util: Tidy header includes
[openafs.git] / src / vol / salvager.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 /*
11  *      System:         VICE-TWO
12  *      Module:         salvager.c
13  *      Institution:    The Information Technology Center, Carnegie-Mellon University
14  */
15
16
17 /* Main program file. Define globals. */
18 #define MAIN 1
19
20 #include <afsconfig.h>
21 #include <afs/param.h>
22
23 #include <afs/procmgmt.h>
24 #include <roken.h>
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <dirent.h>
30 #include <sys/stat.h>
31 #include <time.h>
32 #include <errno.h>
33 #ifdef AFS_NT40_ENV
34 #include <io.h>
35 #include <WINNT/afsevent.h>
36 #else
37 #include <sys/param.h>
38 #include <sys/file.h>
39 #ifndef ITIMER_REAL
40 #include <sys/time.h>
41 #endif /* ITIMER_REAL */
42 #endif
43 #ifndef WCOREDUMP
44 #define WCOREDUMP(x)    ((x) & 0200)
45 #endif
46 #include <rx/xdr.h>
47 #include <afs/afsint.h>
48 #include <afs/afs_assert.h>
49 #if !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV)
50 #if defined(AFS_VFSINCL_ENV)
51 #include <sys/vnode.h>
52 #ifdef  AFS_SUN5_ENV
53 #include <sys/fs/ufs_inode.h>
54 #else
55 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
56 #include <ufs/ufs/dinode.h>
57 #include <ufs/ffs/fs.h>
58 #else
59 #include <ufs/inode.h>
60 #endif
61 #endif
62 #else /* AFS_VFSINCL_ENV */
63 #ifdef  AFS_OSF_ENV
64 #include <ufs/inode.h>
65 #else /* AFS_OSF_ENV */
66 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_XBSD_ENV) && !defined(AFS_ARM_DARWIN_ENV)
67 #include <sys/inode.h>
68 #endif
69 #endif
70 #endif /* AFS_VFSINCL_ENV */
71 #endif /* AFS_SGI_ENV */
72 #ifdef  AFS_AIX_ENV
73 #include <sys/vfs.h>
74 #include <sys/lockf.h>
75 #else
76 #ifdef  AFS_HPUX_ENV
77 #include <unistd.h>
78 #include <checklist.h>
79 #else
80 #if defined(AFS_SGI_ENV)
81 #include <unistd.h>
82 #include <fcntl.h>
83 #include <mntent.h>
84 #else
85 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
86 #ifdef    AFS_SUN5_ENV
87 #include <unistd.h>
88 #include <sys/mnttab.h>
89 #include <sys/mntent.h>
90 #else
91 #include <mntent.h>
92 #endif
93 #else
94 #endif /* AFS_SGI_ENV */
95 #endif /* AFS_HPUX_ENV */
96 #endif
97 #endif
98 #include <fcntl.h>
99 #ifndef AFS_NT40_ENV
100 #include <afs/osi_inode.h>
101 #endif
102 #include <afs/cmd.h>
103 #include <afs/dir.h>
104 #include <afs/afsutil.h>
105 #include <afs/fileutil.h>
106 #ifndef AFS_NT40_ENV
107 #include <syslog.h>
108 #endif
109
110 #include "nfs.h"
111 #include "lwp.h"
112 #include "lock.h"
113 #include <afs/afssyscalls.h>
114 #include "ihandle.h"
115 #include "vnode.h"
116 #include "volume.h"
117 #include "partition.h"
118 #include "daemon_com.h"
119 #include "fssync.h"
120 #include "salvsync.h"
121 #include "viceinode.h"
122 #include "salvage.h"
123 #include "vol-salvage.h"
124 #include "common.h"
125 #ifdef AFS_NT40_ENV
126 #include <pthread.h>
127 pthread_t main_thread;
128 #endif
129
130 static int get_salvage_lock = 0;
131
132 static int
133 handleit(struct cmd_syndesc *as, void *arock)
134 {
135     struct cmd_item *ti;
136     char pname[100], *temp;
137     afs_int32 seenpart = 0, seenvol = 0;
138     VolumeId vid = 0;
139     ProgramType pt;
140
141 #ifdef FAST_RESTART
142     afs_int32  seenany = 0;
143 #endif
144
145     VolumePackageOptions opts;
146     struct DiskPartition64 *partP;
147
148 #ifdef AFS_SGI_VNODE_GLUE
149     if (afs_init_kernel_config(-1) < 0) {
150         printf
151             ("Can't determine NUMA configuration, not starting salvager.\n");
152         exit(1);
153     }
154 #endif
155
156 #ifdef FAST_RESTART
157     {
158         afs_int32 i;
159         for (i = 0; i < CMD_MAXPARMS; i++) {
160             if (as->parms[i].items) {
161                 seenany = 1;
162                 break;
163             }
164         }
165     }
166     if (!seenany) {
167         char *msg =
168             "Exiting immediately without salvage. Look into the FileLog to find volumes which really need to be salvaged!";
169
170 #ifndef AFS_NT40_ENV
171         if (useSyslog)
172             Log(msg);
173         else
174 #endif
175             printf("%s\n", msg);
176
177         Exit(0);
178     }
179 #endif /* FAST_RESTART */
180     if ((ti = as->parms[0].items)) {    /* -partition */
181         seenpart = 1;
182         strncpy(pname, ti->data, 100);
183     }
184     if ((ti = as->parms[1].items)) {    /* -volumeid */
185         char *end;
186         unsigned long vid_l;
187         if (!seenpart) {
188             printf
189                 ("You must also specify '-partition' option with the '-volumeid' option\n");
190             exit(-1);
191         }
192         seenvol = 1;
193         vid_l = strtoul(ti->data, &end, 10);
194         if (vid_l >= MAX_AFS_UINT32 || vid_l == ULONG_MAX || *end != '\0') {
195             Log("salvage: invalid volume id specified; salvage aborted\n");
196             Exit(1);
197         }
198         vid = (VolumeId)vid_l;
199     }
200     if (as->parms[2].items)     /* -debug */
201         debug = 1;
202     if (as->parms[3].items)     /* -nowrite */
203         Testing = 1;
204     if (as->parms[4].items)     /* -inodes */
205         ListInodeOption = 1;
206     if (as->parms[5].items || as->parms[21].items)      /* -force, -f */
207         ForceSalvage = 1;
208     if (as->parms[6].items)     /* -oktozap */
209         OKToZap = 1;
210     if (as->parms[7].items)     /* -rootinodes */
211         ShowRootFiles = 1;
212     if (as->parms[8].items)     /* -RebuildDirs */
213         RebuildDirs = 1;
214     if (as->parms[9].items)     /* -ForceReads */
215         forceR = 1;
216     if ((ti = as->parms[10].items)) {   /* -Parallel # */
217         temp = ti->data;
218         if (strncmp(temp, "all", 3) == 0) {
219             PartsPerDisk = 1;
220             temp += 3;
221         }
222         if (strlen(temp) != 0) {
223             Parallel = atoi(temp);
224             if (Parallel < 1)
225                 Parallel = 1;
226             if (Parallel > MAXPARALLEL) {
227                 printf("Setting parallel salvages to maximum of %d \n",
228                        MAXPARALLEL);
229                 Parallel = MAXPARALLEL;
230             }
231         }
232     }
233     if ((ti = as->parms[11].items)) {   /* -tmpdir */
234         DIR *dirp;
235
236         tmpdir = ti->data;
237         dirp = opendir(tmpdir);
238         if (!dirp) {
239             printf
240                 ("Can't open temporary placeholder dir %s; using current partition \n",
241                  tmpdir);
242             tmpdir = NULL;
243         } else
244             closedir(dirp);
245     }
246     if ((ti = as->parms[12].items))     /* -showlog */
247         ShowLog = 1;
248     if ((ti = as->parms[13].items)) {   /* -log */
249         Testing = 1;
250         ShowSuid = 1;
251         Showmode = 1;
252     }
253     if ((ti = as->parms[14].items)) {   /* -showmounts */
254         Testing = 1;
255         Showmode = 1;
256         ShowMounts = 1;
257     }
258     if ((ti = as->parms[15].items)) {   /* -orphans */
259         if (Testing)
260             orphans = ORPH_IGNORE;
261         else if (strcmp(ti->data, "remove") == 0
262                  || strcmp(ti->data, "r") == 0)
263             orphans = ORPH_REMOVE;
264         else if (strcmp(ti->data, "attach") == 0
265                  || strcmp(ti->data, "a") == 0)
266             orphans = ORPH_ATTACH;
267     }
268 #ifndef AFS_NT40_ENV            /* ignore options on NT */
269     if ((ti = as->parms[16].items)) {   /* -syslog */
270         useSyslog = 1;
271         ShowLog = 0;
272     }
273     if ((ti = as->parms[17].items)) {   /* -syslogfacility */
274         useSyslogFacility = atoi(ti->data);
275     }
276
277     if ((ti = as->parms[18].items)) {   /* -datelogs */
278       TimeStampLogFile((char *)AFSDIR_SERVER_SLVGLOG_FILEPATH);
279     }
280 #endif
281
282 #ifdef FAST_RESTART
283     if (ti = as->parms[19].items) {     /* -DontSalvage */
284         char *msg =
285             "Exiting immediately without salvage. Look into the FileLog to find volumes which really need to be salvaged!";
286
287 #ifndef AFS_NT40_ENV
288         if (useSyslog)
289             Log(msg);
290         else
291 #endif
292             printf("%s\n", msg);
293         Exit(0);
294     }
295 #endif
296
297     /* Note:  if seenvol we initialize this as a standard volume utility:  this has the
298      * implication that the file server may be running; negotations have to be made with
299      * the file server in this case to take the read write volume and associated read-only
300      * volumes off line before salvaging */
301 #ifdef AFS_NT40_ENV
302     if (seenvol) {
303         if (afs_winsockInit() < 0) {
304             ReportErrorEventAlt(AFSEVT_SVR_WINSOCK_INIT_FAILED, 0,
305                                 AFSDIR_SALVAGER_FILE, 0);
306             Log("Failed to initailize winsock, exiting.\n");
307             Exit(1);
308         }
309     }
310 #endif
311
312     if (seenvol) {
313         pt = volumeSalvager;
314     } else {
315         pt = salvager;
316     }
317
318     VOptDefaults(pt, &opts);
319     if (VInitVolumePackage2(pt, &opts)) {
320         Log("errors encountered initializing volume package; salvage aborted\n");
321         Exit(1);
322     }
323
324     /* defer lock until we init volume package */
325     if (get_salvage_lock) {
326         if (seenvol && AskDAFS()) /* support forceDAFS */
327             ObtainSharedSalvageLock();
328         else
329             ObtainSalvageLock();
330     }
331
332     /*
333      * Ok to defer this as Exit will clean up and no real work is done
334      * init'ing volume package
335      */
336     if (seenvol) {
337         char *msg = NULL;
338 #ifdef AFS_DEMAND_ATTACH_FS
339         if (!AskDAFS()) {
340             msg =
341                 "The DAFS dasalvager cannot be run with a non-DAFS fileserver.  Please use 'salvager'.";
342         }
343         if (!msg && !as->parms[20].items) {
344             msg =
345                 "The standalone salvager cannot be run concurrently with a Demand Attach Fileserver.  Please use 'salvageserver -client <partition> <volume id>' to manually schedule volume salvages with the salvageserver (new versions of 'bos salvage' automatically do this for you).  Or, if you insist on using the standalone salvager, add the -forceDAFS flag to your salvager command line.";
346         }
347 #else
348         if (AskDAFS()) {
349             msg =
350                 "The non-DAFS salvager cannot be run with a Demand Attach Fileserver.  Please use 'salvageserver -client <partition> <volume id>' to manually schedule volume salvages with the salvageserver (new versions of 'bos salvage' automatically do this for you).  Or, if you insist on using the standalone salvager, run dasalvager with the -forceDAFS flag.";
351         }
352 #endif
353
354         if (msg) {
355 #ifndef AFS_NT40_ENV
356             if (useSyslog)
357                 Log("%s", msg);
358             else
359 #endif
360                 printf("%s\n", msg);
361             Exit(1);
362         }
363     }
364
365     DInit(10);
366 #ifdef AFS_NT40_ENV
367     if (myjob.cj_number != NOT_CHILD) {
368         if (!seenpart) {
369             seenpart = 1;
370             (void)strcpy(pname, myjob.cj_part);
371         }
372     }
373 #endif
374     if (seenpart == 0) {
375         for (partP = DiskPartitionList; partP; partP = partP->next) {
376             SalvageFileSysParallel(partP);
377         }
378         SalvageFileSysParallel(0);
379     } else {
380         partP = VGetPartition(pname, 0);
381         if (!partP) {
382             Log("salvage: Unknown or unmounted partition %s; salvage aborted\n", pname);
383             Exit(1);
384         }
385         if (!seenvol)
386             SalvageFileSys(partP, 0);
387         else {
388             /* Salvage individual volume */
389             SalvageFileSys(partP, vid);
390         }
391     }
392     return (0);
393 }
394
395
396 #ifndef AFS_NT40_ENV
397 #include "AFS_component_version_number.c"
398 #endif
399
400 int
401 main(int argc, char **argv)
402 {
403     struct cmd_syndesc *ts;
404     int err = 0;
405
406     extern char cml_version_number[];
407
408 #ifdef  AFS_AIX32_ENV
409     /*
410      * The following signal action for AIX is necessary so that in case of a
411      * crash (i.e. core is generated) we can include the user's data section
412      * in the core dump. Unfortunately, by default, only a partial core is
413      * generated which, in many cases, isn't too useful.
414      */
415     struct sigaction nsa;
416
417     sigemptyset(&nsa.sa_mask);
418     nsa.sa_handler = SIG_DFL;
419     nsa.sa_flags = SA_FULLDUMP;
420     sigaction(SIGABRT, &nsa, NULL);
421     sigaction(SIGSEGV, &nsa, NULL);
422 #endif
423
424     /* Initialize directory paths */
425     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
426 #ifdef AFS_NT40_ENV
427         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
428 #endif
429         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
430                 argv[0]);
431         exit(2);
432     }
433 #ifdef AFS_NT40_ENV
434     /* Default to binary mode for fopen() */
435     _set_fmode(_O_BINARY);
436
437     main_thread = pthread_self();
438     if (spawnDatap && spawnDataLen) {
439         /* This is a child per partition salvager. Don't setup log or
440          * try to lock the salvager lock.
441          */
442         if (nt_SetupPartitionSalvage(spawnDatap, spawnDataLen) < 0)
443             exit(3);
444     } else {
445 #endif
446         /* All entries to the log will be appended.  Useful if there are
447          * multiple salvagers appending to the log.
448          */
449
450         CheckLogFile((char *)AFSDIR_SERVER_SLVGLOG_FILEPATH);
451 #ifndef AFS_NT40_ENV
452 #ifdef AFS_LINUX20_ENV
453         fcntl(fileno(logFile), F_SETFL, O_APPEND);      /* Isn't this redundant? */
454 #else
455         fcntl(fileno(logFile), F_SETFL, FAPPEND);       /* Isn't this redundant? */
456 #endif
457 #endif
458         setlinebuf(logFile);
459
460 #ifndef AFS_NT40_ENV
461         if (geteuid() != 0) {
462             printf("Salvager must be run as root.\n");
463             fflush(stdout);
464             Exit(0);
465         }
466 #endif
467
468         /* bad for normal help flag processing, but can do nada */
469
470         fprintf(logFile, "%s\n", cml_version_number);
471         LogCommandLine(argc, argv, "SALVAGER", SalvageVersion, "STARTING AFS",
472                        Log);
473
474         /* Get and hold a lock for the duration of the salvage to make sure
475          * that no other salvage runs at the same time.  The routine
476          * VInitVolumePackage2 (called below) makes sure that a file server or
477          * other volume utilities don't interfere with the salvage.
478          */
479         get_salvage_lock = 1;
480 #ifdef AFS_NT40_ENV
481     }
482 #endif
483
484     ts = cmd_CreateSyntax("initcmd", handleit, NULL, "initialize the program");
485     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
486                 "Name of partition to salvage");
487     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, CMD_OPTIONAL,
488                 "Volume Id to salvage");
489     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
490                 "Run in Debugging mode");
491     cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
492                 "Run readonly/test mode");
493     cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
494                 "Just list affected afs inodes - debugging flag");
495     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "Force full salvaging");
496     cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
497                 "Give permission to destroy bogus inodes/volumes - debugging flag");
498     cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
499                 "Show inodes owned by root - debugging flag");
500     cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
501                 "Force rebuild/salvage of all directories");
502     cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
503                 "Read smaller blocks to handle IO/bad blocks");
504     cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
505                 "# of max parallel partition salvaging");
506     cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
507                 "Name of dir to place tmp files ");
508     cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
509                 "Show log file upon completion");
510     cmd_AddParm(ts, "-showsuid", CMD_FLAG, CMD_OPTIONAL,
511                 "Report on suid/sgid files");
512     cmd_AddParm(ts, "-showmounts", CMD_FLAG, CMD_OPTIONAL,
513                 "Report on mountpoints");
514     cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
515                 "ignore | remove | attach");
516
517     /* note - syslog isn't avail on NT, but if we make it conditional, have
518      * to deal with screwy offsets for cmd params */
519     cmd_AddParm(ts, "-syslog", CMD_FLAG, CMD_OPTIONAL,
520                 "Write salvage log to syslogs");
521     cmd_AddParm(ts, "-syslogfacility", CMD_SINGLE, CMD_OPTIONAL,
522                 "Syslog facility number to use");
523     cmd_AddParm(ts, "-datelogs", CMD_FLAG, CMD_OPTIONAL,
524                 "Include timestamp in logfile filename");
525 #ifdef FAST_RESTART
526     cmd_AddParm(ts, "-DontSalvage", CMD_FLAG, CMD_OPTIONAL,
527                 "Don't salvage. This my be set in BosConfig to let the fileserver restart immediately after a crash. Bad volumes will be taken offline");
528 #elif defined(AFS_DEMAND_ATTACH_FS)
529     cmd_Seek(ts, 20); /* skip DontSalvage */
530     cmd_AddParm(ts, "-forceDAFS", CMD_FLAG, CMD_OPTIONAL,
531                 "For Demand Attach Fileserver, permit a manual volume salvage outside of the salvageserver");
532 #endif /* FAST_RESTART */
533     cmd_Seek(ts, 21); /* skip DontSalvage and forceDAFS if needed */
534     cmd_AddParm(ts, "-f", CMD_FLAG, CMD_OPTIONAL, "Alias for -force");
535     err = cmd_Dispatch(argc, argv);
536     Exit(err);
537     return 0; /* not reached */
538 }
539