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