src/volser/vol-dump.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:              vol-dump.c
  13    Institution: The Information Technology Center, Carnegie-Mellon University
  14
  15    */
  16
  17 #include <afsconfig.h>
  18 #include <afs/param.h>
  19
  20 #ifdef IGNORE_SOME_GCC_WARNINGS
  21 # pragma GCC diagnostic warning "-Wformat"
  22 #endif
  23
  24 #include <roken.h>
  25
  26 #include <ctype.h>
  27
  28 #include <afs/cmd.h>
  29 #include <rx/xdr.h>
  30 #include <rx/rx_queue.h>
  31 #include <afs/afsint.h>
  32 #include <afs/nfs.h>
  33 #include <afs/errors.h>
  34 #include <lock.h>
  35 #include <lwp.h>
  36 #include <afs/afssyscalls.h>
  37 #include <afs/ihandle.h>
  38 #include <afs/vnode.h>
  39 #include <afs/volume.h>
  40 #include <afs/partition.h>
  41 #include <afs/viceinode.h>
  42 #include <afs/afssyscalls.h>
  43 #include <afs/acl.h>
  44 #include <afs/dir.h>
  45 #include <afs/com_err.h>
  46
  47 #include "volser.h"
  48 #include "volint.h"
  49 #include "dump.h"
  50
  51 #define afs_putint32(p, v)  *p++ = v>>24, *p++ = v>>16, *p++ = v>>8, *p++ = v
  52 #define afs_putshort(p, v) *p++ = v>>8, *p++ = v
  53
  54 int VolumeChanged;              /* needed by physio - leave alone */
  55 int verbose = 0;
  56
  57 /* Forward Declarations */
  58 static void HandleVolume(struct DiskPartition64 *partP, char *name,
  59                          char *filename, int fromtime);
  60 static Volume *AttachVolume(struct DiskPartition64 *dp, char *volname,
  61                             struct VolumeHeader *header);
  62 static void DoMyVolDump(Volume * vp, struct DiskPartition64 *dp,
  63                         char *dumpfile, int fromtime);
  64
  65 #ifndef AFS_NT40_ENV
  66 #include "AFS_component_version_number.c"
  67 #endif
  68
  69 char name[VMAXPATHLEN];
  70
  71
  72 static int
  73 ReadHdr1(IHandle_t * ih, char *to, int size, u_int magic, u_int version)
  74 {
  75     int code;
  76
  77     code = IH_IREAD(ih, 0, to, size);
  78     if (code != size)
  79         return -1;
  80
  81     return 0;
  82 }
  83
  84
  85 static Volume *
  86 AttachVolume(struct DiskPartition64 * dp, char *volname,
  87              struct VolumeHeader * header)
  88 {
  89     Volume *vp;
  90     afs_int32 ec = 0;
  91
  92     vp = (Volume *) calloc(1, sizeof(Volume));
  93     vp->specialStatus = 0;
  94     vp->device = dp->device;
  95     vp->partition = dp;
  96     IH_INIT(vp->vnodeIndex[vLarge].handle, dp->device, header->parent,
  97             header->largeVnodeIndex);
  98     IH_INIT(vp->vnodeIndex[vSmall].handle, dp->device, header->parent,
  99             header->smallVnodeIndex);
 100     IH_INIT(vp->diskDataHandle, dp->device, header->parent,
 101             header->volumeInfo);
 102     IH_INIT(V_linkHandle(vp), dp->device, header->parent, header->linkTable);
 103     vp->cacheCheck = 0;         /* XXXX */
 104     vp->shuttingDown = 0;
 105     vp->goingOffline = 0;
 106     vp->nUsers = 1;
 107     vp->header = calloc(1, sizeof(*vp->header));
 108     ec = ReadHdr1(V_diskDataHandle(vp), (char *)&V_disk(vp),
 109                   sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
 110     if (!ec) {
 111         struct IndexFileHeader iHead;
 112         ec = ReadHdr1(vp->vnodeIndex[vSmall].handle, (char *)&iHead,
 113                       sizeof(iHead), SMALLINDEXMAGIC, SMALLINDEXVERSION);
 114     }
 115     if (!ec) {
 116         struct IndexFileHeader iHead;
 117         ec = ReadHdr1(vp->vnodeIndex[vLarge].handle, (char *)&iHead,
 118                       sizeof(iHead), LARGEINDEXMAGIC, LARGEINDEXVERSION);
 119     }
 120 #ifdef AFS_NAMEI_ENV
 121     if (!ec) {
 122         struct versionStamp stamp;
 123         ec = ReadHdr1(V_linkHandle(vp), (char *)&stamp, sizeof(stamp),
 124                       LINKTABLEMAGIC, LINKTABLEVERSION);
 125     }
 126 #endif
 127     if (ec)
 128         return (Volume *) 0;
 129     return vp;
 130 }
 131
 132
 133 static int
 134 handleit(struct cmd_syndesc *as, void *arock)
 135 {
 136     struct cmd_item *ti;
 137     int err = 0;
 138     afs_uint32 volumeId = 0;
 139     char *partName = 0;
 140     char *fileName = NULL;
 141     struct DiskPartition64 *partP = NULL;
 142     char name1[128];
 143     char tmpPartName[20];
 144     int fromtime = 0;
 145     afs_int32 code;
 146
 147
 148 #ifndef AFS_NT40_ENV
 149 #if 0
 150     if (geteuid() != 0) {
 151         fprintf(stderr, "voldump must be run as root; sorry\n");
 152         exit(1);
 153     }
 154 #endif
 155 #endif
 156
 157     if ((ti = as->parms[0].items))
 158         partName = ti->data;
 159     if ((ti = as->parms[1].items))
 160         volumeId = (afs_uint32)atoi(ti->data);
 161     if ((ti = as->parms[2].items))
 162         fileName = ti->data;
 163     if ((ti = as->parms[3].items))
 164         verbose = 1;
 165     if (as->parms[4].items && strcmp(as->parms[4].items->data, "0")) {
 166         code = ktime_DateToInt32(as->parms[4].items->data, &fromtime);
 167         if (code) {
 168             fprintf(STDERR, "failed to parse date '%s' (error=%d))\n",
 169                 as->parms[4].items->data, code);
 170                 return code;
 171         }
 172     }
 173
 174     DInit(10);
 175
 176     err = VAttachPartitions();
 177     if (err) {
 178         fprintf(stderr, "%d partitions had errors during attach.\n", err);
 179     }
 180
 181     if (partName) {
 182         if (strlen(partName) == 1) {
 183             if (partName[0] >= 'a' && partName[0] <= 'z') {
 184                 strcpy(tmpPartName, "/vicepa");
 185                 tmpPartName[6] = partName[0];
 186                 partP = VGetPartition(tmpPartName, 0);
 187             }
 188         } else {
 189             partP = VGetPartition(partName, 0);
 190         }
 191         if (!partP) {
 192             fprintf(stderr,
 193                     "%s is not an AFS partition name on this server.\n",
 194                     partName);
 195             exit(1);
 196         }
 197     }
 198
 199     if (!volumeId) {
 200         fprintf(stderr, "Must specify volume id!\n");
 201         exit(1);
 202     }
 203
 204     if (!partP) {
 205         fprintf(stderr, "must specify vice partition.\n");
 206         exit(1);
 207     }
 208
 209     snprintf(name1, sizeof name1, VFORMAT, (unsigned long)volumeId);
 210     HandleVolume(partP, name1, fileName, fromtime);
 211     return 0;
 212 }
 213
 214 static void
 215 HandleVolume(struct DiskPartition64 *dp, char *name, char *filename, int fromtime)
 216 {
 217     struct VolumeHeader header;
 218     struct VolumeDiskHeader diskHeader;
 219     struct afs_stat status;
 220     int fd;
 221     Volume *vp;
 222     char headerName[1024];
 223
 224     afs_int32 n;
 225
 226     snprintf(headerName, sizeof headerName, "%s" OS_DIRSEP "%s",
 227              VPartitionPath(dp), name);
 228     if ((fd = afs_open(headerName, O_RDONLY)) == -1
 229         || afs_fstat(fd, &status) == -1) {
 230         fprintf(stderr, "Cannot read volume header %s\n", name);
 231         close(fd);
 232         exit(1);
 233     }
 234     n = read(fd, &diskHeader, sizeof(diskHeader));
 235
 236     if (n != sizeof(diskHeader)
 237         || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
 238         fprintf(stderr, "Error reading volume header %s\n", name);
 239         exit(1);
 240     }
 241     if (diskHeader.stamp.version != VOLUMEHEADERVERSION) {
 242         fprintf(stderr,
 243                 "Volume %s, version number is incorrect; volume needs salvage\n",
 244                 name);
 245         exit(1);
 246     }
 247     DiskToVolumeHeader(&header, &diskHeader);
 248
 249     close(fd);
 250     vp = AttachVolume(dp, name, &header);
 251     if (!vp) {
 252         fprintf(stderr, "Error attaching volume header %s\n", name);
 253         exit(1);
 254     }
 255
 256     DoMyVolDump(vp, dp, filename, fromtime);
 257
 258     free(vp);
 259 }
 260
 261
 262 int
 263 main(int argc, char **argv)
 264 {
 265     struct cmd_syndesc *ts;
 266     afs_int32 code;
 267     VolumePackageOptions opts;
 268
 269     VOptDefaults(volumeUtility, &opts);
 270     if (VInitVolumePackage2(volumeUtility, &opts)) {
 271         fprintf(stderr, "errors encountered initializing volume package, but "
 272                         "trying to continue anyway\n");
 273     }
 274
 275     ts = cmd_CreateSyntax(NULL, handleit, NULL,
 276                           "Dump a volume to a 'vos dump' format file without using volserver");
 277     cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL, "AFS partition name");
 278     cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
 279     cmd_AddParm(ts, "-file", CMD_LIST, CMD_OPTIONAL, "Dump filename");
 280     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL,
 281                 "Trace dump progress (very verbose)");
 282     cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_OPTIONAL, "dump from time");
 283     code = cmd_Dispatch(argc, argv);
 284     return code;
 285 }
 286
 287
 288
 289
 290 static int
 291 DumpDouble(int dumpfd, char tag, afs_uint32 value1,
 292            afs_uint32 value2)
 293 {
 294     int res;
 295     char tbuffer[9];
 296     byte *p = (unsigned char *)tbuffer;
 297     *p++ = tag;
 298     afs_putint32(p, value1);
 299     afs_putint32(p, value2);
 300
 301     res = write(dumpfd, tbuffer, 9);
 302     return ((res == 9) ? 0 : VOLSERDUMPERROR);
 303 }
 304
 305 static int
 306 DumpInt32(int dumpfd, char tag, afs_uint32 value)
 307 {
 308     char tbuffer[5];
 309     byte *p = (unsigned char *)tbuffer;
 310     *p++ = tag;
 311     afs_putint32(p, value);
 312     return ((write(dumpfd, tbuffer, 5) == 5) ? 0 : VOLSERDUMPERROR);
 313 }
 314
 315 static int
 316 DumpString(int dumpfd, char tag, char *s)
 317 {
 318     int n;
 319     int code = 0;
 320     code = write(dumpfd, &tag, 1);
 321     if (code != 1)
 322         return VOLSERDUMPERROR;
 323     n = strlen(s) + 1;
 324     code = write(dumpfd, s, n);
 325     if (code != n)
 326         return VOLSERDUMPERROR;
 327     return 0;
 328 }
 329
 330
 331 static int
 332 DumpArrayInt32(int dumpfd, char tag, afs_uint32 * array,
 333                int nelem)
 334 {
 335     char tbuffer[4];
 336     afs_uint32 v;
 337     int code = 0;
 338     byte *p = (unsigned char *)tbuffer;
 339     *p++ = tag;
 340     afs_putshort(p, nelem);
 341     code = write(dumpfd, tbuffer, 3);
 342     if (code != 3)
 343         return VOLSERDUMPERROR;
 344     while (nelem--) {
 345         p = (unsigned char *)tbuffer;
 346         v = *array++;           /*this was register */
 347
 348         afs_putint32(p, v);
 349         code = write(dumpfd, tbuffer, 4);
 350         if (code != 4)
 351             return VOLSERDUMPERROR;
 352     }
 353     return 0;
 354 }
 355
 356
 357
 358
 359 static int
 360 DumpDumpHeader(int dumpfd, Volume * vp, afs_int32 fromtime)
 361 {
 362     int code = 0;
 363     afs_int32 dumpTimes[2];
 364
 365     if (verbose)
 366         fprintf(stderr, "dumping dump header\n");
 367
 368     if (!code)
 369         code = DumpDouble(dumpfd, D_DUMPHEADER, DUMPBEGINMAGIC, DUMPVERSION);
 370
 371     if (!code)
 372         code = DumpInt32(dumpfd, 'v', V_id(vp));
 373
 374     if (!code)
 375         code = DumpString(dumpfd, 'n', V_name(vp));
 376
 377     dumpTimes[0] = fromtime;
 378     dumpTimes[1] = V_backupDate(vp);    /* Until the time the clone was made */
 379     if (!code)
 380         code = DumpArrayInt32(dumpfd, 't', (afs_uint32 *) dumpTimes, 2);
 381
 382     return code;
 383 }
 384
 385
 386 static int
 387 DumpEnd(int dumpfd)
 388 {
 389     return (DumpInt32(dumpfd, D_DUMPEND, DUMPENDMAGIC));
 390 }
 391
 392 static int
 393 DumpByte(int dumpfd, char tag, byte value)
 394 {
 395     char tbuffer[2];
 396     byte *p = (unsigned char *)tbuffer;
 397     *p++ = tag;
 398     *p = value;
 399     return ((write(dumpfd, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
 400 }
 401
 402 static int
 403 DumpTag(int dumpfd, int tag)
 404 {
 405     char p;
 406
 407     p = tag;
 408     return ((write(dumpfd, &p, 1) == 1) ? 0 : VOLSERDUMPERROR);
 409
 410 }
 411
 412 static int
 413 DumpBool(int dumpfd, char tag, unsigned int value)
 414 {
 415     char tbuffer[2];
 416     byte *p = (unsigned char *)tbuffer;
 417     *p++ = tag;
 418     *p = value;
 419     return ((write(dumpfd, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
 420 }
 421
 422
 423
 424 static int
 425 DumpVolumeHeader(int dumpfd, Volume * vp)
 426 {
 427     int code = 0;
 428
 429     if (verbose)
 430         fprintf(stderr, "dumping volume header\n");
 431
 432     if (!code)
 433         code = DumpTag(dumpfd, D_VOLUMEHEADER);
 434     if (!code)
 435         code = DumpInt32(dumpfd, 'i', V_id(vp));
 436     if (!code)
 437         code = DumpInt32(dumpfd, 'v', V_stamp(vp).version);
 438     if (!code)
 439         code = DumpString(dumpfd, 'n', V_name(vp));
 440     if (!code)
 441         code = DumpBool(dumpfd, 's', V_inService(vp));
 442     if (!code)
 443         code = DumpBool(dumpfd, 'b', V_blessed(vp));
 444     if (!code)
 445         code = DumpInt32(dumpfd, 'u', V_uniquifier(vp));
 446     if (!code)
 447         code = DumpByte(dumpfd, 't', (byte) V_type(vp));
 448     if (!code)
 449         code = DumpInt32(dumpfd, 'p', V_parentId(vp));
 450     if (!code)
 451         code = DumpInt32(dumpfd, 'c', V_cloneId(vp));
 452     if (!code)
 453         code = DumpInt32(dumpfd, 'q', V_maxquota(vp));
 454     if (!code)
 455         code = DumpInt32(dumpfd, 'm', V_minquota(vp));
 456     if (!code)
 457         code = DumpInt32(dumpfd, 'd', V_diskused(vp));
 458     if (!code)
 459         code = DumpInt32(dumpfd, 'f', V_filecount(vp));
 460     if (!code)
 461         code = DumpInt32(dumpfd, 'a', V_accountNumber(vp));
 462     if (!code)
 463         code = DumpInt32(dumpfd, 'o', V_owner(vp));
 464     if (!code)
 465         code = DumpInt32(dumpfd, 'C', V_creationDate(vp));      /* Rw volume creation date */
 466     if (!code)
 467         code = DumpInt32(dumpfd, 'A', V_accessDate(vp));
 468     if (!code)
 469         code = DumpInt32(dumpfd, 'U', V_updateDate(vp));
 470     if (!code)
 471         code = DumpInt32(dumpfd, 'E', V_expirationDate(vp));
 472     if (!code)
 473         code = DumpInt32(dumpfd, 'B', V_backupDate(vp));        /* Rw volume backup clone date */
 474     if (!code)
 475         code = DumpString(dumpfd, 'O', V_offlineMessage(vp));
 476
 477     /*
 478      * We do NOT dump the detailed volume statistics residing in the old
 479      * motd field, since we cannot tell from the info in a dump whether
 480      * statistics data has been put there.  Instead, we dump a null string,
 481      * just as if that was what the motd contained.
 482      */
 483     if (!code)
 484         code = DumpString(dumpfd, 'M', "");
 485     if (!code)
 486         code =
 487             DumpArrayInt32(dumpfd, 'W', (afs_uint32 *) V_weekUse(vp),
 488                            sizeof(V_weekUse(vp)) / sizeof(V_weekUse(vp)[0]));
 489     if (!code)
 490         code = DumpInt32(dumpfd, 'D', V_dayUseDate(vp));
 491     if (!code)
 492         code = DumpInt32(dumpfd, 'Z', V_dayUse(vp));
 493     return code;
 494 }
 495
 496 static int
 497 DumpShort(int dumpfd, char tag, unsigned int value)
 498 {
 499     char tbuffer[3];
 500     byte *p = (unsigned char *)tbuffer;
 501     *p++ = tag;
 502     *p++ = value >> 8;
 503     *p = value;
 504     return ((write(dumpfd, tbuffer, 3) == 3) ? 0 : VOLSERDUMPERROR);
 505 }
 506
 507 static int
 508 DumpByteString(int dumpfd, char tag, byte * bs, int nbytes)
 509 {
 510     int code = 0;
 511
 512     code = write(dumpfd, &tag, 1);
 513     if (code != 1)
 514         return VOLSERDUMPERROR;
 515     code = write(dumpfd, (char *)bs, nbytes);
 516     if (code != nbytes)
 517         return VOLSERDUMPERROR;
 518     return 0;
 519 }
 520
 521
 522 static int
 523 DumpFile(int dumpfd, int vnode, FdHandle_t * handleP,  struct VnodeDiskObject *v)
 524 {
 525     int code = 0, failed_seek = 0, failed_write = 0;
 526     afs_int32 pad = 0;
 527     afs_foff_t offset = 0;
 528     afs_sfsize_t nbytes, howBig;
 529     ssize_t n;
 530     size_t howMany;
 531     afs_foff_t howFar = 0;
 532     byte *p;
 533     afs_uint32 hi, lo;
 534     afs_ino_str_t stmp;
 535 #ifndef AFS_NT40_ENV
 536     struct afs_stat status;
 537 #else
 538     LARGE_INTEGER fileSize;
 539 #endif
 540     afs_sfsize_t size;
 541 #ifdef  AFS_AIX_ENV
 542 #include <sys/statfs.h>
 543     struct statfs tstatfs;
 544 #endif
 545
 546     if (verbose)
 547         fprintf(stderr, "dumping file for vnode %d\n", vnode);
 548
 549 #ifdef AFS_NT40_ENV
 550     if (!GetFileSizeEx(handleP->fd_fd, &fileSize)) {
 551         Log("DumpFile: GetFileSizeEx returned error code %d on descriptor %d\n", GetLastError(), handleP->fd_fd);
 552             return VOLSERDUMPERROR;
 553     }
 554     howBig = fileSize.QuadPart;
 555     howMany = 4096;
 556
 557 #else
 558     afs_fstat(handleP->fd_fd, &status);
 559     howBig = status.st_size;
 560
 561 #ifdef  AFS_AIX_ENV
 562     /* Unfortunately in AIX valuable fields such as st_blksize are
 563      * gone from the stat structure.
 564      */
 565     fstatfs(handleP->fd_fd, &tstatfs);
 566     howMany = tstatfs.f_bsize;
 567 #else
 568     howMany = status.st_blksize;
 569 #endif /* AFS_AIX_ENV */
 570 #endif /* AFS_NT40_ENV */
 571
 572
 573     size = FDH_SIZE(handleP);
 574
 575     if (verbose)
 576         fprintf(stderr, "  howBig = %u, howMany = %u, fdh size = %u\n",
 577                 (unsigned int) howBig, (unsigned int) howMany,
 578                 (unsigned int) size);
 579
 580     SplitInt64(size, hi, lo);
 581     if (hi == 0L) {
 582         code = DumpInt32(dumpfd, 'f', lo);
 583     } else {
 584         code = DumpDouble(dumpfd, 'h', hi, lo);
 585     }
 586
 587     if (code) {
 588         return VOLSERDUMPERROR;
 589     }
 590
 591     p = malloc(howMany);
 592     if (!p) {
 593         fprintf(stderr, "out of memory!\n");
 594         return VOLSERDUMPERROR;
 595     }
 596
 597     /* loop through whole file, while we still have bytes left, and no errors, in chunks of howMany bytes */
 598     for (nbytes = size; (nbytes && !failed_write); nbytes -= howMany) {
 599         if (nbytes < howMany)
 600             howMany = nbytes;
 601
 602         /* Read the data - unless we know we can't */
 603         n = (failed_seek ? 0 : FDH_PREAD(handleP, p, howMany, howFar));
 604         howFar += n;
 605
 606         /* If read any good data and we null padded previously, log the
 607          * amount that we had null padded.
 608          */
 609         if ((n > 0) && pad) {
 610             fprintf(stderr, "Null padding file %d bytes at offset %lld\n", pad,
 611                     (long long)offset);
 612             pad = 0;
 613         }
 614
 615         /* If didn't read enough data, null padd the rest of the buffer. This
 616          * can happen if, for instance, the media has some bad spots. We don't
 617          * want to quit the dump, so we start null padding.
 618          */
 619         if (n < howMany) {
 620
 621                 if (verbose) fprintf(stderr, "  read %u instead of %u bytes.\n", (unsigned)n, (unsigned)howMany);
 622
 623             /* Record the read error */
 624             if (n < 0) {
 625                 n = 0;
 626                 fprintf(stderr, "Error %d reading inode %s for vnode %d\n",
 627                         errno, PrintInode(stmp, handleP->fd_ih->ih_ino),
 628                         vnode);
 629             } else if (!pad) {
 630                 fprintf(stderr, "Error reading inode %s for vnode %d\n",
 631                         PrintInode(stmp, handleP->fd_ih->ih_ino), vnode);
 632             }
 633
 634             /* Pad the rest of the buffer with zeros. Remember offset we started
 635              * padding. Keep total tally of padding.
 636              */
 637             memset(p + n, 0, howMany - n);
 638             if (!pad)
 639                 offset = (howBig - nbytes) + n;
 640             pad += (howMany - n);
 641
 642             /* Now seek over the data we could not get. An error here means we
 643              * can't do the next read.
 644              */
 645             howFar = ((size - nbytes) + howMany);
 646         }
 647
 648         /* Now write the data out */
 649         if (write(dumpfd, (char *)p, howMany) != howMany)
 650             failed_write = VOLSERDUMPERROR;
 651     }
 652
 653     if (pad) {                  /* Any padding we hadn't reported yet */
 654         fprintf(stderr, "Null padding file: %d bytes at offset %lld\n", pad,
 655                 (long long)offset);
 656     }
 657
 658     free(p);
 659     return failed_write;
 660 }
 661
 662
 663 static int
 664 DumpVnode(int dumpfd, struct VnodeDiskObject *v, int volid, int vnodeNumber,
 665           int dumpEverything, struct Volume *vp)
 666 {
 667     int code = 0;
 668     IHandle_t *ihP;
 669     FdHandle_t *fdP;
 670     afs_ino_str_t stmp;
 671
 672     if (verbose)
 673         fprintf(stderr, "dumping vnode %d\n", vnodeNumber);
 674
 675     if (!v || v->type == vNull)
 676         return code;
 677     if (!code)
 678         code = DumpDouble(dumpfd, D_VNODE, vnodeNumber, v->uniquifier);
 679     if (!dumpEverything)
 680         return code;
 681     if (!code)
 682         code = DumpByte(dumpfd, 't', (byte) v->type);
 683     if (!code)
 684         code = DumpShort(dumpfd, 'l', v->linkCount);    /* May not need this */
 685     if (!code)
 686         code = DumpInt32(dumpfd, 'v', v->dataVersion);
 687     if (!code)
 688         code = DumpInt32(dumpfd, 'm', v->unixModifyTime);
 689     if (!code)
 690         code = DumpInt32(dumpfd, 'a', v->author);
 691     if (!code)
 692         code = DumpInt32(dumpfd, 'o', v->owner);
 693     if (!code && v->group)
 694         code = DumpInt32(dumpfd, 'g', v->group);        /* default group is 0 */
 695     if (!code)
 696         code = DumpShort(dumpfd, 'b', v->modeBits);
 697     if (!code)
 698         code = DumpInt32(dumpfd, 'p', v->parent);
 699     if (!code)
 700         code = DumpInt32(dumpfd, 's', v->serverModifyTime);
 701     if (v->type == vDirectory) {
 702         acl_HtonACL(VVnodeDiskACL(v));
 703         if (!code)
 704             code =
 705                 DumpByteString(dumpfd, 'A', (byte *) VVnodeDiskACL(v),
 706                                VAclDiskSize(v));
 707     }
 708
 709     if (VNDISK_GET_INO(v)) {
 710         IH_INIT(ihP, V_device(vp), V_parentId(vp), VNDISK_GET_INO(v));
 711         fdP = IH_OPEN(ihP);
 712         if (fdP == NULL) {
 713             fprintf(stderr,
 714                     "Unable to open inode %s for vnode %u (volume %i); not dumped, error %d\n",
 715                     PrintInode(stmp, VNDISK_GET_INO(v)), vnodeNumber, volid,
 716                     errno);
 717         }
 718         else
 719         {
 720                 if (verbose)
 721                     fprintf(stderr, "about to dump inode %s for vnode %u\n",
 722                             PrintInode(stmp, VNDISK_GET_INO(v)), vnodeNumber);
 723                 code = DumpFile(dumpfd, vnodeNumber, fdP, v);
 724                 FDH_CLOSE(fdP);
 725         }
 726         IH_RELEASE(ihP);
 727     }
 728
 729     if (verbose)
 730         fprintf(stderr, "done dumping vnode %d\n", vnodeNumber);
 731     return code;
 732 }
 733
 734
 735 static int
 736 DumpVnodeIndex(int dumpfd, Volume * vp, VnodeClass class, afs_int32 fromtime,
 737                int forcedump)
 738 {
 739     int code = 0;
 740     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
 741     char buf[SIZEOF_LARGEDISKVNODE];
 742     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
 743     StreamHandle_t *file;
 744     FdHandle_t *fdP;
 745     afs_sfsize_t size;
 746     int flag;
 747     afs_foff_t offset = 0;
 748     int vnodeIndex, nVnodes = 0;
 749
 750     fdP = IH_OPEN(vp->vnodeIndex[class].handle);
 751     file = FDH_FDOPEN(fdP, "r+");
 752     size = OS_SIZE(fdP->fd_fd);
 753     nVnodes = (size / vcp->diskSize) - 1;
 754
 755     if (nVnodes > 0) {
 756         STREAM_ASEEK(file, vcp->diskSize);
 757     } else
 758         nVnodes = 0;
 759     for (vnodeIndex = 0;
 760          nVnodes && STREAM_READ(vnode, vcp->diskSize, 1, file) == 1 && !code;
 761          nVnodes--, vnodeIndex++, offset += vcp->diskSize) {
 762         flag = forcedump || (vnode->serverModifyTime >= fromtime);
 763         /* Note:  the >= test is very important since some old volumes may not have
 764          * a serverModifyTime.  For an epoch dump, this results in 0>=0 test, which
 765          * does dump the file! */
 766         if (verbose)
 767             fprintf(stderr, "about to dump %s vnode %u (vnode offset = %lld)\n",
 768                         class == vSmall ? "vSmall" : "vLarge",
 769                     bitNumberToVnodeNumber(vnodeIndex, class), (long long)offset);
 770         if (!code)
 771             code =
 772                 DumpVnode(dumpfd, vnode, V_id(vp),
 773                           bitNumberToVnodeNumber(vnodeIndex, class), flag,
 774                           vp);
 775     }
 776     STREAM_CLOSE(file);
 777     FDH_CLOSE(fdP);
 778     return code;
 779 }
 780
 781
 782
 783 /* A partial dump (no dump header) */
 784 static int
 785 DumpPartial(int dumpfd, Volume * vp, afs_int32 fromtime,
 786             int dumpAllDirs)
 787 {
 788     int code = 0;
 789
 790     if (verbose)
 791         fprintf(stderr, "about to dump the volume header\n");
 792     if (!code)
 793         code = DumpVolumeHeader(dumpfd, vp);
 794
 795     if (verbose)
 796         fprintf(stderr, "about to dump the large vnode index\n");
 797     if (!code)
 798         code = DumpVnodeIndex(dumpfd, vp, vLarge, fromtime, dumpAllDirs);
 799
 800     if (verbose)
 801         fprintf(stderr, "about to dump the small vnode index\n");
 802     if (!code)
 803         code = DumpVnodeIndex(dumpfd, vp, vSmall, fromtime, 0);
 804     return code;
 805 }
 806
 807
 808
 809 static void
 810 DoMyVolDump(Volume * vp, struct DiskPartition64 *dp, char *dumpfile, int fromtime)
 811 {
 812     int code = 0;
 813     int dumpAllDirs = 0;
 814     int dumpfd = 0;
 815
 816     if (dumpfile) {
 817         unlink(dumpfile);
 818         dumpfd =
 819             afs_open(dumpfile, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);
 820         if (dumpfd < 0) {
 821             fprintf(stderr, "Failed to open dump file: %s. Exiting.\n",
 822                     afs_error_message(errno));
 823             exit(1);
 824         }
 825     } else {
 826         dumpfd = 1;             /* stdout */
 827     }
 828
 829     if (verbose)
 830         fprintf(stderr, "about to dump the dump header\n");
 831     if (!code)
 832         code = DumpDumpHeader(dumpfd, vp, fromtime);
 833
 834     if (verbose)
 835         fprintf(stderr, "about to dump volume contents\n");
 836     if (!code)
 837         code = DumpPartial(dumpfd, vp, fromtime, dumpAllDirs);
 838
 839     if (verbose)
 840         fprintf(stderr, "about to dump the dump postamble\n");
 841     if (!code)
 842         code = DumpEnd(dumpfd);
 843
 844     if (verbose)
 845         fprintf(stderr, "finished dump\n");
 846     close(dumpfd);              /* might be closing stdout, no harm */
 847 }