/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
extern int extent_mod;
extern struct afsconf_dir *vldb_confdir;
extern struct ubik_dbase *VL_dbase;
-struct vlheader cheader; /* kept in network byte order */
-extern afs_uint32 HostAddress[]; /* host addresses kept in host byte order */
int maxnservers;
-struct extentaddr *ex_addr[VL_MAX_ADDREXTBLKS] = { 0, 0, 0, 0 };
-static char rxinfo_str[128]; /* Need rxinfo string to be non-local */
#define ABORT(c) { errorcode = (c); goto abort; }
#undef END
#define END(c) { errorcode = (c); goto end; }
#define VLDBALLOCLIMIT 10000
#define VLDBALLOCINCR 2048
-static int put_attributeentry(struct vldbentry **, struct vldbentry **,
+static int put_attributeentry(struct vl_ctx *ctx,
+ struct vldbentry **, struct vldbentry **,
struct vldbentry **, bulkentries *,
struct nvlentry *, afs_int32 *, afs_int32 *);
-static int put_nattributeentry(struct nvldbentry **, struct nvldbentry **,
+static int put_nattributeentry(struct vl_ctx *ctx,
+ struct nvldbentry **, struct nvldbentry **,
struct nvldbentry **, nbulkentries *,
struct nvlentry *, afs_int32, afs_int32,
afs_int32 *, afs_int32 *);
-static int RemoveEntry(struct ubik_trans *trans, afs_int32 entryptr,
+static int RemoveEntry(struct vl_ctx *ctx, afs_int32 entryptr,
struct nvlentry *tentry);
static void ReleaseEntry(struct nvlentry *tentry, afs_int32 releasetype);
static int check_vldbentry(struct vldbentry *aentry);
static int check_nvldbentry(struct nvldbentry *aentry);
-static int vldbentry_to_vlentry(struct ubik_trans *atrans,
+static int vldbentry_to_vlentry(struct vl_ctx *ctx,
struct vldbentry *VldbEntry,
struct nvlentry *VlEntry);
-static int nvldbentry_to_vlentry(struct ubik_trans *atrans,
+static int nvldbentry_to_vlentry(struct vl_ctx *ctx,
struct nvldbentry *VldbEntry,
struct nvlentry *VlEntry);
-static int get_vldbupdateentry(struct ubik_trans *trans, afs_int32 blockindex,
+static int get_vldbupdateentry(struct vl_ctx *ctx, afs_int32 blockindex,
struct VldbUpdateEntry *updateentry,
struct nvlentry *VlEntry);
static int repsite_exists(struct nvlentry *VlEntry, int server, int partition);
static void repsite_compress(struct nvlentry *VlEntry, int offset);
-static void vlentry_to_vldbentry(struct nvlentry *VlEntry,
+static void vlentry_to_vldbentry(struct vl_ctx *ctx,
+ struct nvlentry *VlEntry,
struct vldbentry *VldbEntry);
-static void vlentry_to_nvldbentry(struct nvlentry *VlEntry,
+static void vlentry_to_nvldbentry(struct vl_ctx *ctx,
+ struct nvlentry *VlEntry,
struct nvldbentry *VldbEntry);
-static void vlentry_to_uvldbentry(struct nvlentry *VlEntry,
+static void vlentry_to_uvldbentry(struct vl_ctx *ctx,
+ struct nvlentry *VlEntry,
struct uvldbentry *VldbEntry);
static int InvalidVolname(char *volname);
static int InvalidVoltype(afs_int32 voltype);
static int InvalidOperation(afs_int32 voloper);
static int InvalidReleasetype(afs_int32 releasetype);
-static int IpAddrToRelAddr(afs_uint32 ipaddr, struct ubik_trans *atrans);
-static int ChangeIPAddr(afs_uint32 ipaddr1, afs_uint32 ipaddr2,
- struct ubik_trans *atrans);
+static int IpAddrToRelAddr(struct vl_ctx *ctx, afs_uint32 ipaddr, int create);
+static int ChangeIPAddr(struct vl_ctx *ctx, afs_uint32 ipaddr1,
+ afs_uint32 ipaddr2);
-char *
-rxinfo(struct rx_call *rxcall)
+#define AFS_RXINFO_LEN 128
+static char *
+rxinfo(char * str, struct rx_call *rxcall)
{
int code;
- register struct rx_connection *tconn;
+ struct rx_connection *tconn;
char tname[64] = "";
char tinst[64] = "";
char tcell[64] = "";
rxkad_GetServerInfo(rxcall->conn, NULL, &exp, tname, tinst, tcell,
NULL);
if (!code)
- sprintf(rxinfo_str, "%s %s%s%s%s%s", inet_ntoa(hostAddr), tname,
+ sprintf(str, "%s %s%s%s%s%s", inet_ntoa(hostAddr), tname,
(tinst[0] == '\0') ? "" : ".",
(tinst[0] == '\0') ? "" : tinst,
(tcell[0] == '\0') ? "" : "@",
(tcell[0] == '\0') ? "" : tcell);
else
- sprintf(rxinfo_str, "%s noauth", inet_ntoa(hostAddr));
- return (rxinfo_str);
+ sprintf(str, "%s noauth", inet_ntoa(hostAddr));
+ return (str);
}
/* This is called to initialize the database, set the appropriate locks and make sure that the vldb header is valid */
int
-Init_VLdbase(struct ubik_trans **trans,
+Init_VLdbase(struct vl_ctx *ctx,
int locktype, /* indicate read or write transaction */
int this_op)
{
for (pass = 1; pass <= 3; pass++) {
if (pass == 2) { /* take write lock to rebuild the db */
- errorcode = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, trans);
+ errorcode = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, &ctx->trans);
wl = 1;
} else if (locktype == LOCKREAD) {
errorcode =
- ubik_BeginTransReadAny(VL_dbase, UBIK_READTRANS, trans);
+ ubik_BeginTransReadAnyWrite(VL_dbase, UBIK_READTRANS, &ctx->trans);
wl = 0;
} else {
- errorcode = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, trans);
+ errorcode = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, &ctx->trans);
wl = 1;
}
if (errorcode)
return errorcode;
- errorcode = ubik_SetLock(*trans, 1, 1, locktype);
+ errorcode = ubik_SetLock(ctx->trans, 1, 1, locktype);
if (errorcode) {
COUNT_ABO;
- ubik_AbortTrans(*trans);
+ ubik_AbortTrans(ctx->trans);
return errorcode;
}
/* check that dbase is initialized and setup cheader */
/* 2nd pass we try to rebuild the header */
- errorcode = CheckInit(*trans, ((pass == 2) ? 1 : 0));
+ errorcode = CheckInit(ctx->trans, ((pass == 2) ? 1 : 0));
if (!errorcode && wl && extent_mod)
- errorcode = readExtents(*trans); /* Fix the mh extent blocks */
+ errorcode = readExtents(ctx->trans); /* Fix the mh extent blocks */
if (errorcode) {
COUNT_ABO;
- ubik_AbortTrans(*trans);
+ ubik_AbortTrans(ctx->trans);
/* Only rebuld if the database is empty */
/* Exit if can't rebuild */
if ((pass == 1) && (errorcode != VL_EMPTY))
return errorcode;
} else { /* No errorcode */
if (pass == 2) {
- ubik_EndTrans(*trans); /* Rebuilt db. End trans, then retake original lock */
+ ubik_EndTrans(ctx->trans); /* Rebuilt db. End trans, then retake original lock */
} else {
break; /* didn't rebuild and successful - exit */
}
}
}
+ if (errorcode == 0) {
+ errorcode = vlsetcache(ctx, locktype);
+ }
return errorcode;
}
afs_int32
SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 errorcode, blockindex;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLCREATEENTRY);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
/* Do some validity tests on new entry */
if ((errorcode = check_vldbentry(newentry))
- || (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ || (errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
VLog(1,
("OCreate Volume %d %s\n", newentry->volumeId[RWVOL],
- rxinfo(rxcall)));
- if (EntryIDExists(trans, newentry->volumeId, MAXTYPES, &errorcode)) {
+ rxinfo(rxstr, rxcall)));
+ if (EntryIDExists(&ctx, newentry->volumeId, MAXTYPES, &errorcode)) {
/* at least one of the specified IDs already exists; we fail */
errorcode = VL_IDEXIST;
goto abort;
/* Is this following check (by volume name) necessary?? */
/* If entry already exists, we fail */
- if (FindByName(trans, newentry->name, &tentry, &errorcode)) {
+ if (FindByName(&ctx, newentry->name, &tentry, &errorcode)) {
errorcode = VL_NAMEEXIST;
goto abort;
} else if (errorcode) {
goto abort;
}
- blockindex = AllocBlock(trans, &tentry);
+ blockindex = AllocBlock(&ctx, &tentry);
if (blockindex == 0) {
errorcode = VL_CREATEFAIL;
goto abort;
memset(&tentry, 0, sizeof(struct nvlentry));
/* Convert to its internal representation; both in host byte order */
- if ((errorcode = vldbentry_to_vlentry(trans, newentry, &tentry))) {
- FreeBlock(trans, blockindex);
+ if ((errorcode = vldbentry_to_vlentry(&ctx, newentry, &tentry))) {
+ FreeBlock(&ctx, blockindex);
goto abort;
}
/* Actually insert the entry in vldb */
- errorcode = ThreadVLentry(trans, blockindex, &tentry);
+ errorcode = ThreadVLentry(&ctx, blockindex, &tentry);
if (errorcode) {
- FreeBlock(trans, blockindex);
+ FreeBlock(&ctx, blockindex);
goto abort;
} else {
- errorcode = ubik_EndTrans(trans);
+ errorcode = ubik_EndTrans(ctx.trans);
goto end;
}
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLCreateEntryEvent, errorcode, AUD_STR,
afs_int32
SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 errorcode, blockindex;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLCREATEENTRYN);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
/* Do some validity tests on new entry */
if ((errorcode = check_nvldbentry(newentry))
- || (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ || (errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
VLog(1,
("Create Volume %d %s\n", newentry->volumeId[RWVOL],
- rxinfo(rxcall)));
- if (EntryIDExists(trans, newentry->volumeId, MAXTYPES, &errorcode)) {
+ rxinfo(rxstr, rxcall)));
+ if (EntryIDExists(&ctx, newentry->volumeId, MAXTYPES, &errorcode)) {
/* at least one of the specified IDs already exists; we fail */
errorcode = VL_IDEXIST;
goto abort;
/* Is this following check (by volume name) necessary?? */
/* If entry already exists, we fail */
- if (FindByName(trans, newentry->name, &tentry, &errorcode)) {
+ if (FindByName(&ctx, newentry->name, &tentry, &errorcode)) {
errorcode = VL_NAMEEXIST;
goto abort;
} else if (errorcode) {
goto abort;
}
- blockindex = AllocBlock(trans, &tentry);
+ blockindex = AllocBlock(&ctx, &tentry);
if (blockindex == 0) {
errorcode = VL_CREATEFAIL;
goto abort;
memset(&tentry, 0, sizeof(struct nvlentry));
/* Convert to its internal representation; both in host byte order */
- if ((errorcode = nvldbentry_to_vlentry(trans, newentry, &tentry))) {
- FreeBlock(trans, blockindex);
+ if ((errorcode = nvldbentry_to_vlentry(&ctx, newentry, &tentry))) {
+ FreeBlock(&ctx, blockindex);
goto abort;
}
/* Actually insert the entry in vldb */
- errorcode = ThreadVLentry(trans, blockindex, &tentry);
+ errorcode = ThreadVLentry(&ctx, blockindex, &tentry);
if (errorcode) {
- FreeBlock(trans, blockindex);
+ FreeBlock(&ctx, blockindex);
goto abort;
} else {
- errorcode = ubik_EndTrans(trans);
+ errorcode = ubik_EndTrans(ctx.trans);
goto end;
}
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLCreateEntryEvent, errorcode, AUD_STR,
afs_int32
SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 errorcode;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLCHANGEADDR);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
goto end;
}
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("Change Addr %u -> %u %s\n", ip1, ip2, rxinfo(rxcall)));
- if ((errorcode = ChangeIPAddr(ip1, ip2, trans)))
+ VLog(1, ("Change Addr %u -> %u %s\n", ip1, ip2, rxinfo(rxstr, rxcall)));
+ if ((errorcode = ChangeIPAddr(&ctx, ip1, ip2)))
goto abort;
else {
- errorcode = ubik_EndTrans(trans);
+ errorcode = ubik_EndTrans(ctx.trans);
goto end;
}
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLChangeAddrEvent, errorcode, AUD_LONG, ip1, AUD_LONG,
afs_int32
SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLDELETEENTRY);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
if ((voltype != -1) && (InvalidVoltype(voltype)))
END(VL_BADVOLTYPE);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("Delete Volume %u %s\n", volid, rxinfo(rxcall)));
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ VLog(1, ("Delete Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == 0) { /* volid not found */
if (!errorcode)
errorcode = VL_NOENT;
if (tentry.flags & VLDELETED) { /* Already deleted; return */
ABORT(VL_ENTDELETED);
}
- if ((errorcode = RemoveEntry(trans, blockindex, &tentry))) {
+ if ((errorcode = RemoveEntry(&ctx, blockindex, &tentry))) {
goto abort;
}
- errorcode = (ubik_EndTrans(trans));
+ errorcode = (ubik_EndTrans(ctx.trans));
goto end;
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLDeleteEntryEvent, errorcode, AUD_LONG, volid,
afs_int32 new,
afs_int32 this_op)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
if ((voltype != -1) && (InvalidVoltype(voltype)))
return VL_BADVOLTYPE;
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
- VLog(5, ("GetVolumeByID %u (%d) %s\n", volid, new, rxinfo(rxcall)));
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ VLog(5, ("GetVolumeByID %u (%d) %s\n", volid, new,
+ rxinfo(rxstr, rxcall)));
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == 0) { /* entry not found */
if (!errorcode)
errorcode = VL_NOENT;
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return errorcode;
}
if (tentry.flags & VLDELETED) { /* Entry is deleted! */
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_ENTDELETED;
}
/* Convert from the internal to external form */
if (new == 1)
- vlentry_to_nvldbentry(&tentry, (struct nvldbentry *)aentry);
+ vlentry_to_nvldbentry(&ctx, &tentry, (struct nvldbentry *)aentry);
else if (new == 2)
- vlentry_to_uvldbentry(&tentry, (struct uvldbentry *)aentry);
+ vlentry_to_uvldbentry(&ctx, &tentry, (struct uvldbentry *)aentry);
else
- vlentry_to_vldbentry(&tentry, (struct vldbentry *)aentry);
- return (ubik_EndTrans(trans));
+ vlentry_to_vldbentry(&ctx, &tentry, (struct vldbentry *)aentry);
+ return (ubik_EndTrans(ctx.trans));
}
afs_int32
static int
NameIsId(char *aname)
{
- register int tc;
+ int tc;
while ((tc = *aname++)) {
if (tc > '9' || tc < '0')
return 0;
int new,
int this_op)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
if (NameIsId(volname)) {
return GetEntryByID(rxcall, atoi(volname), -1, aentry, new, this_op);
}
if (InvalidVolname(volname))
return VL_BADNAME;
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
- VLog(5, ("GetVolumeByName %s (%d) %s\n", volname, new, rxinfo(rxcall)));
- blockindex = FindByName(trans, volname, &tentry, &errorcode);
+ VLog(5, ("GetVolumeByName %s (%d) %s\n", volname, new, rxinfo(rxstr, rxcall)));
+ blockindex = FindByName(&ctx, volname, &tentry, &errorcode);
if (blockindex == 0) { /* entry not found */
if (!errorcode)
errorcode = VL_NOENT;
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return errorcode;
}
if (tentry.flags & VLDELETED) { /* Entry is deleted */
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_ENTDELETED;
}
/* Convert to external entry representation */
if (new == 1)
- vlentry_to_nvldbentry(&tentry, (struct nvldbentry *)aentry);
+ vlentry_to_nvldbentry(&ctx, &tentry, (struct nvldbentry *)aentry);
else if (new == 2)
- vlentry_to_uvldbentry(&tentry, (struct uvldbentry *)aentry);
+ vlentry_to_uvldbentry(&ctx, &tentry, (struct uvldbentry *)aentry);
else
- vlentry_to_vldbentry(&tentry, (struct vldbentry *)aentry);
- return (ubik_EndTrans(trans));
+ vlentry_to_vldbentry(&ctx, &tentry, (struct vldbentry *)aentry);
+ return (ubik_EndTrans(ctx.trans));
}
afs_int32
{
afs_int32 errorcode;
afs_uint32 maxvolumeid;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLGETNEWVOLUMEID);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
if (Maxvolidbump < 0 || Maxvolidbump > MAXBUMPCOUNT)
END(VL_BADVOLIDBUMP);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- *newvolumeid = maxvolumeid = NextUnusedID(trans,
- ntohl(cheader.vital_header.MaxVolumeId), Maxvolidbump, &errorcode);
+ *newvolumeid = maxvolumeid = NextUnusedID(&ctx,
+ ntohl(ctx.cheader->vital_header.MaxVolumeId), Maxvolidbump, &errorcode);
if (errorcode) {
goto abort;
}
maxvolumeid += Maxvolidbump;
- VLog(1, ("GetNewVolid newmax=%u %s\n", maxvolumeid, rxinfo(rxcall)));
- cheader.vital_header.MaxVolumeId = htonl(maxvolumeid);
- if (write_vital_vlheader(trans)) {
+ VLog(1, ("GetNewVolid newmax=%u %s\n", maxvolumeid, rxinfo(rxstr, rxcall)));
+ ctx.cheader->vital_header.MaxVolumeId = htonl(maxvolumeid);
+ if (write_vital_vlheader(&ctx)) {
ABORT(VL_IO);
}
- errorcode = (ubik_EndTrans(trans));
+ errorcode = (ubik_EndTrans(ctx.trans));
goto end;
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLGetNewVolumeIdEvent, errorcode, AUD_END);
SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
struct vldbentry *newentry, afs_int32 releasetype)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode, typeindex;
int hashnewname;
int hashVol[MAXTYPES];
struct nvlentry tentry;
afs_uint32 checkids[MAXTYPES];
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLREPLACEENTRY);
for (typeindex = 0; typeindex < MAXTYPES; typeindex++)
if (releasetype && InvalidReleasetype(releasetype))
END(VL_BADRELLOCKTYPE);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("OReplace Volume %u %s\n", volid, rxinfo(rxcall)));
+ VLog(1, ("OReplace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
/* find vlentry we're changing */
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == 0) { /* entry not found */
if (!errorcode)
errorcode = VL_NOENT;
checkids[typeindex] = newentry->volumeId[typeindex];
}
}
- if (EntryIDExists(trans, checkids, MAXTYPES, &errorcode)) {
+ if (EntryIDExists(&ctx, checkids, MAXTYPES, &errorcode)) {
ABORT(VL_IDEXIST);
} else if (errorcode) {
goto abort;
/* make sure the name we're changing to doesn't already exist */
if (strcmp(newentry->name, tentry.name)) {
struct nvlentry tmp_entry;
- if (FindByName(trans, newentry->name, &tmp_entry, &errorcode)) {
+ if (FindByName(&ctx, newentry->name, &tmp_entry, &errorcode)) {
ABORT(VL_NAMEEXIST);
} else if (errorcode) {
goto abort;
if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
if (tentry.volumeId[typeindex])
if ((errorcode =
- UnhashVolid(trans, typeindex, blockindex, &tentry))) {
+ UnhashVolid(&ctx, typeindex, blockindex, &tentry))) {
goto abort;
}
/* we must rehash new id if the id is different and the ID is nonzero */
/* Rehash volname if it changes */
if (strcmp(newentry->name, tentry.name)) { /* Name changes; redo hashing */
- if ((errorcode = UnhashVolname(trans, blockindex, &tentry))) {
+ if ((errorcode = UnhashVolname(&ctx, blockindex, &tentry))) {
goto abort;
}
hashnewname = 1;
/* after this, tentry is new entry, not old one. vldbentry_to_vlentry
* doesn't touch hash chains */
- if ((errorcode = vldbentry_to_vlentry(trans, newentry, &tentry))) {
+ if ((errorcode = vldbentry_to_vlentry(&ctx, newentry, &tentry))) {
goto abort;
}
for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
if (hashVol[typeindex] && tentry.volumeId[typeindex]) {
- if ((errorcode = HashVolid(trans, typeindex, blockindex, &tentry))) {
+ if ((errorcode = HashVolid(&ctx, typeindex, blockindex, &tentry))) {
goto abort;
}
}
}
if (hashnewname)
- HashVolname(trans, blockindex, &tentry);
+ HashVolname(&ctx, blockindex, &tentry);
if (releasetype)
ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
- if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) {
+ if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(trans));
+ END(ubik_EndTrans(ctx.trans));
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLReplaceVLEntryEvent, errorcode, AUD_LONG, volid,
SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
struct nvldbentry *newentry, afs_int32 releasetype)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode, typeindex;
int hashnewname;
int hashVol[MAXTYPES];
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLREPLACEENTRYN);
for (typeindex = 0; typeindex < MAXTYPES; typeindex++)
if (releasetype && InvalidReleasetype(releasetype))
END(VL_BADRELLOCKTYPE);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("Replace Volume %u %s\n", volid, rxinfo(rxcall)));
+ VLog(1, ("Replace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
/* find vlentry we're changing */
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == 0) { /* entry not found */
if (!errorcode)
errorcode = VL_NOENT;
if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
if (tentry.volumeId[typeindex])
if ((errorcode =
- UnhashVolid(trans, typeindex, blockindex, &tentry))) {
+ UnhashVolid(&ctx, typeindex, blockindex, &tentry))) {
goto abort;
}
/* we must rehash new id if the id is different and the ID is nonzero */
/* Rehash volname if it changes */
if (strcmp(newentry->name, tentry.name)) { /* Name changes; redo hashing */
- if ((errorcode = UnhashVolname(trans, blockindex, &tentry))) {
+ if ((errorcode = UnhashVolname(&ctx, blockindex, &tentry))) {
goto abort;
}
hashnewname = 1;
/* after this, tentry is new entry, not old one. vldbentry_to_vlentry
* doesn't touch hash chains */
- if ((errorcode = nvldbentry_to_vlentry(trans, newentry, &tentry))) {
+ if ((errorcode = nvldbentry_to_vlentry(&ctx, newentry, &tentry))) {
goto abort;
}
for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
if (hashVol[typeindex] && tentry.volumeId[typeindex]) {
- if ((errorcode = HashVolid(trans, typeindex, blockindex, &tentry))) {
+ if ((errorcode = HashVolid(&ctx, typeindex, blockindex, &tentry))) {
goto abort;
}
}
}
if (hashnewname)
- HashVolname(trans, blockindex, &tentry);
+ HashVolname(&ctx, blockindex, &tentry);
if (releasetype)
ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
- if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) {
+ if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(trans));
+ END(ubik_EndTrans(ctx.trans));
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLReplaceVLEntryEvent, errorcode, AUD_LONG, volid,
struct VldbUpdateEntry *updateentry, /* Update entry copied here */
afs_int32 releasetype)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLUPDATEENTRY);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
END(VL_BADVOLTYPE);
if (releasetype && InvalidReleasetype(releasetype))
END(VL_BADRELLOCKTYPE);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("Update Volume %u %s\n", volid, rxinfo(rxcall)));
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ VLog(1, ("Update Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == 0) { /* entry not found */
if (!errorcode)
errorcode = VL_NOENT;
/* Do the actual updating of the entry, tentry. */
if ((errorcode =
- get_vldbupdateentry(trans, blockindex, updateentry, &tentry))) {
+ get_vldbupdateentry(&ctx, blockindex, updateentry, &tentry))) {
goto abort;
}
if (releasetype)
ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
- if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) {
+ if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(trans));
+ END(ubik_EndTrans(ctx.trans));
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLUpdateEntryEvent, errorcode, AUD_LONG, volid,
struct VldbUpdateEntry *updateentry, /* Update entry copied here */
afs_int32 releasetype)
{
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
afs_int32 blockindex, errorcode;
struct nvlentry tentry;
END(VL_PERM);
if (releasetype && InvalidReleasetype(releasetype))
END(VL_BADRELLOCKTYPE);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- blockindex = FindByName(trans, volname, &tentry, &errorcode);
+ blockindex = FindByName(&ctx, volname, &tentry, &errorcode);
if (blockindex == 0) { /* entry not found */
if (!errorcode)
errorcode = VL_NOENT;
/* Do the actual updating of the entry, tentry. */
if ((errorcode =
- get_vldbupdateentry(trans, blockindex, updateentry, &tentry))) {
+ get_vldbupdateentry(&ctx, blockindex, updateentry, &tentry))) {
goto abort;
}
if (releasetype)
ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */
- if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) {
+ if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(trans));
+ END(ubik_EndTrans(ctx.trans));
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLUpdateEntryEvent, errorcode, AUD_LONG, -1, AUD_END);
afs_int32 voloper)
{
afs_int32 timestamp, blockindex, errorcode;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLSETLOCK);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
END(VL_BADVOLTYPE);
if (InvalidOperation(voloper))
END(VL_BADVOLOPER);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("SetLock Volume %u %s\n", volid, rxinfo(rxcall)));
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ VLog(1, ("SetLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == NULLO) {
if (!errorcode)
errorcode = VL_NOENT;
tentry.flags &= ~VLOP_ALLOPERS; /* Clear any possible older operation bit */
tentry.flags |= voloper;
- if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) {
+ if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(trans));
+ END(ubik_EndTrans(ctx.trans));
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLSetLockEvent, errorcode, AUD_LONG, volid, AUD_END);
afs_int32 releasetype)
{
afs_int32 blockindex, errorcode;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLRELEASELOCK);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
END(VL_BADVOLTYPE);
if (releasetype && InvalidReleasetype(releasetype))
END(VL_BADRELLOCKTYPE);
- if ((errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
goto end;
- VLog(1, ("ReleaseLock Volume %u %s\n", volid, rxinfo(rxcall)));
- blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode);
+ VLog(1, ("ReleaseLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
+ blockindex = FindByID(&ctx, volid, voltype, &tentry, &errorcode);
if (blockindex == NULLO) {
if (!errorcode)
errorcode = VL_NOENT;
}
if (releasetype)
ReleaseEntry(&tentry, releasetype); /* Unlock the appropriate fields */
- if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) {
+ if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(trans));
+ END(ubik_EndTrans(ctx.trans));
abort:
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
end:
osi_auditU(rxcall, VLReleaseLockEvent, errorcode, AUD_LONG, volid,
struct vldbentry *aentry)
{
int errorcode;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLLISTENTRY);
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
- VLog(25, ("OListEntry index=%d %s\n", previous_index, rxinfo(rxcall)));
- *next_index = NextEntry(trans, previous_index, &tentry, count);
+ VLog(25, ("OListEntry index=%d %s\n", previous_index,
+ rxinfo(rxstr, rxcall)));
+ *next_index = NextEntry(&ctx, previous_index, &tentry, count);
if (*next_index)
- vlentry_to_vldbentry(&tentry, aentry);
- return (ubik_EndTrans(trans));
+ vlentry_to_vldbentry(&ctx, &tentry, aentry);
+ return (ubik_EndTrans(ctx.trans));
}
/* ListEntry returns a single vldb entry, aentry, with offset previous_index;
struct nvldbentry *aentry)
{
int errorcode;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLLISTENTRYN);
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
- VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxcall)));
- *next_index = NextEntry(trans, previous_index, &tentry, count);
+ VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxstr, rxcall)));
+ *next_index = NextEntry(&ctx, previous_index, &tentry, count);
if (*next_index)
- vlentry_to_nvldbentry(&tentry, aentry);
- return (ubik_EndTrans(trans));
+ vlentry_to_nvldbentry(&ctx, &tentry, aentry);
+ return (ubik_EndTrans(ctx.trans));
}
bulkentries *vldbentries)
{
int errorcode, allocCount = 0;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
struct vldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
int pollcount = 0;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLLISTATTRIBUTES);
vldbentries->bulkentries_val = 0;
vldbentries->bulkentries_len = *nentries = 0;
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
allocCount = VLDBALLOCCOUNT;
Vldbentry = VldbentryFirst = vldbentries->bulkentries_val =
(vldbentry *) malloc(allocCount * sizeof(vldbentry));
if (Vldbentry == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
VldbentryLast = VldbentryFirst + allocCount;
afs_int32 blockindex;
blockindex =
- FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode);
+ FindByID(&ctx, attributes->volumeid, -1, &tentry, &errorcode);
if (blockindex == 0) {
if (!errorcode)
errorcode = VL_NOENT;
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->bulkentries_val)
free((char *)vldbentries->bulkentries_val);
vldbentries->bulkentries_val = 0;
return errorcode;
}
if ((errorcode =
- put_attributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast,
+ put_attributeentry(&ctx, &Vldbentry, &VldbentryFirst, &VldbentryLast,
vldbentries, &tentry, nentries, &allocCount))) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->bulkentries_val)
free((char *)vldbentries->bulkentries_val);
vldbentries->bulkentries_val = 0;
} else {
afs_int32 nextblockindex = 0, count = 0, k = 0, match = 0;
while ((nextblockindex =
- NextEntry(trans, nextblockindex, &tentry, &count))) {
+ NextEntry(&ctx, nextblockindex, &tentry, &count))) {
if (++pollcount > 50) {
#ifndef AFS_PTHREAD_ENV
IOMGR_Poll();
if (attributes->Mask & VLLIST_SERVER) {
int serverindex;
if ((serverindex =
- IpAddrToRelAddr(attributes->server, NULL)) == -1)
+ IpAddrToRelAddr(&ctx, attributes->server, 0)) == -1)
continue;
for (k = 0; k < OMAXNSERVERS; k++) {
if (tentry.serverNumber[k] == BADSERVERID)
continue;
}
if ((errorcode =
- put_attributeentry(&Vldbentry, &VldbentryFirst,
+ put_attributeentry(&ctx, &Vldbentry, &VldbentryFirst,
&VldbentryLast, vldbentries, &tentry,
nentries, &allocCount))) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->bulkentries_val)
free((char *)vldbentries->bulkentries_val);
vldbentries->bulkentries_val = 0;
sizeof(vldbentry));
if (vldbentries->bulkentries_val == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
}
VLog(5,
("ListAttrs nentries=%d %s\n", vldbentries->bulkentries_len,
- rxinfo(rxcall)));
- return (ubik_EndTrans(trans));
+ rxinfo(rxstr, rxcall)));
+ return (ubik_EndTrans(ctx.trans));
}
afs_int32
nbulkentries *vldbentries)
{
int errorcode, allocCount = 0;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
int pollcount = 0;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLLISTATTRIBUTESN);
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = *nentries = 0;
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
allocCount = VLDBALLOCCOUNT;
Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
(nvldbentry *) malloc(allocCount * sizeof(nvldbentry));
if (Vldbentry == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
VldbentryLast = VldbentryFirst + allocCount;
afs_int32 blockindex;
blockindex =
- FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode);
+ FindByID(&ctx, attributes->volumeid, -1, &tentry, &errorcode);
if (blockindex == 0) {
if (!errorcode)
errorcode = VL_NOENT;
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->nbulkentries_val)
free((char *)vldbentries->nbulkentries_val);
vldbentries->nbulkentries_val = 0;
return errorcode;
}
if ((errorcode =
- put_nattributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast,
+ put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst, &VldbentryLast,
vldbentries, &tentry, 0, 0, nentries,
&allocCount))) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->nbulkentries_val)
free((char *)vldbentries->nbulkentries_val);
vldbentries->nbulkentries_val = 0;
} else {
afs_int32 nextblockindex = 0, count = 0, k = 0, match = 0;
while ((nextblockindex =
- NextEntry(trans, nextblockindex, &tentry, &count))) {
+ NextEntry(&ctx, nextblockindex, &tentry, &count))) {
if (++pollcount > 50) {
#ifndef AFS_PTHREAD_ENV
IOMGR_Poll();
if (attributes->Mask & VLLIST_SERVER) {
int serverindex;
if ((serverindex =
- IpAddrToRelAddr(attributes->server, NULL)) == -1)
+ IpAddrToRelAddr(&ctx, attributes->server, 0)) == -1)
continue;
for (k = 0; k < NMAXNSERVERS; k++) {
if (tentry.serverNumber[k] == BADSERVERID)
continue;
}
if ((errorcode =
- put_nattributeentry(&Vldbentry, &VldbentryFirst,
+ put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
&VldbentryLast, vldbentries, &tentry, 0,
0, nentries, &allocCount))) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->nbulkentries_val)
free((char *)vldbentries->nbulkentries_val);
vldbentries->nbulkentries_val = 0;
sizeof(nvldbentry));
if (vldbentries->nbulkentries_val == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
}
VLog(5,
("NListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
- rxinfo(rxcall)));
- return (ubik_EndTrans(trans));
+ rxinfo(rxstr, rxcall)));
+ return (ubik_EndTrans(ctx.trans));
}
afs_int32 *nextstartindex)
{
int errorcode = 0, maxCount = VLDBALLOCCOUNT;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
afs_int32 blockindex = 0, count = 0, k, match;
int pollcount = 0;
int namematchRWBK, namematchRO, thismatch;
int matchtype = 0;
- char volumename[VL_MAXNAMELEN];
+ char volumename[VL_MAXNAMELEN+2]; /* regex anchors */
+ char rxstr[AFS_RXINFO_LEN];
#ifdef HAVE_POSIX_REGEX
regex_t re;
int need_regfree = 0;
*nentries = 0;
*nextstartindex = -1;
- errorcode = Init_VLdbase(&trans, LOCKREAD, this_op);
+ errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op);
if (errorcode)
return errorcode;
(nvldbentry *) malloc(maxCount * sizeof(nvldbentry));
if (Vldbentry == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
*/
if (attributes->Mask & VLLIST_VOLUMEID) {
blockindex =
- FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode);
+ FindByID(&ctx, attributes->volumeid, -1, &tentry, &errorcode);
if (blockindex == 0) {
if (!errorcode)
errorcode = VL_NOENT;
} else {
errorcode =
- put_nattributeentry(&Vldbentry, &VldbentryFirst,
+ put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
&VldbentryLast, vldbentries, &tentry, 0,
0, nentries, &maxCount);
if (errorcode)
/* Get the server index for matching server address */
if (attributes->Mask & VLLIST_SERVER) {
serverindex =
- IpAddrToRelAddr(attributes->server, NULL);
+ IpAddrToRelAddr(&ctx, attributes->server, 0);
if (serverindex == -1)
goto done;
findserver = 1;
/* Read each entry and see if it is the one we want */
blockindex = startindex;
- while ((blockindex = NextEntry(trans, blockindex, &tentry, &count))) {
+ while ((blockindex = NextEntry(&ctx, blockindex, &tentry, &count))) {
if (++pollcount > 50) {
#ifndef AFS_PTHREAD_ENV
IOMGR_Poll();
namematchRWBK = (thismatch ? 1 : 2);
}
- /* Match with the RO volume name. Compare once and
+ /* Match with the RO volume name. Compare once and
* remember results in namematchRO. Note that this will
* pick up entries marked NEWREPSITEs and DONTUSE.
*/
/* Passed all the tests. Take it */
if (match) {
errorcode =
- put_nattributeentry(&Vldbentry, &VldbentryFirst,
+ put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
&VldbentryLast, vldbentries, &tentry,
matchtype, matchindex, nentries,
&maxCount);
if (errorcode) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
if (vldbentries->nbulkentries_val)
free((char *)vldbentries->nbulkentries_val);
vldbentries->nbulkentries_val = 0;
} else {
VLog(5,
("N2ListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
- rxinfo(rxcall)));
- return (ubik_EndTrans(trans));
+ rxinfo(rxstr, rxcall)));
+ return (ubik_EndTrans(ctx.trans));
}
}
vldb_list *vldbentries)
{
int errorcode;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
vldblist vllist, *vllistptr;
afs_int32 blockindex, count, match;
int pollcount = 0;
COUNT_REQ(VLLINKEDLIST);
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
*nentries = 0;
/* List by volumeid */
if (attributes->Mask & VLLIST_VOLUMEID) {
blockindex =
- FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode);
+ FindByID(&ctx, attributes->volumeid, -1, &tentry, &errorcode);
if (!blockindex) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return (errorcode ? errorcode : VL_NOENT);
}
vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry));
if (vllist == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
- vlentry_to_vldbentry(&tentry, &vllist->VldbEntry);
+ vlentry_to_vldbentry(&ctx, &tentry, &vllist->VldbEntry);
vllist->next_vldb = NULL;
*vllistptr = vllist; /* Thread onto list */
/* Search by server, partition, and flags */
else {
- for (blockindex = NextEntry(trans, 0, &tentry, &count); blockindex;
- blockindex = NextEntry(trans, blockindex, &tentry, &count)) {
+ for (blockindex = NextEntry(&ctx, 0, &tentry, &count); blockindex;
+ blockindex = NextEntry(&ctx, blockindex, &tentry, &count)) {
match = 0;
if (++pollcount > 50) {
/* Does this volume exist on the desired server */
if (attributes->Mask & VLLIST_SERVER) {
serverindex =
- IpAddrToRelAddr(attributes->server, NULL);
+ IpAddrToRelAddr(&ctx, attributes->server, 0);
if (serverindex == -1)
continue;
for (k = 0; k < OMAXNSERVERS; k++) {
vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry));
if (vllist == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
- vlentry_to_vldbentry(&tentry, &vllist->VldbEntry);
+ vlentry_to_vldbentry(&ctx, &tentry, &vllist->VldbEntry);
vllist->next_vldb = NULL;
*vllistptr = vllist; /* Thread onto list */
(*nentries)++;
if (smallMem && (*nentries >= VLDBALLOCCOUNT)) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_SIZEEXCEEDED;
}
}
}
*vllistptr = NULL;
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
afs_int32
nvldb_list *vldbentries)
{
int errorcode;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
struct nvlentry tentry;
nvldblist vllist, *vllistptr;
afs_int32 blockindex, count, match;
int pollcount = 0;
COUNT_REQ(VLLINKEDLISTN);
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
*nentries = 0;
/* List by volumeid */
if (attributes->Mask & VLLIST_VOLUMEID) {
blockindex =
- FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode);
+ FindByID(&ctx, attributes->volumeid, -1, &tentry, &errorcode);
if (!blockindex) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return (errorcode ? errorcode : VL_NOENT);
}
vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry));
if (vllist == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
- vlentry_to_nvldbentry(&tentry, &vllist->VldbEntry);
+ vlentry_to_nvldbentry(&ctx, &tentry, &vllist->VldbEntry);
vllist->next_vldb = NULL;
*vllistptr = vllist; /* Thread onto list */
/* Search by server, partition, and flags */
else {
- for (blockindex = NextEntry(trans, 0, &tentry, &count); blockindex;
- blockindex = NextEntry(trans, blockindex, &tentry, &count)) {
+ for (blockindex = NextEntry(&ctx, 0, &tentry, &count); blockindex;
+ blockindex = NextEntry(&ctx, blockindex, &tentry, &count)) {
match = 0;
if (++pollcount > 50) {
/* Does this volume exist on the desired server */
if (attributes->Mask & VLLIST_SERVER) {
serverindex =
- IpAddrToRelAddr(attributes->server, NULL);
+ IpAddrToRelAddr(&ctx, attributes->server, 0);
if (serverindex == -1)
continue;
for (k = 0; k < NMAXNSERVERS; k++) {
vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry));
if (vllist == NULL) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
- vlentry_to_nvldbentry(&tentry, &vllist->VldbEntry);
+ vlentry_to_nvldbentry(&ctx, &tentry, &vllist->VldbEntry);
vllist->next_vldb = NULL;
*vllistptr = vllist; /* Thread onto list */
(*nentries)++;
if (smallMem && (*nentries >= VLDBALLOCCOUNT)) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_SIZEEXCEEDED;
}
}
}
*vllistptr = NULL;
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
/* Get back vldb header statistics (allocs, frees, maxvolumeid,
vldstats *stats,
vital_vlheader *vital_header)
{
- register afs_int32 errorcode;
- struct ubik_trans *trans;
+ afs_int32 errorcode;
+ struct vl_ctx ctx;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLGETSTATS);
#ifdef notdef
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) /* Must be in 'UserList' to use */
return VL_PERM;
#endif
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
- VLog(5, ("GetStats %s\n", rxinfo(rxcall)));
- memcpy((char *)vital_header, (char *)&cheader.vital_header,
+ VLog(5, ("GetStats %s\n", rxinfo(rxstr, rxcall)));
+ memcpy((char *)vital_header, (char *)&ctx.cheader->vital_header,
sizeof(vital_vlheader));
memcpy((char *)stats, (char *)&dynamic_statistics, sizeof(vldstats));
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
/* Get the list of file server addresses from the VLDB. Currently it's pretty
afs_int32 *nentries,
bulkaddrs *addrsp)
{
- register afs_int32 errorcode;
- struct ubik_trans *trans;
+ afs_int32 errorcode;
+ struct vl_ctx ctx;
int nservers, i;
afs_uint32 *taddrp;
addrsp->bulkaddrs_val = 0;
memset(spare3, 0, sizeof(struct VLCallBack));
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
VLog(5, ("GetAddrs\n"));
if (!taddrp) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
for (i = 0; i <= MAXSERVERID; i++) {
- if ((*taddrp = ntohl(cheader.IpMappedAddr[i]))) {
+ if ((*taddrp = ntohl(ctx.cheader->IpMappedAddr[i]))) {
taddrp++;
nservers++;
}
}
addrsp->bulkaddrs_len = *nentries = nservers;
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
#define PADDR(addr) VLog(0,("%d.%d.%d.%d", (addr>>24)&0xff, (addr>>16)&0xff, (addr>>8) &0xff, addr&0xff));
bulkaddrs *addrsp)
{
afs_int32 code;
- struct ubik_trans *trans;
+ struct vl_ctx ctx;
int cnt, h, i, j, k, m, base, index;
struct extentaddr *exp = 0, *tex;
afsUUID tuuid;
COUNT_REQ(VLREGADDR);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
return (VL_PERM);
- if ((code = Init_VLdbase(&trans, LOCKWRITE, this_op)))
+ if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
return code;
/* Eliminate duplicates from IP address list */
}
}
if (cnt <= 0) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_INDEXERANGE;
}
for (srvidx = 0; srvidx <= MAXSERVERID; srvidx++) {
willChangeEntry = 0;
WillReplaceEntry = 1;
- if ((HostAddress[srvidx] & 0xff000000) == 0xff000000) {
+ if ((ctx.hostaddress[srvidx] & 0xff000000) == 0xff000000) {
/* The server is registered as a multihomed */
- base = (HostAddress[srvidx] >> 16) & 0xff;
- index = HostAddress[srvidx] & 0x0000ffff;
+ base = (ctx.hostaddress[srvidx] >> 16) & 0xff;
+ index = ctx.hostaddress[srvidx] & 0x0000ffff;
if (base >= VL_MAX_ADDREXTBLKS) {
VLog(0,
("Internal error: Multihome extent base is too large. Base %d index %d\n",
base, index));
continue;
}
- if (!ex_addr[base]) {
+ if (!ctx.ex_addr[base]) {
VLog(0,
("Internal error: Multihome extent does not exist. Base %d\n",
base));
}
/* See if the addresses to register will change this server entry */
- exp = &ex_addr[base][index];
+ exp = &ctx.ex_addr[base][index];
tuuid = exp->ex_hostuuid;
afs_ntohuuid(&tuuid);
if (afs_uuid_equal(uuidp, &tuuid)) {
* See if the addresses to register will replace this server entry.
*/
for (k = 0; k < cnt; k++) {
- if (HostAddress[srvidx] == addrs[k]) {
+ if (ctx.hostaddress[srvidx] == addrs[k]) {
willChangeEntry = 1;
WillChange[count] = srvidx;
WillReplaceEntry = 1;
VLog(0,
(" It would have replaced the existing VLDB server entry:\n"));
VLog(0, (" entry %d: [", FoundUuid));
- base = (HostAddress[FoundUuid] >> 16) & 0xff;
- index = HostAddress[FoundUuid] & 0x0000ffff;
- exp = &ex_addr[base][index];
+ base = (ctx.hostaddress[FoundUuid] >> 16) & 0xff;
+ index = ctx.hostaddress[FoundUuid] & 0x0000ffff;
+ exp = &ctx.ex_addr[base][index];
for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
if (!exp->ex_addrs[mhidx])
continue;
for (j = 0; j < count; j++) {
srvidx = WillChange[j];
VLog(0, (" entry %d: ", srvidx));
- if ((HostAddress[srvidx] & 0xff000000) == 0xff000000) {
+ if ((ctx.hostaddress[srvidx] & 0xff000000) == 0xff000000) {
VLog(0, ("["));
- base = (HostAddress[srvidx] >> 16) & 0xff;
- index = HostAddress[srvidx] & 0x0000ffff;
- exp = &ex_addr[base][index];
+ base = (ctx.hostaddress[srvidx] >> 16) & 0xff;
+ index = ctx.hostaddress[srvidx] & 0x0000ffff;
+ exp = &ctx.ex_addr[base][index];
for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
if (!exp->ex_addrs[mhidx])
continue;
}
VLog(0, ("]"));
} else {
- PADDR(HostAddress[srvidx]);
+ PADDR(ctx.hostaddress[srvidx]);
}
VLog(0, ("\n"));
}
if (count == 1)
VLog(0, (" You must 'vos changeaddr' this other server entry\n"));
else
- VLog(0,
+ VLog(0,
(" You must 'vos changeaddr' these other server entries\n"));
if (foundUuidEntry)
- VLog(0,
+ VLog(0,
(" and/or remove the sysid file from the registering fileserver\n"));
VLog(0, (" before the fileserver can be registered in the VLDB.\n"));
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_MULTIPADDR;
}
/* Found the entry with same uuid. See if we need to change it */
int change = 0;
- fbase = (HostAddress[FoundUuid] >> 16) & 0xff;
- index = HostAddress[FoundUuid] & 0x0000ffff;
- exp = &ex_addr[fbase][index];
+ fbase = (ctx.hostaddress[FoundUuid] >> 16) & 0xff;
+ index = ctx.hostaddress[FoundUuid] & 0x0000ffff;
+ exp = &ctx.ex_addr[fbase][index];
/* Determine if the entry has changed */
for (k = 0; ((k < cnt) && !change); k++) {
change = 1;
}
if (!change) {
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
}
VLog(0, ("]\n"));
if (foundUuidEntry) {
- VLog(0,
+ VLog(0,
(" It will replace the following existing entry in the VLDB (same uuid):\n"));
VLog(0, (" entry %d: [", FoundUuid));
for (k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
}
/* Have an entry that needs to be replaced */
- if ((HostAddress[ReplaceEntry] & 0xff000000) == 0xff000000) {
- fbase = (HostAddress[ReplaceEntry] >> 16) & 0xff;
- index = HostAddress[ReplaceEntry] & 0x0000ffff;
- exp = &ex_addr[fbase][index];
+ if ((ctx.hostaddress[ReplaceEntry] & 0xff000000) == 0xff000000) {
+ fbase = (ctx.hostaddress[ReplaceEntry] >> 16) & 0xff;
+ index = ctx.hostaddress[ReplaceEntry] & 0x0000ffff;
+ exp = &ctx.ex_addr[fbase][index];
- VLog(0,
+ VLog(0,
(" It will replace the following existing entry in the VLDB (new uuid):\n"));
VLog(0, (" entry %d: [", ReplaceEntry));
for (k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
}
VLog(0, ("]\n"));
} else {
- /* Not a mh entry. So we have to create a new mh entry and
- * put it on the ReplaceEntry slot of the HostAddress array.
+ /* Not a mh entry. So we have to create a new mh entry and
+ * put it on the ReplaceEntry slot of the ctx.hostaddress array.
*/
VLog(0, (" It will replace existing entry %d, ", ReplaceEntry));
- PADDR(HostAddress[ReplaceEntry]);
+ PADDR(ctx.hostaddress[ReplaceEntry]);
VLog(0,(", in the VLDB (new uuid):\n"));
code =
- FindExtentBlock(trans, uuidp, 1, ReplaceEntry, &exp, &fbase);
+ FindExtentBlock(&ctx, uuidp, 1, ReplaceEntry, &exp, &fbase);
if (code || !exp) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return (code ? code : VL_IO);
}
}
} else {
/* There is no entry for this server, must create a new mh entry as
- * well as use a new slot of the HostAddress array.
+ * well as use a new slot of the ctx.hostaddress array.
*/
VLog(0, (" It will create a new entry in the VLDB.\n"));
- code = FindExtentBlock(trans, uuidp, 1, -1, &exp, &fbase);
+ code = FindExtentBlock(&ctx, uuidp, 1, -1, &exp, &fbase);
if (code || !exp) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return (code ? code : VL_IO);
}
}
/* Write the new mh entry out */
if (vlwrite
- (trans,
- DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[fbase]),
- (char *)ex_addr[fbase], (char *)exp), (char *)exp,
+ (ctx.trans,
+ DOFFSET(ntohl(ctx.ex_addr[0]->ex_contaddrs[fbase]),
+ (char *)ctx.ex_addr[fbase], (char *)exp), (char *)exp,
sizeof(*exp))) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_IO;
}
- /* Remove any common addresses from other mh entres. We know these entries
+ /* Remove any common addresses from other mh entres. We know these entries
* are being changed and not replaced so they are mh entries.
*/
m = 0;
if (willReplaceCnt && (WillChange[i] == ReplaceEntry))
continue;
- base = (HostAddress[WillChange[i]] >> 16) & 0xff;
- index = HostAddress[WillChange[i]] & 0x0000ffff;
- tex = &ex_addr[fbase][index];
+ base = (ctx.hostaddress[WillChange[i]] >> 16) & 0xff;
+ index = ctx.hostaddress[WillChange[i]] & 0x0000ffff;
+ tex = &ctx.ex_addr[fbase][index];
if (++m == 1)
- VLog(0,
+ VLog(0,
(" The following existing entries in the VLDB will be updated:\n"));
VLog(0, (" entry %d: [", WillChange[i]));
/* Write out the modified mh entry */
tex->ex_uniquifier = htonl(ntohl(tex->ex_uniquifier) + 1);
doff =
- DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[base]),
- (char *)ex_addr[base], (char *)tex);
- if (vlwrite(trans, doff, (char *)tex, sizeof(*tex))) {
- ubik_AbortTrans(trans);
+ DOFFSET(ntohl(ctx.ex_addr[0]->ex_contaddrs[base]),
+ (char *)ctx.ex_addr[base], (char *)tex);
+ if (vlwrite(ctx.trans, doff, (char *)tex, sizeof(*tex))) {
+ ubik_AbortTrans(ctx.trans);
return VL_IO;
}
}
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
afs_int32
afs_int32 *nentries,
bulkaddrs *addrsp)
{
- register afs_int32 errorcode, index = -1, offset;
- struct ubik_trans *trans;
+ afs_int32 errorcode, index = -1, offset;
+ struct vl_ctx ctx;
int nservers, i, j, base = 0;
struct extentaddr *exp = 0;
afsUUID tuuid;
afs_uint32 *taddrp, taddr;
+ char rxstr[AFS_RXINFO_LEN];
COUNT_REQ(VLGETADDRSU);
addrsp->bulkaddrs_len = *nentries = 0;
addrsp->bulkaddrs_val = 0;
- VLog(5, ("GetAddrsU %s\n", rxinfo(rxcall)));
- if ((errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)))
+ VLog(5, ("GetAddrsU %s\n", rxinfo(rxstr, rxcall)));
+ if ((errorcode = Init_VLdbase(&ctx, LOCKREAD, this_op)))
return errorcode;
if (attributes->Mask & VLADDR_IPADDR) {
if (attributes->Mask & (VLADDR_INDEX | VLADDR_UUID)) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_BADMASK;
}
for (base = 0; base < VL_MAX_ADDREXTBLKS; base++) {
- if (!ex_addr[base])
+ if (!ctx.ex_addr[base])
break;
for (i = 1; i < VL_MHSRV_PERBLK; i++) {
- exp = &ex_addr[base][i];
+ exp = &ctx.ex_addr[base][i];
tuuid = exp->ex_hostuuid;
afs_ntohuuid(&tuuid);
if (afs_uuid_is_nil(&tuuid))
break;
}
if (base >= VL_MAX_ADDREXTBLKS) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOENT;
}
} else if (attributes->Mask & VLADDR_INDEX) {
if (attributes->Mask & (VLADDR_IPADDR | VLADDR_UUID)) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_BADMASK;
}
index = attributes->index;
if (index < 1 || index >= (VL_MAX_ADDREXTBLKS * VL_MHSRV_PERBLK)) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_INDEXERANGE;
}
base = index / VL_MHSRV_PERBLK;
offset = index % VL_MHSRV_PERBLK;
if (offset == 0) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOENT;
}
- if (!ex_addr[base]) {
- ubik_AbortTrans(trans);
+ if (!ctx.ex_addr[base]) {
+ ubik_AbortTrans(ctx.trans);
return VL_INDEXERANGE;
}
- exp = &ex_addr[base][offset];
+ exp = &ctx.ex_addr[base][offset];
} else if (attributes->Mask & VLADDR_UUID) {
if (attributes->Mask & (VLADDR_IPADDR | VLADDR_INDEX)) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_BADMASK;
}
- if (!ex_addr[0]) { /* mh servers probably aren't setup on this vldb */
- ubik_AbortTrans(trans);
+ if (!ctx.ex_addr[0]) { /* mh servers probably aren't setup on this vldb */
+ ubik_AbortTrans(ctx.trans);
return VL_NOENT;
}
if ((errorcode =
- FindExtentBlock(trans, &attributes->uuid, 0, -1, &exp, &base))) {
- ubik_AbortTrans(trans);
+ FindExtentBlock(&ctx, &attributes->uuid, 0, -1, &exp, &base))) {
+ ubik_AbortTrans(ctx.trans);
return errorcode;
}
} else {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_BADMASK;
}
if (exp == NULL) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOENT;
}
addrsp->bulkaddrs_val = taddrp =
nservers = *nentries = addrsp->bulkaddrs_len = 0;
if (!taddrp) {
COUNT_ABO;
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOMEM;
}
tuuid = exp->ex_hostuuid;
afs_ntohuuid(&tuuid);
if (afs_uuid_is_nil(&tuuid)) {
- ubik_AbortTrans(trans);
+ ubik_AbortTrans(ctx.trans);
return VL_NOENT;
}
if (uuidpo)
}
}
addrsp->bulkaddrs_len = *nentries = nservers;
- return (ubik_EndTrans(trans));
+ return (ubik_EndTrans(ctx.trans));
}
/* ============> End of Exported vldb RPC functions <============= */
/* Routine that copies the given vldb entry to the output buffer, vldbentries. */
static int
-put_attributeentry(struct vldbentry **Vldbentry,
+put_attributeentry(struct vl_ctx *ctx,
+ struct vldbentry **Vldbentry,
struct vldbentry **VldbentryFirst,
struct vldbentry **VldbentryLast,
bulkentries *vldbentries,
return VL_SIZEEXCEEDED; /* no growing if smallMem defined */
/* Allocate another set of memory; each time allocate twice as
- * many blocks as the last time. When we reach VLDBALLOCLIMIT,
+ * many blocks as the last time. When we reach VLDBALLOCLIMIT,
* then grow in increments of VLDBALLOCINCR.
*/
allo = (*alloccnt > VLDBALLOCLIMIT) ? VLDBALLOCINCR : *alloccnt;
*VldbentryLast = *Vldbentry + allo;
*alloccnt += allo;
}
- vlentry_to_vldbentry(entry, *Vldbentry);
+ vlentry_to_vldbentry(ctx, entry, *Vldbentry);
(*Vldbentry)++;
(*nentries)++;
vldbentries->bulkentries_len++;
}
static int
-put_nattributeentry(struct nvldbentry **Vldbentry,
+put_nattributeentry(struct vl_ctx *ctx,
+ struct nvldbentry **Vldbentry,
struct nvldbentry **VldbentryFirst,
struct nvldbentry **VldbentryLast,
nbulkentries *vldbentries,
return VL_SIZEEXCEEDED; /* no growing if smallMem defined */
/* Allocate another set of memory; each time allocate twice as
- * many blocks as the last time. When we reach VLDBALLOCLIMIT,
+ * many blocks as the last time. When we reach VLDBALLOCLIMIT,
* then grow in increments of VLDBALLOCINCR.
*/
allo = (*alloccnt > VLDBALLOCLIMIT) ? VLDBALLOCINCR : *alloccnt;
*VldbentryLast = *Vldbentry + allo;
*alloccnt += allo;
}
- vlentry_to_nvldbentry(entry, *Vldbentry);
+ vlentry_to_nvldbentry(ctx, entry, *Vldbentry);
(*Vldbentry)->matchindex = (matchtype << 16) + matchindex;
(*Vldbentry)++;
(*nentries)++;
/* Common code to actually remove a vldb entry from the database. */
static int
-RemoveEntry(struct ubik_trans *trans, afs_int32 entryptr,
+RemoveEntry(struct vl_ctx *ctx, afs_int32 entryptr,
struct nvlentry *tentry)
{
- register int errorcode;
+ int errorcode;
- if ((errorcode = UnthreadVLentry(trans, entryptr, tentry)))
+ if ((errorcode = UnthreadVLentry(ctx, entryptr, tentry)))
return errorcode;
- if ((errorcode = FreeBlock(trans, entryptr)))
+ if ((errorcode = FreeBlock(ctx, entryptr)))
return errorcode;
return 0;
}
/* Convert from the external vldb entry representation to its internal
(more compact) form. This call should not change the hash chains! */
static int
-vldbentry_to_vlentry(struct ubik_trans *atrans,
+vldbentry_to_vlentry(struct vl_ctx *ctx,
struct vldbentry *VldbEntry,
struct nvlentry *VlEntry)
{
if (strcmp(VlEntry->name, VldbEntry->name))
strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name));
for (i = 0; i < VldbEntry->nServers; i++) {
- serverindex = IpAddrToRelAddr(VldbEntry->serverNumber[i], atrans);
+ serverindex = IpAddrToRelAddr(ctx, VldbEntry->serverNumber[i], 1);
if (serverindex == -1)
return VL_BADSERVER;
VlEntry->serverNumber[i] = serverindex;
}
static int
-nvldbentry_to_vlentry(struct ubik_trans *atrans,
+nvldbentry_to_vlentry(struct vl_ctx *ctx,
struct nvldbentry *VldbEntry,
struct nvlentry *VlEntry)
{
if (strcmp(VlEntry->name, VldbEntry->name))
strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name));
for (i = 0; i < VldbEntry->nServers; i++) {
- serverindex = IpAddrToRelAddr(VldbEntry->serverNumber[i], atrans);
+ serverindex = IpAddrToRelAddr(ctx, VldbEntry->serverNumber[i], 1);
if (serverindex == -1)
return VL_BADSERVER;
VlEntry->serverNumber[i] = serverindex;
* checks are performed.
*/
static int
-get_vldbupdateentry(struct ubik_trans *trans,
+get_vldbupdateentry(struct vl_ctx *ctx,
afs_int32 blockindex,
struct VldbUpdateEntry *updateentry,
struct nvlentry *VlEntry)
checkids[BACKVOL] = updateentry->BackupId;
}
- if (EntryIDExists(trans, checkids, MAXTYPES, &errorcode)) {
+ if (EntryIDExists(ctx, checkids, MAXTYPES, &errorcode)) {
return VL_IDEXIST;
} else if (errorcode) {
return errorcode;
if (InvalidVolname(updateentry->name))
return VL_BADNAME;
- if (FindByName(trans, updateentry->name, &tentry, &errorcode)) {
+ if (FindByName(ctx, updateentry->name, &tentry, &errorcode)) {
return VL_NAMEEXIST;
} else if (errorcode) {
return errorcode;
}
- if ((errorcode = UnhashVolname(trans, blockindex, VlEntry)))
+ if ((errorcode = UnhashVolname(ctx, blockindex, VlEntry)))
return errorcode;
strncpy(VlEntry->name, updateentry->name, sizeof(VlEntry->name));
- HashVolname(trans, blockindex, VlEntry);
+ HashVolname(ctx, blockindex, VlEntry);
}
if (updateentry->Mask & VLUPDATE_VOLNAMEHASH) {
- if ((errorcode = UnhashVolname(trans, blockindex, VlEntry))) {
+ if ((errorcode = UnhashVolname(ctx, blockindex, VlEntry))) {
if (errorcode != VL_NOENT)
return errorcode;
}
- HashVolname(trans, blockindex, VlEntry);
+ HashVolname(ctx, blockindex, VlEntry);
}
if (updateentry->Mask & VLUPDATE_FLAGS) {
VlEntry->cloneId = updateentry->cloneId;
}
if (updateentry->Mask & VLUPDATE_RWID) {
- if ((errorcode = UnhashVolid(trans, RWVOL, blockindex, VlEntry))) {
+ if ((errorcode = UnhashVolid(ctx, RWVOL, blockindex, VlEntry))) {
if (errorcode != VL_NOENT)
return errorcode;
}
VlEntry->volumeId[RWVOL] = updateentry->spares3; /* rw id */
- if ((errorcode = HashVolid(trans, RWVOL, blockindex, VlEntry)))
+ if ((errorcode = HashVolid(ctx, RWVOL, blockindex, VlEntry)))
return errorcode;
}
if (updateentry->Mask & VLUPDATE_READONLYID) {
- if ((errorcode = UnhashVolid(trans, ROVOL, blockindex, VlEntry))) {
+ if ((errorcode = UnhashVolid(ctx, ROVOL, blockindex, VlEntry))) {
if (errorcode != VL_NOENT)
return errorcode;
}
VlEntry->volumeId[ROVOL] = updateentry->ReadOnlyId;
- if ((errorcode = HashVolid(trans, ROVOL, blockindex, VlEntry)))
+ if ((errorcode = HashVolid(ctx, ROVOL, blockindex, VlEntry)))
return errorcode;
}
if (updateentry->Mask & VLUPDATE_BACKUPID) {
- if ((errorcode = UnhashVolid(trans, BACKVOL, blockindex, VlEntry))) {
+ if ((errorcode = UnhashVolid(ctx, BACKVOL, blockindex, VlEntry))) {
if (errorcode != VL_NOENT)
return errorcode;
}
VlEntry->volumeId[BACKVOL] = updateentry->BackupId;
- if ((errorcode = HashVolid(trans, BACKVOL, blockindex, VlEntry)))
+ if ((errorcode = HashVolid(ctx, BACKVOL, blockindex, VlEntry)))
return errorcode;
}
if (updateentry->Mask & VLUPDATE_REPSITES) {
if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_DELETE) {
if ((j =
repsite_exists(VlEntry,
- IpAddrToRelAddr(updateentry->
+ IpAddrToRelAddr(ctx, updateentry->
RepsitesTargetServer[i],
- trans),
+ 1),
updateentry->RepsitesTargetPart[i])) !=
-1)
repsite_compress(VlEntry, j);
return VL_BADPARTITION;
if (repsite_exists
(VlEntry,
- IpAddrToRelAddr(updateentry->RepsitesNewServer[i],
- trans),
+ IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i], 1),
updateentry->RepsitesNewPart[i]) != -1)
return VL_DUPREPSERVER;
for (j = 0;
if (j >= OMAXNSERVERS)
return VL_REPSFULL;
if ((serverindex =
- IpAddrToRelAddr(updateentry->RepsitesNewServer[i],
- trans)) == -1)
+ IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i],
+ 1)) == -1)
return VL_BADSERVER;
VlEntry->serverNumber[j] = serverindex;
VlEntry->serverPartition[j] = updateentry->RepsitesNewPart[i];
return VL_BADSERVER; */
if ((j =
repsite_exists(VlEntry,
- IpAddrToRelAddr(updateentry->
+ IpAddrToRelAddr(ctx, updateentry->
RepsitesTargetServer[i],
- trans),
+ 1),
updateentry->RepsitesTargetPart[i])) !=
-1) {
VlEntry->serverNumber[j] =
- IpAddrToRelAddr(updateentry->RepsitesNewServer[i],
- trans);
+ IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i],
+ 1);
} else
return VL_NOREPSERVER;
}
return VL_BADPARTITION;
if ((j =
repsite_exists(VlEntry,
- IpAddrToRelAddr(updateentry->
+ IpAddrToRelAddr(ctx, updateentry->
RepsitesTargetServer[i],
- trans),
+ 1),
updateentry->RepsitesTargetPart[i])) !=
-1)
VlEntry->serverPartition[j] =
if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODFLAG) {
if ((j =
repsite_exists(VlEntry,
- IpAddrToRelAddr(updateentry->
+ IpAddrToRelAddr(ctx, updateentry->
RepsitesTargetServer[i],
- trans),
+ 1),
updateentry->RepsitesTargetPart[i])) !=
-1) {
if (updateentry->RepsitesNewFlags[i] < 0
/* Convert from the internal (compacted) vldb entry to the external
* representation used by the interface. */
static void
-vlentry_to_vldbentry(struct nvlentry *VlEntry, struct vldbentry *VldbEntry)
+vlentry_to_vldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
+ struct vldbentry *VldbEntry)
{
int i, j;
for (i = 0; i < OMAXNSERVERS; i++) {
if (VlEntry->serverNumber[i] == BADSERVERID)
break;
- if ((HostAddress[j = VlEntry->serverNumber[i]] & 0xff000000) ==
+ if ((ctx->hostaddress[j = VlEntry->serverNumber[i]] & 0xff000000) ==
0xff000000) {
struct extentaddr *exp;
int base, index;
- base = (HostAddress[j] >> 16) & 0xff;
- index = HostAddress[j] & 0x0000ffff;
- exp = &ex_addr[base][index];
+ base = (ctx->hostaddress[j] >> 16) & 0xff;
+ index = ctx->hostaddress[j] & 0x0000ffff;
+ exp = &ctx->ex_addr[base][index];
/* For now return the first ip address back */
for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
if (exp->ex_addrs[j]) {
}
} else
VldbEntry->serverNumber[i] =
- HostAddress[VlEntry->serverNumber[i]];
+ ctx->hostaddress[VlEntry->serverNumber[i]];
VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
}
/* Convert from the internal (compacted) vldb entry to the external
* representation used by the interface. */
static void
-vlentry_to_nvldbentry(struct nvlentry *VlEntry, struct nvldbentry *VldbEntry)
+vlentry_to_nvldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
+ struct nvldbentry *VldbEntry)
{
int i, j;
for (i = 0; i < NMAXNSERVERS; i++) {
if (VlEntry->serverNumber[i] == BADSERVERID)
break;
- if ((HostAddress[j = VlEntry->serverNumber[i]] & 0xff000000) ==
+ if ((ctx->hostaddress[j = VlEntry->serverNumber[i]] & 0xff000000) ==
0xff000000) {
struct extentaddr *exp;
int base, index;
- base = (HostAddress[j] >> 16) & 0xff;
- index = HostAddress[j] & 0x0000ffff;
- exp = &ex_addr[base][index];
+ base = (ctx->hostaddress[j] >> 16) & 0xff;
+ index = ctx->hostaddress[j] & 0x0000ffff;
+ exp = &ctx->ex_addr[base][index];
/* For now return the first ip address back */
for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
if (exp->ex_addrs[j]) {
}
} else
VldbEntry->serverNumber[i] =
- HostAddress[VlEntry->serverNumber[i]];
+ ctx->hostaddress[VlEntry->serverNumber[i]];
VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
}
}
static void
-vlentry_to_uvldbentry(struct nvlentry *VlEntry, struct uvldbentry *VldbEntry)
+vlentry_to_uvldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
+ struct uvldbentry *VldbEntry)
{
int i, j;
break;
VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
VldbEntry->serverUnique[i] = 0;
- if ((HostAddress[j = VlEntry->serverNumber[i]] & 0xff000000) ==
+ if ((ctx->hostaddress[j = VlEntry->serverNumber[i]] & 0xff000000) ==
0xff000000) {
struct extentaddr *exp;
int base, index;
afsUUID tuuid;
- base = (HostAddress[j] >> 16) & 0xff;
- index = HostAddress[j] & 0x0000ffff;
- exp = &ex_addr[base][index];
+ base = (ctx->hostaddress[j] >> 16) & 0xff;
+ index = ctx->hostaddress[j] & 0x0000ffff;
+ exp = &ctx->ex_addr[base][index];
tuuid = exp->ex_hostuuid;
afs_ntohuuid(&tuuid);
VldbEntry->serverFlags[i] |= VLSERVER_FLAG_UUID;
VldbEntry->serverUnique[i] = ntohl(exp->ex_uniquifier);
} else {
VldbEntry->serverNumber[i].time_low =
- HostAddress[VlEntry->serverNumber[i]];
+ ctx->hostaddress[VlEntry->serverNumber[i]];
}
VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
}
static int
-IpAddrToRelAddr(register afs_uint32 ipaddr, struct ubik_trans *atrans)
+IpAddrToRelAddr(struct vl_ctx *ctx, afs_uint32 ipaddr, int create)
{
- register int i, j;
- register afs_int32 code, base, index;
+ int i, j;
+ afs_int32 code, base, index;
struct extentaddr *exp;
for (i = 0; i <= MAXSERVERID; i++) {
- if (HostAddress[i] == ipaddr)
+ if (ctx->hostaddress[i] == ipaddr)
return i;
- if ((HostAddress[i] & 0xff000000) == 0xff000000) {
- base = (HostAddress[i] >> 16) & 0xff;
- index = HostAddress[i] & 0x0000ffff;
+ if ((ctx->hostaddress[i] & 0xff000000) == 0xff000000) {
+ base = (ctx->hostaddress[i] >> 16) & 0xff;
+ index = ctx->hostaddress[i] & 0x0000ffff;
if (base >= VL_MAX_ADDREXTBLKS) {
VLog(0,
("Internal error: Multihome extent base is too large. Base %d index %d\n",
base, index));
return -1; /* EINVAL */
}
- if (!ex_addr[base]) {
+ if (!ctx->ex_addr[base]) {
VLog(0,
("Internal error: Multihome extent does not exist. Base %d\n",
base));
return -1; /* EINVAL */
}
- exp = &ex_addr[base][index];
+ exp = &ctx->ex_addr[base][index];
for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
if (exp->ex_addrs[j] && (ntohl(exp->ex_addrs[j]) == ipaddr)) {
return i;
}
/* allocate the new server a server id pronto */
- if (atrans) {
+ if (create) {
for (i = 0; i <= MAXSERVERID; i++) {
- if (cheader.IpMappedAddr[i] == 0) {
- cheader.IpMappedAddr[i] = htonl(ipaddr);
+ if (ctx->cheader->IpMappedAddr[i] == 0) {
+ ctx->cheader->IpMappedAddr[i] = htonl(ipaddr);
code =
- vlwrite(atrans,
- DOFFSET(0, &cheader, &cheader.IpMappedAddr[i]),
- (char *)&cheader.IpMappedAddr[i],
+ vlwrite(ctx->trans,
+ DOFFSET(0, ctx->cheader, &ctx->cheader->IpMappedAddr[i]),
+ (char *)&ctx->cheader->IpMappedAddr[i],
sizeof(afs_int32));
- HostAddress[i] = ipaddr;
+ ctx->hostaddress[i] = ipaddr;
if (code)
return -1;
return i;
}
static int
-ChangeIPAddr(afs_uint32 ipaddr1, afs_uint32 ipaddr2, struct ubik_trans *atrans)
+ChangeIPAddr(struct vl_ctx *ctx, afs_uint32 ipaddr1, afs_uint32 ipaddr2)
{
int i, j;
afs_int32 code;
afs_int32 blockindex, count;
int pollcount = 0;
struct nvlentry tentry;
-
- if (!atrans)
- return VL_CREATEFAIL;
+ int ipaddr1_id = -1, ipaddr2_id = -1;
/* Don't let addr change to 256.*.*.* : Causes internal error below */
if ((ipaddr2 & 0xff000000) == 0xff000000)
}
for (i = 0; i <= MAXSERVERID; i++) {
- if ((HostAddress[i] & 0xff000000) == 0xff000000) {
- base = (HostAddress[i] >> 16) & 0xff;
- index = HostAddress[i] & 0x0000ffff;
+ if ((ctx->hostaddress[i] & 0xff000000) == 0xff000000) {
+ base = (ctx->hostaddress[i] >> 16) & 0xff;
+ index = ctx->hostaddress[i] & 0x0000ffff;
if ((base >= VL_MAX_ADDREXTBLKS) || (index >= VL_MHSRV_PERBLK)) {
VLog(0,
("Internal error: Multihome extent addr is too large. Base %d index %d\n",
return -1; /* EINVAL */
}
- exp = &ex_addr[base][index];
+ exp = &ctx->ex_addr[base][index];
for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
if (!exp->ex_addrs[mhidx])
continue;
- if (ntohl(exp->ex_addrs[mhidx]) == ipaddr1)
- break;
+ if (ntohl(exp->ex_addrs[mhidx]) == ipaddr1) {
+ ipaddr1_id = i;
+ }
+ if (ipaddr2 != 0 && ntohl(exp->ex_addrs[mhidx]) == ipaddr2) {
+ ipaddr2_id = i;
+ }
}
- if (mhidx < VL_MAXIPADDRS_PERMH) {
- break;
+ } else {
+ if (ctx->hostaddress[i] == ipaddr1) {
+ exp = NULL;
+ ipaddr1_id = i;
+ }
+ if (ipaddr2 != 0 && ctx->hostaddress[i] == ipaddr2) {
+ ipaddr2_id = i;
}
- } else if (HostAddress[i] == ipaddr1) {
- exp = NULL;
+ }
+
+ if (ipaddr1_id >= 0 && (ipaddr2 == 0 || ipaddr2_id >= 0)) {
+ /* we've either found both IPs already in the VLDB, or we found
+ * ipaddr1, and we're not going to find ipaddr2 because it's 0 */
break;
}
}
- if (i >= MAXSERVERID) {
+ if (ipaddr1_id < 0) {
return VL_NOENT; /* not found */
}
+ if (ipaddr2_id >= 0 && ipaddr2_id != ipaddr1_id) {
+ char buf1[16], buf2[16];
+ VLog(0, ("Cannot change IP address from %s to %s because the latter "
+ "is in use by server id %d\n",
+ afs_inet_ntoa_r(htonl(ipaddr1), buf1),
+ afs_inet_ntoa_r(htonl(ipaddr2), buf2),
+ ipaddr2_id));
+ return VL_MULTIPADDR;
+ }
+
/* If we are removing a server entry, a volume cannot
* exist on the server. If one does, don't remove the
* server entry: return error "volume entry exists".
*/
if (ipaddr2 == 0) {
- for (blockindex = NextEntry(atrans, 0, &tentry, &count); blockindex;
- blockindex = NextEntry(atrans, blockindex, &tentry, &count)) {
+ for (blockindex = NextEntry(ctx, 0, &tentry, &count); blockindex;
+ blockindex = NextEntry(ctx, blockindex, &tentry, &count)) {
if (++pollcount > 50) {
#ifndef AFS_PTHREAD_ENV
IOMGR_Poll();
for (j = 0; j < NMAXNSERVERS; j++) {
if (tentry.serverNumber[j] == BADSERVERID)
break;
- if (tentry.serverNumber[j] == i) {
+ if (tentry.serverNumber[j] == ipaddr1_id) {
return VL_IDEXIST;
}
}
afs_htonuuid(&tuuid);
exp->ex_hostuuid = tuuid;
code =
- vlwrite(atrans,
- DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[base]),
- (char *)ex_addr[base], (char *)exp),
+ vlwrite(ctx->trans,
+ DOFFSET(ntohl(ctx->ex_addr[0]->ex_contaddrs[base]),
+ (char *)ctx->ex_addr[base], (char *)exp),
(char *)&tuuid, sizeof(tuuid));
if (code)
return VL_IO;
}
/* Now change the host address entry */
- cheader.IpMappedAddr[i] = htonl(ipaddr2);
+ ctx->cheader->IpMappedAddr[ipaddr1_id] = htonl(ipaddr2);
code =
- vlwrite(atrans, DOFFSET(0, &cheader, &cheader.IpMappedAddr[i]),
+ vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->IpMappedAddr[ipaddr1_id]),
(char *)
- &cheader.IpMappedAddr[i], sizeof(afs_int32));
- HostAddress[i] = ipaddr2;
+ &ctx->cheader->IpMappedAddr[ipaddr1_id], sizeof(afs_int32));
+ ctx->hostaddress[ipaddr1_id] = ipaddr2;
if (code)
return VL_IO;
git://git.openafs.org / openafs.git / blobdiff