Log binding ip address and port during startup
[openafs.git] / src / vlserver / vlutils.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 #include <lock.h>
16 #include <rx/xdr.h>
17 #include <ubik.h>
18
19 #include "vlserver.h"
20 #include "vlserver_internal.h"
21
22 struct vlheader xheader;
23 extern int maxnservers;
24 extern afs_uint32 rd_HostAddress[MAXSERVERID + 1];
25 extern afs_uint32 wr_HostAddress[MAXSERVERID + 1];
26 struct extentaddr *rd_ex_addr[VL_MAX_ADDREXTBLKS] = { 0, 0, 0, 0 };
27 struct extentaddr *wr_ex_addr[VL_MAX_ADDREXTBLKS] = { 0, 0, 0, 0 };
28 struct vlheader rd_cheader;     /* kept in network byte order */
29 struct vlheader wr_cheader;
30 int vldbversion = 0;
31
32 static int index_OK(struct vl_ctx *ctx, afs_int32 blockindex);
33
34 #define ERROR_EXIT(code) do { \
35     error = (code); \
36     goto error_exit; \
37 } while (0)
38
39 /* Hashing algorithm based on the volume id; HASHSIZE must be prime */
40 afs_int32
41 IDHash(afs_int32 volumeid)
42 {
43     return ((abs(volumeid)) % HASHSIZE);
44 }
45
46
47 /* Hashing algorithm based on the volume name; name's size is implicit (64 chars) and if changed it should be reflected here. */
48 afs_int32
49 NameHash(char *volumename)
50 {
51     unsigned int hash;
52     int i;
53
54     hash = 0;
55     for (i = strlen(volumename), volumename += i - 1; i--; volumename--)
56         hash = (hash * 63) + (*((unsigned char *)volumename) - 63);
57     return (hash % HASHSIZE);
58 }
59
60
61 /* package up seek and write into one procedure for ease of use */
62 afs_int32
63 vlwrite(struct ubik_trans *trans, afs_int32 offset, void *buffer,
64         afs_int32 length)
65 {
66     afs_int32 errorcode;
67
68     if ((errorcode = ubik_Seek(trans, 0, offset)))
69         return errorcode;
70     return (ubik_Write(trans, buffer, length));
71 }
72
73
74 /* Package up seek and read into one procedure for ease of use */
75 afs_int32
76 vlread(struct ubik_trans *trans, afs_int32 offset, char *buffer,
77        afs_int32 length)
78 {
79     afs_int32 errorcode;
80
81     if ((errorcode = ubik_Seek(trans, 0, offset)))
82         return errorcode;
83     return (ubik_Read(trans, buffer, length));
84 }
85
86
87 /* take entry and convert to network order and write to disk */
88 afs_int32
89 vlentrywrite(struct ubik_trans *trans, afs_int32 offset, void *buffer,
90              afs_int32 length)
91 {
92     struct vlentry oentry;
93     struct nvlentry nentry, *nep;
94     char *bufp;
95     afs_int32 i;
96
97     if (length != sizeof(oentry))
98         return -1;
99     if (maxnservers == 13) {
100         nep = (struct nvlentry *)buffer;
101         for (i = 0; i < MAXTYPES; i++)
102             nentry.volumeId[i] = htonl(nep->volumeId[i]);
103         nentry.flags = htonl(nep->flags);
104         nentry.LockAfsId = htonl(nep->LockAfsId);
105         nentry.LockTimestamp = htonl(nep->LockTimestamp);
106         nentry.cloneId = htonl(nep->cloneId);
107         for (i = 0; i < MAXTYPES; i++)
108             nentry.nextIdHash[i] = htonl(nep->nextIdHash[i]);
109         nentry.nextNameHash = htonl(nep->nextNameHash);
110         memcpy(nentry.name, nep->name, VL_MAXNAMELEN);
111         memcpy(nentry.serverNumber, nep->serverNumber, NMAXNSERVERS);
112         memcpy(nentry.serverPartition, nep->serverPartition, NMAXNSERVERS);
113         memcpy(nentry.serverFlags, nep->serverFlags, NMAXNSERVERS);
114         bufp = (char *)&nentry;
115     } else {
116         memset(&oentry, 0, sizeof(struct vlentry));
117         nep = (struct nvlentry *)buffer;
118         for (i = 0; i < MAXTYPES; i++)
119             oentry.volumeId[i] = htonl(nep->volumeId[i]);
120         oentry.flags = htonl(nep->flags);
121         oentry.LockAfsId = htonl(nep->LockAfsId);
122         oentry.LockTimestamp = htonl(nep->LockTimestamp);
123         oentry.cloneId = htonl(nep->cloneId);
124         for (i = 0; i < MAXTYPES; i++)
125             oentry.nextIdHash[i] = htonl(nep->nextIdHash[i]);
126         oentry.nextNameHash = htonl(nep->nextNameHash);
127         memcpy(oentry.name, nep->name, VL_MAXNAMELEN);
128         memcpy(oentry.serverNumber, nep->serverNumber, OMAXNSERVERS);
129         memcpy(oentry.serverPartition, nep->serverPartition, OMAXNSERVERS);
130         memcpy(oentry.serverFlags, nep->serverFlags, OMAXNSERVERS);
131         bufp = (char *)&oentry;
132     }
133     return vlwrite(trans, offset, bufp, length);
134 }
135
136 /* read entry and convert to host order and write to disk */
137 afs_int32
138 vlentryread(struct ubik_trans *trans, afs_int32 offset, char *buffer,
139             afs_int32 length)
140 {
141     struct vlentry *oep, tentry;
142     struct nvlentry *nep, *nbufp;
143     char *bufp = (char *)&tentry;
144     afs_int32 i;
145
146     if (length != sizeof(vlentry))
147         return -1;
148     i = vlread(trans, offset, bufp, length);
149     if (i)
150         return i;
151     if (maxnservers == 13) {
152         nep = (struct nvlentry *)bufp;
153         nbufp = (struct nvlentry *)buffer;
154         for (i = 0; i < MAXTYPES; i++)
155             nbufp->volumeId[i] = ntohl(nep->volumeId[i]);
156         nbufp->flags = ntohl(nep->flags);
157         nbufp->LockAfsId = ntohl(nep->LockAfsId);
158         nbufp->LockTimestamp = ntohl(nep->LockTimestamp);
159         nbufp->cloneId = ntohl(nep->cloneId);
160         for (i = 0; i < MAXTYPES; i++)
161             nbufp->nextIdHash[i] = ntohl(nep->nextIdHash[i]);
162         nbufp->nextNameHash = ntohl(nep->nextNameHash);
163         memcpy(nbufp->name, nep->name, VL_MAXNAMELEN);
164         memcpy(nbufp->serverNumber, nep->serverNumber, NMAXNSERVERS);
165         memcpy(nbufp->serverPartition, nep->serverPartition, NMAXNSERVERS);
166         memcpy(nbufp->serverFlags, nep->serverFlags, NMAXNSERVERS);
167     } else {
168         oep = (struct vlentry *)bufp;
169         nbufp = (struct nvlentry *)buffer;
170         memset(nbufp, 0, sizeof(struct nvlentry));
171         for (i = 0; i < MAXTYPES; i++)
172             nbufp->volumeId[i] = ntohl(oep->volumeId[i]);
173         nbufp->flags = ntohl(oep->flags);
174         nbufp->LockAfsId = ntohl(oep->LockAfsId);
175         nbufp->LockTimestamp = ntohl(oep->LockTimestamp);
176         nbufp->cloneId = ntohl(oep->cloneId);
177         for (i = 0; i < MAXTYPES; i++)
178             nbufp->nextIdHash[i] = ntohl(oep->nextIdHash[i]);
179         nbufp->nextNameHash = ntohl(oep->nextNameHash);
180         memcpy(nbufp->name, oep->name, VL_MAXNAMELEN);
181         memcpy(nbufp->serverNumber, oep->serverNumber, NMAXNSERVERS);
182         memcpy(nbufp->serverPartition, oep->serverPartition, NMAXNSERVERS);
183         memcpy(nbufp->serverFlags, oep->serverFlags, NMAXNSERVERS);
184     }
185     return 0;
186 }
187
188 /* Convenient write of small critical vldb header info to the database. */
189 int
190 write_vital_vlheader(struct vl_ctx *ctx)
191 {
192     if (vlwrite
193         (ctx->trans, 0, (char *)&ctx->cheader->vital_header, sizeof(vital_vlheader)))
194         return VL_IO;
195     return 0;
196 }
197
198
199 int extent_mod = 0;
200
201 /* This routine reads in the extent blocks for multi-homed servers.
202  * There used to be an initialization bug that would cause the contaddrs
203  * pointers in the first extent block to be bad. Here we will check the
204  * pointers and zero them in the in-memory copy if we find them bad. We
205  * also try to write the extent blocks back out. If we can't, then we
206  * will wait until the next write transaction to write them out
207  * (extent_mod tells us the on-disk copy is bad).
208  */
209 afs_int32
210 readExtents(struct ubik_trans *trans)
211 {
212     afs_uint32 extentAddr;
213     afs_int32 error = 0, code;
214     int i;
215
216     extent_mod = 0;
217     extentAddr = ntohl(rd_cheader.SIT);
218     if (!extentAddr)
219         return 0;
220
221     /* Read the first extension block */
222     if (!rd_ex_addr[0]) {
223         rd_ex_addr[0] = malloc(VL_ADDREXTBLK_SIZE);
224         if (!rd_ex_addr[0])
225             ERROR_EXIT(VL_NOMEM);
226     }
227     code = vlread(trans, extentAddr, (char *)rd_ex_addr[0], VL_ADDREXTBLK_SIZE);
228     if (code) {
229         free(rd_ex_addr[0]);    /* Not the place to create it */
230         rd_ex_addr[0] = 0;
231         ERROR_EXIT(VL_IO);
232     }
233
234     /* In case more that 64 mh servers are in use they're kept in these
235      * continuation blocks
236      */
237     for (i = 1; i < VL_MAX_ADDREXTBLKS; i++) {
238         if (!rd_ex_addr[0]->ex_contaddrs[i])
239             continue;
240
241         /* Before reading it in, check to see if the address is good */
242         if ((ntohl(rd_ex_addr[0]->ex_contaddrs[i]) <
243              ntohl(rd_ex_addr[0]->ex_contaddrs[i - 1]) + VL_ADDREXTBLK_SIZE)
244             || (ntohl(rd_ex_addr[0]->ex_contaddrs[i]) >
245                 ntohl(rd_cheader.vital_header.eofPtr) - VL_ADDREXTBLK_SIZE)) {
246             extent_mod = 1;
247             rd_ex_addr[0]->ex_contaddrs[i] = 0;
248             continue;
249         }
250
251
252         /* Read the continuation block */
253         if (!rd_ex_addr[i]) {
254             rd_ex_addr[i] = malloc(VL_ADDREXTBLK_SIZE);
255             if (!rd_ex_addr[i])
256                 ERROR_EXIT(VL_NOMEM);
257         }
258         code =
259             vlread(trans, ntohl(rd_ex_addr[0]->ex_contaddrs[i]),
260                    (char *)rd_ex_addr[i], VL_ADDREXTBLK_SIZE);
261         if (code) {
262             free(rd_ex_addr[i]);        /* Not the place to create it */
263             rd_ex_addr[i] = 0;
264             ERROR_EXIT(VL_IO);
265         }
266
267         /* After reading it in, check to see if its a real continuation block */
268         if (ntohl(rd_ex_addr[i]->ex_hdrflags) != VLCONTBLOCK) {
269             extent_mod = 1;
270             rd_ex_addr[0]->ex_contaddrs[i] = 0;
271             free(rd_ex_addr[i]);        /* Not the place to create it */
272             rd_ex_addr[i] = 0;
273             continue;
274         }
275     }
276
277     if (extent_mod) {
278         code = vlwrite(trans, extentAddr, rd_ex_addr[0], VL_ADDREXTBLK_SIZE);
279         if (!code) {
280             VLog(0, ("Multihome server support modification\n"));
281         }
282         /* Keep extent_mod true in-case the transaction aborts */
283         /* Don't return error so we don't abort transaction */
284     }
285
286   error_exit:
287     return error;
288 }
289
290 /* Check that the database has been initialized.  Be careful to fail in a safe
291    manner, to avoid bogusly reinitializing the db.  */
292 /**
293  * reads in db cache from ubik.
294  *
295  * @param[in] ut ubik transaction
296  * @param[in] rock  opaque pointer to an int*; if 1, we should rebuild the db
297  *                  if it appears empty, if 0 we should return an error if the
298  *                  db appears empty
299  *
300  * @return operation status
301  *   @retval 0 success
302  */
303 static afs_int32
304 UpdateCache(struct ubik_trans *trans, void *rock)
305 {
306     int *builddb_rock = rock;
307     int builddb = *builddb_rock;
308     afs_int32 error = 0, i, code, ubcode;
309
310     /* if version changed (or first call), read the header */
311     ubcode = vlread(trans, 0, (char *)&rd_cheader, sizeof(rd_cheader));
312     vldbversion = ntohl(rd_cheader.vital_header.vldbversion);
313
314     if (!ubcode && (vldbversion != 0)) {
315         memcpy(rd_HostAddress, rd_cheader.IpMappedAddr, sizeof(rd_cheader.IpMappedAddr));
316         for (i = 0; i < MAXSERVERID + 1; i++) { /* cvt HostAddress to host order */
317             rd_HostAddress[i] = ntohl(rd_HostAddress[i]);
318         }
319
320         code = readExtents(trans);
321         if (code)
322             ERROR_EXIT(code);
323     }
324
325     /* now, if can't read, or header is wrong, write a new header */
326     if (ubcode || vldbversion == 0) {
327         if (builddb) {
328             VLog(0, ("Can't read VLDB header, re-initialising...\n"));
329
330             /* try to write a good header */
331             /* The read cache will be sync'ed to this new header
332              * when the ubik transaction is ended by vlsynccache(). */
333             memset(&wr_cheader, 0, sizeof(wr_cheader));
334             wr_cheader.vital_header.vldbversion = htonl(VLDBVERSION);
335             wr_cheader.vital_header.headersize = htonl(sizeof(wr_cheader));
336             /* DANGER: Must get this from a master place!! */
337             wr_cheader.vital_header.MaxVolumeId = htonl(0x20000000);
338             wr_cheader.vital_header.eofPtr = htonl(sizeof(wr_cheader));
339             for (i = 0; i < MAXSERVERID + 1; i++) {
340                 wr_cheader.IpMappedAddr[i] = 0;
341                 wr_HostAddress[i] = 0;
342             }
343             code = vlwrite(trans, 0, (char *)&wr_cheader, sizeof(wr_cheader));
344             if (code) {
345                 VLog(0, ("Can't write VLDB header (error = %d)\n", code));
346                 ERROR_EXIT(VL_IO);
347             }
348             vldbversion = ntohl(wr_cheader.vital_header.vldbversion);
349         } else {
350             VLog(1, ("Unable to read VLDB header.\n"));
351             ERROR_EXIT(VL_EMPTY);
352         }
353     }
354
355     if ((vldbversion != VLDBVERSION) && (vldbversion != OVLDBVERSION)
356         && (vldbversion != VLDBVERSION_4)) {
357         VLog(0,
358             ("VLDB version %d doesn't match this software version(%d, %d or %d), quitting!\n",
359              vldbversion, VLDBVERSION_4, VLDBVERSION, OVLDBVERSION));
360         ERROR_EXIT(VL_BADVERSION);
361     }
362
363     maxnservers = ((vldbversion == 3 || vldbversion == 4) ? 13 : 8);
364
365   error_exit:
366     /* all done */
367     return error;
368 }
369
370 afs_int32
371 CheckInit(struct ubik_trans *trans, int builddb)
372 {
373     afs_int32 code;
374
375     code = ubik_CheckCache(trans, UpdateCache, &builddb);
376     if (code) {
377         return code;
378     }
379
380     /* these next two cases shouldn't happen (UpdateCache should either
381      * rebuild the db or return an error if these cases occur), but just to
382      * be on the safe side... */
383     if (vldbversion == 0) {
384         return VL_EMPTY;
385     }
386     if ((vldbversion != VLDBVERSION) && (vldbversion != OVLDBVERSION)
387         && (vldbversion != VLDBVERSION_4)) {
388         return VL_BADVERSION;
389     }
390
391     return 0;
392 }
393
394
395 afs_int32
396 GetExtentBlock(struct vl_ctx *ctx, register afs_int32 base)
397 {
398     afs_int32 blockindex, code, error = 0;
399
400     /* Base 0 must exist before any other can be created */
401     if ((base != 0) && !ctx->ex_addr[0])
402         ERROR_EXIT(VL_CREATEFAIL);      /* internal error */
403
404     if (!ctx->ex_addr[0] || !ctx->ex_addr[0]->ex_contaddrs[base]) {
405         /* Create a new extension block */
406         if (!ctx->ex_addr[base]) {
407             ctx->ex_addr[base] = malloc(VL_ADDREXTBLK_SIZE);
408             if (!ctx->ex_addr[base])
409                 ERROR_EXIT(VL_NOMEM);
410         }
411         memset(ctx->ex_addr[base], 0, VL_ADDREXTBLK_SIZE);
412
413         /* Write the full extension block at end of vldb */
414         ctx->ex_addr[base]->ex_hdrflags = htonl(VLCONTBLOCK);
415         blockindex = ntohl(ctx->cheader->vital_header.eofPtr);
416         code =
417             vlwrite(ctx->trans, blockindex, (char *)ctx->ex_addr[base],
418                     VL_ADDREXTBLK_SIZE);
419         if (code)
420             ERROR_EXIT(VL_IO);
421
422         /* Update the cheader.vitalheader structure on disk */
423         ctx->cheader->vital_header.eofPtr = blockindex + VL_ADDREXTBLK_SIZE;
424         ctx->cheader->vital_header.eofPtr = htonl(ctx->cheader->vital_header.eofPtr);
425         code = write_vital_vlheader(ctx);
426         if (code)
427             ERROR_EXIT(VL_IO);
428
429         /* Write the address of the base extension block in the vldb header */
430         if (base == 0) {
431             ctx->cheader->SIT = htonl(blockindex);
432             code =
433                 vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->SIT),
434                         (char *)&ctx->cheader->SIT, sizeof(ctx->cheader->SIT));
435             if (code)
436                 ERROR_EXIT(VL_IO);
437         }
438
439         /* Write the address of this extension block into the base extension block */
440         ctx->ex_addr[0]->ex_contaddrs[base] = htonl(blockindex);
441         code =
442             vlwrite(ctx->trans, ntohl(ctx->cheader->SIT), ctx->ex_addr[0],
443                     sizeof(struct extentaddr));
444         if (code)
445             ERROR_EXIT(VL_IO);
446     }
447
448   error_exit:
449     return error;
450 }
451
452
453 afs_int32
454 FindExtentBlock(struct vl_ctx *ctx, afsUUID *uuidp,
455                 afs_int32 createit, afs_int32 hostslot,
456                 struct extentaddr **expp, afs_int32 *basep)
457 {
458     afsUUID tuuid;
459     struct extentaddr *exp;
460     afs_int32 i, j, code, base, index, error = 0;
461
462     *expp = NULL;
463     *basep = 0;
464
465     /* Create the first extension block if it does not exist */
466     if (!ctx->cheader->SIT) {
467         code = GetExtentBlock(ctx, 0);
468         if (code)
469             ERROR_EXIT(code);
470     }
471
472     for (i = 0; i < MAXSERVERID + 1; i++) {
473         if ((ctx->hostaddress[i] & 0xff000000) == 0xff000000) {
474             if ((base = (ctx->hostaddress[i] >> 16) & 0xff) > VL_MAX_ADDREXTBLKS) {
475                 ERROR_EXIT(VL_INDEXERANGE);
476             }
477             if ((index = ctx->hostaddress[i] & 0x0000ffff) > VL_MHSRV_PERBLK) {
478                 ERROR_EXIT(VL_INDEXERANGE);
479             }
480             exp = &ctx->ex_addr[base][index];
481             tuuid = exp->ex_hostuuid;
482             afs_ntohuuid(&tuuid);
483             if (afs_uuid_equal(uuidp, &tuuid)) {
484                 *expp = exp;
485                 *basep = base;
486                 ERROR_EXIT(0);
487             }
488         }
489     }
490
491     if (createit) {
492         if (hostslot == -1) {
493             for (i = 0; i < MAXSERVERID + 1; i++) {
494                 if (!ctx->hostaddress[i])
495                     break;
496             }
497             if (i > MAXSERVERID)
498                 ERROR_EXIT(VL_REPSFULL);
499         } else {
500             i = hostslot;
501         }
502
503         for (base = 0; base < VL_MAX_ADDREXTBLKS; base++) {
504             if (!ctx->ex_addr[0]->ex_contaddrs[base]) {
505                 code = GetExtentBlock(ctx, base);
506                 if (code)
507                     ERROR_EXIT(code);
508             }
509             for (j = 1; j < VL_MHSRV_PERBLK; j++) {
510                 exp = &ctx->ex_addr[base][j];
511                 tuuid = exp->ex_hostuuid;
512                 afs_ntohuuid(&tuuid);
513                 if (afs_uuid_is_nil(&tuuid)) {
514                     tuuid = *uuidp;
515                     afs_htonuuid(&tuuid);
516                     exp->ex_hostuuid = tuuid;
517                     code =
518                         vlwrite(ctx->trans,
519                                 DOFFSET(ntohl(ctx->ex_addr[0]->ex_contaddrs[base]),
520                                         (char *)ctx->ex_addr[base], (char *)exp),
521                                 (char *)&tuuid, sizeof(tuuid));
522                     if (code)
523                         ERROR_EXIT(VL_IO);
524                     ctx->hostaddress[i] =
525                         0xff000000 | ((base << 16) & 0xff0000) | (j & 0xffff);
526                     *expp = exp;
527                     *basep = base;
528                     if (vldbversion != VLDBVERSION_4) {
529                         ctx->cheader->vital_header.vldbversion =
530                             htonl(VLDBVERSION_4);
531                         code = write_vital_vlheader(ctx);
532                         if (code)
533                             ERROR_EXIT(VL_IO);
534                     }
535                     ctx->cheader->IpMappedAddr[i] = htonl(ctx->hostaddress[i]);
536                     code =
537                         vlwrite(ctx->trans,
538                                 DOFFSET(0, ctx->cheader,
539                                         &ctx->cheader->IpMappedAddr[i]),
540                                 (char *)&ctx->cheader->IpMappedAddr[i],
541                                 sizeof(afs_int32));
542                     if (code)
543                         ERROR_EXIT(VL_IO);
544                     ERROR_EXIT(0);
545                 }
546             }
547         }
548         ERROR_EXIT(VL_REPSFULL);        /* No reason to utilize a new error code */
549     }
550
551   error_exit:
552     return error;
553 }
554
555 /* Allocate a free block of storage for entry, returning address of a new
556    zeroed entry (or zero if something is wrong).  */
557 afs_int32
558 AllocBlock(struct vl_ctx *ctx, struct nvlentry *tentry)
559 {
560     afs_int32 blockindex;
561
562     if (ctx->cheader->vital_header.freePtr) {
563         /* allocate this dude */
564         blockindex = ntohl(ctx->cheader->vital_header.freePtr);
565         if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(vlentry)))
566             return 0;
567         ctx->cheader->vital_header.freePtr = htonl(tentry->nextIdHash[0]);
568     } else {
569         /* hosed, nothing on free list, grow file */
570         blockindex = ntohl(ctx->cheader->vital_header.eofPtr);  /* remember this guy */
571         ctx->cheader->vital_header.eofPtr = htonl(blockindex + sizeof(vlentry));
572     }
573     ctx->cheader->vital_header.allocs++;
574     if (write_vital_vlheader(ctx))
575         return 0;
576     memset(tentry, 0, sizeof(nvlentry));        /* zero new entry */
577     return blockindex;
578 }
579
580
581 /* Free a block given its index.  It must already have been unthreaded. Returns zero for success or an error code on failure. */
582 int
583 FreeBlock(struct vl_ctx *ctx, afs_int32 blockindex)
584 {
585     struct nvlentry tentry;
586
587     /* check validity of blockindex just to be on the safe side */
588     if (!index_OK(ctx, blockindex))
589         return VL_BADINDEX;
590     memset(&tentry, 0, sizeof(nvlentry));
591     tentry.nextIdHash[0] = ctx->cheader->vital_header.freePtr;  /* already in network order */
592     tentry.flags = htonl(VLFREE);
593     ctx->cheader->vital_header.freePtr = htonl(blockindex);
594     if (vlwrite(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
595         return VL_IO;
596     ctx->cheader->vital_header.frees++;
597     if (write_vital_vlheader(ctx))
598         return VL_IO;
599     return 0;
600 }
601
602
603 /* Look for a block by volid and voltype (if not known use -1 which searches
604  * all 3 volid hash lists. Note that the linked lists are read in first from
605  * the database header.  If found read the block's contents into the area
606  * pointed to by tentry and return the block's index.  If not found return 0.
607  */
608 afs_int32
609 FindByID(struct vl_ctx *ctx, afs_uint32 volid, afs_int32 voltype,
610          struct nvlentry *tentry, afs_int32 *error)
611 {
612     afs_int32 typeindex, hashindex, blockindex;
613
614     *error = 0;
615     hashindex = IDHash(volid);
616     if (voltype == -1) {
617 /* Should we have one big hash table for volids as opposed to the three ones? */
618         for (typeindex = 0; typeindex < MAXTYPES; typeindex++) {
619             for (blockindex = ntohl(ctx->cheader->VolidHash[typeindex][hashindex]);
620                  blockindex != NULLO;
621                  blockindex = tentry->nextIdHash[typeindex]) {
622                 if (vlentryread
623                     (ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
624                     *error = VL_IO;
625                     return 0;
626                 }
627                 if (volid == tentry->volumeId[typeindex])
628                     return blockindex;
629             }
630         }
631     } else {
632         for (blockindex = ntohl(ctx->cheader->VolidHash[voltype][hashindex]);
633              blockindex != NULLO; blockindex = tentry->nextIdHash[voltype]) {
634             if (vlentryread
635                 (ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
636                 *error = VL_IO;
637                 return 0;
638             }
639             if (volid == tentry->volumeId[voltype])
640                 return blockindex;
641         }
642     }
643     return 0;                   /* no such entry */
644 }
645
646
647 /* Look for a block by volume name. If found read the block's contents into
648  * the area pointed to by tentry and return the block's index.  If not
649  * found return 0.
650  */
651 afs_int32
652 FindByName(struct vl_ctx *ctx, char *volname, struct nvlentry *tentry,
653            afs_int32 *error)
654 {
655     afs_int32 hashindex;
656     afs_int32 blockindex;
657     char tname[VL_MAXNAMELEN];
658
659     /* remove .backup or .readonly extensions for stupid backwards
660      * compatibility
661      */
662     hashindex = strlen(volname);        /* really string length */
663     if (hashindex >= 8 && strcmp(volname + hashindex - 7, ".backup") == 0) {
664         /* this is a backup volume */
665         strcpy(tname, volname);
666         tname[hashindex - 7] = 0;       /* zap extension */
667     } else if (hashindex >= 10
668                && strcmp(volname + hashindex - 9, ".readonly") == 0) {
669         /* this is a readonly volume */
670         strcpy(tname, volname);
671         tname[hashindex - 9] = 0;       /* zap extension */
672     } else
673         strcpy(tname, volname);
674
675     *error = 0;
676     hashindex = NameHash(tname);
677     for (blockindex = ntohl(ctx->cheader->VolnameHash[hashindex]);
678          blockindex != NULLO; blockindex = tentry->nextNameHash) {
679         if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
680             *error = VL_IO;
681             return 0;
682         }
683         if (!strcmp(tname, tentry->name))
684             return blockindex;
685     }
686     return 0;                   /* no such entry */
687 }
688
689 /**
690  * Returns whether or not any of the supplied volume IDs already exist
691  * in the vldb.
692  *
693  * @param ctx      transaction context
694  * @param ids      an array of volume IDs
695  * @param ids_len  the number of elements in the 'ids' array
696  * @param error    filled in with an error code in case of error
697  *
698  * @return whether any of the volume IDs are already used
699  *  @retval 1  at least one of the volume IDs is already used
700  *  @retval 0  none of the volume IDs are used, or an error occurred
701  */
702 int
703 EntryIDExists(struct vl_ctx *ctx, const afs_uint32 *ids,
704               afs_int32 ids_len, afs_int32 *error)
705 {
706     afs_int32 typeindex;
707     struct nvlentry tentry;
708
709     *error = 0;
710
711     for (typeindex = 0; typeindex < ids_len; typeindex++) {
712         if (ids[typeindex]
713             && FindByID(ctx, ids[typeindex], -1, &tentry, error)) {
714
715             return 1;
716         } else if (*error) {
717             return 0;
718         }
719     }
720
721     return 0;
722 }
723
724 /**
725  * Finds the next range of unused volume IDs in the vldb.
726  *
727  * @param ctx       transaction context
728  * @param maxvolid  the current max vol ID, and where to start looking
729  *                  for an unused volume ID range
730  * @param bump      how many volume IDs we need to be unused
731  * @param error     filled in with an error code in case of error
732  *
733  * @return the next volume ID 'volid' such that the range
734  *         [volid, volid+bump) of volume IDs is unused, or 0 if there's
735  *         an error
736  */
737 afs_uint32
738 NextUnusedID(struct vl_ctx *ctx, afs_uint32 maxvolid, afs_uint32 bump,
739              afs_int32 *error)
740 {
741     struct nvlentry tentry;
742     afs_uint32 id;
743     afs_uint32 nfree;
744
745     *error = 0;
746
747      /* we simply start at the given maxvolid, keep a running tally of
748       * how many free volume IDs we've seen in a row, and return when
749       * we've seen 'bump' unused IDs in a row */
750     for (id = maxvolid, nfree = 0; nfree < bump; ++id) {
751         if (FindByID(ctx, id, -1, &tentry, error)) {
752             nfree = 0;
753         } else if (*error) {
754             return 0;
755         } else {
756             ++nfree;
757         }
758     }
759
760     /* 'id' is now at the end of the [maxvolid,maxvolid+bump) range,
761      * but we need to return the first unused id, so subtract the
762      * number of current running free IDs to get the beginning */
763     return id - nfree;
764 }
765
766 int
767 HashNDump(struct vl_ctx *ctx, int hashindex)
768 {
769     int i = 0;
770     int blockindex;
771     struct nvlentry tentry;
772
773     for (blockindex = ntohl(ctx->cheader->VolnameHash[hashindex]);
774          blockindex != NULLO; blockindex = tentry.nextNameHash) {
775         if (vlentryread(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
776             return 0;
777         i++;
778         VLog(0,
779              ("[%d]#%d: %10d %d %d (%s)\n", hashindex, i, tentry.volumeId[0],
780               tentry.nextIdHash[0], tentry.nextNameHash, tentry.name));
781     }
782     return 0;
783 }
784
785
786 int
787 HashIdDump(struct vl_ctx *ctx, int hashindex)
788 {
789     int i = 0;
790     int blockindex;
791     struct nvlentry tentry;
792
793     for (blockindex = ntohl(ctx->cheader->VolidHash[0][hashindex]);
794          blockindex != NULLO; blockindex = tentry.nextIdHash[0]) {
795         if (vlentryread(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
796             return 0;
797         i++;
798         VLog(0,
799              ("[%d]#%d: %10d %d %d (%s)\n", hashindex, i, tentry.volumeId[0],
800               tentry.nextIdHash[0], tentry.nextNameHash, tentry.name));
801     }
802     return 0;
803 }
804
805
806 /* Add a block to the hash table given a pointer to the block and its index.
807  * The block is threaded onto both hash tables and written to disk.  The
808  * routine returns zero if there were no errors.
809  */
810 int
811 ThreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
812               struct nvlentry *tentry)
813 {
814     int errorcode;
815
816     if (!index_OK(ctx, blockindex))
817         return VL_BADINDEX;
818     /* Insert into volid's hash linked list */
819     if ((errorcode = HashVolid(ctx, RWVOL, blockindex, tentry)))
820         return errorcode;
821
822     /* For rw entries we also enter the RO and BACK volume ids (if they
823      * exist) in the hash tables; note all there volids (RW, RO, BACK)
824      * should not be hashed yet! */
825     if (tentry->volumeId[ROVOL]) {
826         if ((errorcode = HashVolid(ctx, ROVOL, blockindex, tentry)))
827             return errorcode;
828     }
829     if (tentry->volumeId[BACKVOL]) {
830         if ((errorcode = HashVolid(ctx, BACKVOL, blockindex, tentry)))
831             return errorcode;
832     }
833
834     /* Insert into volname's hash linked list */
835     HashVolname(ctx, blockindex, tentry);
836
837     /* Update cheader entry */
838     if (write_vital_vlheader(ctx))
839         return VL_IO;
840
841     /* Update hash list pointers in the entry itself */
842     if (vlentrywrite(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry)))
843         return VL_IO;
844     return 0;
845 }
846
847
848 /* Remove a block from both the hash tables.  If success return 0, else
849  * return an error code. */
850 int
851 UnthreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
852                 struct nvlentry *aentry)
853 {
854     afs_int32 errorcode, typeindex;
855
856     if (!index_OK(ctx, blockindex))
857         return VL_BADINDEX;
858     if ((errorcode = UnhashVolid(ctx, RWVOL, blockindex, aentry)))
859         return errorcode;
860
861     /* Take the RO/RW entries of their respective hash linked lists. */
862     for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
863         if ((errorcode = UnhashVolid(ctx, typeindex, blockindex, aentry)))
864             return errorcode;
865     }
866
867     /* Take it out of the Volname hash list */
868     if ((errorcode = UnhashVolname(ctx, blockindex, aentry)))
869         return errorcode;
870
871     /* Update cheader entry */
872     write_vital_vlheader(ctx);
873
874     return 0;
875 }
876
877 /* cheader must have be read before this routine is called. */
878 int
879 HashVolid(struct vl_ctx *ctx, afs_int32 voltype, afs_int32 blockindex,
880           struct nvlentry *tentry)
881 {
882     afs_int32 hashindex, errorcode;
883     struct nvlentry ventry;
884
885     if (FindByID
886         (ctx, tentry->volumeId[voltype], voltype, &ventry, &errorcode))
887         return VL_IDALREADYHASHED;
888     else if (errorcode)
889         return errorcode;
890     hashindex = IDHash(tentry->volumeId[voltype]);
891     tentry->nextIdHash[voltype] =
892         ntohl(ctx->cheader->VolidHash[voltype][hashindex]);
893     ctx->cheader->VolidHash[voltype][hashindex] = htonl(blockindex);
894     if (vlwrite
895         (ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->VolidHash[voltype][hashindex]),
896          (char *)&ctx->cheader->VolidHash[voltype][hashindex], sizeof(afs_int32)))
897         return VL_IO;
898     return 0;
899 }
900
901
902 /* cheader must have be read before this routine is called. */
903 int
904 UnhashVolid(struct vl_ctx *ctx, afs_int32 voltype, afs_int32 blockindex,
905             struct nvlentry *aentry)
906 {
907     int hashindex, nextblockindex, prevblockindex;
908     struct nvlentry tentry;
909     afs_int32 code;
910     afs_int32 temp;
911
912     if (aentry->volumeId[voltype] == NULLO)     /* Assume no volume id */
913         return 0;
914     /* Take it out of the VolId[voltype] hash list */
915     hashindex = IDHash(aentry->volumeId[voltype]);
916     nextblockindex = ntohl(ctx->cheader->VolidHash[voltype][hashindex]);
917     if (nextblockindex == blockindex) {
918         /* First on the hash list; just adjust pointers */
919         ctx->cheader->VolidHash[voltype][hashindex] =
920             htonl(aentry->nextIdHash[voltype]);
921         code =
922             vlwrite(ctx->trans,
923                     DOFFSET(0, ctx->cheader,
924                             &ctx->cheader->VolidHash[voltype][hashindex]),
925                     (char *)&ctx->cheader->VolidHash[voltype][hashindex],
926                     sizeof(afs_int32));
927         if (code)
928             return VL_IO;
929     } else {
930         while (nextblockindex != blockindex) {
931             prevblockindex = nextblockindex;    /* always done once */
932             if (vlentryread
933                 (ctx->trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
934                 return VL_IO;
935             if ((nextblockindex = tentry.nextIdHash[voltype]) == NULLO)
936                 return VL_NOENT;
937         }
938         temp = tentry.nextIdHash[voltype] = aentry->nextIdHash[voltype];
939         temp = htonl(temp);     /* convert to network byte order before writing */
940         if (vlwrite
941             (ctx->trans,
942              DOFFSET(prevblockindex, &tentry, &tentry.nextIdHash[voltype]),
943              (char *)&temp, sizeof(afs_int32)))
944             return VL_IO;
945     }
946     aentry->nextIdHash[voltype] = 0;
947     return 0;
948 }
949
950
951 int
952 HashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
953             struct nvlentry *aentry)
954 {
955     afs_int32 hashindex;
956     afs_int32 code;
957
958     /* Insert into volname's hash linked list */
959     hashindex = NameHash(aentry->name);
960     aentry->nextNameHash = ntohl(ctx->cheader->VolnameHash[hashindex]);
961     ctx->cheader->VolnameHash[hashindex] = htonl(blockindex);
962     code =
963         vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->VolnameHash[hashindex]),
964                 (char *)&ctx->cheader->VolnameHash[hashindex], sizeof(afs_int32));
965     if (code)
966         return VL_IO;
967     return 0;
968 }
969
970
971 int
972 UnhashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
973               struct nvlentry *aentry)
974 {
975     afs_int32 hashindex, nextblockindex, prevblockindex;
976     struct nvlentry tentry;
977     afs_int32 temp;
978
979     /* Take it out of the Volname hash list */
980     hashindex = NameHash(aentry->name);
981     nextblockindex = ntohl(ctx->cheader->VolnameHash[hashindex]);
982     if (nextblockindex == blockindex) {
983         /* First on the hash list; just adjust pointers */
984         ctx->cheader->VolnameHash[hashindex] = htonl(aentry->nextNameHash);
985         if (vlwrite
986             (ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->VolnameHash[hashindex]),
987              (char *)&ctx->cheader->VolnameHash[hashindex], sizeof(afs_int32)))
988             return VL_IO;
989     } else {
990         while (nextblockindex != blockindex) {
991             prevblockindex = nextblockindex;    /* always done at least once */
992             if (vlentryread
993                 (ctx->trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
994                 return VL_IO;
995             if ((nextblockindex = tentry.nextNameHash) == NULLO)
996                 return VL_NOENT;
997         }
998         tentry.nextNameHash = aentry->nextNameHash;
999         temp = htonl(tentry.nextNameHash);
1000         if (vlwrite
1001             (ctx->trans, DOFFSET(prevblockindex, &tentry, &tentry.nextNameHash),
1002              (char *)&temp, sizeof(afs_int32)))
1003             return VL_IO;
1004     }
1005     aentry->nextNameHash = 0;
1006     return 0;
1007 }
1008
1009
1010 /* Returns the vldb entry tentry at offset index; remaining is the number of
1011  * entries left; the routine also returns the index of the next sequential
1012  * entry in the vldb
1013  */
1014
1015 afs_int32
1016 NextEntry(struct vl_ctx *ctx, afs_int32 blockindex,
1017           struct nvlentry *tentry, afs_int32 *remaining)
1018 {
1019     afs_int32 lastblockindex;
1020
1021     if (blockindex == 0)        /* get first one */
1022         blockindex = sizeof(*ctx->cheader);
1023     else {
1024         if (!index_OK(ctx, blockindex)) {
1025             *remaining = -1;    /* error */
1026             return 0;
1027         }
1028         blockindex += sizeof(nvlentry);
1029     }
1030     /* now search for the first entry that isn't free */
1031     for (lastblockindex = ntohl(ctx->cheader->vital_header.eofPtr);
1032          blockindex < lastblockindex;) {
1033         if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
1034             *remaining = -1;
1035             return 0;
1036         }
1037         if (tentry->flags == VLCONTBLOCK) {
1038             /*
1039              * This is a special mh extension block just simply skip over it
1040              */
1041             blockindex += VL_ADDREXTBLK_SIZE;
1042         } else {
1043             if (tentry->flags != VLFREE) {
1044                 /* estimate remaining number of entries, not including this one */
1045                 *remaining =
1046                     (lastblockindex - blockindex) / sizeof(nvlentry) - 1;
1047                 return blockindex;
1048             }
1049             blockindex += sizeof(nvlentry);
1050         }
1051     }
1052     *remaining = 0;             /* no more entries */
1053     return 0;
1054 }
1055
1056
1057 /* Routine to verify that index is a legal offset to a vldb entry in the
1058  * table
1059  */
1060 static int
1061 index_OK(struct vl_ctx *ctx, afs_int32 blockindex)
1062 {
1063     if ((blockindex < sizeof(*ctx->cheader))
1064         || (blockindex >= ntohl(ctx->cheader->vital_header.eofPtr)))
1065         return 0;
1066     return 1;
1067 }
1068
1069 /* makes a deep copy of src_ex into dst_ex */
1070 static int
1071 vlexcpy(struct extentaddr **dst_ex, struct extentaddr **src_ex)
1072 {
1073     int i;
1074     for (i = 0; i < VL_MAX_ADDREXTBLKS; i++) {
1075         if (src_ex[i]) {
1076             if (!dst_ex[i]) {
1077                 dst_ex[i] = malloc(VL_ADDREXTBLK_SIZE);
1078             }
1079             if (!dst_ex[i]) {
1080                 return VL_NOMEM;
1081             }
1082             memcpy(dst_ex[i], src_ex[i], VL_ADDREXTBLK_SIZE);
1083
1084         } else if (dst_ex[i]) {
1085             /* we have no src, but we have a dst... meaning, this block
1086              * has gone away */
1087             free(dst_ex[i]);
1088             dst_ex[i] = NULL;
1089         }
1090     }
1091     return 0;
1092 }
1093
1094 int
1095 vlsetcache(struct vl_ctx *ctx, int locktype)
1096 {
1097     if (locktype == LOCKREAD) {
1098         ctx->hostaddress = rd_HostAddress;
1099         ctx->ex_addr = rd_ex_addr;
1100         ctx->cheader = &rd_cheader;
1101         return 0;
1102     } else {
1103         memcpy(wr_HostAddress, rd_HostAddress, sizeof(wr_HostAddress));
1104         memcpy(&wr_cheader, &rd_cheader, sizeof(wr_cheader));
1105
1106         ctx->hostaddress = wr_HostAddress;
1107         ctx->ex_addr = wr_ex_addr;
1108         ctx->cheader = &wr_cheader;
1109
1110         return vlexcpy(wr_ex_addr, rd_ex_addr);
1111     }
1112 }
1113
1114 int
1115 vlsynccache(void)
1116 {
1117     memcpy(rd_HostAddress, wr_HostAddress, sizeof(rd_HostAddress));
1118     memcpy(&rd_cheader, &wr_cheader, sizeof(rd_cheader));
1119     return vlexcpy(rd_ex_addr, wr_ex_addr);
1120 }