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