ac206f9ff9ff449819f25c8f9eeb17c3e4d7d8b9
[openafs.git] / src / volser / dumpstuff.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 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #include <sys/types.h>
17 #include <ctype.h>
18 #include <stdio.h>
19 #include <errno.h>
20 #ifdef AFS_NT40_ENV
21 #include <fcntl.h>
22 #else
23 #include <sys/param.h>
24 #include <sys/file.h>
25 #include <sys/uio.h>
26 #include <netinet/in.h>
27 #include <unistd.h>
28 #endif
29 #ifdef HAVE_STRING_H
30 #include <string.h>
31 #else
32 #ifdef HAVE_STRINGS_H
33 #include <strings.h>
34 #endif
35 #endif
36 #include <sys/stat.h>
37 #include <afs/assert.h>
38 #include <rx/xdr.h>
39 #include <rx/rx.h>
40 #include <afs/afsint.h>
41 #include <afs/nfs.h>
42 #include <afs/errors.h>
43 #include <lock.h>
44 #include <lwp.h>
45 #include <afs/ihandle.h>
46 #include <afs/vnode.h>
47 #include <afs/volume.h>
48 #include <afs/partition.h>
49 #include "dump.h"
50 #include <afs/fssync.h>
51 #include <afs/acl.h>
52 #include "volser.h"
53 #include "volint.h"
54
55 #ifndef AFS_NT40_ENV
56 #ifdef O_LARGEFILE
57 #define afs_stat        stat64
58 #define afs_fstat       fstat64
59 #else /* !O_LARGEFILE */
60 #define afs_stat        stat
61 #define afs_fstat       fstat
62 #endif /* !O_LARGEFILE */
63 #endif /* !AFS_NT40_ENV */
64
65 /*@printflike@*/ extern void Log(const char *format, ...);
66
67 extern int DoLogging;
68
69 /* This iod stuff is a silly little package to emulate the old qi_in stuff, which
70    emulated the stdio stuff.  There is a big assumption here, that the
71    rx_Read will never be called directly, by a routine like readFile, when
72    there is an old character that was pushed back with iod_ungetc.  This
73    is really bletchy, and is here for compatibility only.  Eventually,
74    we should define a volume format that doesn't require
75    the pushing back of characters (i.e. characters should not double both
76    as an end marker and a begin marker) */
77 struct iod {
78     struct rx_call *call;       /* call to which to write, might be an array */
79     int device;                 /* dump device ID for volume */
80     int parentId;               /* dump parent ID for volume */
81     struct DiskPartition *dumpPartition;        /* Dump partition. */
82     struct rx_call **calls;     /* array of pointers to calls */
83     int ncalls;                 /* how many calls/codes in array */
84     int *codes;                 /* one return code for each call */
85     char haveOldChar;           /* state for pushing back a character */
86     char oldChar;
87 };
88
89
90 /* Forward Declarations */
91 static int DumpDumpHeader(register struct iod *iodp, register Volume * vp,
92                           afs_int32 fromtime);
93 static int DumpPartial(register struct iod *iodp, register Volume * vp,
94                        afs_int32 fromtime, int dumpAllDirs);
95 static int DumpVnodeIndex(register struct iod *iodp, Volume * vp,
96                           VnodeClass class, afs_int32 fromtime,
97                           int forcedump);
98 static int DumpVnode(register struct iod *iodp, struct VnodeDiskObject *v,
99                      int volid, int vnodeNumber, int dumpEverything);
100 static int ReadDumpHeader(register struct iod *iodp, struct DumpHeader *hp);
101 static int ReadVnodes(register struct iod *iodp, Volume * vp, int incremental,
102                       afs_int32 * Lbuf, afs_int32 s1, afs_int32 * Sbuf,
103                       afs_int32 s2, afs_int32 delo);
104 static afs_fsize_t volser_WriteFile(int vn, struct iod *iodp,
105                                     FdHandle_t * handleP, int tag,
106                                     Error * status);
107
108 static int SizeDumpDumpHeader(register struct iod *iodp, register Volume * vp,
109                               afs_int32 fromtime,
110                               register struct volintSize *size);
111 static int SizeDumpPartial(register struct iod *iodp, register Volume * vp,
112                            afs_int32 fromtime, int dumpAllDirs,
113                            register struct volintSize *size);
114 static int SizeDumpVnodeIndex(register struct iod *iodp, Volume * vp,
115                               VnodeClass class, afs_int32 fromtime,
116                               int forcedump,
117                               register struct volintSize *size);
118 static int SizeDumpVnode(register struct iod *iodp, struct VnodeDiskObject *v,
119                          int volid, int vnodeNumber, int dumpEverything,
120                          register struct volintSize *size);
121
122 static void
123 iod_Init(register struct iod *iodp, register struct rx_call *call)
124 {
125     iodp->call = call;
126     iodp->haveOldChar = 0;
127     iodp->ncalls = 1;
128     iodp->calls = (struct rx_call **)0;
129 }
130
131 static void
132 iod_InitMulti(struct iod *iodp, struct rx_call **calls, int ncalls,
133               int *codes)
134 {
135
136     iodp->calls = calls;
137     iodp->haveOldChar = 0;
138     iodp->ncalls = ncalls;
139     iodp->codes = codes;
140     iodp->call = (struct rx_call *)0;
141 }
142
143 /* N.B. iod_Read doesn't check for oldchar (see previous comment) */
144 #define iod_Read(iodp, buf, nbytes) rx_Read((iodp)->call, buf, nbytes)
145
146 /* For the single dump case, it's ok to just return the "bytes written"
147  * that rx_Write returns, since all the callers of iod_Write abort when
148  * the returned value is less than they expect.  For the multi dump case,
149  * I don't think we want half the replicas to go bad just because one 
150  * connection timed out, but if they all time out, then we should give up. 
151  */
152 static int
153 iod_Write(struct iod *iodp, char *buf, int nbytes)
154 {
155     int code, i;
156     int one_success = 0;
157
158     assert((iodp->call && iodp->ncalls == 1 && !iodp->calls)
159            || (!iodp->call && iodp->ncalls >= 1 && iodp->calls));
160
161     if (iodp->call) {
162         code = rx_Write(iodp->call, buf, nbytes);
163         return code;
164     }
165
166     for (i = 0; i < iodp->ncalls; i++) {
167         if (iodp->calls[i] && !iodp->codes[i]) {
168             code = rx_Write(iodp->calls[i], buf, nbytes);
169             if (code != nbytes) {       /* everything gets merged into a single error */
170                 iodp->codes[i] = VOLSERDUMPERROR;       /* but that's exactly what the */
171             } /* standard dump does, anyways */
172             else {
173                 one_success = TRUE;
174             }
175         }
176     }                           /* for all calls */
177
178     if (one_success)
179         return nbytes;
180     else
181         return 0;
182 }
183
184 static void
185 iod_ungetc(struct iod *iodp, int achar)
186 {
187     iodp->oldChar = achar;
188     iodp->haveOldChar = 1;
189 }
190
191 static int
192 iod_getc(register struct iod *iodp)
193 {
194     unsigned char t;
195
196     if (iodp->haveOldChar) {
197         iodp->haveOldChar = 0;
198         return iodp->oldChar;
199     }
200     if (iod_Read(iodp, &t, 1) == 1)
201         return t;
202     return EOF;
203 }
204
205 static int
206 ReadShort(register struct iod *iodp, register unsigned short *sp)
207 {
208     register b1, b0;
209     b1 = iod_getc(iodp);
210     b0 = iod_getc(iodp);
211     *sp = (b1 << 8) | b0;
212     return b0 != EOF;
213 }
214
215 static int
216 ReadInt32(register struct iod *iodp, afs_uint32 * lp)
217 {
218     afs_uint32 register b3, b2, b1, b0;
219     b3 = iod_getc(iodp);
220     b2 = iod_getc(iodp);
221     b1 = iod_getc(iodp);
222     b0 = iod_getc(iodp);
223     *lp = (((((b3 << 8) | b2) << 8) | b1) << 8) | b0;
224     return b0 != EOF;
225 }
226
227 static void
228 ReadString(register struct iod *iodp, register char *to, register int maxa)
229 {
230     register int c;
231     while (maxa--) {
232         if ((*to++ = iod_getc(iodp)) == 0)
233             break;
234     }
235     if (to[-1]) {
236         while ((c = iod_getc(iodp)) && c != EOF);
237         to[-1] = 0;
238     }
239 }
240
241 static void
242 ReadByteString(register struct iod *iodp, register byte * to,
243                register int size)
244 {
245     while (size--)
246         *to++ = iod_getc(iodp);
247 }
248
249 static int
250 ReadVolumeHeader(register struct iod *iodp, VolumeDiskData * vol)
251 {
252     register tag;
253     afs_uint32 trash;
254     memset(vol, 0, sizeof(*vol));
255     while ((tag = iod_getc(iodp)) > D_MAX && tag != EOF) {
256         switch (tag) {
257         case 'i':
258             if (!ReadInt32(iodp, &vol->id))
259                 return VOLSERREAD_DUMPERROR;
260             break;
261         case 'v':
262             if (!ReadInt32(iodp, &trash))
263                 return VOLSERREAD_DUMPERROR;
264             break;
265         case 'n':
266             ReadString(iodp, vol->name, sizeof(vol->name));
267             /*this means the name of the retsored volume could be possibly different. In conjunction with SAFSVolSignalRestore */
268             break;
269         case 's':
270             vol->inService = iod_getc(iodp);
271             break;
272         case 'b':
273             vol->blessed = iod_getc(iodp);
274             break;
275         case 'u':
276             if (!ReadInt32(iodp, &vol->uniquifier))
277                 return VOLSERREAD_DUMPERROR;
278             break;
279         case 't':
280             vol->type = iod_getc(iodp);
281             break;
282         case 'p':
283             if (!ReadInt32(iodp, &vol->parentId))
284                 return VOLSERREAD_DUMPERROR;
285             break;
286         case 'c':
287             if (!ReadInt32(iodp, &vol->cloneId))
288                 return VOLSERREAD_DUMPERROR;
289             break;
290         case 'q':
291             if (!ReadInt32(iodp, (afs_uint32 *) & vol->maxquota))
292                 return VOLSERREAD_DUMPERROR;
293             break;
294         case 'm':
295             if (!ReadInt32(iodp, (afs_uint32 *) & vol->minquota))
296                 return VOLSERREAD_DUMPERROR;
297             break;
298         case 'd':
299             if (!ReadInt32(iodp, (afs_uint32 *) & vol->diskused))
300                 return VOLSERREAD_DUMPERROR;    /* Bogus:  should calculate this */
301             break;
302         case 'f':
303             if (!ReadInt32(iodp, (afs_uint32 *) & vol->filecount))
304                 return VOLSERREAD_DUMPERROR;
305             break;
306         case 'a':
307             if (!ReadInt32(iodp, &vol->accountNumber))
308                 return VOLSERREAD_DUMPERROR;
309             break;
310         case 'o':
311             if (!ReadInt32(iodp, &vol->owner))
312                 return VOLSERREAD_DUMPERROR;
313             break;
314         case 'C':
315             if (!ReadInt32(iodp, &vol->creationDate))
316                 return VOLSERREAD_DUMPERROR;
317             break;
318         case 'A':
319             if (!ReadInt32(iodp, &vol->accessDate))
320                 return VOLSERREAD_DUMPERROR;
321             break;
322         case 'U':
323             if (!ReadInt32(iodp, &vol->updateDate))
324                 return VOLSERREAD_DUMPERROR;
325             break;
326         case 'E':
327             if (!ReadInt32(iodp, &vol->expirationDate))
328                 return VOLSERREAD_DUMPERROR;
329             break;
330         case 'B':
331             if (!ReadInt32(iodp, &vol->backupDate))
332                 return VOLSERREAD_DUMPERROR;
333             break;
334         case 'O':
335             ReadString(iodp, vol->offlineMessage,
336                        sizeof(vol->offlineMessage));
337             break;
338         case 'M':
339             /*
340              * Detailed volume statistics are never stored in dumps,
341              * so we just restore either the null string if this volume
342              * had already been set to store statistics, or the old motd
343              * contents otherwise.  It doesn't matter, since this field
344              * will soon get initialized anyway.
345              */
346             ReadString(iodp, (char *)(vol->stat_reads), VMSGSIZE);
347             break;
348         case 'W':{
349                 unsigned short length;
350                 int i;
351                 afs_uint32 data;
352                 if (!ReadShort(iodp, &length))
353                     return VOLSERREAD_DUMPERROR;
354                 for (i = 0; i < length; i++) {
355                     if (!ReadInt32(iodp, &data))
356                         return VOLSERREAD_DUMPERROR;
357                     if (i < sizeof(vol->weekUse) / sizeof(vol->weekUse[0]))
358                         vol->weekUse[i] = data;
359                 }
360                 break;
361             }
362         case 'D':
363             if (!ReadInt32(iodp, &vol->dayUseDate))
364                 return VOLSERREAD_DUMPERROR;
365             break;
366         case 'Z':
367             if (!ReadInt32(iodp, (afs_uint32 *) & vol->dayUse))
368                 return VOLSERREAD_DUMPERROR;
369             break;
370         }
371     }
372     iod_ungetc(iodp, tag);
373     return 0;
374 }
375
376 static int
377 DumpTag(register struct iod *iodp, register int tag)
378 {
379     char p;
380
381     p = tag;
382     return ((iod_Write(iodp, &p, 1) == 1) ? 0 : VOLSERDUMPERROR);
383
384 }
385
386 static int
387 DumpByte(register struct iod *iodp, char tag, byte value)
388 {
389     char tbuffer[2];
390     register byte *p = (unsigned char *)tbuffer;
391     *p++ = tag;
392     *p = value;
393     return ((iod_Write(iodp, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
394 }
395
396 #define putint32(p, v)  *p++ = v>>24, *p++ = v>>16, *p++ = v>>8, *p++ = v
397 #define putshort(p, v) *p++ = v>>8, *p++ = v
398
399 static int
400 DumpDouble(register struct iod *iodp, char tag, register afs_uint32 value1,
401            register afs_uint32 value2)
402 {
403     char tbuffer[9];
404     register byte *p = (unsigned char *)tbuffer;
405     *p++ = tag;
406     putint32(p, value1);
407     putint32(p, value2);
408     return ((iod_Write(iodp, tbuffer, 9) == 9) ? 0 : VOLSERDUMPERROR);
409 }
410
411 static int
412 DumpInt32(register struct iod *iodp, char tag, register afs_uint32 value)
413 {
414     char tbuffer[5];
415     register byte *p = (unsigned char *)tbuffer;
416     *p++ = tag;
417     putint32(p, value);
418     return ((iod_Write(iodp, tbuffer, 5) == 5) ? 0 : VOLSERDUMPERROR);
419 }
420
421 static int
422 DumpArrayInt32(register struct iod *iodp, char tag,
423                register afs_uint32 * array, register int nelem)
424 {
425     char tbuffer[4];
426     register afs_uint32 v;
427     int code = 0;
428     register byte *p = (unsigned char *)tbuffer;
429     *p++ = tag;
430     putshort(p, nelem);
431     code = iod_Write(iodp, tbuffer, 3);
432     if (code != 3)
433         return VOLSERDUMPERROR;
434     while (nelem--) {
435         p = (unsigned char *)tbuffer;
436         v = *array++;           /*this was register */
437
438         putint32(p, v);
439         code = iod_Write(iodp, tbuffer, 4);
440         if (code != 4)
441             return VOLSERDUMPERROR;
442     }
443     return 0;
444 }
445
446 static int
447 DumpShort(register struct iod *iodp, char tag, unsigned int value)
448 {
449     char tbuffer[3];
450     register byte *p = (unsigned char *)tbuffer;
451     *p++ = tag;
452     *p++ = value >> 8;
453     *p = value;
454     return ((iod_Write(iodp, tbuffer, 3) == 3) ? 0 : VOLSERDUMPERROR);
455 }
456
457 static int
458 DumpBool(register struct iod *iodp, char tag, unsigned int value)
459 {
460     char tbuffer[2];
461     register byte *p = (unsigned char *)tbuffer;
462     *p++ = tag;
463     *p = value;
464     return ((iod_Write(iodp, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
465 }
466
467 static int
468 DumpString(register struct iod *iodp, char tag, register char *s)
469 {
470     register n;
471     int code = 0;
472     code = iod_Write(iodp, &tag, 1);
473     if (code != 1)
474         return VOLSERDUMPERROR;
475     n = strlen(s) + 1;
476     code = iod_Write(iodp, s, n);
477     if (code != n)
478         return VOLSERDUMPERROR;
479     return 0;
480 }
481
482 static int
483 DumpByteString(register struct iod *iodp, char tag, register byte * bs,
484                register int nbytes)
485 {
486     int code = 0;
487
488     code = iod_Write(iodp, &tag, 1);
489     if (code != 1)
490         return VOLSERDUMPERROR;
491     code = iod_Write(iodp, (char *)bs, nbytes);
492     if (code != nbytes)
493         return VOLSERDUMPERROR;
494     return 0;
495 }
496
497 static int
498 DumpFile(struct iod *iodp, int vnode, FdHandle_t * handleP)
499 {
500     int code = 0, lcode = 0, error = 0;
501     afs_int32 pad = 0, offset;
502     afs_sfsize_t n, nbytes, howMany, howBig;
503     byte *p;
504 #ifndef AFS_NT40_ENV
505     struct afs_stat status;
506 #endif
507     afs_sfsize_t size;
508 #ifdef  AFS_AIX_ENV
509 #include <sys/statfs.h>
510     struct statfs tstatfs;
511 #endif
512
513 #ifdef AFS_NT40_ENV
514     howBig = _filelength(handleP->fd_fd);
515     howMany = 4096;
516
517 #else
518     afs_fstat(handleP->fd_fd, &status);
519     howBig = status.st_size;
520
521 #ifdef  AFS_AIX_ENV
522     /* Unfortunately in AIX valuable fields such as st_blksize are 
523      * gone from the stat structure.
524      */
525     fstatfs(handleP->fd_fd, &tstatfs);
526     howMany = tstatfs.f_bsize;
527 #else
528     howMany = status.st_blksize;
529 #endif /* AFS_AIX_ENV */
530 #endif /* AFS_NT40_ENV */
531
532
533     size = FDH_SIZE(handleP);
534 #ifdef AFS_LARGEFILE_ENV
535     {
536         afs_uint32 hi, lo;
537         SplitInt64(size, hi, lo);
538         if (hi == 0L) {
539             code = DumpInt32(iodp, 'f', lo);
540         } else {
541             code = DumpDouble(iodp, 'h', hi, lo);
542         }
543     }
544 #else /* !AFS_LARGEFILE_ENV */
545     code = DumpInt32(iodp, 'f', size);
546 #endif /* !AFS_LARGEFILE_ENV */
547     if (code) {
548         return VOLSERDUMPERROR;
549     }
550
551     p = (unsigned char *)malloc(howMany);
552     if (!p) {
553         Log("1 Volser: DumpFile: no memory");
554         return VOLSERDUMPERROR;
555     }
556
557     for (nbytes = size; (nbytes && !error); nbytes -= howMany) {
558         if (nbytes < howMany)
559             howMany = nbytes;
560
561         /* Read the data - unless we know we can't */
562         n = (lcode ? 0 : FDH_READ(handleP, p, howMany));
563
564         /* If read any good data and we null padded previously, log the
565          * amount that we had null padded.
566          */
567         if ((n > 0) && pad) {
568             Log("1 Volser: DumpFile: Null padding file %d bytes at offset %u\n", pad, offset);
569             pad = 0;
570         }
571
572         /* If didn't read enough data, null padd the rest of the buffer. This
573          * can happen if, for instance, the media has some bad spots. We don't
574          * want to quit the dump, so we start null padding.
575          */
576         if (n < howMany) {
577             /* Record the read error */
578             if (n < 0) {
579                 n = 0;
580                 Log("1 Volser: DumpFile: Error %d reading inode %s for vnode %d\n", errno, PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
581             } else if (!pad) {
582                 Log("1 Volser: DumpFile: Error reading inode %s for vnode %d\n", PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
583             }
584
585             /* Pad the rest of the buffer with zeros. Remember offset we started 
586              * padding. Keep total tally of padding.
587              */
588             memset(p + n, 0, howMany - n);
589             if (!pad)
590                 offset = (howBig - nbytes) + n;
591             pad += (howMany - n);
592
593             /* Now seek over the data we could not get. An error here means we
594              * can't do the next read.
595              */
596             lcode = FDH_SEEK(handleP, ((size - nbytes) + howMany), SEEK_SET);
597             if (lcode != ((size - nbytes) + howMany)) {
598                 if (lcode < 0) {
599                     Log("1 Volser: DumpFile: Error %d seeking in inode %s for vnode %d\n", errno, PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
600                 } else {
601                     Log("1 Volser: DumpFile: Error seeking in inode %s for vnode %d\n", PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
602                     lcode = -1;
603                 }
604             } else {
605                 lcode = 0;
606             }
607         }
608
609         /* Now write the data out */
610         if (iod_Write(iodp, (char *)p, howMany) != howMany)
611             error = VOLSERDUMPERROR;
612         IOMGR_Poll();
613     }
614
615     if (pad) {                  /* Any padding we hadn't reported yet */
616         Log("1 Volser: DumpFile: Null padding file: %d bytes at offset %u\n",
617             pad, offset);
618     }
619
620     free(p);
621     return error;
622 }
623
624 static int
625 DumpVolumeHeader(register struct iod *iodp, register Volume * vp)
626 {
627     int code = 0;
628     static char nullString[1] = "";     /*The ``contents'' of motd */
629
630     if (!code)
631         code = DumpTag(iodp, D_VOLUMEHEADER);
632     if (!code) {
633         code = DumpInt32(iodp, 'i', V_id(vp));
634     }
635     if (!code)
636         code = DumpInt32(iodp, 'v', V_stamp(vp).version);
637     if (!code)
638         code = DumpString(iodp, 'n', V_name(vp));
639     if (!code)
640         code = DumpBool(iodp, 's', V_inService(vp));
641     if (!code)
642         code = DumpBool(iodp, 'b', V_blessed(vp));
643     if (!code)
644         code = DumpInt32(iodp, 'u', V_uniquifier(vp));
645     if (!code)
646         code = DumpByte(iodp, 't', (byte) V_type(vp));
647     if (!code) {
648         code = DumpInt32(iodp, 'p', V_parentId(vp));
649     }
650     if (!code)
651         code = DumpInt32(iodp, 'c', V_cloneId(vp));
652     if (!code)
653         code = DumpInt32(iodp, 'q', V_maxquota(vp));
654     if (!code)
655         code = DumpInt32(iodp, 'm', V_minquota(vp));
656     if (!code)
657         code = DumpInt32(iodp, 'd', V_diskused(vp));
658     if (!code)
659         code = DumpInt32(iodp, 'f', V_filecount(vp));
660     if (!code)
661         code = DumpInt32(iodp, 'a', V_accountNumber(vp));
662     if (!code)
663         code = DumpInt32(iodp, 'o', V_owner(vp));
664     if (!code)
665         code = DumpInt32(iodp, 'C', V_creationDate(vp));        /* Rw volume creation date */
666     if (!code)
667         code = DumpInt32(iodp, 'A', V_accessDate(vp));
668     if (!code)
669         code = DumpInt32(iodp, 'U', V_updateDate(vp));
670     if (!code)
671         code = DumpInt32(iodp, 'E', V_expirationDate(vp));
672     if (!code)
673         code = DumpInt32(iodp, 'B', V_backupDate(vp));  /* Rw volume backup clone date */
674     if (!code)
675         code = DumpString(iodp, 'O', V_offlineMessage(vp));
676     /*
677      * We do NOT dump the detailed volume statistics residing in the old
678      * motd field, since we cannot tell from the info in a dump whether
679      * statistics data has been put there.  Instead, we dump a null string,
680      * just as if that was what the motd contained.
681      */
682     if (!code)
683         code = DumpString(iodp, 'M', nullString);
684     if (!code)
685         code =
686             DumpArrayInt32(iodp, 'W', (afs_uint32 *) V_weekUse(vp),
687                            sizeof(V_weekUse(vp)) / sizeof(V_weekUse(vp)[0]));
688     if (!code)
689         code = DumpInt32(iodp, 'D', V_dayUseDate(vp));
690     if (!code)
691         code = DumpInt32(iodp, 'Z', V_dayUse(vp));
692     return code;
693 }
694
695 static int
696 DumpEnd(register struct iod *iodp)
697 {
698     return (DumpInt32(iodp, D_DUMPEND, DUMPENDMAGIC));
699 }
700
701 /* Guts of the dump code */
702
703 /* Dump a whole volume */
704 int
705 DumpVolume(register struct rx_call *call, register Volume * vp,
706            afs_int32 fromtime, int dumpAllDirs)
707 {
708     struct iod iod;
709     int code = 0;
710     register struct iod *iodp = &iod;
711     iod_Init(iodp, call);
712
713     if (!code)
714         code = DumpDumpHeader(iodp, vp, fromtime);
715
716     if (!code)
717         code = DumpPartial(iodp, vp, fromtime, dumpAllDirs);
718
719 /* hack follows.  Errors should be handled quite differently in this version of dump than they used to be.*/
720     if (rx_Error(iodp->call)) {
721         Log("1 Volser: DumpVolume: Rx call failed during dump, error %d\n",
722             rx_Error(iodp->call));
723         return VOLSERDUMPERROR;
724     }
725     if (!code)
726         code = DumpEnd(iodp);
727
728     return code;
729 }
730
731 /* Dump a volume to multiple places*/
732 int
733 DumpVolMulti(struct rx_call **calls, int ncalls, Volume * vp,
734              afs_int32 fromtime, int dumpAllDirs, int *codes)
735 {
736     struct iod iod;
737     int code = 0;
738     iod_InitMulti(&iod, calls, ncalls, codes);
739
740     if (!code)
741         code = DumpDumpHeader(&iod, vp, fromtime);
742     if (!code)
743         code = DumpPartial(&iod, vp, fromtime, dumpAllDirs);
744     if (!code)
745         code = DumpEnd(&iod);
746     return code;
747 }
748
749 /* A partial dump (no dump header) */
750 static int
751 DumpPartial(register struct iod *iodp, register Volume * vp,
752             afs_int32 fromtime, int dumpAllDirs)
753 {
754     int code = 0;
755     if (!code)
756         code = DumpVolumeHeader(iodp, vp);
757     if (!code)
758         code = DumpVnodeIndex(iodp, vp, vLarge, fromtime, dumpAllDirs);
759     if (!code)
760         code = DumpVnodeIndex(iodp, vp, vSmall, fromtime, 0);
761     return code;
762 }
763
764 static int
765 DumpVnodeIndex(register struct iod *iodp, Volume * vp, VnodeClass class,
766                afs_int32 fromtime, int forcedump)
767 {
768     register int code = 0;
769     register struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
770     char buf[SIZEOF_LARGEDISKVNODE];
771     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
772     StreamHandle_t *file;
773     FdHandle_t *fdP;
774     int size;
775     int flag;
776     register int vnodeIndex, nVnodes;
777
778     fdP = IH_OPEN(vp->vnodeIndex[class].handle);
779     assert(fdP != NULL);
780     file = FDH_FDOPEN(fdP, "r+");
781     assert(file != NULL);
782     size = OS_SIZE(fdP->fd_fd);
783     assert(size != -1);
784     nVnodes = (size / vcp->diskSize) - 1;
785     if (nVnodes > 0) {
786         assert((nVnodes + 1) * vcp->diskSize == size);
787         assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
788     } else
789         nVnodes = 0;
790     for (vnodeIndex = 0;
791          nVnodes && STREAM_READ(vnode, vcp->diskSize, 1, file) == 1 && !code;
792          nVnodes--, vnodeIndex++) {
793         flag = forcedump || (vnode->serverModifyTime >= fromtime);
794         /* Note:  the >= test is very important since some old volumes may not have
795          * a serverModifyTime.  For an epoch dump, this results in 0>=0 test, which
796          * does dump the file! */
797         if (!code)
798             code =
799                 DumpVnode(iodp, vnode, V_id(vp),
800                           bitNumberToVnodeNumber(vnodeIndex, class), flag);
801         if (!flag)
802             IOMGR_Poll();       /* if we dont' xfr data, but scan instead, could lose conn */
803     }
804     STREAM_CLOSE(file);
805     FDH_CLOSE(fdP);
806     return code;
807 }
808
809 static int
810 DumpDumpHeader(register struct iod *iodp, register Volume * vp,
811                afs_int32 fromtime)
812 {
813     int code = 0;
814     int UseLatestReadOnlyClone = 1;
815     afs_int32 dumpTimes[2];
816     iodp->device = vp->device;
817     iodp->parentId = V_parentId(vp);
818     iodp->dumpPartition = vp->partition;
819     if (!code)
820         code = DumpDouble(iodp, D_DUMPHEADER, DUMPBEGINMAGIC, DUMPVERSION);
821     if (!code)
822         code =
823             DumpInt32(iodp, 'v',
824                       UseLatestReadOnlyClone ? V_id(vp) : V_parentId(vp));
825     if (!code)
826         code = DumpString(iodp, 'n', V_name(vp));
827     dumpTimes[0] = fromtime;
828     dumpTimes[1] = V_backupDate(vp);    /* Until the time the clone was made */
829     if (!code)
830         code = DumpArrayInt32(iodp, 't', (afs_uint32 *) dumpTimes, 2);
831     return code;
832 }
833
834 static int
835 DumpVnode(register struct iod *iodp, struct VnodeDiskObject *v, int volid,
836           int vnodeNumber, int dumpEverything)
837 {
838     int code = 0;
839     IHandle_t *ihP;
840     FdHandle_t *fdP;
841
842     if (!v || v->type == vNull)
843         return code;
844     if (!code)
845         code = DumpDouble(iodp, D_VNODE, vnodeNumber, v->uniquifier);
846     if (!dumpEverything)
847         return code;
848     if (!code)
849         code = DumpByte(iodp, 't', (byte) v->type);
850     if (!code)
851         code = DumpShort(iodp, 'l', v->linkCount);      /* May not need this */
852     if (!code)
853         code = DumpInt32(iodp, 'v', v->dataVersion);
854     if (!code)
855         code = DumpInt32(iodp, 'm', v->unixModifyTime);
856     if (!code)
857         code = DumpInt32(iodp, 'a', v->author);
858     if (!code)
859         code = DumpInt32(iodp, 'o', v->owner);
860     if (!code && v->group)
861         code = DumpInt32(iodp, 'g', v->group);  /* default group is 0 */
862     if (!code)
863         code = DumpShort(iodp, 'b', v->modeBits);
864     if (!code)
865         code = DumpInt32(iodp, 'p', v->parent);
866     if (!code)
867         code = DumpInt32(iodp, 's', v->serverModifyTime);
868     if (v->type == vDirectory) {
869         acl_HtonACL(VVnodeDiskACL(v));
870         if (!code)
871             code =
872                 DumpByteString(iodp, 'A', (byte *) VVnodeDiskACL(v),
873                                VAclDiskSize(v));
874     }
875     if (VNDISK_GET_INO(v)) {
876         IH_INIT(ihP, iodp->device, iodp->parentId, VNDISK_GET_INO(v));
877         fdP = IH_OPEN(ihP);
878         if (fdP == NULL) {
879             Log("1 Volser: DumpVnode: dump: Unable to open inode %llu for vnode %u (volume %i); not dumped, error %d\n", (afs_uintmax_t) VNDISK_GET_INO(v), vnodeNumber, volid, errno);
880             IH_RELEASE(ihP);
881             return VOLSERREAD_DUMPERROR;
882         }
883         code = DumpFile(iodp, vnodeNumber, fdP);
884         FDH_CLOSE(fdP);
885         IH_RELEASE(ihP);
886     }
887     return code;
888 }
889
890
891 int
892 ProcessIndex(Volume * vp, VnodeClass class, afs_int32 ** Bufp, int *sizep,
893              int del)
894 {
895     int i, nVnodes, offset, code, index = 0;
896     afs_int32 *Buf;
897     int cnt = 0;
898     int size;
899     StreamHandle_t *afile;
900     FdHandle_t *fdP;
901     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
902     char buf[SIZEOF_LARGEDISKVNODE], zero[SIZEOF_LARGEDISKVNODE];
903     register struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
904
905     memset(zero, 0, sizeof(zero));      /* zero out our proto-vnode */
906     fdP = IH_OPEN(vp->vnodeIndex[class].handle);
907     if (fdP == NULL)
908         return -1;
909     afile = FDH_FDOPEN(fdP, "r+");
910     if (del) {
911         int cnt1 = 0;
912         Buf = *Bufp;
913         for (i = 0; i < *sizep; i++) {
914             if (Buf[i]) {
915                 cnt++;
916                 STREAM_SEEK(afile, Buf[i], 0);
917                 code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
918                 if (code == 1) {
919                     if (vnode->type != vNull && VNDISK_GET_INO(vnode)) {
920                         cnt1++;
921                         if (DoLogging) {
922                             afs_fsize_t vnodeLength;
923                             Log("RestoreVolume %u Cleanup: Removing old vnode=%u inode=%llu size=%llu\n", V_id(vp), bitNumberToVnodeNumber(i, class), (afs_uintmax_t) VNDISK_GET_INO(vnode), (afs_uintmax_t) vnodeLength);
924                         }
925                         IH_DEC(V_linkHandle(vp), VNDISK_GET_INO(vnode),
926                                V_parentId(vp));
927                         DOPOLL;
928                     }
929                     STREAM_SEEK(afile, Buf[i], 0);
930                     (void)STREAM_WRITE(zero, vcp->diskSize, 1, afile);  /* Zero it out */
931                 }
932                 Buf[i] = 0;
933             }
934         }
935         if (DoLogging) {
936             Log("RestoreVolume Cleanup: Removed %d inodes for volume %d\n",
937                 cnt1, V_id(vp));
938         }
939         STREAM_FLUSH(afile);    /* ensure 0s are on the disk */
940         OS_SYNC(afile->str_fd);
941     } else {
942         size = OS_SIZE(fdP->fd_fd);
943         assert(size != -1);
944         nVnodes =
945             (size <=
946              vcp->diskSize ? 0 : size - vcp->diskSize) >> vcp->logSize;
947         if (nVnodes > 0) {
948             Buf = (afs_int32 *) malloc(nVnodes * sizeof(afs_int32));
949             if (Buf == NULL)
950                 return 1;
951             memset((char *)Buf, 0, nVnodes * sizeof(afs_int32));
952             STREAM_SEEK(afile, offset = vcp->diskSize, 0);
953             while (1) {
954                 code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
955                 if (code != 1) {
956                     break;
957                 }
958                 if (vnode->type != vNull && VNDISK_GET_INO(vnode)) {
959                     Buf[(offset >> vcp->logSize) - 1] = offset;
960                     cnt++;
961                 }
962                 offset += vcp->diskSize;
963             }
964             *Bufp = Buf;
965             *sizep = nVnodes;
966         }
967     }
968     STREAM_CLOSE(afile);
969     FDH_CLOSE(fdP);
970     return 0;
971 }
972
973
974 int
975 RestoreVolume(register struct rx_call *call, Volume * avp, int incremental,
976               struct restoreCookie *cookie)
977 {
978     VolumeDiskData vol;
979     struct DumpHeader header;
980     afs_uint32 endMagic;
981     Error error = 0, vupdate;
982     register Volume *vp;
983     struct iod iod;
984     register struct iod *iodp = &iod;
985     afs_int32 *b1 = 0, *b2 = 0;
986     int s1 = 0, s2 = 0, delo = 0, tdelo;
987     int tag;
988
989     iod_Init(iodp, call);
990
991     vp = avp;
992     if (!ReadDumpHeader(iodp, &header)) {
993         Log("1 Volser: RestoreVolume: Error reading header file for dump; aborted\n");
994         return VOLSERREAD_DUMPERROR;
995     }
996     if (iod_getc(iodp) != D_VOLUMEHEADER) {
997         Log("1 Volser: RestoreVolume: Volume header missing from dump; not restored\n");
998         return VOLSERREAD_DUMPERROR;
999     }
1000     if (ReadVolumeHeader(iodp, &vol) == VOLSERREAD_DUMPERROR)
1001         return VOLSERREAD_DUMPERROR;
1002
1003     delo = ProcessIndex(vp, vLarge, &b1, &s1, 0);
1004     if (!delo)
1005         delo = ProcessIndex(vp, vSmall, &b2, &s2, 0);
1006     if (delo) {
1007         if (b1)
1008             free((char *)b1);
1009         if (b2)
1010             free((char *)b2);
1011         b1 = b2 = 0;
1012     }
1013
1014     strncpy(vol.name, cookie->name, VOLSER_OLDMAXVOLNAME);
1015     vol.type = cookie->type;
1016     vol.cloneId = cookie->clone;
1017     vol.parentId = cookie->parent;
1018
1019
1020     tdelo = delo;
1021     while (1) {
1022         if (ReadVnodes(iodp, vp, 0, b1, s1, b2, s2, tdelo)) {
1023             error = VOLSERREAD_DUMPERROR;
1024             goto clean;
1025         }
1026         tag = iod_getc(iodp);
1027         if (tag != D_VOLUMEHEADER)
1028             break;
1029         if (ReadVolumeHeader(iodp, &vol) == VOLSERREAD_DUMPERROR) {
1030             error = VOLSERREAD_DUMPERROR;
1031             goto out;
1032         }
1033         tdelo = -1;
1034     }
1035     if (tag != D_DUMPEND || !ReadInt32(iodp, &endMagic)
1036         || endMagic != DUMPENDMAGIC) {
1037         Log("1 Volser: RestoreVolume: End of dump not found; restore aborted\n");
1038         error = VOLSERREAD_DUMPERROR;
1039         goto clean;
1040     }
1041
1042
1043     if (iod_getc(iodp) != EOF) {
1044         Log("1 Volser: RestoreVolume: Unrecognized postamble in dump; restore aborted\n");
1045         error = VOLSERREAD_DUMPERROR;
1046         goto clean;
1047     }
1048
1049     if (!delo) {
1050         ProcessIndex(vp, vLarge, &b1, &s1, 1);
1051         ProcessIndex(vp, vSmall, &b2, &s2, 1);
1052     }
1053
1054   clean:
1055     ClearVolumeStats(&vol);
1056     CopyVolumeHeader(&vol, &V_disk(vp));
1057     V_destroyMe(vp) = 0;
1058     VUpdateVolume(&vupdate, vp);
1059     if (vupdate) {
1060         Log("1 Volser: RestoreVolume: Unable to rewrite volume header; restore aborted\n");
1061         error = VOLSERREAD_DUMPERROR;
1062         goto out;
1063     }
1064   out:
1065     /* Free the malloced space above */
1066     if (b1)
1067         free((char *)b1);
1068     if (b2)
1069         free((char *)b2);
1070     return error;
1071 }
1072
1073 static int
1074 ReadVnodes(register struct iod *iodp, Volume * vp, int incremental,
1075            afs_int32 * Lbuf, afs_int32 s1, afs_int32 * Sbuf, afs_int32 s2,
1076            afs_int32 delo)
1077 {
1078     afs_int32 vnodeNumber;
1079     char buf[SIZEOF_LARGEDISKVNODE];
1080     register tag;
1081     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
1082     struct VnodeDiskObject oldvnode;
1083     int idx;
1084     VnodeClass class;
1085     struct VnodeClassInfo *vcp;
1086     IHandle_t *tmpH;
1087     FdHandle_t *fdP;
1088     Inode nearInode;
1089
1090     tag = iod_getc(iodp);
1091     V_pref(vp, nearInode);
1092     while (tag == D_VNODE) {
1093         int haveStuff = 0;
1094         memset(buf, 0, sizeof(buf));
1095         if (!ReadInt32(iodp, (afs_uint32 *) & vnodeNumber))
1096             break;
1097
1098         ReadInt32(iodp, &vnode->uniquifier);
1099         while ((tag = iod_getc(iodp)) > D_MAX && tag != EOF) {
1100             haveStuff = 1;
1101             switch (tag) {
1102             case 't':
1103                 vnode->type = (VnodeType) iod_getc(iodp);
1104                 break;
1105             case 'l':
1106                 {
1107                     unsigned short tlc;
1108                     ReadShort(iodp, &tlc);
1109                     vnode->linkCount = (signed int)tlc;
1110                 }
1111                 break;
1112             case 'v':
1113                 ReadInt32(iodp, &vnode->dataVersion);
1114                 break;
1115             case 'm':
1116                 ReadInt32(iodp, &vnode->unixModifyTime);
1117                 break;
1118             case 's':
1119                 ReadInt32(iodp, &vnode->serverModifyTime);
1120                 break;
1121             case 'a':
1122                 ReadInt32(iodp, &vnode->author);
1123                 break;
1124             case 'o':
1125                 ReadInt32(iodp, &vnode->owner);
1126                 break;
1127             case 'g':
1128                 ReadInt32(iodp, (afs_uint32 *) & vnode->group);
1129                 break;
1130             case 'b':{
1131                     unsigned short modeBits;
1132                     ReadShort(iodp, &modeBits);
1133                     vnode->modeBits = (unsigned int)modeBits;
1134                     break;
1135                 }
1136             case 'p':
1137                 ReadInt32(iodp, &vnode->parent);
1138                 break;
1139             case 'A':
1140                 ReadByteString(iodp, (byte *) VVnodeDiskACL(vnode),
1141                                VAclDiskSize(vnode));
1142                 acl_NtohACL(VVnodeDiskACL(vnode));
1143                 break;
1144 #ifdef AFS_LARGEFILE_ENV
1145             case 'h':
1146 #endif
1147             case 'f':{
1148                     Inode ino;
1149                     Error error;
1150                     afs_fsize_t vnodeLength;
1151
1152                     ino =
1153                         IH_CREATE(V_linkHandle(vp), V_device(vp),
1154                                   VPartitionPath(V_partition(vp)), nearInode,
1155                                   V_parentId(vp), vnodeNumber,
1156                                   vnode->uniquifier, vnode->dataVersion);
1157                     if (!VALID_INO(ino)) {
1158                         perror("unable to allocate inode");
1159                         Log("1 Volser: ReadVnodes: Restore aborted\n");
1160                         return VOLSERREAD_DUMPERROR;
1161                     }
1162                     nearInode = ino;
1163                     VNDISK_SET_INO(vnode, ino);
1164                     IH_INIT(tmpH, vp->device, V_parentId(vp), ino);
1165                     fdP = IH_OPEN(tmpH);
1166                     if (fdP == NULL) {
1167                         IH_RELEASE(tmpH);
1168                         return VOLSERREAD_DUMPERROR;
1169                     }
1170                     vnodeLength =
1171                         volser_WriteFile(vnodeNumber, iodp, fdP, tag, &error);
1172                     VNDISK_SET_LEN(vnode, vnodeLength);
1173                     FDH_REALLYCLOSE(fdP);
1174                     IH_RELEASE(tmpH);
1175                     if (error) {
1176                         Log("1 Volser: ReadVnodes: IDEC inode %llu\n",
1177                             (afs_uintmax_t) ino);
1178                         IH_DEC(V_linkHandle(vp), ino, V_parentId(vp));
1179                         return VOLSERREAD_DUMPERROR;
1180                     }
1181                     break;
1182                 }
1183             }
1184         }
1185
1186         class = vnodeIdToClass(vnodeNumber);
1187         vcp = &VnodeClassInfo[class];
1188
1189         /* Mark this vnode as in this dump - so we don't delete it later */
1190         if (!delo) {
1191             idx = (vnodeIndexOffset(vcp, vnodeNumber) >> vcp->logSize) - 1;
1192             if (class == vLarge) {
1193                 if (Lbuf && (idx < s1))
1194                     Lbuf[idx] = 0;
1195             } else {
1196                 if (Sbuf && (idx < s2))
1197                     Sbuf[idx] = 0;
1198             }
1199         }
1200
1201         if (haveStuff) {
1202             FdHandle_t *fdP = IH_OPEN(vp->vnodeIndex[class].handle);
1203             if (fdP == NULL) {
1204                 Log("1 Volser: ReadVnodes: Error opening vnode index; restore aborted\n");
1205                 return VOLSERREAD_DUMPERROR;
1206             }
1207             if (FDH_SEEK(fdP, vnodeIndexOffset(vcp, vnodeNumber), SEEK_SET) <
1208                 0) {
1209                 Log("1 Volser: ReadVnodes: Error seeking into vnode index; restore aborted\n");
1210                 FDH_REALLYCLOSE(fdP);
1211                 return VOLSERREAD_DUMPERROR;
1212             }
1213             if (FDH_READ(fdP, &oldvnode, sizeof(oldvnode)) ==
1214                 sizeof(oldvnode)) {
1215                 if (oldvnode.type != vNull && VNDISK_GET_INO(&oldvnode)) {
1216                     IH_DEC(V_linkHandle(vp), VNDISK_GET_INO(&oldvnode),
1217                            V_parentId(vp));
1218                 }
1219             }
1220             vnode->vnodeMagic = vcp->magic;
1221             if (FDH_SEEK(fdP, vnodeIndexOffset(vcp, vnodeNumber), SEEK_SET) <
1222                 0) {
1223                 Log("1 Volser: ReadVnodes: Error seeking into vnode index; restore aborted\n");
1224                 FDH_REALLYCLOSE(fdP);
1225                 return VOLSERREAD_DUMPERROR;
1226             }
1227             if (FDH_WRITE(fdP, vnode, vcp->diskSize) != vcp->diskSize) {
1228                 Log("1 Volser: ReadVnodes: Error writing vnode index; restore aborted\n");
1229                 FDH_REALLYCLOSE(fdP);
1230                 return VOLSERREAD_DUMPERROR;
1231             }
1232             FDH_CLOSE(fdP);
1233         }
1234     }
1235     iod_ungetc(iodp, tag);
1236
1237
1238     return 0;
1239 }
1240
1241
1242 /* called with disk file only.  Note that we don't have to worry about rx_Read
1243  * needing to read an ungetc'd character, since the ReadInt32 will have read
1244  * it instead.
1245  */
1246 static afs_fsize_t
1247 volser_WriteFile(int vn, struct iod *iodp, FdHandle_t * handleP, int tag,
1248                  Error * status)
1249 {
1250     afs_int32 code;
1251     afs_fsize_t filesize;
1252     afs_fsize_t written = 0;
1253     register afs_uint32 size = 8192;
1254     register afs_fsize_t nbytes;
1255     unsigned char *p;
1256
1257
1258     *status = 0;
1259 #ifdef AFS_64BIT_ENV
1260     {
1261         afs_uint32 filesize_high = 0L, filesize_low = 0L;
1262 #ifdef AFS_LARGEFILE_ENV
1263         if (tag == 'h') {
1264             if (!ReadInt32(iodp, &filesize_high)) {
1265                 *status = 1;
1266                 return 0;
1267             }
1268         }
1269 #endif /* !AFS_LARGEFILE_ENV */
1270         if (!ReadInt32(iodp, &filesize_low)) {
1271             *status = 1;
1272             return 0;
1273         }
1274         FillInt64(filesize, filesize_high, filesize_low);
1275     }
1276 #else /* !AFS_64BIT_ENV */
1277     if (!ReadInt32(iodp, &filesize)) {
1278         *status = 1;
1279         return (0);
1280     }
1281 #endif /* !AFS_64BIT_ENV */
1282     p = (unsigned char *)malloc(size);
1283     if (p == NULL) {
1284         *status = 2;
1285         return (0);
1286     }
1287     for (nbytes = filesize; nbytes; nbytes -= size) {
1288         if (nbytes < size)
1289             size = nbytes;
1290
1291         if ((code = iod_Read(iodp, p, size)) != size) {
1292             Log("1 Volser: WriteFile: Error reading dump file %d size=%llu nbytes=%u (%d of %u); restore aborted\n", vn, (afs_uintmax_t) filesize, nbytes, code, size);
1293             *status = 3;
1294             break;
1295         }
1296         code = FDH_WRITE(handleP, p, size);
1297         if (code > 0)
1298             written += code;
1299         if (code != size) {
1300             Log("1 Volser: WriteFile: Error creating file in volume; restore aborted\n");
1301             *status = 4;
1302             break;
1303         }
1304     }
1305     free(p);
1306     return (written);
1307 }
1308
1309 static int
1310 ReadDumpHeader(register struct iod *iodp, struct DumpHeader *hp)
1311 {
1312     register tag;
1313     afs_uint32 beginMagic;
1314     if (iod_getc(iodp) != D_DUMPHEADER || !ReadInt32(iodp, &beginMagic)
1315         || !ReadInt32(iodp, (afs_uint32 *) & hp->version)
1316         || beginMagic != DUMPBEGINMAGIC)
1317         return 0;
1318     hp->volumeId = 0;
1319     hp->nDumpTimes = 0;
1320     while ((tag = iod_getc(iodp)) > D_MAX) {
1321         unsigned short arrayLength;
1322         register int i;
1323         switch (tag) {
1324         case 'v':
1325             if (!ReadInt32(iodp, &hp->volumeId))
1326                 return 0;
1327             break;
1328         case 'n':
1329             ReadString(iodp, hp->volumeName, sizeof(hp->volumeName));
1330             break;
1331         case 't':
1332             if (!ReadShort(iodp, &arrayLength))
1333                 return 0;
1334             hp->nDumpTimes = (arrayLength >> 1);
1335             for (i = 0; i < hp->nDumpTimes; i++)
1336                 if (!ReadInt32(iodp, (afs_uint32 *) & hp->dumpTimes[i].from)
1337                     || !ReadInt32(iodp, (afs_uint32 *) & hp->dumpTimes[i].to))
1338                     return 0;
1339             break;
1340         }
1341     }
1342     if (!hp->volumeId || !hp->nDumpTimes) {
1343         return 0;
1344     }
1345     iod_ungetc(iodp, tag);
1346     return 1;
1347 }
1348
1349
1350 /* ----- Below are the calls that calculate dump size ----- */
1351
1352 static int
1353 SizeDumpVolumeHeader(register struct iod *iodp, register Volume * vp,
1354                      register struct volintSize *v_size)
1355 {
1356     int code = 0;
1357     static char nullString[1] = "";     /*The ``contents'' of motd */
1358     afs_uint64 addvar;
1359
1360 /*     if (!code) code = DumpTag(iodp, D_VOLUMEHEADER); */
1361     FillInt64(addvar,0, 1);
1362     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1363 /*     if (!code) {code = DumpInt32(iodp, 'i',V_id(vp));} */
1364     FillInt64(addvar,0, 5);
1365     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1366 /*     if (!code) code = DumpInt32(iodp, 'v',V_stamp(vp).version); */
1367     FillInt64(addvar,0, 5);
1368     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1369 /*     if (!code) code = DumpString(iodp, 'n',V_name(vp)); */
1370     FillInt64(addvar,0, (2 + strlen(V_name(vp))));
1371     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1372 /*     if (!code) code = DumpBool(iodp, 's',V_inService(vp)); */
1373     FillInt64(addvar,0, 2);
1374     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1375 /*     if (!code) code = DumpBool(iodp, 'b',V_blessed(vp)); */
1376     FillInt64(addvar,0, 2);
1377     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1378 /*     if (!code) code = DumpInt32(iodp, 'u',V_uniquifier(vp)); */
1379     FillInt64(addvar,0, 5);
1380     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1381 /*     if (!code) code = DumpByte(iodp, 't',(byte)V_type(vp)); */
1382     FillInt64(addvar,0, 2);
1383     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1384 /*     if (!code){ code = DumpInt32(iodp, 'p',V_parentId(vp));} */
1385     FillInt64(addvar,0, 5);
1386     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1387 /*     if (!code) code = DumpInt32(iodp, 'c',V_cloneId(vp)); */
1388     FillInt64(addvar,0, 5);
1389     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1390 /*     if (!code) code = DumpInt32(iodp, 'q',V_maxquota(vp)); */
1391     FillInt64(addvar,0, 5);
1392     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1393 /*     if (!code) code = DumpInt32(iodp, 'm',V_minquota(vp)); */
1394     FillInt64(addvar,0, 5);
1395     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1396 /*     if (!code) code = DumpInt32(iodp, 'd',V_diskused(vp)); */
1397     FillInt64(addvar,0, 5);
1398     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1399 /*     if (!code) code = DumpInt32(iodp, 'f',V_filecount(vp)); */
1400     FillInt64(addvar,0, 5);
1401     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1402 /*     if (!code) code = DumpInt32(iodp, 'a', V_accountNumber(vp)); */
1403     FillInt64(addvar,0, 5);
1404     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1405 /*     if (!code) code = DumpInt32(iodp, 'o', V_owner(vp)); */
1406     FillInt64(addvar,0, 5);
1407     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1408 /*     if (!code) code = DumpInt32(iodp, 'C',V_creationDate(vp));       /\* Rw volume creation date *\/ */
1409     FillInt64(addvar,0, 5);
1410     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1411 /*     if (!code) code = DumpInt32(iodp, 'A',V_accessDate(vp)); */
1412     FillInt64(addvar,0, 5);
1413     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1414 /*     if (!code) code = DumpInt32(iodp, 'U',V_updateDate(vp)); */
1415     FillInt64(addvar,0, 5);
1416     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1417 /*     if (!code) code = DumpInt32(iodp, 'E',V_expirationDate(vp)); */
1418     FillInt64(addvar,0, 5);
1419     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1420 /*     if (!code) code = DumpInt32(iodp, 'B',V_backupDate(vp));         /\* Rw volume backup clone date *\/ */
1421     FillInt64(addvar,0, 5);
1422     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1423 /*     if (!code) code = DumpString(iodp, 'O',V_offlineMessage(vp)); */
1424     FillInt64(addvar,0, (2 + strlen(V_offlineMessage(vp))));
1425     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1426 /*     /\* */
1427 /*      * We do NOT dump the detailed volume statistics residing in the old */
1428 /*      * motd field, since we cannot tell from the info in a dump whether */
1429 /*      * statistics data has been put there.  Instead, we dump a null string, */
1430 /*      * just as if that was what the motd contained. */
1431 /*      *\/ */
1432 /*     if (!code) code = DumpString(iodp, 'M', nullString); */
1433     FillInt64(addvar,0, (2 + strlen(nullString)));
1434     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1435 /*     if (!code) code = DumpArrayInt32(iodp, 'W', (afs_uint32 *)V_weekUse(vp), sizeof(V_weekUse(vp))/sizeof(V_weekUse(vp)[0])); */
1436     FillInt64(addvar,0, (3 + 4 * (sizeof(V_weekUse(vp)) / sizeof(V_weekUse(vp)[0]))));
1437     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1438 /*     if (!code) code = DumpInt32(iodp, 'D', V_dayUseDate(vp)); */
1439     FillInt64(addvar,0, 5);
1440     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1441 /*     if (!code) code = DumpInt32(iodp, 'Z', V_dayUse(vp)); */
1442     FillInt64(addvar,0, 5);
1443     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1444     return code;
1445 }
1446
1447 static int
1448 SizeDumpEnd(register struct iod *iodp, register struct volintSize *v_size)
1449 {
1450     int code = 0;
1451     afs_uint64 addvar;
1452     FillInt64(addvar,0, 5);
1453     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1454     return code;
1455 }
1456
1457 int
1458 SizeDumpVolume(register struct rx_call *call, register Volume * vp,
1459                afs_int32 fromtime, int dumpAllDirs,
1460                register struct volintSize *v_size)
1461 {
1462     struct iod iod;
1463     int code = 0;
1464     register struct iod *iodp = (struct iod *)0;
1465 /*    iod_Init(iodp, call); */
1466
1467     if (!code)
1468         code = SizeDumpDumpHeader(iodp, vp, fromtime, v_size);
1469     if (!code)
1470         code = SizeDumpPartial(iodp, vp, fromtime, dumpAllDirs, v_size);
1471     if (!code)
1472         code = SizeDumpEnd(iodp, v_size);
1473
1474     return code;
1475 }
1476
1477 static int
1478 SizeDumpDumpHeader(register struct iod *iodp, register Volume * vp,
1479                    afs_int32 fromtime, register struct volintSize *v_size)
1480 {
1481     int code = 0;
1482     int UseLatestReadOnlyClone = 1;
1483     afs_int32 dumpTimes[2];
1484     afs_uint64 addvar;
1485 /*    iodp->device = vp->device; */
1486 /*    iodp->parentId = V_parentId(vp); */
1487 /*    iodp->dumpPartition = vp->partition; */
1488
1489     ZeroInt64(v_size->dump_size);       /* initialize the size */
1490 /*     if (!code) code = DumpDouble(iodp, D_DUMPHEADER, DUMPBEGINMAGIC, DUMPVERSION); */
1491     FillInt64(addvar,0, 9);
1492     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1493 /*     if (!code) code = DumpInt32(iodp, 'v', UseLatestReadOnlyClone? V_id(vp): V_parentId(vp)); */
1494     FillInt64(addvar,0, 5);
1495     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1496 /*     if (!code) code = DumpString(iodp, 'n',V_name(vp)); */
1497     FillInt64(addvar,0, (2 + strlen(V_name(vp))));
1498     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1499 /*     dumpTimes[0] = fromtime; */
1500 /*     dumpTimes[1] = V_backupDate(vp); /\* Until the time the clone was made *\/ */
1501 /*     if (!code) code = DumpArrayInt32(iodp, 't', (afs_uint32 *)dumpTimes, 2); */
1502     FillInt64(addvar,0, (3 + 4 * 2));
1503     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1504     return code;
1505 }
1506
1507 static int
1508 SizeDumpVnode(register struct iod *iodp, struct VnodeDiskObject *v, int volid,
1509               int vnodeNumber, int dumpEverything,
1510               register struct volintSize *v_size)
1511 {
1512     int code = 0;
1513     afs_uint64 addvar;
1514
1515     if (!v || v->type == vNull)
1516         return code;
1517 /*     if (!code) code = DumpDouble(iodp, D_VNODE, vnodeNumber, v->uniquifier); */
1518     FillInt64(addvar,0, 9);
1519     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1520     if (!dumpEverything)
1521         return code;
1522 /*     if (!code)  code = DumpByte(iodp, 't',(byte)v->type); */
1523     FillInt64(addvar,0, 2);
1524     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1525 /*     if (!code) code = DumpShort(iodp, 'l', v->linkCount); /\* May not need this *\/ */
1526     FillInt64(addvar,0, 3);
1527     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1528 /*     if (!code) code = DumpInt32(iodp, 'v', v->dataVersion); */
1529     FillInt64(addvar,0, 5);
1530     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1531 /*     if (!code) code = DumpInt32(iodp, 'm', v->unixModifyTime); */
1532     FillInt64(addvar,0, 5);
1533     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1534 /*     if (!code) code = DumpInt32(iodp, 'a', v->author); */
1535     FillInt64(addvar,0, 5);
1536     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1537 /*     if (!code) code = DumpInt32(iodp, 'o', v->owner); */
1538     FillInt64(addvar,0, 5);
1539     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1540 /*     if (!code && v->group) code = DumpInt32(iodp, 'g', v->group);    /\* default group is 0 *\/ */
1541     if (v->group) {
1542         FillInt64(addvar,0, 5);
1543         AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1544     }
1545 /*     if (!code) code = DumpShort(iodp, 'b', v->modeBits); */
1546     FillInt64(addvar,0, 3);
1547     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1548 /*     if (!code) code = DumpInt32(iodp, 'p', v->parent); */
1549     FillInt64(addvar,0, 5);
1550     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1551 /*     if (!code) code = DumpInt32(iodp, 's', v->serverModifyTime); */
1552     FillInt64(addvar,0, 5);
1553     AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1554     if (v->type == vDirectory) {
1555 /*      acl_HtonACL(VVnodeDiskACL(v)); */
1556 /*      if (!code) code = DumpByteString(iodp, 'A', (byte *) VVnodeDiskACL(v), VAclDiskSize(v)); */
1557         FillInt64(addvar,0, (1 + VAclDiskSize(v)));
1558         AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1559     }
1560
1561     if (VNDISK_GET_INO(v)) {
1562         FillInt64(addvar,0, (v->length + 5));
1563         AddUInt64(v_size->dump_size, addvar, &v_size->dump_size);
1564     }
1565     return code;
1566 }
1567
1568 /* A partial dump (no dump header) */
1569 static int
1570 SizeDumpPartial(register struct iod *iodp, register Volume * vp,
1571                 afs_int32 fromtime, int dumpAllDirs,
1572                 register struct volintSize *v_size)
1573 {
1574     int code = 0;
1575     if (!code)
1576         code = SizeDumpVolumeHeader(iodp, vp, v_size);
1577     if (!code)
1578         code =
1579             SizeDumpVnodeIndex(iodp, vp, vLarge, fromtime, dumpAllDirs,
1580                                v_size);
1581     if (!code)
1582         code = SizeDumpVnodeIndex(iodp, vp, vSmall, fromtime, 0, v_size);
1583     return code;
1584 }
1585
1586 static int
1587 SizeDumpVnodeIndex(register struct iod *iodp, Volume * vp, VnodeClass class,
1588                    afs_int32 fromtime, int forcedump,
1589                    register struct volintSize *v_size)
1590 {
1591     register int code = 0;
1592     register struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
1593     char buf[SIZEOF_LARGEDISKVNODE];
1594     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
1595     StreamHandle_t *file;
1596     FdHandle_t *fdP;
1597     int size;
1598     int flag;
1599     register int vnodeIndex, nVnodes;
1600
1601     fdP = IH_OPEN(vp->vnodeIndex[class].handle);
1602     assert(fdP != NULL);
1603     file = FDH_FDOPEN(fdP, "r+");
1604     assert(file != NULL);
1605     size = OS_SIZE(fdP->fd_fd);
1606     assert(size != -1);
1607     nVnodes = (size / vcp->diskSize) - 1;
1608     if (nVnodes > 0) {
1609         assert((nVnodes + 1) * vcp->diskSize == size);
1610         assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
1611     } else
1612         nVnodes = 0;
1613     for (vnodeIndex = 0;
1614          nVnodes && STREAM_READ(vnode, vcp->diskSize, 1, file) == 1 && !code;
1615          nVnodes--, vnodeIndex++) {
1616         flag = forcedump || (vnode->serverModifyTime >= fromtime);
1617         /* Note:  the >= test is very important since some old volumes may not have
1618          * a serverModifyTime.  For an epoch dump, this results in 0>=0 test, which
1619          * does dump the file! */
1620         if (!code)
1621             code =
1622                 SizeDumpVnode(iodp, vnode, V_id(vp),
1623                               bitNumberToVnodeNumber(vnodeIndex, class), flag,
1624                               v_size);
1625     }
1626     STREAM_CLOSE(file);
1627     FDH_CLOSE(fdP);
1628     return code;
1629 }