/* Machine generated file -- Do NOT edit */

#include "afsint.h"

#ifndef FSINT_COMMON_XG
#endif /* FSINT_COMMON_XG */
#define VICECONNBAD 1234
#define VICETOKENDEAD 1235
#define AFS_LOCKWAIT (5*60)
#define Invalid 0
#define File 1
#define Directory 2
#define SymbolicLink 3
#ifdef KERNEL
#define afs_xdr_array(a,b,c,d,e,f) afs_xdr_arrayN(a,b,c,d,e,f)
#endif
#define AFS_SETMODTIME 1
#define AFS_SETOWNER 2
#define AFS_SETGROUP 4
#define AFS_SETMODE 8
#define AFS_SETSEGSIZE 16
#define AFS_FSYNC 1024
#define ReadOnly 0
#define ReadWrite 1
#define LockRead 0
#define LockWrite 1
#define LockExtend 2
#define LockRelease 3
#define NoSalvage 0
#define Salvage 1
#ifdef KERNEL
#include "../afs/longc_procs.h"
#endif
#define MAXCMDINT64S 3
#define MAXCMDINT32S 200
#define MAXCMDCHARS 256
#define CMD_GETRESIDENCIES 1
#define CMD_CHANGERESIDENCIES 2
#define CMD_IMPORTRESIDENCIES 3
#define CMD_GETEXTVOLATTR 4
#define CMD_SETEXTVOLATTR 5
#define CMD_GETACCESSHISTORY 6
#define CMD_MIGRATEFILE 7
#define CMD_CHECKHSMMETADATA 8
#define CMD_FETCHSTATUS 9
#define VOLATTR_DESIREDRESIDENCYMASK 1
#define VOLATTR_UNDESIREDRESIDENCYMASK 2
#define VOLATTR_SETSPECIALACCESSFLAG 4
static afs_int32 _RXAFS_FetchData(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	afs_int32 Pos, Length;
	AFSFetchStatus OutStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_afs_int32(z_xdrs, &Pos))
	     || (!xdr_afs_int32(z_xdrs, &Length))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_FetchData(z_call, &Fid, Pos, Length, &OutStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		0, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_FetchACL(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSOpaque AccessList;
	AFSFetchStatus OutStatus;
	AFSVolSync Sync;



	AccessList.AFSOpaque_val = 0;
	AccessList.AFSOpaque_len = 0;

	if ((!xdr_AFSFid(z_xdrs, &Fid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_FetchACL(z_call, &Fid, &AccessList, &OutStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSOpaque(z_xdrs, &AccessList))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSOpaque(z_xdrs, &AccessList)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		1, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		1, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_FetchStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSFetchStatus OutStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_FetchStatus(z_call, &Fid, &OutStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		2, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_StoreData(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSStoreStatus InStatus;
	afs_uint32 Pos, Length, FileLength;
	AFSFetchStatus OutStatus;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))
	     || (!xdr_afs_uint32(z_xdrs, &Pos))
	     || (!xdr_afs_uint32(z_xdrs, &Length))
	     || (!xdr_afs_uint32(z_xdrs, &FileLength))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_StoreData(z_call, &Fid, &InStatus, Pos, Length, FileLength, &OutStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		3, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_StoreACL(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSOpaque AccessList;
	AFSFetchStatus OutStatus;
	AFSVolSync Sync;



	AccessList.AFSOpaque_val = 0;
	AccessList.AFSOpaque_len = 0;

	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_AFSOpaque(z_xdrs, &AccessList))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_StoreACL(z_call, &Fid, &AccessList, &OutStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSOpaque(z_xdrs, &AccessList)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		4, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		4, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_StoreStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSStoreStatus InStatus;
	AFSFetchStatus OutStatus;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_StoreStatus(z_call, &Fid, &InStatus, &OutStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		5, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_RemoveFile(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid;
	char * Name=(char *)0;
	AFSFetchStatus OutStatus;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_RemoveFile(z_call, &DirFid, Name, &OutStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		6, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		6, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_CreateFile(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid, OutFid;
	char * Name=(char *)0;
	AFSStoreStatus InStatus;
	AFSFetchStatus OutFidStatus, OutDirStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_CreateFile(z_call, &DirFid, Name, &InStatus, &OutFid, &OutFidStatus, &OutDirStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFid(z_xdrs, &OutFid))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutFidStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		7, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		7, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_Rename(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid OldDirFid, NewDirFid;
	char * OldName=(char *)0, *NewName=(char *)0;
	AFSFetchStatus OutOldDirStatus, OutNewDirStatus;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &OldDirFid))
	     || (!xdr_string(z_xdrs, &OldName, AFSNAMEMAX))
	     || (!xdr_AFSFid(z_xdrs, &NewDirFid))
	     || (!xdr_string(z_xdrs, &NewName, AFSNAMEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_Rename(z_call, &OldDirFid, OldName, &NewDirFid, NewName, &OutOldDirStatus, &OutNewDirStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutOldDirStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutNewDirStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &OldName, AFSNAMEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &NewName, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		8, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		8, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_Symlink(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid, OutFid;
	char * Name=(char *)0, *LinkContents=(char *)0;
	AFSStoreStatus InStatus;
	AFSFetchStatus OutFidStatus, OutDirStatus;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_string(z_xdrs, &LinkContents, AFSPATHMAX))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_Symlink(z_call, &DirFid, Name, LinkContents, &InStatus, &OutFid, &OutFidStatus, &OutDirStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFid(z_xdrs, &OutFid))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutFidStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &LinkContents, AFSPATHMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		9, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		9, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_Link(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid, ExistingFid;
	char * Name=(char *)0;
	AFSFetchStatus OutFidStatus, OutDirStatus;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_AFSFid(z_xdrs, &ExistingFid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_Link(z_call, &DirFid, Name, &ExistingFid, &OutFidStatus, &OutDirStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutFidStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		10, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		10, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_MakeDir(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid, OutFid;
	char * Name=(char *)0;
	AFSStoreStatus InStatus;
	AFSFetchStatus OutFidStatus, OutDirStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_MakeDir(z_call, &DirFid, Name, &InStatus, &OutFid, &OutFidStatus, &OutDirStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFid(z_xdrs, &OutFid))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutFidStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		11, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		11, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_RemoveDir(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid;
	char * Name=(char *)0;
	AFSFetchStatus OutDirStatus;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_RemoveDir(z_call, &DirFid, Name, &OutDirStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		12, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		12, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_OldSetLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	ViceLockType Type;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_ViceLockType(z_xdrs, &Type))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_OldSetLock(z_call, &Fid, Type, &Sync);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_ViceLockType(z_xdrs, &Type)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		13, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		13, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_OldExtendLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_OldExtendLock(z_call, &Fid, &Sync);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		14, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_OldReleaseLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_OldReleaseLock(z_call, &Fid, &Sync);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		15, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_GetStatistics(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	ViceStatistics Statistics;



	z_result = SRXAFS_GetStatistics(z_call, &Statistics);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ViceStatistics(z_xdrs, &Statistics)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		16, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_GiveUpCallBacks(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSCBFids Fids_Array;
	AFSCBs CallBacks_Array;



	Fids_Array.AFSCBFids_val = 0;
	Fids_Array.AFSCBFids_len = 0;
	CallBacks_Array.AFSCBs_val = 0;
	CallBacks_Array.AFSCBs_len = 0;

	if ((!xdr_AFSCBFids(z_xdrs, &Fids_Array))
	     || (!xdr_AFSCBs(z_xdrs, &CallBacks_Array))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_GiveUpCallBacks(z_call, &Fids_Array, &CallBacks_Array);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSCBFids(z_xdrs, &Fids_Array)) goto fail1;
	if (!xdr_AFSCBs(z_xdrs, &CallBacks_Array)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		17, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		17, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_GetVolumeInfo(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * VolumeName=(char *)0;
	VolumeInfo Volumeinfo;



	if ((!xdr_string(z_xdrs, &VolumeName, AFSNAMEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_GetVolumeInfo(z_call, VolumeName, &Volumeinfo);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_VolumeInfo(z_xdrs, &Volumeinfo)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &VolumeName, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		18, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		18, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_GetVolumeStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 Volumeid;
	AFSFetchVolumeStatus Volumestatus;
	char * Name=(char *)0, *OfflineMsg=(char *)0, *Motd=(char *)0;



	if ((!xdr_afs_int32(z_xdrs, &Volumeid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_GetVolumeStatus(z_call, Volumeid, &Volumestatus, &Name, &OfflineMsg, &Motd);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchVolumeStatus(z_xdrs, &Volumestatus))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_string(z_xdrs, &OfflineMsg, AFSOPAQUEMAX))
	     || (!xdr_string(z_xdrs, &Motd, AFSOPAQUEMAX)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &OfflineMsg, AFSOPAQUEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &Motd, AFSOPAQUEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		19, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		19, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_SetVolumeStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 Volumeid;
	AFSStoreVolumeStatus Volumestatus;
	char * Name=(char *)0, *OfflineMsg=(char *)0, *Motd=(char *)0;



	if ((!xdr_afs_int32(z_xdrs, &Volumeid))
	     || (!xdr_AFSStoreVolumeStatus(z_xdrs, &Volumestatus))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_string(z_xdrs, &OfflineMsg, AFSOPAQUEMAX))
	     || (!xdr_string(z_xdrs, &Motd, AFSOPAQUEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_SetVolumeStatus(z_call, Volumeid, &Volumestatus, Name, OfflineMsg, Motd);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &OfflineMsg, AFSOPAQUEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &Motd, AFSOPAQUEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		20, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		20, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_GetRootVolume(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * VolumeName=(char *)0;


	z_result = SRXAFS_GetRootVolume(z_call, &VolumeName);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &VolumeName, AFSNAMEMAX)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &VolumeName, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		21, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		21, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_CheckToken(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 ViceId;
	AFSOpaque token;



	token.AFSOpaque_val = 0;
	token.AFSOpaque_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &ViceId))
	     || (!xdr_AFSOpaque(z_xdrs, &token))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_CheckToken(z_call, ViceId, &token);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSOpaque(z_xdrs, &token)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		22, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		22, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_GetTime(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_uint32 Seconds, USeconds;



	z_result = SRXAFS_GetTime(z_call, &Seconds, &USeconds);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_uint32(z_xdrs, &Seconds))
	     || (!xdr_afs_uint32(z_xdrs, &USeconds)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		23, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_NGetVolumeInfo(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * VolumeName=(char *)0;
	AFSVolumeInfo stuff;



	if ((!xdr_string(z_xdrs, &VolumeName, AFSNAMEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_NGetVolumeInfo(z_call, VolumeName, &stuff);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSVolumeInfo(z_xdrs, &stuff)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &VolumeName, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		24, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		24, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_BulkStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSCBFids FidsArray;
	AFSBulkStats StatArray;
	AFSCBs CBArray;
	AFSVolSync Sync;



	FidsArray.AFSCBFids_val = 0;
	FidsArray.AFSCBFids_len = 0;
	CBArray.AFSCBs_val = 0;
	CBArray.AFSCBs_len = 0;
	StatArray.AFSBulkStats_val = 0;
	StatArray.AFSBulkStats_len = 0;

	if ((!xdr_AFSCBFids(z_xdrs, &FidsArray))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_BulkStatus(z_call, &FidsArray, &StatArray, &CBArray, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSBulkStats(z_xdrs, &StatArray))
	     || (!xdr_AFSCBs(z_xdrs, &CBArray))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSCBFids(z_xdrs, &FidsArray)) goto fail1;
	if (!xdr_AFSBulkStats(z_xdrs, &StatArray)) goto fail1;
	if (!xdr_AFSCBs(z_xdrs, &CBArray)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		25, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		25, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_SetLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	ViceLockType Type;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_ViceLockType(z_xdrs, &Type))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_SetLock(z_call, &Fid, Type, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_ViceLockType(z_xdrs, &Type)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		26, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		26, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_ExtendLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_ExtendLock(z_call, &Fid, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		27, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_ReleaseLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_ReleaseLock(z_call, &Fid, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		28, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_XStatsVersion(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 versionNumberP;



	z_result = SRXAFS_XStatsVersion(z_call, &versionNumberP);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &versionNumberP)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		29, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_GetXStats(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 clientVersionNumber, collectionNumber;
	afs_int32 srvVersionNumberP, timeP;
	AFS_CollData dataP;



	dataP.AFS_CollData_val = 0;
	dataP.AFS_CollData_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &clientVersionNumber))
	     || (!xdr_afs_int32(z_xdrs, &collectionNumber))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_GetXStats(z_call, clientVersionNumber, collectionNumber, &srvVersionNumberP, &timeP, &dataP);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &srvVersionNumberP))
	     || (!xdr_afs_int32(z_xdrs, &timeP))
	     || (!xdr_AFS_CollData(z_xdrs, &dataP)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFS_CollData(z_xdrs, &dataP)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		30, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		30, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_Lookup(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid, OutFid;
	char * Name=(char *)0;
	AFSFetchStatus OutFidStatus, OutDirStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_Lookup(z_call, &DirFid, Name, &OutFid, &OutFidStatus, &OutDirStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFid(z_xdrs, &OutFid))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutFidStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		31, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		31, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_FlushCPS(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	ViceIds IdsArray;
	IPAddrs AddrsArray;
	afs_int32 spare1;
	afs_int32 spare2, spare3;



	IdsArray.ViceIds_val = 0;
	IdsArray.ViceIds_len = 0;
	AddrsArray.IPAddrs_val = 0;
	AddrsArray.IPAddrs_len = 0;

	if ((!xdr_ViceIds(z_xdrs, &IdsArray))
	     || (!xdr_IPAddrs(z_xdrs, &AddrsArray))
	     || (!xdr_afs_int32(z_xdrs, &spare1))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_FlushCPS(z_call, &IdsArray, &AddrsArray, spare1, &spare2, &spare3);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &spare2))
	     || (!xdr_afs_int32(z_xdrs, &spare3)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_ViceIds(z_xdrs, &IdsArray)) goto fail1;
	if (!xdr_IPAddrs(z_xdrs, &AddrsArray)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		32, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		32, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_DFSSymlink(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid DirFid, OutFid;
	char * Name=(char *)0, *LinkContents=(char *)0;
	AFSStoreStatus InStatus;
	AFSFetchStatus OutFidStatus, OutDirStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;



	if ((!xdr_AFSFid(z_xdrs, &DirFid))
	     || (!xdr_string(z_xdrs, &Name, AFSNAMEMAX))
	     || (!xdr_string(z_xdrs, &LinkContents, AFSPATHMAX))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_DFSSymlink(z_call, &DirFid, Name, LinkContents, &InStatus, &OutFid, &OutFidStatus, &OutDirStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFid(z_xdrs, &OutFid))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutFidStatus))
	     || (!xdr_AFSFetchStatus(z_xdrs, &OutDirStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &Name, AFSNAMEMAX)) goto fail1;
	if (!xdr_string(z_xdrs, &LinkContents, AFSPATHMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		33, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		33, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_ResidencyCmd(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	struct ResidencyCmdInputs Inputs;
	struct ResidencyCmdOutputs Outputs;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_ResidencyCmdInputs(z_xdrs, &Inputs))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_ResidencyCmd(z_call, &Fid, &Inputs, &Outputs);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ResidencyCmdOutputs(z_xdrs, &Outputs)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		34, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_InlineBulkStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSCBFids FidsArray;
	AFSBulkStats StatArray;
	AFSCBs CBArray;
	AFSVolSync Sync;



	FidsArray.AFSCBFids_val = 0;
	FidsArray.AFSCBFids_len = 0;
	CBArray.AFSCBs_val = 0;
	CBArray.AFSCBs_len = 0;
	StatArray.AFSBulkStats_val = 0;
	StatArray.AFSBulkStats_len = 0;

	if ((!xdr_AFSCBFids(z_xdrs, &FidsArray))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_InlineBulkStatus(z_call, &FidsArray, &StatArray, &CBArray, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSBulkStats(z_xdrs, &StatArray))
	     || (!xdr_AFSCBs(z_xdrs, &CBArray))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSCBFids(z_xdrs, &FidsArray)) goto fail1;
	if (!xdr_AFSBulkStats(z_xdrs, &StatArray)) goto fail1;
	if (!xdr_AFSCBs(z_xdrs, &CBArray)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		35, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		35, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_FetchData64(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	afs_int64 Pos, Length;
	AFSFetchStatus OutStatus;
	AFSCallBack CallBack;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_afs_int64(z_xdrs, &Pos))
	     || (!xdr_afs_int64(z_xdrs, &Length))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_FetchData64(z_call, &Fid, Pos, Length, &OutStatus, &CallBack, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSCallBack(z_xdrs, &CallBack))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		36, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_StoreData64(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSFid Fid;
	AFSStoreStatus InStatus;
	afs_uint64 Pos, Length, FileLength;
	AFSFetchStatus OutStatus;
	AFSVolSync Sync;




	if ((!xdr_AFSFid(z_xdrs, &Fid))
	     || (!xdr_AFSStoreStatus(z_xdrs, &InStatus))
	     || (!xdr_afs_uint64(z_xdrs, &Pos))
	     || (!xdr_afs_uint64(z_xdrs, &Length))
	     || (!xdr_afs_uint64(z_xdrs, &FileLength))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_StoreData64(z_call, &Fid, &InStatus, Pos, Length, FileLength, &OutStatus, &Sync);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSFetchStatus(z_xdrs, &OutStatus))
	     || (!xdr_AFSVolSync(z_xdrs, &Sync)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		37, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_GiveUpAllCallBacks(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;



	z_result = SRXAFS_GiveUpAllCallBacks(z_call);
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		38, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFS_GetCapabilities(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	Capabilities capabilities;



	capabilities.Capabilities_val = 0;
	capabilities.Capabilities_len = 0;
	z_result = SRXAFS_GetCapabilities(z_call, &capabilities);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_Capabilities(z_xdrs, &capabilities)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_Capabilities(z_xdrs, &capabilities)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		39, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		39, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFS_CallBackRxConnAddr(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 addr;




	if ((!xdr_afs_int32(z_xdrs, &addr))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_CallBackRxConnAddr(z_call, &addr);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		40, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

#define STATS64_CURRENTTIME 0
#define STATS64_BOOTTIME 1
#define STATS64_STARTTIME 2
#define STATS64_CURRENTCONNECTIONS 3
#define STATS64_TOTALFETCHES 4
#define STATS64_FETCHDATAS 5
#define STATS64_FETCHEDBYTES 6
#define STATS64_FETCHDATARATE 7
#define STATS64_TOTALSTORES 8
#define STATS64_STOREDATAS 9
#define STATS64_STOREDBYTES 10
#define STATS64_STOREDATARATE 11
#define STATS64_TOTALVICECALLS 12
#define STATS64_WORKSTATIONS 13
#define STATS64_ACTIVEWORKSTATIONS 14
#define STATS64_PROCESSSIZE 15
static afs_int32 _RXAFS_GetStatistics64(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 statsVersion;
	ViceStatistics64 Statistics;



	Statistics.ViceStatistics64_val = 0;
	Statistics.ViceStatistics64_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &statsVersion))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFS_GetStatistics64(z_call, statsVersion, &Statistics);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ViceStatistics64(z_xdrs, &Statistics)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_ViceStatistics64(z_xdrs, &Statistics)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		41, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFS_STATINDEX,
		41, RXAFS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}


int RXAFS_ExecuteRequest (register struct rx_call *z_call)
{
	int op;
	XDR z_xdrs;
	afs_int32 z_result;

	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	z_result = RXGEN_DECODE;
	if (!xdr_int(&z_xdrs, &op)) goto fail;
	switch (op) {
		case 130:
			z_result = _RXAFS_FetchData(z_call, &z_xdrs);
			break;
		case 131:
			z_result = _RXAFS_FetchACL(z_call, &z_xdrs);
			break;
		case 132:
			z_result = _RXAFS_FetchStatus(z_call, &z_xdrs);
			break;
		case 133:
			z_result = _RXAFS_StoreData(z_call, &z_xdrs);
			break;
		case 134:
			z_result = _RXAFS_StoreACL(z_call, &z_xdrs);
			break;
		case 135:
			z_result = _RXAFS_StoreStatus(z_call, &z_xdrs);
			break;
		case 136:
			z_result = _RXAFS_RemoveFile(z_call, &z_xdrs);
			break;
		case 137:
			z_result = _RXAFS_CreateFile(z_call, &z_xdrs);
			break;
		case 138:
			z_result = _RXAFS_Rename(z_call, &z_xdrs);
			break;
		case 139:
			z_result = _RXAFS_Symlink(z_call, &z_xdrs);
			break;
		case 140:
			z_result = _RXAFS_Link(z_call, &z_xdrs);
			break;
		case 141:
			z_result = _RXAFS_MakeDir(z_call, &z_xdrs);
			break;
		case 142:
			z_result = _RXAFS_RemoveDir(z_call, &z_xdrs);
			break;
		case 143:
			z_result = _RXAFS_OldSetLock(z_call, &z_xdrs);
			break;
		case 144:
			z_result = _RXAFS_OldExtendLock(z_call, &z_xdrs);
			break;
		case 145:
			z_result = _RXAFS_OldReleaseLock(z_call, &z_xdrs);
			break;
		case 146:
			z_result = _RXAFS_GetStatistics(z_call, &z_xdrs);
			break;
		case 147:
			z_result = _RXAFS_GiveUpCallBacks(z_call, &z_xdrs);
			break;
		case 148:
			z_result = _RXAFS_GetVolumeInfo(z_call, &z_xdrs);
			break;
		case 149:
			z_result = _RXAFS_GetVolumeStatus(z_call, &z_xdrs);
			break;
		case 150:
			z_result = _RXAFS_SetVolumeStatus(z_call, &z_xdrs);
			break;
		case 151:
			z_result = _RXAFS_GetRootVolume(z_call, &z_xdrs);
			break;
		case 152:
			z_result = _RXAFS_CheckToken(z_call, &z_xdrs);
			break;
		case 153:
			z_result = _RXAFS_GetTime(z_call, &z_xdrs);
			break;
		case 154:
			z_result = _RXAFS_NGetVolumeInfo(z_call, &z_xdrs);
			break;
		case 155:
			z_result = _RXAFS_BulkStatus(z_call, &z_xdrs);
			break;
		case 156:
			z_result = _RXAFS_SetLock(z_call, &z_xdrs);
			break;
		case 157:
			z_result = _RXAFS_ExtendLock(z_call, &z_xdrs);
			break;
		case 158:
			z_result = _RXAFS_ReleaseLock(z_call, &z_xdrs);
			break;
		case 159:
			z_result = _RXAFS_XStatsVersion(z_call, &z_xdrs);
			break;
		case 160:
			z_result = _RXAFS_GetXStats(z_call, &z_xdrs);
			break;
		case 161:
			z_result = _RXAFS_Lookup(z_call, &z_xdrs);
			break;
		case 162:
			z_result = _RXAFS_FlushCPS(z_call, &z_xdrs);
			break;
		case 163:
			z_result = _RXAFS_DFSSymlink(z_call, &z_xdrs);
			break;
		case 220:
			z_result = _RXAFS_ResidencyCmd(z_call, &z_xdrs);
			break;
		case 65536:
			z_result = _RXAFS_InlineBulkStatus(z_call, &z_xdrs);
			break;
		case 65537:
			z_result = _RXAFS_FetchData64(z_call, &z_xdrs);
			break;
		case 65538:
			z_result = _RXAFS_StoreData64(z_call, &z_xdrs);
			break;
		case 65539:
			z_result = _RXAFS_GiveUpAllCallBacks(z_call, &z_xdrs);
			break;
		case 65540:
			z_result = _RXAFS_GetCapabilities(z_call, &z_xdrs);
			break;
		case 65541:
			z_result = _RXAFS_CallBackRxConnAddr(z_call, &z_xdrs);
			break;
		case 65542:
			z_result = _RXAFS_GetStatistics64(z_call, &z_xdrs);
			break;
		default:
			z_result = RXGEN_OPCODE;
			break;
	}
fail:
	return z_result;
}