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