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

#include "volint.h"

#define VOLDUMPV2_OMITDIRS 1
static afs_int32 _AFSVolCreateVolume(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 partition, type, parent;
	char * name=(char *)0;
	afs_int32 volid, trans;



	if ((!xdr_afs_int32(z_xdrs, &partition))
	     || (!xdr_string(z_xdrs, &name, ~0))
	     || (!xdr_afs_int32(z_xdrs, &type))
	     || (!xdr_afs_int32(z_xdrs, &parent))
	     || (!xdr_afs_int32(z_xdrs, &volid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolCreateVolume(z_call, partition, name, type, parent, &volid, &trans);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &volid))
	     || (!xdr_afs_int32(z_xdrs, &trans)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, ~0)) 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, AFSVolSTATINDEX,
		0, AFSVolNO_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, AFSVolSTATINDEX,
		0, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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




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

	z_result = SAFSVolDeleteVolume(z_call, trans);
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, AFSVolSTATINDEX,
		1, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolRestore(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 toTrans, flags;
	struct restoreCookie cookie;




	if ((!xdr_afs_int32(z_xdrs, &toTrans))
	     || (!xdr_afs_int32(z_xdrs, &flags))
	     || (!xdr_restoreCookie(z_xdrs, &cookie))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolRestore(z_call, toTrans, flags, &cookie);
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, AFSVolSTATINDEX,
		2, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolForward(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 fromTrans, fromDate, destTrans;
	struct destServer destination;
	struct restoreCookie cookie;




	if ((!xdr_afs_int32(z_xdrs, &fromTrans))
	     || (!xdr_afs_int32(z_xdrs, &fromDate))
	     || (!xdr_destServer(z_xdrs, &destination))
	     || (!xdr_afs_int32(z_xdrs, &destTrans))
	     || (!xdr_restoreCookie(z_xdrs, &cookie))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolForward(z_call, fromTrans, fromDate, &destination, destTrans, &cookie);
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, AFSVolSTATINDEX,
		3, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SAFSVolEndTrans(z_call, trans, &rcode);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &rcode)))
		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, AFSVolSTATINDEX,
		4, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolClone(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 trans, purgeVol, newType;
	char * newName=(char *)0;
	afs_int32 newVol;



	if ((!xdr_afs_int32(z_xdrs, &trans))
	     || (!xdr_afs_int32(z_xdrs, &purgeVol))
	     || (!xdr_afs_int32(z_xdrs, &newType))
	     || (!xdr_string(z_xdrs, &newName, ~0))
	     || (!xdr_afs_int32(z_xdrs, &newVol))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolClone(z_call, trans, purgeVol, newType, newName, &newVol);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &newVol)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &newName, ~0)) 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, AFSVolSTATINDEX,
		5, AFSVolNO_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, AFSVolSTATINDEX,
		5, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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




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

	z_result = SAFSVolSetFlags(z_call, trans, flags);
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, AFSVolSTATINDEX,
		6, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SAFSVolGetFlags(z_call, trans, &flags);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &flags)))
		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, AFSVolSTATINDEX,
		7, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolTransCreate(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 volume, partition, flags;
	afs_int32 trans;




	if ((!xdr_afs_int32(z_xdrs, &volume))
	     || (!xdr_afs_int32(z_xdrs, &partition))
	     || (!xdr_afs_int32(z_xdrs, &flags))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolTransCreate(z_call, volume, partition, flags, &trans);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &trans)))
		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, AFSVolSTATINDEX,
		8, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SAFSVolDump(z_call, fromTrans, fromDate);
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, AFSVolSTATINDEX,
		9, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolGetNthVolume(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 index;
	afs_int32 volume, partition;




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

	z_result = SAFSVolGetNthVolume(z_call, index, &volume, &partition);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &volume))
	     || (!xdr_afs_int32(z_xdrs, &partition)))
		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, AFSVolSTATINDEX,
		10, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SAFSVolSetForwarding(z_call, tid, newsite);
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, AFSVolSTATINDEX,
		11, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



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

	z_result = SAFSVolGetName(z_call, tid, &tname);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &tname, 256)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &tname, 256)) 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, AFSVolSTATINDEX,
		12, AFSVolNO_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, AFSVolSTATINDEX,
		12, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _AFSVolGetStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 tid;
	struct volser_status status;




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

	z_result = SAFSVolGetStatus(z_call, tid, &status);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_volser_status(z_xdrs, &status)))
		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, AFSVolSTATINDEX,
		13, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolSignalRestore(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * name=(char *)0;
	int type;
	afs_int32 pid, cloneid;



	if ((!xdr_string(z_xdrs, &name, ~0))
	     || (!xdr_int(z_xdrs, &type))
	     || (!xdr_afs_int32(z_xdrs, &pid))
	     || (!xdr_afs_int32(z_xdrs, &cloneid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolSignalRestore(z_call, name, type, pid, cloneid);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, ~0)) 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, AFSVolSTATINDEX,
		14, AFSVolNO_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, AFSVolSTATINDEX,
		14, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	z_result = SAFSVolListPartitions(z_call, &partIDs);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_pIDs(z_xdrs, &partIDs)))
		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, AFSVolSTATINDEX,
		15, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolListVolumes(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 partID, flags;
	volEntries resultEntries;



	resultEntries.volEntries_val = 0;
	resultEntries.volEntries_len = 0;

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

	z_result = SAFSVolListVolumes(z_call, partID, flags, &resultEntries);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_volEntries(z_xdrs, &resultEntries)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_volEntries(z_xdrs, &resultEntries)) 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, AFSVolSTATINDEX,
		16, AFSVolNO_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, AFSVolSTATINDEX,
		16, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _AFSVolSetIdsTypes(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 tId, type, pId, cloneId, backupId;
	char * name=(char *)0;



	if ((!xdr_afs_int32(z_xdrs, &tId))
	     || (!xdr_string(z_xdrs, &name, ~0))
	     || (!xdr_afs_int32(z_xdrs, &type))
	     || (!xdr_afs_int32(z_xdrs, &pId))
	     || (!xdr_afs_int32(z_xdrs, &cloneId))
	     || (!xdr_afs_int32(z_xdrs, &backupId))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolSetIdsTypes(z_call, tId, name, type, pId, cloneId, backupId);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, ~0)) 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, AFSVolSTATINDEX,
		17, AFSVolNO_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, AFSVolSTATINDEX,
		17, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	result.transDebugEntries_val = 0;
	result.transDebugEntries_len = 0;
	z_result = SAFSVolMonitor(z_call, &result);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_transDebugEntries(z_xdrs, &result)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_transDebugEntries(z_xdrs, &result)) 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, AFSVolSTATINDEX,
		18, AFSVolNO_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, AFSVolSTATINDEX,
		18, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _AFSVolPartitionInfo(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * name=(char *)0;
	struct diskPartition partition;



	if ((!xdr_string(z_xdrs, &name, ~0))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolPartitionInfo(z_call, name, &partition);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_diskPartition(z_xdrs, &partition)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, ~0)) 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, AFSVolSTATINDEX,
		19, AFSVolNO_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, AFSVolSTATINDEX,
		19, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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




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

	z_result = SAFSVolReClone(z_call, tid, cloneID);
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, AFSVolSTATINDEX,
		20, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolListOneVolume(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 partID, volid;
	volEntries resultEntries;



	resultEntries.volEntries_val = 0;
	resultEntries.volEntries_len = 0;

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

	z_result = SAFSVolListOneVolume(z_call, partID, volid, &resultEntries);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_volEntries(z_xdrs, &resultEntries)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_volEntries(z_xdrs, &resultEntries)) 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, AFSVolSTATINDEX,
		21, AFSVolNO_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, AFSVolSTATINDEX,
		21, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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




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

	z_result = SAFSVolNukeVolume(z_call, partID, volID);
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, AFSVolSTATINDEX,
		22, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SAFSVolSetDate(z_call, tid, newDate);
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, AFSVolSTATINDEX,
		23, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolXListVolumes(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 partID, flags;
	volXEntries resultXEntriesP;



	resultXEntriesP.volXEntries_val = 0;
	resultXEntriesP.volXEntries_len = 0;

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

	z_result = SAFSVolXListVolumes(z_call, partID, flags, &resultXEntriesP);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_volXEntries(z_xdrs, &resultXEntriesP)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_volXEntries(z_xdrs, &resultXEntriesP)) 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, AFSVolSTATINDEX,
		24, AFSVolNO_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, AFSVolSTATINDEX,
		24, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _AFSVolXListOneVolume(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 partID, volid;
	volXEntries resultXEntries;



	resultXEntries.volXEntries_val = 0;
	resultXEntries.volXEntries_len = 0;

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

	z_result = SAFSVolXListOneVolume(z_call, partID, volid, &resultXEntries);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_volXEntries(z_xdrs, &resultXEntries)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_volXEntries(z_xdrs, &resultXEntries)) 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, AFSVolSTATINDEX,
		25, AFSVolNO_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, AFSVolSTATINDEX,
		25, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _AFSVolSetInfo(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 tid;
	struct volintInfo status;




	if ((!xdr_afs_int32(z_xdrs, &tid))
	     || (!xdr_volintInfo(z_xdrs, &status))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolSetInfo(z_call, tid, &status);
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, AFSVolSTATINDEX,
		26, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	partIDs.partEntries_val = 0;
	partIDs.partEntries_len = 0;
	z_result = SAFSVolXListPartitions(z_call, &partIDs);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_partEntries(z_xdrs, &partIDs)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_partEntries(z_xdrs, &partIDs)) 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, AFSVolSTATINDEX,
		27, AFSVolNO_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, AFSVolSTATINDEX,
		27, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _AFSVolForwardMultiple(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 fromTrans, fromDate, spare;
	manyDests destinations;
	struct restoreCookie cookie;
	manyResults results;



	destinations.manyDests_val = 0;
	destinations.manyDests_len = 0;
	results.manyResults_val = 0;
	results.manyResults_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &fromTrans))
	     || (!xdr_afs_int32(z_xdrs, &fromDate))
	     || (!xdr_manyDests(z_xdrs, &destinations))
	     || (!xdr_afs_int32(z_xdrs, &spare))
	     || (!xdr_restoreCookie(z_xdrs, &cookie))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolForwardMultiple(z_call, fromTrans, fromDate, &destinations, spare, &cookie, &results);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_manyResults(z_xdrs, &results)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_manyDests(z_xdrs, &destinations)) goto fail1;
	if (!xdr_manyResults(z_xdrs, &results)) 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, AFSVolSTATINDEX,
		28, AFSVolNO_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, AFSVolSTATINDEX,
		28, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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




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

	z_result = SAFSVolConvertROtoRWvolume(z_call, partid, volid);
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, AFSVolSTATINDEX,
		29, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolGetSize(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 fromTrans, fromDate;
	struct volintSize size;




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

	z_result = SAFSVolGetSize(z_call, fromTrans, fromDate, &size);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_volintSize(z_xdrs, &size)))
		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, AFSVolSTATINDEX,
		30, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolDumpV2(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 fromTrans, fromDate, flags;




	if ((!xdr_afs_int32(z_xdrs, &fromTrans))
	     || (!xdr_afs_int32(z_xdrs, &fromDate))
	     || (!xdr_afs_int32(z_xdrs, &flags))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolDumpV2(z_call, fromTrans, fromDate, flags);
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, AFSVolSTATINDEX,
		31, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _AFSVolPartitionInfo64(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * name=(char *)0;
	struct diskPartition64 partition;



	if ((!xdr_string(z_xdrs, &name, ~0))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SAFSVolPartitionInfo64(z_call, name, &partition);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_diskPartition64(z_xdrs, &partition)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, ~0)) 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, AFSVolSTATINDEX,
		32, AFSVolNO_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, AFSVolSTATINDEX,
		32, AFSVolNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}


int AFSVolExecuteRequest (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 100:
			z_result = _AFSVolCreateVolume(z_call, &z_xdrs);
			break;
		case 101:
			z_result = _AFSVolDeleteVolume(z_call, &z_xdrs);
			break;
		case 102:
			z_result = _AFSVolRestore(z_call, &z_xdrs);
			break;
		case 103:
			z_result = _AFSVolForward(z_call, &z_xdrs);
			break;
		case 104:
			z_result = _AFSVolEndTrans(z_call, &z_xdrs);
			break;
		case 105:
			z_result = _AFSVolClone(z_call, &z_xdrs);
			break;
		case 106:
			z_result = _AFSVolSetFlags(z_call, &z_xdrs);
			break;
		case 107:
			z_result = _AFSVolGetFlags(z_call, &z_xdrs);
			break;
		case 108:
			z_result = _AFSVolTransCreate(z_call, &z_xdrs);
			break;
		case 109:
			z_result = _AFSVolDump(z_call, &z_xdrs);
			break;
		case 110:
			z_result = _AFSVolGetNthVolume(z_call, &z_xdrs);
			break;
		case 111:
			z_result = _AFSVolSetForwarding(z_call, &z_xdrs);
			break;
		case 112:
			z_result = _AFSVolGetName(z_call, &z_xdrs);
			break;
		case 113:
			z_result = _AFSVolGetStatus(z_call, &z_xdrs);
			break;
		case 114:
			z_result = _AFSVolSignalRestore(z_call, &z_xdrs);
			break;
		case 115:
			z_result = _AFSVolListPartitions(z_call, &z_xdrs);
			break;
		case 116:
			z_result = _AFSVolListVolumes(z_call, &z_xdrs);
			break;
		case 117:
			z_result = _AFSVolSetIdsTypes(z_call, &z_xdrs);
			break;
		case 118:
			z_result = _AFSVolMonitor(z_call, &z_xdrs);
			break;
		case 119:
			z_result = _AFSVolPartitionInfo(z_call, &z_xdrs);
			break;
		case 120:
			z_result = _AFSVolReClone(z_call, &z_xdrs);
			break;
		case 121:
			z_result = _AFSVolListOneVolume(z_call, &z_xdrs);
			break;
		case 122:
			z_result = _AFSVolNukeVolume(z_call, &z_xdrs);
			break;
		case 123:
			z_result = _AFSVolSetDate(z_call, &z_xdrs);
			break;
		case 124:
			z_result = _AFSVolXListVolumes(z_call, &z_xdrs);
			break;
		case 125:
			z_result = _AFSVolXListOneVolume(z_call, &z_xdrs);
			break;
		case 126:
			z_result = _AFSVolSetInfo(z_call, &z_xdrs);
			break;
		case 127:
			z_result = _AFSVolXListPartitions(z_call, &z_xdrs);
			break;
		case 128:
			z_result = _AFSVolForwardMultiple(z_call, &z_xdrs);
			break;
		case 65536:
			z_result = _AFSVolConvertROtoRWvolume(z_call, &z_xdrs);
			break;
		case 65537:
			z_result = _AFSVolGetSize(z_call, &z_xdrs);
			break;
		case 65538:
			z_result = _AFSVolDumpV2(z_call, &z_xdrs);
			break;
		case 65539:
			z_result = _AFSVolPartitionInfo64(z_call, &z_xdrs);
			break;
		default:
			z_result = RXGEN_OPCODE;
			break;
	}
fail:
	return z_result;
}