bozo: bosserver -pidfiles option
[openafs.git] / src / bozo / bnode.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <afs/procmgmt.h>
14 #include <roken.h>
15
16 #include <stddef.h>
17
18 #include <lwp.h>
19 #include <rx/rx.h>
20 #include <afs/audit.h>
21 #include <afs/afsutil.h>
22 #include <afs/fileutil.h>
23
24 #include "bnode.h"
25 #include "bosprototypes.h"
26
27 #ifndef WCOREDUMP
28 #define WCOREDUMP(x) ((x) & 0200)
29 #endif
30
31 #define BNODE_LWP_STACKSIZE     (16 * 1024)
32
33 int bnode_waiting = 0;
34 static PROCESS bproc_pid;       /* pid of waker-upper */
35 static struct bnode *allBnodes = 0;     /* list of all bnodes */
36 static struct bnode_proc *allProcs = 0; /* list of all processes for which we're waiting */
37 static struct bnode_type *allTypes = 0; /* list of registered type handlers */
38
39 static struct bnode_stats {
40     int weirdPids;
41 } bnode_stats;
42
43 extern const char *DoCore;
44 extern const char *DoPidFiles;
45 #ifndef AFS_NT40_ENV
46 extern char **environ;          /* env structure */
47 #endif
48
49 int hdl_notifier(struct bnode_proc *tp);
50
51 /* Remember the name of the process, if any, that failed last */
52 static void
53 RememberProcName(struct bnode_proc *ap)
54 {
55     struct bnode *tbnodep;
56
57     tbnodep = ap->bnode;
58     if (tbnodep->lastErrorName) {
59         free(tbnodep->lastErrorName);
60         tbnodep->lastErrorName = NULL;
61     }
62     if (ap->coreName) {
63         tbnodep->lastErrorName = (char *)malloc(strlen(ap->coreName) + 1);
64         strcpy(tbnodep->lastErrorName, ap->coreName);
65     }
66 }
67
68 /* utility for use by BOP_HASCORE functions to determine where a core file might
69  * be stored.
70  */
71 int
72 bnode_CoreName(struct bnode *abnode, char *acoreName, char *abuffer)
73 {
74     if (DoCore) {
75         strcpy(abuffer, DoCore);
76         strcat(abuffer, "/");
77         strcat(abuffer, AFSDIR_CORE_FILE);
78     } else
79         strcpy(abuffer, AFSDIR_SERVER_CORELOG_FILEPATH);
80     if (acoreName) {
81         strcat(abuffer, acoreName);
82         strcat(abuffer, ".");
83     }
84     strcat(abuffer, abnode->name);
85     return 0;
86 }
87
88 /* save core file, if any */
89 static void
90 SaveCore(struct bnode *abnode, struct bnode_proc
91          *aproc)
92 {
93     char tbuffer[256];
94     struct stat tstat;
95     afs_int32 code = 0;
96     char *corefile = NULL;
97 #ifdef BOZO_SAVE_CORES
98     struct timeval Start;
99     struct tm *TimeFields;
100     char FileName[256];
101 #endif
102
103     /* Linux always appends the PID to core dumps from threaded processes, so
104      * we have to scan the directory to find core files under another name. */
105     if (DoCore) {
106         strcpy(tbuffer, DoCore);
107         strcat(tbuffer, "/");
108         strcat(tbuffer, AFSDIR_CORE_FILE);
109     } else
110         code = stat(AFSDIR_SERVER_CORELOG_FILEPATH, &tstat);
111     if (code) {
112         DIR *logdir;
113         struct dirent *file;
114         size_t length;
115         unsigned long pid;
116         const char *coredir = AFSDIR_LOGS_DIR;
117
118         if (DoCore)
119           coredir = DoCore;
120
121         logdir = opendir(coredir);
122         if (logdir == NULL)
123             return;
124         while ((file = readdir(logdir)) != NULL) {
125             if (strncmp(file->d_name, "core.", 5) != 0)
126                 continue;
127             pid = atol(file->d_name + 5);
128             if (pid == aproc->pid) {
129                 length = strlen(coredir) + strlen(file->d_name) + 2;
130                 corefile = malloc(length);
131                 if (corefile == NULL) {
132                     closedir(logdir);
133                     return;
134                 }
135                 snprintf(corefile, length, "%s/%s", coredir, file->d_name);
136                 code = 0;
137                 break;
138             }
139         }
140         closedir(logdir);
141     } else {
142         corefile = strdup(tbuffer);
143     }
144     if (code)
145         return;
146
147     bnode_CoreName(abnode, aproc->coreName, tbuffer);
148 #ifdef BOZO_SAVE_CORES
149     FT_GetTimeOfDay(&Start, 0);
150     TimeFields = localtime(&Start.tv_sec);
151     sprintf(FileName, "%s.%d%02d%02d%02d%02d%02d", tbuffer,
152             TimeFields->tm_year + 1900, TimeFields->tm_mon + 1, TimeFields->tm_mday,
153             TimeFields->tm_hour, TimeFields->tm_min, TimeFields->tm_sec);
154     strcpy(tbuffer, FileName);
155 #endif
156     code = renamefile(corefile, tbuffer);
157     free(corefile);
158 }
159
160 int
161 bnode_GetString(struct bnode *abnode, char *abuffer,
162                 afs_int32 alen)
163 {
164     return BOP_GETSTRING(abnode, abuffer, alen);
165 }
166
167 int
168 bnode_GetParm(struct bnode *abnode, afs_int32 aindex,
169               char *abuffer, afs_int32 alen)
170 {
171     return BOP_GETPARM(abnode, aindex, abuffer, alen);
172 }
173
174 int
175 bnode_GetStat(struct bnode *abnode, afs_int32 * astatus)
176 {
177     return BOP_GETSTAT(abnode, astatus);
178 }
179
180 int
181 bnode_RestartP(struct bnode *abnode)
182 {
183     return BOP_RESTARTP(abnode);
184 }
185
186 static int
187 bnode_Check(struct bnode *abnode)
188 {
189     if (abnode->flags & BNODE_WAIT) {
190         abnode->flags &= ~BNODE_WAIT;
191         LWP_NoYieldSignal(abnode);
192     }
193     return 0;
194 }
195
196 /* tell if an instance has a core file */
197 int
198 bnode_HasCore(struct bnode *abnode)
199 {
200     return BOP_HASCORE(abnode);
201 }
202
203 /* wait for all bnodes to stabilize */
204 int
205 bnode_WaitAll(void)
206 {
207     struct bnode *tb;
208     afs_int32 code;
209     afs_int32 stat;
210
211   retry:
212     for (tb = allBnodes; tb; tb = tb->next) {
213         bnode_Hold(tb);
214         code = BOP_GETSTAT(tb, &stat);
215         if (code) {
216             bnode_Release(tb);
217             return code;
218         }
219         if (stat != tb->goal) {
220             tb->flags |= BNODE_WAIT;
221             LWP_WaitProcess(tb);
222             bnode_Release(tb);
223             goto retry;
224         }
225         bnode_Release(tb);
226     }
227     return 0;
228 }
229
230 /* wait until bnode status is correct */
231 int
232 bnode_WaitStatus(struct bnode *abnode, int astatus)
233 {
234     afs_int32 code;
235     afs_int32 stat;
236
237     bnode_Hold(abnode);
238     while (1) {
239         /* get the status */
240         code = BOP_GETSTAT(abnode, &stat);
241         if (code)
242             return code;
243
244         /* otherwise, check if we're done */
245         if (stat == astatus) {
246             bnode_Release(abnode);
247             return 0;           /* done */
248         }
249         if (astatus != abnode->goal) {
250             bnode_Release(abnode);
251             return -1;          /* no longer our goal, don't keep waiting */
252         }
253         /* otherwise, block */
254         abnode->flags |= BNODE_WAIT;
255         LWP_WaitProcess(abnode);
256     }
257 }
258
259 int
260 bnode_SetStat(struct bnode *abnode, int agoal)
261 {
262     abnode->goal = agoal;
263     bnode_Check(abnode);
264     BOP_SETSTAT(abnode, agoal);
265     abnode->flags &= ~BNODE_ERRORSTOP;
266     return 0;
267 }
268
269 int
270 bnode_SetGoal(struct bnode *abnode, int agoal)
271 {
272     abnode->goal = agoal;
273     bnode_Check(abnode);
274     return 0;
275 }
276
277 int
278 bnode_SetFileGoal(struct bnode *abnode, int agoal)
279 {
280     if (abnode->fileGoal == agoal)
281         return 0;               /* already done */
282     abnode->fileGoal = agoal;
283     WriteBozoFile(0);
284     return 0;
285 }
286
287 /* apply a function to all bnodes in the system */
288 int
289 bnode_ApplyInstance(int (*aproc) (struct bnode *tb, void *), void *arock)
290 {
291     struct bnode *tb, *nb;
292     afs_int32 code;
293
294     for (tb = allBnodes; tb; tb = nb) {
295         nb = tb->next;
296         code = (*aproc) (tb, arock);
297         if (code)
298             return code;
299     }
300     return 0;
301 }
302
303 struct bnode *
304 bnode_FindInstance(char *aname)
305 {
306     struct bnode *tb;
307
308     for (tb = allBnodes; tb; tb = tb->next) {
309         if (!strcmp(tb->name, aname))
310             return tb;
311     }
312     return NULL;
313 }
314
315 static struct bnode_type *
316 FindType(char *aname)
317 {
318     struct bnode_type *tt;
319
320     for (tt = allTypes; tt; tt = tt->next) {
321         if (!strcmp(tt->name, aname))
322             return tt;
323     }
324     return (struct bnode_type *)0;
325 }
326
327 int
328 bnode_Register(char *atype, struct bnode_ops *aprocs, int anparms)
329 {
330     struct bnode_type *tt;
331
332     for (tt = allTypes; tt; tt = tt->next) {
333         if (!strcmp(tt->name, atype))
334             break;
335     }
336     if (!tt) {
337         tt = (struct bnode_type *)malloc(sizeof(struct bnode_type));
338         memset(tt, 0, sizeof(struct bnode_type));
339         tt->next = allTypes;
340         allTypes = tt;
341         tt->name = atype;
342     }
343     tt->ops = aprocs;
344     return 0;
345 }
346
347 afs_int32
348 bnode_Create(char *atype, char *ainstance, struct bnode ** abp, char *ap1,
349              char *ap2, char *ap3, char *ap4, char *ap5, char *notifier,
350              int fileGoal, int rewritefile)
351 {
352     struct bnode_type *type;
353     struct bnode *tb;
354     char *notifierpath = NULL;
355     struct stat tstat;
356
357     if (bnode_FindInstance(ainstance))
358         return BZEXISTS;
359     type = FindType(atype);
360     if (!type)
361         return BZBADTYPE;
362
363     if (notifier && strcmp(notifier, NONOTIFIER)) {
364         /* construct local path from canonical (wire-format) path */
365         if (ConstructLocalBinPath(notifier, &notifierpath)) {
366             bozo_Log("BNODE-Create: Notifier program path invalid '%s'\n",
367                      notifier);
368             return BZNOCREATE;
369         }
370
371         if (stat(notifierpath, &tstat)) {
372             bozo_Log("BNODE-Create: Notifier program '%s' not found\n",
373                      notifierpath);
374             free(notifierpath);
375             return BZNOCREATE;
376         }
377     }
378     tb = (*type->ops->create) (ainstance, ap1, ap2, ap3, ap4, ap5);
379     if (!tb) {
380         free(notifierpath);
381         return BZNOCREATE;
382     }
383     tb->notifier = notifierpath;
384     *abp = tb;
385     tb->type = type;
386
387     /* The fs_create above calls bnode_InitBnode() which always sets the
388      ** fileGoal to BSTAT_NORMAL .... overwrite it with whatever is passed into
389      ** this function as a parameter... */
390     tb->fileGoal = fileGoal;
391
392     bnode_SetStat(tb, tb->goal);        /* nudge it once */
393
394     if (rewritefile != 0)
395         WriteBozoFile(0);
396
397     return 0;
398 }
399
400 int
401 bnode_DeleteName(char *ainstance)
402 {
403     struct bnode *tb;
404
405     tb = bnode_FindInstance(ainstance);
406     if (!tb)
407         return BZNOENT;
408
409     return bnode_Delete(tb);
410 }
411
412 int
413 bnode_Hold(struct bnode *abnode)
414 {
415     abnode->refCount++;
416     return 0;
417 }
418
419 int
420 bnode_Release(struct bnode *abnode)
421 {
422     abnode->refCount--;
423     if (abnode->refCount == 0 && abnode->flags & BNODE_DELETE) {
424         abnode->flags &= ~BNODE_DELETE; /* we're going for it */
425         bnode_Delete(abnode);
426     }
427     return 0;
428 }
429
430 int
431 bnode_Delete(struct bnode *abnode)
432 {
433     afs_int32 code;
434     struct bnode **lb, *ub;
435     afs_int32 temp;
436
437     if (abnode->refCount != 0) {
438         abnode->flags |= BNODE_DELETE;
439         return 0;
440     }
441
442     /* make sure the bnode is idle before zapping */
443     bnode_Hold(abnode);
444     code = BOP_GETSTAT(abnode, &temp);
445     bnode_Release(abnode);
446     if (code)
447         return code;
448     if (temp != BSTAT_SHUTDOWN)
449         return BZBUSY;
450
451     /* all clear to zap */
452     for (lb = &allBnodes, ub = *lb; ub; lb = &ub->next, ub = *lb) {
453         if (ub == abnode) {
454             /* unthread it from the list */
455             *lb = ub->next;
456             break;
457         }
458     }
459     free(abnode->name);         /* do this first, since bnode fields may be bad after BOP_DELETE */
460     code = BOP_DELETE(abnode);  /* don't play games like holding over this one */
461     WriteBozoFile(0);
462     return code;
463 }
464
465 /* function to tell if there's a timeout coming up */
466 int
467 bnode_PendingTimeout(struct bnode *abnode)
468 {
469     return (abnode->flags & BNODE_NEEDTIMEOUT);
470 }
471
472 /* function called to set / clear periodic bnode wakeup times */
473 int
474 bnode_SetTimeout(struct bnode *abnode, afs_int32 atimeout)
475 {
476     if (atimeout != 0) {
477         abnode->nextTimeout = FT_ApproxTime() + atimeout;
478         abnode->flags |= BNODE_NEEDTIMEOUT;
479         abnode->period = atimeout;
480         IOMGR_Cancel(bproc_pid);
481     } else {
482         abnode->flags &= ~BNODE_NEEDTIMEOUT;
483     }
484     return 0;
485 }
486
487 /* used by new bnode creation code to format bnode header */
488 int
489 bnode_InitBnode(struct bnode *abnode, struct bnode_ops *abnodeops,
490                 char *aname)
491 {
492     struct bnode **lb, *nb;
493
494     /* format the bnode properly */
495     memset(abnode, 0, sizeof(struct bnode));
496     abnode->ops = abnodeops;
497     abnode->name = (char *)malloc(strlen(aname) + 1);
498     if (!abnode->name)
499         return ENOMEM;
500     strcpy(abnode->name, aname);
501     abnode->flags = BNODE_ACTIVE;
502     abnode->fileGoal = BSTAT_NORMAL;
503     abnode->goal = BSTAT_SHUTDOWN;
504
505     /* put the bnode at the end of the list so we write bnode file in same order */
506     for (lb = &allBnodes, nb = *lb; nb; lb = &nb->next, nb = *lb);
507     *lb = abnode;
508
509     return 0;
510 }
511
512 static int
513 DeleteProc(struct bnode_proc *abproc)
514 {
515     struct bnode_proc **pb, *tb;
516     struct bnode_proc *nb;
517
518     for (pb = &allProcs, tb = *pb; tb; pb = &tb->next, tb = nb) {
519         nb = tb->next;
520         if (tb == abproc) {
521             *pb = nb;
522             free(tb);
523             return 0;
524         }
525     }
526     return BZNOENT;
527 }
528
529 /* bnode lwp executes this code repeatedly */
530 static void *
531 bproc(void *unused)
532 {
533     afs_int32 code;
534     struct bnode *tb;
535     afs_int32 temp;
536     struct bnode_proc *tp;
537     struct bnode *nb;
538     int options;                /* must not be register */
539     struct timeval tv;
540     int setAny;
541     int status;
542
543     while (1) {
544         /* first figure out how long to sleep for */
545         temp = 0x7fffffff;      /* afs_int32 time; maxint doesn't work in select */
546         setAny = 0;
547         for (tb = allBnodes; tb; tb = tb->next) {
548             if (tb->flags & BNODE_NEEDTIMEOUT) {
549                 if (tb->nextTimeout < temp) {
550                     setAny = 1;
551                     temp = tb->nextTimeout;
552                 }
553             }
554         }
555         /* now temp has the time at which we should wakeup next */
556
557         /* sleep */
558         if (setAny)
559             temp -= FT_ApproxTime();    /* how many seconds until next event */
560         else
561             temp = 999999;
562         if (temp > 0) {
563             tv.tv_sec = temp;
564             tv.tv_usec = 0;
565             code = IOMGR_Select(0, 0, 0, 0, &tv);
566         } else
567             code = 0;           /* fake timeout code */
568
569         /* figure out why we woke up; child exit or timeouts */
570         FT_GetTimeOfDay(&tv, 0);        /* must do the real gettimeofday once and a while */
571         temp = tv.tv_sec;
572
573         /* check all bnodes to see which ones need timeout events */
574         for (tb = allBnodes; tb; tb = nb) {
575             if ((tb->flags & BNODE_NEEDTIMEOUT) && temp > tb->nextTimeout) {
576                 bnode_Hold(tb);
577                 BOP_TIMEOUT(tb);
578                 bnode_Check(tb);
579                 if (tb->flags & BNODE_NEEDTIMEOUT) {    /* check again, BOP_TIMEOUT could change */
580                     tb->nextTimeout = FT_ApproxTime() + tb->period;
581                 }
582                 nb = tb->next;
583                 bnode_Release(tb);      /* delete may occur here */
584             } else
585                 nb = tb->next;
586         }
587
588         if (code < 0) {
589             /* signalled, probably by incoming signal */
590             while (1) {
591                 options = WNOHANG;
592                 bnode_waiting = options | 0x800000;
593                 code = waitpid((pid_t) - 1, &status, options);
594                 bnode_waiting = 0;
595                 if (code == 0 || code == -1)
596                     break;      /* all done */
597                 /* otherwise code has a process id, which we now search for */
598                 for (tp = allProcs; tp; tp = tp->next)
599                     if (tp->pid == code)
600                         break;
601                 if (tp) {
602                     /* found the pid */
603                     tb = tp->bnode;
604                     bnode_Hold(tb);
605
606                     /* count restarts in last 10 seconds */
607                     if (temp > tb->rsTime + 30) {
608                         /* it's been 10 seconds we've been counting */
609                         tb->rsTime = temp;
610                         tb->rsCount = 0;
611                     }
612
613                     if (WIFSIGNALED(status) == 0) {
614                         /* exited, not signalled */
615                         tp->lastExit = WEXITSTATUS(status);
616                         tp->lastSignal = 0;
617                         if (tp->lastExit) {
618                             tb->errorCode = tp->lastExit;
619                             tb->lastErrorExit = FT_ApproxTime();
620                             RememberProcName(tp);
621                             tb->errorSignal = 0;
622                         }
623                         if (tp->coreName)
624                             bozo_Log("%s:%s exited with code %d\n", tb->name,
625                                      tp->coreName, tp->lastExit);
626                         else
627                             bozo_Log("%s exited with code %d\n", tb->name,
628                                      tp->lastExit);
629                     } else {
630                         /* Signal occurred, perhaps spurious due to shutdown request.
631                          * If due to a shutdown request, don't overwrite last error
632                          * information.
633                          */
634                         tp->lastSignal = WTERMSIG(status);
635                         tp->lastExit = 0;
636                         if (tp->lastSignal != SIGQUIT
637                             && tp->lastSignal != SIGTERM
638                             && tp->lastSignal != SIGKILL) {
639                             tb->errorSignal = tp->lastSignal;
640                             tb->lastErrorExit = FT_ApproxTime();
641                             RememberProcName(tp);
642                         }
643                         if (tp->coreName)
644                             bozo_Log("%s:%s exited on signal %d%s\n",
645                                      tb->name, tp->coreName, tp->lastSignal,
646                                      WCOREDUMP(status) ? " (core dumped)" :
647                                      "");
648                         else
649                             bozo_Log("%s exited on signal %d%s\n", tb->name,
650                                      tp->lastSignal,
651                                      WCOREDUMP(status) ? " (core dumped)" :
652                                      "");
653                         SaveCore(tb, tp);
654                     }
655                     tb->lastAnyExit = FT_ApproxTime();
656
657                     if (tb->notifier) {
658                         bozo_Log("BNODE: Notifier %s will be called\n",
659                                  tb->notifier);
660                         hdl_notifier(tp);
661                     }
662                     BOP_PROCEXIT(tb, tp);
663
664                     bnode_Check(tb);
665                     if (tb->rsCount++ > 10) {
666                         /* 10 in 10 seconds */
667                         tb->flags |= BNODE_ERRORSTOP;
668                         bnode_SetGoal(tb, BSTAT_SHUTDOWN);
669                         bozo_Log
670                             ("BNODE '%s' repeatedly failed to start, perhaps missing executable.\n",
671                              tb->name);
672                     }
673                     bnode_Release(tb);  /* bnode delete can happen here */
674                     DeleteProc(tp);
675                 } else
676                     bnode_stats.weirdPids++;
677             }
678         }
679     }
680     return NULL;
681 }
682
683 static afs_int32
684 SendNotifierData(int fd, struct bnode_proc *tp)
685 {
686     struct bnode *tb = tp->bnode;
687     char buffer[1000], *bufp = buffer, *buf1;
688     int len;
689
690     /*
691      * First sent out the bnode_proc struct
692      */
693     (void)sprintf(bufp, "BEGIN bnode_proc\n");
694     bufp += strlen(bufp);
695     (void)sprintf(bufp, "comLine: %s\n", tp->comLine);
696     bufp += strlen(bufp);
697     if (!(buf1 = tp->coreName))
698         buf1 = "(null)";
699     (void)sprintf(bufp, "coreName: %s\n", buf1);
700     bufp += strlen(bufp);
701     (void)sprintf(bufp, "pid: %ld\n", afs_printable_int32_ld(tp->pid));
702     bufp += strlen(bufp);
703     (void)sprintf(bufp, "lastExit: %ld\n", afs_printable_int32_ld(tp->lastExit));
704     bufp += strlen(bufp);
705 #ifdef notdef
706     (void)sprintf(bufp, "lastSignal: %ld\n", afs_printable_int32_ld(tp->lastSignal));
707     bufp += strlen(bufp);
708 #endif
709     (void)sprintf(bufp, "flags: %ld\n", afs_printable_int32_ld(tp->flags));
710     bufp += strlen(bufp);
711     (void)sprintf(bufp, "END bnode_proc\n");
712     bufp += strlen(bufp);
713     len = (int)(bufp - buffer);
714     if (write(fd, buffer, len) < 0) {
715         return -1;
716     }
717
718     /*
719      * Now sent out the bnode struct
720      */
721     bufp = buffer;
722     (void)sprintf(bufp, "BEGIN bnode\n");
723     bufp += strlen(bufp);
724     (void)sprintf(bufp, "name: %s\n", tb->name);
725     bufp += strlen(bufp);
726     (void)sprintf(bufp, "rsTime: %ld\n", afs_printable_int32_ld(tb->rsTime));
727     bufp += strlen(bufp);
728     (void)sprintf(bufp, "rsCount: %ld\n", afs_printable_int32_ld(tb->rsCount));
729     bufp += strlen(bufp);
730     (void)sprintf(bufp, "procStartTime: %ld\n", afs_printable_int32_ld(tb->procStartTime));
731     bufp += strlen(bufp);
732     (void)sprintf(bufp, "procStarts: %ld\n", afs_printable_int32_ld(tb->procStarts));
733     bufp += strlen(bufp);
734     (void)sprintf(bufp, "lastAnyExit: %ld\n", afs_printable_int32_ld(tb->lastAnyExit));
735     bufp += strlen(bufp);
736     (void)sprintf(bufp, "lastErrorExit: %ld\n", afs_printable_int32_ld(tb->lastErrorExit));
737     bufp += strlen(bufp);
738     (void)sprintf(bufp, "errorCode: %ld\n", afs_printable_int32_ld(tb->errorCode));
739     bufp += strlen(bufp);
740     (void)sprintf(bufp, "errorSignal: %ld\n", afs_printable_int32_ld(tb->errorSignal));
741     bufp += strlen(bufp);
742 /*
743     (void) sprintf(bufp, "lastErrorName: %s\n", tb->lastErrorName);
744     bufp += strlen(bufp);
745 */
746     (void)sprintf(bufp, "goal: %d\n", tb->goal);
747     bufp += strlen(bufp);
748     (void)sprintf(bufp, "END bnode\n");
749     bufp += strlen(bufp);
750     len = (int)(bufp - buffer);
751     if (write(fd, buffer, len) < 0) {
752         return -1;
753     }
754     return 0;
755 }
756
757 int
758 hdl_notifier(struct bnode_proc *tp)
759 {
760 #ifndef AFS_NT40_ENV            /* NT notifier callout not yet implemented */
761     int pid;
762     struct stat tstat;
763
764     if (stat(tp->bnode->notifier, &tstat)) {
765         bozo_Log("BNODE: Failed to find notifier '%s'; ignored\n",
766                  tp->bnode->notifier);
767         return (1);
768     }
769     if ((pid = fork()) == 0) {
770         FILE *fout;
771         struct bnode *tb = tp->bnode;
772
773 #if defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI51_ENV)
774         setsid();
775 #elif defined(AFS_DARWIN90_ENV)
776         setpgid(0, 0);
777 #elif defined(AFS_LINUX20_ENV) || defined(AFS_AIX_ENV)
778         setpgrp();
779 #else
780         setpgrp(0, 0);
781 #endif
782         fout = popen(tb->notifier, "w");
783         if (fout == NULL) {
784             bozo_Log("BNODE: Failed to find notifier '%s'; ignored\n",
785                      tb->notifier);
786             perror(tb->notifier);
787             exit(1);
788         }
789         SendNotifierData(fileno(fout), tp);
790         pclose(fout);
791         exit(0);
792     } else if (pid < 0) {
793         bozo_Log("Failed to fork creating process to handle notifier '%s'\n",
794                  tp->bnode->notifier);
795         return -1;
796     }
797 #endif /* AFS_NT40_ENV */
798     return (0);
799 }
800
801 /* Called by IOMGR at low priority on IOMGR's stack shortly after a SIGCHLD
802  * occurs.  Wakes up bproc do redo things */
803 void *
804 bnode_SoftInt(void *param)
805 {
806     /* int asignal = (int) param; */
807
808     IOMGR_Cancel(bproc_pid);
809     return 0;
810 }
811
812 /* Called at signal interrupt level; queues function to be called
813  * when IOMGR runs again.
814  */
815 void
816 bnode_Int(int asignal)
817 {
818     if (asignal == SIGQUIT || asignal == SIGTERM) {
819         IOMGR_SoftSig(bozo_ShutdownAndExit, (void *)(intptr_t)asignal);
820     } else {
821         IOMGR_SoftSig(bnode_SoftInt, (void *)(intptr_t)asignal);
822     }
823 }
824
825
826 /* intialize the whole system */
827 int
828 bnode_Init(void)
829 {
830     PROCESS junk;
831     afs_int32 code;
832     struct sigaction newaction;
833     static int initDone = 0;
834
835     if (initDone)
836         return 0;
837     initDone = 1;
838     memset(&bnode_stats, 0, sizeof(bnode_stats));
839     LWP_InitializeProcessSupport(1, &junk);     /* just in case */
840     IOMGR_Initialize();
841     code = LWP_CreateProcess(bproc, BNODE_LWP_STACKSIZE,
842                              /* priority */ 1, (void *) /* parm */ 0,
843                              "bnode-manager", &bproc_pid);
844     if (code)
845         return code;
846     memset(&newaction, 0, sizeof(newaction));
847     newaction.sa_handler = bnode_Int;
848     code = sigaction(SIGCHLD, &newaction, NULL);
849     if (code)
850         return errno;
851     code = sigaction(SIGQUIT, &newaction, NULL);
852     if (code)
853         return errno;
854     code = sigaction(SIGTERM, &newaction, NULL);
855     if (code)
856         return errno;
857     return code;
858 }
859
860 /* free token list returned by parseLine */
861 int
862 bnode_FreeTokens(struct bnode_token *alist)
863 {
864     struct bnode_token *nlist;
865     for (; alist; alist = nlist) {
866         nlist = alist->next;
867         free(alist->key);
868         free(alist);
869     }
870     return 0;
871 }
872
873 static int
874 space(int x)
875 {
876     if (x == 0 || x == ' ' || x == '\t' || x == '\n')
877         return 1;
878     else
879         return 0;
880 }
881
882 int
883 bnode_ParseLine(char *aline, struct bnode_token **alist)
884 {
885     char tbuffer[256];
886     char *tptr = NULL;
887     int inToken;
888     struct bnode_token *first, *last;
889     struct bnode_token *ttok;
890     int tc;
891
892     inToken = 0;                /* not copying token chars at start */
893     first = (struct bnode_token *)0;
894     last = (struct bnode_token *)0;
895     while (1) {
896         tc = *aline++;
897         if (tc == 0 || space(tc)) {     /* terminating null gets us in here, too */
898             if (inToken) {
899                 inToken = 0;    /* end of this token */
900                 *tptr++ = 0;
901                 ttok =
902                     (struct bnode_token *)malloc(sizeof(struct bnode_token));
903                 ttok->next = (struct bnode_token *)0;
904                 ttok->key = (char *)malloc(strlen(tbuffer) + 1);
905                 strcpy(ttok->key, tbuffer);
906                 if (last) {
907                     last->next = ttok;
908                     last = ttok;
909                 } else
910                     last = ttok;
911                 if (!first)
912                     first = ttok;
913             }
914         } else {
915             /* an alpha character */
916             if (!inToken) {
917                 tptr = tbuffer;
918                 inToken = 1;
919             }
920             if (tptr - tbuffer >= sizeof(tbuffer))
921                 return -1;      /* token too long */
922             *tptr++ = tc;
923         }
924         if (tc == 0) {
925             /* last token flushed 'cause space(0) --> true */
926             if (last)
927                 last->next = (struct bnode_token *)0;
928             *alist = first;
929             return 0;
930         }
931     }
932 }
933
934 #define MAXVARGS            128
935 int
936 bnode_NewProc(struct bnode *abnode, char *aexecString, char *coreName,
937               struct bnode_proc **aproc)
938 {
939     struct bnode_token *tlist, *tt;
940     afs_int32 code;
941     struct bnode_proc *tp;
942     pid_t cpid;
943     char *argv[MAXVARGS];
944     int i;
945
946     code = bnode_ParseLine(aexecString, &tlist);        /* try parsing first */
947     if (code)
948         return code;
949     tp = (struct bnode_proc *)malloc(sizeof(struct bnode_proc));
950     memset(tp, 0, sizeof(struct bnode_proc));
951     tp->next = allProcs;
952     tp->bnode = abnode;
953     tp->comLine = aexecString;
954     tp->coreName = coreName;    /* may be null */
955     abnode->procStartTime = FT_ApproxTime();
956     abnode->procStarts++;
957
958     /* convert linked list of tokens into argv structure */
959     for (tt = tlist, i = 0; i < (MAXVARGS - 1) && tt; tt = tt->next, i++) {
960         argv[i] = tt->key;
961     }
962     argv[i] = NULL;             /* null-terminated */
963
964     cpid = spawnprocve(argv[0], argv, environ, -1);
965     osi_audit(BOSSpawnProcEvent, 0, AUD_STR, aexecString, AUD_END);
966
967     if (cpid == (pid_t) - 1) {
968         bozo_Log("Failed to spawn process for bnode '%s'\n", abnode->name);
969         bnode_FreeTokens(tlist);
970         free(tp);
971         return errno;
972     }
973
974     bnode_FreeTokens(tlist);
975     allProcs = tp;
976     *aproc = tp;
977     tp->pid = cpid;
978     tp->flags = BPROC_STARTED;
979     tp->flags &= ~BPROC_EXITED;
980     BOP_PROCSTARTED(abnode, tp);
981     bnode_Check(abnode);
982     return 0;
983 }
984
985 int
986 bnode_StopProc(struct bnode_proc *aproc, int asignal)
987 {
988     int code;
989     if (!(aproc->flags & BPROC_STARTED) || (aproc->flags & BPROC_EXITED))
990         return BZNOTACTIVE;
991
992     osi_audit(BOSStopProcEvent, 0, AUD_STR, (aproc ? aproc->comLine : NULL),
993               AUD_END);
994
995     code = kill(aproc->pid, asignal);
996     bnode_Check(aproc->bnode);
997     return code;
998 }
999
1000 int
1001 bnode_Deactivate(struct bnode *abnode)
1002 {
1003     struct bnode **pb, *tb;
1004     struct bnode *nb;
1005     if (!(abnode->flags & BNODE_ACTIVE))
1006         return BZNOTACTIVE;
1007     for (pb = &allBnodes, tb = *pb; tb; tb = nb) {
1008         nb = tb->next;
1009         if (tb == abnode) {
1010             *pb = nb;
1011             tb->flags &= ~BNODE_ACTIVE;
1012             return 0;
1013         }
1014     }
1015     return BZNOENT;
1016 }