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