/*
* Create the XBSA Backup Copy Object.
* BSACreateObject
*/
afs_int32
xbsa_WriteObjectBegin(struct butx_transactionInfo * info,
char *objectSpaceName, char *pathName, char *lGName,
afs_hyper_t estimatedSize, char *objectDescription,
char *objectInfo)
{
int rc;
int length;
DataBlock dataBlock;
if (debugLevel > 98) {
printf
("\nxbsa_WriteObjectBegin objectSpacename='%s' pathName='%s' lGName='%s' "
"estimatesSize='0x%x%08x objectDescription='%s' objectInfo='%s'\n",
GOODSTR(objectSpaceName), GOODSTR(pathName), GOODSTR(lGName),
hgethi(estimatedSize), hgetlo(estimatedSize),
GOODSTR(objectDescription), GOODSTR(objectInfo));
printf
("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
GOODSTR(info->serverName),
GOODSTR(info->objOwner.bsaObjectOwner),
GOODSTR(info->objOwner.appObjectOwner));
}
if (info->bsaHandle == 0) {
/* We haven't initialized yet! */
ELog(0,
"xbsa_WriteObjectBegin: No current handle, butx not initialized\n");
return (BUTX_NOHANDLE);
}
if (objectSpaceName) {
if (strlen(objectSpaceName) >= BSA_MAX_OSNAME) {
ELog(0,
"xbsa_WriteObjectBegin: The objectSpaceName is too long; size = %d; name = %s\n",
strlen(objectSpaceName), objectSpaceName);
return (BUTX_INVALIDOBJECTSPNAME);
}
strcpy(info->curObject.objName.objectSpaceName, objectSpaceName);
} else {
info->curObject.objName.objectSpaceName[0] = NULL;
}
if (pathName) {
if (strlen(pathName) >= BSA_MAX_PATHNAME) {
ELog(0,
"xbsa_WriteObjectBegin: The pathName is too long; size = %d; name = %s\n",
strlen(pathName), pathName);
return (BUTX_INVALIDPATHNAME);
}
strcpy(info->curObject.objName.pathName, pathName);
} else {
info->curObject.objName.pathName[0] = NULL;
}
if (lGName) {
if (strlen(lGName) >= BSA_MAX_LG_NAME) {
ELog(0,
"xbsa_WriteObjectBegin: The lGName is too long; size = %d; name = %s\n",
strlen(lGName), lGName);
return (BUTX_INVALIDLGNAME);
}
strcpy(info->curObject.lGName, lGName);
} else {
info->curObject.lGName[0] = NULL;
}
if (objectDescription) {
if (((XBSA_GET_SERVER_TYPE(info->serverType) == XBSA_SERVER_TYPE_ADSM)
&& (strlen(objectDescription) >= ADSM_MAX_DESC))
||
((XBSA_GET_SERVER_TYPE(info->serverType) != XBSA_SERVER_TYPE_ADSM)
&& (strlen(objectDescription) >= BSA_MAX_DESC))) {
ELog(0,
"xbsa_WriteObjectBegin: The objectDescription is too long; size = %d; name = %s\n",
strlen(objectDescription), objectDescription);
return (BUTX_INVALIDOBJDESC);
}
strcpy(info->curObject.desc, objectDescription);
} else {
info->curObject.desc[0] = NULL;
}
if (objectInfo) {
if (((XBSA_GET_SERVER_TYPE(info->serverType) == XBSA_SERVER_TYPE_ADSM)
&& (strlen(objectInfo) >= ADSM_MAX_OBJINFO))
||
((XBSA_GET_SERVER_TYPE(info->serverType) != XBSA_SERVER_TYPE_ADSM)
&& (strlen(objectInfo) >= BSA_MAX_OBJINFO))) {
ELog(0,
"xbsa_WriteObjectBegin: The objectInfo is too long; size = %d; name = %s\n",
strlen(objectInfo), objectInfo);
return (BUTX_INVALIDOBJINFO);
}
strcpy(info->curObject.objectInfo, objectInfo);
} else {
info->curObject.objectInfo[0] = NULL;
}
if (info->numObjects == info->maxObjects) {
/* If we've used up Max Objects we must start a new transaction. */
rc = (int)xbsa_EndTrans(info);
if (rc != XBSA_SUCCESS) {
return (rc);
}
rc = (int)xbsa_BeginTrans(info);
if (rc != XBSA_SUCCESS) {
return (rc);
}
}
dataBlock.bufferLen = (BSA_UInt16) 0;
dataBlock.numBytes = (BSA_UInt16) 0;
dataBlock.bufferPtr = 0;
info->curObject.Owner = info->objOwner;
info->curObject.copyType = BSACopyType_BACKUP;
info->curObject.size.left = hgethi(estimatedSize);
info->curObject.size.right = hgetlo(estimatedSize);
info->curObject.objectType = BSAObjectType_FILE;
strcpy(info->curObject.resourceType, resourceType);
rc = (int)XBSACreateObject(info->bsaHandle, &info->curObject, &dataBlock);
if (rc != BSA_RC_SUCCESS) {
ELog(0,
"xbsa_WriteObjectBegin: The XBSACreateObject call failed with %d\n",
rc);
xbsa_error(rc, info);
return (BUTX_CREATEOBJFAIL);
}
info->numObjects++;
return (XBSA_SUCCESS);
}
/* copy out attributes from cache entry */
int
afs_CopyOutAttrs(struct vcache *avc, struct vattr *attrs)
{
struct volume *tvp;
struct cell *tcell;
#if defined(AFS_FBSD_ENV) || defined(AFS_DFBSD_ENV)
struct vnode *vp = AFSTOV(avc);
#endif
int fakedir = 0;
AFS_STATCNT(afs_CopyOutAttrs);
if (afs_fakestat_enable && avc->mvstat == AFS_MVSTAT_MTPT)
fakedir = 1;
attrs->va_type = fakedir ? VDIR : vType(avc);
#if defined(AFS_SGI_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV)
attrs->va_mode = fakedir ? S_IFDIR | 0755 : (mode_t) (avc->f.m.Mode & 0xffff);
#else
attrs->va_mode = fakedir ? VDIR | 0755 : avc->f.m.Mode;
#endif
if (avc->f.m.Mode & (VSUID | VSGID)) {
/* setuid or setgid, make sure we're allowed to run them from this cell */
tcell = afs_GetCell(avc->f.fid.Cell, 0);
if (tcell && (tcell->states & CNoSUID))
attrs->va_mode &= ~(VSUID | VSGID);
}
#if defined(AFS_DARWIN_ENV)
{
if (!afs_darwin_realmodes) {
/* Mac OS X uses the mode bits to determine whether a file or
* directory is accessible, and believes them, even though under
* AFS they're almost assuredly wrong, especially if the local uid
* does not match the AFS ID. So we set the mode bits
* conservatively.
*/
if (S_ISDIR(attrs->va_mode)) {
/* all access bits need to be set for directories, since even
* a mode 0 directory can still be used normally.
*/
attrs->va_mode |= ACCESSPERMS;
} else {
/* for other files, replicate the user bits to group and other */
mode_t ubits = (attrs->va_mode & S_IRWXU) >> 6;
attrs->va_mode |= ubits | (ubits << 3);
}
}
}
#endif /* AFS_DARWIN_ENV */
attrs->va_uid = fakedir ? 0 : avc->f.m.Owner;
attrs->va_gid = fakedir ? 0 : avc->f.m.Group; /* yeah! */
#if defined(AFS_SUN5_ENV)
attrs->va_fsid = avc->v.v_vfsp->vfs_fsid.val[0];
#elif defined(AFS_DARWIN80_ENV)
VATTR_RETURN(attrs, va_fsid, vfs_statfs(vnode_mount(AFSTOV(avc)))->f_fsid.val[0]);
#elif defined(AFS_DARWIN_ENV)
attrs->va_fsid = avc->v->v_mount->mnt_stat.f_fsid.val[0];
#else /* ! AFS_DARWIN_ENV */
attrs->va_fsid = 1;
#endif
if (avc->mvstat == AFS_MVSTAT_ROOT) {
tvp = afs_GetVolume(&avc->f.fid, 0, READ_LOCK);
/* The mount point's vnode. */
if (tvp) {
attrs->va_nodeid =
afs_calc_inum(tvp->mtpoint.Cell,
tvp->mtpoint.Fid.Volume,
tvp->mtpoint.Fid.Vnode);
if (FidCmp(&afs_rootFid, &avc->f.fid) && !attrs->va_nodeid)
attrs->va_nodeid = 2;
afs_PutVolume(tvp, READ_LOCK);
} else
attrs->va_nodeid = 2;
} else
attrs->va_nodeid =
afs_calc_inum(avc->f.fid.Cell,
avc->f.fid.Fid.Volume,
avc->f.fid.Fid.Vnode);
attrs->va_nodeid &= 0x7fffffff; /* Saber C hates negative inode #s! */
attrs->va_nlink = fakedir ? 100 : avc->f.m.LinkCount;
attrs->va_size = fakedir ? 4096 : avc->f.m.Length;
#if defined(AFS_FBSD_ENV) || defined(AFS_DFBSD_ENV)
vnode_pager_setsize(vp, (u_long) attrs->va_size);
#endif
attrs->va_atime.tv_sec = attrs->va_mtime.tv_sec = attrs->va_ctime.tv_sec =
fakedir ? 0 : (int)avc->f.m.Date;
/* set microseconds to be dataversion # so that we approximate NFS-style
* use of mtime as a dataversion #. We take it mod 512K because
* microseconds *must* be less than a million, and 512K is the biggest
* power of 2 less than such. DataVersions are typically pretty small
* anyway, so the difference between 512K and 1000000 shouldn't matter
* much, and "&" is a lot faster than "%".
*/
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
/* nfs on these systems puts an 0 in nsec and stores the nfs usec (aka
* dataversion) in va_gen */
attrs->va_atime.tv_nsec = attrs->va_mtime.tv_nsec =
attrs->va_ctime.tv_nsec = 0;
attrs->va_gen = hgetlo(avc->f.m.DataVersion);
#elif defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_OBSD_ENV) || defined(AFS_NBSD_ENV)
attrs->va_atime.tv_nsec = attrs->va_mtime.tv_nsec =
attrs->va_ctime.tv_nsec =
(hgetlo(avc->f.m.DataVersion) & 0x7ffff) * 1000;
#else
attrs->va_atime.tv_usec = attrs->va_mtime.tv_usec =
attrs->va_ctime.tv_usec = (hgetlo(avc->f.m.DataVersion) & 0x7ffff);
#endif
#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
attrs->va_flags = 0;
#endif
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)
attrs->va_blksize = AFS_BLKSIZE; /* XXX Was 8192 XXX */
#else
attrs->va_blocksize = AFS_BLKSIZE; /* XXX Was 8192 XXX */
#endif
attrs->va_rdev = 1;
#if defined(AFS_HPUX110_ENV)
if (afs_globalVFS)
attrs->va_fstype = afs_globalVFS->vfs_mtype;
#endif
/*
* Below return 0 (and not 1) blocks if the file is zero length. This conforms
* better with the other filesystems that do return 0.
*/
#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
attrs->va_bytes = (attrs->va_size ? (attrs->va_size + 1023) : 1024);
#ifdef va_bytes_rsv
attrs->va_bytes_rsv = -1;
#endif
#elif defined(AFS_HPUX_ENV)
attrs->va_blocks = (attrs->va_size ? ((attrs->va_size + 1023)>>10) : 0);
#elif defined(AFS_SGI_ENV)
attrs->va_blocks = BTOBB(attrs->va_size);
#elif defined(AFS_SUN5_ENV)
attrs->va_nblocks = (attrs->va_size ? ((attrs->va_size + 1023)>>10)<<1:0);
#else /* everything else */
attrs->va_blocks = (attrs->va_size ? ((attrs->va_size + 1023)>>10)<<1:0);
#endif
return 0;
}
int
main(int argc, char *argv[])
{
int rc;
afs_status_t st = 0;
rxdebugHandle_p handle;
char *srvrName;
long srvrPort;
void *iterator;
struct rx_debugPeer peer;
afs_uint32 supportedValues;
ParseArgs(argc, argv, &srvrName, &srvrPort);
rc = afsclient_Init(&st);
if (!rc) {
fprintf(stderr, "afsclient_Init, status %d\n", st);
exit(1);
}
rc = afsclient_RXDebugOpenPort(srvrName, srvrPort, &handle, &st);
if (!rc) {
fprintf(stderr, "afsclient_RXDebugOpenPort, status %d\n", st);
exit(1);
}
rc = util_RXDebugPeersBegin(handle, &iterator, &st);
if (!rc) {
fprintf(stderr, "util_RXDebugPeersBegin, status %d\n", st);
exit(1);
}
while (util_RXDebugPeersNext(iterator, &peer, &supportedValues, &st)) {
printf("\n");
printf("host: %u.%u.%u.%u\n", (peer.host >> 24) & 0xff,
(peer.host >> 16) & 0xff, (peer.host >> 8) & 0xff,
peer.host & 0xff);
printf("port: %u\n", peer.port);
printf("ifMTU: %u\n", peer.ifMTU);
printf("idleWhen: %u\n", peer.idleWhen);
printf("refCount: %u\n", peer.refCount);
printf("burstSize: %u\n", peer.burstSize);
printf("burst: %u\n", peer.burst);
printf("burstWait: %u.%06u\n", peer.burstWait.sec,
peer.burstWait.usec);
printf("rtt: %u\n", peer.rtt);
printf("rtt_dev: %u\n", peer.rtt_dev);
printf("timeout: %u.%06u\n", peer.timeout.sec,
peer.timeout.usec);
printf("nSent: %u\n", peer.nSent);
printf("reSends: %u\n", peer.reSends);
printf("inPacketSkew: %u\n", peer.inPacketSkew);
printf("outPacketSkew: %u\n", peer.outPacketSkew);
printf("rateFlag: %u\n", peer.rateFlag);
printf("natMTU: %u\n", peer.natMTU);
printf("maxMTU: %u\n", peer.maxMTU);
printf("maxDgramPackets: %u\n", peer.maxDgramPackets);
printf("ifDgramPackets: %u\n", peer.ifDgramPackets);
printf("MTU: %u\n", peer.MTU);
printf("cwind: %u\n", peer.cwind);
printf("nDgramPackets: %u\n", peer.nDgramPackets);
printf("congestSeq: %u\n", peer.congestSeq);
printf("bytesSent: (%u.%u)\n", hgethi(peer.bytesSent),
hgetlo(peer.bytesSent));
printf("bytesReceived: (%u.%u)\n", hgethi(peer.bytesReceived),
hgetlo(peer.bytesReceived));
}
if (st != ADMITERATORDONE) {
fprintf(stderr, "util_RXDebugPeersNext, status %d\n", st);
exit(1);
}
printf("\n");
rc = util_RXDebugPeersDone(iterator, &st);
if (!rc) {
fprintf(stderr, "util_RXDebugPeersDone, status %d\n", st);
exit(1);
}
rc = afsclient_RXDebugClose(handle, &st);
if (!rc) {
fprintf(stderr, "afsclient_RXDebugClose, status %d\n", st);
exit(1);
}
exit(0);
}
int
SRXAFSCB_GetCE(struct rx_call *a_call, afs_int32 a_index,
struct AFSDBCacheEntry *a_result)
{
int i; /*Loop variable */
struct vcache *tvc; /*Ptr to current cache entry */
int code; /*Return code */
XSTATS_DECLS;
RX_AFS_GLOCK();
XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_GETCE);
AFS_STATCNT(SRXAFSCB_GetCE);
for (i = 0; i < VCSIZE; i++) {
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
if (a_index == 0)
goto searchDone;
a_index--;
} /*Zip through current hash chain */
} /*Zip through hash chains */
searchDone:
if (tvc == NULL) {
/*Past EOF */
code = 1;
goto fcnDone;
}
/*
* Copy out the located entry.
*/
a_result->addr = afs_data_pointer_to_int32(tvc);
a_result->cell = tvc->f.fid.Cell;
a_result->netFid.Volume = tvc->f.fid.Fid.Volume;
a_result->netFid.Vnode = tvc->f.fid.Fid.Vnode;
a_result->netFid.Unique = tvc->f.fid.Fid.Unique;
a_result->lock.waitStates = tvc->lock.wait_states;
a_result->lock.exclLocked = tvc->lock.excl_locked;
a_result->lock.readersReading = tvc->lock.readers_reading;
a_result->lock.numWaiting = tvc->lock.num_waiting;
#if defined(INSTRUMENT_LOCKS)
a_result->lock.pid_last_reader = MyPidxx2Pid(tvc->lock.pid_last_reader);
a_result->lock.pid_writer = MyPidxx2Pid(tvc->lock.pid_writer);
a_result->lock.src_indicator = tvc->lock.src_indicator;
#else
/* On osf20 , the vcache does not maintain these three fields */
a_result->lock.pid_last_reader = 0;
a_result->lock.pid_writer = 0;
a_result->lock.src_indicator = 0;
#endif /* INSTRUMENT_LOCKS */
#ifdef AFS_64BIT_CLIENT
a_result->Length = (afs_int32) tvc->f.m.Length & 0xffffffff;
#else /* AFS_64BIT_CLIENT */
a_result->Length = tvc->f.m.Length;
#endif /* AFS_64BIT_CLIENT */
a_result->DataVersion = hgetlo(tvc->f.m.DataVersion);
a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */
a_result->cbExpires = tvc->cbExpires;
if (tvc->f.states & CVInit) {
a_result->refCount = 1;
} else {
#ifdef AFS_DARWIN80_ENV
a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
#else
a_result->refCount = VREFCOUNT(tvc);
#endif
}
a_result->opens = tvc->opens;
a_result->writers = tvc->execsOrWriters;
a_result->mvstat = tvc->mvstat;
a_result->states = tvc->f.states;
code = 0;
/*
* Return our results.
*/
fcnDone:
XSTATS_END_TIME;
RX_AFS_GUNLOCK();
return (code);
} /*SRXAFSCB_GetCE */