int
pr_ReadCoEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct contentry *tentry)
{
afs_int32 code;
afs_int32 i;
struct contentry nentry;
code = ubik_Seek(tt, afd, pos);
if (code)
return (code);
if (ntohl(1) == 1) { /* No swapping needed. */
code = ubik_Read(tt, (char *)tentry, sizeof(struct contentry));
return (code);
}
code = ubik_Read(tt, (char *)&nentry, sizeof(struct contentry));
if (code)
return (code);
memset(tentry, 0, sizeof(*tentry)); /* make reseved fields zero */
tentry->flags = ntohl(nentry.flags);
tentry->id = ntohl(nentry.id);
tentry->cellid = ntohl(nentry.cellid);
tentry->next = ntohl(nentry.next);
for (i = 0; i < COSIZE; i++)
tentry->entries[i] = ntohl(nentry.entries[i]);
return (code);
}
int
SSAMPLE_Inc(struct rx_call *call)
{
afs_int32 code, temp;
struct ubik_trans *tt;
struct timeval tv;
code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, &tt);
if (code)
return code;
printf("about to set lock\n");
/* now set database locks. Must do this or people may read uncommitted
* data. Note that we're just setting a lock at position 1, which is
* this program's convention for locking the whole database */
code = ubik_SetLock(tt, 1, 1, LOCKWRITE);
printf("now have lock\n");
if (code) {
ubik_AbortTrans(tt);
return code;
}
/* sleep for a little while to make it possible for us to test for some
* race conditions */
if (sleepTime) {
tv.tv_sec = sleepTime;
tv.tv_usec = 0;
#ifdef AFS_PTHREAD_ENV
select(0, 0, 0, 0, &tv);
#else
IOMGR_Select(0, 0, 0, 0, &tv);
#endif
}
/* read the original value */
code = ubik_Read(tt, &temp, sizeof(afs_int32));
if (code == UEOF) {
/* short read */
temp = 0;
} else if (code) {
ubik_AbortTrans(tt);
return code;
}
temp++; /* bump the value here */
/* reset the file pointer back to where it was before the read */
code = ubik_Seek(tt, 0, 0);
if (code) {
ubik_AbortTrans(tt);
return code;
}
/* write the data back */
code = ubik_Write(tt, &temp, sizeof(afs_int32));
if (code) {
ubik_AbortTrans(tt);
return code;
}
/* finally, we commit the transaction */
code = ubik_EndTrans(tt);
temp = 0;
return code;
}
int
pr_ReadEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct prentry *tentry)
{
afs_int32 code;
afs_int32 i;
struct prentry nentry;
code = ubik_Seek(tt, afd, pos);
if (code)
return (code);
if (ntohl(1) == 1) { /* no swapping needed */
code = ubik_Read(tt, (char *)tentry, sizeof(struct prentry));
return (code);
}
code = ubik_Read(tt, (char *)&nentry, sizeof(struct prentry));
if (code)
return (code);
memset(tentry, 0, sizeof(*tentry)); /* make sure reseved fields are zero */
tentry->flags = ntohl(nentry.flags);
tentry->id = ntohl(nentry.id);
tentry->cellid = ntohl(nentry.cellid);
tentry->next = ntohl(nentry.next);
tentry->nextID = ntohl(nentry.nextID);
tentry->nextName = ntohl(nentry.nextName);
tentry->owner = ntohl(nentry.owner);
tentry->creator = ntohl(nentry.creator);
tentry->ngroups = ntohl(nentry.ngroups);
tentry->nusers = ntohl(nentry.nusers);
tentry->count = ntohl(nentry.count);
tentry->instance = ntohl(nentry.instance);
tentry->owned = ntohl(nentry.owned);
tentry->nextOwned = ntohl(nentry.nextOwned);
tentry->parent = ntohl(nentry.parent);
tentry->sibling = ntohl(nentry.sibling);
tentry->child = ntohl(nentry.child);
strncpy(tentry->name, nentry.name, PR_MAXNAMELEN);
#ifdef PR_REMEMBER_TIMES
tentry->createTime = ntohl(nentry.createTime);
tentry->addTime = ntohl(nentry.addTime);
tentry->removeTime = ntohl(nentry.removeTime);
tentry->changeTime = ntohl(nentry.changeTime);
#endif
for (i = 0; i < PRSIZE; i++)
tentry->entries[i] = ntohl(nentry.entries[i]);
return (code);
}
afs_int32
karead(struct ubik_trans *tt, afs_int32 pos, char *buff, afs_int32 len)
{
afs_int32 code;
code = ubik_Seek(tt, 0, pos);
if (code)
return code;
code = ubik_Read(tt, buff, len);
return code;
}
afs_int32
pr_Read(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, void *buff, afs_int32 len)
{
/* same thing for read */
afs_int32 code;
code = ubik_Seek(tt, afd, pos);
if (code)
return code;
code = ubik_Read(tt, buff, len);
return code;
}
int
SSAMPLE_Test(struct rx_call *call)
{
afs_int32 code, temp;
struct ubik_trans *tt;
struct timeval tv;
/* first start a new transaction. Must be a write transaction since
* we're going to change some data (with ubik_Write) */
code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, &tt);
if (code)
return code;
printf("about to set lock\n");
/* now set database locks. Must do this or people may read uncommitted
* data. Note that we're just setting a lock at position 1, which is
* this program's convention for locking the whole database */
code = ubik_SetLock(tt, 1, 1, LOCKWRITE);
printf("now have lock\n");
if (code) {
ubik_AbortTrans(tt);
return code;
}
/* sleep for a little while to make it possible for us to test for some
* race conditions */
if (sleepTime) {
tv.tv_sec = sleepTime;
tv.tv_usec = 0;
#ifdef AFS_PTHREAD_ENV
select(0, 0, 0, 0, &tv);
#else
IOMGR_Select(0, 0, 0, 0, &tv);
#endif
}
/* read the original value */
code = ubik_Read(tt, &temp, sizeof(afs_int32));
if (code == UEOF) {
printf("short read, using 0\n");
temp = 0;
} else if (code) {
ubik_AbortTrans(tt);
return code;
}
ubik_AbortTrans(tt); /* surprise! pretend something went wrong */
return code;
}
int
SSAMPLE_Get(struct rx_call *call, afs_int32 *gnumber)
{
afs_int32 code, temp;
struct ubik_trans *tt;
struct timeval tv;
/* start with a read transaction, since we're only going to do read
* operations in this transaction. */
code = ubik_BeginTrans(dbase, UBIK_READTRANS, &tt);
if (code)
return code;
printf("about to set lock\n");
/* obtain a read lock, so we don't read data the other guy is writing */
code = ubik_SetLock(tt, 1, 1, LOCKREAD);
printf("now have lock\n");
if (code) {
ubik_AbortTrans(tt);
return code;
}
/* sleep to allow races */
if (sleepTime) {
tv.tv_sec = sleepTime;
tv.tv_usec = 0;
#ifdef AFS_PTHREAD_ENV
select(0, 0, 0, 0, &tv);
#else
IOMGR_Select(0, 0, 0, 0, &tv);
#endif
}
/* read the value */
code = ubik_Read(tt, &temp, sizeof(afs_int32));
if (code == UEOF) {
/* premature eof, use 0 */
temp = 0;
} else if (code) {
ubik_AbortTrans(tt);
return code;
}
*gnumber = temp;
/* end the transaction, automatically releasing locks */
code = ubik_EndTrans(tt);
return code;
}
