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