mirror of
https://git.openafs.org/openafs.git
synced 2025-01-20 07:51:00 +00:00
vlserver: Add a struct for trans-specific data
Instead of passing a ubik_trans pointer to many functions inside the vlserver, pass a vlserver-defined vl_ctx struct, so we can add new things to keep track of in a transaction that are not part of ubik. Change-Id: Icf8df6bfdf8960134493ab7f379f0f65b92bdb5a Reviewed-on: http://gerrit.openafs.org/2104 Reviewed-by: Derrick Brashear <shadow@dementia.org> Tested-by: Derrick Brashear <shadow@dementia.org>
This commit is contained in:
Andrew Deason
Derrick Brashear
parent
fd7f7469bd
commit
3bf0350218
File diff suppressed because it is too large
Load Diff
@ -87,20 +87,20 @@ static void *
|
||||
CheckSignal(void *unused)
|
||||
{
|
||||
int i, errorcode;
|
||||
struct ubik_trans *trans;
|
||||
struct vl_ctx ctx;
|
||||
|
||||
if ((errorcode =
|
||||
Init_VLdbase(&trans, LOCKREAD, VLGETSTATS - VL_LOWEST_OPCODE)))
|
||||
Init_VLdbase(&ctx, LOCKREAD, VLGETSTATS - VL_LOWEST_OPCODE)))
|
||||
return (void *)(intptr_t)errorcode;
|
||||
VLog(0, ("Dump name hash table out\n"));
|
||||
for (i = 0; i < HASHSIZE; i++) {
|
||||
HashNDump(trans, i);
|
||||
HashNDump(&ctx, i);
|
||||
}
|
||||
VLog(0, ("Dump id hash table out\n"));
|
||||
for (i = 0; i < HASHSIZE; i++) {
|
||||
HashIdDump(trans, i);
|
||||
HashIdDump(&ctx, i);
|
||||
}
|
||||
return ((void *)(intptr_t)ubik_EndTrans(trans));
|
||||
return ((void *)(intptr_t)ubik_EndTrans(ctx.trans));
|
||||
} /*CheckSignal */
|
||||
|
||||
|
||||
|
||||
@ -10,46 +10,53 @@
|
||||
#ifndef _VLSERVER_INTERNAL_H
|
||||
#define _VLSERVER_INTERNAL_H
|
||||
|
||||
/**
|
||||
* context for a transaction of a single VL operation.
|
||||
*/
|
||||
struct vl_ctx {
|
||||
struct ubik_trans *trans;
|
||||
};
|
||||
|
||||
/* vlprocs.c */
|
||||
extern int Init_VLdbase(struct ubik_trans **trans, int locktype, int this_op);
|
||||
extern int Init_VLdbase(struct vl_ctx *ctx, int locktype, int this_op);
|
||||
|
||||
/* vlutils.c */
|
||||
extern afs_int32 vlwrite(struct ubik_trans *trans, afs_int32 offset,
|
||||
void *buffer, afs_int32 length);
|
||||
extern afs_int32 vlentrywrite(struct ubik_trans *trans, afs_int32 offset,
|
||||
void *buffer, afs_int32 length);
|
||||
extern int write_vital_vlheader(struct ubik_trans *trans);
|
||||
extern int write_vital_vlheader(struct vl_ctx *ctx);
|
||||
extern afs_int32 readExtents(struct ubik_trans *trans);
|
||||
extern afs_int32 CheckInit(struct ubik_trans *trans, int builddb);
|
||||
extern afs_int32 AllocBlock(struct ubik_trans *trans,
|
||||
extern afs_int32 AllocBlock(struct vl_ctx *ctx,
|
||||
struct nvlentry *tentry);
|
||||
extern afs_int32 FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
extern afs_int32 FindExtentBlock(struct vl_ctx *ctx, afsUUID *uuidp,
|
||||
afs_int32 createit, afs_int32 hostslot,
|
||||
struct extentaddr **expp, afs_int32 *basep);
|
||||
extern afs_int32 FindByID(struct ubik_trans *trans, afs_uint32 volid,
|
||||
extern afs_int32 FindByID(struct vl_ctx *ctx, afs_uint32 volid,
|
||||
afs_int32 voltype, struct nvlentry *tentry,
|
||||
afs_int32 *error);
|
||||
extern afs_int32 FindByName(struct ubik_trans *trans, char *volname,
|
||||
extern afs_int32 FindByName(struct vl_ctx *ctx, char *volname,
|
||||
struct nvlentry *tentry, afs_int32 *error);
|
||||
extern int EntryIDExists(struct ubik_trans *trans, const afs_uint32 *ids,
|
||||
extern int EntryIDExists(struct vl_ctx *ctx, const afs_uint32 *ids,
|
||||
afs_int32 ids_len, afs_int32 *error);
|
||||
extern afs_uint32 NextUnusedID(struct ubik_trans *trans, afs_uint32 maxvolid,
|
||||
extern afs_uint32 NextUnusedID(struct vl_ctx *ctx, afs_uint32 maxvolid,
|
||||
afs_uint32 bump, afs_int32 *error);
|
||||
extern int HashNDump(struct ubik_trans *trans, int hashindex);
|
||||
extern int HashIdDump(struct ubik_trans *trans, int hashindex);
|
||||
extern int ThreadVLentry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
extern int HashNDump(struct vl_ctx *ctx, int hashindex);
|
||||
extern int HashIdDump(struct vl_ctx *ctx, int hashindex);
|
||||
extern int ThreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *tentry);
|
||||
extern int UnthreadVLentry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
extern int UnthreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *aentry);
|
||||
extern int HashVolid(struct ubik_trans *trans, afs_int32 voltype,
|
||||
extern int HashVolid(struct vl_ctx *ctx, afs_int32 voltype,
|
||||
afs_int32 blockindex, struct nvlentry *tentry);
|
||||
extern int UnhashVolid(struct ubik_trans *trans, afs_int32 voltype,
|
||||
extern int UnhashVolid(struct vl_ctx *ctx, afs_int32 voltype,
|
||||
afs_int32 blockindex, struct nvlentry *aentry);
|
||||
extern int HashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
extern int HashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *aentry);
|
||||
extern int UnhashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
extern int UnhashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *aentry);
|
||||
extern afs_int32 NextEntry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
extern afs_int32 NextEntry(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *tentry, afs_int32 *remaining);
|
||||
extern int FreeBlock(struct ubik_trans *trans, afs_int32 blockindex);
|
||||
extern int FreeBlock(struct vl_ctx *ctx, afs_int32 blockindex);
|
||||
#endif
|
||||
|
||||
@ -33,7 +33,7 @@ struct extentaddr extentaddr;
|
||||
extern struct extentaddr *ex_addr[];
|
||||
int vldbversion = 0;
|
||||
|
||||
static int index_OK(struct ubik_trans *trans, afs_int32 blockindex);
|
||||
static int index_OK(struct vl_ctx *ctx, afs_int32 blockindex);
|
||||
|
||||
#define ERROR_EXIT(code) {error=(code); goto error_exit;}
|
||||
|
||||
@ -188,10 +188,10 @@ vlentryread(struct ubik_trans *trans, afs_int32 offset, char *buffer,
|
||||
|
||||
/* Convenient write of small critical vldb header info to the database. */
|
||||
int
|
||||
write_vital_vlheader(struct ubik_trans *trans)
|
||||
write_vital_vlheader(struct vl_ctx *ctx)
|
||||
{
|
||||
if (vlwrite
|
||||
(trans, 0, (char *)&cheader.vital_header, sizeof(vital_vlheader)))
|
||||
(ctx->trans, 0, (char *)&cheader.vital_header, sizeof(vital_vlheader)))
|
||||
return VL_IO;
|
||||
return 0;
|
||||
}
|
||||
@ -391,7 +391,7 @@ CheckInit(struct ubik_trans *trans, int builddb)
|
||||
|
||||
|
||||
afs_int32
|
||||
GetExtentBlock(struct ubik_trans *trans, afs_int32 base)
|
||||
GetExtentBlock(struct vl_ctx *ctx, register afs_int32 base)
|
||||
{
|
||||
afs_int32 blockindex, code, error = 0;
|
||||
|
||||
@ -412,7 +412,7 @@ GetExtentBlock(struct ubik_trans *trans, afs_int32 base)
|
||||
ex_addr[base]->ex_flags = htonl(VLCONTBLOCK);
|
||||
blockindex = ntohl(cheader.vital_header.eofPtr);
|
||||
code =
|
||||
vlwrite(trans, blockindex, (char *)ex_addr[base],
|
||||
vlwrite(ctx->trans, blockindex, (char *)ex_addr[base],
|
||||
VL_ADDREXTBLK_SIZE);
|
||||
if (code)
|
||||
ERROR_EXIT(VL_IO);
|
||||
@ -420,7 +420,7 @@ GetExtentBlock(struct ubik_trans *trans, afs_int32 base)
|
||||
/* Update the cheader.vitalheader structure on disk */
|
||||
cheader.vital_header.eofPtr = blockindex + VL_ADDREXTBLK_SIZE;
|
||||
cheader.vital_header.eofPtr = htonl(cheader.vital_header.eofPtr);
|
||||
code = write_vital_vlheader(trans);
|
||||
code = write_vital_vlheader(ctx);
|
||||
if (code)
|
||||
ERROR_EXIT(VL_IO);
|
||||
|
||||
@ -428,7 +428,7 @@ GetExtentBlock(struct ubik_trans *trans, afs_int32 base)
|
||||
if (base == 0) {
|
||||
cheader.SIT = htonl(blockindex);
|
||||
code =
|
||||
vlwrite(trans, DOFFSET(0, &cheader, &cheader.SIT),
|
||||
vlwrite(ctx->trans, DOFFSET(0, &cheader, &cheader.SIT),
|
||||
(char *)&cheader.SIT, sizeof(cheader.SIT));
|
||||
if (code)
|
||||
ERROR_EXIT(VL_IO);
|
||||
@ -437,7 +437,7 @@ GetExtentBlock(struct ubik_trans *trans, afs_int32 base)
|
||||
/* Write the address of this extension block into the base extension block */
|
||||
ex_addr[0]->ex_contaddrs[base] = htonl(blockindex);
|
||||
code =
|
||||
vlwrite(trans, ntohl(cheader.SIT), ex_addr[0],
|
||||
vlwrite(ctx->trans, ntohl(cheader.SIT), ex_addr[0],
|
||||
sizeof(struct extentaddr));
|
||||
if (code)
|
||||
ERROR_EXIT(VL_IO);
|
||||
@ -449,7 +449,7 @@ GetExtentBlock(struct ubik_trans *trans, afs_int32 base)
|
||||
|
||||
|
||||
afs_int32
|
||||
FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
FindExtentBlock(struct vl_ctx *ctx, afsUUID *uuidp,
|
||||
afs_int32 createit, afs_int32 hostslot,
|
||||
struct extentaddr **expp, afs_int32 *basep)
|
||||
{
|
||||
@ -462,7 +462,7 @@ FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
|
||||
/* Create the first extension block if it does not exist */
|
||||
if (!cheader.SIT) {
|
||||
code = GetExtentBlock(trans, 0);
|
||||
code = GetExtentBlock(ctx, 0);
|
||||
if (code)
|
||||
ERROR_EXIT(code);
|
||||
}
|
||||
@ -500,7 +500,7 @@ FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
|
||||
for (base = 0; base < VL_MAX_ADDREXTBLKS; base++) {
|
||||
if (!ex_addr[0]->ex_contaddrs[base]) {
|
||||
code = GetExtentBlock(trans, base);
|
||||
code = GetExtentBlock(ctx, base);
|
||||
if (code)
|
||||
ERROR_EXIT(code);
|
||||
}
|
||||
@ -513,7 +513,7 @@ FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
afs_htonuuid(&tuuid);
|
||||
exp->ex_hostuuid = tuuid;
|
||||
code =
|
||||
vlwrite(trans,
|
||||
vlwrite(ctx->trans,
|
||||
DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[base]),
|
||||
(char *)ex_addr[base], (char *)exp),
|
||||
(char *)&tuuid, sizeof(tuuid));
|
||||
@ -526,13 +526,13 @@ FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
if (vldbversion != VLDBVERSION_4) {
|
||||
cheader.vital_header.vldbversion =
|
||||
htonl(VLDBVERSION_4);
|
||||
code = write_vital_vlheader(trans);
|
||||
code = write_vital_vlheader(ctx);
|
||||
if (code)
|
||||
ERROR_EXIT(VL_IO);
|
||||
}
|
||||
cheader.IpMappedAddr[i] = htonl(HostAddress[i]);
|
||||
code =
|
||||
vlwrite(trans,
|
||||
vlwrite(ctx->trans,
|
||||
DOFFSET(0, &cheader,
|
||||
&cheader.IpMappedAddr[i]),
|
||||
(char *)&cheader.IpMappedAddr[i],
|
||||
@ -553,14 +553,14 @@ FindExtentBlock(struct ubik_trans *trans, afsUUID *uuidp,
|
||||
/* Allocate a free block of storage for entry, returning address of a new
|
||||
zeroed entry (or zero if something is wrong). */
|
||||
afs_int32
|
||||
AllocBlock(struct ubik_trans *trans, struct nvlentry *tentry)
|
||||
AllocBlock(struct vl_ctx *ctx, struct nvlentry *tentry)
|
||||
{
|
||||
afs_int32 blockindex;
|
||||
|
||||
if (cheader.vital_header.freePtr) {
|
||||
/* allocate this dude */
|
||||
blockindex = ntohl(cheader.vital_header.freePtr);
|
||||
if (vlentryread(trans, blockindex, (char *)tentry, sizeof(vlentry)))
|
||||
if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(vlentry)))
|
||||
return 0;
|
||||
cheader.vital_header.freePtr = htonl(tentry->nextIdHash[0]);
|
||||
} else {
|
||||
@ -569,7 +569,7 @@ AllocBlock(struct ubik_trans *trans, struct nvlentry *tentry)
|
||||
cheader.vital_header.eofPtr = htonl(blockindex + sizeof(vlentry));
|
||||
}
|
||||
cheader.vital_header.allocs++;
|
||||
if (write_vital_vlheader(trans))
|
||||
if (write_vital_vlheader(ctx))
|
||||
return 0;
|
||||
memset(tentry, 0, sizeof(nvlentry)); /* zero new entry */
|
||||
return blockindex;
|
||||
@ -578,21 +578,21 @@ AllocBlock(struct ubik_trans *trans, struct nvlentry *tentry)
|
||||
|
||||
/* Free a block given its index. It must already have been unthreaded. Returns zero for success or an error code on failure. */
|
||||
int
|
||||
FreeBlock(struct ubik_trans *trans, afs_int32 blockindex)
|
||||
FreeBlock(struct vl_ctx *ctx, afs_int32 blockindex)
|
||||
{
|
||||
struct nvlentry tentry;
|
||||
|
||||
/* check validity of blockindex just to be on the safe side */
|
||||
if (!index_OK(trans, blockindex))
|
||||
if (!index_OK(ctx, blockindex))
|
||||
return VL_BADINDEX;
|
||||
memset(&tentry, 0, sizeof(nvlentry));
|
||||
tentry.nextIdHash[0] = cheader.vital_header.freePtr; /* already in network order */
|
||||
tentry.flags = htonl(VLFREE);
|
||||
cheader.vital_header.freePtr = htonl(blockindex);
|
||||
if (vlwrite(trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
if (vlwrite(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
return VL_IO;
|
||||
cheader.vital_header.frees++;
|
||||
if (write_vital_vlheader(trans))
|
||||
if (write_vital_vlheader(ctx))
|
||||
return VL_IO;
|
||||
return 0;
|
||||
}
|
||||
@ -604,7 +604,7 @@ FreeBlock(struct ubik_trans *trans, afs_int32 blockindex)
|
||||
* pointed to by tentry and return the block's index. If not found return 0.
|
||||
*/
|
||||
afs_int32
|
||||
FindByID(struct ubik_trans *trans, afs_uint32 volid, afs_int32 voltype,
|
||||
FindByID(struct vl_ctx *ctx, afs_uint32 volid, afs_int32 voltype,
|
||||
struct nvlentry *tentry, afs_int32 *error)
|
||||
{
|
||||
afs_int32 typeindex, hashindex, blockindex;
|
||||
@ -618,7 +618,7 @@ FindByID(struct ubik_trans *trans, afs_uint32 volid, afs_int32 voltype,
|
||||
blockindex != NULLO;
|
||||
blockindex = tentry->nextIdHash[typeindex]) {
|
||||
if (vlentryread
|
||||
(trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
*error = VL_IO;
|
||||
return 0;
|
||||
}
|
||||
@ -630,7 +630,7 @@ FindByID(struct ubik_trans *trans, afs_uint32 volid, afs_int32 voltype,
|
||||
for (blockindex = ntohl(cheader.VolidHash[voltype][hashindex]);
|
||||
blockindex != NULLO; blockindex = tentry->nextIdHash[voltype]) {
|
||||
if (vlentryread
|
||||
(trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
*error = VL_IO;
|
||||
return 0;
|
||||
}
|
||||
@ -647,7 +647,7 @@ FindByID(struct ubik_trans *trans, afs_uint32 volid, afs_int32 voltype,
|
||||
* found return 0.
|
||||
*/
|
||||
afs_int32
|
||||
FindByName(struct ubik_trans *trans, char *volname, struct nvlentry *tentry,
|
||||
FindByName(struct vl_ctx *ctx, char *volname, struct nvlentry *tentry,
|
||||
afs_int32 *error)
|
||||
{
|
||||
afs_int32 hashindex;
|
||||
@ -674,7 +674,7 @@ FindByName(struct ubik_trans *trans, char *volname, struct nvlentry *tentry,
|
||||
hashindex = NameHash(tname);
|
||||
for (blockindex = ntohl(cheader.VolnameHash[hashindex]);
|
||||
blockindex != NULLO; blockindex = tentry->nextNameHash) {
|
||||
if (vlentryread(trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
*error = VL_IO;
|
||||
return 0;
|
||||
}
|
||||
@ -688,7 +688,7 @@ FindByName(struct ubik_trans *trans, char *volname, struct nvlentry *tentry,
|
||||
* Returns whether or not any of the supplied volume IDs already exist
|
||||
* in the vldb.
|
||||
*
|
||||
* @param trans the ubik transaction
|
||||
* @param ctx transaction context
|
||||
* @param ids an array of volume IDs
|
||||
* @param ids_len the number of elements in the 'ids' array
|
||||
* @param error filled in with an error code in case of error
|
||||
@ -698,7 +698,7 @@ FindByName(struct ubik_trans *trans, char *volname, struct nvlentry *tentry,
|
||||
* @retval 0 none of the volume IDs are used, or an error occurred
|
||||
*/
|
||||
int
|
||||
EntryIDExists(struct ubik_trans *trans, const afs_uint32 *ids,
|
||||
EntryIDExists(struct vl_ctx *ctx, const afs_uint32 *ids,
|
||||
afs_int32 ids_len, afs_int32 *error)
|
||||
{
|
||||
afs_int32 typeindex;
|
||||
@ -708,7 +708,7 @@ EntryIDExists(struct ubik_trans *trans, const afs_uint32 *ids,
|
||||
|
||||
for (typeindex = 0; typeindex < ids_len; typeindex++) {
|
||||
if (ids[typeindex]
|
||||
&& FindByID(trans, ids[typeindex], -1, &tentry, error)) {
|
||||
&& FindByID(ctx, ids[typeindex], -1, &tentry, error)) {
|
||||
|
||||
return 1;
|
||||
} else if (*error) {
|
||||
@ -722,7 +722,7 @@ EntryIDExists(struct ubik_trans *trans, const afs_uint32 *ids,
|
||||
/**
|
||||
* Finds the next range of unused volume IDs in the vldb.
|
||||
*
|
||||
* @param trans the ubik transaction
|
||||
* @param ctx transaction context
|
||||
* @param maxvolid the current max vol ID, and where to start looking
|
||||
* for an unused volume ID range
|
||||
* @param bump how many volume IDs we need to be unused
|
||||
@ -733,7 +733,7 @@ EntryIDExists(struct ubik_trans *trans, const afs_uint32 *ids,
|
||||
* an error
|
||||
*/
|
||||
afs_uint32
|
||||
NextUnusedID(struct ubik_trans *trans, afs_uint32 maxvolid, afs_uint32 bump,
|
||||
NextUnusedID(struct vl_ctx *ctx, afs_uint32 maxvolid, afs_uint32 bump,
|
||||
afs_int32 *error)
|
||||
{
|
||||
struct nvlentry tentry;
|
||||
@ -746,7 +746,7 @@ NextUnusedID(struct ubik_trans *trans, afs_uint32 maxvolid, afs_uint32 bump,
|
||||
* how many free volume IDs we've seen in a row, and return when
|
||||
* we've seen 'bump' unused IDs in a row */
|
||||
for (id = maxvolid, nfree = 0; nfree < bump; ++id) {
|
||||
if (FindByID(trans, id, -1, &tentry, error)) {
|
||||
if (FindByID(ctx, id, -1, &tentry, error)) {
|
||||
nfree = 0;
|
||||
} else if (*error) {
|
||||
return 0;
|
||||
@ -762,7 +762,7 @@ NextUnusedID(struct ubik_trans *trans, afs_uint32 maxvolid, afs_uint32 bump,
|
||||
}
|
||||
|
||||
int
|
||||
HashNDump(struct ubik_trans *trans, int hashindex)
|
||||
HashNDump(struct vl_ctx *ctx, int hashindex)
|
||||
{
|
||||
int i = 0;
|
||||
int blockindex;
|
||||
@ -770,7 +770,7 @@ HashNDump(struct ubik_trans *trans, int hashindex)
|
||||
|
||||
for (blockindex = ntohl(cheader.VolnameHash[hashindex]);
|
||||
blockindex != NULLO; blockindex = tentry.nextNameHash) {
|
||||
if (vlentryread(trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
if (vlentryread(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
return 0;
|
||||
i++;
|
||||
VLog(0,
|
||||
@ -782,7 +782,7 @@ HashNDump(struct ubik_trans *trans, int hashindex)
|
||||
|
||||
|
||||
int
|
||||
HashIdDump(struct ubik_trans *trans, int hashindex)
|
||||
HashIdDump(struct vl_ctx *ctx, int hashindex)
|
||||
{
|
||||
int i = 0;
|
||||
int blockindex;
|
||||
@ -790,7 +790,7 @@ HashIdDump(struct ubik_trans *trans, int hashindex)
|
||||
|
||||
for (blockindex = ntohl(cheader.VolidHash[0][hashindex]);
|
||||
blockindex != NULLO; blockindex = tentry.nextIdHash[0]) {
|
||||
if (vlentryread(trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
if (vlentryread(ctx->trans, blockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
return 0;
|
||||
i++;
|
||||
VLog(0,
|
||||
@ -806,38 +806,38 @@ HashIdDump(struct ubik_trans *trans, int hashindex)
|
||||
* routine returns zero if there were no errors.
|
||||
*/
|
||||
int
|
||||
ThreadVLentry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
ThreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *tentry)
|
||||
{
|
||||
int errorcode;
|
||||
|
||||
if (!index_OK(trans, blockindex))
|
||||
if (!index_OK(ctx, blockindex))
|
||||
return VL_BADINDEX;
|
||||
/* Insert into volid's hash linked list */
|
||||
if ((errorcode = HashVolid(trans, RWVOL, blockindex, tentry)))
|
||||
if ((errorcode = HashVolid(ctx, RWVOL, blockindex, tentry)))
|
||||
return errorcode;
|
||||
|
||||
/* For rw entries we also enter the RO and BACK volume ids (if they
|
||||
* exist) in the hash tables; note all there volids (RW, RO, BACK)
|
||||
* should not be hashed yet! */
|
||||
if (tentry->volumeId[ROVOL]) {
|
||||
if ((errorcode = HashVolid(trans, ROVOL, blockindex, tentry)))
|
||||
if ((errorcode = HashVolid(ctx, ROVOL, blockindex, tentry)))
|
||||
return errorcode;
|
||||
}
|
||||
if (tentry->volumeId[BACKVOL]) {
|
||||
if ((errorcode = HashVolid(trans, BACKVOL, blockindex, tentry)))
|
||||
if ((errorcode = HashVolid(ctx, BACKVOL, blockindex, tentry)))
|
||||
return errorcode;
|
||||
}
|
||||
|
||||
/* Insert into volname's hash linked list */
|
||||
HashVolname(trans, blockindex, tentry);
|
||||
HashVolname(ctx, blockindex, tentry);
|
||||
|
||||
/* Update cheader entry */
|
||||
if (write_vital_vlheader(trans))
|
||||
if (write_vital_vlheader(ctx))
|
||||
return VL_IO;
|
||||
|
||||
/* Update hash list pointers in the entry itself */
|
||||
if (vlentrywrite(trans, blockindex, (char *)tentry, sizeof(nvlentry)))
|
||||
if (vlentrywrite(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry)))
|
||||
return VL_IO;
|
||||
return 0;
|
||||
}
|
||||
@ -846,42 +846,42 @@ ThreadVLentry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
/* Remove a block from both the hash tables. If success return 0, else
|
||||
* return an error code. */
|
||||
int
|
||||
UnthreadVLentry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
UnthreadVLentry(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *aentry)
|
||||
{
|
||||
afs_int32 errorcode, typeindex;
|
||||
|
||||
if (!index_OK(trans, blockindex))
|
||||
if (!index_OK(ctx, blockindex))
|
||||
return VL_BADINDEX;
|
||||
if ((errorcode = UnhashVolid(trans, RWVOL, blockindex, aentry)))
|
||||
if ((errorcode = UnhashVolid(ctx, RWVOL, blockindex, aentry)))
|
||||
return errorcode;
|
||||
|
||||
/* Take the RO/RW entries of their respective hash linked lists. */
|
||||
for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
|
||||
if ((errorcode = UnhashVolid(trans, typeindex, blockindex, aentry)))
|
||||
if ((errorcode = UnhashVolid(ctx, typeindex, blockindex, aentry)))
|
||||
return errorcode;
|
||||
}
|
||||
|
||||
/* Take it out of the Volname hash list */
|
||||
if ((errorcode = UnhashVolname(trans, blockindex, aentry)))
|
||||
if ((errorcode = UnhashVolname(ctx, blockindex, aentry)))
|
||||
return errorcode;
|
||||
|
||||
/* Update cheader entry */
|
||||
write_vital_vlheader(trans);
|
||||
write_vital_vlheader(ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* cheader must have be read before this routine is called. */
|
||||
int
|
||||
HashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
HashVolid(struct vl_ctx *ctx, afs_int32 voltype, afs_int32 blockindex,
|
||||
struct nvlentry *tentry)
|
||||
{
|
||||
afs_int32 hashindex, errorcode;
|
||||
struct nvlentry ventry;
|
||||
|
||||
if (FindByID
|
||||
(trans, tentry->volumeId[voltype], voltype, &ventry, &errorcode))
|
||||
(ctx, tentry->volumeId[voltype], voltype, &ventry, &errorcode))
|
||||
return VL_IDALREADYHASHED;
|
||||
else if (errorcode)
|
||||
return errorcode;
|
||||
@ -890,7 +890,7 @@ HashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
ntohl(cheader.VolidHash[voltype][hashindex]);
|
||||
cheader.VolidHash[voltype][hashindex] = htonl(blockindex);
|
||||
if (vlwrite
|
||||
(trans, DOFFSET(0, &cheader, &cheader.VolidHash[voltype][hashindex]),
|
||||
(ctx->trans, DOFFSET(0, &cheader, &cheader.VolidHash[voltype][hashindex]),
|
||||
(char *)&cheader.VolidHash[voltype][hashindex], sizeof(afs_int32)))
|
||||
return VL_IO;
|
||||
return 0;
|
||||
@ -899,7 +899,7 @@ HashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
|
||||
/* cheader must have be read before this routine is called. */
|
||||
int
|
||||
UnhashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
UnhashVolid(struct vl_ctx *ctx, afs_int32 voltype, afs_int32 blockindex,
|
||||
struct nvlentry *aentry)
|
||||
{
|
||||
int hashindex, nextblockindex, prevblockindex;
|
||||
@ -917,7 +917,7 @@ UnhashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
cheader.VolidHash[voltype][hashindex] =
|
||||
htonl(aentry->nextIdHash[voltype]);
|
||||
code =
|
||||
vlwrite(trans,
|
||||
vlwrite(ctx->trans,
|
||||
DOFFSET(0, &cheader,
|
||||
&cheader.VolidHash[voltype][hashindex]),
|
||||
(char *)&cheader.VolidHash[voltype][hashindex],
|
||||
@ -928,7 +928,7 @@ UnhashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
while (nextblockindex != blockindex) {
|
||||
prevblockindex = nextblockindex; /* always done once */
|
||||
if (vlentryread
|
||||
(trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
(ctx->trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
return VL_IO;
|
||||
if ((nextblockindex = tentry.nextIdHash[voltype]) == NULLO)
|
||||
return VL_NOENT;
|
||||
@ -936,7 +936,7 @@ UnhashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
temp = tentry.nextIdHash[voltype] = aentry->nextIdHash[voltype];
|
||||
temp = htonl(temp); /* convert to network byte order before writing */
|
||||
if (vlwrite
|
||||
(trans,
|
||||
(ctx->trans,
|
||||
DOFFSET(prevblockindex, &tentry, &tentry.nextIdHash[voltype]),
|
||||
(char *)&temp, sizeof(afs_int32)))
|
||||
return VL_IO;
|
||||
@ -947,7 +947,7 @@ UnhashVolid(struct ubik_trans *trans, afs_int32 voltype, afs_int32 blockindex,
|
||||
|
||||
|
||||
int
|
||||
HashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
HashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *aentry)
|
||||
{
|
||||
afs_int32 hashindex;
|
||||
@ -958,7 +958,7 @@ HashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
aentry->nextNameHash = ntohl(cheader.VolnameHash[hashindex]);
|
||||
cheader.VolnameHash[hashindex] = htonl(blockindex);
|
||||
code =
|
||||
vlwrite(trans, DOFFSET(0, &cheader, &cheader.VolnameHash[hashindex]),
|
||||
vlwrite(ctx->trans, DOFFSET(0, &cheader, &cheader.VolnameHash[hashindex]),
|
||||
(char *)&cheader.VolnameHash[hashindex], sizeof(afs_int32));
|
||||
if (code)
|
||||
return VL_IO;
|
||||
@ -967,7 +967,7 @@ HashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
|
||||
|
||||
int
|
||||
UnhashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
UnhashVolname(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *aentry)
|
||||
{
|
||||
afs_int32 hashindex, nextblockindex, prevblockindex;
|
||||
@ -981,14 +981,14 @@ UnhashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
/* First on the hash list; just adjust pointers */
|
||||
cheader.VolnameHash[hashindex] = htonl(aentry->nextNameHash);
|
||||
if (vlwrite
|
||||
(trans, DOFFSET(0, &cheader, &cheader.VolnameHash[hashindex]),
|
||||
(ctx->trans, DOFFSET(0, &cheader, &cheader.VolnameHash[hashindex]),
|
||||
(char *)&cheader.VolnameHash[hashindex], sizeof(afs_int32)))
|
||||
return VL_IO;
|
||||
} else {
|
||||
while (nextblockindex != blockindex) {
|
||||
prevblockindex = nextblockindex; /* always done at least once */
|
||||
if (vlentryread
|
||||
(trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
(ctx->trans, nextblockindex, (char *)&tentry, sizeof(nvlentry)))
|
||||
return VL_IO;
|
||||
if ((nextblockindex = tentry.nextNameHash) == NULLO)
|
||||
return VL_NOENT;
|
||||
@ -996,7 +996,7 @@ UnhashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
tentry.nextNameHash = aentry->nextNameHash;
|
||||
temp = htonl(tentry.nextNameHash);
|
||||
if (vlwrite
|
||||
(trans, DOFFSET(prevblockindex, &tentry, &tentry.nextNameHash),
|
||||
(ctx->trans, DOFFSET(prevblockindex, &tentry, &tentry.nextNameHash),
|
||||
(char *)&temp, sizeof(afs_int32)))
|
||||
return VL_IO;
|
||||
}
|
||||
@ -1011,7 +1011,7 @@ UnhashVolname(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
*/
|
||||
|
||||
afs_int32
|
||||
NextEntry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
NextEntry(struct vl_ctx *ctx, afs_int32 blockindex,
|
||||
struct nvlentry *tentry, afs_int32 *remaining)
|
||||
{
|
||||
afs_int32 lastblockindex;
|
||||
@ -1019,7 +1019,7 @@ NextEntry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
if (blockindex == 0) /* get first one */
|
||||
blockindex = sizeof(cheader);
|
||||
else {
|
||||
if (!index_OK(trans, blockindex)) {
|
||||
if (!index_OK(ctx, blockindex)) {
|
||||
*remaining = -1; /* error */
|
||||
return 0;
|
||||
}
|
||||
@ -1028,7 +1028,7 @@ NextEntry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
/* now search for the first entry that isn't free */
|
||||
for (lastblockindex = ntohl(cheader.vital_header.eofPtr);
|
||||
blockindex < lastblockindex;) {
|
||||
if (vlentryread(trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
if (vlentryread(ctx->trans, blockindex, (char *)tentry, sizeof(nvlentry))) {
|
||||
*remaining = -1;
|
||||
return 0;
|
||||
}
|
||||
@ -1056,7 +1056,7 @@ NextEntry(struct ubik_trans *trans, afs_int32 blockindex,
|
||||
* table
|
||||
*/
|
||||
static int
|
||||
index_OK(struct ubik_trans *trans, afs_int32 blockindex)
|
||||
index_OK(struct vl_ctx *ctx, afs_int32 blockindex)
|
||||
{
|
||||
if ((blockindex < sizeof(cheader))
|
||||
|| (blockindex >= ntohl(cheader.vital_header.eofPtr)))
|
||||
|
||||
Loading…
Reference in New Issue
Block a user