Expand ProgramType enumeration
[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 #ifndef WCOREDUMP
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     VolumePackageOptions opts;
424
425     VOptDefaults(volumeUtility, &opts);
426     VInitVolumePackage2(volumeUtility, &opts);
427     SALVSYNC_clientInit();
428     
429     code = SALVSYNC_SalvageVolume(vid, pname, SALVSYNC_SALVAGE, SALVSYNC_OPERATOR, 0, NULL);
430     if (code != SYNC_OK) {
431         goto sync_error;
432     }
433
434     res.payload.buf = (void *) &sres;
435     res.payload.len = sizeof(sres);
436
437     while(!done) {
438         sleep(2);
439         code = SALVSYNC_SalvageVolume(vid, pname, SALVSYNC_QUERY, SALVSYNC_WHATEVER, 0, &res);
440         if (code != SYNC_OK) {
441             goto sync_error;
442         }
443         switch (sres.state) {
444         case SALVSYNC_STATE_ERROR:
445             printf("salvageserver reports salvage ended in an error; check log files for more details\n");
446         case SALVSYNC_STATE_DONE:
447         case SALVSYNC_STATE_UNKNOWN:
448             done = 1;
449         }
450     }
451     SALVSYNC_clientFinis();
452     return;
453
454  sync_error:
455     if (code == SYNC_DENIED) {
456         printf("salvageserver refused to salvage volume %u on partition %s\n",
457                vid, pname);
458     } else if (code == SYNC_BAD_COMMAND) {
459         printf("SALVSYNC protocol mismatch; please make sure fileserver, volserver, salvageserver and salvager are same version\n");
460     } else if (code == SYNC_COM_ERROR) {
461         printf("SALVSYNC communications error\n");
462     }
463     SALVSYNC_clientFinis();
464     exit(-1);
465 }
466
467 static int * child_slot;
468
469 static void
470 SalvageServer(void)
471 {
472     int pid, ret;
473     struct SalvageQueueNode * node;
474     pthread_t tid;
475     pthread_attr_t attrs;
476     int slot;
477     VolumePackageOptions opts;
478
479     /* All entries to the log will be appended.  Useful if there are
480      * multiple salvagers appending to the log.
481      */
482
483     CheckLogFile((char *)AFSDIR_SERVER_SALSRVLOG_FILEPATH);
484 #ifndef AFS_NT40_ENV
485 #ifdef AFS_LINUX20_ENV
486     fcntl(fileno(logFile), F_SETFL, O_APPEND);  /* Isn't this redundant? */
487 #else
488     fcntl(fileno(logFile), F_SETFL, FAPPEND);   /* Isn't this redundant? */
489 #endif
490 #endif
491     setlinebuf(logFile);
492
493     fprintf(logFile, "%s\n", cml_version_number);
494     Log("Starting OpenAFS Online Salvage Server %s (%s)\n", SalvageVersion, commandLine);
495     
496     /* Get and hold a lock for the duration of the salvage to make sure
497      * that no other salvage runs at the same time.  The routine
498      * VInitVolumePackage2 (called below) makes sure that a file server or
499      * other volume utilities don't interfere with the salvage.
500      */
501     
502     /* even demand attach online salvager
503      * still needs this because we don't want
504      * a stand-alone salvager to conflict with
505      * the salvager daemon */
506     ObtainSalvageLock();
507
508     child_slot = (int *) malloc(Parallel * sizeof(int));
509     assert(child_slot != NULL);
510     memset(child_slot, 0, Parallel * sizeof(int));
511
512     /* initialize things */
513     VOptDefaults(salvageServer, &opts);
514     VInitVolumePackage2(salvageServer, &opts);
515     DInit(10);
516     queue_Init(&pending_q);
517     queue_Init(&log_cleanup_queue);
518     assert(pthread_mutex_init(&worker_lock, NULL) == 0);
519     assert(pthread_cond_init(&worker_cv, NULL) == 0);
520     assert(pthread_cond_init(&log_cleanup_queue.queue_change_cv, NULL) == 0);
521     assert(pthread_attr_init(&attrs) == 0);
522
523     /* start up the reaper and log cleaner threads */
524     assert(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0);
525     assert(pthread_create(&tid, 
526                           &attrs, 
527                           &SalvageChildReaperThread,
528                           NULL) == 0);
529     assert(pthread_create(&tid, 
530                           &attrs, 
531                           &SalvageLogCleanupThread,
532                           NULL) == 0);
533     assert(pthread_create(&tid,
534                           &attrs,
535                           &SalvageLogScanningThread,
536                           NULL) == 0);
537
538     /* loop forever serving requests */
539     while (1) {
540         node = SALVSYNC_getWork();
541         assert(node != NULL);
542
543         Log("dispatching child to salvage volume %u...\n",
544             node->command.sop.parent);
545
546         VOL_LOCK;
547         /* find a slot */
548         for (slot = 0; slot < Parallel; slot++) {
549           if (!child_slot[slot])
550             break;
551         }
552         assert (slot < Parallel);
553
554     do_fork:
555         pid = Fork();
556         if (pid == 0) {
557             VOL_UNLOCK;
558             ret = DoSalvageVolume(node, slot);
559             Exit(ret);
560         } else if (pid < 0) {
561             Log("failed to fork child worker process\n");
562             sleep(1);
563             goto do_fork;
564         } else {
565             child_slot[slot] = pid;
566             node->pid = pid;
567             VOL_UNLOCK;
568             
569             assert(pthread_mutex_lock(&worker_lock) == 0);
570             current_workers++;
571             
572             /* let the reaper thread know another worker was spawned */
573             assert(pthread_cond_broadcast(&worker_cv) == 0);
574             
575             /* if we're overquota, wait for the reaper */
576             while (current_workers >= Parallel) {
577                 assert(pthread_cond_wait(&worker_cv, &worker_lock) == 0);
578             }
579             assert(pthread_mutex_unlock(&worker_lock) == 0);
580         }
581     }
582 }
583
584 static int
585 DoSalvageVolume(struct SalvageQueueNode * node, int slot)
586 {
587     char childLog[AFSDIR_PATH_MAX];
588     struct DiskPartition64 * partP;
589
590     /* do not allow further forking inside salvager */
591     canfork = 0;
592
593     /* do not attempt to close parent's logFile handle as
594      * another thread may have held the lock on the FILE
595      * structure when fork was called! */
596
597     afs_snprintf(childLog, sizeof(childLog), "%s.%d", 
598                  AFSDIR_SERVER_SLVGLOG_FILEPATH, getpid());
599
600     logFile = afs_fopen(childLog, "a");
601     if (!logFile) {             /* still nothing, use stdout */
602         logFile = stdout;
603         ShowLog = 0;
604     }
605
606     if (node->command.sop.parent <= 0) {
607         Log("salvageServer: invalid volume id specified; salvage aborted\n");
608         return 1;
609     }
610     
611     partP = VGetPartition(node->command.sop.partName, 0);
612     if (!partP) {
613         Log("salvageServer: Unknown or unmounted partition %s; salvage aborted\n", 
614             node->command.sop.partName);
615         return 1;
616     }
617
618     /* Salvage individual volume; don't notify fs */
619     SalvageFileSys1(partP, node->command.sop.parent);
620
621     fclose(logFile);
622     return 0;
623 }
624
625
626 static void *
627 SalvageChildReaperThread(void * args)
628 {
629     int slot, pid, status;
630     struct log_cleanup_node * cleanup;
631
632     assert(pthread_mutex_lock(&worker_lock) == 0);
633
634     /* loop reaping our children */
635     while (1) {
636         /* wait() won't block unless we have children, so
637          * block on the cond var if we're childless */
638         while (current_workers == 0) {
639             assert(pthread_cond_wait(&worker_cv, &worker_lock) == 0);
640         }
641
642         assert(pthread_mutex_unlock(&worker_lock) == 0);
643
644         cleanup = (struct log_cleanup_node *) malloc(sizeof(struct log_cleanup_node));
645
646         while (Reap_Child("salvageserver", &pid, &status) < 0) {
647             /* try to prevent livelock if something goes wrong */
648             sleep(1);
649         }
650
651         VOL_LOCK;
652         for (slot = 0; slot < Parallel; slot++) {
653             if (child_slot[slot] == pid)
654                 break;
655         }
656         assert(slot < Parallel);
657         child_slot[slot] = 0;
658         VOL_UNLOCK;
659
660         SALVSYNC_doneWorkByPid(pid, status);
661
662         assert(pthread_mutex_lock(&worker_lock) == 0);
663
664         if (cleanup) {
665             cleanup->pid = pid;
666             queue_Append(&log_cleanup_queue, cleanup);
667             assert(pthread_cond_signal(&log_cleanup_queue.queue_change_cv) == 0);
668         }
669
670         /* ok, we've reaped a child */
671         current_workers--;
672         assert(pthread_cond_broadcast(&worker_cv) == 0);
673     }
674
675     return NULL;
676 }
677
678 static int
679 Reap_Child(char *prog, int * pid, int * status)
680 {
681     int ret;
682     ret = wait(status);
683
684     if (ret >= 0) {
685         *pid = ret;
686         if (WCOREDUMP(*status))
687             Log("\"%s\" core dumped!\n", prog);
688         if ((WIFSIGNALED(*status) != 0) ||
689             ((WEXITSTATUS(*status) != 0) &&
690              (WEXITSTATUS(*status) != SALSRV_EXIT_VOLGROUP_LINK)))
691             Log("\"%s\" (pid=%d) terminated abnormally!\n", prog, ret);
692     } else {
693         Log("wait returned -1\n");
694     }
695     return ret;
696 }
697
698 /*
699  * thread to combine salvager child logs
700  * back into the main salvageserver log
701  */
702 static void *
703 SalvageLogCleanupThread(void * arg)
704 {
705     struct log_cleanup_node * cleanup;
706
707     assert(pthread_mutex_lock(&worker_lock) == 0);
708
709     while (1) {
710         while (queue_IsEmpty(&log_cleanup_queue)) {
711             assert(pthread_cond_wait(&log_cleanup_queue.queue_change_cv, &worker_lock) == 0);
712         }
713
714         while (queue_IsNotEmpty(&log_cleanup_queue)) {
715             cleanup = queue_First(&log_cleanup_queue, log_cleanup_node);
716             queue_Remove(cleanup);
717             assert(pthread_mutex_unlock(&worker_lock) == 0);
718             SalvageLogCleanup(cleanup->pid);
719             free(cleanup);
720             assert(pthread_mutex_lock(&worker_lock) == 0);
721         }           
722     }
723
724     assert(pthread_mutex_unlock(&worker_lock) == 0);
725     return NULL;
726 }
727
728 #define LOG_XFER_BUF_SIZE 65536
729 static int
730 SalvageLogCleanup(int pid)
731 {
732     int pidlog, len;
733     char fn[AFSDIR_PATH_MAX];
734     static char buf[LOG_XFER_BUF_SIZE];
735
736     afs_snprintf(fn, sizeof(fn), "%s.%d", 
737                  AFSDIR_SERVER_SLVGLOG_FILEPATH, pid);
738     
739
740     pidlog = open(fn, O_RDONLY);
741     unlink(fn);
742     if (pidlog < 0)
743         return 1;
744
745     len = read(pidlog, buf, LOG_XFER_BUF_SIZE);
746     while (len) {
747         fwrite(buf, len, 1, logFile);
748         len = read(pidlog, buf, LOG_XFER_BUF_SIZE);
749     }
750
751     close(pidlog);
752
753     return 0;
754 }
755
756 /* wake up every five minutes to see if a non-child salvage has finished */
757 #define SALVAGE_SCAN_POLL_INTERVAL 300
758
759 /**
760  * Thread to look for SalvageLog.$pid files that are not from our child
761  * worker salvagers, and notify SalvageLogCleanupThread to clean them
762  * up. This can happen if we restart during salvages, or the
763  * salvageserver crashes or something.
764  *
765  * @param arg  unused
766  *
767  * @return always NULL
768  */
769 static void *
770 SalvageLogScanningThread(void * arg)
771 {
772     struct rx_queue log_watch_queue;
773
774     queue_Init(&log_watch_queue);
775
776     {
777         DIR *dp;
778         struct dirent *dirp;
779         char prefix[AFSDIR_PATH_MAX];
780         size_t prefix_len;
781
782         afs_snprintf(prefix, sizeof(prefix), "%s.", AFSDIR_SLVGLOG_FILE);
783         prefix_len = strlen(prefix);
784
785         dp = opendir(AFSDIR_LOGS_DIR);
786         assert(dp);
787
788         while ((dirp = readdir(dp)) != NULL) {
789             pid_t pid;
790             struct log_cleanup_node *cleanup;
791             int i;
792
793             if (strncmp(dirp->d_name, prefix, prefix_len) != 0) {
794                 /* not a salvage logfile; skip */
795                 continue;
796             }
797
798             errno = 0;
799             pid = strtol(dirp->d_name + prefix_len, NULL, 10);
800
801             if (errno != 0) {
802                 /* file is SalvageLog.<something> but <something> isn't
803                  * a pid, so skip */
804                  continue;
805             }
806
807             VOL_LOCK;
808             for (i = 0; i < Parallel; ++i) {
809                 if (pid == child_slot[i]) {
810                     break;
811                 }
812             }
813             VOL_UNLOCK;
814             if (i < Parallel) {
815                 /* this pid is one of our children, so the reaper thread
816                  * will take care of it; skip */
817                 continue;
818             }
819
820             cleanup =
821                 (struct log_cleanup_node *) malloc(sizeof(struct log_cleanup_node));
822             cleanup->pid = pid;
823
824             queue_Append(&log_watch_queue, cleanup);
825         }
826
827         closedir(dp);
828     }
829
830     ScanLogs(&log_watch_queue);
831
832     while (queue_IsNotEmpty(&log_watch_queue)) {
833         sleep(SALVAGE_SCAN_POLL_INTERVAL);
834         ScanLogs(&log_watch_queue);
835     }
836
837     return NULL;
838 }
839
840 /**
841  * look through log_watch_queue, and if any processes are not still
842  * running, hand them off to the SalvageLogCleanupThread
843  *
844  * @param log_watch_queue  a queue of PIDs that we should clean up if
845  * that PID has died
846  */
847 static void
848 ScanLogs(struct rx_queue *log_watch_queue)
849 {
850     struct log_cleanup_node *cleanup, *next;
851
852     assert(pthread_mutex_lock(&worker_lock) == 0);
853
854     for (queue_Scan(log_watch_queue, cleanup, next, log_cleanup_node)) {
855         /* if a process is still running, assume it's the salvage process
856          * still going, and keep waiting for it */
857         if (kill(cleanup->pid, 0) < 0 && errno == ESRCH) {
858             queue_Remove(cleanup);
859             queue_Append(&log_cleanup_queue, cleanup);
860             assert(pthread_cond_signal(&log_cleanup_queue.queue_change_cv) == 0);
861         }
862     }
863
864     assert(pthread_mutex_unlock(&worker_lock) == 0);
865 }