#define vldbread(x,y,z) vldbio(x,y,z,0)
#define vldbwrite(x,y,z) vldbio(x,y,z,1)
-#define ADDR(x) (x/sizeof(struct nvlentry))
+#define HDRSIZE 64
+#define ADDR(x) ((x)/sizeof(struct nvlentry))
+#define OFFSET(addr) ((addr) + HDRSIZE)
int fd;
int listentries, listservers, listheader, listuheader, verbose, quiet;
} *record;
afs_int32 maxentries;
int serveraddrs[MAXSERVERID + 2];
+u_char serverxref[MAXSERVERID + 2]; /**< to resolve cross-linked mh entries */
+int serverref[MAXSERVERID + 2]; /**< which addrs are referenced by vl entries */
+
+struct mhinfo {
+ afs_uint32 addr; /**< vldb file record */
+ char orphan[VL_MHSRV_PERBLK]; /**< unreferenced mh enties */
+} mhinfo[VL_MAX_ADDREXTBLKS];
+
/* Used to control what goes to stdout based on quiet flag */
void
}
-#define HDRSIZE 64
int
readUbikHeader(void)
{
int offset, r, p;
/* seek to the correct spot. skip ubik stuff */
- p = position + HDRSIZE;
+ p = OFFSET(position);
offset = lseek(fd, p, 0);
if (offset != p) {
log_error(VLDB_CHECK_FATAL,"error: lseek to %d failed: %d %d\n", p, offset, errno);
slen = strlen(volname);
if (slen >= VL_MAXNAMELEN)
return 1;
+ if (slen == 0)
+ return 1;
return (slen != strspn(volname, map));
}
}
void
-readMH(afs_int32 addr, struct extentaddr *mhblockP)
+readMH(afs_uint32 addr, int block, struct extentaddr *mhblockP)
{
int i, j;
struct extentaddr *e;
vldbread(addr, (char *)mhblockP, VL_ADDREXTBLK_SIZE);
- mhblockP->ex_count = ntohl(mhblockP->ex_count);
+ /* Every mh block has the VLCONTBLOCK flag set in the header to
+ * indicate the entry is an 8192 byte extended block. The
+ * VLCONTBLOCK flag is always clear in regular vl entries. The
+ * vlserver depends on the VLCONTBLOCK flag to correctly traverse
+ * the vldb. The flags field is in network byte order. */
mhblockP->ex_hdrflags = ntohl(mhblockP->ex_hdrflags);
- for (i = 0; i < VL_MAX_ADDREXTBLKS; i++)
- mhblockP->ex_contaddrs[i] = ntohl(mhblockP->ex_contaddrs[i]);
+ if (block == 0) {
+ /* These header fields are only used in the first mh block. */
+ mhblockP->ex_count = ntohl(mhblockP->ex_count);
+ for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
+ mhblockP->ex_contaddrs[i] = ntohl(mhblockP->ex_contaddrs[i]);
+ }
+ }
for (i = 1; i < VL_MHSRV_PERBLK; i++) {
e = &(mhblockP[i]);
}
if (listentries) {
- quiet_println("address %u: ", addr);
+ quiet_println("address %u (offset 0x%0x): ", addr, OFFSET(addr));
if (vlentryp->flags == VLCONTBLOCK) {
quiet_println("mh extension block\n");
} else if (vlentryp->flags == VLFREE) {
}
void
+writeMH(afs_int32 addr, int block, struct extentaddr *mhblockP)
+{
+ int i, j;
+ struct extentaddr *e;
+
+ if (verbose) {
+ quiet_println("Writing back MH block % at addr %u\n", block, addr);
+ }
+ if (block == 0) {
+ mhblockP->ex_count = htonl(mhblockP->ex_count);
+ mhblockP->ex_hdrflags = htonl(mhblockP->ex_hdrflags);
+ for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
+ mhblockP->ex_contaddrs[i] = htonl(mhblockP->ex_contaddrs[i]);
+ }
+ }
+ for (i = 1; i < VL_MHSRV_PERBLK; i++) {
+ e = &(mhblockP[i]);
+ /* hostuuid was not converted */
+ e->ex_uniquifier = htonl(e->ex_uniquifier);
+ for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
+ e->ex_addrs[j] = htonl(e->ex_addrs[j]);
+ }
+ }
+ vldbwrite(addr, (char *)mhblockP, VL_ADDREXTBLK_SIZE);
+}
+
+void
writeentry(afs_int32 addr, struct nvlentry *vlentryp)
{
int i;
/* Remember the highest volume id */
readentry(addr, &vlentry, &type);
if (type == VL) {
- if (!(vlentry.flags & VLF_RWEXISTS))
- log_error(VLDB_CHECK_WARNING,"VLDB_CHECK_WARNING: VLDB entry '%s' has no RW volume\n",
- vlentry.name);
for (i = 0; i < MAXTYPES; i++)
if (maxvolid < vlentry.volumeId[i])
}
if (e) {
log_error
- (VLDB_CHECK_ERROR,"VLDB entry '%s' contains an unknown RW/RO index serverFlag\n",
- vlentry.name);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): VLDB entry '%s' contains an unknown RW/RO index serverFlag\n",
+ addr, OFFSET(addr), vlentry.name);
e = 0;
}
quiet_println
entrysize = VL_ADDREXTBLK_SIZE;
mhcount++;
} else {
- log_error(VLDB_CHECK_ERROR, "Unknown entry at %u. Aborting\n", addr);
+ log_error(VLDB_CHECK_ERROR, "address %u (offset 0x%0x): Unknown entry. Aborting\n", addr, OFFSET(addr));
break;
}
}
chainlength = 0;
if (!validVolumeAddr(header->VolnameHash[i])) {
- log_error(VLDB_CHECK_ERROR,"Name Hash %d: Bad entry %u is out of range\n",
+ log_error(VLDB_CHECK_ERROR,"Name Hash index %d is out of range: %u\n",
i, header->VolnameHash[i]);
continue;
}
for (addr = header->VolnameHash[i]; addr; addr = vlentry.nextNameHash) {
readentry(addr, &vlentry, &type);
if (type != VL) {
- log_error(VLDB_CHECK_ERROR,"Name Hash %d: Bad entry at %u: Not a valid vlentry\n",
- i, addr);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: Not a vlentry\n",
+ addr, OFFSET(addr), i);
continue;
}
}
if (record[rindex].type & NH) {
log_error
- (VLDB_CHECK_ERROR,"Name Hash %d: Bad entry '%s': Already in the name hash\n",
- i, vlentry.name);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: volume name '%s' is already in the name hash\n",
+ addr, OFFSET(addr), i, vlentry.name);
record[rindex].type |= MULTN;
break;
}
if (!validVolumeAddr(vlentry.nextNameHash)) {
- log_error(VLDB_CHECK_ERROR,"Name Hash forward link of '%s' is out of range\n",
- vlentry.name);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash forward link of '%s' is out of range\n",
+ addr, OFFSET(addr), vlentry.name);
record[rindex].type |= MULTN;
break;
}
/* Hash the name and check if in correct hash table */
if (NameHash(vlentry.name) != i) {
log_error
- (VLDB_CHECK_ERROR,"Name Hash %d: Bad entry '%s': Incorrect name hash chain (should be in %d)\n",
- i, vlentry.name, NameHash(vlentry.name));
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Name Hash %d: volume name '%s': Incorrect name hash chain (should be in %d)\n",
+ addr, OFFSET(addr), i, vlentry.name, NameHash(vlentry.name));
record[rindex].type |= MULTN;
}
}
for (j = 0; j < HASHSIZE; j++) {
chainlength = 0;
if (!validVolumeAddr(header->VolidHash[i][j])) {
- log_error(VLDB_CHECK_ERROR,"%s Hash %d: Bad entry %u is out of range\n",
+ log_error(VLDB_CHECK_ERROR,"%s Hash index %d is out of range: %u\n",
vtype(i), j, header->VolidHash[i][j]);
continue;
}
readentry(addr, &vlentry, &type);
if (type != VL) {
log_error
- (VLDB_CHECK_ERROR,"%s Id Hash %d: Bad entry at %u: Not a valid vlentry\n",
- vtype(i), j, addr);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: Not a vlentry\n",
+ addr, OFFSET(addr), vtype(i), j);
continue;
}
}
if (record[rindex].type & hash) {
log_error
- (VLDB_CHECK_ERROR,"%s Id Hash %d: Bad entry '%s': Already in the hash table\n",
- vtype(i), j, vlentry.name);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: volume name '%s': Already in the hash table\n",
+ addr, OFFSET(addr), vtype(i), j, vlentry.name);
record[rindex].type |= badref;
break;
}
if (!validVolumeAddr(vlentry.nextIdHash[i])) {
- log_error(VLDB_CHECK_ERROR,"%s Id Hash forward link of '%s' is out of range\n",
- vtype(i), vlentry.name);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash forward link of '%s' is out of range\n",
+ addr, OFFSET(addr), vtype(i), vlentry.name);
record[rindex].type |= badref;
break;
}
/* Hash the id and check if in correct hash table */
if (IdHash(vlentry.volumeId[i]) != j) {
log_error
- (VLDB_CHECK_ERROR,"%s Id Hash %d: Bad entry '%s': Incorrect Id hash chain (should be in %d)\n",
- vtype(i), j, vlentry.name,
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): %s Id Hash %d: volume name '%s': Incorrect Id hash chain (should be in %d)\n",
+ addr, OFFSET(addr), vtype(i), j, vlentry.name,
IdHash(vlentry.volumeId[i]));
record[rindex].type |= badhash;
}
readentry(addr, &vlentry, &type);
if (type != FR) {
log_error
- (VLDB_CHECK_ERROR,"Free Chain %d: Bad entry at %u: Not a valid free vlentry (0x%x)\n",
- count, addr, type);
+ (VLDB_CHECK_ERROR,"address %u (offset 0%0x): Free Chain %d: Not a free vlentry (0x%x)\n",
+ addr, OFFSET(addr), count, type);
continue;
}
rindex = addr / sizeof(vlentry);
if (record[rindex].addr != addr && record[rindex].addr) {
log_error
- (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u and %ld use same record slot %d\n",
- record[rindex].addr, addr, rindex);
+ (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u (0x%0x) and %ld (0x%0x) use same record slot %d\n",
+ record[rindex].addr, OFFSET(record[rindex].addr), addr, OFFSET(addr), rindex);
}
if (record[rindex].type & FRC) {
- log_error(VLDB_CHECK_ERROR,"Free Chain: Bad entry at %u: Already in the free chain\n",
- addr);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free Chain: Already in the free chain\n",
+ addr, OFFSET(addr));
break;
}
record[rindex].type |= FRC;
int mhblocks = 0;
afs_int32 i, j, m, rindex;
afs_int32 mhentries, regentries;
- afs_uint32 caddrs[VL_MAX_ADDREXTBLKS];
char mhblock[VL_ADDREXTBLK_SIZE];
struct extentaddr *MHblock = (struct extentaddr *)mhblock;
struct extentaddr *e;
/* Read the first MH block and from it, gather the
* addresses of all the mh blocks.
*/
- readMH(header->SIT, MHblock);
+ readMH(header->SIT, 0, MHblock);
if (MHblock->ex_hdrflags != VLCONTBLOCK) {
log_error
- (VLDB_CHECK_ERROR,"Multihomed Block 0: Bad entry at %u: Not a valid multihomed block\n",
- header->SIT);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed Block 0: Not a multihomed block\n",
+ header->SIT, OFFSET(header->SIT));
}
for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
- caddrs[i] = MHblock->ex_contaddrs[i];
+ mhinfo[i].addr = MHblock->ex_contaddrs[i];
}
- if (header->SIT != caddrs[0]) {
+ if (header->SIT != mhinfo[0].addr) {
log_error
- (VLDB_CHECK_ERROR,"MH block does not point to self %u in header, %u in block\n",
- header->SIT, caddrs[0]);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): MH block does not point to self in header, %u in block\n",
+ header->SIT, OFFSET(header->SIT), mhinfo[0].addr);
}
/* Now read each MH block and record it in the record array */
for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
- if (!caddrs[i])
+ if (!mhinfo[i].addr)
continue;
- readMH(caddrs[i], MHblock);
+ readMH(mhinfo[i].addr, i, MHblock);
if (MHblock->ex_hdrflags != VLCONTBLOCK) {
log_error
- (VLDB_CHECK_ERROR,"Multihomed Block 0: Bad entry at %u: Not a valid multihomed block\n",
- header->SIT);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed Block %d: Not a multihomed block\n",
+ mhinfo[i].addr, OFFSET(mhinfo[i].addr), i);
}
- rindex = caddrs[i] / sizeof(vlentry);
- if (record[rindex].addr != caddrs[i] && record[rindex].addr) {
+ rindex = mhinfo[i].addr / sizeof(vlentry);
+ if (record[rindex].addr != mhinfo[i].addr && record[rindex].addr) {
log_error
- (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u and %u use same record slot %d\n",
- record[rindex].addr, caddrs[i], rindex);
+ (VLDB_CHECK_ERROR,"INTERNAL VLDB_CHECK_ERROR: addresses %u (0x%0x) and %u (0x%0x) use same record slot %d\n",
+ record[rindex].addr, OFFSET(record[rindex].addr), mhinfo[i].addr, OFFSET(mhinfo[i].addr), rindex);
}
if (record[rindex].type & FRC) {
log_error
- (VLDB_CHECK_ERROR,"MH Blocks Chain %d: Bad entry at %ld: Already a MH block\n",
- i, record[rindex].addr);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): MH Blocks Chain %d: Already a MH block\n",
+ record[rindex].addr, OFFSET(record[rindex].addr), i);
break;
}
record[rindex].type |= MHC;
*/
mhentries = 0;
for (j = 1; j < VL_MHSRV_PERBLK; j++) {
+ int first_ipindex = -1;
e = (struct extentaddr *)&(MHblock[j]);
- /* Search the IpMappedAddr array for the reference to this entry */
+ /* Search the IpMappedAddr array for all the references to this entry. */
+ /* Use the first reference for checking the ip addresses of this entry. */
for (ipindex = 0; ipindex <= MAXSERVERID; ipindex++) {
- if (((header->IpMappedAddr[ipindex] & 0xff000000) ==
- 0xff000000)
- &&
- (((header->
- IpMappedAddr[ipindex] & 0x00ff0000) >> 16) == i)
- && ((header->IpMappedAddr[ipindex] & 0x0000ffff) ==
- j)) {
- break;
+ if (((header->IpMappedAddr[ipindex] & 0xff000000) == 0xff000000)
+ && (((header-> IpMappedAddr[ipindex] & 0x00ff0000) >> 16) == i)
+ && ((header->IpMappedAddr[ipindex] & 0x0000ffff) == j)) {
+ if (first_ipindex == -1) {
+ first_ipindex = ipindex;
+ } else {
+ serverxref[ipindex] = first_ipindex;
+ }
}
}
- if (ipindex > MAXSERVERID)
- ipindex = -1;
- else
+ ipindex = first_ipindex;
+ if (ipindex != -1)
serveraddrs[ipindex] = -1;
if (memcmp(&e->ex_hostuuid, &nulluuid, sizeof(afsUUID)) == 0) {
if (ipaddrs) {
mhentries++;
if (ipindex == -1) {
+ mhinfo[i].orphan[j] = 1;
log_error
(VLDB_CHECK_ERROR,"MH block %d, index %d: Not referenced by server addrs\n",
i, j);
log_error
(VLDB_CHECK_ERROR,"IP Addr for entry %d: Multihome block is bad (%d)\n",
i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
+ if (mhinfo[(header->IpMappedAddr[i] & 0x00ff0000) >> 16].addr == 0)
+ log_error(VLDB_CHECK_ERROR,"IP Addr for entry %d: No such multihome block (%d)\n",
+ i, ((header->IpMappedAddr[i] & 0x00ff0000) >> 16));
if (((header->IpMappedAddr[i] & 0x0000ffff) > VL_MHSRV_PERBLK)
|| ((header->IpMappedAddr[i] & 0x0000ffff) < 1))
log_error
i);
serveraddrs[i] = 0;
}
+ if (serverxref[i] != BADSERVERID) {
+ log_error
+ (VLDB_CHECK_WARNING,
+ "warning: MH block %d, index %d is cross-linked by server numbers %d and %d.\n",
+ (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
+ (header->IpMappedAddr[i] & 0x0000ffff),
+ i, serverxref[i]);
+ /* set addresses found/not found for this server number,
+ * using the first index to the mh we found above. */
+ serveraddrs[i] = serveraddrs[serverxref[i]];
+ }
if (listservers) {
quiet_println(" Server ip addr %d = MH block %d, index %d\n",
i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
}
}
+/**
+ * Remove unreferenced, duplicate multi-home address indices.
+ *
+ * Removes entries from IpMappedAddr which where found to be
+ * duplicates. Only entries which are not referenced by vl entries
+ * are removed on this pass.
+ *
+ * @param[inout] header the vldb header to be updated.
+ */
+void
+removeCrossLinkedAddresses(struct vlheader *header)
+{
+ int i;
+
+ for (i = 0; i <= MAXSERVERID; i++) {
+ if (serverref[i] == 0
+ && (header->IpMappedAddr[i] & 0xff000000) == 0xff000000
+ && serverxref[i] != BADSERVERID) {
+ if (serverxref[i] == i) {
+ log_error(VLDB_CHECK_ERROR,
+ "INTERNAL VLDB_CHECK_ERROR: serverxref points to self; index %d\n",
+ i);
+ } else if (header->IpMappedAddr[serverxref[i]] == 0) {
+ log_error(VLDB_CHECK_ERROR,
+ "INTERNAL VLDB_CHECK_ERROR: serverxref points to empty addr; index %d, value %d\n",
+ i, serverxref[i]);
+ } else if (header->IpMappedAddr[serverxref[i]] != header->IpMappedAddr[i]) {
+ log_error(VLDB_CHECK_ERROR,
+ "INTERNAL VLDB_CHECK_ERROR: invalid serverxref; index %d, value %d\n",
+ i, serverxref[i]);
+ } else {
+ quiet_println
+ ("FIX: Removing unreferenced address index %d, which cross-links MH block %d, index %d\n",
+ i, (header->IpMappedAddr[i] & 0x00ff0000) >> 16,
+ (header->IpMappedAddr[i] & 0x0000ffff));
+ header->IpMappedAddr[i] = 0;
+ }
+ }
+ }
+}
+
int
WorkerBee(struct cmd_syndesc *as, void *arock)
{
afs_int32 type;
struct vlheader header;
struct nvlentry vlentry, vlentry2;
- int i, j;
+ int i, j, k;
afs_uint32 oldnamehash[HASHSIZE];
afs_uint32 oldidhash[MAXTYPES][HASHSIZE];
maxentries = (header.vital_header.eofPtr / sizeof(vlentry)) + 1;
record = calloc(maxentries, sizeof(struct er));
memset(serveraddrs, 0, sizeof(serveraddrs));
+ memset(mhinfo, 0, sizeof(mhinfo));
+ memset(serverref, 0, sizeof(serverref));
+ for (i = 0; i <= MAXSERVERID; i++) {
+ serverxref[i] = BADSERVERID;
+ }
/* Will fill in the record array of entries it found */
ReadAllEntries(&header);
readentry(record[i].addr, &vlentry, &type);
+ if (!(vlentry.flags & VLF_RWEXISTS))
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has no RW volume\n",
+ record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
+
if (InvalidVolname(vlentry.name))
- log_error(VLDB_CHECK_ERROR,"Volume '%s' at addr %ld has an invalid name\n",
- vlentry.name, record[i].addr);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has an invalid name\n",
+ record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
+
+ if (vlentry.volumeId[0] == 0)
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' (%u) has an invalid volume id\n",
+ record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0]);
if (!(record[i].type & NH)) {
hash = NameHash(vlentry.name);
}
if (foundbroken) {
- log_error(VLDB_CHECK_ERROR, "%d: Volume '%s' %s forward link in %s hash chain is broken (hash %d != %d)\n", i,
- vlentry.name, volidbuf, which, hash, nexthash);
+ log_error(VLDB_CHECK_ERROR,
+ "address %u (offset 0x%0x): Volume '%s' %s forward link in %s hash chain is broken (hash %d != %d)\n",
+ record[i].addr, OFFSET(record[i].addr),
+ vlentry.name, volidbuf, which, hash, nexthash);
} else if (foundbad) {
- log_error(VLDB_CHECK_ERROR, "%d: Volume '%s' %snot found in %s hash %d\n", i,
- vlentry.name, volidbuf, which, hash);
+ log_error(VLDB_CHECK_ERROR,
+ "address %u (offset 0x%0x): Volume '%s' %snot found in %s hash %d\n",
+ record[i].addr, OFFSET(record[i].addr),
+ vlentry.name, volidbuf, which, hash);
}
for (j = 0; j < NMAXNSERVERS; j++) {
- if ((vlentry.serverNumber[j] != 255)
- && (serveraddrs[vlentry.serverNumber[j]] == 0)) {
- log_error
- (VLDB_CHECK_ERROR,"Volume '%s', index %d points to empty server entry %d\n",
- vlentry.name, j, vlentry.serverNumber[j]);
+ if (vlentry.serverNumber[j] != BADSERVERID) {
+ serverref[vlentry.serverNumber[j]] = 1;
+ if (serveraddrs[vlentry.serverNumber[j]] == 0) {
+ log_error
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s', index %d points to empty server entry %d\n",
+ record[i].addr, OFFSET(record[i].addr), vlentry.name, j, vlentry.serverNumber[j]);
+ } else if (serverxref[vlentry.serverNumber[j]] != BADSERVERID) {
+ log_error
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s', index %d points to server entry %d, which is cross-linked by %d\n",
+ record[i].addr, OFFSET(record[i].addr), vlentry.name, j, vlentry.serverNumber[j], serverxref[vlentry.serverNumber[j]]);
+ }
}
}
if (record[i].type & 0xffff0f00)
log_error
- (VLDB_CHECK_ERROR,"Volume '%s' id %u also found on other chains (0x%x)\n",
- vlentry.name, vlentry.volumeId[0], record[i].type);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Volume '%s' id %u also found on other chains (0x%x)\n",
+ record[i].addr, OFFSET(record[i].addr), vlentry.name, vlentry.volumeId[0], record[i].type);
/* A free entry */
} else if (record[i].type & FR) {
if (!(record[i].type & FRC))
- log_error(VLDB_CHECK_ERROR,"Free vlentry at %ld not on free chain\n",
- record[i].addr);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free vlentry not on free chain\n",
+ record[i].addr, OFFSET(record[i].addr));
if (record[i].type & 0xfffffdf0)
log_error
- (VLDB_CHECK_ERROR,"Free vlentry at %ld also found on other chains (0x%x)\n",
- record[i].addr, record[i].type);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Free vlentry also found on other chains (0x%x)\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
/* A multihomed entry */
} else if (record[i].type & MH) {
if (!(record[i].type & MHC))
- log_error(VLDB_CHECK_ERROR,"Multihomed block at %ld is orphaned\n",
- record[i].addr);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed block is orphaned\n",
+ record[i].addr, OFFSET(record[i].addr));
if (record[i].type & 0xfffffef0)
log_error
- (VLDB_CHECK_ERROR,"Multihomed block at %ld also found on other chains (0x%x)\n",
- record[i].addr, record[i].type);
+ (VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Multihomed block also found on other chains (0x%x)\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
} else {
- log_error(VLDB_CHECK_ERROR,"Unknown entry type at %u (0x%x)\n", record[i].addr,
- record[i].type);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Unknown entry type 0x%x\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
}
}
if (fix) {
/*
- * If we are fixing we will rebuild all the hash lists from the ground up
+ * If we are fixing we will rebuild the free and hash lists from the ground up.
*/
+ header.vital_header.freePtr = 0;
memcpy(oldnamehash, header.VolnameHash, sizeof(oldnamehash));
memset(header.VolnameHash, 0, sizeof(header.VolnameHash));
if (record[i].type & VL) {
readentry(record[i].addr, &vlentry, &type);
if (!(record[i].type & REFN)) {
- log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a name chain\n", i,
- record[i].addr, record[i].type);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record is not in a name chain (type 0x%0x)\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
}
if (vlentry.volumeId[0] && !(record[i].type & REFRW)) {
- log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a RW chain\n", i,
- record[i].addr, record[i].type);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a RW chain (type 0x%0x)\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
}
if (vlentry.volumeId[1] && !(record[i].type & REFRO)) {
- log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a RO chain\n", i,
- record[i].addr, record[i].type);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a RO chain (type 0x%0x)\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
}
if (vlentry.volumeId[2] && !(record[i].type & REFBK)) {
- log_error(VLDB_CHECK_ERROR,"%d: Record %ld (type 0x%x) not in a BK chain\n", i,
- record[i].addr, record[i].type);
+ log_error(VLDB_CHECK_ERROR,"address %u (offset 0x%0x): Record not in a BK chain (type 0x%0x)\n",
+ record[i].addr, OFFSET(record[i].addr), record[i].type);
}
if (fix) {
afs_uint32 oldhash, newhash;
char newNameBuffer[10 + VL_MAXNAMELEN];
char *oldname, *newname;
+ /* Fix broken names and numbers so entries can be inspected and deleted. */
+ if (InvalidVolname(vlentry.name)) {
+ char bogus[VL_MAXNAMELEN];
+ memset(bogus, 0, sizeof(bogus));
+ snprintf(bogus, sizeof(bogus)-1, ".bogus.%ld", record[i].addr);
+ strcpy(vlentry.name, bogus);
+ quiet_println("FIX: Record %ld invalid volume name set to '%s'\n", record[i].addr, bogus);
+ }
+ if (vlentry.volumeId[0] == 0) {
+ afs_uint32 next_volid = header.vital_header.MaxVolumeId++;
+ vlentry.volumeId[0] = next_volid;
+ quiet_println("FIX: Record %ld invalid volume id set to %ld. New max volid is %ld\n",
+ record[i].addr, next_volid, header.vital_header.MaxVolumeId);
+ }
+
/*
* Put the current hash table contexts into our 'next'
* and our address into the hash table.
}
}
+ /* Consolidate server numbers which point to the same mh entry.
+ * The serverref flags are not reset here, since we want to make
+ * sure the data is actually written before the server number is
+ * considered unreferenced. */
+ for (k = 0; k < NMAXNSERVERS; k++) {
+ if (vlentry.serverNumber[k] != BADSERVERID
+ && serverxref[vlentry.serverNumber[k]] != BADSERVERID) {
+ u_char oldsn = vlentry.serverNumber[k];
+ u_char newsn = serverxref[oldsn];
+ if (newsn == oldsn) {
+ log_error(VLDB_CHECK_ERROR,
+ "INTERNAL VLDB_CHECK_ERROR: serverxref points to self; index %d\n",
+ oldsn);
+ } else if (header.IpMappedAddr[oldsn] == 0) {
+ log_error(VLDB_CHECK_ERROR,
+ "INTERNAL VLDB_CHECK_ERROR: serverxref; points to empty address; index %d, value %d\n",
+ oldsn, newsn);
+ } else if (header.IpMappedAddr[newsn] != header.IpMappedAddr[oldsn]) {
+ log_error(VLDB_CHECK_ERROR,
+ "INTERNAL VLDB_CHECK_ERROR: invalid serverxref; index %d\n",
+ oldsn);
+ } else {
+ quiet_println
+ ("FIX: Volume '%s', index %d, server number was %d, is now %d\n",
+ vlentry.name, k, oldsn, newsn);
+ vlentry.serverNumber[k] = newsn;
+ }
+ }
+ }
+
vlentry.nextIdHash[j] = header.VolidHash[j][hash];
header.VolidHash[j][hash] = record[i].addr;
}
writeentry(record[i].addr, &vlentry);
}
}
+ else if (record[i].type & MH) {
+ int block, index;
+ char mhblock[VL_ADDREXTBLK_SIZE];
+ struct extentaddr *MHblock = (struct extentaddr *)mhblock;
+
+ if (fix) {
+ for (block = 0; block < VL_MAX_ADDREXTBLKS; block++) {
+ if (mhinfo[block].addr == record[i].addr)
+ break;
+ }
+ if (block == VL_MAX_ADDREXTBLKS) {
+ continue; /* skip orphaned extent block */
+ }
+ readMH(record[i].addr, block, MHblock);
+ for (index = 0; index < VL_MHSRV_PERBLK; index++) {
+ if (mhinfo[block].orphan[index]) {
+ quiet_println("FIX: Removing unreferenced mh entry; block %d, index %d\n",
+ block, index);
+ memset(&(MHblock[index]), 0, sizeof(struct extentaddr));
+ }
+ }
+ writeMH(record[i].addr, block, MHblock);
+ }
+ } else if (record[i].type & FR) {
+ if (fix) {
+ readentry(record[i].addr, &vlentry, &type);
+ vlentry.nextIdHash[0] = header.vital_header.freePtr;
+ header.vital_header.freePtr = record[i].addr;
+ if ((record[i].type & FRC) == 0) {
+ quiet_println
+ ("FIX: Putting free entry on the free chain: addr=%lu (offset 0x%0x)\n",
+ record[i].addr, OFFSET(record[i].addr));
+ }
+ writeentry(record[i].addr, &vlentry);
+ }
+ }
}
if (fix) {
reportHashChanges(&header, oldnamehash, oldidhash);
+ removeCrossLinkedAddresses(&header);
writeheader(&header);
}
setlinebuf(stdout);
- ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "vldb check");
+ ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, 0, "vldb check");
cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "vldb_file");
cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
"Display UBIK header");
git://git.openafs.org / openafs.git / blobdiff