/* 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 "ubik_int.h"

int VOTE_Beacon(struct rx_connection *z_conn,afs_int32 state,afs_int32 voteStart,ubik_version * Version,ubik_tid * tid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10000;
	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, &state))
	     || (!xdr_afs_int32(&z_xdrs, &voteStart))
	     || (!xdr_ubik_version(&z_xdrs, Version))
	     || (!xdr_ubik_tid(&z_xdrs, tid))) {
		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, VOTE_STATINDEX,
		0, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartVOTE_Beacon(struct rx_call *z_call,afs_int32 state,afs_int32 voteStart,ubik_version * Version,ubik_tid * tid)
{
	static int z_op = 10000;
	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, &state))
	     || (!xdr_afs_int32(&z_xdrs, &voteStart))
	     || (!xdr_ubik_version(&z_xdrs, Version))
	     || (!xdr_ubik_tid(&z_xdrs, tid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndVOTE_Beacon(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, VOTE_STATINDEX,
		0, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_DebugOld(struct rx_connection *z_conn,ubik_debug_old * db)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10001;
	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_ubik_debug_old(&z_xdrs, db))) {
		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, VOTE_STATINDEX,
		1, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_SDebugOld(struct rx_connection *z_conn,afs_int32 which,ubik_sdebug_old * db)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10002;
	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, &which))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_ubik_sdebug_old(&z_xdrs, db))) {
		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, VOTE_STATINDEX,
		2, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_GetSyncSite(struct rx_connection *z_conn,afs_int32 * site)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10003;
	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, site))) {
		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, VOTE_STATINDEX,
		3, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_Debug(struct rx_connection *z_conn,ubik_debug * db)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10004;
	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_ubik_debug(&z_xdrs, db))) {
		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, VOTE_STATINDEX,
		4, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_SDebug(struct rx_connection *z_conn,afs_int32 which,ubik_sdebug * db)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10005;
	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, &which))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_ubik_sdebug(&z_xdrs, db))) {
		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, VOTE_STATINDEX,
		5, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_XDebug(struct rx_connection *z_conn,ubik_debug * db,afs_int32 * isClone)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10006;
	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_ubik_debug(&z_xdrs, db))
	     || (!xdr_afs_int32(&z_xdrs, isClone))) {
		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, VOTE_STATINDEX,
		6, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int VOTE_XSDebug(struct rx_connection *z_conn,afs_int32 which,ubik_sdebug * db,afs_int32 * isClone)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 10007;
	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, &which))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_ubik_sdebug(&z_xdrs, db))
	     || (!xdr_afs_int32(&z_xdrs, isClone))) {
		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, VOTE_STATINDEX,
		7, VOTE_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Begin(struct rx_connection *z_conn,ubik_tid * tid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20000;
	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_ubik_tid(&z_xdrs, tid))) {
		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, DISK_STATINDEX,
		0, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Commit(struct rx_connection *z_conn,ubik_tid * tid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20001;
	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_ubik_tid(&z_xdrs, tid))) {
		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, DISK_STATINDEX,
		1, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Lock(struct rx_connection *z_conn,ubik_tid * tid,afs_int32 file,afs_int32 position,afs_int32 length,afs_int32 type)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20002;
	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_ubik_tid(&z_xdrs, tid))
	     || (!xdr_afs_int32(&z_xdrs, &file))
	     || (!xdr_afs_int32(&z_xdrs, &position))
	     || (!xdr_afs_int32(&z_xdrs, &length))
	     || (!xdr_afs_int32(&z_xdrs, &type))) {
		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, DISK_STATINDEX,
		2, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Write(struct rx_connection *z_conn,ubik_tid * tid,afs_int32 file,afs_int32 position,bulkdata * data)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20003;
	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_ubik_tid(&z_xdrs, tid))
	     || (!xdr_afs_int32(&z_xdrs, &file))
	     || (!xdr_afs_int32(&z_xdrs, &position))
	     || (!xdr_bulkdata(&z_xdrs, data))) {
		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, DISK_STATINDEX,
		3, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_GetVersion(struct rx_connection *z_conn,ubik_version * Version)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20004;
	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_ubik_version(&z_xdrs, Version))) {
		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, DISK_STATINDEX,
		4, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartDISK_GetFile(struct rx_call *z_call,afs_int32 file)
{
	static int z_op = 20005;
	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, &file))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndDISK_GetFile(struct rx_call *z_call,ubik_version * Version)
{
	int z_result;
	XDR z_xdrs;
	/* Un-marshal the reply arguments */
	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	if ((!xdr_ubik_version(&z_xdrs, Version))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, DISK_STATINDEX,
		5, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartDISK_SendFile(struct rx_call *z_call,afs_int32 file,afs_int32 length,ubik_version * Version)
{
	static int z_op = 20006;
	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, &file))
	     || (!xdr_afs_int32(&z_xdrs, &length))
	     || (!xdr_ubik_version(&z_xdrs, Version))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndDISK_SendFile(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, DISK_STATINDEX,
		6, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Abort(struct rx_connection *z_conn,ubik_tid * tid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20007;
	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_ubik_tid(&z_xdrs, tid))) {
		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, DISK_STATINDEX,
		7, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_ReleaseLocks(struct rx_connection *z_conn,ubik_tid * tid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20008;
	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_ubik_tid(&z_xdrs, tid))) {
		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, DISK_STATINDEX,
		8, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Truncate(struct rx_connection *z_conn,ubik_tid * tid,afs_int32 file,afs_int32 length)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20009;
	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_ubik_tid(&z_xdrs, tid))
	     || (!xdr_afs_int32(&z_xdrs, &file))
	     || (!xdr_afs_int32(&z_xdrs, &length))) {
		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, DISK_STATINDEX,
		9, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_Probe(struct rx_connection *z_conn)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20010;
	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;
	}

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

	return z_result;
}

int StartDISK_Probe(struct rx_call *z_call)
{
	static int z_op = 20010;
	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;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndDISK_Probe(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, DISK_STATINDEX,
		10, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_WriteV(struct rx_connection *z_conn,ubik_tid * tid,iovec_wrt * io_vector,iovec_buf * io_buffer)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20011;
	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_ubik_tid(&z_xdrs, tid))
	     || (!xdr_iovec_wrt(&z_xdrs, io_vector))
	     || (!xdr_iovec_buf(&z_xdrs, io_buffer))) {
		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, DISK_STATINDEX,
		11, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_UpdateInterfaceAddr(struct rx_connection *z_conn,UbikInterfaceAddr * inAddr,UbikInterfaceAddr * outAddr)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20012;
	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_UbikInterfaceAddr(&z_xdrs, inAddr))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_UbikInterfaceAddr(&z_xdrs, outAddr))) {
		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, DISK_STATINDEX,
		12, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartDISK_UpdateInterfaceAddr(struct rx_call *z_call,UbikInterfaceAddr * inAddr)
{
	static int z_op = 20012;
	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_UbikInterfaceAddr(&z_xdrs, inAddr))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndDISK_UpdateInterfaceAddr(struct rx_call *z_call,UbikInterfaceAddr * outAddr)
{
	int z_result;
	XDR z_xdrs;
	/* Un-marshal the reply arguments */
	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	if ((!xdr_UbikInterfaceAddr(&z_xdrs, outAddr))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, DISK_STATINDEX,
		12, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int DISK_SetVersion(struct rx_connection *z_conn,ubik_tid * tid,ubik_version * OldVersion,ubik_version * NewVersion)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 20013;
	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_ubik_tid(&z_xdrs, tid))
	     || (!xdr_ubik_version(&z_xdrs, OldVersion))
	     || (!xdr_ubik_version(&z_xdrs, NewVersion))) {
		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, DISK_STATINDEX,
		13, DISK_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

