Log binding ip address and port during startup
[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     mhblockP->ex_hdrflags = htonl(mhblockP->ex_hdrflags);
483     if (block == 0) {
484         /*
485          * These header fields are only used in the first mh block, so were
486          * converted to host byte order only when the first mh block was read.
487          */
488         mhblockP->ex_count = htonl(mhblockP->ex_count);
489         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
490             mhblockP->ex_contaddrs[i] = htonl(mhblockP->ex_contaddrs[i]);
491         }
492     }
493     for (i = 1; i < VL_MHSRV_PERBLK; i++) {
494         e = &(mhblockP[i]);
495         /* hostuuid was not converted */
496         e->ex_uniquifier = htonl(e->ex_uniquifier);
497         for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
498             e->ex_addrs[j] = htonl(e->ex_addrs[j]);
499         }
500     }
501     vldbwrite(addr, (char *)mhblockP, VL_ADDREXTBLK_SIZE);
502 }
503
504 void
505 writeentry(afs_int32 addr, struct nvlentry *vlentryp)
506 {
507     int i;
508
509     if (verbose) quiet_println("Writing back entry at addr %u\n", addr);
510     for (i = 0; i < MAXTYPES; i++)
511         vlentryp->volumeId[i] = htonl(vlentryp->volumeId[i]);
512     vlentryp->flags = htonl(vlentryp->flags);
513     vlentryp->LockAfsId = htonl(vlentryp->LockAfsId);
514     vlentryp->LockTimestamp = htonl(vlentryp->LockTimestamp);
515     vlentryp->cloneId = htonl(vlentryp->cloneId);
516     for (i = 0; i < MAXTYPES; i++)
517         vlentryp->nextIdHash[i] = htonl(vlentryp->nextIdHash[i]);
518     vlentryp->nextNameHash = htonl(vlentryp->nextNameHash);
519     for (i = 0; i < NMAXNSERVERS; i++) {
520         /* make sure not to htonl these, as they're chars, not ints */
521         vlentryp->serverNumber[i] =  vlentryp->serverNumber[i] ;
522         vlentryp->serverPartition[i] = vlentryp->serverPartition[i] ;
523         vlentryp->serverFlags[i] = vlentryp->serverFlags[i] ;
524     }
525     vldbwrite(addr, (char *)vlentryp, sizeof(*vlentryp));
526 }
527
528 /*
529  * Read each entry in the database:
530  * Record what type of entry it is and its address in the record array.
531  * Remember what the maximum volume id we found is and check against the header.
532  */
533 void
534 ReadAllEntries(struct vlheader *header)
535 {
536     afs_int32 type, rindex, i, j, e;
537     int freecount = 0, mhcount = 0, vlcount = 0;
538     int rwcount = 0, rocount = 0, bkcount = 0;
539     struct nvlentry vlentry;
540     afs_uint32 addr;
541     afs_uint32 entrysize = 0;
542     afs_uint32 maxvolid = 0;
543
544     if (verbose) quiet_println("Read each entry in the database\n");
545     for (addr = header->vital_header.headersize;
546          addr < header->vital_header.eofPtr; addr += entrysize) {
547
548         /* Remember the highest volume id */
549         readentry(addr, &vlentry, &type);
550         if (type == VL) {
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,"address %u (offset 0x%0x): VLDB entry '%s' contains an unknown RW/RO index serverFlag\n",
577                         addr, OFFSET(addr), 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, "address %u (offset 0x%0x): Unknown entry. Aborting\n", addr, OFFSET(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  * Follow each Name hash bucket marking it as read in the record array.
627  * Record we found it in the name hash within the record array.
628  * Check that the name is hashed correctly.
629  */
630 void
631 FollowNameHash(struct vlheader *header)
632 {
633     int count = 0, longest = 0, shortest = -1, chainlength;
634     struct nvlentry vlentry;
635     afs_uint32 addr;
636     afs_int32 i, type, rindex;
637
638     /* Now follow the Name Hash Table */
639     if (verbose) quiet_println("Check Volume Name Hash\n");
640     for (i = 0; i < HASHSIZE; i++) {
641         chainlength = 0;
642
643         if (!validVolumeAddr(header->VolnameHash[i])) {
644             log_error(VLDB_CHECK_ERROR,"Name Hash index %d is out of range: %u\n",
645                       i, header->VolnameHash[i]);
646             continue;
647         }
648
649         for (addr = header->VolnameHash[i]; addr; addr = vlentry.nextNameHash) {
650             readentry(addr, &vlentry, &type);
651             if (type != VL) {
652                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: Not a vlentry\n",
653                        addr, OFFSET(addr), i);
654                 continue;
655             }
656
657             rindex = ADDR(addr);
658
659             /*
660              * we know that the address is valid because we
661              * checked it either above or below
662              */
663             if (record[rindex].addr != addr && record[rindex].addr) {
664                 log_error
665                     (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %ld and %u use same record slot %d\n",
666                      record[rindex].addr, addr, rindex);
667             }
668             if (record[rindex].type & NH) {
669                 log_error
670                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: volume name '%s' is already in the name hash\n",
671                      addr, OFFSET(addr), i, vlentry.name);
672                 record[rindex].type |= MULTN;
673                 break;
674             }
675
676             if (!validVolumeAddr(vlentry.nextNameHash)) {
677                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash forward link of '%s' is out of range\n",
678                           addr, OFFSET(addr), vlentry.name);
679                 record[rindex].type |= MULTN;
680                 break;
681             }
682
683             record[rindex].type |= NH;
684             record[rindex].type |= REFN;
685
686             chainlength++;
687             count++;
688
689             /* Hash the name and check if in correct hash table */
690             if (NameHash(vlentry.name) != i) {
691                 log_error
692                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: volume name '%s': Incorrect name hash chain (should be in %d)\n",
693                      addr, OFFSET(addr), i, vlentry.name, NameHash(vlentry.name));
694                 record[rindex].type |= MULTN;
695             }
696         }
697         if (chainlength > longest)
698             longest = chainlength;
699         if ((shortest == -1) || (chainlength < shortest))
700             shortest = chainlength;
701     }
702     if (verbose) {
703         quiet_println
704             ("%d entries in name hash, longest is %d, shortest is %d, average length is %f\n",
705              count, longest, shortest, ((float)count / (float)HASHSIZE));
706     }
707     return;
708 }
709
710 /*
711  * Follow the ID hash chains for the RW, RO, and BK hash tables.
712  * Record we found it in the id hash within the record array.
713  * Check that the ID is hashed correctly.
714  */
715 void
716 FollowIdHash(struct vlheader *header)
717 {
718     int count = 0, longest = 0, shortest = -1, chainlength;
719     struct nvlentry vlentry;
720     afs_uint32 addr;
721     afs_int32 i, j, hash, type, rindex, ref, badref, badhash;
722
723     /* Now follow the RW, RO, and BK Hash Tables */
724     if (verbose) quiet_println("Check RW, RO, and BK id Hashes\n");
725     for (i = 0; i < MAXTYPES; i++) {
726         hash = ((i == 0) ? RWH : ((i == 1) ? ROH : BKH));
727         ref = ((i == 0) ? REFRW : ((i == 1) ? REFRO : REFBK));
728         badref = ((i == 0) ? MULTRW : ((i == 1) ? MULTRO : MULTBK));
729         badhash = ((i == 0) ? MULTRW : ((i == 1) ? MULTRO : MULTBK));
730         count = longest = 0;
731         shortest = -1;
732
733         for (j = 0; j < HASHSIZE; j++) {
734             chainlength = 0;
735             if (!validVolumeAddr(header->VolidHash[i][j])) {
736                 log_error(VLDB_CHECK_ERROR,"%s Hash index %d is out of range: %u\n",
737                           vtype(i), j, header->VolidHash[i][j]);
738                 continue;
739             }
740
741             for (addr = header->VolidHash[i][j]; addr;
742                  addr = vlentry.nextIdHash[i]) {
743                 readentry(addr, &vlentry, &type);
744                 if (type != VL) {
745                     log_error
746                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: Not a vlentry\n",
747                          addr, OFFSET(addr), vtype(i), j);
748                     continue;
749                 }
750
751                 rindex = ADDR(addr);
752                 if (record[rindex].addr != addr && record[rindex].addr) {
753                     log_error
754                         (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %ld and %u use same record slot %d\n",
755                          record[rindex].addr, addr, rindex);
756                 }
757                 if (record[rindex].type & hash) {
758                     log_error
759                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: volume name '%s': Already in the hash table\n",
760                          addr, OFFSET(addr), vtype(i), j, vlentry.name);
761                     record[rindex].type |= badref;
762                     break;
763                 }
764
765                 if (!validVolumeAddr(vlentry.nextIdHash[i])) {
766                     log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash forward link of '%s' is out of range\n",
767                               addr, OFFSET(addr), vtype(i), vlentry.name);
768                     record[rindex].type |= badref;
769                     break;
770                 }
771
772                 record[rindex].type |= hash;
773                 record[rindex].type |= ref;
774
775                 chainlength++;
776                 count++;
777
778                 /* Hash the id and check if in correct hash table */
779                 if (IdHash(vlentry.volumeId[i]) != j) {
780                    log_error
781                         (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: volume name '%s': Incorrect Id hash chain (should be in %d)\n",
782                          addr, OFFSET(addr), vtype(i), j, vlentry.name,
783                          IdHash(vlentry.volumeId[i]));
784                     record[rindex].type |= badhash;
785                 }
786             }
787
788             if (chainlength > longest)
789                 longest = chainlength;
790             if ((shortest == -1) || (chainlength < shortest))
791                 shortest = chainlength;
792         }
793         if (verbose) {
794             quiet_println
795                 ("%d entries in %s hash, longest is %d, shortest is %d, average length is %f\n",
796                  count, vtype(i), longest, shortest,((float)count / (float)HASHSIZE));
797         }
798     }
799     return;
800 }
801
802 /*
803  * Follow the free chain.
804  * Record we found it in the free chain within the record array.
805  */
806 void
807 FollowFreeChain(struct vlheader *header)
808 {
809     afs_int32 count = 0;
810     struct nvlentry vlentry;
811     afs_uint32 addr;
812     afs_int32 type, rindex;
813
814     /* Now follow the Free Chain */
815     if (verbose) quiet_println("Check Volume Free Chain\n");
816     for (addr = header->vital_header.freePtr; addr;
817          addr = vlentry.nextIdHash[0]) {
818         readentry(addr, &vlentry, &type);
819         if (type != FR) {
820            log_error
821                 (VLDB_CHECK_ERROR,"address %u (offset 0%0x): Free Chain %d: Not a free vlentry (0x%x)\n",
822                  addr, OFFSET(addr), count, type);
823             continue;
824         }
825
826         rindex = addr / sizeof(vlentry);
827         if (record[rindex].addr != addr && record[rindex].addr) {
828            log_error
829                 (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u (0x%0x) and %ld (0x%0x) use same record slot %d\n",
830                  record[rindex].addr, OFFSET(record[rindex].addr), addr, OFFSET(addr), rindex);
831         }
832         if (record[rindex].type & FRC) {
833             log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free Chain: Already in the free chain\n",
834                    addr, OFFSET(addr));
835             break;
836         }
837         record[rindex].type |= FRC;
838
839         count++;
840     }
841     if (verbose)
842      quiet_println("%d entries on free chain\n", count);
843     return;
844 }
845
846 /*
847  * Read each multihomed block and mark it as found in the record.
848  * Read each entry in each multihomed block and mark the serveraddrs
849  * array with the number of ip addresses found for this entry.
850  *
851  * Then read the IpMappedAddr array in the header.
852  * Verify that multihomed entries base and index are valid and points to
853  * a good multhomed entry.
854  * Mark the serveraddrs array with 1 ip address for regular entries.
855  *
856  * By the end, the severaddrs array will have a 0 if the entry has no
857  * IP addresses in it or the count of the number of IP addresses.
858  *
859  * The code does not verify if there are duplicate IP addresses in the
860  * list. The vlserver does this when a fileserver registeres itself.
861  */
862 void
863 CheckIpAddrs(struct vlheader *header)
864 {
865     int mhblocks = 0;
866     afs_int32 i, j, m, rindex;
867     afs_int32 mhentries, regentries;
868     char mhblock[VL_ADDREXTBLK_SIZE];
869     struct extentaddr *MHblock = (struct extentaddr *)mhblock;
870     struct extentaddr *e;
871     int ipindex, ipaddrs;
872     afsUUID nulluuid;
873
874     memset(&nulluuid, 0, sizeof(nulluuid));
875
876     if (verbose)
877         quiet_println("Check Multihomed blocks\n");
878
879     if (header->SIT) {
880         /* Read the first MH block and from it, gather the
881          * addresses of all the mh blocks.
882          */
883         readMH(header->SIT, 0, MHblock);
884         if (MHblock->ex_hdrflags != VLCONTBLOCK) {
885            log_error
886                 (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed Block 0: Not a multihomed block\n",
887                  header->SIT, OFFSET(header->SIT));
888         }
889
890         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
891             mhinfo[i].addr = MHblock->ex_contaddrs[i];
892         }
893
894         if (header->SIT != mhinfo[0].addr) {
895            log_error
896                 (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): MH block does not point to self in header, %u in block\n",
897                  header->SIT, OFFSET(header->SIT), mhinfo[0].addr);
898         }
899
900         /* Now read each MH block and record it in the record array */
901         for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
902             if (!mhinfo[i].addr)
903                 continue;
904
905             readMH(mhinfo[i].addr, i, MHblock);
906             if (MHblock->ex_hdrflags != VLCONTBLOCK) {
907                 log_error
908                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed Block %d: Not a multihomed block\n",
909                      mhinfo[i].addr, OFFSET(mhinfo[i].addr), i);
910             }
911
912             rindex = mhinfo[i].addr / sizeof(vlentry);
913             if (record[rindex].addr != mhinfo[i].addr && record[rindex].addr) {
914                 log_error
915                     (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u (0x%0x) and %u (0x%0x) use same record slot %d\n",
916                      record[rindex].addr, OFFSET(record[rindex].addr), mhinfo[i].addr, OFFSET(mhinfo[i].addr), rindex);
917             }
918             if (record[rindex].type & FRC) {
919                 log_error
920                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): MH Blocks Chain %d: Already a MH block\n",
921                      record[rindex].addr, OFFSET(record[rindex].addr), i);
922                 break;
923             }
924             record[rindex].type |= MHC;
925
926             mhblocks++;
927
928             /* Read each entry in a multihomed block.
929              * Find the pointer to the entry in the IpMappedAddr array and
930              * verify that the entry is good (has IP addresses in it).
931              */
932             mhentries = 0;
933             for (j = 1; j < VL_MHSRV_PERBLK; j++) {
934                 int first_ipindex = -1;
935                 e = (struct extentaddr *)&(MHblock[j]);
936
937                 /* Search the IpMappedAddr array for all the references to this entry. */
938                 /* Use the first reference for checking the ip addresses of this entry. */
939                 for (ipindex = 0; ipindex <= MAXSERVERID; ipindex++) {
940                     if (((header->IpMappedAddr[ipindex] & 0xff000000) == 0xff000000)
941                         && (((header-> IpMappedAddr[ipindex] & 0x00ff0000) >> 16) == i)
942                         && ((header->IpMappedAddr[ipindex] & 0x0000ffff) == j)) {
943                         if (first_ipindex == -1) {
944                             first_ipindex = ipindex;
945                         } else {
946                             serverxref[ipindex] = first_ipindex;
947                         }
948                     }
949                 }
950                 ipindex = first_ipindex;
951                 if (ipindex != -1)
952                     serveraddrs[ipindex] = -1;
953
954                 if (memcmp(&e->ex_hostuuid, &nulluuid, sizeof(afsUUID)) == 0) {
955                     if (ipindex != -1) {
956                         log_error
957                             (VLDB_CHECK_ERROR,"Server Addrs index %d references null MH block %d, index %d\n",
958                              ipindex, i, j);
959                         serveraddrs[ipindex] = 0;       /* avoids printing 2nd error below */
960                     }
961                     continue;
962                 }
963
964                 /* Step through each ip address and count the good addresses */
965                 ipaddrs = 0;
966                 for (m = 0; m < VL_MAXIPADDRS_PERMH; m++) {
967                     if (e->ex_addrs[m])
968                         ipaddrs++;
969                 }
970
971                 /* If we found any good ip addresses, mark it in the serveraddrs record */
972                 if (ipaddrs) {
973                     mhentries++;
974                     if (ipindex == -1) {
975                         mhinfo[i].orphan[j] = 1;
976                         log_error
977                             (VLDB_CHECK_ERROR,"MH block %d, index %d: Not referenced by server addrs\n",
978                              i, j);
979                     } else {
980                         serveraddrs[ipindex] = ipaddrs; /* It is good */
981                     }
982                 }
983
984                 if (listservers && ipaddrs) {
985                     quiet_println("MH block %d, index %d:", i, j);
986                     for (m = 0; m < VL_MAXIPADDRS_PERMH; m++) {
987                         if (!e->ex_addrs[m])
988                             continue;
989                         quiet_println(" %d.%d.%d.%d",
990                                (e->ex_addrs[m] & 0xff000000) >> 24,
991                                (e->ex_addrs[m] & 0x00ff0000) >> 16,
992                                (e->ex_addrs[m] & 0x0000ff00) >> 8,
993                                (e->ex_addrs[m] & 0x000000ff));
994                     }
995                     quiet_println("\n");
996                 }
997             }
998 /*
999  *      if (mhentries != MHblock->ex_count) {
1000  *         quiet_println("MH blocks says it has %d entries (found %d)\n",
1001  *                MHblock->ex_count, mhentries);
1002  *      }
1003  */
1004         }
1005     }
1006     if (verbose)
1007         quiet_println("%d multihomed blocks\n", mhblocks);
1008
1009     /* Check the server addresses */
1010     if (verbose)
1011         quiet_println("Check server addresses\n");
1012     mhentries = regentries = 0;
1013     for (i = 0; i <= MAXSERVERID; i++) {
1014         if (header->IpMappedAddr[i]) {
1015             if ((header->IpMappedAddr[i] & 0xff000000) == 0xff000000) {
1016                 mhentries++;
1017                 if (((header->IpMappedAddr[i] & 0x00ff0000) >> 16) >
1018                     VL_MAX_ADDREXTBLKS)
1019                    log_error
1020                         (VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome block is bad (%d)\n",
1021                          i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
1022                 if (mhinfo[(header->IpMappedAddr[i] & 0x00ff0000) >> 16].addr == 0)
1023                     log_error(VLDB_CHECK_ERROR,"IP Addr for entry %d: No such multihome block (%d)\n",
1024                          i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
1025                 if (((header->IpMappedAddr[i] & 0x0000ffff) > VL_MHSRV_PERBLK)
1026                     || ((header->IpMappedAddr[i] & 0x0000ffff) < 1))
1027                     log_error
1028                         (VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome index is bad (%d)\n",
1029                          i, (header->IpMappedAddr[i] & 0x0000ffff));
1030                 if (serveraddrs[i] == -1) {
1031                     log_error
1032                         (VLDB_CHECK_WARNING,"warning: IP Addr for entry %d: Multihome entry has no ip addresses\n",
1033                          i);
1034                     serveraddrs[i] = 0;
1035                 }
1036                 if (serverxref[i] != BADSERVERID) {
1037                     log_error
1038                         (VLDB_CHECK_WARNING,
1039                         "warning: MH block %d, index %d is cross-linked by server numbers %d and %d.\n",
1040                         (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1041                         (header->IpMappedAddr[i] & 0x0000ffff),
1042                         i, serverxref[i]);
1043                     /* set addresses found/not found for this server number,
1044                      * using the first index to the mh we found above. */
1045                     serveraddrs[i] = serveraddrs[serverxref[i]];
1046                 }
1047                 if (listservers) {
1048                     quiet_println("   Server ip addr %d = MH block %d, index %d\n",
1049                            i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1050                            (header->IpMappedAddr[i] & 0x0000ffff));
1051                 }
1052             } else {
1053                 regentries++;
1054                 serveraddrs[i] = 1;     /* It is good */
1055                 if (listservers) {
1056                     quiet_println("   Server ip addr %d = %d.%d.%d.%d\n", i,
1057                            (header->IpMappedAddr[i] & 0xff000000) >> 24,
1058                            (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1059                            (header->IpMappedAddr[i] & 0x0000ff00) >> 8,
1060                            (header->IpMappedAddr[i] & 0x000000ff));
1061                 }
1062             }
1063         }
1064     }
1065     if (verbose) {
1066         quiet_println("%d simple entries, %d multihomed entries, Total = %d\n",
1067                regentries, mhentries, mhentries + regentries);
1068     }
1069     return;
1070 }
1071
1072 char *
1073 nameForAddr(afs_uint32 addr, int hashtype, afs_uint32 *hash, char *buffer)
1074 {
1075     /*
1076      * We need to simplify the reporting, while retaining
1077      * legible messages.  This is a helper function.  The return address
1078      * is either a fixed char or the provided buffer - so don't use the
1079      * name after the valid lifetime of the buffer.
1080      */
1081     afs_int32 type;
1082     struct nvlentry entry;
1083     if (!addr) {
1084         /* Distinguished, invalid, hash */
1085         *hash = 0xFFFFFFFF;
1086         return "empty";
1087     } else if (!validVolumeAddr(addr)) {
1088         /* Different, invalid, hash */
1089         *hash = 0XFFFFFFFE;
1090         return "invalid";
1091     }
1092     readentry(addr, &entry, &type);
1093     if (VL != type) {
1094         *hash = 0XFFFFFFFE;
1095         return "invalid";
1096     }
1097     if (hashtype >= MAXTYPES) {
1098         *hash = NameHash(entry.name);
1099     } else {
1100         *hash = IdHash(entry.volumeId[hashtype]);
1101     }
1102     sprintf(buffer, "for '%s'", entry.name);
1103     return buffer;
1104 }
1105
1106 void
1107 reportHashChanges(struct vlheader *header, afs_uint32 oldnamehash[HASHSIZE], afs_uint32 oldidhash[MAXTYPES][HASHSIZE])
1108 {
1109     int i, j;
1110     afs_uint32 oldhash, newhash;
1111     char oldNameBuffer[10 + VL_MAXNAMELEN];
1112     char newNameBuffer[10 + VL_MAXNAMELEN];
1113     char *oldname, *newname;
1114     /*
1115      * report hash changes
1116      */
1117
1118     for (i = 0; i < HASHSIZE; i++) {
1119         if (oldnamehash[i] != header->VolnameHash[i]) {
1120
1121             oldname = nameForAddr(oldnamehash[i], MAXTYPES, &oldhash, oldNameBuffer);
1122             newname = nameForAddr(header->VolnameHash[i], MAXTYPES, &newhash, newNameBuffer);
1123             if (verbose || (oldhash != newhash)) {
1124                 quiet_println("FIX: Name hash header at %d was %s, is now %s\n", i, oldname, newname);
1125             }
1126         }
1127         for (j = 0; j < MAXTYPES; j++) {
1128             if (oldidhash[j][i] != header->VolidHash[j][i]) {
1129
1130                 oldname = nameForAddr(oldidhash[j][i], j, &oldhash, oldNameBuffer);
1131                 newname = nameForAddr(header->VolidHash[j][i], j, &newhash, newNameBuffer);
1132                 if (verbose || (oldhash != newhash)) {
1133                     quiet_println("FIX: %s hash header at %d was %s, is now %s\n", vtype(j), i, oldname, newname);
1134                 }
1135             }
1136         }
1137     }
1138 }
1139
1140 /**
1141  * Remove unreferenced, duplicate multi-home address indices.
1142  *
1143  * Removes entries from IpMappedAddr which where found to be
1144  * duplicates. Only entries which are not referenced by vl entries
1145  * are removed on this pass.
1146  *
1147  * @param[inout] header the vldb header to be updated.
1148  */
1149 void
1150 removeCrossLinkedAddresses(struct vlheader *header)
1151 {
1152     int i;
1153
1154     for (i = 0; i <= MAXSERVERID; i++) {
1155         if (serverref[i] == 0
1156             && (header->IpMappedAddr[i] & 0xff000000) == 0xff000000
1157             && serverxref[i] != BADSERVERID) {
1158             if (serverxref[i] == i) {
1159                 log_error(VLDB_CHECK_ERROR,
1160                           "INTERNAL VLDB_CHECK_ERROR: serverxref points to self; index %d\n",
1161                           i);
1162             } else if (header->IpMappedAddr[serverxref[i]] == 0) {
1163                 log_error(VLDB_CHECK_ERROR,
1164                           "INTERNAL VLDB_CHECK_ERROR: serverxref points to empty addr; index %d, value %d\n",
1165                           i, serverxref[i]);
1166             } else if (header->IpMappedAddr[serverxref[i]] != header->IpMappedAddr[i]) {
1167                 log_error(VLDB_CHECK_ERROR,
1168                           "INTERNAL VLDB_CHECK_ERROR: invalid serverxref; index %d, value %d\n",
1169                           i, serverxref[i]);
1170             } else {
1171                 quiet_println
1172                     ("FIX: Removing unreferenced address index %d, which cross-links MH block %d, index %d\n",
1173                      i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
1174                      (header->IpMappedAddr[i] & 0x0000ffff));
1175                 header->IpMappedAddr[i] = 0;
1176             }
1177         }
1178     }
1179 }
1180
1181 int
1182 WorkerBee(struct cmd_syndesc *as, void *arock)
1183 {
1184     char *dbfile;
1185     afs_int32 type;
1186     struct vlheader header;
1187     struct nvlentry vlentry, vlentry2;
1188     int i, j, k;
1189     afs_uint32 oldnamehash[HASHSIZE];
1190     afs_uint32 oldidhash[MAXTYPES][HASHSIZE];
1191
1192     error_level = 0;  /*  start clean with no error status */
1193     dbfile = as->parms[0].items->data;  /* -database */
1194     listuheader = (as->parms[1].items ? 1 : 0); /* -uheader  */
1195     listheader = (as->parms[2].items ? 1 : 0);  /* -vheader  */
1196     listservers = (as->parms[3].items ? 1 : 0); /* -servers  */
1197     listentries = (as->parms[4].items ? 1 : 0); /* -entries  */
1198     verbose = (as->parms[5].items ? 1 : 0);     /* -verbose  */
1199     quiet = (as->parms[6].items ? 1 : 0);  /* -quiet */
1200     fix = (as->parms[7].items ? 1 : 0);    /* -fix  */
1201
1202     /* sanity check */
1203     if (quiet && (verbose || listuheader || listheader ||listservers \
1204                 || listentries)) {
1205         log_error(VLDB_CHECK_FATAL," -quiet cannot be used other display flags\n");
1206         return VLDB_CHECK_FATAL;
1207     }
1208
1209
1210     /* open the vldb database file */
1211     fd = open(dbfile, (fix > 0)?O_RDWR:O_RDONLY, 0);
1212     if (fd < 0) {
1213         log_error(VLDB_CHECK_FATAL,"can't open file '%s'. error = %d\n", dbfile, errno);
1214         return 0;
1215     }
1216
1217     /* read the ubik header and the vldb database header */
1218     readUbikHeader();
1219     readheader(&header);
1220     if (header.vital_header.vldbversion < 3) {
1221         log_error(VLDB_CHECK_FATAL,"does not support vldb with version less than 3\n");
1222         return VLDB_CHECK_FATAL;
1223     }
1224
1225     maxentries = (header.vital_header.eofPtr / sizeof(vlentry)) + 1;
1226     record = calloc(maxentries, sizeof(struct er));
1227     memset(serveraddrs, 0, sizeof(serveraddrs));
1228     memset(mhinfo, 0, sizeof(mhinfo));
1229     memset(serverref, 0, sizeof(serverref));
1230     for (i = 0; i <= MAXSERVERID; i++) {
1231         serverxref[i] = BADSERVERID;
1232     }
1233
1234     /* Will fill in the record array of entries it found */
1235     ReadAllEntries(&header);
1236     listentries = 0;            /* Listed all the entries */
1237
1238     /* Check the multihomed blocks for valid entries as well as
1239      * the IpMappedAddrs array in the header for valid entries.
1240      */
1241     CheckIpAddrs(&header);
1242
1243     /* Follow the hash tables */
1244     FollowNameHash(&header);
1245     FollowIdHash(&header);
1246
1247     /* Follow the chain of free entries */
1248     FollowFreeChain(&header);
1249
1250     /* Now check the record we have been keeping for inconsistencies
1251      * For valid vlentries, also check that the server we point to is
1252      * valid (the serveraddrs array).
1253      */
1254     if (verbose)
1255         quiet_println("Verify each volume entry\n");
1256     for (i = 0; i < maxentries; i++) {
1257         int hash = 0;
1258         int nexthash = 0;
1259         char *which = NULL;
1260
1261         if (record[i].type == 0)
1262             continue;
1263
1264         /* If a vlentry, verify that its name is valid, its name and ids are
1265          * on the hash chains, and its server numbers are good.
1266          */
1267         if (record[i].type & VL) {
1268             int foundbad = 0;
1269             int foundbroken = 0;
1270             char volidbuf[256];
1271
1272             readentry(record[i].addr, &vlentry, &type);
1273
1274             if (!(vlentry.flags & VLF_RWEXISTS))
1275                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has no RW volume\n",
1276                        record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
1277
1278             if (InvalidVolname(vlentry.name))
1279                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has an invalid name\n",
1280                        record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
1281
1282             if (vlentry.volumeId[0] == 0)
1283                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has an invalid volume id\n",
1284                        record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
1285
1286             if (!(record[i].type & NH)) {
1287                 hash = NameHash(vlentry.name);
1288                 which = "name";
1289                 volidbuf[0]='\0';
1290                 foundbad = 1;
1291             }
1292
1293             if (vlentry.volumeId[0] && !(record[i].type & RWH)) {
1294                 hash = IdHash(vlentry.volumeId[0]);
1295                 which = "RW";
1296                 sprintf(volidbuf, "id %u ", vlentry.volumeId[0]);
1297                 foundbad = 1;
1298             }
1299
1300             if (vlentry.volumeId[1] && !(record[i].type & ROH)) {
1301                 hash = IdHash(vlentry.volumeId[1]);
1302                 which = "RO";
1303                 sprintf(volidbuf, "id %u ", vlentry.volumeId[1]);
1304                 foundbad = 1;
1305             }
1306
1307             if (vlentry.volumeId[2] && !(record[i].type & BKH)) {
1308                 hash = IdHash(vlentry.volumeId[2]);
1309                 which = "BK";
1310                 sprintf(volidbuf, "id %u ", vlentry.volumeId[2]);
1311                 foundbad = 1;
1312             }
1313
1314             if (!validVolumeAddr(vlentry.nextNameHash) ||
1315                 record[ADDR(vlentry.nextNameHash)].type & MULTN) {
1316                 hash = NameHash(vlentry.name);
1317                 which = "name";
1318                 volidbuf[0]='\0';
1319                 if (validVolumeAddr(vlentry.nextNameHash)) {
1320                     readentry(vlentry.nextNameHash, &vlentry2, &type);
1321                     nexthash = NameHash(vlentry2.name);
1322                 } else {
1323                     nexthash = 0xFFFFFFFF;
1324                 }
1325                 if (hash != nexthash)
1326                     foundbroken = 1;
1327             }
1328
1329             if (!validVolumeAddr(vlentry.nextIdHash[0]) ||
1330                 record[ADDR(vlentry.nextIdHash[0])].type & MULTRW) {
1331                 hash = IdHash(vlentry.volumeId[0]);
1332                 which = "RW";
1333                 sprintf(volidbuf, "id %u ", vlentry.volumeId[0]);
1334                 if (validVolumeAddr(vlentry.nextIdHash[0])) {
1335                     readentry(vlentry.nextIdHash[0], &vlentry2, &type);
1336                     nexthash = IdHash(vlentry2.volumeId[0]);
1337                 } else {
1338                     nexthash = 0xFFFFFFFF;
1339                 }
1340                 if (hash != nexthash)
1341                     foundbroken = 1;
1342             }
1343
1344             if (!validVolumeAddr(vlentry.nextIdHash[1]) ||
1345                 record[ADDR(vlentry.nextIdHash[1])].type & MULTRO) {
1346                 hash = IdHash(vlentry.volumeId[1]);
1347                 which = "RO";
1348                 sprintf(volidbuf, "id %u ", vlentry.volumeId[1]);
1349                 if (validVolumeAddr(vlentry.nextIdHash[1])) {
1350                     readentry(vlentry.nextIdHash[1], &vlentry2, &type);
1351                     nexthash = IdHash(vlentry2.volumeId[1]);
1352                 } else {
1353                     nexthash = 0xFFFFFFFF;
1354                 }
1355                 if (hash != nexthash)
1356                     foundbroken = 1;
1357             }
1358
1359             if (!validVolumeAddr(vlentry.nextIdHash[2]) ||
1360                 record[ADDR(vlentry.nextIdHash[2])].type & MULTBK) {
1361                 hash = IdHash(vlentry.volumeId[2]);
1362                 which = "BK";
1363                 sprintf(volidbuf, "id %u ", vlentry.volumeId[2]);
1364                 if (validVolumeAddr(vlentry.nextIdHash[2])) {
1365                     readentry(vlentry.nextIdHash[2], &vlentry2, &type);
1366                     nexthash = IdHash(vlentry2.volumeId[2]);
1367                 } else {
1368                     nexthash = 0xFFFFFFFF;
1369                 }
1370                 if (hash != nexthash)
1371                     foundbroken = 1;
1372             }
1373
1374             if (foundbroken) {
1375                 log_error(VLDB_CHECK_ERROR,
1376                         "address %u (offset 0x%0x): Volume '%s' %s forward link in %s hash chain is broken (hash %d != %d)\n",
1377                         record[i].addr, OFFSET(record[i].addr),
1378                         vlentry.name, volidbuf, which, hash, nexthash);
1379             } else if (foundbad) {
1380                 log_error(VLDB_CHECK_ERROR,
1381                         "address %u (offset 0x%0x): Volume '%s' %snot found in %s hash %d\n",
1382                         record[i].addr, OFFSET(record[i].addr),
1383                         vlentry.name, volidbuf, which, hash);
1384             }
1385
1386             for (j = 0; j < NMAXNSERVERS; j++) {
1387                 if (vlentry.serverNumber[j] != BADSERVERID) {
1388                     serverref[vlentry.serverNumber[j]] = 1;
1389                     if (serveraddrs[vlentry.serverNumber[j]] == 0) {
1390                         log_error
1391                             (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s', index %d points to empty server entry %d\n",
1392                              record[i].addr, OFFSET(record[i].addr), vlentry.name, j, vlentry.serverNumber[j]);
1393                     } else if (serverxref[vlentry.serverNumber[j]] != BADSERVERID) {
1394                             log_error
1395                             (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s', index %d points to server entry %d, which is cross-linked by %d\n",
1396                              record[i].addr, OFFSET(record[i].addr), vlentry.name, j, vlentry.serverNumber[j], serverxref[vlentry.serverNumber[j]]);
1397                     }
1398                 }
1399             }
1400
1401             if (record[i].type & 0xffff0f00)
1402                 log_error
1403                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' id %u also found on other chains (0x%x)\n",
1404                      record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0], record[i].type);
1405
1406             /* A free entry */
1407         } else if (record[i].type & FR) {
1408             if (!(record[i].type & FRC))
1409                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free vlentry not on free chain\n",
1410                        record[i].addr, OFFSET(record[i].addr));
1411
1412             if (record[i].type & 0xfffffdf0)
1413                 log_error
1414                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free vlentry also found on other chains (0x%x)\n",
1415                      record[i].addr, OFFSET(record[i].addr), record[i].type);
1416
1417             /* A multihomed entry */
1418         } else if (record[i].type & MH) {
1419             if (!(record[i].type & MHC))
1420                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed block is orphaned\n",
1421                        record[i].addr, OFFSET(record[i].addr));
1422
1423             if (record[i].type & 0xfffffef0)
1424                 log_error
1425                     (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed block also found on other chains (0x%x)\n",
1426                      record[i].addr, OFFSET(record[i].addr), record[i].type);
1427
1428         } else {
1429             log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Unknown entry type 0x%x\n",
1430                    record[i].addr, OFFSET(record[i].addr), record[i].type);
1431         }
1432     }
1433
1434     if (fix) {
1435         /*
1436          * If we are fixing we will rebuild the free and hash lists from the ground up.
1437          */
1438         header.vital_header.freePtr = 0;
1439         memcpy(oldnamehash, header.VolnameHash, sizeof(oldnamehash));
1440         memset(header.VolnameHash, 0, sizeof(header.VolnameHash));
1441
1442         memcpy(oldidhash, header.VolidHash, sizeof(oldidhash));
1443         memset(header.VolidHash, 0, sizeof(header.VolidHash));
1444         quiet_println("Rebuilding %u entries\n", maxentries);
1445     } else {
1446         quiet_println("Scanning %u entries for possible repairs\n", maxentries);
1447     }
1448     for (i = 0; i < maxentries; i++) {
1449         afs_uint32 hash;
1450         if (record[i].type & VL) {
1451             readentry(record[i].addr, &vlentry, &type);
1452             if (!(record[i].type & REFN)) {
1453                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record is not in a name chain (type 0x%0x)\n",
1454                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1455             }
1456             if (vlentry.volumeId[0] && !(record[i].type & REFRW)) {
1457                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a RW chain (type 0x%0x)\n",
1458                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1459             }
1460             if (vlentry.volumeId[1] && !(record[i].type & REFRO)) {
1461                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a RO chain (type 0x%0x)\n",
1462                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1463             }
1464             if (vlentry.volumeId[2] && !(record[i].type & REFBK)) {
1465                 log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a BK chain (type 0x%0x)\n",
1466                        record[i].addr, OFFSET(record[i].addr), record[i].type);
1467             }
1468             if (fix) {
1469                 afs_uint32 oldhash, newhash;
1470                 char oldNameBuffer[10 + VL_MAXNAMELEN];
1471                 char newNameBuffer[10 + VL_MAXNAMELEN];
1472                 char *oldname, *newname;
1473
1474                 /* Fix broken names and numbers so entries can be inspected and deleted. */
1475                 if (InvalidVolname(vlentry.name)) {
1476                     char bogus[VL_MAXNAMELEN];
1477                     memset(bogus, 0, sizeof(bogus));
1478                     snprintf(bogus, sizeof(bogus)-1, ".bogus.%ld", record[i].addr);
1479                     strcpy(vlentry.name, bogus);
1480                     quiet_println("FIX: Record %ld invalid volume name set to '%s'\n", record[i].addr, bogus);
1481                 }
1482                 if (vlentry.volumeId[0] == 0) {
1483                     afs_uint32 next_volid = header.vital_header.MaxVolumeId++;
1484                     vlentry.volumeId[0] = next_volid;
1485                     quiet_println("FIX: Record %ld invalid volume id set to %ld. New max volid is %ld\n",
1486                         record[i].addr, next_volid, header.vital_header.MaxVolumeId);
1487                 }
1488
1489                 /*
1490                  * Put the current hash table contexts into our 'next'
1491                  * and our address into the hash table.
1492                  */
1493                 hash = NameHash(vlentry.name);
1494
1495                 if (vlentry.nextNameHash != header.VolnameHash[hash]) {
1496                     oldname = nameForAddr(vlentry.nextNameHash, MAXTYPES, &oldhash, oldNameBuffer);
1497                     newname = nameForAddr(header.VolnameHash[hash], MAXTYPES, &newhash, newNameBuffer);
1498                     if (verbose || ((oldhash != newhash) &&
1499                                     (0 != vlentry.nextNameHash) &&
1500                                     (0 != header.VolnameHash[hash]))) {
1501                         /*
1502                          * That is, only report if we are verbose
1503                          * or the hash is changing (and one side wasn't NULL
1504                          */
1505                         quiet_println("FIX: Name hash link for '%s' was %s, is now %s\n",
1506                               vlentry.name, oldname, newname);
1507                     }
1508                 }
1509
1510                 vlentry.nextNameHash = header.VolnameHash[hash];
1511                 header.VolnameHash[hash] = record[i].addr;
1512
1513                 for (j = 0; j < MAXTYPES; j++) {
1514
1515                     if (0 == vlentry.volumeId[j]) {
1516                         /*
1517                          * No volume of that type.  Continue
1518                          */
1519                         continue;
1520                     }
1521                     hash = IdHash(vlentry.volumeId[j]);
1522
1523                     if (vlentry.nextIdHash[j] != header.VolidHash[j][hash]) {
1524                         oldname = nameForAddr(vlentry.nextIdHash[j], j, &oldhash, oldNameBuffer);
1525                         newname = nameForAddr(header.VolidHash[j][hash], j, &newhash, newNameBuffer);
1526                         if (verbose || ((oldhash != newhash) &&
1527                                         (0 != vlentry.nextIdHash[j]) &&
1528                                         (0 != header.VolidHash[j][hash]))) {
1529                             quiet_println("FIX: %s hash link for '%s' was %s, is now %s\n",
1530                                           vtype(j), vlentry.name, oldname, newname);
1531                         }
1532                     }
1533
1534                     /* Consolidate server numbers which point to the same mh entry.
1535                      * The serverref flags are not reset here, since we want to make
1536                      * sure the data is actually written before the server number is
1537                      * considered unreferenced. */
1538                     for (k = 0; k < NMAXNSERVERS; k++) {
1539                         if (vlentry.serverNumber[k] != BADSERVERID
1540                             && serverxref[vlentry.serverNumber[k]] != BADSERVERID) {
1541                             u_char oldsn = vlentry.serverNumber[k];
1542                             u_char newsn = serverxref[oldsn];
1543                             if (newsn == oldsn) {
1544                                 log_error(VLDB_CHECK_ERROR,
1545                                           "INTERNAL VLDB_CHECK_ERROR: serverxref points to self; index %d\n",
1546                                           oldsn);
1547                             } else if (header.IpMappedAddr[oldsn] == 0) {
1548                                 log_error(VLDB_CHECK_ERROR,
1549                                           "INTERNAL VLDB_CHECK_ERROR: serverxref; points to empty address; index %d, value %d\n",
1550                                           oldsn, newsn);
1551                             } else if (header.IpMappedAddr[newsn] != header.IpMappedAddr[oldsn]) {
1552                                 log_error(VLDB_CHECK_ERROR,
1553                                           "INTERNAL VLDB_CHECK_ERROR: invalid serverxref; index %d\n",
1554                                           oldsn);
1555                             } else {
1556                                 quiet_println
1557                                     ("FIX: Volume '%s', index %d, server number was %d, is now %d\n",
1558                                      vlentry.name, k, oldsn, newsn);
1559                                 vlentry.serverNumber[k] = newsn;
1560                             }
1561                         }
1562                     }
1563
1564                     vlentry.nextIdHash[j] = header.VolidHash[j][hash];
1565                     header.VolidHash[j][hash] = record[i].addr;
1566                 }
1567                 writeentry(record[i].addr, &vlentry);
1568             }
1569         }
1570         else if (record[i].type & MH) {
1571             int block, index;
1572             char mhblock[VL_ADDREXTBLK_SIZE];
1573             struct extentaddr *MHblock = (struct extentaddr *)mhblock;
1574
1575             if (fix) {
1576                 for (block = 0; block < VL_MAX_ADDREXTBLKS; block++) {
1577                     if (mhinfo[block].addr == record[i].addr)
1578                         break;
1579                 }
1580                 if (block == VL_MAX_ADDREXTBLKS) {
1581                     continue;  /* skip orphaned extent block */
1582                 }
1583                 readMH(record[i].addr, block, MHblock);
1584                 for (index = 0; index < VL_MHSRV_PERBLK; index++) {
1585                     if (mhinfo[block].orphan[index]) {
1586                         quiet_println("FIX: Removing unreferenced mh entry; block %d, index %d\n",
1587                                 block, index);
1588                         memset(&(MHblock[index]), 0, sizeof(struct extentaddr));
1589                     }
1590                 }
1591                 writeMH(record[i].addr, block, MHblock);
1592             }
1593         } else if (record[i].type & FR) {
1594             if (fix) {
1595                 readentry(record[i].addr, &vlentry, &type);
1596                 vlentry.nextIdHash[0] = header.vital_header.freePtr;
1597                 header.vital_header.freePtr = record[i].addr;
1598                 if ((record[i].type & FRC) == 0) {
1599                     quiet_println
1600                         ("FIX: Putting free entry on the free chain: addr=%lu (offset 0x%0x)\n",
1601                          record[i].addr, OFFSET(record[i].addr));
1602                 }
1603                 writeentry(record[i].addr, &vlentry);
1604             }
1605         }
1606     }
1607     if (fix) {
1608         reportHashChanges(&header, oldnamehash, oldidhash);
1609         removeCrossLinkedAddresses(&header);
1610         writeheader(&header);
1611     }
1612
1613     close(fd);
1614
1615     return error_level;
1616 }
1617
1618 int
1619 main(int argc, char **argv)
1620 {
1621     struct cmd_syndesc *ts;
1622
1623     setlinebuf(stdout);
1624
1625     ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, 0, "vldb check");
1626     cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "vldb_file");
1627     cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
1628                 "Display UBIK header");
1629     cmd_AddParm(ts, "-vheader", CMD_FLAG, CMD_OPTIONAL,
1630                 "Display VLDB header");
1631     cmd_AddParm(ts, "-servers", CMD_FLAG, CMD_OPTIONAL,
1632                 "Display server list");
1633     cmd_AddParm(ts, "-entries", CMD_FLAG, CMD_OPTIONAL, "Display entries");
1634     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
1635     cmd_AddParm(ts, "-quiet", CMD_FLAG, CMD_OPTIONAL, "quiet");
1636     cmd_AddParm(ts, "-fix", CMD_FLAG, CMD_OPTIONAL, "attempt to patch the database (potentially dangerous)");
1637
1638     return cmd_Dispatch(argc, argv);
1639 }