831cb53f82f14d95c3b562ec63e17576425a2c5f
[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("$Header$");
14
15 #include <sys/types.h>
16 #include <ctype.h>
17 #include <stdio.h>
18 #include <errno.h>
19 #ifdef AFS_NT40_ENV
20 #include <fcntl.h>
21 #else
22 #include <sys/param.h>
23 #include <sys/file.h>
24 #include <sys/uio.h>
25 #include <netinet/in.h>
26 #include <unistd.h>
27 #endif
28 #ifdef HAVE_STRING_H
29 #include <string.h>
30 #else
31 #ifdef HAVE_STRINGS_H
32 #include <strings.h>
33 #endif
34 #endif
35 #include <sys/stat.h>
36 #include <afs/assert.h>
37 #include <rx/xdr.h>
38 #include <rx/rx.h>
39 #include <afs/afsint.h>
40 #include <afs/nfs.h>
41 #include <afs/errors.h>
42 #include <lock.h>
43 #include <lwp.h>
44 #include <afs/ihandle.h>
45 #include <afs/vnode.h>
46 #include <afs/volume.h>
47 #include <afs/partition.h>
48 #include "dump.h"
49 #include <afs/fssync.h>
50 #include <afs/acl.h>
51 #include "volser.h"
52 #include "volint.h"
53
54 extern int DoLogging;
55
56 /* This iod stuff is a silly little package to emulate the old qi_in stuff, which
57    emulated the stdio stuff.  There is a big assumption here, that the
58    rx_Read will never be called directly, by a routine like readFile, when
59    there is an old character that was pushed back with iod_ungetc.  This
60    is really bletchy, and is here for compatibility only.  Eventually,
61    we should define a volume format that doesn't require
62    the pushing back of characters (i.e. characters should not double both
63    as an end marker and a begin marker) */
64 struct iod {
65     struct rx_call *call;       /* call to which to write, might be an array */
66     int device;                 /* dump device ID for volume */
67     int parentId;               /* dump parent ID for volume */
68     struct DiskPartition *dumpPartition; /* Dump partition. */
69     struct rx_call **calls;      /* array of pointers to calls */
70     int ncalls;                 /* how many calls/codes in array */
71     int *codes;                 /* one return code for each call */
72     char haveOldChar;           /* state for pushing back a character */
73     char oldChar;
74 };
75
76
77 /* Forward Declarations */
78 static int DumpDumpHeader(register struct iod *iodp, register Volume *vp,
79                           afs_int32 fromtime);
80 static int DumpPartial(register struct iod *iodp, register Volume *vp,
81                        afs_int32 fromtime, int dumpAllDirs);
82 static int DumpVnodeIndex(register struct iod *iodp, Volume *vp,
83                           VnodeClass class, afs_int32 fromtime, int forcedump);
84 static int DumpVnode(register struct iod *iodp, struct VnodeDiskObject *v,
85                      int volid, int vnodeNumber, int dumpEverything);
86 static int ReadDumpHeader(register struct iod *iodp, struct DumpHeader *hp);
87 static int ReadVnodes(register struct iod *iodp, Volume *vp,
88                       int incremental, afs_int32 *Lbuf, afs_int32 s1,
89                       afs_int32 *Sbuf, afs_int32 s2, afs_int32 delo);
90 static bit32 volser_WriteFile(int vn, struct iod *iodp, FdHandle_t *handleP,
91                               Error *status);
92
93
94 static void iod_Init(register struct iod *iodp, register struct rx_call *call)
95 {
96     iodp->call = call;
97     iodp->haveOldChar = 0;
98     iodp->ncalls = 1;
99     iodp->calls = (struct rx_call **) 0;
100 }
101
102 static void iod_InitMulti(struct iod *iodp, struct rx_call **calls, int ncalls,
103                    int *codes)
104 {
105
106   iodp->calls = calls;
107   iodp->haveOldChar = 0;
108   iodp->ncalls = ncalls;
109   iodp->codes = codes;
110   iodp->call = (struct rx_call *) 0;
111 }
112
113 /* N.B. iod_Read doesn't check for oldchar (see previous comment) */
114 #define iod_Read(iodp, buf, nbytes) rx_Read((iodp)->call, buf, nbytes)
115
116 /* For the single dump case, it's ok to just return the "bytes written"
117  * that rx_Write returns, since all the callers of iod_Write abort when
118  * the returned value is less than they expect.  For the multi dump case,
119  * I don't think we want half the replicas to go bad just because one 
120  * connection timed out, but if they all time out, then we should give up. 
121  */
122 static int iod_Write(struct iod *iodp, char *buf, int nbytes)
123 {
124   int code, i;
125   int one_success = 0;
126
127   assert ((iodp->call && iodp->ncalls == 1 && !iodp->calls) ||
128           (!iodp->call && iodp->ncalls >= 1 && iodp->calls));
129
130   if (iodp->call) {
131     code = rx_Write(iodp->call, buf, nbytes); 
132     return code;     
133   }
134
135   for (i=0; i < iodp->ncalls; i++) {
136     if (iodp->calls[i] && !iodp->codes[i]) {
137       code = rx_Write(iodp->calls[i], buf, nbytes);
138       if (code != nbytes) { /* everything gets merged into a single error */
139         iodp->codes[i] = VOLSERDUMPERROR;  /* but that's exactly what the */
140       }                                    /* standard dump does, anyways */
141       else {
142         one_success = TRUE;
143       }
144     }
145   } /* for all calls */
146
147 if (one_success)
148   return nbytes;
149 else return 0;
150 }
151
152 static void iod_ungetc(struct iod *iodp, int achar)
153 {
154     iodp->oldChar = achar;
155     iodp->haveOldChar = 1;
156 }
157
158 static int iod_getc(register struct iod *iodp)
159 {
160     unsigned char t;
161    
162     if (iodp->haveOldChar) {
163         iodp->haveOldChar = 0;
164         return iodp->oldChar;
165     }
166     if (iod_Read(iodp, &t, 1) == 1) return t;
167     return EOF;
168 }
169
170 static int ReadShort(register struct iod *iodp, register unsigned short *sp)
171 {
172     register b1,b0;
173     b1 = iod_getc(iodp);
174     b0 = iod_getc(iodp);
175     *sp = (b1<<8) | b0;
176     return b0 != EOF;
177 }
178
179 static int ReadInt32(register struct iod *iodp, afs_uint32 *lp)
180 {
181     afs_uint32 register b3,b2,b1,b0;
182     b3 = iod_getc(iodp);
183     b2 = iod_getc(iodp);
184     b1 = iod_getc(iodp);
185     b0 = iod_getc(iodp);
186     *lp = (((((b3<<8)|b2)<<8)|b1)<<8)|b0;
187     return b0 != EOF;
188 }
189
190 static void ReadString(register struct iod *iodp, register char *to,
191                       register int maxa)
192 {
193     register int c;
194     while (maxa--) {
195         if ((*to++ = iod_getc(iodp)) == 0)
196             break;
197     }
198     if (to[-1]) {
199         while ((c = iod_getc(iodp)) && c != EOF);
200         to[-1] = 0;
201     }
202 }
203
204 static void ReadByteString(register struct iod *iodp, register byte *to,
205                    register int size)
206 {
207     while (size--)
208         *to++ = iod_getc(iodp);
209 }
210
211 static int ReadVolumeHeader(register struct iod *iodp, VolumeDiskData *vol)
212 {
213     register tag;
214     afs_uint32 trash;
215     memset(vol, 0, sizeof(*vol));
216     while ((tag = iod_getc(iodp)) > D_MAX && tag != EOF) {
217         switch (tag) {
218             case 'i':
219                 if(!ReadInt32(iodp, &vol->id)) return VOLSERREAD_DUMPERROR;
220                 break;
221             case 'v':
222                 if(!ReadInt32(iodp, &trash)) return VOLSERREAD_DUMPERROR;
223                 break;
224             case 'n':
225                  ReadString(iodp, vol->name, sizeof(vol->name));
226                 /*this means the name of the retsored volume could be possibly different. In conjunction with SAFSVolSignalRestore */
227                 break;
228             case 's':
229                 vol->inService = iod_getc(iodp );
230                 break;
231             case 'b':
232                 vol->blessed = iod_getc(iodp );
233                 break;
234             case 'u':
235                 if(!ReadInt32(iodp, &vol->uniquifier)) return VOLSERREAD_DUMPERROR;
236                 break;
237             case 't':
238                 vol->type = iod_getc(iodp );
239                 break;
240             case 'p':
241                 if(!ReadInt32(iodp, &vol->parentId)) return VOLSERREAD_DUMPERROR;
242                 break;
243             case 'c':
244                 if(!ReadInt32(iodp, &vol->cloneId)) return VOLSERREAD_DUMPERROR;
245                 break;
246             case 'q':
247                 if(!ReadInt32(iodp, (afs_uint32 *)&vol->maxquota)) return VOLSERREAD_DUMPERROR;
248                 break;
249             case 'm':
250                 if(!ReadInt32(iodp, (afs_uint32 *)&vol->minquota)) return VOLSERREAD_DUMPERROR;
251                 break;
252             case 'd':
253                 if(!ReadInt32(iodp, (afs_uint32 *)&vol->diskused)) return VOLSERREAD_DUMPERROR; /* Bogus:  should calculate this */
254                 break;
255             case 'f':
256                 if(!ReadInt32(iodp, (afs_uint32 *)&vol->filecount)) return VOLSERREAD_DUMPERROR;
257                 break;
258             case 'a':
259                 if(!ReadInt32(iodp, &vol->accountNumber)) return VOLSERREAD_DUMPERROR;
260                 break;
261             case 'o':
262                 if(!ReadInt32(iodp, &vol->owner)) return VOLSERREAD_DUMPERROR;
263                 break;
264             case 'C':
265                 if(!ReadInt32(iodp, &vol->creationDate)) return VOLSERREAD_DUMPERROR;
266                 break;
267             case 'A':
268                 if(!ReadInt32(iodp, &vol->accessDate)) return VOLSERREAD_DUMPERROR;
269                 break;
270             case 'U':
271                 if(!ReadInt32(iodp, &vol->updateDate)) return VOLSERREAD_DUMPERROR;
272                 break;
273             case 'E':
274                 if(!ReadInt32(iodp, &vol->expirationDate)) return VOLSERREAD_DUMPERROR;
275                 break;
276             case 'B':
277                 if(!ReadInt32(iodp, &vol->backupDate)) return VOLSERREAD_DUMPERROR;
278                 break;
279             case 'O':
280                 ReadString(iodp, vol->offlineMessage, sizeof(vol->offlineMessage));
281                 break;
282             case 'M':
283                 /*
284                  * Detailed volume statistics are never stored in dumps,
285                  * so we just restore either the null string if this volume
286                  * had already been set to store statistics, or the old motd
287                  * contents otherwise.  It doesn't matter, since this field
288                  * will soon get initialized anyway.
289                  */
290                 ReadString(iodp, (char *)(vol->stat_reads), VMSGSIZE);
291                 break;
292             case 'W': {
293                 unsigned short length;
294                 int i;
295                 afs_uint32 data;
296                 if(!ReadShort(iodp, &length)) return VOLSERREAD_DUMPERROR;
297                 for (i = 0; i<length; i++) {
298                     if(!ReadInt32(iodp, &data)) return VOLSERREAD_DUMPERROR;
299                     if (i < sizeof(vol->weekUse)/sizeof(vol->weekUse[0]))
300                         vol->weekUse[i] = data;
301                 }
302                 break;
303             }
304             case 'D':
305                 if(!ReadInt32(iodp, &vol->dayUseDate)) return VOLSERREAD_DUMPERROR;
306                 break;
307             case 'Z':
308                 if(!ReadInt32(iodp, (afs_uint32 *)&vol->dayUse)) return VOLSERREAD_DUMPERROR;
309                 break;
310         }
311     }
312     iod_ungetc(iodp, tag);
313     return 0;
314 }
315
316 static int DumpTag(register struct iod *iodp, register int tag)
317 {
318     char p;
319     
320     p = tag;
321     return((iod_Write(iodp, &p, 1) == 1)? 0 : VOLSERDUMPERROR);
322     
323 }
324
325 static int DumpByte(register struct iod *iodp, char tag, byte value)
326 {
327     char tbuffer[2];
328     register byte *p = (unsigned char *) tbuffer;
329     *p++ = tag;
330     *p = value;
331     return((iod_Write(iodp, tbuffer, 2) == 2)? 0: VOLSERDUMPERROR);
332 }
333
334 #define putint32(p, v)  *p++ = v>>24, *p++ = v>>16, *p++ = v>>8, *p++ = v
335 #define putshort(p, v) *p++ = v>>8, *p++ = v
336
337 static int DumpDouble(register struct iod *iodp, char tag,
338                       register afs_uint32 value1, register afs_uint32 value2)
339 {
340     char tbuffer[9];
341     register byte *p = (unsigned char *) tbuffer;
342     *p++ = tag;
343     putint32(p, value1);
344     putint32(p, value2);
345     return((iod_Write(iodp, tbuffer, 9) == 9)? 0: VOLSERDUMPERROR);
346 }
347
348 static int DumpInt32(register struct iod *iodp, char tag,
349                      register afs_uint32 value)
350 {
351     char tbuffer[5];
352     register byte *p = (unsigned char *) tbuffer;
353     *p++ = tag;
354     putint32(p, value);
355     return((iod_Write(iodp, tbuffer, 5) == 5)? 0: VOLSERDUMPERROR);
356 }
357
358 static int DumpArrayInt32(register struct iod *iodp, char tag,
359                           register afs_uint32 *array, register int nelem)
360 {
361     char tbuffer[4];
362     register afs_uint32 v ;
363     int code = 0;
364     register byte *p = (unsigned char *) tbuffer;
365     *p++ = tag;
366     putshort(p, nelem);
367     code = iod_Write(iodp, tbuffer, 3);
368     if (code != 3) return VOLSERDUMPERROR;
369     while (nelem--) {
370         p = (unsigned char *) tbuffer;
371         v = *array++;/*this was register */
372         
373         putint32(p, v);
374         code = iod_Write(iodp, tbuffer, 4);
375         if(code != 4) return VOLSERDUMPERROR;
376     }
377     return 0;
378 }
379
380 static int DumpShort(register struct iod *iodp, char tag, unsigned int value)
381 {
382     char tbuffer[3];
383     register byte *p = (unsigned char *) tbuffer;
384     *p++ = tag;
385     *p++ = value>>8;
386     *p = value;
387     return((iod_Write(iodp, tbuffer, 3) == 3)? 0: VOLSERDUMPERROR);
388 }
389
390 static int DumpBool(register struct iod *iodp, char tag, unsigned int value)
391 {
392     char tbuffer[2];
393     register byte *p = (unsigned char *) tbuffer;
394     *p++ = tag;
395     *p = value;
396     return((iod_Write(iodp, tbuffer, 2) == 2)? 0: VOLSERDUMPERROR);
397 }
398
399 static int DumpString(register struct iod *iodp, char tag, register char *s)
400 {
401     register n;
402     int code = 0;
403     code = iod_Write(iodp, &tag, 1);
404     if(code != 1) return VOLSERDUMPERROR;
405     n = strlen(s)+1;
406     code = iod_Write(iodp, s, n);
407     if(code != n) return VOLSERDUMPERROR;
408     return 0;
409 }
410
411 static int DumpByteString(register struct iod *iodp, char tag,
412                           register byte *bs, register int nbytes)
413 {
414     int code = 0;
415
416     code = iod_Write(iodp, &tag, 1);
417     if(code != 1) return VOLSERDUMPERROR;
418     code = iod_Write(iodp, (char *)bs, nbytes);
419     if(code != nbytes) return VOLSERDUMPERROR;
420     return 0;
421 }
422     
423 static int DumpFile(struct iod *iodp, char tag, int vnode, FdHandle_t *handleP)
424 {
425     int   code = 0, lcode = 0, error = 0;
426     afs_int32 pad = 0, offset;
427     int   n, nbytes, howMany, howBig;
428     byte  *p;
429     struct stat status;
430     int size;
431 #ifdef  AFS_AIX_ENV
432 #include <sys/statfs.h>
433     struct statfs tstatfs;
434 #endif
435
436 #ifdef AFS_NT40_ENV
437     howBig = _filelength(handleP->fd_fd);
438     howMany = 4096;
439
440 #else
441     fstat(handleP->fd_fd, &status);
442     howBig = status.st_size;
443
444 #ifdef  AFS_AIX_ENV
445     /* Unfortunately in AIX valuable fields such as st_blksize are 
446      * gone from the stat structure.
447      */
448     fstatfs(handleP->fd_fd, &tstatfs);
449     howMany = tstatfs.f_bsize;
450 #else
451     howMany = status.st_blksize;
452 #endif /* AFS_AIX_ENV */
453 #endif /* AFS_NT40_ENV */
454
455
456     size = FDH_SIZE(handleP);
457     code = DumpInt32(iodp, tag, size);
458     if (code) {
459        return VOLSERDUMPERROR;
460     }
461
462     p = (unsigned char *) malloc(howMany);
463     if (!p) {
464        Log("1 Volser: DumpFile: no memory");
465        return VOLSERDUMPERROR;
466     }
467
468     for (nbytes = size; (nbytes && !error); nbytes -= howMany) {
469         if (nbytes < howMany) 
470            howMany = nbytes;
471
472         /* Read the data - unless we know we can't */
473         n = (lcode ? 0 : FDH_READ(handleP, p, howMany));        
474
475         /* If read any good data and we null padded previously, log the
476          * amount that we had null padded.
477          */
478         if ((n > 0) && pad) {
479            Log("1 Volser: DumpFile: Null padding file %d bytes at offset %u\n",
480                pad, offset);
481            pad = 0;
482         }
483
484         /* If didn't read enough data, null padd the rest of the buffer. This
485          * can happen if, for instance, the media has some bad spots. We don't
486          * want to quit the dump, so we start null padding.
487          */
488         if (n < howMany) {
489            /* Record the read error */
490            if (n < 0) {
491               n = 0;
492               Log("1 Volser: DumpFile: Error %d reading inode %s for vnode %d\n", 
493                   errno, PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
494            }
495            else if (!pad) {
496               Log("1 Volser: DumpFile: Error reading inode %s for vnode %d\n",
497                   PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
498            }
499            
500            /* Pad the rest of the buffer with zeros. Remember offset we started 
501             * padding. Keep total tally of padding.
502             */
503            memset(p+n, 0, howMany-n);
504            if (!pad)
505               offset = (howBig - nbytes) + n;
506            pad += (howMany-n);
507            
508            /* Now seek over the data we could not get. An error here means we
509             * can't do the next read.
510             */
511            lcode = FDH_SEEK(handleP, ((size - nbytes) + howMany), SEEK_SET);
512            if (lcode != ((size - nbytes) + howMany)) {
513               if (lcode < 0) {
514                  Log("1 Volser: DumpFile: Error %d seeking in inode %s for vnode %d\n",
515                      errno, PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
516               }
517               else {
518                  Log("1 Volser: DumpFile: Error seeking in inode %s for vnode %d\n",
519                      PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
520                  lcode = -1;
521               }
522            }
523            else {
524              lcode = 0;
525            }
526         }
527
528         /* Now write the data out */
529         if (iod_Write(iodp, (char *)p, howMany) != howMany) 
530            error = VOLSERDUMPERROR;
531         IOMGR_Poll();
532     }
533
534     if (pad) {                     /* Any padding we hadn't reported yet */
535        Log("1 Volser: DumpFile: Null padding file: %d bytes at offset %u\n",
536            pad, offset);
537     }
538
539     free(p);
540     return error;
541 }
542
543 static int DumpVolumeHeader(register struct iod *iodp, register Volume *vp)
544 {
545     int code = 0;
546     static char nullString[1] = "";  /*The ``contents'' of motd*/
547
548     if (!code) code = DumpTag(iodp, D_VOLUMEHEADER);
549     if (!code) {code = DumpInt32(iodp, 'i',V_id(vp));}
550     if (!code) code = DumpInt32(iodp, 'v',V_stamp(vp).version);
551     if (!code) code = DumpString(iodp, 'n',V_name(vp));
552     if (!code) code = DumpBool(iodp, 's',V_inService(vp));
553     if (!code) code = DumpBool(iodp, 'b',V_blessed(vp));
554     if (!code) code = DumpInt32(iodp, 'u',V_uniquifier(vp));
555     if (!code) code = DumpByte(iodp, 't',(byte)V_type(vp));
556     if (!code){ code = DumpInt32(iodp, 'p',V_parentId(vp));}
557     if (!code) code = DumpInt32(iodp, 'c',V_cloneId(vp));
558     if (!code) code = DumpInt32(iodp, 'q',V_maxquota(vp));
559     if (!code) code = DumpInt32(iodp, 'm',V_minquota(vp));
560     if (!code) code = DumpInt32(iodp, 'd',V_diskused(vp));
561     if (!code) code = DumpInt32(iodp, 'f',V_filecount(vp));
562     if (!code) code = DumpInt32(iodp, 'a', V_accountNumber(vp));
563     if (!code) code = DumpInt32(iodp, 'o', V_owner(vp));
564     if (!code) code = DumpInt32(iodp, 'C',V_creationDate(vp));  /* Rw volume creation date */
565     if (!code) code = DumpInt32(iodp, 'A',V_accessDate(vp));
566     if (!code) code = DumpInt32(iodp, 'U',V_updateDate(vp));
567     if (!code) code = DumpInt32(iodp, 'E',V_expirationDate(vp));
568     if (!code) code = DumpInt32(iodp, 'B',V_backupDate(vp));            /* Rw volume backup clone date */
569     if (!code) code = DumpString(iodp, 'O',V_offlineMessage(vp));
570     /*
571      * We do NOT dump the detailed volume statistics residing in the old
572      * motd field, since we cannot tell from the info in a dump whether
573      * statistics data has been put there.  Instead, we dump a null string,
574      * just as if that was what the motd contained.
575      */
576     if (!code) code = DumpString(iodp, 'M', nullString);
577     if (!code) code = DumpArrayInt32(iodp, 'W', (afs_uint32 *)V_weekUse(vp), sizeof(V_weekUse(vp))/sizeof(V_weekUse(vp)[0]));
578     if (!code) code = DumpInt32(iodp, 'D', V_dayUseDate(vp));
579     if (!code) code = DumpInt32(iodp, 'Z', V_dayUse(vp));
580     return code;
581 }
582
583 static int DumpEnd(register struct iod *iodp)
584 {
585     return(DumpInt32(iodp, D_DUMPEND, DUMPENDMAGIC));
586 }
587
588 /* Guts of the dump code */
589
590 /* Dump a whole volume */
591 int DumpVolume(register struct rx_call *call, register Volume *vp,
592                       afs_int32 fromtime, int dumpAllDirs)
593 {
594     struct iod iod;
595     int code = 0;
596     register struct iod *iodp = &iod;
597     iod_Init(iodp, call);
598     
599     if (!code) code = DumpDumpHeader(iodp, vp, fromtime);
600     
601     if (!code) code = DumpPartial(iodp, vp, fromtime, dumpAllDirs);
602     
603 /* hack follows.  Errors should be handled quite differently in this version of dump than they used to be.*/
604     if (rx_Error(iodp->call)) {
605         Log("1 Volser: DumpVolume: Rx call failed during dump, error %d\n", rx_Error(iodp->call));
606         return VOLSERDUMPERROR;
607     }
608     if (!code) code = DumpEnd(iodp);
609     
610     return code;
611 }
612
613 /* Dump a volume to multiple places*/
614 int DumpVolMulti(struct rx_call **calls, int ncalls, Volume *vp,
615                  afs_int32 fromtime, int dumpAllDirs, int *codes)
616 {
617     struct iod iod;
618     int code = 0;
619     iod_InitMulti(&iod, calls, ncalls, codes);
620     
621     if (!code) code = DumpDumpHeader(&iod, vp, fromtime);
622     if (!code) code = DumpPartial(&iod, vp, fromtime, dumpAllDirs);
623     if (!code) code = DumpEnd(&iod);
624     return code;
625 }
626
627 /* A partial dump (no dump header) */
628 static int DumpPartial(register struct iod *iodp, register Volume *vp,
629                        afs_int32 fromtime, int dumpAllDirs)
630 {
631     int code = 0;
632     if (!code) code = DumpVolumeHeader(iodp, vp);
633     if (!code) code = DumpVnodeIndex(iodp, vp, vLarge, fromtime, dumpAllDirs);
634     if (!code) code = DumpVnodeIndex(iodp, vp, vSmall, fromtime, 0);
635     return code;
636 }
637
638 static int DumpVnodeIndex(register struct iod *iodp, Volume *vp,
639                           VnodeClass class, afs_int32 fromtime, int forcedump)
640 {
641     register int code = 0;
642     register struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
643     char buf[SIZEOF_LARGEDISKVNODE];
644     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *) buf;
645     StreamHandle_t *file;
646     FdHandle_t *fdP;
647     int size;
648     int flag;
649     register int vnodeIndex, nVnodes;
650
651     fdP = IH_OPEN(vp->vnodeIndex[class].handle);
652     assert(fdP != NULL);
653     file = FDH_FDOPEN(fdP, "r+");
654     assert(file != NULL);
655     size = OS_SIZE(fdP->fd_fd);
656     assert(size != -1);
657     nVnodes = (size / vcp->diskSize) - 1;
658     if (nVnodes > 0) {
659         assert((nVnodes+1)*vcp->diskSize == size);
660         assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
661     }
662     else nVnodes = 0;
663     for (vnodeIndex = 0; nVnodes && STREAM_READ(vnode, vcp->diskSize, 1, file) == 1 && !code;
664       nVnodes--, vnodeIndex++) {
665         flag = forcedump || (vnode->serverModifyTime >= fromtime);
666         /* Note:  the >= test is very important since some old volumes may not have
667            a serverModifyTime.  For an epoch dump, this results in 0>=0 test, which
668            does dump the file! */
669         if (!code) code = DumpVnode(iodp, vnode, V_id(vp), bitNumberToVnodeNumber(vnodeIndex, class), flag);
670         if (!flag) IOMGR_Poll(); /* if we dont' xfr data, but scan instead, could lose conn */
671     }
672     STREAM_CLOSE(file);
673     FDH_CLOSE(fdP);
674     return code;
675 }
676
677 static int DumpDumpHeader(register struct iod *iodp, register Volume *vp,
678                           afs_int32 fromtime)
679 {
680     int code = 0;
681     int UseLatestReadOnlyClone = 1;
682     afs_int32 dumpTimes[2];
683     iodp->device = vp->device;
684     iodp->parentId = V_parentId(vp);
685     iodp->dumpPartition = vp->partition;
686     if (!code) code = DumpDouble(iodp, D_DUMPHEADER, DUMPBEGINMAGIC, DUMPVERSION);
687     if (!code) code = DumpInt32(iodp, 'v', UseLatestReadOnlyClone? V_id(vp): V_parentId(vp));
688     if (!code) code = DumpString(iodp, 'n',V_name(vp));
689     dumpTimes[0] = fromtime;
690     dumpTimes[1] = V_backupDate(vp);    /* Until the time the clone was made */
691     if (!code) code = DumpArrayInt32(iodp, 't', (afs_uint32 *)dumpTimes, 2);
692     return code;
693 }
694
695 static int DumpVnode(register struct iod *iodp, struct VnodeDiskObject *v,
696                      int volid, int vnodeNumber, int dumpEverything)
697 {
698     int code = 0;
699     IHandle_t *ihP;
700     FdHandle_t *fdP;
701
702     if (!v || v->type == vNull)
703         return code;
704     if (!code) code = DumpDouble(iodp, D_VNODE, vnodeNumber, v->uniquifier);
705     if (!dumpEverything)
706         return code;
707     if (!code) code = DumpByte(iodp, 't',(byte)v->type);
708     if (!code) code = DumpShort(iodp, 'l', v->linkCount); /* May not need this */
709     if (!code) code = DumpInt32(iodp, 'v', v->dataVersion);
710     if (!code) code = DumpInt32(iodp, 'm', v->unixModifyTime);
711     if (!code) code = DumpInt32(iodp, 'a', v->author);
712     if (!code) code = DumpInt32(iodp, 'o', v->owner);
713     if (!code && v->group) code = DumpInt32(iodp, 'g', v->group);       /* default group is 0 */
714     if (!code) code = DumpShort(iodp, 'b', v->modeBits);
715     if (!code) code = DumpInt32(iodp, 'p', v->parent);
716     if (!code) code = DumpInt32(iodp, 's', v->serverModifyTime);
717     if (v->type == vDirectory) {
718         acl_HtonACL(VVnodeDiskACL(v));
719         if (!code) code = DumpByteString(iodp, 'A', (byte *) VVnodeDiskACL(v), VAclDiskSize(v));
720     }
721     if (VNDISK_GET_INO(v)) {
722         IH_INIT(ihP, iodp->device, iodp->parentId, VNDISK_GET_INO(v));
723         fdP = IH_OPEN(ihP);
724         if (fdP == NULL) {
725             Log("1 Volser: DumpVnode: dump: Unable to open inode %d for vnode %d (volume %d); not dumped, error %d\n",
726                 VNDISK_GET_INO(v), vnodeNumber, volid, errno);
727             IH_RELEASE(ihP);
728             return VOLSERREAD_DUMPERROR;
729         }
730         code = DumpFile(iodp, 'f', vnodeNumber, fdP);
731         FDH_CLOSE(fdP);
732         IH_RELEASE(ihP);
733     }
734     return code;
735 }
736
737
738 int ProcessIndex(Volume *vp, VnodeClass class, afs_int32 **Bufp, int *sizep,
739                  int del)
740 {
741     int i, nVnodes, offset, code, index=0;
742     afs_int32 *Buf;
743     int cnt=0;  
744     int size;
745     StreamHandle_t *afile;
746     FdHandle_t *fdP;
747     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
748     char buf[SIZEOF_LARGEDISKVNODE], zero[SIZEOF_LARGEDISKVNODE];
749     register struct VnodeDiskObject *vnode = (struct VnodeDiskObject *) buf;
750     
751     memset(zero, 0, sizeof(zero));      /* zero out our proto-vnode */
752     fdP = IH_OPEN(vp->vnodeIndex[class].handle);
753     if (fdP == NULL)
754         return -1;
755     afile = FDH_FDOPEN(fdP, "r+");
756     if (del) {
757         int cnt1=0;
758         Buf = *Bufp;
759         for (i = 0; i<*sizep; i++) {
760             if (Buf[i]) {
761                 cnt++;
762                 STREAM_SEEK(afile, Buf[i], 0);    
763                 code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
764                 if (code == 1) {
765                     if (vnode->type != vNull && VNDISK_GET_INO(vnode)) {
766                         cnt1++;
767                         if (DoLogging) {
768                            Log("RestoreVolume %d Cleanup: Removing old vnode=%d inode=%d size=%d\n", 
769                                V_id(vp), bitNumberToVnodeNumber(i,class),
770                                VNDISK_GET_INO(vnode), vnode->length);
771                         }
772                         IH_DEC(V_linkHandle(vp), VNDISK_GET_INO(vnode),
773                              V_parentId(vp));
774                         DOPOLL;
775                     }
776                     STREAM_SEEK(afile, Buf[i], 0);
777                     (void ) STREAM_WRITE(zero, vcp->diskSize, 1, afile);        /* Zero it out */
778                 }
779                 Buf[i] = 0;
780             }
781         }
782         if (DoLogging) {
783            Log("RestoreVolume Cleanup: Removed %d inodes for volume %d\n",
784                cnt1, V_id(vp));
785         }
786         STREAM_FLUSH(afile);            /* ensure 0s are on the disk */
787         OS_SYNC(afile->str_fd);
788     } else {
789         size = OS_SIZE(fdP->fd_fd);
790         assert(size != -1);
791         nVnodes = (size <= vcp->diskSize ? 0 :
792                    size-vcp->diskSize) >> vcp->logSize;
793         if (nVnodes > 0) {
794             Buf = (afs_int32 *) malloc(nVnodes * sizeof(afs_int32));
795             if (Buf == NULL) return 1;
796             memset((char *)Buf, 0, nVnodes * sizeof(afs_int32));
797             STREAM_SEEK(afile, offset = vcp->diskSize, 0);
798             while (1) {
799                 code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
800                 if (code != 1) {
801                     break;
802                 }
803                 if (vnode->type != vNull && VNDISK_GET_INO(vnode)) {
804                     Buf[(offset >> vcp->logSize)-1] = offset;
805                     cnt++;
806                 }
807                 offset += vcp->diskSize;
808             }
809             *Bufp = Buf;
810             *sizep = nVnodes;
811         }
812     }
813     STREAM_CLOSE(afile);
814     FDH_CLOSE(fdP);
815     return 0;
816 }
817
818
819 int RestoreVolume(register struct rx_call *call, Volume *avp,
820                   int incremental, struct restoreCookie *cookie)
821 {
822     VolumeDiskData vol;
823     struct DumpHeader header;
824     afs_uint32 endMagic;
825     Error error = 0, vupdate;
826     register Volume *vp;
827     struct iod iod;
828     register struct iod *iodp = &iod;
829     afs_int32 *b1=0, *b2=0;
830     int s1=0, s2=0, delo=0, tdelo;
831     int tag;
832
833     iod_Init(iodp, call);
834     
835     vp = avp;
836     if (!ReadDumpHeader(iodp, &header)){
837         Log("1 Volser: RestoreVolume: Error reading header file for dump; aborted\n");
838         return VOLSERREAD_DUMPERROR;
839     }
840     if (iod_getc(iodp) != D_VOLUMEHEADER){
841         Log("1 Volser: RestoreVolume: Volume header missing from dump; not restored\n");
842         return VOLSERREAD_DUMPERROR;
843     }
844     if(ReadVolumeHeader(iodp, &vol) == VOLSERREAD_DUMPERROR) return VOLSERREAD_DUMPERROR;
845
846     delo = ProcessIndex(vp, vLarge, &b1, &s1, 0);
847     if (!delo) delo = ProcessIndex(vp, vSmall, &b2, &s2, 0);
848     if (delo) {
849        if (b1) free((char *)b1);
850        if (b2) free((char *)b2);
851        b1 = b2 = 0;
852     }
853
854     strncpy(vol.name,cookie->name,VOLSER_OLDMAXVOLNAME);
855     vol.type = cookie->type;
856     vol.cloneId = cookie->clone;
857     vol.parentId = cookie->parent;
858     
859
860     tdelo = delo;
861     while (1) {
862        if (ReadVnodes(iodp, vp, 0, b1, s1, b2, s2, tdelo)) {
863           error =  VOLSERREAD_DUMPERROR;
864           goto clean;
865        }
866        tag = iod_getc(iodp);
867        if (tag != D_VOLUMEHEADER)
868           break;
869        if (ReadVolumeHeader(iodp, &vol) == VOLSERREAD_DUMPERROR) {
870           error = VOLSERREAD_DUMPERROR;
871           goto out;
872        }
873        tdelo = -1;
874     }
875     if (tag != D_DUMPEND || !ReadInt32(iodp, &endMagic) || endMagic != DUMPENDMAGIC){
876        Log("1 Volser: RestoreVolume: End of dump not found; restore aborted\n");
877        error =  VOLSERREAD_DUMPERROR;
878        goto clean;
879     }
880
881
882     if (iod_getc(iodp) != EOF) {
883         Log("1 Volser: RestoreVolume: Unrecognized postamble in dump; restore aborted\n");
884         error = VOLSERREAD_DUMPERROR;
885         goto clean;
886     }
887
888     if (!delo) {
889         ProcessIndex(vp, vLarge, &b1, &s1, 1);
890         ProcessIndex(vp, vSmall, &b2, &s2, 1);
891     }
892
893  clean:
894     ClearVolumeStats(&vol);
895     CopyVolumeHeader(&vol, &V_disk(vp));
896     V_destroyMe(vp) = 0;
897     VUpdateVolume(&vupdate, vp);
898     if (vupdate) {
899         Log("1 Volser: RestoreVolume: Unable to rewrite volume header; restore aborted\n");
900         error = VOLSERREAD_DUMPERROR;
901         goto out;
902     }
903  out:
904     /* Free the malloced space above */
905     if (b1) free((char *)b1);
906     if (b2) free((char *)b2);
907     return error;
908 }
909
910 static int ReadVnodes(register struct iod *iodp, Volume *vp,
911                       int incremental, afs_int32 *Lbuf, afs_int32 s1,
912                       afs_int32 *Sbuf, afs_int32 s2, afs_int32 delo)
913 {
914     afs_int32 vnodeNumber;
915     char buf[SIZEOF_LARGEDISKVNODE];
916     register tag;
917     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *) buf;
918     struct VnodeDiskObject oldvnode;
919     int idx;
920     VnodeClass class;
921     struct VnodeClassInfo *vcp;
922     IHandle_t *tmpH;
923     FdHandle_t *fdP;
924     Inode       nearInode;
925
926     tag = iod_getc(iodp);
927     V_pref(vp, nearInode);
928     while (tag == D_VNODE) {
929         int haveStuff = 0;
930         memset(buf, 0, sizeof (buf));
931         if (!ReadInt32(iodp, (afs_uint32 *)&vnodeNumber))
932             break;
933
934         ReadInt32(iodp, &vnode->uniquifier);
935         while ((tag = iod_getc(iodp)) > D_MAX && tag != EOF) {
936             haveStuff = 1;
937             switch (tag) {
938                 case 't':
939                     vnode->type = (VnodeType) iod_getc(iodp);
940                     break;
941                 case 'l':
942                     {
943                         unsigned short tlc;
944                         ReadShort(iodp, &tlc);
945                         vnode->linkCount = (signed int)tlc;
946                     }
947                     break;
948                 case 'v':
949                     ReadInt32(iodp, &vnode->dataVersion);
950                     break;
951                 case 'm':
952                     ReadInt32(iodp, &vnode->unixModifyTime);
953                     break;
954                 case 's':
955                     ReadInt32(iodp, &vnode->serverModifyTime);
956                     break;
957                 case 'a':
958                     ReadInt32(iodp, &vnode->author);
959                     break;
960                 case 'o':
961                     ReadInt32(iodp, &vnode->owner);
962                     break;
963                 case 'g':
964                     ReadInt32(iodp, (afs_uint32 *)&vnode->group);
965                     break;
966                 case 'b': {
967                     unsigned short modeBits;
968                     ReadShort(iodp, &modeBits);
969                     vnode->modeBits = (unsigned int)modeBits;
970                     break;
971                 }
972                 case 'p':
973                     ReadInt32(iodp, &vnode->parent);
974                     break;
975                 case 'A':
976                     ReadByteString(iodp, (byte *)VVnodeDiskACL(vnode),
977                                    VAclDiskSize(vnode));
978                     acl_NtohACL(VVnodeDiskACL(vnode));
979                     break;
980                 case 'f': {
981                     Inode ino;
982                     Error error;
983
984                     ino = IH_CREATE(V_linkHandle(vp),
985                                     V_device(vp),
986                                     VPartitionPath(V_partition(vp)),
987                                     nearInode, V_parentId(vp), vnodeNumber,
988                                     vnode->uniquifier,
989                                     vnode->dataVersion);
990                     if (!VALID_INO(ino)) {
991                         perror("unable to allocate inode");
992                         Log("1 Volser: ReadVnodes: Restore aborted\n");
993                         return VOLSERREAD_DUMPERROR;
994                     }
995                     nearInode = ino;
996                     VNDISK_SET_INO(vnode, ino);
997                     IH_INIT(tmpH, vp->device, V_parentId(vp), ino);
998                     fdP = IH_OPEN(tmpH);
999                     if (fdP == NULL) {
1000                         IH_RELEASE(tmpH);
1001                         return VOLSERREAD_DUMPERROR;
1002                     }
1003                     vnode->length = volser_WriteFile(vnodeNumber, iodp, fdP,
1004                                                      &error);
1005                     FDH_REALLYCLOSE(fdP);
1006                     IH_RELEASE(tmpH);
1007                     if (error) {
1008                         Log("1 Volser: ReadVnodes: IDEC inode %d\n", ino);
1009                         IH_DEC(V_linkHandle(vp), ino, V_parentId(vp));
1010                         return VOLSERREAD_DUMPERROR;
1011                     }
1012                     break;
1013                 }
1014             }
1015         }
1016
1017         class = vnodeIdToClass(vnodeNumber);
1018         vcp   = &VnodeClassInfo[class];
1019
1020         /* Mark this vnode as in this dump - so we don't delete it later */
1021         if (!delo) {
1022            idx = (vnodeIndexOffset(vcp,vnodeNumber) >> vcp->logSize) - 1;
1023            if (class == vLarge) {
1024               if (Lbuf && (idx < s1)) Lbuf[idx] = 0;
1025            } else {
1026               if (Sbuf && (idx < s2)) Sbuf[idx] = 0;
1027            }
1028         }
1029
1030         if (haveStuff) {
1031             FdHandle_t *fdP = IH_OPEN(vp->vnodeIndex[class].handle);
1032             if (fdP == NULL) {
1033                 Log("1 Volser: ReadVnodes: Error opening vnode index; restore aborted\n");
1034                 return VOLSERREAD_DUMPERROR;
1035             }
1036             if (FDH_SEEK(fdP, vnodeIndexOffset(vcp, vnodeNumber), SEEK_SET) < 0) {
1037                 Log("1 Volser: ReadVnodes: Error seeking into vnode index; restore aborted\n");
1038                 FDH_REALLYCLOSE(fdP);
1039                 return VOLSERREAD_DUMPERROR;
1040             }
1041             if (FDH_READ(fdP, &oldvnode, sizeof(oldvnode)) == sizeof(oldvnode)) {
1042                 if (oldvnode.type != vNull && VNDISK_GET_INO(&oldvnode)) {
1043                     IH_DEC(V_linkHandle(vp), VNDISK_GET_INO(&oldvnode),
1044                          V_parentId(vp));
1045                 }
1046             }
1047             vnode->vnodeMagic = vcp->magic;
1048             if (FDH_SEEK(fdP, vnodeIndexOffset(vcp, vnodeNumber), SEEK_SET) < 0) {
1049                 Log("1 Volser: ReadVnodes: Error seeking into vnode index; restore aborted\n");
1050                 FDH_REALLYCLOSE(fdP);
1051                 return VOLSERREAD_DUMPERROR;
1052             }
1053             if (FDH_WRITE(fdP, vnode, vcp->diskSize) != vcp->diskSize) {
1054                 Log("1 Volser: ReadVnodes: Error writing vnode index; restore aborted\n");
1055                 FDH_REALLYCLOSE(fdP);
1056                 return VOLSERREAD_DUMPERROR;
1057             }
1058             FDH_CLOSE(fdP);
1059         }
1060     }
1061     iod_ungetc(iodp, tag);
1062
1063
1064     return 0;
1065 }
1066
1067
1068 /* called with disk file only.  Note that we don't have to worry about rx_Read
1069  * needing to read an ungetc'd character, since the ReadInt32 will have read
1070  * it instead.
1071  */
1072 static bit32 volser_WriteFile(int vn, struct iod *iodp, FdHandle_t *handleP,
1073                               Error *status)
1074 {
1075     afs_int32 code;
1076     afs_uint32 filesize;
1077     bit32 written=0;
1078     register afs_uint32 size = 8192;
1079     register afs_uint32 nbytes;
1080     unsigned char *p;
1081
1082
1083     *status = 0;
1084     if (!ReadInt32(iodp, &filesize)) {
1085         *status = 1;
1086         return(0);
1087     }
1088     p = (unsigned char *) malloc(size);
1089     if (p == NULL) {
1090         *status = 2;
1091         return(0);
1092     }
1093     for (nbytes = filesize; nbytes; nbytes -= size) {
1094         if (nbytes < size)
1095             size = nbytes;
1096         
1097         if ((code = iod_Read(iodp, p, size)) != size) {
1098             Log("1 Volser: WriteFile: Error reading dump file %d size=%d nbytes=%d (%d of %d); restore aborted\n", vn, filesize, nbytes, code, size);
1099             *status = 3;
1100             break;
1101         }
1102         code = FDH_WRITE(handleP, p, size);
1103         if (code > 0) written += code;
1104         if (code != size) {
1105             Log("1 Volser: WriteFile: Error creating file in volume; restore aborted\n");
1106             *status = 4;
1107             break;
1108         }
1109     }
1110     free(p);
1111     return(written);
1112 }
1113
1114 static int ReadDumpHeader(register struct iod *iodp, struct DumpHeader *hp)
1115 {
1116     register tag;
1117     afs_uint32 beginMagic;
1118     if (iod_getc(iodp) != D_DUMPHEADER || !ReadInt32(iodp, &beginMagic)
1119        || !ReadInt32(iodp, (afs_uint32 *)&hp->version)
1120        || beginMagic != DUMPBEGINMAGIC
1121        ) return 0;
1122     hp->volumeId = 0;
1123     hp->nDumpTimes = 0;
1124     while ((tag = iod_getc(iodp)) > D_MAX) {
1125         unsigned short arrayLength;
1126         register int i;
1127         switch(tag) {
1128             case 'v':
1129                 if (!ReadInt32(iodp, &hp->volumeId))
1130                     return 0;
1131                 break;
1132             case 'n':
1133                 ReadString(iodp, hp->volumeName, sizeof(hp->volumeName));
1134                 break;
1135             case 't':
1136                 if (!ReadShort(iodp, &arrayLength))
1137                     return 0;
1138                 hp->nDumpTimes = (arrayLength >> 1);
1139                 for (i = 0; i<hp->nDumpTimes; i++)
1140                     if (!ReadInt32(iodp, (afs_uint32 *)&hp->dumpTimes[i].from)
1141                         || !ReadInt32(iodp, (afs_uint32 *)&hp->dumpTimes[i].to))
1142                         return 0;
1143                 break;
1144         }
1145     }
1146     if (!hp->volumeId || !hp->nDumpTimes) {
1147         return 0;
1148     }
1149     iod_ungetc(iodp, tag);
1150     return 1;
1151 }