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