fs/lockd/nlm4xdr_gen.c

// SPDX-License-Identifier: GPL-2.0
// Generated by xdrgen. Manual edits will be lost.
// XDR specification file: ../../Documentation/sunrpc/xdr/nlm4.x
// XDR specification modification time: Mon Jun 29 20:42:29 2026

#include <linux/sunrpc/svc.h>

#include "nlm4xdr_gen.h"

static bool __maybe_unused
xdrgen_decode_netobj(struct xdr_stream *xdr, netobj *ptr)
{
	return xdrgen_decode_opaque(xdr, ptr, MAXNETOBJ_SZ);
}

static bool __maybe_unused
xdrgen_decode_fsh4_mode(struct xdr_stream *xdr, fsh4_mode *ptr)
{
	u32 val;

	if (xdr_stream_decode_u32(xdr, &val) < 0)
		return false;
	/* Compiler may optimize to a range check for dense enums */
	switch (val) {
	case fsm_DN:
	case fsm_DR:
	case fsm_DW:
	case fsm_DRW:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

static bool __maybe_unused
xdrgen_decode_fsh4_access(struct xdr_stream *xdr, fsh4_access *ptr)
{
	u32 val;

	if (xdr_stream_decode_u32(xdr, &val) < 0)
		return false;
	/* Compiler may optimize to a range check for dense enums */
	switch (val) {
	case fsa_NONE:
	case fsa_R:
	case fsa_W:
	case fsa_RW:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

static bool __maybe_unused
xdrgen_decode_uint64(struct xdr_stream *xdr, uint64 *ptr)
{
	return xdrgen_decode_unsigned_hyper(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_int64(struct xdr_stream *xdr, int64 *ptr)
{
	return xdrgen_decode_hyper(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_uint32(struct xdr_stream *xdr, uint32 *ptr)
{
	return xdrgen_decode_unsigned_long(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_int32(struct xdr_stream *xdr, int32 *ptr)
{
	return xdrgen_decode_long(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_nlm4_stats(struct xdr_stream *xdr, nlm4_stats *ptr)
{
	__be32 raw;
	u32 val;

	if (xdr_stream_decode_be32(xdr, &raw) < 0)
		return false;
	val = be32_to_cpu(raw);
	/* Compiler may optimize to a range check for dense enums */
	switch (val) {
	case NLM4_GRANTED:
	case NLM4_DENIED:
	case NLM4_DENIED_NOLOCKS:
	case NLM4_BLOCKED:
	case NLM4_DENIED_GRACE_PERIOD:
	case NLM4_DEADLCK:
	case NLM4_ROFS:
	case NLM4_STALE_FH:
	case NLM4_FBIG:
	case NLM4_FAILED:
		break;
	default:
		return false;
	}
	*ptr = raw;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_holder(struct xdr_stream *xdr, struct nlm4_holder *ptr)
{
	if (!xdrgen_decode_bool(xdr, &ptr->exclusive))
		return false;
	if (!xdrgen_decode_int32(xdr, &ptr->svid))
		return false;
	if (!xdrgen_decode_netobj(xdr, &ptr->oh))
		return false;
	if (!xdrgen_decode_uint64(xdr, &ptr->l_offset))
		return false;
	if (!xdrgen_decode_uint64(xdr, &ptr->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_testrply(struct xdr_stream *xdr, struct nlm4_testrply *ptr)
{
	if (!xdrgen_decode_nlm4_stats(xdr, &ptr->stat))
		return false;
	switch (ptr->stat) {
	case __constant_cpu_to_be32(NLM4_DENIED):
		if (!xdrgen_decode_nlm4_holder(xdr, &ptr->u.holder))
			return false;
		break;
	default:
		break;
	}
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_stat(struct xdr_stream *xdr, struct nlm4_stat *ptr)
{
	if (!xdrgen_decode_nlm4_stats(xdr, &ptr->stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_res(struct xdr_stream *xdr, struct nlm4_res *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm4_stat(xdr, &ptr->stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_testres(struct xdr_stream *xdr, struct nlm4_testres *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm4_testrply(xdr, &ptr->stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_lock(struct xdr_stream *xdr, struct nlm4_lock *ptr)
{
	if (!xdrgen_decode_string(xdr, (string *)ptr, LM_MAXSTRLEN))
		return false;
	if (!xdrgen_decode_netobj(xdr, &ptr->fh))
		return false;
	if (!xdrgen_decode_netobj(xdr, &ptr->oh))
		return false;
	if (!xdrgen_decode_int32(xdr, &ptr->svid))
		return false;
	if (!xdrgen_decode_uint64(xdr, &ptr->l_offset))
		return false;
	if (!xdrgen_decode_uint64(xdr, &ptr->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_lockargs(struct xdr_stream *xdr, struct nlm4_lockargs *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->block))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->exclusive))
		return false;
	if (!xdrgen_decode_nlm4_lock(xdr, &ptr->alock))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->reclaim))
		return false;
	if (!xdrgen_decode_int32(xdr, &ptr->state))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_cancargs(struct xdr_stream *xdr, struct nlm4_cancargs *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->block))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->exclusive))
		return false;
	if (!xdrgen_decode_nlm4_lock(xdr, &ptr->alock))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_testargs(struct xdr_stream *xdr, struct nlm4_testargs *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->exclusive))
		return false;
	if (!xdrgen_decode_nlm4_lock(xdr, &ptr->alock))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_unlockargs(struct xdr_stream *xdr, struct nlm4_unlockargs *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm4_lock(xdr, &ptr->alock))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_share(struct xdr_stream *xdr, struct nlm4_share *ptr)
{
	if (!xdrgen_decode_string(xdr, (string *)ptr, LM_MAXSTRLEN))
		return false;
	if (!xdrgen_decode_netobj(xdr, &ptr->fh))
		return false;
	if (!xdrgen_decode_netobj(xdr, &ptr->oh))
		return false;
	if (!xdrgen_decode_fsh4_mode(xdr, &ptr->mode))
		return false;
	if (!xdrgen_decode_fsh4_access(xdr, &ptr->access))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_shareargs(struct xdr_stream *xdr, struct nlm4_shareargs *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm4_share(xdr, &ptr->share))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->reclaim))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_shareres(struct xdr_stream *xdr, struct nlm4_shareres *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm4_stats(xdr, &ptr->stat))
		return false;
	if (!xdrgen_decode_int32(xdr, &ptr->sequence))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_notify(struct xdr_stream *xdr, struct nlm4_notify *ptr)
{
	if (!xdrgen_decode_string(xdr, (string *)ptr, LM_MAXNAMELEN))
		return false;
	if (!xdrgen_decode_int32(xdr, &ptr->state))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm4_notifyargs(struct xdr_stream *xdr, struct nlm4_notifyargs *ptr)
{
	if (!xdrgen_decode_nlm4_notify(xdr, &ptr->notify))
		return false;
	if (xdr_stream_decode_opaque_fixed(xdr, ptr->private, SM_PRIV_SIZE) < 0)
		return false;
	return true;
}

/**
 * nlm4_svc_decode_nlm4_testargs - Decode a nlm4_testargs argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_testargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_testargs *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_testargs(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_lockargs - Decode a nlm4_lockargs argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_lockargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_lockargs *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_lockargs(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_cancargs - Decode a nlm4_cancargs argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_cancargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_cancargs *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_cancargs(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_unlockargs - Decode a nlm4_unlockargs argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_unlockargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_unlockargs *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_unlockargs(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_testres - Decode a nlm4_testres argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_testres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_testres *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_testres(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_res - Decode a nlm4_res argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_res(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_res *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_res(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_notifyargs - Decode a nlm4_notifyargs argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_notifyargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_notifyargs *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_notifyargs(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_shareargs - Decode a nlm4_shareargs argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_shareargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_shareargs *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_shareargs(xdr, argp);
}

/**
 * nlm4_svc_decode_nlm4_notify - Decode a nlm4_notify argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm4_svc_decode_nlm4_notify(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_notify *argp = rqstp->rq_argp;

	return xdrgen_decode_nlm4_notify(xdr, argp);
}

static bool __maybe_unused
xdrgen_encode_netobj(struct xdr_stream *xdr, const netobj value)
{
	return xdr_stream_encode_opaque(xdr, value.data, value.len) >= 0;
}

static bool __maybe_unused
xdrgen_encode_fsh4_mode(struct xdr_stream *xdr, fsh4_mode value)
{
	return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
}

static bool __maybe_unused
xdrgen_encode_fsh4_access(struct xdr_stream *xdr, fsh4_access value)
{
	return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
}

static bool __maybe_unused
xdrgen_encode_uint64(struct xdr_stream *xdr, const uint64 value)
{
	return xdrgen_encode_unsigned_hyper(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_int64(struct xdr_stream *xdr, const int64 value)
{
	return xdrgen_encode_hyper(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_uint32(struct xdr_stream *xdr, const uint32 value)
{
	return xdrgen_encode_unsigned_long(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_int32(struct xdr_stream *xdr, const int32 value)
{
	return xdrgen_encode_long(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_nlm4_stats(struct xdr_stream *xdr, nlm4_stats value)
{
	return xdr_stream_encode_be32(xdr, value) == XDR_UNIT;
}

static bool __maybe_unused
xdrgen_encode_nlm4_holder(struct xdr_stream *xdr, const struct nlm4_holder *value)
{
	if (!xdrgen_encode_bool(xdr, value->exclusive))
		return false;
	if (!xdrgen_encode_int32(xdr, value->svid))
		return false;
	if (!xdrgen_encode_netobj(xdr, value->oh))
		return false;
	if (!xdrgen_encode_uint64(xdr, value->l_offset))
		return false;
	if (!xdrgen_encode_uint64(xdr, value->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_testrply(struct xdr_stream *xdr, const struct nlm4_testrply *ptr)
{
	if (!xdrgen_encode_nlm4_stats(xdr, ptr->stat))
		return false;
	switch (ptr->stat) {
	case __constant_cpu_to_be32(NLM4_DENIED):
		if (!xdrgen_encode_nlm4_holder(xdr, &ptr->u.holder))
			return false;
		break;
	default:
		break;
	}
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_stat(struct xdr_stream *xdr, const struct nlm4_stat *value)
{
	if (!xdrgen_encode_nlm4_stats(xdr, value->stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_res(struct xdr_stream *xdr, const struct nlm4_res *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm4_stat(xdr, &value->stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_testres(struct xdr_stream *xdr, const struct nlm4_testres *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm4_testrply(xdr, &value->stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_lock(struct xdr_stream *xdr, const struct nlm4_lock *value)
{
	if (value->caller_name.len > LM_MAXSTRLEN)
		return false;
	if (xdr_stream_encode_opaque(xdr, value->caller_name.data, value->caller_name.len) < 0)
		return false;
	if (!xdrgen_encode_netobj(xdr, value->fh))
		return false;
	if (!xdrgen_encode_netobj(xdr, value->oh))
		return false;
	if (!xdrgen_encode_int32(xdr, value->svid))
		return false;
	if (!xdrgen_encode_uint64(xdr, value->l_offset))
		return false;
	if (!xdrgen_encode_uint64(xdr, value->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_lockargs(struct xdr_stream *xdr, const struct nlm4_lockargs *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_bool(xdr, value->block))
		return false;
	if (!xdrgen_encode_bool(xdr, value->exclusive))
		return false;
	if (!xdrgen_encode_nlm4_lock(xdr, &value->alock))
		return false;
	if (!xdrgen_encode_bool(xdr, value->reclaim))
		return false;
	if (!xdrgen_encode_int32(xdr, value->state))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_cancargs(struct xdr_stream *xdr, const struct nlm4_cancargs *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_bool(xdr, value->block))
		return false;
	if (!xdrgen_encode_bool(xdr, value->exclusive))
		return false;
	if (!xdrgen_encode_nlm4_lock(xdr, &value->alock))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_testargs(struct xdr_stream *xdr, const struct nlm4_testargs *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_bool(xdr, value->exclusive))
		return false;
	if (!xdrgen_encode_nlm4_lock(xdr, &value->alock))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_unlockargs(struct xdr_stream *xdr, const struct nlm4_unlockargs *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm4_lock(xdr, &value->alock))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_share(struct xdr_stream *xdr, const struct nlm4_share *value)
{
	if (value->caller_name.len > LM_MAXSTRLEN)
		return false;
	if (xdr_stream_encode_opaque(xdr, value->caller_name.data, value->caller_name.len) < 0)
		return false;
	if (!xdrgen_encode_netobj(xdr, value->fh))
		return false;
	if (!xdrgen_encode_netobj(xdr, value->oh))
		return false;
	if (!xdrgen_encode_fsh4_mode(xdr, value->mode))
		return false;
	if (!xdrgen_encode_fsh4_access(xdr, value->access))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_shareargs(struct xdr_stream *xdr, const struct nlm4_shareargs *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm4_share(xdr, &value->share))
		return false;
	if (!xdrgen_encode_bool(xdr, value->reclaim))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_shareres(struct xdr_stream *xdr, const struct nlm4_shareres *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm4_stats(xdr, value->stat))
		return false;
	if (!xdrgen_encode_int32(xdr, value->sequence))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_notify(struct xdr_stream *xdr, const struct nlm4_notify *value)
{
	if (value->name.len > LM_MAXNAMELEN)
		return false;
	if (xdr_stream_encode_opaque(xdr, value->name.data, value->name.len) < 0)
		return false;
	if (!xdrgen_encode_int32(xdr, value->state))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm4_notifyargs(struct xdr_stream *xdr, const struct nlm4_notifyargs *value)
{
	if (!xdrgen_encode_nlm4_notify(xdr, &value->notify))
		return false;
	if (xdr_stream_encode_opaque_fixed(xdr, value->private, SM_PRIV_SIZE) < 0)
		return false;
	return true;
}

/**
 * nlm4_svc_encode_nlm4_testres - Encode a nlm4_testres result
 * @rqstp: RPC transaction context
 * @xdr: target XDR data stream
 *
 * Return values:
 *   %true: procedure results encoded successfully
 *   %false: encode failed
 */
bool nlm4_svc_encode_nlm4_testres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_testres *resp = rqstp->rq_resp;

	return xdrgen_encode_nlm4_testres(xdr, resp);
}

/**
 * nlm4_svc_encode_nlm4_res - Encode a nlm4_res result
 * @rqstp: RPC transaction context
 * @xdr: target XDR data stream
 *
 * Return values:
 *   %true: procedure results encoded successfully
 *   %false: encode failed
 */
bool nlm4_svc_encode_nlm4_res(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_res *resp = rqstp->rq_resp;

	return xdrgen_encode_nlm4_res(xdr, resp);
}

/**
 * nlm4_svc_encode_nlm4_shareres - Encode a nlm4_shareres result
 * @rqstp: RPC transaction context
 * @xdr: target XDR data stream
 *
 * Return values:
 *   %true: procedure results encoded successfully
 *   %false: encode failed
 */
bool nlm4_svc_encode_nlm4_shareres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	struct nlm4_shareres *resp = rqstp->rq_resp;

	return xdrgen_encode_nlm4_shareres(xdr, resp);
}