code = (c); \
goto abort; \
} while (0)
-#undef END
-#define END(c) do { \
- code = (c); \
- goto end; \
-} while (0)
#define VLDBALLOCLIMIT 10000
#define VLDBALLOCINCR 2048
* (non-existant in vldb).
*/
-afs_int32
-SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
+static afs_int32
+CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
{
int this_op = VLCREATEENTRY;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
- code = VL_PERM;
- goto end;
+ return VL_PERM;
}
/* Do some validity tests on new entry */
if ((code = check_vldbentry(newentry))
|| (code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1,
("OCreate Volume %d %s\n", newentry->volumeId[RWVOL],
FreeBlock(&ctx, blockindex);
goto abort;
} else {
- code = ubik_EndTrans(ctx.trans);
- goto end;
+ return ubik_EndTrans(ctx.trans);
}
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
+
+afs_int32
+SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
+{
+ afs_int32 code;
- end:
+ code = CreateEntry(rxcall, newentry);
osi_auditU(rxcall, VLCreateEntryEvent, code, AUD_STR,
(newentry ? newentry->name : NULL), AUD_END);
return code;
}
-
-afs_int32
-SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
+static afs_int32
+CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
{
int this_op = VLCREATEENTRYN;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
- code = VL_PERM;
- goto end;
+ return VL_PERM;
}
/* Do some validity tests on new entry */
if ((code = check_nvldbentry(newentry))
|| (code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1,
("Create Volume %d %s\n", newentry->volumeId[RWVOL],
FreeBlock(&ctx, blockindex);
goto abort;
} else {
- code = ubik_EndTrans(ctx.trans);
- goto end;
+ return ubik_EndTrans(ctx.trans);
}
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
+{
+ afs_int32 code;
+
+ code = CreateEntryN(rxcall, newentry);
osi_auditU(rxcall, VLCreateEntryEvent, code, AUD_STR,
(newentry ? newentry->name : NULL), AUD_END);
return code;
}
-
-afs_int32
-SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
+static afs_int32
+ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
{
int this_op = VLCHANGEADDR;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
- code = VL_PERM;
- goto end;
+ return VL_PERM;
}
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Change Addr %u -> %u %s\n", ip1, ip2, rxinfo(rxstr, rxcall)));
if ((code = ChangeIPAddr(&ctx, ip1, ip2)))
goto abort;
else {
code = ubik_EndTrans(ctx.trans);
- goto end;
+ return code;
}
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
+{
+ afs_int32 code;
+
+ code = ChangeAddr(rxcall, ip1, ip2);
osi_auditU(rxcall, VLChangeAddrEvent, code, AUD_LONG, ip1, AUD_LONG,
ip2, AUD_END);
return code;
}
/* Delete a vldb entry given the volume id. */
-afs_int32
-SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
+static afs_int32
+DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
{
int this_op = VLDELETEENTRY;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Delete Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if ((code = RemoveEntry(&ctx, blockindex, &tentry))) {
goto abort;
}
- code = (ubik_EndTrans(ctx.trans));
- goto end;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
+
+afs_int32
+SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
+{
+ afs_int32 code;
- end:
+ code = DeleteEntry(rxcall, volid, voltype);
osi_auditU(rxcall, VLDeleteEntryEvent, code, AUD_LONG, volid,
AUD_END);
return code;
/* Get a vldb entry given its volume id; make sure it's not a deleted entry. */
-int
+static int
GetEntryByID(struct rx_call *rxcall,
afs_uint32 volid,
afs_int32 voltype,
/* Get a vldb entry given the volume's name; of course, very similar to
* VLGetEntryByID() above. */
-afs_int32
+static afs_int32
GetEntryByName(struct rx_call *rxcall,
char *volname,
char *aentry, /* entry data copied here */
VLGETENTRYBYNAME));
}
-
afs_int32
SVL_GetEntryByNameN(struct rx_call *rxcall,
char *volname,
VLGETENTRYBYNAMEU));
}
-
-
/* Get the current value of the maximum volume id and bump the volume id counter by Maxvolidbump. */
-afs_int32
-SVL_GetNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
+static afs_int32
+getNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
afs_uint32 *newvolumeid)
{
int this_op = VLGETNEWVOLUMEID;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if (Maxvolidbump > MAXBUMPCOUNT)
- END(VL_BADVOLIDBUMP);
+ return VL_BADVOLIDBUMP;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
*newvolumeid = maxvolumeid = NextUnusedID(&ctx,
ntohl(ctx.cheader->vital_header.MaxVolumeId), Maxvolidbump, &code);
if (write_vital_vlheader(&ctx)) {
ABORT(VL_IO);
}
- code = (ubik_EndTrans(ctx.trans));
- goto end;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_GetNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
+ afs_uint32 *newvolumeid)
+{
+ afs_int32 code;
+
+ code = getNewVolumeId(rxcall, Maxvolidbump, newvolumeid);
osi_auditU(rxcall, VLGetNewVolumeIdEvent, code, AUD_END);
return code;
}
* newentry. No individual checking/updating per field (alike
* VLUpdateEntry) is done. */
-afs_int32
-SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+static afs_int32
+ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
struct vldbentry *newentry, afs_int32 releasetype)
{
int this_op = VLREPLACEENTRY;
hashVol[typeindex] = 0;
hashnewname = 0;
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((code = check_vldbentry(newentry)))
- goto end;
+ return code;
if (voltype != -1 && InvalidVoltype(voltype))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("OReplace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
/* find vlentry we're changing */
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- end:
- osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid,
- AUD_END);
return code;
}
afs_int32
-SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ struct vldbentry *newentry, afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = ReplaceEntry(rxcall, volid, voltype, newentry, releasetype);
+ osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid, AUD_END);
+ return code;
+}
+
+static afs_int32
+ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
struct nvldbentry *newentry, afs_int32 releasetype)
{
int this_op = VLREPLACEENTRYN;
hashVol[typeindex] = 0;
hashnewname = 0;
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((code = check_nvldbentry(newentry)))
- goto end;
+ return code;
if (voltype != -1 && InvalidVoltype(voltype))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Replace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
/* find vlentry we're changing */
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
- osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid,
- AUD_END);
+afs_int32
+SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ struct nvldbentry *newentry, afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = ReplaceEntryN(rxcall, volid, voltype, newentry, releasetype);
+ osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid, AUD_END);
return code;
}
* appropriate bits in the Mask field in VldbUpdateentry. */
/* this routine may never have been tested; use replace entry instead
* unless you're brave */
-afs_int32
-SVL_UpdateEntry(struct rx_call *rxcall,
- afs_uint32 volid,
- afs_int32 voltype,
- struct VldbUpdateEntry *updateentry, /* Update entry copied here */
- afs_int32 releasetype)
+static afs_int32
+UpdateEntry(struct rx_call *rxcall,
+ afs_uint32 volid,
+ afs_int32 voltype,
+ struct VldbUpdateEntry *updateentry, /* Update entry copied here */
+ afs_int32 releasetype)
{
int this_op = VLUPDATEENTRY;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("Update Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- end:
- osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, volid,
- AUD_END);
return code;
}
-
afs_int32
-SVL_UpdateEntryByName(struct rx_call *rxcall,
- char *volname,
- struct VldbUpdateEntry *updateentry, /* Update entry copied here */
- afs_int32 releasetype)
+SVL_UpdateEntry(struct rx_call *rxcall,
+ afs_uint32 volid,
+ afs_int32 voltype,
+ struct VldbUpdateEntry *updateentry,
+ afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = UpdateEntry(rxcall, volid, voltype, updateentry, releasetype);
+ osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, volid, AUD_END);
+ return code;
+}
+
+static afs_int32
+UpdateEntryByName(struct rx_call *rxcall,
+ char *volname,
+ struct VldbUpdateEntry *updateentry, /* Update entry copied here */
+ afs_int32 releasetype)
{
int this_op = VLUPDATEENTRYBYNAME;
struct vl_ctx ctx;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
blockindex = FindByName(&ctx, volname, &tentry, &code);
if (blockindex == 0) { /* entry not found */
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
+
+afs_int32
+SVL_UpdateEntryByName(struct rx_call *rxcall,
+ char *volname,
+ struct VldbUpdateEntry *updateentry, /* Update entry copied here */
+ afs_int32 releasetype)
+{
+ afs_int32 code;
- end:
+ code = UpdateEntryByName(rxcall, volname, updateentry, releasetype);
osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, -1, AUD_END);
return code;
}
-
/* Set a lock to the vldb entry for volid (of type voltype if not -1). */
-afs_int32
-SVL_SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
- afs_int32 voloper)
+static afs_int32
+SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 voloper)
{
int this_op = VLSETLOCK;
afs_int32 timestamp, blockindex, code;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (InvalidOperation(voloper))
- END(VL_BADVOLOPER);
+ return VL_BADVOLOPER;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("SetLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
+ return code;
+}
- end:
+afs_int32
+SVL_SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 voloper)
+{
+ afs_int32 code;
+
+ code = SetLock(rxcall, volid, voltype, voloper);
osi_auditU(rxcall, VLSetLockEvent, code, AUD_LONG, volid, AUD_END);
return code;
}
-
/* Release an already locked vldb entry. Releasetype determines what
* fields (afsid and/or volume operation) will be cleared along with
* the lock time stamp. */
-afs_int32
-SVL_ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
- afs_int32 releasetype)
+static afs_int32
+ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 releasetype)
{
int this_op = VLRELEASELOCK;
afs_int32 blockindex, code;
countRequest(this_op);
if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
- END(VL_PERM);
+ return VL_PERM;
if ((voltype != -1) && (InvalidVoltype(voltype)))
- END(VL_BADVOLTYPE);
+ return VL_BADVOLTYPE;
if (releasetype && InvalidReleasetype(releasetype))
- END(VL_BADRELLOCKTYPE);
+ return VL_BADRELLOCKTYPE;
if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
- goto end;
+ return code;
VLog(1, ("ReleaseLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
ABORT(VL_IO);
}
- END(ubik_EndTrans(ctx.trans));
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- end:
- osi_auditU(rxcall, VLReleaseLockEvent, code, AUD_LONG, volid,
- AUD_END);
return code;
}
+afs_int32
+SVL_ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
+ afs_int32 releasetype)
+{
+ afs_int32 code;
+
+ code = ReleaseLock(rxcall, volid, voltype, releasetype);
+ osi_auditU(rxcall, VLReleaseLockEvent, code, AUD_LONG, volid, AUD_END);
+ return code;
+}
/* ListEntry returns a single vldb entry, aentry, with offset previous_index;
* the remaining parameters (i.e. next_index) are used so that sequential
* calls to this routine will get the next (all) vldb entries.
*/
-afs_int32
-SVL_ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
- afs_int32 *count, afs_int32 *next_index,
- struct vldbentry *aentry)
+static afs_int32
+ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct vldbentry *aentry)
{
int this_op = VLLISTENTRY;
int code;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
VLog(25, ("OListEntry index=%d %s\n", previous_index,
rxinfo(rxstr, rxcall)));
*next_index = NextEntry(&ctx, previous_index, &tentry, count);
if (code) {
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
- goto end;
+ return code;
}
}
- code = ubik_EndTrans(ctx.trans);
- end:
+ return ubik_EndTrans(ctx.trans);
+}
+
+afs_int32
+SVL_ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct vldbentry *aentry)
+{
+ afs_int32 code;
+
+ code = ListEntry(rxcall, previous_index, count, next_index, aentry);
osi_auditU(rxcall, VLListEntryEvent, code, AUD_LONG, previous_index, AUD_END);
return code;
}
* the remaining parameters (i.e. next_index) are used so that sequential
* calls to this routine will get the next (all) vldb entries.
*/
-afs_int32
-SVL_ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
- afs_int32 *count, afs_int32 *next_index,
- struct nvldbentry *aentry)
+static afs_int32
+ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct nvldbentry *aentry)
{
int this_op = VLLISTENTRYN;
int code;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxstr, rxcall)));
*next_index = NextEntry(&ctx, previous_index, &tentry, count);
if (*next_index) {
if (code) {
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
- goto end;
+ return code;
}
}
- code = ubik_EndTrans(ctx.trans);
- end:
+ return ubik_EndTrans(ctx.trans);
+}
+
+afs_int32
+SVL_ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
+ afs_int32 *count, afs_int32 *next_index,
+ struct nvldbentry *aentry)
+{
+ afs_int32 code;
+
+ code = ListEntryN(rxcall, previous_index, count, next_index, aentry);
osi_auditU(rxcall, VLListEntryEventN, code, AUD_LONG, previous_index, AUD_END);
return code;
}
-
/* Retrieves in vldbentries all vldb entries that match the specified
* attributes (by server number, partition, volume type, and flag); if volume
* id is specified then the associated list for that entry is returned.
* CAUTION: This could be a very expensive call since in most cases
* sequential search of all vldb entries is performed.
*/
-afs_int32
-SVL_ListAttributes(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- bulkentries *vldbentries)
+static afs_int32
+ListAttributes(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ bulkentries *vldbentries)
{
int this_op = VLLISTATTRIBUTES;
int code, allocCount = 0;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
vldbentries->bulkentries_val = 0;
vldbentries->bulkentries_len = *nentries = 0;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
allocCount = VLDBALLOCCOUNT;
Vldbentry = VldbentryFirst = vldbentries->bulkentries_val =
malloc(allocCount * sizeof(vldbentry));
VLog(5,
("ListAttrs nentries=%d %s\n", vldbentries->bulkentries_len,
rxinfo(rxstr, rxcall)));
- code = ubik_EndTrans(ctx.trans);
- end:
- osi_auditU(rxcall, VLListAttributesEvent, code, AUD_END);
- return code;
+ return ubik_EndTrans(ctx.trans);
abort:
if (vldbentries->bulkentries_val)
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
-
- goto end;
+ return code;
}
afs_int32
-SVL_ListAttributesN(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- nbulkentries *vldbentries)
+SVL_ListAttributes(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ bulkentries *vldbentries)
+{
+ afs_int32 code;
+
+ code = ListAttributes(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLListAttributesEvent, code, AUD_END);
+ return code;
+}
+
+static afs_int32
+ListAttributesN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries)
{
int this_op = VLLISTATTRIBUTESN;
int code, allocCount = 0;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = *nentries = 0;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
allocCount = VLDBALLOCCOUNT;
Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
malloc(allocCount * sizeof(nvldbentry));
VLog(5,
("NListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
rxinfo(rxstr, rxcall)));
- code = ubik_EndTrans(ctx.trans);
- end:
- osi_auditU(rxcall, VLListAttributesNEvent, code, AUD_END);
- return code;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
free(vldbentries->nbulkentries_val);
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = 0;
- goto end;
+ return code;
}
-
afs_int32
-SVL_ListAttributesN2(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- char *name, /* Wildcarded volume name */
- afs_int32 startindex,
- afs_int32 *nentries,
- nbulkentries *vldbentries,
- afs_int32 *nextstartindex)
+SVL_ListAttributesN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries)
+{
+ afs_int32 code;
+
+ code = ListAttributesN(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLListAttributesNEvent, code, AUD_END);
+ return code;
+}
+
+static afs_int32
+ListAttributesN2(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ char *name, /* Wildcarded volume name */
+ afs_int32 startindex,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries,
+ afs_int32 *nextstartindex)
{
int this_op = VLLISTATTRIBUTESN2;
int code = 0, maxCount = VLDBALLOCCOUNT;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
vldbentries->nbulkentries_val = 0;
vldbentries->nbulkentries_len = 0;
code = Init_VLdbase(&ctx, LOCKREAD, this_op);
if (code)
- goto end;
+ return code;
Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
malloc(maxCount * sizeof(nvldbentry));
if (Vldbentry == NULL) {
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
- code = VL_NOMEM;
- goto end;
+ return VL_NOMEM;
}
VldbentryLast = VldbentryFirst + maxCount;
code = ubik_EndTrans(ctx.trans);
}
- end:
- osi_auditU(rxcall, VLListAttributesN2Event, code, AUD_END);
return code;
}
+afs_int32
+SVL_ListAttributesN2(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ char *name, /* Wildcarded volume name */
+ afs_int32 startindex,
+ afs_int32 *nentries,
+ nbulkentries *vldbentries,
+ afs_int32 *nextstartindex)
+{
+ afs_int32 code;
+
+ code = ListAttributesN2(rxcall, attributes, name, startindex,
+ nentries, vldbentries, nextstartindex);
+ osi_auditU(rxcall, VLListAttributesN2Event, code, AUD_END);
+ return code;
+}
/* Retrieves in vldbentries all vldb entries that match the specified
* attributes (by server number, partition, volume type, and flag); if
* returned. CAUTION: This could be a very expensive call since in most
* cases sequential search of all vldb entries is performed.
*/
-afs_int32
-SVL_LinkedList(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- vldb_list *vldbentries)
+static afs_int32
+LinkedList(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ vldb_list *vldbentries)
{
int this_op = VLLINKEDLIST;
int code;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
*nentries = 0;
vldbentries->node = NULL;
}
}
*vllistptr = NULL;
- code = ubik_EndTrans(ctx.trans);
- end:
- osi_auditU(rxcall, VLLinkedListEvent, code, AUD_END);
- return code;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
- goto end;
+ return code;
}
afs_int32
-SVL_LinkedListN(struct rx_call *rxcall,
- struct VldbListByAttributes *attributes,
- afs_int32 *nentries,
- nvldb_list *vldbentries)
+SVL_LinkedList(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ vldb_list *vldbentries)
+{
+ afs_int32 code;
+
+ code = LinkedList(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLLinkedListEvent, code, AUD_END);
+ return code;
+}
+
+static afs_int32
+LinkedListN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nvldb_list *vldbentries)
{
int this_op = VLLINKEDLISTN;
int code;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
*nentries = 0;
vldbentries->node = NULL;
}
}
*vllistptr = NULL;
- code = ubik_EndTrans(ctx.trans);
- end:
- osi_auditU(rxcall, VLLinkedListNEvent, code, AUD_END);
- return code;
+ return ubik_EndTrans(ctx.trans);
abort:
countAbort(this_op);
ubik_AbortTrans(ctx.trans);
- goto end;
+ return code;
+}
+
+afs_int32
+SVL_LinkedListN(struct rx_call *rxcall,
+ struct VldbListByAttributes *attributes,
+ afs_int32 *nentries,
+ nvldb_list *vldbentries)
+{
+ afs_int32 code;
+
+ code = LinkedListN(rxcall, attributes, nentries, vldbentries);
+ osi_auditU(rxcall, VLLinkedListNEvent, code, AUD_END);
+ return code;
}
/* Get back vldb header statistics (allocs, frees, maxvolumeid,
* totalentries, etc) and dynamic statistics (number of requests and/or
* aborts per remote procedure call, etc)
*/
-afs_int32
-SVL_GetStats(struct rx_call *rxcall,
- vldstats *stats,
- vital_vlheader *vital_header)
+static afs_int32
+GetStats(struct rx_call *rxcall,
+ vldstats *stats,
+ vital_vlheader *vital_header)
{
int this_op = VLGETSTATS;
afs_int32 code;
if (!afsconf_CheckRestrictedQuery(vldb_confdir, rxcall,
restrictedQueryLevel))
- END(VL_PERM);
+ return VL_PERM;
if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
- goto end;
+ return code;
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));
- code = ubik_EndTrans(ctx.trans);
- end:
+ return ubik_EndTrans(ctx.trans);
+}
+
+afs_int32
+SVL_GetStats(struct rx_call *rxcall,
+ vldstats *stats,
+ vital_vlheader *vital_header)
+{
+ afs_int32 code;
+
+ code = GetStats(rxcall, stats, vital_header);
osi_auditU(rxcall, VLGetStatsEvent, code, AUD_END);
return code;
}
git://git.openafs.org / openafs.git / blobdiff