![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ildr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / support|
Return to ildr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / support |
1.1 root 1: /*
2: * ilwrite() : write driver
3: * 1. copy Lock request info to lockbuf
4: * 2. follow action in l_act
5: * 3. Error return conditions
6: * -1: lockrequest fails(only on act=1)
7: * -2: attempt to release a lock not set
8: * by calling program
9: * -3: illegal action requested
10: */
11:
12: # include <stdio.h>
13: # include <sys/param.h>
14: # include <sys/socket.h>
15: # include <netinet/in.h>
16: # include <sys/ioctl.h>
17: # include <errno.h>
18: # include <ildr.h>
19: # include <sys/time.h>
20: # include <netdb.h>
21: # include <sccs.h>
22:
23: # define TRUE 1
24: # define FALSE 0
25:
26: # ifdef DEBUG
27: static int ildebug = TRUE;
28: # endif DEBUG
29:
30: SCCSID(@(#)ildr.c 8.1 12/31/84)
31:
32: int From_server; /* read connection from socket server */
33: long Read_fmt; /* bit mask for select */
34: char *Prog_name; /* program name for abnormal errors */
35: extern int errno; /* error number */
36:
37: /*
38: ** main
39: ** initilize the socket to the socket server, and then sit and on
40: ** a select waiting for input.
41: */
42: main(ac,av)
43: int ac;
44: char **av;
45: {
46: long read_fd, /* bit mask of useable descriptors*/
47: num_des; /* number of readable descriptors */
48: int abnormal(); /* error function */
49: register int i; /* index */
50:
51:
52: /*
53: ** close all the files descriptors, so we can have more INGRES
54: ** processes. We are lmited by file descriptors.
55: */
56: # ifdef DEBUG
57: setbuf(stdout,NULL);
58: printf("DRIVER: starting up\n");
59: close(0); /* guarantee that 0 is what is attached to the socket server */
60: for ( i = 3 ; i < NOFILE ; i++ )
61: # else
62: for ( i = 0 ; i < NOFILE ; i++ )
63: # endif DEBUG
64: close(i);
65:
66: /*
67: ** set up all the signals. Catching any signal
68: ** is an error. We do a "warm start" in this condition
69: */
70: for ( i = 0 ; i < NSIG ; i++ )
71: signal(i,abnormal);
72: signal(SIGPIPE,SIG_IGN); /* ignore this one, in case a process simply dies in mid stride */
73: Prog_name = *av;
74: /*
75: ** if ac == 2, then we are restarted from the the lock driver
76: ** itself, and we don't have to reattach ourselves to the magic
77: ** ingres socket.
78: */
79: if ( ac == 2 )
80: From_server = 0;
81: else
82: From_server = init_socket();
83: Read_fmt = (1<<From_server);
84:
85: /*
86: ** infinite loop waiting for something to happen
87: */
88: for ( ;; )
89: {
90: read_fd = Read_fmt;
91:
92: /*
93: ** wake up whenever something happens
94: */
95: while ( (num_des = select(NOFILE,&read_fd,0,0,0)) == 0 )
96: {
97: # ifdef DEBUG
98: printf("select returns 0 (%o)\n",read_fd);
99: # endif DEBUG
100: read_fd = Read_fmt;
101: }
102: # ifdef DEBUG
103: printf("select returns %d (%o)\n",num_des,read_fd);
104: # endif DEBUG
105: if ( num_des == -1 )
106: {
107: # ifdef DEBUG
108: perror("DRIVER:num_des = -1");
109: # endif DEBUG
110: /*
111: ** a bit of defensive programming.
112: ** If there is an EBADF (bad file descriptor) error
113: ** then we assume that a file descriptor has shut down,
114: ** with out tellng us. We go to a function to figure
115: ** out what has died.
116: */
117: if ( errno == EBADF )
118: close_up(Read_fmt);
119: sleep(1);
120: continue;
121: }
122: if ( (read_fd & (1<<From_server)) )
123: {
124: num_des--;
125: new_proc();
126: read_fd &= ~(1<<From_server);
127: }
128: if ( num_des > 0 )
129: {
130: for ( i = 0 ; i < NOFILE ; i++ )
131: if ( (read_fd & (1<<i)) )
132: ilwrite(i);
133: }
134: }
135: }/* main */
136:
137: /*
138: ** new_proc
139: ** start up a new connection to an Ingres process
140: */
141: new_proc()
142: {
143: register int fd;
144: auto int to_ioctl = 1;
145: struct sockaddr_in addr;
146: auto int len;
147:
148: len = sizeof (addr);
149: if ( (fd = accept(From_server,&addr,&len)) != -1 )
150: {
151: Read_fmt |= (1<<fd);
152: ioctl(fd,FIONBIO,&to_ioctl);
153: }
154: # ifdef DEBUG
155: else
156: {
157: perror("accept");
158: sleep(1);
159: }
160: printf("DRIVER: new file %d (%o)\n",fd,(1<<fd));
161: # endif DEBUG
162: }/* new_proc */
163:
164:
165:
166: ilwrite(read_desc)
167: register int read_desc;
168: {
169: struct Lockreq lockbuf;
170: register int i;
171: register int blockflag;
172: extern int errno;
173:
174: errno = 0;
175: # ifdef DEBUG
176: printf("DRIVER: entering ilwrite, read_desc = %d\n",read_desc);
177: # endif DEBUG
178: if ( read(read_desc,&lockbuf, sizeof ( lockbuf)) != sizeof ( lockbuf ) )
179: {
180: # ifdef DEBUG
181: printf("Read error, errno = %d\n",errno);
182: # endif DEBUG
183: if ( errno == EWOULDBLOCK )
184: return;
185: if ( errno == ECONNRESET )
186: {
187: ilrma(read_desc,TRUE);
188: close(read_desc);
189: Read_fmt &= ~(1<<read_desc);
190: return;
191: }
192: send_info(read_desc,-5);
193: return;
194: }
195:
196: # ifdef DEBUG
197: if (ildebug)
198: printf("ildr: act %d, type %d, mode %d, read_desc %d\n",
199: lockbuf.lr_act, lockbuf.lr_type, lockbuf.lr_mod, read_desc);
200: # endif DEBUG
201: if (( lockbuf.lr_act < A_RLS1)
202: && ((lockbuf.lr_type < T_CS) || (lockbuf.lr_type > T_DB )
203: || (lockbuf.lr_mod < M_EXCL) || (lockbuf.lr_mod > M_SHARE )))
204: {
205: # ifdef DEBUG
206: printf("Illegal request\n");
207: # endif DEBUG
208: send_info(read_desc,-5);
209: return;
210: }
211: /*
212: * follow action from lock request
213: */
214: switch(lockbuf.lr_act)
215: {
216: case A_RTN:
217: # ifdef DEBUG
218: if ( ildebug )
219: printf("Driver: A_RTN\n");
220: # endif DEBUG
221:
222: /*
223: ** attempt to set lock.
224: ** error return if failure.
225: */
226: for ( i = 0; i <= lockbuf.lr_type; i++)
227: {
228: if (Lockset[i] == 0)
229: {
230: # ifdef DEBUG
231: if (ildebug)
232: printf("ildr: lock %d not available\n", i);
233: # endif DEBUG
234: send_info(read_desc,-1);
235: return;
236: }
237: }
238: if (ilunique(&lockbuf) >= 0)
239: {
240: send_info(read_desc,-1);
241: return;
242: }
243: # ifdef DEBUG
244: if ( ildebug )
245: printf("Driver: lock assigned\n");
246: # endif DEBUG
247: ilenter(&lockbuf,read_desc);
248: break;
249:
250: case A_SLP:
251: # ifdef DEBUG
252: if ( ildebug )
253: printf("Driver: A_SLP\n");
254: # endif DEBUG
255: if ( set_lock(read_desc,lockbuf) == -1 )
256: return;
257: # ifdef DEBUG
258: if ( ildebug )
259: printf("Driver: got lock\n");
260: # endif DEBUG
261: break;
262: case A_RLS1:
263: /* remove 1 lock */
264: # ifdef DEBUG
265: if ( ildebug )
266: printf("Driver: A_RLS1\n");
267: # endif DEBUG
268: if ((i = ilfind(&lockbuf,read_desc)) >= 0)
269: {
270: ilrm(i,read_desc);
271: }
272: else
273: {
274: send_info(read_desc,-2);
275: return;
276: }
277: # ifdef DEBUG
278: if ( ildebug )
279: printf("Driver: released\n");
280: # endif DEBUG
281: break;
282:
283: case A_RLSA:
284: /* remove all locks for this process id*/
285: # ifdef DEBUG
286: if ( ildebug )
287: printf("Driver: A_RLSA\n");
288: # endif DEBUG
289: ilrma(read_desc,FALSE);
290: break;
291:
292: case A_ABT: /* remove all locks */
293: # ifdef DEBUG
294: if ( ildebug )
295: printf("Driver: A_ABT\n");
296: # endif DEBUG
297: ilclose();
298: break;
299:
300: default :
301: # ifdef DEBUG
302: if ( ildebug )
303: printf("DRIVER: garbage\n");
304: # endif DEBUG
305: send_info(read_desc,-3);
306: }
307: send_info(read_desc,0);
308: }
309: /*
310: * ilunique- check for match on key
311: *
312: * return index of Locktab if match found
313: * else return -1
314: */
315: static
316: ilunique(ll)
317: register struct Lockreq *ll;
318: {
319: register int k;
320: register struct Lockform *p;
321: register struct Lockreq *q;
322:
323: for (k = 0; k < NLOCKS; k++)
324: {
325: p = &Locktab[k];
326: if ((p->l_mod != M_EMTY)
327: && (ilcomp(p->l_key,ll->lr_key) == 0)
328: && (p->l_type == ll->lr_type)
329: && ( (p->l_mod == M_EXCL) || (ll->lr_mod == M_EXCL)) ) {
330: # ifdef DEBUG
331: if (ildebug) {
332: register int i;
333:
334: printf("ildr: lock ");
335: for (i = 0; i < KEYSIZE; i++)
336: printf("%c", ll->lr_key[i]);
337: printf(" busy\n");
338: }
339: # endif DEBUG
340: return(k);
341: }
342: }
343: return(-1);
344: }
345:
346: static
347: ilfind(ll,key)
348: register struct Lockreq *ll;
349: int key;
350: {
351: register int k;
352: register struct Lockform *p;
353: register struct Lockreq *q;
354:
355: for (k = 0; k < NLOCKS; k++)
356: {
357: p = &Locktab[k];
358: if ((p->l_mod != M_EMTY)
359: && (ilcomp(p->l_key,ll->lr_key) == 0)
360: && (p->l_type == ll->lr_type)
361: && (p->l_pid == key))
362: return(k);
363: }
364: return(-1);
365: }/* ilfind */
366:
367: /*
368: * remove the lth Lock
369: * if the correct user is requesting the move.
370: */
371: static
372: ilrm(l,key,remove_all)
373: int l;
374: int key;
375: int remove_all;
376: {
377: register struct Lockform *a;
378: register k;
379:
380:
381: a = &Locktab[l];
382: if (a->l_pid == key && a->l_mod != M_EMTY)
383: {
384: if ( !remove_all && a->l_type == T_DB )
385: return;
386: a->l_mod = M_EMTY;
387: a->l_pid = 0;
388: if (a->l_wflag == W_ON)
389: {
390: a->l_wflag = W_OFF;
391: wakeup(&Locktab[l]);
392: }
393: for (k = 0; k <= a->l_type; k++)
394: {
395: Lockset[k]++;
396: if (Lockset[k] == 1)
397: wakeup(&Lockset[k]);
398: }
399: }
400: }/* ilrm */
401:
402: /*
403: * ilrma releases all locks for a given process id(pd)
404: * -- called from sys1.c$exit() code.
405: */
406: ilrma(key,remove_all)
407: int key;
408: int remove_all;
409: {
410: register int i;
411:
412: # ifdef DEBUG
413: printf("DRVIER: Removing all, key = %d\n",key);
414: # endif DEBUG
415: for ( i = 0; i < NLOCKS; i++ )
416: ilrm(i,key,remove_all);
417: }
418:
419: /*
420: * enter Lockbuf in locktable
421: * return position in Locktable
422: * error return of -1
423: */
424: static
425: ilenter(ll,key)
426: register struct Lockreq *ll;
427: int key;
428: {
429: int k,l;
430: register char *f,*t;
431: register struct Lockform *p;
432:
433: for (k = 0; k < NLOCKS; k++)
434: {
435: p = &Locktab[k];
436: if (p->l_mod == M_EMTY)
437: {
438: p->l_pid = key;
439: p->l_type = ll->lr_type;
440: Locktab[k].l_mod = p->l_mod = ll->lr_mod;
441: f = ll->lr_key;
442: t = p->l_key;
443: for (l = 0; l < KEYSIZE; l++)
444: *t++ = *f++;
445: for (l = 0; l <= ll->lr_type; l++)
446: Lockset[l]--;
447: # ifdef DEBUG
448: if ( ildebug )
449: printf("DRIVER: ilenter %d, mod %d, omod = %d\n",k,p->l_mod,Locktab[k].l_mod);
450: # endif DEBUG
451: return(k);
452: }
453: }
454: # ifdef DEBUG
455: if ( ildebug )
456: printf("DRIVER: ilenter -1\n");
457: # endif DEBUG
458: return (-1);
459: }
460:
461: /*
462: * ilcomp- string compare
463: * returns 0 if strings match
464: * returns -1 otherwise
465: */
466: static
467: ilcomp(s1,s2)
468: register char *s1,*s2;
469: {
470: register int k;
471:
472: for (k = 0; k < KEYSIZE; k++)
473: if ( *s1++ != *s2++)
474: # ifdef DEBUG
475: {
476: if ( ildebug )
477: printf("DRIVER: ilcomp returning -1\n");
478: return ( -1 );
479: }
480: # else DEBUG
481: return (-1);
482: # endif DEBUG
483: return (0);
484: }
485:
486: /*
487: * ilclose- releases all locks
488: */
489: static
490: ilclose()
491: {
492: register int k;
493: register caddr_t c;
494: # ifdef DEBUG
495: printf("DRIVER: entered close\n");
496: # endif DEBUG
497:
498: for (k = 0; k < NLOCKS; k++)
499: wakeup( &Locktab[k] );
500: for (k = 0; k < 4; k++)
501: wakeup( &Lockset[k]);
502: for (c = (caddr_t)&Locktab[0].l_pid; c < (caddr_t)&Locktab[NLOCKS];)
503: *c++ = 0;
504: Lockset[0] = NLOCKS;
505: Lockset[1] = PLOCKS;
506: Lockset[2] = RLOCKS;
507: Lockset[3] = DLOCKS;
508: }/* ilclose */
509:
510: /*
511: ** set_lock
512: ** attempt to set a lock. If we can't, block the process and
513: ** return -1, if we can than set the lock and return 0.
514: */
515: set_lock(read_desc,lockbuf)
516: register int read_desc;
517: struct Lockreq lockbuf;
518: {
519: register int blockflag;
520: register int i;
521:
522: /*
523: ** attempt to set lock.
524: ** sleep on blocking address if failure.
525: */
526:
527: do
528: {
529: do
530: {
531: blockflag = TRUE;
532: for ( i = 0; i <= lockbuf.lr_type; i++)
533: if (Lockset[i] == 0)
534: {
535: # ifdef DEBUG
536: if (ildebug)
537: printf("ildr: lock %d not available\n", i);
538: # endif DEBUG
539: wait_on(read_desc,&Lockset[i],lockbuf);
540: return(-1);
541: }
542: } while (!blockflag);
543:
544: if (( i = ilunique(&lockbuf)) >= 0 )
545: {
546: blockflag = FALSE;
547: Locktab[i].l_wflag = W_ON;
548: wait_on(read_desc,&Locktab[i],lockbuf);
549: return(-1);
550: }
551: } while (!blockflag);
552: ilenter(&lockbuf,read_desc);
553: return ( 0 );
554: }/* set_lock */
555:
556: /*
557: ** send_info
558: ** Send the data down the socket. Don't do it if it would cause the driver
559: ** to block.
560: */
561: send_info(fd,data)
562: register int fd;
563: int data;
564: {
565: auto int wdes = ( 1<<fd );
566: struct timeval time;
567:
568: errno = 0;
569: time.tv_sec = 10;
570: time.tv_usec = 0;
571:
572: if ( select(NOFILE,0,&wdes,0,&time) != 1 )
573: {
574: Read_fmt &= ~(1<<fd);
575: ilrma(fd,TRUE);
576: close(fd);
577: }
578: else
579: if ( write(fd,&data,sizeof (int)) != sizeof (int) )
580: {
581: if ( errno == 0 )
582: return;
583: Read_fmt &= ~(1<<fd);
584: ilrma(fd,TRUE);
585: close(fd);
586: }
587: }/* send_info */
588:
589: struct Wait {
590: int wait_fd; /* file descriptor to send lock info to off of */
591: int wait_lock; /* what lock we are waiting for */
592: struct Lockreq wait_req; /* the lock request */
593: struct Wait *next;
594: };
595: struct Wait *Wait_queue = NULL;
596:
597: /*
598: ** wait_on
599: ** Set up to wait for a free lock.
600: */
601: wait_on(fd,lock,req)
602: register int fd, lock;
603: struct Lockreq req;
604: {
605: register struct Wait *ptr;
606: char *calloc();
607:
608: ptr = (struct Wait *)calloc(1,sizeof (struct Wait));
609: ptr->wait_fd = fd;
610: ptr->wait_lock = lock;
611: ptr->wait_req = req;
612: ptr->next = Wait_queue;
613: Wait_queue = ptr;
614: }/* wait_on */
615:
616: /*
617: ** wakeup
618: ** See if there is anythng waiting on the newly freed lock. If there is,
619: ** tell it it can have the lock now.
620: */
621: wakeup(lock)
622: register int lock;
623: {
624: register struct Wait *ptr,*back;
625:
626: for ( back = NULL, ptr = Wait_queue ; ptr != NULL ; back = ptr, ptr = ptr->next )
627: {
628: if ( ptr->wait_lock == lock )
629: {
630: if ( set_lock(ptr->wait_fd,ptr->wait_req) == 0 )
631: {
632: send_info(ptr->wait_fd,0);
633: if ( back != NULL )
634: back->next = ptr->next;
635: else
636: Wait_queue = Wait_queue->next;
637: cfree(ptr);
638: return;
639: }
640: }
641: }
642: }/* wakeup */
643:
644: /*
645: ** abnormal
646: ** a signal has come down and hit us. We restart the entire
647: ** program, and hope it goes away
648: */
649: abnormal(sig)
650: int sig;
651: {
652: extern int errno;
653:
654: # ifdef DEBUG
655: printf("DRIVER: error %d, restarting\n",sig);
656: # endif
657:
658: execl("/etc/lock_driver","lock_driver","restart",0);
659: execl(Prog_name,Prog_name,"restart",0);
660: execlp("lock_driver","lock_driver","restart",0);
661: exit(4);
662: }/* abnormal */
663:
664: /*
665: ** close_up
666: ** try and find a closed up file descriptor.
667: */
668: close_up(fmt)
669: long fmt;
670: {
671: long rdesc;
672: register int i;
673: struct timeval time;
674:
675: errno = 0;
676: time.tv_sec = 0;
677: time.tv_usec = 0;
678:
679: for ( i = 0 ; i < NOFILE ; i++ )
680: {
681: if ( (1<<i) & fmt )
682: {
683: rdesc = (1<<i);
684: if ( select(NOFILE,&rdesc,0,0,&time) == -1 )
685: {
686: /*
687: ** the server socket has closed down.
688: ** BOY ARE WE IN TROUBLE
689: */
690: if ( i == From_server )
691: {
692: sleep(1);
693: # ifdef DEBUG
694: printf("Restarting socket\n");
695: # endif DEBUG
696: init_socket();
697: }
698: if ( errno == EBADF )
699: {
700: shutdown(i,2);
701: close(i);
702: Read_fmt &= ~(1<<i);
703: ilrma(i,TRUE);
704: }
705: }
706: }
707: }
708: }/* close_up */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.