c53ad37c96c8c2054f8bd8316626fcbed2ad90bd
[openafs.git] / 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 <afs/nfs.h>
43 #include <afs/errors.h>
44 #include <lock.h>
45 #include <lwp.h>
46 #include <afs/afssyscalls.h>
47 #include <afs/ihandle.h>
48 #include <afs/vnode.h>
49 #include <afs/volume.h>
50 #include <afs/partition.h>
51 #include <afs/viceinode.h>
52 #include <afs/afssyscalls.h>
53 #include <afs/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.h"
76 #include "volint.h"
77 #include "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     VolumePackageOptions opts;
303
304     VOptDefaults(volumeUtility, &opts);
305     if (VInitVolumePackage2(volumeUtility, &opts)) {
306         fprintf(stderr, "errors encountered initializing volume package, but "
307                         "trying to continue anyway\n");
308     }
309
310     ts = cmd_CreateSyntax(NULL, handleit, NULL,
311                           "Dump a volume to a 'vos dump' format file without using volserver");
312     cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL, "AFS partition name");
313     cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
314     cmd_AddParm(ts, "-file", CMD_LIST, CMD_OPTIONAL, "Dump filename");
315     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL,
316                 "Trace dump progress (very verbose)");
317     cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_OPTIONAL, "dump from time");
318     code = cmd_Dispatch(argc, argv);
319     return code;
320 }
321
322
323
324
325 static int
326 DumpDouble(int dumpfd, char tag, register afs_uint32 value1,
327            register afs_uint32 value2)
328 {
329     int res;
330     char tbuffer[9];
331     register byte *p = (unsigned char *)tbuffer;
332     *p++ = tag;
333     putint32(p, value1);
334     putint32(p, value2);
335
336     res = write(dumpfd, tbuffer, 9);
337     return ((res == 9) ? 0 : VOLSERDUMPERROR);
338 }
339
340 static int
341 DumpInt32(int dumpfd, char tag, register afs_uint32 value)
342 {
343     char tbuffer[5];
344     register byte *p = (unsigned char *)tbuffer;
345     *p++ = tag;
346     putint32(p, value);
347     return ((write(dumpfd, tbuffer, 5) == 5) ? 0 : VOLSERDUMPERROR);
348 }
349
350 static int
351 DumpString(int dumpfd, char tag, register char *s)
352 {
353     register int n;
354     int code = 0;
355     code = write(dumpfd, &tag, 1);
356     if (code != 1)
357         return VOLSERDUMPERROR;
358     n = strlen(s) + 1;
359     code = write(dumpfd, s, n);
360     if (code != n)
361         return VOLSERDUMPERROR;
362     return 0;
363 }
364
365
366 static int
367 DumpArrayInt32(int dumpfd, char tag, register afs_uint32 * array,
368                register int nelem)
369 {
370     char tbuffer[4];
371     register afs_uint32 v;
372     int code = 0;
373     register byte *p = (unsigned char *)tbuffer;
374     *p++ = tag;
375     putshort(p, nelem);
376     code = write(dumpfd, tbuffer, 3);
377     if (code != 3)
378         return VOLSERDUMPERROR;
379     while (nelem--) {
380         p = (unsigned char *)tbuffer;
381         v = *array++;           /*this was register */
382
383         putint32(p, v);
384         code = write(dumpfd, tbuffer, 4);
385         if (code != 4)
386             return VOLSERDUMPERROR;
387     }
388     return 0;
389 }
390
391
392
393
394 static int
395 DumpDumpHeader(int dumpfd, register Volume * vp, afs_int32 fromtime)
396 {
397     int code = 0;
398     afs_int32 dumpTimes[2];
399
400     if (verbose)
401         fprintf(stderr, "dumping dump header\n");
402
403     if (!code)
404         code = DumpDouble(dumpfd, D_DUMPHEADER, DUMPBEGINMAGIC, DUMPVERSION);
405
406     if (!code)
407         code = DumpInt32(dumpfd, 'v', V_id(vp));
408
409     if (!code)
410         code = DumpString(dumpfd, 'n', V_name(vp));
411
412     dumpTimes[0] = fromtime;
413     dumpTimes[1] = V_backupDate(vp);    /* Until the time the clone was made */
414     if (!code)
415         code = DumpArrayInt32(dumpfd, 't', (afs_uint32 *) dumpTimes, 2);
416
417     return code;
418 }
419
420
421 static int
422 DumpEnd(int dumpfd)
423 {
424     return (DumpInt32(dumpfd, D_DUMPEND, DUMPENDMAGIC));
425 }
426
427 static int
428 DumpByte(int dumpfd, char tag, byte value)
429 {
430     char tbuffer[2];
431     register byte *p = (unsigned char *)tbuffer;
432     *p++ = tag;
433     *p = value;
434     return ((write(dumpfd, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
435 }
436
437 static int
438 DumpTag(int dumpfd, register int tag)
439 {
440     char p;
441
442     p = tag;
443     return ((write(dumpfd, &p, 1) == 1) ? 0 : VOLSERDUMPERROR);
444
445 }
446
447 static int
448 DumpBool(int dumpfd, char tag, unsigned int value)
449 {
450     char tbuffer[2];
451     register byte *p = (unsigned char *)tbuffer;
452     *p++ = tag;
453     *p = value;
454     return ((write(dumpfd, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
455 }
456
457
458
459 static int
460 DumpVolumeHeader(int dumpfd, register Volume * vp)
461 {
462     int code = 0;
463
464     if (verbose)
465         fprintf(stderr, "dumping volume header\n");
466
467     if (!code)
468         code = DumpTag(dumpfd, D_VOLUMEHEADER);
469     if (!code)
470         code = DumpInt32(dumpfd, 'i', V_id(vp));
471     if (!code)
472         code = DumpInt32(dumpfd, 'v', V_stamp(vp).version);
473     if (!code)
474         code = DumpString(dumpfd, 'n', V_name(vp));
475     if (!code)
476         code = DumpBool(dumpfd, 's', V_inService(vp));
477     if (!code)
478         code = DumpBool(dumpfd, 'b', V_blessed(vp));
479     if (!code)
480         code = DumpInt32(dumpfd, 'u', V_uniquifier(vp));
481     if (!code)
482         code = DumpByte(dumpfd, 't', (byte) V_type(vp));
483     if (!code)
484         code = DumpInt32(dumpfd, 'p', V_parentId(vp));
485     if (!code)
486         code = DumpInt32(dumpfd, 'c', V_cloneId(vp));
487     if (!code)
488         code = DumpInt32(dumpfd, 'q', V_maxquota(vp));
489     if (!code)
490         code = DumpInt32(dumpfd, 'm', V_minquota(vp));
491     if (!code)
492         code = DumpInt32(dumpfd, 'd', V_diskused(vp));
493     if (!code)
494         code = DumpInt32(dumpfd, 'f', V_filecount(vp));
495     if (!code)
496         code = DumpInt32(dumpfd, 'a', V_accountNumber(vp));
497     if (!code)
498         code = DumpInt32(dumpfd, 'o', V_owner(vp));
499     if (!code)
500         code = DumpInt32(dumpfd, 'C', V_creationDate(vp));      /* Rw volume creation date */
501     if (!code)
502         code = DumpInt32(dumpfd, 'A', V_accessDate(vp));
503     if (!code)
504         code = DumpInt32(dumpfd, 'U', V_updateDate(vp));
505     if (!code)
506         code = DumpInt32(dumpfd, 'E', V_expirationDate(vp));
507     if (!code)
508         code = DumpInt32(dumpfd, 'B', V_backupDate(vp));        /* Rw volume backup clone date */
509     if (!code)
510         code = DumpString(dumpfd, 'O', V_offlineMessage(vp));
511
512     /*
513      * We do NOT dump the detailed volume statistics residing in the old
514      * motd field, since we cannot tell from the info in a dump whether
515      * statistics data has been put there.  Instead, we dump a null string,
516      * just as if that was what the motd contained.
517      */
518     if (!code)
519         code = DumpString(dumpfd, 'M', "");
520     if (!code)
521         code =
522             DumpArrayInt32(dumpfd, 'W', (afs_uint32 *) V_weekUse(vp),
523                            sizeof(V_weekUse(vp)) / sizeof(V_weekUse(vp)[0]));
524     if (!code)
525         code = DumpInt32(dumpfd, 'D', V_dayUseDate(vp));
526     if (!code)
527         code = DumpInt32(dumpfd, 'Z', V_dayUse(vp));
528     return code;
529 }
530
531 static int
532 DumpShort(int dumpfd, char tag, unsigned int value)
533 {
534     char tbuffer[3];
535     register byte *p = (unsigned char *)tbuffer;
536     *p++ = tag;
537     *p++ = value >> 8;
538     *p = value;
539     return ((write(dumpfd, tbuffer, 3) == 3) ? 0 : VOLSERDUMPERROR);
540 }
541
542 static int
543 DumpByteString(int dumpfd, char tag, register byte * bs, register int nbytes)
544 {
545     int code = 0;
546
547     code = write(dumpfd, &tag, 1);
548     if (code != 1)
549         return VOLSERDUMPERROR;
550     code = write(dumpfd, (char *)bs, nbytes);
551     if (code != nbytes)
552         return VOLSERDUMPERROR;
553     return 0;
554 }
555
556
557 static int
558 DumpFile(int dumpfd, int vnode, FdHandle_t * handleP,  struct VnodeDiskObject *v)
559 {
560     int code = 0, failed_seek = 0, failed_write = 0;
561     afs_int32 pad = 0;
562     afs_int32 offset = 0;
563     afs_sfsize_t n, nbytes, howMany, howBig;
564     byte *p;
565     afs_uint32 hi, lo;
566 #ifndef AFS_NT40_ENV
567     struct afs_stat status;
568 #endif
569     afs_sfsize_t size;
570 #ifdef  AFS_AIX_ENV
571 #include <sys/statfs.h>
572     struct statfs tstatfs;
573 #endif
574
575     if (verbose)
576         fprintf(stderr, "dumping file for vnode %d\n", vnode);
577
578 #ifdef AFS_NT40_ENV
579     howBig = _filelength(handleP->fd_fd);
580     howMany = 4096;
581
582 #else
583     afs_fstat(handleP->fd_fd, &status);
584     howBig = status.st_size;
585
586 #ifdef  AFS_AIX_ENV
587     /* Unfortunately in AIX valuable fields such as st_blksize are 
588      * gone from the stat structure.
589      */
590     fstatfs(handleP->fd_fd, &tstatfs);
591     howMany = tstatfs.f_bsize;
592 #else
593     howMany = status.st_blksize;
594 #endif /* AFS_AIX_ENV */
595 #endif /* AFS_NT40_ENV */
596
597
598     size = FDH_SIZE(handleP);
599
600     if (verbose)
601         fprintf(stderr, "  howBig = %u, howMany = %u, fdh size = %u\n",
602                 (unsigned int) howBig, (unsigned int) howMany,
603                 (unsigned int) size);
604
605     SplitInt64(size, hi, lo);
606     if (hi == 0L) {
607         code = DumpInt32(dumpfd, 'f', lo);
608     } else {
609         code = DumpDouble(dumpfd, 'h', hi, lo);
610     }
611
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 }