ING_DB
This commit is contained in:
Oliver Lehmann
parent
2199bf4643
commit
54917b53af
|
|
@ -0,0 +1,628 @@
|
|||
/************************************************************************/
|
||||
/* */
|
||||
/* DBS LOCK DEVICE SERVER */
|
||||
/* ************************** */
|
||||
/* Release 6/3.3 20/03/89 */
|
||||
/* */
|
||||
/************************************************************************/
|
||||
|
||||
# include <stdio.h>
|
||||
# include <signal.h>
|
||||
# include "../conf/gen.h"
|
||||
# include "../h/dbs.h"
|
||||
# include "../h/access.h"
|
||||
# include "../h/lock.h"
|
||||
# include "../h/bs.h"
|
||||
|
||||
# ifndef major
|
||||
# define major(x) ((short) (((unsigned) (x) >> 8)))
|
||||
# define minor(x) ((short) ((x) & 0377))
|
||||
# endif
|
||||
|
||||
# define OBJS (30 * LOCKS)
|
||||
# define REQS (40 * LOCKS)
|
||||
# define KSIZE 12
|
||||
|
||||
# define OK 0
|
||||
# define ERROR 1
|
||||
# define OBJ_OVFLO 2
|
||||
# define PROC_OVFLO 3
|
||||
# define REQ_OVFLO 4
|
||||
# define OPEN_ERROR 5
|
||||
# define RD_ERROR 6
|
||||
# define WR_ERROR 7
|
||||
# define FORK_ERROR 8
|
||||
|
||||
# define CANT_LOCK -1
|
||||
# define LOCK_NOT_SET -2
|
||||
# define ILL_REQUEST -3
|
||||
# define DRIVER_LOCKED -4
|
||||
|
||||
# define PROC_FREE 0
|
||||
# define REQ_FREE ((struct object *) 0)
|
||||
|
||||
# define NO_PROC ((struct process *) 0)
|
||||
# define NO_REQ ((struct request *) 0)
|
||||
# define NO_OBJ ((struct object *) 0)
|
||||
|
||||
struct object
|
||||
{
|
||||
long o_db; /* | KEY | inode of data base */
|
||||
long o_rel; /* | FOR | relation tid */
|
||||
long o_page; /* | LOCK | page address */
|
||||
char o_reqs; /* request reference count */
|
||||
/* free space if zero */
|
||||
char o_locks; /* lock reference count */
|
||||
char o_tas; /* TA reference count */
|
||||
char o_mode; /* mode of lock */
|
||||
};
|
||||
|
||||
struct process
|
||||
{
|
||||
struct request *p_lock; /* pointer to lock queue */
|
||||
struct request *p_req; /* pointer to request queue */
|
||||
struct process *p_wait; /* pointer to wait queue */
|
||||
short p_pid; /* requesting process id */
|
||||
/* free space if zero */
|
||||
};
|
||||
|
||||
struct request
|
||||
{
|
||||
struct request *r_next; /* next request in queue */
|
||||
struct object *r_obj; /* pointer to requested object */
|
||||
/* free space if zero */
|
||||
short r_mode; /* mode of lock */
|
||||
};
|
||||
|
||||
LOCKREQ AALOCKREQ = { 0 } ;
|
||||
int AAlockdes = -1 ;
|
||||
struct object *Object = 0 ;
|
||||
struct process *Process = 0 ;
|
||||
struct process *Wait = 0 ;
|
||||
struct object Obj[OBJS + 1] = { 0 } ;
|
||||
struct request Req[REQS + 1] = { 0 } ;
|
||||
struct process Proc[LOCKS] = { 0 } ;
|
||||
char SERVER[] = "DB.SERVER: ";
|
||||
|
||||
|
||||
catch_signal(sig)
|
||||
register int sig;
|
||||
{
|
||||
signal(sig, (int (*)()) 1);
|
||||
fflush(stdout);
|
||||
signal(sig, catch_signal);
|
||||
}
|
||||
|
||||
main(argc, argv)
|
||||
int argc;
|
||||
char *argv[];
|
||||
{
|
||||
register int i;
|
||||
register LOCKREQ *lb;
|
||||
register struct process *p;
|
||||
char stdbuf[BUFSIZ];
|
||||
extern int errno;
|
||||
extern int (*signal())();
|
||||
|
||||
# ifdef xSTR1
|
||||
AAtTrace(&argc, argv, 'X');
|
||||
# endif
|
||||
|
||||
if (argc > 1)
|
||||
pr_startup();
|
||||
|
||||
errno = 0;
|
||||
if ((i = fork()) < 0)
|
||||
{
|
||||
printf("\n%sFORK ERROR(%d)", SERVER, errno);
|
||||
term(FORK_ERROR);
|
||||
}
|
||||
else if (i) /* PARENT */
|
||||
term(OK);
|
||||
|
||||
/*********************/
|
||||
/*** ***/
|
||||
/*** +---------+ ***/
|
||||
/*** | CHILD | ***/
|
||||
/*** +---------+ ***/
|
||||
/*** ***/
|
||||
/*** lock(1) ***/
|
||||
/*** ***/
|
||||
/*********************/
|
||||
|
||||
# ifdef SETBUF
|
||||
setbuf(stdout, stdbuf);
|
||||
# endif
|
||||
|
||||
/* user signal catch */
|
||||
for (i = SIGHUP; i <= SIGTERM; i++)
|
||||
signal(i, catch_signal);
|
||||
|
||||
for (i = MAXFILES - 1; i; --i)
|
||||
if (i != 1)
|
||||
close(i);
|
||||
|
||||
/* open AA_DBS_LOCK */
|
||||
errno = 0;
|
||||
if ((AAlockdes = open(AA_DBS_LOCK, 2)) < 0)
|
||||
{
|
||||
printf("\n%sOPEN %s: ERROR(%d)\n", SERVER, AA_DBS_LOCK, errno);
|
||||
term(OPEN_ERROR);
|
||||
}
|
||||
|
||||
lb = &AALOCKREQ;
|
||||
for ( ; ; )
|
||||
{
|
||||
# ifdef xSTR1
|
||||
if (AAtTf(10, 0))
|
||||
pr_locks();
|
||||
AAtTfp(12, 0, "\n%s", SERVER);
|
||||
# endif
|
||||
|
||||
if ((i = read(AAlockdes, lb, DBS_RSIZE)) != DBS_RSIZE)
|
||||
{
|
||||
if (i < 0 && errno == DRIVER_LOCKED)
|
||||
term(OK);
|
||||
printf("\n%sREAD ERROR(%d) got %d\n", SERVER, errno, i);
|
||||
term(RD_ERROR);
|
||||
}
|
||||
|
||||
if ((i = lb->l_act) == A_INFO)
|
||||
{
|
||||
pr_locks();
|
||||
continue;
|
||||
}
|
||||
|
||||
find_process();
|
||||
|
||||
# ifdef xSTR1
|
||||
if (AAtTfp(11, 0, " A%d M%02o ", i, lb->l_mode))
|
||||
{
|
||||
if (i >= A_RLSA)
|
||||
putchar('\n');
|
||||
else
|
||||
pr_object(&AALOCKREQ);
|
||||
}
|
||||
# endif
|
||||
|
||||
if (i == A_RLSA)
|
||||
{
|
||||
lb->l_db = lb->l_rel = lb->l_page = 0L;
|
||||
rm_all_locks();
|
||||
}
|
||||
else if (i == A_RLS1)
|
||||
response(rm_one_lock());
|
||||
else
|
||||
enter_lock();
|
||||
if (!(p = Process)->p_lock && !p->p_req)
|
||||
p->p_pid = PROC_FREE;
|
||||
relock();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
find_process()
|
||||
{
|
||||
register struct process *p;
|
||||
register short pid;
|
||||
|
||||
for (pid = AALOCKREQ.l_pid, p = &Proc[LOCKS - 1]; p >= Proc; --p)
|
||||
if (p->p_pid == pid)
|
||||
goto proc_found;
|
||||
for (p = &Proc[LOCKS - 1]; p >= Proc; --p)
|
||||
if (!p->p_pid)
|
||||
{
|
||||
p->p_lock = p->p_req = NO_REQ;
|
||||
p->p_wait = NO_PROC;
|
||||
p->p_pid = pid;
|
||||
proc_found:
|
||||
Process = p;
|
||||
# ifdef xSTR1
|
||||
AAtTfp(23, 0, "PID %5u", p->p_pid);
|
||||
# endif
|
||||
return;
|
||||
}
|
||||
term(PROC_OVFLO);
|
||||
}
|
||||
|
||||
|
||||
rm_all_locks()
|
||||
{
|
||||
register struct request *r;
|
||||
register struct process *p;
|
||||
|
||||
for (r = (p = Process)->p_lock; r; r = r->r_next)
|
||||
{
|
||||
if (!(--(r->r_obj->o_locks)))
|
||||
r->r_obj->o_mode = 0;
|
||||
--(r->r_obj->o_reqs);
|
||||
r->r_obj = REQ_FREE;
|
||||
}
|
||||
for (r = p->p_req; r; r = r->r_next)
|
||||
{
|
||||
--(r->r_obj->o_reqs);
|
||||
if (r->r_mode & M_TA)
|
||||
--(r->r_obj->o_tas);
|
||||
r->r_obj = REQ_FREE;
|
||||
}
|
||||
p->p_pid = PROC_FREE;
|
||||
}
|
||||
|
||||
|
||||
rm_one_lock()
|
||||
{
|
||||
register struct request **rr;
|
||||
register struct request *r;
|
||||
register LOCKREQ *lb;
|
||||
|
||||
lb = &AALOCKREQ;
|
||||
for (rr = &(Process->p_lock); r = *rr; rr = &r->r_next)
|
||||
if (AAbequal(lb, r->r_obj, KSIZE))
|
||||
{
|
||||
if (!(--(r->r_obj->o_locks)))
|
||||
r->r_obj->o_mode = 0;
|
||||
--(r->r_obj->o_reqs);
|
||||
r->r_obj = REQ_FREE;
|
||||
*rr = r->r_next;
|
||||
return (OK);
|
||||
}
|
||||
return (ERROR);
|
||||
}
|
||||
|
||||
|
||||
enter_lock()
|
||||
{
|
||||
register struct process *p;
|
||||
register LOCKREQ *lb;
|
||||
register struct object *o;
|
||||
extern struct object *find_object();
|
||||
extern struct request *enter_request();
|
||||
|
||||
if ((lb = &AALOCKREQ)->l_mode & M_TA)
|
||||
enter_ta(1);
|
||||
else if (check_lock(find_object(), lb->l_mode))
|
||||
{
|
||||
p = Process;
|
||||
p->p_lock = enter_request(p->p_lock);
|
||||
if (!(((o = Object)->o_locks)++))
|
||||
o->o_mode = lb->l_mode & M_MODE;
|
||||
response(OK);
|
||||
}
|
||||
else if (lb->l_act == A_RTN)
|
||||
response(ERROR);
|
||||
else
|
||||
{
|
||||
lb->l_mode |= M_TE;
|
||||
enter_ta(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
relock()
|
||||
{
|
||||
register struct process *w;
|
||||
register struct request *r;
|
||||
register int i;
|
||||
register struct process *lw;
|
||||
register struct request *lr;
|
||||
|
||||
restart:
|
||||
for (lw = w = Wait; w; )
|
||||
{
|
||||
i = 0;
|
||||
for (r = w->p_req; r; r = r->r_next)
|
||||
if (!(i = check_lock(r->r_obj, r->r_mode)))
|
||||
break;
|
||||
if (i)
|
||||
{
|
||||
lr = w->p_lock;
|
||||
for (w->p_lock = r = w->p_req; ; r = r->r_next)
|
||||
{
|
||||
if (r->r_mode & M_TA)
|
||||
{
|
||||
r->r_mode &= ~M_TA;
|
||||
--(r->r_obj->o_tas);
|
||||
}
|
||||
if (!((r->r_obj->o_locks)++))
|
||||
r->r_obj->o_mode = r->r_mode & M_MODE;
|
||||
if (!r->r_next)
|
||||
{
|
||||
r->r_next = lr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
w->p_req = NO_REQ;
|
||||
AALOCKREQ.l_pid = w->p_pid;
|
||||
response(OK);
|
||||
if (w == lw)
|
||||
{
|
||||
Wait = w->p_wait;
|
||||
w->p_wait = NO_PROC;
|
||||
goto restart;
|
||||
}
|
||||
else
|
||||
{
|
||||
lw->p_wait = w->p_wait;
|
||||
w->p_wait = NO_PROC;
|
||||
w = lw->p_wait;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
lw = w;
|
||||
w = w->p_wait;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
check_lock(o, s)
|
||||
register struct object *o;
|
||||
register int s;
|
||||
{
|
||||
return (!o || !o->o_locks || ((o->o_mode & M_SHARE) && (s & M_SHARE)));
|
||||
}
|
||||
|
||||
|
||||
enter_ta(find)
|
||||
int find;
|
||||
{
|
||||
register struct request **rr;
|
||||
register struct request *r;
|
||||
register struct process *w;
|
||||
long rel_tid;
|
||||
extern struct object *find_object();
|
||||
extern struct request *enter_request();
|
||||
|
||||
if (find)
|
||||
find_object();
|
||||
rel_tid = AALOCKREQ.l_rel;
|
||||
rr = &Process->p_req;
|
||||
while (r = *rr)
|
||||
{
|
||||
if (r->r_obj->o_rel > rel_tid)
|
||||
break;
|
||||
rr = &r->r_next;
|
||||
}
|
||||
*rr = enter_request(r);
|
||||
if (AALOCKREQ.l_mode & M_TA)
|
||||
(*rr)->r_obj->o_tas++;
|
||||
if (AALOCKREQ.l_mode & M_TE)
|
||||
{
|
||||
if (!(w = Wait))
|
||||
Wait = Process;
|
||||
else
|
||||
{
|
||||
while (w->p_wait)
|
||||
w = w->p_wait;
|
||||
w->p_wait = Process;
|
||||
}
|
||||
}
|
||||
else
|
||||
response(OK);
|
||||
}
|
||||
|
||||
|
||||
struct object *find_object()
|
||||
{
|
||||
register struct object *o;
|
||||
register LOCKREQ *lb;
|
||||
|
||||
lb = &AALOCKREQ;
|
||||
for (o = &Obj[OBJS]; o >= Obj; --o)
|
||||
if (o->o_reqs && AAbequal(lb, o, KSIZE))
|
||||
return (Object = o);
|
||||
return (Object = NO_OBJ);
|
||||
}
|
||||
|
||||
|
||||
enter_object()
|
||||
{
|
||||
register struct object *o;
|
||||
|
||||
if (o = Object)
|
||||
{
|
||||
(o->o_reqs)++;
|
||||
goto entered;
|
||||
}
|
||||
for (o = &Obj[OBJS]; o >= Obj; --o)
|
||||
if (!o->o_reqs)
|
||||
{
|
||||
AAbmove(&AALOCKREQ, o, KSIZE);
|
||||
o->o_reqs = 1;
|
||||
o->o_locks = o->o_tas = o->o_mode = 0;
|
||||
Object = o;
|
||||
entered:
|
||||
return;
|
||||
}
|
||||
term(OBJ_OVFLO);
|
||||
}
|
||||
|
||||
|
||||
struct request *enter_request(next)
|
||||
register struct request *next;
|
||||
{
|
||||
register struct request *r;
|
||||
|
||||
enter_object();
|
||||
for (r = &Req[REQS]; r >= Req; --r)
|
||||
if (!r->r_obj)
|
||||
{
|
||||
r->r_next = next;
|
||||
r->r_obj = Object;
|
||||
r->r_mode = AALOCKREQ.l_mode;
|
||||
return (r);
|
||||
}
|
||||
term(REQ_OVFLO);
|
||||
}
|
||||
|
||||
|
||||
response(error)
|
||||
register int error;
|
||||
{
|
||||
register int i;
|
||||
register LOCKRES *lr;
|
||||
LOCKRES res_buf;
|
||||
extern int errno;
|
||||
|
||||
if (error < 0)
|
||||
return;
|
||||
(lr = &res_buf)->s_pid = AALOCKREQ.l_pid;
|
||||
lr->s_error = error;
|
||||
|
||||
# ifdef xSTR1
|
||||
AAtTfp(9, 0, "%s%s %5u\n", SERVER, error? "ERR": "RUN", lr->s_pid);
|
||||
# endif
|
||||
|
||||
if ((i = write(AAlockdes, lr, DBS_SSIZE)) != DBS_SSIZE)
|
||||
{
|
||||
printf("\n%sWRITE ERROR(%d) got %d\n", SERVER, errno, i);
|
||||
term(WR_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
term(code)
|
||||
register int code;
|
||||
{
|
||||
close(AAlockdes);
|
||||
fflush(stdout);
|
||||
exit(code);
|
||||
}
|
||||
|
||||
pr_locks()
|
||||
{
|
||||
register struct object *o;
|
||||
register LOCKREQ *lb;
|
||||
|
||||
pr_process();
|
||||
lb = &AALOCKREQ;
|
||||
for (o = &Obj[OBJS]; o >= Obj; --o)
|
||||
if (o->o_reqs && (!lb->l_db || o->o_db == lb->l_db))
|
||||
{
|
||||
printf("L%5u | %2dRQ %2dLK %2dTA ",
|
||||
o - Obj, o->o_reqs, o->o_locks, o->o_tas);
|
||||
pr_mode(o->o_mode);
|
||||
pr_object(o);
|
||||
}
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
pr_process()
|
||||
{
|
||||
register struct process *p;
|
||||
register struct request *r;
|
||||
register LOCKREQ *lb;
|
||||
|
||||
lb = &AALOCKREQ;
|
||||
if (p = Wait)
|
||||
{
|
||||
printf("%sWAITQUEUE", SERVER);
|
||||
for ( ; p; p = p->p_wait)
|
||||
printf("-->%5u", p->p_pid);
|
||||
putchar('\n');
|
||||
}
|
||||
for (p = &Proc[LOCKS - 1]; p >= Proc; --p)
|
||||
{
|
||||
if (p->p_pid)
|
||||
{
|
||||
printf("P%5u:", p->p_pid);
|
||||
for (r = p->p_lock; r; r = r->r_next)
|
||||
{
|
||||
if (lb->l_db && r->r_obj->o_db != lb->l_db)
|
||||
continue;
|
||||
printf("\tL%4u", r->r_obj - Obj);
|
||||
}
|
||||
for (r = p->p_req; r; r = r->r_next)
|
||||
{
|
||||
if (lb->l_db && r->r_obj->o_db != lb->l_db)
|
||||
continue;
|
||||
printf("\tR%4u", r->r_obj - Obj);
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
}
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
pr_object(o)
|
||||
register struct object *o;
|
||||
{
|
||||
register struct stat *s;
|
||||
|
||||
s = (struct stat *) &o->o_db;
|
||||
printf(" |%5d", major(s->st_dev));
|
||||
printf(" |%5d", minor(s->st_dev));
|
||||
printf(" |%6d | ", s->st_ino);
|
||||
pr_tid(&o->o_rel);
|
||||
printf(" |");
|
||||
if (o->o_page == REL_LOCK)
|
||||
printf(" REL");
|
||||
else if (o->o_page == USE_LOCK)
|
||||
printf(" USE");
|
||||
else if (o->o_page == CS_LOCK)
|
||||
printf(" CS");
|
||||
else
|
||||
printf("%6ld", o->o_page);
|
||||
putchar('\n');
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
pr_tid(tid)
|
||||
register struct tup_id *tid;
|
||||
{
|
||||
register int lineid;
|
||||
long pageid;
|
||||
|
||||
AApluck_page(tid, &pageid);
|
||||
if (pageid == 0xffffff)
|
||||
pageid = -1L;
|
||||
if ((lineid = ctou(tid->line_id)) == SCANTID)
|
||||
lineid = -1;
|
||||
printf("%3ld/%3d", pageid, lineid);
|
||||
}
|
||||
|
||||
AApluck_page(tid, var)
|
||||
register struct tup_id *tid;
|
||||
register struct lpage *var;
|
||||
{
|
||||
var->lpg0 = tid->pg0;
|
||||
var->lpg1 = tid->pg1;
|
||||
var->lpg2 = tid->pg2;
|
||||
var->lpgx = 0;
|
||||
}
|
||||
|
||||
pr_mode(mode)
|
||||
register int mode;
|
||||
{
|
||||
if (mode & M_REL)
|
||||
putchar('R');
|
||||
else if (mode & M_TA)
|
||||
putchar('A');
|
||||
else if (mode & M_TE)
|
||||
putchar('E');
|
||||
else
|
||||
putchar(' ');
|
||||
|
||||
if (mode & M_EXCL)
|
||||
putchar('E');
|
||||
else if (mode & M_SHARE)
|
||||
putchar('S');
|
||||
else
|
||||
putchar(' ');
|
||||
}
|
||||
|
||||
pr_startup()
|
||||
{
|
||||
printf("\n%sWAITQUEUE-->pid-->pid...\n", SERVER);
|
||||
printf("Ppid: {Llock} {Rlock}\n");
|
||||
printf("Llock | nRQ nLK nTA mode | major | minor | inode | rel_tid | page\n");
|
||||
printf("\npid\tProzessnummer\n");
|
||||
printf("mode\tR-relation A-TA E-TE E-exclusive S-shared\n");
|
||||
printf("Llock\tbelegter Lock\n");
|
||||
printf("Rlock\tangeforderter Lock\n");
|
||||
printf("nRQ\tAnzahl der Verweise auf diesen Lock\n");
|
||||
printf("nLK\tAnzahl der Prozesse, die diesen Lock belegen\n");
|
||||
printf("nTA\tAnzahl der Transaktionen, die diesen Lock anfordern\n\n");
|
||||
fflush(stdout);
|
||||
}
|
||||
Loading…
Reference in New Issue