Fix incorrect uses of abs()
[openafs.git] / src / vlserver / vldb_check.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 #include <roken.h>
14
15 #ifdef AFS_NT40_ENV
16 #include <WINNT/afsevent.h>
17 #endif
18
19 #include <ubik.h>
20 #include <afs/afsutil.h>
21 #include <afs/cmd.h>
22
23 #include "vlserver.h"
24 #include "vldbint.h"
25
26 /* Read a VLDB file and verify it for correctness */
27
28 #define VL  0x001               /* good volume entry */
29 #define FR  0x002               /* free volume entry */
30 #define MH  0x004               /* multi-homed entry */
31
32 #define RWH 0x010               /* on rw hash chain */
33 #define ROH 0x020               /* on ro hash chain */
34 #define BKH 0x040               /* on bk hash chain */
35 #define NH  0x080               /* on name hash chain */
36
37 #define MHC 0x100               /* on multihomed chain */
38 #define FRC 0x200               /* on free chain */
39
40 #define REFRW 0x1000            /* linked from something (RW) */
41 #define REFRO 0x2000            /* linked from something (RO) */
42 #define REFBK 0x4000            /* linked from something (BK) */
43 #define REFN  0x8000            /* linked from something (name) */
44
45 #define MULTRW 0x10000         /* multiply-chained (RW) */
46 #define MULTRO 0x20000         /* multiply-chained (RO) */
47 #define MULTBK 0x40000         /* multiply-chained (BK) */
48 #define MULTN  0x80000         /* multiply-chained (name) */
49
50 #define MISRWH 0x100000          /* mischained (RW) */
51 #define MISROH 0x200000          /* mischained (RO) */
52 #define MISBKH 0x400000          /* mischained (BK) */
53 #define MISNH  0x800000          /* mischained (name) */
54
55 #define VLDB_CHECK_NO_VLDB_CHECK_ERROR 0
56 #define VLDB_CHECK_WARNING  1
57 #define VLDB_CHECK_ERROR    2
58 #define VLDB_CHECK_FATAL    4
59 #define vldbread(x,y,z) vldbio(x,y,z,0)
60 #define vldbwrite(x,y,z) vldbio(x,y,z,1)
61
62 #define HDRSIZE 64
63 #define ADDR(x) ((x)/sizeof(struct nvlentry))
64 #define OFFSET(addr) ((addr) + HDRSIZE)
65
66 int fd;
67 int listentries, listservers, listheader, listuheader, verbose, quiet;
68
69 int fix = 0;
70 int passes = 0;
71 /* if quiet, don't send anything to stdout */
72 int quiet = 0;
73 /*  error level. 0 = no error, 1 = warning, 2 = error, 4 = fatal */
74 int error_level  = 0;
75
76 struct er {
77     long addr;
78     int type;
79 } *record;
80 afs_int32 maxentries;
81 int serveraddrs[MAXSERVERID + 2];
82 u_char serverxref[MAXSERVERID + 2];  /**< to resolve cross-linked mh entries */
83 int serverref[MAXSERVERID + 2];      /**< which addrs are referenced by vl entries */
84
85 struct mhinfo {
86     afs_uint32 addr;                    /**< vldb file record */
87     char orphan[VL_MHSRV_PERBLK];       /**< unreferenced mh enties */
88 } mhinfo[VL_MAX_ADDREXTBLKS];
89
90
91 /*  Used to control what goes to stdout based on quiet flag */
92 void
93 quiet_println(const char *fmt,...) {
94     va_list args;
95     if (!quiet) {
96         va_start(args, fmt);
97         vfprintf(stdout, fmt, args);
98         va_end(args);
99     }
100 }
101
102 /*  Used to set the error level and ship messages to stderr */
103 void
104 log_error(int eval, const char *fmt, ...)
105 {
106     va_list args;
107     if (error_level < eval) error_level  = eval ;  /*  bump up the severity */
108     va_start(args, fmt);
109     vfprintf(stderr, fmt, args);
110     va_end(args);
111
112     if (error_level  == VLDB_CHECK_FATAL) exit(VLDB_CHECK_FATAL);
113 }
114
115
116 int
117 readUbikHeader(void)
118 {
119     int offset, r;
120     struct ubik_hdr uheader;
121
122     offset = lseek(fd, 0, 0);
123     if (offset != 0) {
124         log_error(VLDB_CHECK_FATAL,"error: lseek to 0 failed: %d %d\n", offset, errno);
125         return (VLDB_CHECK_FATAL);
126     }
127
128     /* now read the info */
129     r = read(fd, &uheader, sizeof(uheader));
130     if (r != sizeof(uheader)) {
131         log_error(VLDB_CHECK_FATAL,"error: read of %lu bytes failed: %d %d\n", sizeof(uheader), r,
132                errno);
133         return (VLDB_CHECK_FATAL);
134     }
135
136     uheader.magic = ntohl(uheader.magic);
137     uheader.size = ntohs(uheader.size);
138     uheader.version.epoch = ntohl(uheader.version.epoch);
139     uheader.version.counter = ntohl(uheader.version.counter);
140
141     if (listuheader) {
142         quiet_println("Ubik Header\n");
143         quiet_println("   Magic           = 0x%x\n", uheader.magic);
144         quiet_println("   Size            = %u\n", uheader.size);
145         quiet_println("   Version.epoch   = %u\n", uheader.version.epoch);
146         quiet_println("   Version.counter = %u\n", uheader.version.counter);
147     }
148
149     if (uheader.size != HDRSIZE)
150         log_error(VLDB_CHECK_WARNING,"VLDB_CHECK_WARNING: Ubik header size is %u (should be %u)\n", uheader.size,
151                HDRSIZE);
152     if (uheader.magic != UBIK_MAGIC)
153         log_error(VLDB_CHECK_ERROR,"Ubik header magic is 0x%x (should be 0x%x)\n", uheader.magic,
154                UBIK_MAGIC);
155
156     return (0);
157 }
158
159 int
160 vldbio(int position, void *buffer, int size, int rdwr)
161 {
162     int offset, r, p;
163
164     /* seek to the correct spot. skip ubik stuff */
165     p = OFFSET(position);
166     offset = lseek(fd, p, 0);
167     if (offset != p) {
168         log_error(VLDB_CHECK_FATAL,"error: lseek to %d failed: %d %d\n", p, offset, errno);
169         return (-1);
170     }
171
172     if (rdwr == 1)
173         r = write(fd, buffer, size);
174     else
175         r = read(fd, buffer, size);
176
177     if (r != size) {
178         log_error(VLDB_CHECK_FATAL,"error: %s of %d bytes failed: %d %d\n", rdwr==1?"write":"read",
179                size, r, errno);
180         return (-1);
181     }
182     return (0);
183 }
184
185 char *
186 vtype(int type)
187 {
188     static char Type[3];
189
190     if (type == 0)
191         strcpy(Type, "rw");
192     else if (type == 1)
193         strcpy(Type, "ro");
194     else if (type == 2)
195         strcpy(Type, "bk");
196     else
197         strcpy(Type, "??");
198     return (Type);
199 }
200
201 afs_int32
202 NameHash(char *volname)
203 {
204     unsigned int hash;
205     char *vchar;
206
207     hash = 0;
208     for (vchar = volname + strlen(volname) - 1; vchar >= volname; vchar--)
209         hash = (hash * 63) + (*((unsigned char *)vchar) - 63);
210     return (hash % HASHSIZE);
211 }
212
213 afs_int32
214 IdHash(afs_uint32 volid)
215 {
216     return (volid % HASHSIZE);
217 }
218
219 #define LEGALCHARS ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
220 int
221 InvalidVolname(char *volname)
222 {
223     char *map;
224     size_t slen;
225
226     map = LEGALCHARS;
227     slen = strlen(volname);
228     if (slen >= VL_MAXNAMELEN)
229         return 1;
230     if (slen == 0)
231         return 1;
232     return (slen != strspn(volname, map));
233 }
234
235 int
236 validVolumeAddr(afs_uint32 fileOffset)
237 {
238     if (ADDR(fileOffset) >= maxentries) {
239         /* Are we in range */
240         return 0;
241     }
242     /*
243      * We cannot test whether the offset is aligned
244      * since the vl entries are not in a regular array
245      */
246     return 1;
247 }
248
249 void
250 readheader(struct vlheader *headerp)
251 {
252     int i, j;
253
254     vldbread(0, (char *)headerp, sizeof(*headerp));
255
256     headerp->vital_header.vldbversion =
257         ntohl(headerp->vital_header.vldbversion);
258     headerp->vital_header.headersize =
259         ntohl(headerp->vital_header.headersize);
260     headerp->vital_header.freePtr = ntohl(headerp->vital_header.freePtr);
261     headerp->vital_header.eofPtr = ntohl(headerp->vital_header.eofPtr);
262     headerp->vital_header.allocs = ntohl(headerp->vital_header.allocs);
263     headerp->vital_header.frees = ntohl(headerp->vital_header.frees);
264     headerp->vital_header.MaxVolumeId =
265         ntohl(headerp->vital_header.MaxVolumeId);
266     headerp->vital_header.totalEntries[0] =
267         ntohl(headerp->vital_header.totalEntries[0]);
268     for (i = 0; i < MAXTYPES; i++)
269         headerp->vital_header.totalEntries[i] =
270             ntohl(headerp->vital_header.totalEntries[1]);
271
272     headerp->SIT = ntohl(headerp->SIT);
273     for (i = 0; i <= MAXSERVERID; i++)
274         headerp->IpMappedAddr[i] = ntohl(headerp->IpMappedAddr[i]);
275     for (i = 0; i < HASHSIZE; i++)
276         headerp->VolnameHash[i] = ntohl(headerp->VolnameHash[i]);
277     for (i = 0; i < MAXTYPES; i++)
278         for (j = 0; j < HASHSIZE; j++)
279             headerp->VolidHash[i][j] = ntohl(headerp->VolidHash[i][j]);
280
281     if (listheader) {
282         quiet_println("vldb header\n");
283         quiet_println("   vldbversion      = %u\n",
284                headerp->vital_header.vldbversion);
285         quiet_println("   headersize       = %u [actual=%lu]\n",
286                headerp->vital_header.headersize, sizeof(*headerp));
287         quiet_println("   freePtr          = 0x%x\n", headerp->vital_header.freePtr);
288         quiet_println("   eofPtr           = %u\n", headerp->vital_header.eofPtr);
289         quiet_println("   allocblock calls = %10u\n", headerp->vital_header.allocs);
290         quiet_println("   freeblock  calls = %10u\n", headerp->vital_header.frees);
291         quiet_println("   MaxVolumeId      = %u\n",
292                headerp->vital_header.MaxVolumeId);
293         quiet_println("   rw vol entries   = %u\n",
294                headerp->vital_header.totalEntries[0]);
295         quiet_println("   ro vol entries   = %u\n",
296                headerp->vital_header.totalEntries[1]);
297         quiet_println("   bk vol entries   = %u\n",
298                headerp->vital_header.totalEntries[2]);
299         quiet_println("   multihome info   = 0x%x (%u)\n", headerp->SIT,
300                headerp->SIT);
301         quiet_println("   server ip addr   table: size = %d entries\n",
302                MAXSERVERID + 1);
303         quiet_println("   volume name hash table: size = %d buckets\n", HASHSIZE);
304         quiet_println("   volume id   hash table: %d tables with %d buckets each\n",
305                MAXTYPES, HASHSIZE);
306     }
307
308     /* Check the header size */
309     if (headerp->vital_header.headersize != sizeof(*headerp))
310         log_error(VLDB_CHECK_WARNING,"Header reports its size as %d (should be %lu)\n",
311                headerp->vital_header.headersize, sizeof(*headerp));
312     return;
313 }
314
315 void
316 writeheader(struct vlheader *headerp)
317 {
318     int i, j;
319
320     headerp->vital_header.vldbversion =
321         htonl(headerp->vital_header.vldbversion);
322     headerp->vital_header.headersize =
323         htonl(headerp->vital_header.headersize);
324     headerp->vital_header.freePtr = htonl(headerp->vital_header.freePtr);
325     headerp->vital_header.eofPtr = htonl(headerp->vital_header.eofPtr);
326     headerp->vital_header.allocs = htonl(headerp->vital_header.allocs);
327     headerp->vital_header.frees = htonl(headerp->vital_header.frees);
328     headerp->vital_header.MaxVolumeId =
329         htonl(headerp->vital_header.MaxVolumeId);
330     headerp->vital_header.totalEntries[0] =
331         htonl(headerp->vital_header.totalEntries[0]);
332     for (i = 0; i < MAXTYPES; i++)
333         headerp->vital_header.totalEntries[i] =
334             htonl(headerp->vital_header.totalEntries[1]);
335
336     headerp->SIT = htonl(headerp->SIT);
337     for (i = 0; i <= MAXSERVERID; i++)
338         headerp->IpMappedAddr[i] = htonl(headerp->IpMappedAddr[i]);
339     for (i = 0; i < HASHSIZE; i++)
340         headerp->VolnameHash[i] = htonl(headerp->VolnameHash[i]);
341     for (i = 0; i < MAXTYPES; i++)
342         for (j = 0; j < HASHSIZE; j++)
343             headerp->VolidHash[i][j] = htonl(headerp->VolidHash[i][j]);
344
345     vldbwrite(0, (char *)headerp, sizeof(*headerp));
346 }
347
348 void
349 readMH(afs_uint32 addr, int block, struct extentaddr *mhblockP)
350 {
351     int i, j;
352     struct extentaddr *e;
353
354     vldbread(addr, (char *)mhblockP, VL_ADDREXTBLK_SIZE);
355
356     /* Every mh block has the VLCONTBLOCK flag set in the header to
357      * indicate the entry is an 8192 byte extended block. The
358      * VLCONTBLOCK flag is always clear in regular vl entries. The
359      * vlserver depends on the VLCONTBLOCK flag to correctly traverse
360      * the vldb. The flags field is in network byte order. */
361     mhblockP->ex_hdrflags = ntohl(mhblockP->ex_hdrflags);
362
363     if (block == 0) {
364         /* These header fields are only used in the first mh block. */
365         mhblockP->ex_count = ntohl(mhblockP->ex_count);
366         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
367             mhblockP->ex_contaddrs[i] = ntohl(mhblockP->ex_contaddrs[i]);
368         }
369     }
370     for (i = 1; i < VL_MHSRV_PERBLK; i++) {
371         e = &(mhblockP[i]);
372
373         /* won't convert hostuuid */
374         e->ex_uniquifier = ntohl(e->ex_uniquifier);
375         for (j = 0; j < VL_MAXIPADDRS_PERMH; j++)
376             e->ex_addrs[j] = ntohl(e->ex_addrs[j]);
377     }
378     return;
379 }
380
381 void
382 readentry(afs_int32 addr, struct nvlentry *vlentryp, afs_int32 *type)
383 {
384     int i;
385
386     vldbread(addr, (char *)vlentryp, sizeof(*vlentryp));
387
388     for (i = 0; i < MAXTYPES; i++)
389         vlentryp->volumeId[i] = ntohl(vlentryp->volumeId[i]);
390     vlentryp->flags = ntohl(vlentryp->flags);
391     vlentryp->LockAfsId = ntohl(vlentryp->LockAfsId);
392     vlentryp->LockTimestamp = ntohl(vlentryp->LockTimestamp);
393     vlentryp->cloneId = ntohl(vlentryp->cloneId);
394     for (i = 0; i < MAXTYPES; i++)
395         vlentryp->nextIdHash[i] = ntohl(vlentryp->nextIdHash[i]);
396     vlentryp->nextNameHash = ntohl(vlentryp->nextNameHash);
397     for (i = 0; i < NMAXNSERVERS; i++) {
398         /* make sure not to ntohl these, as they're chars, not ints */
399         vlentryp->serverNumber[i] = vlentryp->serverNumber[i];
400         vlentryp->serverPartition[i] = vlentryp->serverPartition[i];
401         vlentryp->serverFlags[i] = vlentryp->serverFlags[i];
402     }
403
404     if (vlentryp->flags == VLCONTBLOCK) {
405         *type = MH;
406     } else if (vlentryp->flags == VLFREE) {
407         *type = FR;
408     } else {
409         *type = VL;
410     }
411
412     if (listentries) {
413         quiet_println("address %u (offset 0x%0x): ", addr, OFFSET(addr));
414         if (vlentryp->flags == VLCONTBLOCK) {
415             quiet_println("mh extension block\n");
416         } else if (vlentryp->flags == VLFREE) {
417             quiet_println("free vlentry\n");
418         } else {
419             quiet_println("vlentry %s\n", vlentryp->name);
420             quiet_println("   rw id = %u ; ro id = %u ; bk id = %u\n",
421                    vlentryp->volumeId[0], vlentryp->volumeId[1],
422                    vlentryp->volumeId[2]);
423             quiet_println("   flags         =");
424             if (vlentryp->flags & VLF_RWEXISTS)
425                 quiet_println(" rw");
426             if (vlentryp->flags & VLF_ROEXISTS)
427                 quiet_println(" ro");
428             if (vlentryp->flags & VLF_BACKEXISTS)
429                 quiet_println(" bk");
430             if (vlentryp->flags & VLOP_MOVE)
431                 quiet_println(" lock_move");
432             if (vlentryp->flags & VLOP_RELEASE)
433                 quiet_println(" lock_release");
434             if (vlentryp->flags & VLOP_BACKUP)
435                 quiet_println(" lock_backup");
436             if (vlentryp->flags & VLOP_DELETE)
437                 quiet_println(" lock_delete");
438             if (vlentryp->flags & VLOP_DUMP)
439                 quiet_println(" lock_dump");
440
441             /* all bits not covered by VLF_* and VLOP_* constants */
442             if (vlentryp->flags & 0xffff8e0f)
443                 quiet_println(" errorflag(0x%x)", vlentryp->flags);
444             quiet_println("\n");
445             quiet_println("   LockAfsId     = %d\n", vlentryp->LockAfsId);
446             quiet_println("   LockTimestamp = %d\n", vlentryp->LockTimestamp);
447             quiet_println("   cloneId       = %u\n", vlentryp->cloneId);
448             quiet_println
449                 ("   next hash for rw = %u ; ro = %u ; bk = %u ; name = %u\n",
450                  vlentryp->nextIdHash[0], vlentryp->nextIdHash[1],
451                  vlentryp->nextIdHash[2], vlentryp->nextNameHash);
452             for (i = 0; i < NMAXNSERVERS; i++) {
453                 if (vlentryp->serverNumber[i] != 255) {
454                     quiet_println("   server %d ; partition %d ; flags =",
455                            vlentryp->serverNumber[i],
456                            vlentryp->serverPartition[i]);
457                     if (vlentryp->serverFlags[i] & VLSF_RWVOL)
458                         quiet_println(" rw");
459                     if (vlentryp->serverFlags[i] & VLSF_ROVOL)
460                         quiet_println(" ro");
461                     if (vlentryp->serverFlags[i] & VLSF_BACKVOL)
462                         quiet_println(" bk");
463                     if (vlentryp->serverFlags[i] & VLSF_NEWREPSITE)
464                         quiet_println(" newro");
465                     quiet_println("\n");
466                 }
467             }
468         }
469     }
470     return;
471 }
472
473 void
474 writeMH(afs_int32 addr, int block, struct extentaddr *mhblockP)
475 {
476     int i, j;
477     struct extentaddr *e;
478
479     if (verbose) {
480         quiet_println("Writing back MH block % at addr %u\n", block,  addr);
481     }
482     if (block == 0) {
483         mhblockP->ex_count = htonl(mhblockP->ex_count);
484         mhblockP->ex_hdrflags = htonl(mhblockP->ex_hdrflags);
485         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
486             mhblockP->ex_contaddrs[i] = htonl(mhblockP->ex_contaddrs[i]);
487         }
488     }
489     for (i = 1; i < VL_MHSRV_PERBLK; i++) {
490         e = &(mhblockP[i]);
491         /* hostuuid was not converted */
492         e->ex_uniquifier = htonl(e->ex_uniquifier);
493         for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
494             e->ex_addrs[j] = htonl(e->ex_addrs[j]);
495         }
496     }
497     vldbwrite(addr, (char *)mhblockP, VL_ADDREXTBLK_SIZE);
498 }
499
500 void
501 writeentry(afs_int32 addr, struct nvlentry *vlentryp)
502 {
503     int i;
504
505     if (verbose) quiet_println("Writing back entry at addr %u\n", addr);
506     for (i = 0; i < MAXTYPES; i++)
507         vlentryp->volumeId[i] = htonl(vlentryp->volumeId[i]);
508     vlentryp->flags = htonl(vlentryp->flags);
509     vlentryp->LockAfsId = htonl(vlentryp->LockAfsId);
510     vlentryp->LockTimestamp = htonl(vlentryp->LockTimestamp);
511     vlentryp->cloneId = htonl(vlentryp->cloneId);
512     for (i = 0; i < MAXTYPES; i++)
513         vlentryp->nextIdHash[i] = htonl(vlentryp->nextIdHash[i]);
514     vlentryp->nextNameHash = htonl(vlentryp->nextNameHash);
515     for (i = 0; i < NMAXNSERVERS; i++) {
516         /* make sure not to htonl these, as they're chars, not ints */
517         vlentryp->serverNumber[i] =  vlentryp->serverNumber[i] ;
518         vlentryp->serverPartition[i] = vlentryp->serverPartition[i] ;
519         vlentryp->serverFlags[i] = vlentryp->serverFlags[i] ;
520     }
521     vldbwrite(addr, (char *)vlentryp, sizeof(*vlentryp));
522 }
523
524 /*
525  * Read each entry in the database:
526  * Record what type of entry it is and its address in the record array.
527  * Remember what the maximum volume id we found is and check against the header.
528  */
529 void
530 ReadAllEntries(struct vlheader *header)
531 {
532     afs_int32 type, rindex, i, j, e;
533     int freecount = 0, mhcount = 0, vlcount = 0;
534     int rwcount = 0, rocount = 0, bkcount = 0;
535     struct nvlentry vlentry;
536     afs_uint32 addr;
537     afs_uint32 entrysize = 0;
538     afs_uint32 maxvolid = 0;
539
540     if (verbose) quiet_println("Read each entry in the database\n");
541     for (addr = header->vital_header.headersize;
542          addr < header->vital_header.eofPtr; addr += entrysize) {
543
544         /* Remember the highest volume id */
545         readentry(addr, &vlentry, &type);
546         if (type == VL) {
547
548             for (i = 0; i < MAXTYPES; i++)
549                 if (maxvolid < vlentry.volumeId[i])
550                     maxvolid = vlentry.volumeId[i];
551
552             e = 1;
553             for (j = 0; j < NMAXNSERVERS; j++) {
554                 if (vlentry.serverNumber[j] == 255)
555                     continue;
556                 if (vlentry.serverFlags[j] & (VLSF_ROVOL | VLSF_NEWREPSITE)) {
557                     rocount++;
558                     continue;
559                 }
560                 if (vlentry.serverFlags[j] & VLSF_RWVOL) {
561                     rwcount++;
562                     if (vlentry.flags & VLF_BACKEXISTS)
563                         bkcount++;
564                     continue;
565                 }
566                 if (!vlentry.serverFlags[j]) {
567                     /*e = 0;*/
568                     continue;
569                 }
570                 if (e) {
571                    log_error
572                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): VLDB entry '%s' contains an unknown RW/RO index serverFlag\n",
573                         addr, OFFSET(addr), vlentry.name);
574                     e = 0;
575                 }
576                 quiet_println
577                     ("   index %d : serverNumber %d : serverPartition %d : serverFlag %d\n",
578                      j, vlentry.serverNumber[j], vlentry.serverPartition[j],
579                      vlentry.serverFlags[j]);
580             }
581         }
582
583         rindex = addr / sizeof(vlentry);
584         if (record[rindex].type) {
585             log_error(VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: record holder %d already in use\n",
586                    rindex);
587             return;
588         }
589         record[rindex].addr = addr;
590         record[rindex].type = type;
591
592         /* Determine entrysize and keep count */
593         if (type == VL) {
594             entrysize = sizeof(vlentry);
595             vlcount++;
596         } else if (type == FR) {
597             entrysize = sizeof(vlentry);
598             freecount++;
599         } else if (type == MH) {
600             entrysize = VL_ADDREXTBLK_SIZE;
601             mhcount++;
602         } else {
603             log_error(VLDB_CHECK_ERROR, "address %u (offset 0x%0x): Unknown entry. Aborting\n", addr, OFFSET(addr));
604             break;
605         }
606     }
607     if (verbose) {
608         quiet_println("Found %d entries, %d free entries, %d multihomed blocks\n",
609                vlcount, freecount, mhcount);
610         quiet_println("Found %d RW volumes, %d BK volumes, %d RO volumes\n", rwcount,
611                bkcount, rocount);
612     }
613
614     /* Check the maxmimum volume id in the header */
615     if (maxvolid != header->vital_header.MaxVolumeId - 1)
616         quiet_println
617             ("Header's maximum volume id is %u and largest id found in VLDB is %u\n",
618              header->vital_header.MaxVolumeId, maxvolid);
619 }
620
621 /*
622  * Follow each Name hash bucket marking it as read in the record array.
623  * Record we found it in the name hash within the record array.
624  * Check that the name is hashed correctly.
625  */
626 void
627 FollowNameHash(struct vlheader *header)
628 {
629     int count = 0, longest = 0, shortest = -1, chainlength;
630     struct nvlentry vlentry;
631     afs_uint32 addr;
632     afs_int32 i, type, rindex;
633
634     /* Now follow the Name Hash Table */
635     if (verbose) quiet_println("Check Volume Name Hash\n");
636     for (i = 0; i < HASHSIZE; i++) {
637         chainlength = 0;
638
639         if (!validVolumeAddr(header->VolnameHash[i])) {
640             log_error(VLDB_CHECK_ERROR,"Name Hash index %d is out of range: %u\n",
641                       i, header->VolnameHash[i]);
642             continue;
643         }
644
645         for (addr = header->VolnameHash[i]; addr; addr = vlentry.nextNameHash) {
646             readentry(addr, &vlentry, &type);
647             if (type != VL) {
648                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: Not a vlentry\n",
649                        addr, OFFSET(addr), i);
650                 continue;
651             }
652
653             rindex = ADDR(addr);
654
655             /*
656              * we know that the address is valid because we
657              * checked it either above or below
658              */
659             if (record[rindex].addr != addr && record[rindex].addr) {
660                 log_error
661                     (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %ld and %u use same record slot %d\n",
662                      record[rindex].addr, addr, rindex);
663             }
664             if (record[rindex].type & NH) {
665                 log_error
666                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: volume name '%s' is already in the name hash\n",
667                      addr, OFFSET(addr), i, vlentry.name);
668                 record[rindex].type |= MULTN;
669                 break;
670             }
671
672             if (!validVolumeAddr(vlentry.nextNameHash)) {
673                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash forward link of '%s' is out of range\n",
674                           addr, OFFSET(addr), vlentry.name);
675                 record[rindex].type |= MULTN;
676                 break;
677             }
678
679             record[rindex].type |= NH;
680             record[rindex].type |= REFN;
681
682             chainlength++;
683             count++;
684
685             /* Hash the name and check if in correct hash table */
686             if (NameHash(vlentry.name) != i) {
687                 log_error
688                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: volume name '%s': Incorrect name hash chain (should be in %d)\n",
689                      addr, OFFSET(addr), i, vlentry.name, NameHash(vlentry.name));
690                 record[rindex].type |= MULTN;
691             }
692         }
693         if (chainlength > longest)
694             longest = chainlength;
695         if ((shortest == -1) || (chainlength < shortest))
696             shortest = chainlength;
697     }
698     if (verbose) {
699         quiet_println
700             ("%d entries in name hash, longest is %d, shortest is %d, average length is %f\n",
701              count, longest, shortest, ((float)count / (float)HASHSIZE));
702     }
703     return;
704 }
705
706 /*
707  * Follow the ID hash chains for the RW, RO, and BK hash tables.
708  * Record we found it in the id hash within the record array.
709  * Check that the ID is hashed correctly.
710  */
711 void
712 FollowIdHash(struct vlheader *header)
713 {
714     int count = 0, longest = 0, shortest = -1, chainlength;
715     struct nvlentry vlentry;
716     afs_uint32 addr;
717     afs_int32 i, j, hash, type, rindex, ref, badref, badhash;
718
719     /* Now follow the RW, RO, and BK Hash Tables */
720     if (verbose) quiet_println("Check RW, RO, and BK id Hashes\n");
721     for (i = 0; i < MAXTYPES; i++) {
722         hash = ((i == 0) ? RWH : ((i == 1) ? ROH : BKH));
723         ref = ((i == 0) ? REFRW : ((i == 1) ? REFRO : REFBK));
724         badref = ((i == 0) ? MULTRW : ((i == 1) ? MULTRO : MULTBK));
725         badhash = ((i == 0) ? MULTRW : ((i == 1) ? MULTRO : MULTBK));
726         count = longest = 0;
727         shortest = -1;
728
729         for (j = 0; j < HASHSIZE; j++) {
730             chainlength = 0;
731             if (!validVolumeAddr(header->VolidHash[i][j])) {
732                 log_error(VLDB_CHECK_ERROR,"%s Hash index %d is out of range: %u\n",
733                           vtype(i), j, header->VolidHash[i][j]);
734                 continue;
735             }
736
737             for (addr = header->VolidHash[i][j]; addr;
738                  addr = vlentry.nextIdHash[i]) {
739                 readentry(addr, &vlentry, &type);
740                 if (type != VL) {
741                     log_error
742                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: Not a vlentry\n",
743                          addr, OFFSET(addr), vtype(i), j);
744                     continue;
745                 }
746
747                 rindex = ADDR(addr);
748                 if (record[rindex].addr != addr && record[rindex].addr) {
749                     log_error
750                         (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %ld and %u use same record slot %d\n",
751                          record[rindex].addr, addr, rindex);
752                 }
753                 if (record[rindex].type & hash) {
754                     log_error
755                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: volume name '%s': Already in the hash table\n",
756                          addr, OFFSET(addr), vtype(i), j, vlentry.name);
757                     record[rindex].type |= badref;
758                     break;
759                 }
760
761                 if (!validVolumeAddr(vlentry.nextIdHash[i])) {
762                     log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash forward link of '%s' is out of range\n",
763                               addr, OFFSET(addr), vtype(i), vlentry.name);
764                     record[rindex].type |= badref;
765                     break;
766                 }
767
768                 record[rindex].type |= hash;
769                 record[rindex].type |= ref;
770
771                 chainlength++;
772                 count++;
773
774                 /* Hash the id and check if in correct hash table */
775                 if (IdHash(vlentry.volumeId[i]) != j) {
776                    log_error
777                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: volume name '%s': Incorrect Id hash chain (should be in %d)\n",
778                          addr, OFFSET(addr), vtype(i), j, vlentry.name,
779                          IdHash(vlentry.volumeId[i]));
780                     record[rindex].type |= badhash;
781                 }
782             }
783
784             if (chainlength > longest)
785                 longest = chainlength;
786             if ((shortest == -1) || (chainlength < shortest))
787                 shortest = chainlength;
788         }
789         if (verbose) {
790             quiet_println
791                 ("%d entries in %s hash, longest is %d, shortest is %d, average length is %f\n",
792                  count, vtype(i), longest, shortest,((float)count / (float)HASHSIZE));
793         }
794     }
795     return;
796 }
797
798 /*
799  * Follow the free chain.
800  * Record we found it in the free chain within the record array.
801  */
802 void
803 FollowFreeChain(struct vlheader *header)
804 {
805     afs_int32 count = 0;
806     struct nvlentry vlentry;
807     afs_uint32 addr;
808     afs_int32 type, rindex;
809
810     /* Now follow the Free Chain */
811     if (verbose) quiet_println("Check Volume Free Chain\n");
812     for (addr = header->vital_header.freePtr; addr;
813          addr = vlentry.nextIdHash[0]) {
814         readentry(addr, &vlentry, &type);
815         if (type != FR) {
816            log_error
817                 (VLDB_CHECK_ERROR,"address %u (offset 0%0x): Free Chain %d: Not a free vlentry (0x%x)\n",
818                  addr, OFFSET(addr), count, type);
819             continue;
820         }
821
822         rindex = addr / sizeof(vlentry);
823         if (record[rindex].addr != addr && record[rindex].addr) {
824            log_error
825                 (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u (0x%0x) and %ld (0x%0x) use same record slot %d\n",
826                  record[rindex].addr, OFFSET(record[rindex].addr), addr, OFFSET(addr), rindex);
827         }
828         if (record[rindex].type & FRC) {
829             log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free Chain: Already in the free chain\n",
830                    addr, OFFSET(addr));
831             break;
832         }
833         record[rindex].type |= FRC;
834
835         count++;
836     }
837     if (verbose)
838      quiet_println("%d entries on free chain\n", count);
839     return;
840 }
841
842 /*
843  * Read each multihomed block and mark it as found in the record.
844  * Read each entry in each multihomed block and mark the serveraddrs
845  * array with the number of ip addresses found for this entry.
846  *
847  * Then read the IpMappedAddr array in the header.
848  * Verify that multihomed entries base and index are valid and points to
849  * a good multhomed entry.
850  * Mark the serveraddrs array with 1 ip address for regular entries.
851  *
852  * By the end, the severaddrs array will have a 0 if the entry has no
853  * IP addresses in it or the count of the number of IP addresses.
854  *
855  * The code does not verify if there are duplicate IP addresses in the
856  * list. The vlserver does this when a fileserver registeres itself.
857  */
858 void
859 CheckIpAddrs(struct vlheader *header)
860 {
861     int mhblocks = 0;
862     afs_int32 i, j, m, rindex;
863     afs_int32 mhentries, regentries;
864     char mhblock[VL_ADDREXTBLK_SIZE];
865     struct extentaddr *MHblock = (struct extentaddr *)mhblock;
866     struct extentaddr *e;
867     int ipindex, ipaddrs;
868     afsUUID nulluuid;
869
870     memset(&nulluuid, 0, sizeof(nulluuid));
871
872     if (verbose)
873         quiet_println("Check Multihomed blocks\n");
874
875     if (header->SIT) {
876         /* Read the first MH block and from it, gather the
877          * addresses of all the mh blocks.
878          */
879         readMH(header->SIT, 0, MHblock);
880         if (MHblock->ex_hdrflags != VLCONTBLOCK) {
881            log_error
882                 (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed Block 0: Not a multihomed block\n",
883                  header->SIT, OFFSET(header->SIT));
884         }
885
886         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
887             mhinfo[i].addr = MHblock->ex_contaddrs[i];
888         }
889
890         if (header->SIT != mhinfo[0].addr) {
891            log_error
892                 (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): MH block does not point to self in header, %u in block\n",
893                  header->SIT, OFFSET(header->SIT), mhinfo[0].addr);
894         }
895
896         /* Now read each MH block and record it in the record array */
897         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
898             if (!mhinfo[i].addr)
899                 continue;
900
901             readMH(mhinfo[i].addr, i, MHblock);
902             if (MHblock->ex_hdrflags != VLCONTBLOCK) {
903                 log_error
904                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed Block %d: Not a multihomed block\n",
905                      mhinfo[i].addr, OFFSET(mhinfo[i].addr), i);
906             }
907
908             rindex = mhinfo[i].addr / sizeof(vlentry);
909             if (record[rindex].addr != mhinfo[i].addr && record[rindex].addr) {
910                 log_error
911                     (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u (0x%0x) and %u (0x%0x) use same record slot %d\n",
912                      record[rindex].addr, OFFSET(record[rindex].addr), mhinfo[i].addr, OFFSET(mhinfo[i].addr), rindex);
913             }
914             if (record[rindex].type & FRC) {
915                 log_error
916                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): MH Blocks Chain %d: Already a MH block\n",
917                      record[rindex].addr, OFFSET(record[rindex].addr), i);
918                 break;
919             }
920             record[rindex].type |= MHC;
921
922             mhblocks++;
923
924             /* Read each entry in a multihomed block.
925              * Find the pointer to the entry in the IpMappedAddr array and
926              * verify that the entry is good (has IP addresses in it).
927              */
928             mhentries = 0;
929             for (j = 1; j < VL_MHSRV_PERBLK; j++) {
930                 int first_ipindex = -1;
931                 e = (struct extentaddr *)&(MHblock[j]);
932
933                 /* Search the IpMappedAddr array for all the references to this entry. */
934                 /* Use the first reference for checking the ip addresses of this entry. */
935                 for (ipindex = 0; ipindex <= MAXSERVERID; ipindex++) {
936                     if (((header->IpMappedAddr[ipindex] & 0xff000000) == 0xff000000)
937                         && (((header-> IpMappedAddr[ipindex] & 0x00ff0000) >> 16) == i)
938                         && ((header->IpMappedAddr[ipindex] & 0x0000ffff) == j)) {
939                         if (first_ipindex == -1) {
940                             first_ipindex = ipindex;
941                         } else {
942                             serverxref[ipindex] = first_ipindex;
943                         }
944                     }
945                 }
946                 ipindex = first_ipindex;
947                 if (ipindex != -1)
948                     serveraddrs[ipindex] = -1;
949
950                 if (memcmp(&e->ex_hostuuid, &nulluuid, sizeof(afsUUID)) == 0) {
951                     if (ipindex != -1) {
952                         log_error
953                             (VLDB_CHECK_ERROR,"Server Addrs index %d references null MH block %d, index %d\n",
954                              ipindex, i, j);
955                         serveraddrs[ipindex] = 0;       /* avoids printing 2nd error below */
956                     }
957                     continue;
958                 }
959
960                 /* Step through each ip address and count the good addresses */
961                 ipaddrs = 0;
962                 for (m = 0; m < VL_MAXIPADDRS_PERMH; m++) {
963                     if (e->ex_addrs[m])
964                         ipaddrs++;
965                 }
966
967                 /* If we found any good ip addresses, mark it in the serveraddrs record */
968                 if (ipaddrs) {
969                     mhentries++;
970                     if (ipindex == -1) {
971                         mhinfo[i].orphan[j] = 1;
972                         log_error
973                             (VLDB_CHECK_ERROR,"MH block %d, index %d: Not referenced by server addrs\n",
974                              i, j);
975                     } else {
976                         serveraddrs[ipindex] = ipaddrs; /* It is good */
977                     }
978                 }
979
980                 if (listservers && ipaddrs) {
981                     quiet_println("MH block %d, index %d:", i, j);
982                     for (m = 0; m < VL_MAXIPADDRS_PERMH; m++) {
983                         if (!e->ex_addrs[m])
984                             continue;
985                         quiet_println(" %d.%d.%d.%d",
986                                (e->ex_addrs[m] & 0xff000000) >> 24,
987                                (e->ex_addrs[m] & 0x00ff0000) >> 16,
988                                (e->ex_addrs[m] & 0x0000ff00) >> 8,
989                                (e->ex_addrs[m] & 0x000000ff));
990                     }
991                     quiet_println("\n");
992                 }
993             }
994 /*
995  *      if (mhentries != MHblock->ex_count) {
996  *         quiet_println("MH blocks says it has %d entries (found %d)\n",
997  *                MHblock->ex_count, mhentries);
998  *      }
999  */
1000         }
1001     }
1002     if (verbose)
1003         quiet_println("%d multihomed blocks\n", mhblocks);
1004
1005     /* Check the server addresses */
1006     if (verbose)
1007         quiet_println("Check server addresses\n");
1008     mhentries = regentries = 0;
1009     for (i = 0; i <= MAXSERVERID; i++) {
1010         if (header->IpMappedAddr[i]) {
1011             if ((header->IpMappedAddr[i] & 0xff000000) == 0xff000000) {
1012                 mhentries++;
1013                 if (((header->IpMappedAddr[i] & 0x00ff0000) >> 16) >
1014                     VL_MAX_ADDREXTBLKS)
1015                    log_error
1016                         (VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome block is bad (%d)\n",
1017                          i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
1018                 if (mhinfo[(header->IpMappedAddr[i] & 0x00ff0000) >> 16].addr == 0)
1019                     log_error(VLDB_CHECK_ERROR,"IP Addr for entry %d: No such multihome block (%d)\n",
1020                          i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
1021                 if (((header->IpMappedAddr[i] & 0x0000ffff) > VL_MHSRV_PERBLK)
1022                     || ((header->IpMappedAddr[i] & 0x0000ffff) < 1))
1023                     log_error
1024                         (VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome index is bad (%d)\n",
1025                          i, (header->IpMappedAddr[i] & 0x0000ffff));
1026                 if (serveraddrs[i] == -1) {
1027                     log_error
1028                         (VLDB_CHECK_WARNING,"warning: IP Addr for entry %d: Multihome entry has no ip addresses\n",
1029                          i);
1030                     serveraddrs[i] = 0;
1031                 }
1032                 if (serverxref[i] != BADSERVERID) {
1033                     log_error
1034                         (VLDB_CHECK_WARNING,
1035                         "warning: MH block %d, index %d is cross-linked by server numbers %d and %d.\n",
1036                         (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1037                         (header->IpMappedAddr[i] & 0x0000ffff),
1038                         i, serverxref[i]);
1039                     /* set addresses found/not found for this server number,
1040                      * using the first index to the mh we found above. */
1041                     serveraddrs[i] = serveraddrs[serverxref[i]];
1042                 }
1043                 if (listservers) {
1044                     quiet_println("   Server ip addr %d = MH block %d, index %d\n",
1045                            i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1046                            (header->IpMappedAddr[i] & 0x0000ffff));
1047                 }
1048             } else {
1049                 regentries++;
1050                 serveraddrs[i] = 1;     /* It is good */
1051                 if (listservers) {
1052                     quiet_println("   Server ip addr %d = %d.%d.%d.%d\n", i,
1053                            (header->IpMappedAddr[i] & 0xff000000) >> 24,
1054                            (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1055                            (header->IpMappedAddr[i] & 0x0000ff00) >> 8,
1056                            (header->IpMappedAddr[i] & 0x000000ff));
1057                 }
1058             }
1059         }
1060     }
1061     if (verbose) {
1062         quiet_println("%d simple entries, %d multihomed entries, Total = %d\n",
1063                regentries, mhentries, mhentries + regentries);
1064     }
1065     return;
1066 }
1067
1068 char *
1069 nameForAddr(afs_uint32 addr, int hashtype, afs_uint32 *hash, char *buffer)
1070 {
1071     /*
1072      * We need to simplify the reporting, while retaining
1073      * legible messages.  This is a helper function.  The return address
1074      * is either a fixed char or the provided buffer - so don't use the
1075      * name after the valid lifetime of the buffer.
1076      */
1077     afs_int32 type;
1078     struct nvlentry entry;
1079     if (!addr) {
1080         /* Distinguished, invalid, hash */
1081         *hash = 0xFFFFFFFF;
1082         return "empty";
1083     } else if (!validVolumeAddr(addr)) {
1084         /* Different, invalid, hash */
1085         *hash = 0XFFFFFFFE;
1086         return "invalid";
1087     }
1088     readentry(addr, &entry, &type);
1089     if (VL != type) {
1090         *hash = 0XFFFFFFFE;
1091         return "invalid";
1092     }
1093     if (hashtype >= MAXTYPES) {
1094         *hash = NameHash(entry.name);
1095     } else {
1096         *hash = IdHash(entry.volumeId[hashtype]);
1097     }
1098     sprintf(buffer, "for '%s'", entry.name);
1099     return buffer;
1100 }
1101
1102 void
1103 reportHashChanges(struct vlheader *header, afs_uint32 oldnamehash[HASHSIZE], afs_uint32 oldidhash[MAXTYPES][HASHSIZE])
1104 {
1105     int i, j;
1106     afs_uint32 oldhash, newhash;
1107     char oldNameBuffer[10 + VL_MAXNAMELEN];
1108     char newNameBuffer[10 + VL_MAXNAMELEN];
1109     char *oldname, *newname;
1110     /*
1111      * report hash changes
1112      */
1113
1114     for (i = 0; i < HASHSIZE; i++) {
1115         if (oldnamehash[i] != header->VolnameHash[i]) {
1116
1117             oldname = nameForAddr(oldnamehash[i], MAXTYPES, &oldhash, oldNameBuffer);
1118             newname = nameForAddr(header->VolnameHash[i], MAXTYPES, &newhash, newNameBuffer);
1119             if (verbose || (oldhash != newhash)) {
1120                 quiet_println("FIX: Name hash header at %d was %s, is now %s\n", i, oldname, newname);
1121             }
1122         }
1123         for (j = 0; j < MAXTYPES; j++) {
1124             if (oldidhash[j][i] != header->VolidHash[j][i]) {
1125
1126                 oldname = nameForAddr(oldidhash[j][i], j, &oldhash, oldNameBuffer);
1127                 newname = nameForAddr(header->VolidHash[j][i], j, &newhash, newNameBuffer);
1128                 if (verbose || (oldhash != newhash)) {
1129                     quiet_println("FIX: %s hash header at %d was %s, is now %s\n", vtype(j), i, oldname, newname);
1130                 }
1131             }
1132         }
1133     }
1134 }
1135
1136 /**
1137  * Remove unreferenced, duplicate multi-home address indices.
1138  *
1139  * Removes entries from IpMappedAddr which where found to be
1140  * duplicates. Only entries which are not referenced by vl entries
1141  * are removed on this pass.
1142  *
1143  * @param[inout] header the vldb header to be updated.
1144  */
1145 void
1146 removeCrossLinkedAddresses(struct vlheader *header)
1147 {
1148     int i;
1149
1150     for (i = 0; i <= MAXSERVERID; i++) {
1151         if (serverref[i] == 0
1152             && (header->IpMappedAddr[i] & 0xff000000) == 0xff000000
1153             && serverxref[i] != BADSERVERID) {
1154             if (serverxref[i] == i) {
1155                 log_error(VLDB_CHECK_ERROR,
1156                           "INTERNAL VLDB_CHECK_ERROR: serverxref points to self; index %d\n",
1157                           i);
1158             } else if (header->IpMappedAddr[serverxref[i]] == 0) {
1159                 log_error(VLDB_CHECK_ERROR,
1160                           "INTERNAL VLDB_CHECK_ERROR: serverxref points to empty addr; index %d, value %d\n",
1161                           i, serverxref[i]);
1162             } else if (header->IpMappedAddr[serverxref[i]] != header->IpMappedAddr[i]) {
1163                 log_error(VLDB_CHECK_ERROR,
1164                           "INTERNAL VLDB_CHECK_ERROR: invalid serverxref; index %d, value %d\n",
1165                           i, serverxref[i]);
1166             } else {
1167                 quiet_println
1168                     ("FIX: Removing unreferenced address index %d, which cross-links MH block %d, index %d\n",
1169                      i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1170                      (header->IpMappedAddr[i] & 0x0000ffff));
1171                 header->IpMappedAddr[i] = 0;
1172             }
1173         }
1174     }
1175 }
1176
1177 int
1178 WorkerBee(struct cmd_syndesc *as, void *arock)
1179 {
1180     char *dbfile;
1181     afs_int32 type;
1182     struct vlheader header;
1183     struct nvlentry vlentry, vlentry2;
1184     int i, j, k;
1185     afs_uint32 oldnamehash[HASHSIZE];
1186     afs_uint32 oldidhash[MAXTYPES][HASHSIZE];
1187
1188     error_level = 0;  /*  start clean with no error status */
1189     dbfile = as->parms[0].items->data;  /* -database */
1190     listuheader = (as->parms[1].items ? 1 : 0); /* -uheader  */
1191     listheader = (as->parms[2].items ? 1 : 0);  /* -vheader  */
1192     listservers = (as->parms[3].items ? 1 : 0); /* -servers  */
1193     listentries = (as->parms[4].items ? 1 : 0); /* -entries  */
1194     verbose = (as->parms[5].items ? 1 : 0);     /* -verbose  */
1195     quiet = (as->parms[6].items ? 1 : 0);  /* -quiet */
1196     fix = (as->parms[7].items ? 1 : 0);    /* -fix  */
1197
1198     /* sanity check */
1199     if (quiet && (verbose || listuheader || listheader ||listservers \
1200                 || listentries)) {
1201         log_error(VLDB_CHECK_FATAL," -quiet cannot be used other display flags\n");
1202         return VLDB_CHECK_FATAL;
1203     }
1204
1205
1206     /* open the vldb database file */
1207     fd = open(dbfile, (fix > 0)?O_RDWR:O_RDONLY, 0);
1208     if (fd < 0) {
1209         log_error(VLDB_CHECK_FATAL,"can't open file '%s'. error = %d\n", dbfile, errno);
1210         return 0;
1211     }
1212
1213     /* read the ubik header and the vldb database header */
1214     readUbikHeader();
1215     readheader(&header);
1216     if (header.vital_header.vldbversion < 3) {
1217         log_error(VLDB_CHECK_FATAL,"does not support vldb with version less than 3\n");
1218         return VLDB_CHECK_FATAL;
1219     }
1220
1221     maxentries = (header.vital_header.eofPtr / sizeof(vlentry)) + 1;
1222     record = calloc(maxentries, sizeof(struct er));
1223     memset(serveraddrs, 0, sizeof(serveraddrs));
1224     memset(mhinfo, 0, sizeof(mhinfo));
1225     memset(serverref, 0, sizeof(serverref));
1226     for (i = 0; i <= MAXSERVERID; i++) {
1227         serverxref[i] = BADSERVERID;
1228     }
1229
1230     /* Will fill in the record array of entries it found */
1231     ReadAllEntries(&header);
1232     listentries = 0;            /* Listed all the entries */
1233
1234     /* Check the multihomed blocks for valid entries as well as
1235      * the IpMappedAddrs array in the header for valid entries.
1236      */
1237     CheckIpAddrs(&header);
1238
1239     /* Follow the hash tables */
1240     FollowNameHash(&header);
1241     FollowIdHash(&header);
1242
1243     /* Follow the chain of free entries */
1244     FollowFreeChain(&header);
1245
1246     /* Now check the record we have been keeping for inconsistencies
1247      * For valid vlentries, also check that the server we point to is
1248      * valid (the serveraddrs array).
1249      */
1250     if (verbose)
1251         quiet_println("Verify each volume entry\n");
1252     for (i = 0; i < maxentries; i++) {
1253         int hash = 0;
1254         int nexthash = 0;
1255         char *which = NULL;
1256
1257         if (record[i].type == 0)
1258             continue;
1259
1260         /* If a vlentry, verify that its name is valid, its name and ids are
1261          * on the hash chains, and its server numbers are good.
1262          */
1263         if (record[i].type & VL) {
1264             int foundbad = 0;
1265             int foundbroken = 0;
1266             char volidbuf[256];
1267
1268             readentry(record[i].addr, &vlentry, &type);
1269
1270             if (!(vlentry.flags & VLF_RWEXISTS))
1271                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has no RW volume\n",
1272                        record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
1273
1274             if (InvalidVolname(vlentry.name))
1275                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has an invalid name\n",
1276                        record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
1277
1278             if (vlentry.volumeId[0] == 0)
1279                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has an invalid volume id\n",
1280                        record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
1281
1282             if (!(record[i].type & NH)) {
1283                 hash = NameHash(vlentry.name);
1284                 which = "name";
1285                 volidbuf[0]='\0';
1286                 foundbad = 1;
1287             }
1288
1289             if (vlentry.volumeId[0] && !(record[i].type & RWH)) {
1290                 hash = IdHash(vlentry.volumeId[0]);
1291                 which = "RW";
1292                 sprintf(volidbuf, "id %u ", vlentry.volumeId[0]);
1293                 foundbad = 1;
1294             }
1295
1296             if (vlentry.volumeId[1] && !(record[i].type & ROH)) {
1297                 hash = IdHash(vlentry.volumeId[1]);
1298                 which = "RO";
1299                 sprintf(volidbuf, "id %u ", vlentry.volumeId[1]);
1300                 foundbad = 1;
1301             }
1302
1303             if (vlentry.volumeId[2] && !(record[i].type & BKH)) {
1304                 hash = IdHash(vlentry.volumeId[2]);
1305                 which = "BK";
1306                 sprintf(volidbuf, "id %u ", vlentry.volumeId[2]);
1307                 foundbad = 1;
1308             }
1309
1310             if (!validVolumeAddr(vlentry.nextNameHash) ||
1311                 record[ADDR(vlentry.nextNameHash)].type & MULTN) {
1312                 hash = NameHash(vlentry.name);
1313                 which = "name";
1314                 volidbuf[0]='\0';
1315                 if (validVolumeAddr(vlentry.nextNameHash)) {
1316                     readentry(vlentry.nextNameHash, &vlentry2, &type);
1317                     nexthash = NameHash(vlentry2.name);
1318                 } else {
1319                     nexthash = 0xFFFFFFFF;
1320                 }
1321                 if (hash != nexthash)
1322                     foundbroken = 1;
1323             }
1324
1325             if (!validVolumeAddr(vlentry.nextIdHash[0]) ||
1326                 record[ADDR(vlentry.nextIdHash[0])].type & MULTRW) {
1327                 hash = IdHash(vlentry.volumeId[0]);
1328                 which = "RW";
1329                 sprintf(volidbuf, "id %u ", vlentry.volumeId[0]);
1330                 if (validVolumeAddr(vlentry.nextIdHash[0])) {
1331                     readentry(vlentry.nextIdHash[0], &vlentry2, &type);
1332                     nexthash = IdHash(vlentry2.volumeId[0]);
1333                 } else {
1334                     nexthash = 0xFFFFFFFF;
1335                 }
1336                 if (hash != nexthash)
1337                     foundbroken = 1;
1338             }
1339
1340             if (!validVolumeAddr(vlentry.nextIdHash[1]) ||
1341                 record[ADDR(vlentry.nextIdHash[1])].type & MULTRO) {
1342                 hash = IdHash(vlentry.volumeId[1]);
1343                 which = "RO";
1344                 sprintf(volidbuf, "id %u ", vlentry.volumeId[1]);
1345                 if (validVolumeAddr(vlentry.nextIdHash[1])) {
1346                     readentry(vlentry.nextIdHash[1], &vlentry2, &type);
1347                     nexthash = IdHash(vlentry2.volumeId[1]);
1348                 } else {
1349                     nexthash = 0xFFFFFFFF;
1350                 }
1351                 if (hash != nexthash)
1352                     foundbroken = 1;
1353             }
1354
1355             if (!validVolumeAddr(vlentry.nextIdHash[2]) ||
1356                 record[ADDR(vlentry.nextIdHash[2])].type & MULTBK) {
1357                 hash = IdHash(vlentry.volumeId[2]);
1358                 which = "BK";
1359                 sprintf(volidbuf, "id %u ", vlentry.volumeId[2]);
1360                 if (validVolumeAddr(vlentry.nextIdHash[2])) {
1361                     readentry(vlentry.nextIdHash[2], &vlentry2, &type);
1362                     nexthash = IdHash(vlentry2.volumeId[2]);
1363                 } else {
1364                     nexthash = 0xFFFFFFFF;
1365                 }
1366                 if (hash != nexthash)
1367                     foundbroken = 1;
1368             }
1369
1370             if (foundbroken) {
1371                 log_error(VLDB_CHECK_ERROR,
1372                         "address %u (offset 0x%0x): Volume '%s' %s forward link in %s hash chain is broken (hash %d != %d)\n",
1373                         record[i].addr, OFFSET(record[i].addr),
1374                         vlentry.name, volidbuf, which, hash, nexthash);
1375             } else if (foundbad) {
1376                 log_error(VLDB_CHECK_ERROR,
1377                         "address %u (offset 0x%0x): Volume '%s' %snot found in %s hash %d\n",
1378                         record[i].addr, OFFSET(record[i].addr),
1379                         vlentry.name, volidbuf, which, hash);
1380             }
1381
1382             for (j = 0; j < NMAXNSERVERS; j++) {
1383                 if (vlentry.serverNumber[j] != BADSERVERID) {
1384                     serverref[vlentry.serverNumber[j]] = 1;
1385                     if (serveraddrs[vlentry.serverNumber[j]] == 0) {
1386                         log_error
1387                             (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s', index %d points to empty server entry %d\n",
1388                              record[i].addr, OFFSET(record[i].addr), vlentry.name, j, vlentry.serverNumber[j]);
1389                     } else if (serverxref[vlentry.serverNumber[j]] != BADSERVERID) {
1390                             log_error
1391                             (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s', index %d points to server entry %d, which is cross-linked by %d\n",
1392                              record[i].addr, OFFSET(record[i].addr), vlentry.name, j, vlentry.serverNumber[j], serverxref[vlentry.serverNumber[j]]);
1393                     }
1394                 }
1395             }
1396
1397             if (record[i].type & 0xffff0f00)
1398                 log_error
1399                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' id %u also found on other chains (0x%x)\n",
1400                      record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0], record[i].type);
1401
1402             /* A free entry */
1403         } else if (record[i].type & FR) {
1404             if (!(record[i].type & FRC))
1405                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free vlentry not on free chain\n",
1406                        record[i].addr, OFFSET(record[i].addr));
1407
1408             if (record[i].type & 0xfffffdf0)
1409                 log_error
1410                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free vlentry also found on other chains (0x%x)\n",
1411                      record[i].addr, OFFSET(record[i].addr), record[i].type);
1412
1413             /* A multihomed entry */
1414         } else if (record[i].type & MH) {
1415             if (!(record[i].type & MHC))
1416                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed block is orphaned\n",
1417                        record[i].addr, OFFSET(record[i].addr));
1418
1419             if (record[i].type & 0xfffffef0)
1420                 log_error
1421                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed block also found on other chains (0x%x)\n",
1422                      record[i].addr, OFFSET(record[i].addr), record[i].type);
1423
1424         } else {
1425             log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Unknown entry type 0x%x\n",
1426                    record[i].addr, OFFSET(record[i].addr), record[i].type);
1427         }
1428     }
1429
1430     if (fix) {
1431         /*
1432          * If we are fixing we will rebuild the free and hash lists from the ground up.
1433          */
1434         header.vital_header.freePtr = 0;
1435         memcpy(oldnamehash, header.VolnameHash, sizeof(oldnamehash));
1436         memset(header.VolnameHash, 0, sizeof(header.VolnameHash));
1437
1438         memcpy(oldidhash, header.VolidHash, sizeof(oldidhash));
1439         memset(header.VolidHash, 0, sizeof(header.VolidHash));
1440         quiet_println("Rebuilding %u entries\n", maxentries);
1441     } else {
1442         quiet_println("Scanning %u entries for possible repairs\n", maxentries);
1443     }
1444     for (i = 0; i < maxentries; i++) {
1445         afs_uint32 hash;
1446         if (record[i].type & VL) {
1447             readentry(record[i].addr, &vlentry, &type);
1448             if (!(record[i].type & REFN)) {
1449                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record is not in a name chain (type 0x%0x)\n",
1450                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1451             }
1452             if (vlentry.volumeId[0] && !(record[i].type & REFRW)) {
1453                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a RW chain (type 0x%0x)\n",
1454                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1455             }
1456             if (vlentry.volumeId[1] && !(record[i].type & REFRO)) {
1457                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a RO chain (type 0x%0x)\n",
1458                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1459             }
1460             if (vlentry.volumeId[2] && !(record[i].type & REFBK)) {
1461                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a BK chain (type 0x%0x)\n",
1462                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1463             }
1464             if (fix) {
1465                 afs_uint32 oldhash, newhash;
1466                 char oldNameBuffer[10 + VL_MAXNAMELEN];
1467                 char newNameBuffer[10 + VL_MAXNAMELEN];
1468                 char *oldname, *newname;
1469
1470                 /* Fix broken names and numbers so entries can be inspected and deleted. */
1471                 if (InvalidVolname(vlentry.name)) {
1472                     char bogus[VL_MAXNAMELEN];
1473                     memset(bogus, 0, sizeof(bogus));
1474                     snprintf(bogus, sizeof(bogus)-1, ".bogus.%ld", record[i].addr);
1475                     strcpy(vlentry.name, bogus);
1476                     quiet_println("FIX: Record %ld invalid volume name set to '%s'\n", record[i].addr, bogus);
1477                 }
1478                 if (vlentry.volumeId[0] == 0) {
1479                     afs_uint32 next_volid = header.vital_header.MaxVolumeId++;
1480                     vlentry.volumeId[0] = next_volid;
1481                     quiet_println("FIX: Record %ld invalid volume id set to %ld. New max volid is %ld\n",
1482                         record[i].addr, next_volid, header.vital_header.MaxVolumeId);
1483                 }
1484
1485                 /*
1486                  * Put the current hash table contexts into our 'next'
1487                  * and our address into the hash table.
1488                  */
1489                 hash = NameHash(vlentry.name);
1490
1491                 if (vlentry.nextNameHash != header.VolnameHash[hash]) {
1492                     oldname = nameForAddr(vlentry.nextNameHash, MAXTYPES, &oldhash, oldNameBuffer);
1493                     newname = nameForAddr(header.VolnameHash[hash], MAXTYPES, &newhash, newNameBuffer);
1494                     if (verbose || ((oldhash != newhash) &&
1495                                     (0 != vlentry.nextNameHash) &&
1496                                     (0 != header.VolnameHash[hash]))) {
1497                         /*
1498                          * That is, only report if we are verbose
1499                          * or the hash is changing (and one side wasn't NULL
1500                          */
1501                         quiet_println("FIX: Name hash link for '%s' was %s, is now %s\n",
1502                               vlentry.name, oldname, newname);
1503                     }
1504                 }
1505
1506                 vlentry.nextNameHash = header.VolnameHash[hash];
1507                 header.VolnameHash[hash] = record[i].addr;
1508
1509                 for (j = 0; j < MAXTYPES; j++) {
1510
1511                     if (0 == vlentry.volumeId[j]) {
1512                         /*
1513                          * No volume of that type.  Continue
1514                          */
1515                         continue;
1516                     }
1517                     hash = IdHash(vlentry.volumeId[j]);
1518
1519                     if (vlentry.nextIdHash[j] != header.VolidHash[j][hash]) {
1520                         oldname = nameForAddr(vlentry.nextIdHash[j], j, &oldhash, oldNameBuffer);
1521                         newname = nameForAddr(header.VolidHash[j][hash], j, &newhash, newNameBuffer);
1522                         if (verbose || ((oldhash != newhash) &&
1523                                         (0 != vlentry.nextIdHash[j]) &&
1524                                         (0 != header.VolidHash[j][hash]))) {
1525                             quiet_println("FIX: %s hash link for '%s' was %s, is now %s\n",
1526                                           vtype(j), vlentry.name, oldname, newname);
1527                         }
1528                     }
1529
1530                     /* Consolidate server numbers which point to the same mh entry.
1531                      * The serverref flags are not reset here, since we want to make
1532                      * sure the data is actually written before the server number is
1533                      * considered unreferenced. */
1534                     for (k = 0; k < NMAXNSERVERS; k++) {
1535                         if (vlentry.serverNumber[k] != BADSERVERID
1536                             && serverxref[vlentry.serverNumber[k]] != BADSERVERID) {
1537                             u_char oldsn = vlentry.serverNumber[k];
1538                             u_char newsn = serverxref[oldsn];
1539                             if (newsn == oldsn) {
1540                                 log_error(VLDB_CHECK_ERROR,
1541                                           "INTERNAL VLDB_CHECK_ERROR: serverxref points to self; index %d\n",
1542                                           oldsn);
1543                             } else if (header.IpMappedAddr[oldsn] == 0) {
1544                                 log_error(VLDB_CHECK_ERROR,
1545                                           "INTERNAL VLDB_CHECK_ERROR: serverxref; points to empty address; index %d, value %d\n",
1546                                           oldsn, newsn);
1547                             } else if (header.IpMappedAddr[newsn] != header.IpMappedAddr[oldsn]) {
1548                                 log_error(VLDB_CHECK_ERROR,
1549                                           "INTERNAL VLDB_CHECK_ERROR: invalid serverxref; index %d\n",
1550                                           oldsn);
1551                             } else {
1552                                 quiet_println
1553                                     ("FIX: Volume '%s', index %d, server number was %d, is now %d\n",
1554                                      vlentry.name, k, oldsn, newsn);
1555                                 vlentry.serverNumber[k] = newsn;
1556                             }
1557                         }
1558                     }
1559
1560                     vlentry.nextIdHash[j] = header.VolidHash[j][hash];
1561                     header.VolidHash[j][hash] = record[i].addr;
1562                 }
1563                 writeentry(record[i].addr, &vlentry);
1564             }
1565         }
1566         else if (record[i].type & MH) {
1567             int block, index;
1568             char mhblock[VL_ADDREXTBLK_SIZE];
1569             struct extentaddr *MHblock = (struct extentaddr *)mhblock;
1570
1571             if (fix) {
1572                 for (block = 0; block < VL_MAX_ADDREXTBLKS; block++) {
1573                     if (mhinfo[block].addr == record[i].addr)
1574                         break;
1575                 }
1576                 if (block == VL_MAX_ADDREXTBLKS) {
1577                     continue;  /* skip orphaned extent block */
1578                 }
1579                 readMH(record[i].addr, block, MHblock);
1580                 for (index = 0; index < VL_MHSRV_PERBLK; index++) {
1581                     if (mhinfo[block].orphan[index]) {
1582                         quiet_println("FIX: Removing unreferenced mh entry; block %d, index %d\n",
1583                                 block, index);
1584                         memset(&(MHblock[index]), 0, sizeof(struct extentaddr));
1585                     }
1586                 }
1587                 writeMH(record[i].addr, block, MHblock);
1588             }
1589         } else if (record[i].type & FR) {
1590             if (fix) {
1591                 readentry(record[i].addr, &vlentry, &type);
1592                 vlentry.nextIdHash[0] = header.vital_header.freePtr;
1593                 header.vital_header.freePtr = record[i].addr;
1594                 if ((record[i].type & FRC) == 0) {
1595                     quiet_println
1596                         ("FIX: Putting free entry on the free chain: addr=%lu (offset 0x%0x)\n",
1597                          record[i].addr, OFFSET(record[i].addr));
1598                 }
1599                 writeentry(record[i].addr, &vlentry);
1600             }
1601         }
1602     }
1603     if (fix) {
1604         reportHashChanges(&header, oldnamehash, oldidhash);
1605         removeCrossLinkedAddresses(&header);
1606         writeheader(&header);
1607     }
1608
1609     close(fd);
1610
1611     return error_level;
1612 }
1613
1614 int
1615 main(int argc, char **argv)
1616 {
1617     struct cmd_syndesc *ts;
1618
1619     setlinebuf(stdout);
1620
1621     ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, 0, "vldb check");
1622     cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "vldb_file");
1623     cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
1624                 "Display UBIK header");
1625     cmd_AddParm(ts, "-vheader", CMD_FLAG, CMD_OPTIONAL,
1626                 "Display VLDB header");
1627     cmd_AddParm(ts, "-servers", CMD_FLAG, CMD_OPTIONAL,
1628                 "Display server list");
1629     cmd_AddParm(ts, "-entries", CMD_FLAG, CMD_OPTIONAL, "Display entries");
1630     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
1631     cmd_AddParm(ts, "-quiet", CMD_FLAG, CMD_OPTIONAL, "quiet");
1632     cmd_AddParm(ts, "-fix", CMD_FLAG, CMD_OPTIONAL, "attempt to patch the database (potentially dangerous)");
1633
1634     return cmd_Dispatch(argc, argv);
1635 }