Avoid 'salvageserver -client -showlog' segfault
[openafs.git] / src / vol / salvaged.c
1 /*
2  * Copyright 2006-2007, Sine Nomine Associates 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 /* 
11  * demand attach fs
12  * online salvager daemon
13  */
14
15 /* Main program file. Define globals. */
16 #define MAIN 1
17
18 #include <afsconfig.h>
19 #include <afs/param.h>
20
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <dirent.h>
26 #include <sys/stat.h>
27 #include <time.h>
28 #include <errno.h>
29 #ifdef AFS_NT40_ENV
30 #include <io.h>
31 #include <WINNT/afsevent.h>
32 #else
33 #include <sys/param.h>
34 #include <sys/file.h>
35 #ifndef ITIMER_REAL
36 #include <sys/time.h>
37 #endif /* ITIMER_REAL */
38 #endif
39 #if     defined(AFS_AIX_ENV) || defined(AFS_SUN4_ENV)
40 #define WCOREDUMP(x)    (x & 0200)
41 #endif
42 #include <rx/xdr.h>
43 #include <afs/afsint.h>
44 #include <afs/assert.h>
45 #if !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV)
46 #if defined(AFS_VFSINCL_ENV)
47 #include <sys/vnode.h>
48 #ifdef  AFS_SUN5_ENV
49 #include <sys/fs/ufs_inode.h>
50 #else
51 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
52 #include <ufs/ufs/dinode.h>
53 #include <ufs/ffs/fs.h>
54 #else
55 #include <ufs/inode.h>
56 #endif
57 #endif
58 #else /* AFS_VFSINCL_ENV */
59 #ifdef  AFS_OSF_ENV
60 #include <ufs/inode.h>
61 #else /* AFS_OSF_ENV */
62 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_XBSD_ENV)
63 #include <sys/inode.h>
64 #endif
65 #endif
66 #endif /* AFS_VFSINCL_ENV */
67 #endif /* AFS_SGI_ENV */
68 #ifdef  AFS_AIX_ENV
69 #include <sys/vfs.h>
70 #include <sys/lockf.h>
71 #else
72 #ifdef  AFS_HPUX_ENV
73 #include <unistd.h>
74 #include <checklist.h>
75 #else
76 #if defined(AFS_SGI_ENV)
77 #include <unistd.h>
78 #include <fcntl.h>
79 #include <mntent.h>
80 #else
81 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
82 #ifdef    AFS_SUN5_ENV
83 #include <unistd.h>
84 #include <sys/mnttab.h>
85 #include <sys/mntent.h>
86 #else
87 #include <mntent.h>
88 #endif
89 #else
90 #endif /* AFS_SGI_ENV */
91 #endif /* AFS_HPUX_ENV */
92 #endif
93 #endif
94 #include <fcntl.h>
95 #ifndef AFS_NT40_ENV
96 #include <afs/osi_inode.h>
97 #endif
98 #include <afs/cmd.h>
99 #include <afs/afsutil.h>
100 #include <afs/fileutil.h>
101 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
102 #include <afs/dir.h>
103 #ifndef AFS_NT40_ENV
104 #include <syslog.h>
105 #endif
106
107 #include "nfs.h"
108 #include "lwp.h"
109 #include "lock.h"
110 #include <afs/afssyscalls.h>
111 #include "ihandle.h"
112 #include "vnode.h"
113 #include "volume.h"
114 #include "partition.h"
115 #include "daemon_com.h"
116 #include "fssync.h"
117 #include "salvsync.h"
118 #include "viceinode.h"
119 #include "salvage.h"
120 #include "vol-salvage.h"
121 #ifdef AFS_NT40_ENV
122 #include <pthread.h>
123 #endif
124
125
126 #if !defined(AFS_DEMAND_ATTACH_FS)
127 #error "online salvager only supported for demand attach fileserver"
128 #endif /* AFS_DEMAND_ATTACH_FS */
129
130 #if defined(AFS_NT40_ENV)
131 #error "online salvager not supported on NT"
132 #endif /* AFS_NT40_ENV */
133
134
135 /* Forward declarations */
136 /*@printflike@*/ void Log(const char *format, ...);
137 /*@printflike@*/ void Abort(const char *format, ...);
138
139
140 /*@+fcnmacros +macrofcndecl@*/
141 #ifdef O_LARGEFILE
142 #define afs_fopen       fopen64
143 #else /* !O_LARGEFILE */
144 #define afs_fopen       fopen
145 #endif /* !O_LARGEFILE */
146 /*@=fcnmacros =macrofcndecl@*/
147
148
149
150 static volatile int current_workers = 0;
151 static volatile struct rx_queue pending_q;
152 static pthread_mutex_t worker_lock;
153 static pthread_cond_t worker_cv;
154
155 static void * SalvageChildReaperThread(void *);
156 static int DoSalvageVolume(struct SalvageQueueNode * node, int slot);
157
158 static void SalvageServer(void);
159 static void SalvageClient(VolumeId vid, char * pname);
160
161 static int Reap_Child(char * prog, int * pid, int * status);
162
163 static void * SalvageLogCleanupThread(void *);
164 static int SalvageLogCleanup(int pid);
165
166 static void * SalvageLogScanningThread(void *);
167 static void ScanLogs(struct rx_queue *log_watch_queue);
168
169 struct log_cleanup_node {
170     struct rx_queue q;
171     int pid;
172 };
173
174 struct {
175     struct rx_queue queue_head;
176     pthread_cond_t queue_change_cv;
177 } log_cleanup_queue;
178
179
180 #define DEFAULT_PARALLELISM 4 /* allow 4 parallel salvage workers by default */
181
182 static int
183 handleit(struct cmd_syndesc *as, void *arock)
184 {
185     register struct cmd_item *ti;
186     char pname[100], *temp;
187     afs_int32 seenpart = 0, seenvol = 0, vid = 0;
188
189 #ifdef AFS_SGI_VNODE_GLUE
190     if (afs_init_kernel_config(-1) < 0) {
191         printf
192             ("Can't determine NUMA configuration, not starting salvager.\n");
193         exit(1);
194     }
195 #endif
196
197     if (as->parms[2].items)     /* -debug */
198         debug = 1;
199     if (as->parms[3].items)     /* -nowrite */
200         Testing = 1;
201     if (as->parms[4].items)     /* -inodes */
202         ListInodeOption = 1;
203     if (as->parms[5].items)     /* -oktozap */
204         OKToZap = 1;
205     if (as->parms[6].items)     /* -rootinodes */
206         ShowRootFiles = 1;
207     if (as->parms[8].items)     /* -ForceReads */
208         forceR = 1;
209     if ((ti = as->parms[9].items)) {    /* -Parallel # */
210         temp = ti->data;
211         if (strncmp(temp, "all", 3) == 0) {
212             PartsPerDisk = 1;
213             temp += 3;
214         }
215         if (strlen(temp) != 0) {
216             Parallel = atoi(temp);
217             if (Parallel < 1)
218                 Parallel = 1;
219             if (Parallel > MAXPARALLEL) {
220                 printf("Setting parallel salvages to maximum of %d \n",
221                        MAXPARALLEL);
222                 Parallel = MAXPARALLEL;
223             }
224         }
225     } else {
226         Parallel = MIN(DEFAULT_PARALLELISM, MAXPARALLEL);
227     }
228     if ((ti = as->parms[10].items)) {   /* -tmpdir */
229         DIR *dirp;
230
231         tmpdir = ti->data;
232         dirp = opendir(tmpdir);
233         if (!dirp) {
234             printf
235                 ("Can't open temporary placeholder dir %s; using current partition \n",
236                  tmpdir);
237             tmpdir = NULL;
238         } else
239             closedir(dirp);
240     }
241     if ((ti = as->parms[11].items))     /* -showlog */
242         ShowLog = 1;
243     if ((ti = as->parms[12].items)) {   /* -orphans */
244         if (Testing)
245             orphans = ORPH_IGNORE;
246         else if (strcmp(ti->data, "remove") == 0
247                  || strcmp(ti->data, "r") == 0)
248             orphans = ORPH_REMOVE;
249         else if (strcmp(ti->data, "attach") == 0
250                  || strcmp(ti->data, "a") == 0)
251             orphans = ORPH_ATTACH;
252     }
253 #ifndef AFS_NT40_ENV            /* ignore options on NT */
254     if ((ti = as->parms[13].items)) {   /* -syslog */
255         useSyslog = 1;
256         ShowLog = 0;
257     }
258     if ((ti = as->parms[14].items)) {   /* -syslogfacility */
259         useSyslogFacility = atoi(ti->data);
260     }
261
262     if ((ti = as->parms[15].items)) {   /* -datelogs */
263         TimeStampLogFile((char *)AFSDIR_SERVER_SALSRVLOG_FILEPATH);
264     }
265 #endif
266
267     if ((ti = as->parms[16].items)) {   /* -client */
268         if ((ti = as->parms[0].items)) {        /* -partition */
269             seenpart = 1;
270             strlcpy(pname, ti->data, sizeof(pname));
271         }
272         if ((ti = as->parms[1].items)) {        /* -volumeid */
273             seenvol = 1;
274             vid = atoi(ti->data);
275         }
276
277         if (ShowLog) {
278             printf("-showlog does not work with -client\n");
279             exit(-1);
280         }
281
282         if (!seenpart || !seenvol) {
283             printf("You must specify '-partition' and '-volumeid' with the '-client' option\n");
284             exit(-1);
285         }
286
287         SalvageClient(vid, pname);
288
289     } else {  /* salvageserver mode */
290         SalvageServer();
291     }
292     return (0);
293 }
294
295
296 #ifndef AFS_NT40_ENV
297 #include "AFS_component_version_number.c"
298 #endif
299 #define MAX_ARGS 128
300 #ifdef AFS_NT40_ENV
301 char *save_args[MAX_ARGS];
302 int n_save_args = 0;
303 pthread_t main_thread;
304 #endif
305
306 static char commandLine[150];
307
308 int
309 main(int argc, char **argv)
310 {
311     struct cmd_syndesc *ts;
312     int err = 0;
313
314     int i;
315
316 #ifdef  AFS_AIX32_ENV
317     /*
318      * The following signal action for AIX is necessary so that in case of a 
319      * crash (i.e. core is generated) we can include the user's data section 
320      * in the core dump. Unfortunately, by default, only a partial core is
321      * generated which, in many cases, isn't too useful.
322      */
323     struct sigaction nsa;
324
325     sigemptyset(&nsa.sa_mask);
326     nsa.sa_handler = SIG_DFL;
327     nsa.sa_flags = SA_FULLDUMP;
328     sigaction(SIGABRT, &nsa, NULL);
329     sigaction(SIGSEGV, &nsa, NULL);
330 #endif
331
332     /* Initialize directory paths */
333     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
334 #ifdef AFS_NT40_ENV
335         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
336 #endif
337         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
338                 argv[0]);
339         exit(2);
340     }
341 #ifdef AFS_NT40_ENV
342     main_thread = pthread_self();
343     if (spawnDatap && spawnDataLen) {
344         /* This is a child per partition salvager. Don't setup log or
345          * try to lock the salvager lock.
346          */
347         if (nt_SetupPartitionSalvage(spawnDatap, spawnDataLen) < 0)
348             exit(3);
349     } else {
350 #endif
351         for (commandLine[0] = '\0', i = 0; i < argc; i++) {
352             if (i > 0)
353                 strlcat(commandLine, " ", sizeof(commandLine));
354             strlcat(commandLine, argv[i], sizeof(commandLine));
355         }
356
357 #ifndef AFS_NT40_ENV
358         if (geteuid() != 0) {
359             printf("Salvager must be run as root.\n");
360             fflush(stdout);
361             Exit(0);
362         }
363 #endif
364
365         /* bad for normal help flag processing, but can do nada */
366
367 #ifdef AFS_NT40_ENV
368     }
369 #endif
370
371     ts = cmd_CreateSyntax("initcmd", handleit, NULL, "initialize the program");
372     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
373                 "Name of partition to salvage");
374     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, CMD_OPTIONAL,
375                 "Volume Id to salvage");
376     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
377                 "Run in Debugging mode");
378     cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
379                 "Run readonly/test mode");
380     cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
381                 "Just list affected afs inodes - debugging flag");
382     cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
383                 "Give permission to destroy bogus inodes/volumes - debugging flag");
384     cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
385                 "Show inodes owned by root - debugging flag");
386     cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
387                 "Force rebuild/salvage of all directories");
388     cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
389                 "Read smaller blocks to handle IO/bad blocks");
390     cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
391                 "# of max parallel partition salvaging");
392     cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
393                 "Name of dir to place tmp files ");
394     cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
395                 "Show log file upon completion");
396     cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
397                 "ignore | remove | attach");
398
399     /* note - syslog isn't avail on NT, but if we make it conditional, have
400      * to deal with screwy offsets for cmd params */
401     cmd_AddParm(ts, "-syslog", CMD_FLAG, CMD_OPTIONAL,
402                 "Write salvage log to syslogs");
403     cmd_AddParm(ts, "-syslogfacility", CMD_SINGLE, CMD_OPTIONAL,
404                 "Syslog facility number to use");
405     cmd_AddParm(ts, "-datelogs", CMD_FLAG, CMD_OPTIONAL,
406                 "Include timestamp in logfile filename");
407
408     cmd_AddParm(ts, "-client", CMD_FLAG, CMD_OPTIONAL,
409                 "Use SALVSYNC to ask salvageserver to salvage a volume");
410
411     err = cmd_Dispatch(argc, argv);
412     Exit(err);
413     return 0; /* not reached */
414 }
415
416 static void
417 SalvageClient(VolumeId vid, char * pname)
418 {
419     int done = 0;
420     afs_int32 code;
421     SYNC_response res;
422     SALVSYNC_response_hdr sres;
423
424     VInitVolumePackage(volumeUtility, 5, 5, DONT_CONNECT_FS, 0);
425     SALVSYNC_clientInit();
426     
427     code = SALVSYNC_SalvageVolume(vid, pname, SALVSYNC_SALVAGE, SALVSYNC_OPERATOR, 0, NULL);
428     if (code != SYNC_OK) {
429         goto sync_error;
430     }
431
432     res.payload.buf = (void *) &sres;
433     res.payload.len = sizeof(sres);
434
435     while(!done) {
436         sleep(2);
437         code = SALVSYNC_SalvageVolume(vid, pname, SALVSYNC_QUERY, SALVSYNC_WHATEVER, 0, &res);
438         if (code != SYNC_OK) {
439             goto sync_error;
440         }
441         switch (sres.state) {
442         case SALVSYNC_STATE_ERROR:
443             printf("salvageserver reports salvage ended in an error; check log files for more details\n");
444         case SALVSYNC_STATE_DONE:
445         case SALVSYNC_STATE_UNKNOWN:
446             done = 1;
447         }
448     }
449     SALVSYNC_clientFinis();
450     return;
451
452  sync_error:
453     if (code == SYNC_DENIED) {
454         printf("salvageserver refused to salvage volume %u on partition %s\n",
455                vid, pname);
456     } else if (code == SYNC_BAD_COMMAND) {
457         printf("SALVSYNC protocol mismatch; please make sure fileserver, volserver, salvageserver and salvager are same version\n");
458     } else if (code == SYNC_COM_ERROR) {
459         printf("SALVSYNC communications error\n");
460     }
461     SALVSYNC_clientFinis();
462     exit(-1);
463 }
464
465 static int * child_slot;
466
467 static void
468 SalvageServer(void)
469 {
470     int pid, ret;
471     struct SalvageQueueNode * node;
472     pthread_t tid;
473     pthread_attr_t attrs;
474     int slot;
475
476     /* All entries to the log will be appended.  Useful if there are
477      * multiple salvagers appending to the log.
478      */
479
480     CheckLogFile((char *)AFSDIR_SERVER_SALSRVLOG_FILEPATH);
481 #ifndef AFS_NT40_ENV
482 #ifdef AFS_LINUX20_ENV
483     fcntl(fileno(logFile), F_SETFL, O_APPEND);  /* Isn't this redundant? */
484 #else
485     fcntl(fileno(logFile), F_SETFL, FAPPEND);   /* Isn't this redundant? */
486 #endif
487 #endif
488     setlinebuf(logFile);
489
490     fprintf(logFile, "%s\n", cml_version_number);
491     Log("Starting OpenAFS Online Salvage Server %s (%s)\n", SalvageVersion, commandLine);
492     
493     /* Get and hold a lock for the duration of the salvage to make sure
494      * that no other salvage runs at the same time.  The routine
495      * VInitVolumePackage (called below) makes sure that a file server or
496      * other volume utilities don't interfere with the salvage.
497      */
498     
499     /* even demand attach online salvager
500      * still needs this because we don't want
501      * a stand-alone salvager to conflict with
502      * the salvager daemon */
503     ObtainSalvageLock();
504
505     child_slot = (int *) malloc(Parallel * sizeof(int));
506     assert(child_slot != NULL);
507     memset(child_slot, 0, Parallel * sizeof(int));
508             
509     /* initialize things */
510     VInitVolumePackage(salvageServer, 5, 5,
511                        1, 0);
512     DInit(10);
513     queue_Init(&pending_q);
514     queue_Init(&log_cleanup_queue);
515     assert(pthread_mutex_init(&worker_lock, NULL) == 0);
516     assert(pthread_cond_init(&worker_cv, NULL) == 0);
517     assert(pthread_cond_init(&log_cleanup_queue.queue_change_cv, NULL) == 0);
518     assert(pthread_attr_init(&attrs) == 0);
519
520     /* start up the reaper and log cleaner threads */
521     assert(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0);
522     assert(pthread_create(&tid, 
523                           &attrs, 
524                           &SalvageChildReaperThread,
525                           NULL) == 0);
526     assert(pthread_create(&tid, 
527                           &attrs, 
528                           &SalvageLogCleanupThread,
529                           NULL) == 0);
530     assert(pthread_create(&tid,
531                           &attrs,
532                           &SalvageLogScanningThread,
533                           NULL) == 0);
534
535     /* loop forever serving requests */
536     while (1) {
537         node = SALVSYNC_getWork();
538         assert(node != NULL);
539
540         Log("dispatching child to salvage volume %u...\n",
541             node->command.sop.parent);
542
543         VOL_LOCK;
544         /* find a slot */
545         for (slot = 0; slot < Parallel; slot++) {
546           if (!child_slot[slot])
547             break;
548         }
549         assert (slot < Parallel);
550
551     do_fork:
552         pid = Fork();
553         if (pid == 0) {
554             VOL_UNLOCK;
555             ret = DoSalvageVolume(node, slot);
556             Exit(ret);
557         } else if (pid < 0) {
558             Log("failed to fork child worker process\n");
559             sleep(1);
560             goto do_fork;
561         } else {
562             child_slot[slot] = pid;
563             node->pid = pid;
564             VOL_UNLOCK;
565             
566             assert(pthread_mutex_lock(&worker_lock) == 0);
567             current_workers++;
568             
569             /* let the reaper thread know another worker was spawned */
570             assert(pthread_cond_broadcast(&worker_cv) == 0);
571             
572             /* if we're overquota, wait for the reaper */
573             while (current_workers >= Parallel) {
574                 assert(pthread_cond_wait(&worker_cv, &worker_lock) == 0);
575             }
576             assert(pthread_mutex_unlock(&worker_lock) == 0);
577         }
578     }
579 }
580
581 static int
582 DoSalvageVolume(struct SalvageQueueNode * node, int slot)
583 {
584     char childLog[AFSDIR_PATH_MAX];
585     struct DiskPartition64 * partP;
586
587     /* do not allow further forking inside salvager */
588     canfork = 0;
589
590     /* do not attempt to close parent's logFile handle as
591      * another thread may have held the lock on the FILE
592      * structure when fork was called! */
593
594     afs_snprintf(childLog, sizeof(childLog), "%s.%d", 
595                  AFSDIR_SERVER_SLVGLOG_FILEPATH, getpid());
596
597     logFile = afs_fopen(childLog, "a");
598     if (!logFile) {             /* still nothing, use stdout */
599         logFile = stdout;
600         ShowLog = 0;
601     }
602
603     if (node->command.sop.parent <= 0) {
604         Log("salvageServer: invalid volume id specified; salvage aborted\n");
605         return 1;
606     }
607     
608     partP = VGetPartition(node->command.sop.partName, 0);
609     if (!partP) {
610         Log("salvageServer: Unknown or unmounted partition %s; salvage aborted\n", 
611             node->command.sop.partName);
612         return 1;
613     }
614
615     /* Salvage individual volume; don't notify fs */
616     SalvageFileSys1(partP, node->command.sop.parent);
617
618     fclose(logFile);
619     return 0;
620 }
621
622
623 static void *
624 SalvageChildReaperThread(void * args)
625 {
626     int slot, pid, status;
627     struct log_cleanup_node * cleanup;
628
629     assert(pthread_mutex_lock(&worker_lock) == 0);
630
631     /* loop reaping our children */
632     while (1) {
633         /* wait() won't block unless we have children, so
634          * block on the cond var if we're childless */
635         while (current_workers == 0) {
636             assert(pthread_cond_wait(&worker_cv, &worker_lock) == 0);
637         }
638
639         assert(pthread_mutex_unlock(&worker_lock) == 0);
640
641         cleanup = (struct log_cleanup_node *) malloc(sizeof(struct log_cleanup_node));
642
643         while (Reap_Child("salvageserver", &pid, &status) < 0) {
644             /* try to prevent livelock if something goes wrong */
645             sleep(1);
646         }
647
648         VOL_LOCK;
649         for (slot = 0; slot < Parallel; slot++) {
650             if (child_slot[slot] == pid)
651                 break;
652         }
653         assert(slot < Parallel);
654         child_slot[slot] = 0;
655         VOL_UNLOCK;
656
657         SALVSYNC_doneWorkByPid(pid, status);
658
659         assert(pthread_mutex_lock(&worker_lock) == 0);
660
661         if (cleanup) {
662             cleanup->pid = pid;
663             queue_Append(&log_cleanup_queue, cleanup);
664             assert(pthread_cond_signal(&log_cleanup_queue.queue_change_cv) == 0);
665         }
666
667         /* ok, we've reaped a child */
668         current_workers--;
669         assert(pthread_cond_broadcast(&worker_cv) == 0);
670     }
671
672     return NULL;
673 }
674
675 static int
676 Reap_Child(char *prog, int * pid, int * status)
677 {
678     int ret;
679     ret = wait(status);
680
681     if (ret >= 0) {
682         *pid = ret;
683         if (WCOREDUMP(*status))
684             Log("\"%s\" core dumped!\n", prog);
685         if ((WIFSIGNALED(*status) != 0) ||
686             ((WEXITSTATUS(*status) != 0) &&
687              (WEXITSTATUS(*status) != SALSRV_EXIT_VOLGROUP_LINK)))
688             Log("\"%s\" (pid=%d) terminated abnormally!\n", prog, ret);
689     } else {
690         Log("wait returned -1\n");
691     }
692     return ret;
693 }
694
695 /*
696  * thread to combine salvager child logs
697  * back into the main salvageserver log
698  */
699 static void *
700 SalvageLogCleanupThread(void * arg)
701 {
702     struct log_cleanup_node * cleanup;
703
704     assert(pthread_mutex_lock(&worker_lock) == 0);
705
706     while (1) {
707         while (queue_IsEmpty(&log_cleanup_queue)) {
708             assert(pthread_cond_wait(&log_cleanup_queue.queue_change_cv, &worker_lock) == 0);
709         }
710
711         while (queue_IsNotEmpty(&log_cleanup_queue)) {
712             cleanup = queue_First(&log_cleanup_queue, log_cleanup_node);
713             queue_Remove(cleanup);
714             assert(pthread_mutex_unlock(&worker_lock) == 0);
715             SalvageLogCleanup(cleanup->pid);
716             free(cleanup);
717             assert(pthread_mutex_lock(&worker_lock) == 0);
718         }           
719     }
720
721     assert(pthread_mutex_unlock(&worker_lock) == 0);
722     return NULL;
723 }
724
725 #define LOG_XFER_BUF_SIZE 65536
726 static int
727 SalvageLogCleanup(int pid)
728 {
729     int pidlog, len;
730     char fn[AFSDIR_PATH_MAX];
731     static char buf[LOG_XFER_BUF_SIZE];
732
733     afs_snprintf(fn, sizeof(fn), "%s.%d", 
734                  AFSDIR_SERVER_SLVGLOG_FILEPATH, pid);
735     
736
737     pidlog = open(fn, O_RDONLY);
738     unlink(fn);
739     if (pidlog < 0)
740         return 1;
741
742     len = read(pidlog, buf, LOG_XFER_BUF_SIZE);
743     while (len) {
744         fwrite(buf, len, 1, logFile);
745         len = read(pidlog, buf, LOG_XFER_BUF_SIZE);
746     }
747
748     close(pidlog);
749
750     return 0;
751 }
752
753 /* wake up every five minutes to see if a non-child salvage has finished */
754 #define SALVAGE_SCAN_POLL_INTERVAL 300
755
756 /**
757  * Thread to look for SalvageLog.$pid files that are not from our child
758  * worker salvagers, and notify SalvageLogCleanupThread to clean them
759  * up. This can happen if we restart during salvages, or the
760  * salvageserver crashes or something.
761  *
762  * @param arg  unused
763  *
764  * @return always NULL
765  */
766 static void *
767 SalvageLogScanningThread(void * arg)
768 {
769     struct rx_queue log_watch_queue;
770
771     queue_Init(&log_watch_queue);
772
773     {
774         DIR *dp;
775         struct dirent *dirp;
776         char prefix[AFSDIR_PATH_MAX];
777         size_t prefix_len;
778
779         afs_snprintf(prefix, sizeof(prefix), "%s.", AFSDIR_SLVGLOG_FILE);
780         prefix_len = strlen(prefix);
781
782         dp = opendir(AFSDIR_LOGS_DIR);
783         assert(dp);
784
785         while ((dirp = readdir(dp)) != NULL) {
786             pid_t pid;
787             struct log_cleanup_node *cleanup;
788             int i;
789
790             if (strncmp(dirp->d_name, prefix, prefix_len) != 0) {
791                 /* not a salvage logfile; skip */
792                 continue;
793             }
794
795             errno = 0;
796             pid = strtol(dirp->d_name + prefix_len, NULL, 10);
797
798             if (errno != 0) {
799                 /* file is SalvageLog.<something> but <something> isn't
800                  * a pid, so skip */
801                  continue;
802             }
803
804             VOL_LOCK;
805             for (i = 0; i < Parallel; ++i) {
806                 if (pid == child_slot[i]) {
807                     break;
808                 }
809             }
810             VOL_UNLOCK;
811             if (i < Parallel) {
812                 /* this pid is one of our children, so the reaper thread
813                  * will take care of it; skip */
814                 continue;
815             }
816
817             cleanup =
818                 (struct log_cleanup_node *) malloc(sizeof(struct log_cleanup_node));
819             cleanup->pid = pid;
820
821             queue_Append(&log_watch_queue, cleanup);
822         }
823
824         closedir(dp);
825     }
826
827     ScanLogs(&log_watch_queue);
828
829     while (queue_IsNotEmpty(&log_watch_queue)) {
830         sleep(SALVAGE_SCAN_POLL_INTERVAL);
831         ScanLogs(&log_watch_queue);
832     }
833
834     return NULL;
835 }
836
837 /**
838  * look through log_watch_queue, and if any processes are not still
839  * running, hand them off to the SalvageLogCleanupThread
840  *
841  * @param log_watch_queue  a queue of PIDs that we should clean up if
842  * that PID has died
843  */
844 static void
845 ScanLogs(struct rx_queue *log_watch_queue)
846 {
847     struct log_cleanup_node *cleanup, *next;
848
849     assert(pthread_mutex_lock(&worker_lock) == 0);
850
851     for (queue_Scan(log_watch_queue, cleanup, next, log_cleanup_node)) {
852         /* if a process is still running, assume it's the salvage process
853          * still going, and keep waiting for it */
854         if (kill(cleanup->pid, 0) < 0 && errno == ESRCH) {
855             queue_Remove(cleanup);
856             queue_Append(&log_cleanup_queue, cleanup);
857             assert(pthread_cond_signal(&log_cleanup_queue.queue_change_cv) == 0);
858         }
859     }
860
861     assert(pthread_mutex_unlock(&worker_lock) == 0);
862 }