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

#include "rxstat.h"
static afs_int32 _RXSTATS_RetrieveProcessRPCStats(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_uint32 clientVersion;
	afs_uint32 serverVersion, clock_sec, clock_usec, stat_count;
	rpcStats stats;



	stats.rpcStats_val = 0;
	stats.rpcStats_len = 0;

	if ((!xdr_afs_uint32(z_xdrs, &clientVersion))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = MRXSTATS_RetrieveProcessRPCStats(z_call, clientVersion, &serverVersion, &clock_sec, &clock_usec, &stat_count, &stats);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_uint32(z_xdrs, &serverVersion))
	     || (!xdr_afs_uint32(z_xdrs, &clock_sec))
	     || (!xdr_afs_uint32(z_xdrs, &clock_usec))
	     || (!xdr_afs_uint32(z_xdrs, &stat_count))
	     || (!xdr_rpcStats(z_xdrs, &stats)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_rpcStats(z_xdrs, &stats)) 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, RXSTATS_STATINDEX,
		0, RXSTATS_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, RXSTATS_STATINDEX,
		0, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXSTATS_RetrievePeerRPCStats(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_uint32 clientVersion;
	afs_uint32 serverVersion, stat_count, clock_sec, clock_usec;
	rpcStats stats;



	stats.rpcStats_val = 0;
	stats.rpcStats_len = 0;

	if ((!xdr_afs_uint32(z_xdrs, &clientVersion))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = MRXSTATS_RetrievePeerRPCStats(z_call, clientVersion, &serverVersion, &stat_count, &clock_sec, &clock_usec, &stats);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_uint32(z_xdrs, &serverVersion))
	     || (!xdr_afs_uint32(z_xdrs, &stat_count))
	     || (!xdr_afs_uint32(z_xdrs, &clock_sec))
	     || (!xdr_afs_uint32(z_xdrs, &clock_usec))
	     || (!xdr_rpcStats(z_xdrs, &stats)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_rpcStats(z_xdrs, &stats)) 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, RXSTATS_STATINDEX,
		1, RXSTATS_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, RXSTATS_STATINDEX,
		1, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	z_result = MRXSTATS_QueryProcessRPCStats(z_call, &on);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &on)))
		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, RXSTATS_STATINDEX,
		2, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = MRXSTATS_QueryPeerRPCStats(z_call, &on);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &on)))
		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, RXSTATS_STATINDEX,
		3, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = MRXSTATS_EnableProcessRPCStats(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, RXSTATS_STATINDEX,
		4, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = MRXSTATS_EnablePeerRPCStats(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, RXSTATS_STATINDEX,
		5, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = MRXSTATS_DisableProcessRPCStats(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, RXSTATS_STATINDEX,
		6, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = MRXSTATS_DisablePeerRPCStats(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, RXSTATS_STATINDEX,
		7, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = MRXSTATS_QueryRPCStatsVersion(z_call, &ver);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_uint32(z_xdrs, &ver)))
		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, RXSTATS_STATINDEX,
		8, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




	if ((!xdr_afs_uint32(z_xdrs, &clearFlag))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = MRXSTATS_ClearProcessRPCStats(z_call, clearFlag);
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, RXSTATS_STATINDEX,
		9, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




	if ((!xdr_afs_uint32(z_xdrs, &clearFlag))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = MRXSTATS_ClearPeerRPCStats(z_call, clearFlag);
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, RXSTATS_STATINDEX,
		10, RXSTATS_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}



static afs_int32 (*StubProcsArray0[])(struct rx_call *z_call, XDR *z_xdrs) = {_RXSTATS_RetrieveProcessRPCStats, _RXSTATS_RetrievePeerRPCStats, _RXSTATS_QueryProcessRPCStats, _RXSTATS_QueryPeerRPCStats, _RXSTATS_EnableProcessRPCStats, _RXSTATS_EnablePeerRPCStats, _RXSTATS_DisableProcessRPCStats, _RXSTATS_DisablePeerRPCStats, _RXSTATS_QueryRPCStatsVersion, _RXSTATS_ClearProcessRPCStats, _RXSTATS_ClearPeerRPCStats};

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

	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	if (!xdr_int(&z_xdrs, &op))
		z_result = RXGEN_DECODE;
	else if (op < RXSTATS_LOWEST_OPCODE || op > RXSTATS_HIGHEST_OPCODE)
		z_result = RXGEN_OPCODE;
	else
		z_result = (*StubProcsArray0[op - RXSTATS_LOWEST_OPCODE])(z_call, &z_xdrs);
	return hton_syserr_conv(z_result);
}