fs/lockd/nlm3xdr_gen.c

// SPDX-License-Identifier: GPL-2.0
// Generated by xdrgen. Manual edits will be lost.
// XDR specification file: ../../Documentation/sunrpc/xdr/nlm3.x
// XDR specification modification time: Thu Apr 23 10:56:34 2026

#include <linux/sunrpc/svc.h>

#include "nlm3xdr_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_nlm_stats(struct xdr_stream *xdr, nlm_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 LCK_GRANTED:
	case LCK_DENIED:
	case LCK_DENIED_NOLOCKS:
	case LCK_BLOCKED:
	case LCK_DENIED_GRACE_PERIOD:
		break;
	default:
		return false;
	}
	*ptr = raw;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm_stat(struct xdr_stream *xdr, struct nlm_stat *ptr)
{
	if (!xdrgen_decode_nlm_stats(xdr, &ptr->stat))
		return false;
	return true;
}

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

static bool __maybe_unused
xdrgen_decode_nlm_holder(struct xdr_stream *xdr, struct nlm_holder *ptr)
{
	if (!xdrgen_decode_bool(xdr, &ptr->exclusive))
		return false;
	if (!xdrgen_decode_int(xdr, &ptr->uppid))
		return false;
	if (!xdrgen_decode_netobj(xdr, &ptr->oh))
		return false;
	if (!xdrgen_decode_unsigned_int(xdr, &ptr->l_offset))
		return false;
	if (!xdrgen_decode_unsigned_int(xdr, &ptr->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm_testrply(struct xdr_stream *xdr, struct nlm_testrply *ptr)
{
	if (!xdrgen_decode_nlm_stats(xdr, &ptr->stat))
		return false;
	switch (ptr->stat) {
	case __constant_cpu_to_be32(LCK_DENIED):
		if (!xdrgen_decode_nlm_holder(xdr, &ptr->u.holder))
			return false;
		break;
	default:
		break;
	}
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm_testres(struct xdr_stream *xdr, struct nlm_testres *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm_testrply(xdr, &ptr->test_stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm_lock(struct xdr_stream *xdr, struct nlm_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_int(xdr, &ptr->uppid))
		return false;
	if (!xdrgen_decode_unsigned_int(xdr, &ptr->l_offset))
		return false;
	if (!xdrgen_decode_unsigned_int(xdr, &ptr->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm_lockargs(struct xdr_stream *xdr, struct nlm_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_nlm_lock(xdr, &ptr->alock))
		return false;
	if (!xdrgen_decode_bool(xdr, &ptr->reclaim))
		return false;
	if (!xdrgen_decode_int(xdr, &ptr->state))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_nlm_cancargs(struct xdr_stream *xdr, struct nlm_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_nlm_lock(xdr, &ptr->alock))
		return false;
	return true;
}

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

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

static bool __maybe_unused
xdrgen_decode_fsh_mode(struct xdr_stream *xdr, fsh_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_fsh_access(struct xdr_stream *xdr, fsh_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_nlm_share(struct xdr_stream *xdr, struct nlm_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_fsh_mode(xdr, &ptr->mode))
		return false;
	if (!xdrgen_decode_fsh_access(xdr, &ptr->access))
		return false;
	return true;
}

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

static bool __maybe_unused
xdrgen_decode_nlm_shareres(struct xdr_stream *xdr, struct nlm_shareres *ptr)
{
	if (!xdrgen_decode_netobj(xdr, &ptr->cookie))
		return false;
	if (!xdrgen_decode_nlm_stats(xdr, &ptr->stat))
		return false;
	if (!xdrgen_decode_int(xdr, &ptr->sequence))
		return false;
	return true;
}

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

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

/**
 * nlm_svc_decode_void - Decode a void argument
 * @rqstp: RPC transaction context
 * @xdr: source XDR data stream
 *
 * Return values:
 *   %true: procedure arguments decoded successfully
 *   %false: decode failed
 */
bool nlm_svc_decode_void(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	return xdrgen_decode_void(xdr);
}

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

	return xdrgen_decode_nlm_testargs(xdr, argp);
}

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

	return xdrgen_decode_nlm_lockargs(xdr, argp);
}

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

	return xdrgen_decode_nlm_cancargs(xdr, argp);
}

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

	return xdrgen_decode_nlm_unlockargs(xdr, argp);
}

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

	return xdrgen_decode_nlm_testres(xdr, argp);
}

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

	return xdrgen_decode_nlm_res(xdr, argp);
}

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

	return xdrgen_decode_nlm_notifyargs(xdr, argp);
}

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

	return xdrgen_decode_nlm_shareargs(xdr, argp);
}

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

	return xdrgen_decode_nlm_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_nlm_stats(struct xdr_stream *xdr, nlm_stats value)
{
	return xdr_stream_encode_be32(xdr, value) == XDR_UNIT;
}

static bool __maybe_unused
xdrgen_encode_nlm_stat(struct xdr_stream *xdr, const struct nlm_stat *value)
{
	if (!xdrgen_encode_nlm_stats(xdr, value->stat))
		return false;
	return true;
}

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

static bool __maybe_unused
xdrgen_encode_nlm_holder(struct xdr_stream *xdr, const struct nlm_holder *value)
{
	if (!xdrgen_encode_bool(xdr, value->exclusive))
		return false;
	if (!xdrgen_encode_int(xdr, value->uppid))
		return false;
	if (!xdrgen_encode_netobj(xdr, value->oh))
		return false;
	if (!xdrgen_encode_unsigned_int(xdr, value->l_offset))
		return false;
	if (!xdrgen_encode_unsigned_int(xdr, value->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm_testrply(struct xdr_stream *xdr, const struct nlm_testrply *ptr)
{
	if (!xdrgen_encode_nlm_stats(xdr, ptr->stat))
		return false;
	switch (ptr->stat) {
	case __constant_cpu_to_be32(LCK_DENIED):
		if (!xdrgen_encode_nlm_holder(xdr, &ptr->u.holder))
			return false;
		break;
	default:
		break;
	}
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm_testres(struct xdr_stream *xdr, const struct nlm_testres *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm_testrply(xdr, &value->test_stat))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm_lock(struct xdr_stream *xdr, const struct nlm_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_int(xdr, value->uppid))
		return false;
	if (!xdrgen_encode_unsigned_int(xdr, value->l_offset))
		return false;
	if (!xdrgen_encode_unsigned_int(xdr, value->l_len))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm_lockargs(struct xdr_stream *xdr, const struct nlm_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_nlm_lock(xdr, &value->alock))
		return false;
	if (!xdrgen_encode_bool(xdr, value->reclaim))
		return false;
	if (!xdrgen_encode_int(xdr, value->state))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm_cancargs(struct xdr_stream *xdr, const struct nlm_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_nlm_lock(xdr, &value->alock))
		return false;
	return true;
}

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

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

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

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

static bool __maybe_unused
xdrgen_encode_nlm_share(struct xdr_stream *xdr, const struct nlm_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_fsh_mode(xdr, value->mode))
		return false;
	if (!xdrgen_encode_fsh_access(xdr, value->access))
		return false;
	return true;
}

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

static bool __maybe_unused
xdrgen_encode_nlm_shareres(struct xdr_stream *xdr, const struct nlm_shareres *value)
{
	if (!xdrgen_encode_netobj(xdr, value->cookie))
		return false;
	if (!xdrgen_encode_nlm_stats(xdr, value->stat))
		return false;
	if (!xdrgen_encode_int(xdr, value->sequence))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_nlm_notify(struct xdr_stream *xdr, const struct nlm_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_long(xdr, value->state))
		return false;
	return true;
}

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

/**
 * nlm_svc_encode_void - Encode a void result
 * @rqstp: RPC transaction context
 * @xdr: target XDR data stream
 *
 * Return values:
 *   %true: procedure results encoded successfully
 *   %false: encode failed
 */
bool nlm_svc_encode_void(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
	return xdrgen_encode_void(xdr);
}

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

	return xdrgen_encode_nlm_testres(xdr, resp);
}

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

	return xdrgen_encode_nlm_res(xdr, resp);
}

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

	return xdrgen_encode_nlm_shareres(xdr, resp);
}