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

#include <afsconfig.h>
#include <afs/param.h>
#include <roken.h>
#include <afs/opr.h>
#ifdef AFS_PTHREAD_ENV
# include <opr/lock.h>
#endif
#include "volint.h"

#define VOLDUMPV2_OMITDIRS 1
int AFSVolCreateVolume(struct rx_connection *z_conn,afs_int32 partition,const char * name,afs_int32 type,afs_uint32 parent,afs_uint32 * volid,afs_int32 * trans)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 100;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partition))
	     || (!xdr_string(&z_xdrs, (char **) &name, 32))
	     || (!xdr_afs_int32(&z_xdrs, &type))
	     || (!xdr_afs_uint32(&z_xdrs, &parent))
	     || (!xdr_afs_uint32(&z_xdrs, volid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_uint32(&z_xdrs, volid))
	     || (!xdr_afs_int32(&z_xdrs, trans))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		0, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolDeleteVolume(struct rx_connection *z_conn,afs_int32 trans)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 101;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &trans))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		1, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartAFSVolRestore(struct rx_call *z_call,afs_int32 toTrans,afs_int32 flags,struct restoreCookie * cookie)
{
	static int z_op = 102;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &toTrans))
	     || (!xdr_afs_int32(&z_xdrs, &flags))
	     || (!xdr_restoreCookie(&z_xdrs, cookie))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndAFSVolRestore(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		2, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolForward(struct rx_connection *z_conn,afs_int32 fromTrans,afs_int32 fromDate,struct destServer * destination,afs_int32 destTrans,struct restoreCookie * cookie)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 103;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!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_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		3, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolEndTrans(struct rx_connection *z_conn,afs_int32 trans,afs_int32 * rcode)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 104;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &trans))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_int32(&z_xdrs, rcode))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		4, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolClone(struct rx_connection *z_conn,afs_int32 trans,afs_uint32 purgeVol,afs_int32 newType,const char * newName,afs_uint32 * newVol)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 105;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &trans))
	     || (!xdr_afs_uint32(&z_xdrs, &purgeVol))
	     || (!xdr_afs_int32(&z_xdrs, &newType))
	     || (!xdr_string(&z_xdrs, (char **) &newName, 32))
	     || (!xdr_afs_uint32(&z_xdrs, newVol))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_uint32(&z_xdrs, newVol))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		5, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolSetFlags(struct rx_connection *z_conn,afs_int32 trans,afs_int32 flags)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 106;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &trans))
	     || (!xdr_afs_int32(&z_xdrs, &flags))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		6, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolGetFlags(struct rx_connection *z_conn,afs_int32 trans,afs_int32 * flags)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 107;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &trans))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_int32(&z_xdrs, flags))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		7, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolTransCreate(struct rx_connection *z_conn,afs_uint32 volume,afs_int32 partition,afs_int32 flags,afs_int32 * trans)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 108;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_uint32(&z_xdrs, &volume))
	     || (!xdr_afs_int32(&z_xdrs, &partition))
	     || (!xdr_afs_int32(&z_xdrs, &flags))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_int32(&z_xdrs, trans))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		8, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartAFSVolDump(struct rx_call *z_call,afs_int32 fromTrans,afs_int32 fromDate)
{
	static int z_op = 109;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &fromTrans))
	     || (!xdr_afs_int32(&z_xdrs, &fromDate))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndAFSVolDump(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		9, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolGetNthVolume(struct rx_connection *z_conn,afs_int32 index,afs_uint32 * volume,afs_int32 * partition)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 110;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &index))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_uint32(&z_xdrs, volume))
	     || (!xdr_afs_int32(&z_xdrs, partition))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		10, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolSetForwarding(struct rx_connection *z_conn,afs_int32 tid,afs_int32 newsite)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 111;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tid))
	     || (!xdr_afs_int32(&z_xdrs, &newsite))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		11, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolGetName(struct rx_connection *z_conn,afs_int32 tid,char * *tname)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 112;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_string(&z_xdrs, tname, 256))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		12, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolGetStatus(struct rx_connection *z_conn,afs_int32 tid,struct volser_status * status)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 113;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_volser_status(&z_xdrs, status))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		13, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolSignalRestore(struct rx_connection *z_conn,const char * name,int type,afs_uint32 pid,afs_uint32 cloneid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 114;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_string(&z_xdrs, (char **) &name, 32))
	     || (!xdr_int(&z_xdrs, &type))
	     || (!xdr_afs_uint32(&z_xdrs, &pid))
	     || (!xdr_afs_uint32(&z_xdrs, &cloneid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		14, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolListPartitions(struct rx_connection *z_conn,struct pIDs * partIDs)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 115;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_pIDs(&z_xdrs, partIDs))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		15, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolListVolumes(struct rx_connection *z_conn,afs_int32 partID,afs_int32 flags,volEntries * resultEntries)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 116;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partID))
	     || (!xdr_afs_int32(&z_xdrs, &flags))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_volEntries(&z_xdrs, resultEntries))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		16, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolSetIdsTypes(struct rx_connection *z_conn,afs_int32 tId,const char * name,afs_int32 type,afs_uint32 pId,afs_uint32 cloneId,afs_uint32 backupId)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 117;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tId))
	     || (!xdr_string(&z_xdrs, (char **) &name, 32))
	     || (!xdr_afs_int32(&z_xdrs, &type))
	     || (!xdr_afs_uint32(&z_xdrs, &pId))
	     || (!xdr_afs_uint32(&z_xdrs, &cloneId))
	     || (!xdr_afs_uint32(&z_xdrs, &backupId))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		17, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolMonitor(struct rx_connection *z_conn,transDebugEntries * result)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 118;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_transDebugEntries(&z_xdrs, result))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		18, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolPartitionInfo(struct rx_connection *z_conn,const char * name,struct diskPartition * partition)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 119;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_string(&z_xdrs, (char **) &name, 4096))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_diskPartition(&z_xdrs, partition))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		19, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolReClone(struct rx_connection *z_conn,afs_int32 tid,afs_uint32 cloneID)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 120;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tid))
	     || (!xdr_afs_uint32(&z_xdrs, &cloneID))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		20, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolListOneVolume(struct rx_connection *z_conn,afs_int32 partID,afs_uint32 volid,volEntries * resultEntries)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 121;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partID))
	     || (!xdr_afs_uint32(&z_xdrs, &volid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_volEntries(&z_xdrs, resultEntries))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		21, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolNukeVolume(struct rx_connection *z_conn,afs_int32 partID,afs_uint32 volID)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 122;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partID))
	     || (!xdr_afs_uint32(&z_xdrs, &volID))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		22, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolSetDate(struct rx_connection *z_conn,afs_int32 tid,afs_int32 newDate)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 123;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tid))
	     || (!xdr_afs_int32(&z_xdrs, &newDate))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		23, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolXListVolumes(struct rx_connection *z_conn,afs_int32 partID,afs_int32 flags,volXEntries * resultXEntriesP)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 124;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partID))
	     || (!xdr_afs_int32(&z_xdrs, &flags))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_volXEntries(&z_xdrs, resultXEntriesP))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		24, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolXListOneVolume(struct rx_connection *z_conn,afs_int32 partID,afs_uint32 volid,volXEntries * resultXEntries)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 125;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partID))
	     || (!xdr_afs_uint32(&z_xdrs, &volid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_volXEntries(&z_xdrs, resultXEntries))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		25, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolSetInfo(struct rx_connection *z_conn,afs_int32 tid,struct volintInfo * status)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 126;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &tid))
	     || (!xdr_volintInfo(&z_xdrs, status))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		26, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolXListPartitions(struct rx_connection *z_conn,struct partEntries * partIDs)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 127;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_partEntries(&z_xdrs, partIDs))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		27, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolForwardMultiple(struct rx_connection *z_conn,afs_int32 fromTrans,afs_int32 fromDate,manyDests * destinations,afs_int32 spare,struct restoreCookie * cookie,manyResults * results)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 128;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!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_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_manyResults(&z_xdrs, results))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		28, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolConvertROtoRWvolume(struct rx_connection *z_conn,afs_int32 partid,afs_uint32 volid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 65536;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &partid))
	     || (!xdr_afs_uint32(&z_xdrs, &volid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		29, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolGetSize(struct rx_connection *z_conn,afs_int32 fromTrans,afs_int32 fromDate,struct volintSize * size)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 65537;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &fromTrans))
	     || (!xdr_afs_int32(&z_xdrs, &fromDate))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_volintSize(&z_xdrs, size))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		30, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartAFSVolDumpV2(struct rx_call *z_call,afs_int32 fromTrans,afs_int32 fromDate,afs_int32 flags)
{
	static int z_op = 65538;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &fromTrans))
	     || (!xdr_afs_int32(&z_xdrs, &fromDate))
	     || (!xdr_afs_int32(&z_xdrs, &flags))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndAFSVolDumpV2(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		31, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int AFSVolPartitionInfo64(struct rx_connection *z_conn,const char * name,struct diskPartition64 * partition)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 65539;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_string(&z_xdrs, (char **) &name, 4096))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_diskPartition64(&z_xdrs, partition))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		32, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartAFSVolSplitVolume(struct rx_call *z_call,afs_uint32 vid,afs_uint32 newid,afs_uint32 where,afs_int32 verbose)
{
	static int z_op = 65547;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_uint32(&z_xdrs, &vid))
	     || (!xdr_afs_uint32(&z_xdrs, &newid))
	     || (!xdr_afs_uint32(&z_xdrs, &where))
	     || (!xdr_afs_int32(&z_xdrs, &verbose))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndAFSVolSplitVolume(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, AFSVolSTATINDEX,
		33, AFSVolNO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

