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 RCSID
  24     ("$Header$");
  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 #if     defined(AFS_AIX_ENV) || defined(AFS_SUN4_ENV)
  44 #define WCOREDUMP(x)    (x & 0200)
  45 #endif
  46 #include <rx/xdr.h>
  47 #include <afs/afsint.h>
  48 #include <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)
  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/afsutil.h>
 104 #include <afs/fileutil.h>
 105 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
 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 "volinodes.h"          /* header magic number, etc. stuff */
 124 #include "vol-salvage.h"
 125 #ifdef AFS_NT40_ENV
 126 #include <pthread.h>
 127 #endif
 128
 129
 130 static int get_salvage_lock = 0;
 131
 132
 133 /* Forward declarations */
 134 /*@printflike@*/ void Log(const char *format, ...);
 135 /*@printflike@*/ void Abort(const char *format, ...);
 136
 137
 138 static int
 139 handleit(struct cmd_syndesc *as)
 140 {
 141     register struct cmd_item *ti;
 142     char pname[100], *temp;
 143     afs_int32 seenpart = 0, seenvol = 0, vid = 0, seenany = 0;
 144     struct DiskPartition *partP;
 145
 146 #ifdef AFS_SGI_VNODE_GLUE
 147     if (afs_init_kernel_config(-1) < 0) {
 148         printf
 149             ("Can't determine NUMA configuration, not starting salvager.\n");
 150         exit(1);
 151     }
 152 #endif
 153
 154 #ifdef FAST_RESTART
 155     {
 156         afs_int32 i;
 157         for (i = 0; i < CMD_MAXPARMS; i++) {
 158             if (as->parms[i].items) {
 159                 seenany = 1;
 160                 break;
 161             }
 162         }
 163     }
 164     if (!seenany) {
 165         char *msg =
 166             "Exiting immediately without salvage. Look into the FileLog to find volumes which really need to be salvaged!";
 167
 168         if (useSyslog)
 169             Log(msg);
 170         else
 171             printf("%s\n", msg);
 172
 173         Exit(0);
 174     }
 175 #endif /* FAST_RESTART */
 176     if ((ti = as->parms[0].items)) {    /* -partition */
 177         seenpart = 1;
 178         strncpy(pname, ti->data, 100);
 179     }
 180     if ((ti = as->parms[1].items)) {    /* -volumeid */
 181         if (!seenpart) {
 182             printf
 183                 ("You must also specify '-partition' option with the '-volumeid' option\n");
 184             exit(-1);
 185         }
 186         seenvol = 1;
 187         vid = atoi(ti->data);
 188     }
 189     if (as->parms[2].items)     /* -debug */
 190         debug = 1;
 191     if (as->parms[3].items)     /* -nowrite */
 192         Testing = 1;
 193     if (as->parms[4].items)     /* -inodes */
 194         ListInodeOption = 1;
 195     if (as->parms[5].items)     /* -force */
 196         ForceSalvage = 1;
 197     if (as->parms[6].items)     /* -oktozap */
 198         OKToZap = 1;
 199     if (as->parms[7].items)     /* -rootinodes */
 200         ShowRootFiles = 1;
 201     if (as->parms[8].items)     /* -RebuildDirs */
 202         RebuildDirs = 1;
 203     if (as->parms[9].items)     /* -ForceReads */
 204         forceR = 1;
 205     if ((ti = as->parms[10].items)) {   /* -Parallel # */
 206         temp = ti->data;
 207         if (strncmp(temp, "all", 3) == 0) {
 208             PartsPerDisk = 1;
 209             temp += 3;
 210         }
 211         if (strlen(temp) != 0) {
 212             Parallel = atoi(temp);
 213             if (Parallel < 1)
 214                 Parallel = 1;
 215             if (Parallel > MAXPARALLEL) {
 216                 printf("Setting parallel salvages to maximum of %d \n",
 217                        MAXPARALLEL);
 218                 Parallel = MAXPARALLEL;
 219             }
 220         }
 221     }
 222     if ((ti = as->parms[11].items)) {   /* -tmpdir */
 223         DIR *dirp;
 224
 225         tmpdir = ti->data;
 226         dirp = opendir(tmpdir);
 227         if (!dirp) {
 228             printf
 229                 ("Can't open temporary placeholder dir %s; using current partition \n",
 230                  tmpdir);
 231             tmpdir = NULL;
 232         } else
 233             closedir(dirp);
 234     }
 235     if ((ti = as->parms[12].items))     /* -showlog */
 236         ShowLog = 1;
 237     if ((ti = as->parms[13].items)) {   /* -log */
 238         Testing = 1;
 239         ShowSuid = 1;
 240         Showmode = 1;
 241     }
 242     if ((ti = as->parms[14].items)) {   /* -showmounts */
 243         Testing = 1;
 244         Showmode = 1;
 245         ShowMounts = 1;
 246     }
 247     if ((ti = as->parms[15].items)) {   /* -orphans */
 248         if (Testing)
 249             orphans = ORPH_IGNORE;
 250         else if (strcmp(ti->data, "remove") == 0
 251                  || strcmp(ti->data, "r") == 0)
 252             orphans = ORPH_REMOVE;
 253         else if (strcmp(ti->data, "attach") == 0
 254                  || strcmp(ti->data, "a") == 0)
 255             orphans = ORPH_ATTACH;
 256     }
 257 #ifndef AFS_NT40_ENV            /* ignore options on NT */
 258     if ((ti = as->parms[16].items)) {   /* -syslog */
 259         useSyslog = 1;
 260         ShowLog = 0;
 261     }
 262     if ((ti = as->parms[17].items)) {   /* -syslogfacility */
 263         useSyslogFacility = atoi(ti->data);
 264     }
 265
 266     if ((ti = as->parms[18].items)) {   /* -datelogs */
 267         TimeStampLogFile(AFSDIR_SERVER_SLVGLOG_FILEPATH);
 268     }
 269 #endif
 270
 271 #ifdef FAST_RESTART
 272     if (ti = as->parms[19].items) {     /* -DontSalvage */
 273         char *msg =
 274             "Exiting immediately without salvage. Look into the FileLog to find volumes which really need to be salvaged!";
 275
 276         if (useSyslog)
 277             Log(msg);
 278         else
 279             printf("%s\n", msg);
 280         Exit(0);
 281     }
 282 #elif defined(DEMAND_ATTACH_ENABLE)
 283     if (seenvol && !as->parms[19].items) {
 284         char * msg =
 285             "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.";
 286
 287         if (useSyslog)
 288             Log(msg);
 289         else
 290             printf("%s\n", msg);
 291         Exit(1);
 292     }
 293 #endif
 294
 295     if (get_salvage_lock) {
 296         ObtainSalvageLock();
 297     }
 298
 299     /* Note:  if seenvol we initialize this as a standard volume utility:  this has the
 300      * implication that the file server may be running; negotations have to be made with
 301      * the file server in this case to take the read write volume and associated read-only
 302      * volumes off line before salvaging */
 303 #ifdef AFS_NT40_ENV
 304     if (seenvol) {
 305         if (afs_winsockInit() < 0) {
 306             ReportErrorEventAlt(AFSEVT_SVR_WINSOCK_INIT_FAILED, 0,
 307                                 AFSDIR_SALVAGER_FILE, 0);
 308             Log("Failed to initailize winsock, exiting.\n");
 309             Exit(1);
 310         }
 311     }
 312 #endif
 313     VInitVolumePackage(seenvol ? volumeUtility : salvager, 5, 5,
 314                        DONT_CONNECT_FS, 0);
 315     DInit(10);
 316 #ifdef AFS_NT40_ENV
 317     if (myjob.cj_number != NOT_CHILD) {
 318         if (!seenpart) {
 319             seenpart = 1;
 320             (void)strcpy(pname, myjob.cj_part);
 321         }
 322     }
 323 #endif
 324     if (seenpart == 0) {
 325         for (partP = DiskPartitionList; partP; partP = partP->next) {
 326             SalvageFileSysParallel(partP);
 327         }
 328         SalvageFileSysParallel(0);
 329     } else {
 330         partP = VGetPartition(pname, 0);
 331         if (!partP) {
 332             Log("salvage: Unknown or unmounted partition %s; salvage aborted\n", pname);
 333             Exit(1);
 334         }
 335         if (!seenvol)
 336             SalvageFileSys(partP, 0);
 337         else {
 338             /* Salvage individual volume */
 339             if (vid <= 0) {
 340                 Log("salvage: invalid volume id specified; salvage aborted\n");
 341                 Exit(1);
 342             }
 343             SalvageFileSys(partP, vid);
 344         }
 345     }
 346     return (0);
 347 }
 348
 349
 350 #ifndef AFS_NT40_ENV
 351 #include "AFS_component_version_number.c"
 352 #endif
 353 #define MAX_ARGS 128
 354 #ifdef AFS_NT40_ENV
 355 char *save_args[MAX_ARGS];
 356 int n_save_args = 0;
 357 pthread_t main_thread;
 358 #endif
 359
 360 int
 361 main(int argc, char **argv)
 362 {
 363     struct cmd_syndesc *ts;
 364     int err = 0;
 365     char commandLine[150];
 366
 367     int i;
 368     extern char cml_version_number[];
 369
 370 #ifdef  AFS_AIX32_ENV
 371     /*
 372      * The following signal action for AIX is necessary so that in case of a
 373      * crash (i.e. core is generated) we can include the user's data section
 374      * in the core dump. Unfortunately, by default, only a partial core is
 375      * generated which, in many cases, isn't too useful.
 376      */
 377     struct sigaction nsa;
 378
 379     sigemptyset(&nsa.sa_mask);
 380     nsa.sa_handler = SIG_DFL;
 381     nsa.sa_flags = SA_FULLDUMP;
 382     sigaction(SIGABRT, &nsa, NULL);
 383     sigaction(SIGSEGV, &nsa, NULL);
 384 #endif
 385
 386     /* Initialize directory paths */
 387     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
 388 #ifdef AFS_NT40_ENV
 389         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
 390 #endif
 391         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
 392                 argv[0]);
 393         exit(2);
 394     }
 395 #ifdef AFS_NT40_ENV
 396     main_thread = pthread_self();
 397     if (spawnDatap && spawnDataLen) {
 398         /* This is a child per partition salvager. Don't setup log or
 399          * try to lock the salvager lock.
 400          */
 401         if (nt_SetupPartitionSalvage(spawnDatap, spawnDataLen) < 0)
 402             exit(3);
 403     } else {
 404 #endif
 405         for (commandLine[0] = '\0', i = 0; i < argc; i++) {
 406             if (i > 0)
 407                 strcat(commandLine, " ");
 408             strcat(commandLine, argv[i]);
 409         }
 410
 411         /* All entries to the log will be appended.  Useful if there are
 412          * multiple salvagers appending to the log.
 413          */
 414
 415         CheckLogFile(AFSDIR_SERVER_SLVGLOG_FILEPATH);
 416 #ifndef AFS_NT40_ENV
 417 #ifdef AFS_LINUX20_ENV
 418         fcntl(fileno(logFile), F_SETFL, O_APPEND);      /* Isn't this redundant? */
 419 #else
 420         fcntl(fileno(logFile), F_SETFL, FAPPEND);       /* Isn't this redundant? */
 421 #endif
 422 #endif
 423         setlinebuf(logFile);
 424
 425 #ifndef AFS_NT40_ENV
 426         if (geteuid() != 0) {
 427             printf("Salvager must be run as root.\n");
 428             fflush(stdout);
 429             Exit(0);
 430         }
 431 #endif
 432
 433         /* bad for normal help flag processing, but can do nada */
 434
 435         fprintf(logFile, "%s\n", cml_version_number);
 436         Log("STARTING AFS SALVAGER %s (%s)\n", SalvageVersion, commandLine);
 437
 438         /* Get and hold a lock for the duration of the salvage to make sure
 439          * that no other salvage runs at the same time.  The routine
 440          * VInitVolumePackage (called below) makes sure that a file server or
 441          * other volume utilities don't interfere with the salvage.
 442          */
 443         get_salvage_lock = 1;
 444 #ifdef AFS_NT40_ENV
 445     }
 446 #endif
 447
 448     ts = cmd_CreateSyntax("initcmd", handleit, 0, "initialize the program");
 449     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
 450                 "Name of partition to salvage");
 451     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, CMD_OPTIONAL,
 452                 "Volume Id to salvage");
 453     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
 454                 "Run in Debugging mode");
 455     cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
 456                 "Run readonly/test mode");
 457     cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
 458                 "Just list affected afs inodes - debugging flag");
 459     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "Force full salvaging");
 460     cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
 461                 "Give permission to destroy bogus inodes/volumes - debugging flag");
 462     cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
 463                 "Show inodes owned by root - debugging flag");
 464     cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
 465                 "Force rebuild/salvage of all directories");
 466     cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
 467                 "Read smaller blocks to handle IO/bad blocks");
 468     cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
 469                 "# of max parallel partition salvaging");
 470     cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
 471                 "Name of dir to place tmp files ");
 472     cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
 473                 "Show log file upon completion");
 474     cmd_AddParm(ts, "-showsuid", CMD_FLAG, CMD_OPTIONAL,
 475                 "Report on suid/sgid files");
 476     cmd_AddParm(ts, "-showmounts", CMD_FLAG, CMD_OPTIONAL,
 477                 "Report on mountpoints");
 478     cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
 479                 "ignore | remove | attach");
 480
 481     /* note - syslog isn't avail on NT, but if we make it conditional, have
 482      * to deal with screwy offsets for cmd params */
 483     cmd_AddParm(ts, "-syslog", CMD_FLAG, CMD_OPTIONAL,
 484                 "Write salvage log to syslogs");
 485     cmd_AddParm(ts, "-syslogfacility", CMD_SINGLE, CMD_OPTIONAL,
 486                 "Syslog facility number to use");
 487     cmd_AddParm(ts, "-datelogs", CMD_FLAG, CMD_OPTIONAL,
 488                 "Include timestamp in logfile filename");
 489 #ifdef FAST_RESTART
 490     cmd_AddParm(ts, "-DontSalvage", CMD_FLAG, CMD_OPTIONAL,
 491                 "Don't salvage. This my be set in BosConfig to let the fileserver restart immediately after a crash. Bad volumes will be taken offline");
 492 #elif defined(DEMAND_ATTACH_ENABLE)
 493     cmd_AddParm(ts, "-forceDAFS", CMD_FLAG, CMD_OPTIONAL,
 494                 "For Demand Attach Fileserver, permit a manual volume salvage outside of the salvageserver");
 495 #endif /* FAST_RESTART */
 496     err = cmd_Dispatch(argc, argv);
 497     Exit(err);
 498 }
 499