Contributors: 5
Author Tokens Token Proportion Commits Commit Proportion
Jeff Layton 1514 65.34% 2 25.00%
Chuck Lever 475 20.50% 3 37.50%
Anna Schumaker 162 6.99% 1 12.50%
Trond Myklebust 112 4.83% 1 12.50%
Fred Isaman 54 2.33% 1 12.50%
Total 2317 8 


// SPDX-License-Identifier: GPL-2.0
// Generated by xdrgen. Manual edits will be lost.
// XDR specification file: ../../Documentation/sunrpc/xdr/nfs4_1.x
// XDR specification modification time: Thu Jan  8 23:12:07 2026

#include <linux/sunrpc/svc.h>

#include "nfs4xdr_gen.h"

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

static bool __maybe_unused
xdrgen_decode_uint32_t(struct xdr_stream *xdr, uint32_t *ptr)
{
	return xdrgen_decode_unsigned_int(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_bitmap4(struct xdr_stream *xdr, bitmap4 *ptr)
{
	if (xdr_stream_decode_u32(xdr, &ptr->count) < 0)
		return false;
	for (u32 i = 0; i < ptr->count; i++)
		if (!xdrgen_decode_uint32_t(xdr, &ptr->element[i]))
			return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_utf8string(struct xdr_stream *xdr, utf8string *ptr)
{
	return xdrgen_decode_opaque(xdr, ptr, 0);
}

static bool __maybe_unused
xdrgen_decode_utf8str_cis(struct xdr_stream *xdr, utf8str_cis *ptr)
{
	return xdrgen_decode_utf8string(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_utf8str_cs(struct xdr_stream *xdr, utf8str_cs *ptr)
{
	return xdrgen_decode_utf8string(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_utf8str_mixed(struct xdr_stream *xdr, utf8str_mixed *ptr)
{
	return xdrgen_decode_utf8string(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_nfstime4(struct xdr_stream *xdr, struct nfstime4 *ptr)
{
	if (!xdrgen_decode_int64_t(xdr, &ptr->seconds))
		return false;
	if (!xdrgen_decode_uint32_t(xdr, &ptr->nseconds))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_fattr4_offline(struct xdr_stream *xdr, fattr4_offline *ptr)
{
	return xdrgen_decode_bool(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_open_arguments4(struct xdr_stream *xdr, struct open_arguments4 *ptr)
{
	if (!xdrgen_decode_bitmap4(xdr, &ptr->oa_share_access))
		return false;
	if (!xdrgen_decode_bitmap4(xdr, &ptr->oa_share_deny))
		return false;
	if (!xdrgen_decode_bitmap4(xdr, &ptr->oa_share_access_want))
		return false;
	if (!xdrgen_decode_bitmap4(xdr, &ptr->oa_open_claim))
		return false;
	if (!xdrgen_decode_bitmap4(xdr, &ptr->oa_create_mode))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_open_args_share_access4(struct xdr_stream *xdr, open_args_share_access4 *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 OPEN_ARGS_SHARE_ACCESS_READ:
	case OPEN_ARGS_SHARE_ACCESS_WRITE:
	case OPEN_ARGS_SHARE_ACCESS_BOTH:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

static bool __maybe_unused
xdrgen_decode_open_args_share_deny4(struct xdr_stream *xdr, open_args_share_deny4 *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 OPEN_ARGS_SHARE_DENY_NONE:
	case OPEN_ARGS_SHARE_DENY_READ:
	case OPEN_ARGS_SHARE_DENY_WRITE:
	case OPEN_ARGS_SHARE_DENY_BOTH:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

static bool __maybe_unused
xdrgen_decode_open_args_share_access_want4(struct xdr_stream *xdr, open_args_share_access_want4 *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 OPEN_ARGS_SHARE_ACCESS_WANT_ANY_DELEG:
	case OPEN_ARGS_SHARE_ACCESS_WANT_NO_DELEG:
	case OPEN_ARGS_SHARE_ACCESS_WANT_CANCEL:
	case OPEN_ARGS_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
	case OPEN_ARGS_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED:
	case OPEN_ARGS_SHARE_ACCESS_WANT_DELEG_TIMESTAMPS:
	case OPEN_ARGS_SHARE_ACCESS_WANT_OPEN_XOR_DELEGATION:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

static bool __maybe_unused
xdrgen_decode_open_args_open_claim4(struct xdr_stream *xdr, open_args_open_claim4 *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 OPEN_ARGS_OPEN_CLAIM_NULL:
	case OPEN_ARGS_OPEN_CLAIM_PREVIOUS:
	case OPEN_ARGS_OPEN_CLAIM_DELEGATE_CUR:
	case OPEN_ARGS_OPEN_CLAIM_DELEGATE_PREV:
	case OPEN_ARGS_OPEN_CLAIM_FH:
	case OPEN_ARGS_OPEN_CLAIM_DELEG_CUR_FH:
	case OPEN_ARGS_OPEN_CLAIM_DELEG_PREV_FH:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

static bool __maybe_unused
xdrgen_decode_open_args_createmode4(struct xdr_stream *xdr, open_args_createmode4 *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 OPEN_ARGS_CREATEMODE_UNCHECKED4:
	case OPEN_ARGS_CREATE_MODE_GUARDED:
	case OPEN_ARGS_CREATEMODE_EXCLUSIVE4:
	case OPEN_ARGS_CREATE_MODE_EXCLUSIVE4_1:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

bool
xdrgen_decode_fattr4_open_arguments(struct xdr_stream *xdr, fattr4_open_arguments *ptr)
{
	return xdrgen_decode_open_arguments4(xdr, ptr);
}

/*
 * Determine what OPEN supports.
 */

bool
xdrgen_decode_fattr4_time_deleg_access(struct xdr_stream *xdr, fattr4_time_deleg_access *ptr)
{
	return xdrgen_decode_nfstime4(xdr, ptr);
}

bool
xdrgen_decode_fattr4_time_deleg_modify(struct xdr_stream *xdr, fattr4_time_deleg_modify *ptr)
{
	return xdrgen_decode_nfstime4(xdr, ptr);
}

/*
 * New RECOMMENDED Attribute for
 * delegation caching of times
 */

static bool __maybe_unused
xdrgen_decode_open_delegation_type4(struct xdr_stream *xdr, open_delegation_type4 *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 OPEN_DELEGATE_NONE:
	case OPEN_DELEGATE_READ:
	case OPEN_DELEGATE_WRITE:
	case OPEN_DELEGATE_NONE_EXT:
	case OPEN_DELEGATE_READ_ATTRS_DELEG:
	case OPEN_DELEGATE_WRITE_ATTRS_DELEG:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

bool
xdrgen_decode_aclmodel4(struct xdr_stream *xdr, aclmodel4 *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 ACL_MODEL_NFS4:
	case ACL_MODEL_POSIX_DRAFT:
	case ACL_MODEL_NONE:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

bool
xdrgen_decode_aclscope4(struct xdr_stream *xdr, aclscope4 *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 ACL_SCOPE_FILE_OBJECT:
	case ACL_SCOPE_FILE_SYSTEM:
	case ACL_SCOPE_SERVER:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

bool
xdrgen_decode_posixacetag4(struct xdr_stream *xdr, posixacetag4 *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 POSIXACE4_TAG_USER_OBJ:
	case POSIXACE4_TAG_USER:
	case POSIXACE4_TAG_GROUP_OBJ:
	case POSIXACE4_TAG_GROUP:
	case POSIXACE4_TAG_MASK:
	case POSIXACE4_TAG_OTHER:
		break;
	default:
		return false;
	}
	*ptr = val;
	return true;
}

bool
xdrgen_decode_posixaceperm4(struct xdr_stream *xdr, posixaceperm4 *ptr)
{
	return xdrgen_decode_uint32_t(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_posixace4(struct xdr_stream *xdr, struct posixace4 *ptr)
{
	if (!xdrgen_decode_posixacetag4(xdr, &ptr->tag))
		return false;
	if (!xdrgen_decode_posixaceperm4(xdr, &ptr->perm))
		return false;
	if (!xdrgen_decode_utf8str_mixed(xdr, &ptr->who))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_fattr4_acl_trueform(struct xdr_stream *xdr, fattr4_acl_trueform *ptr)
{
	return xdrgen_decode_aclmodel4(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_fattr4_acl_trueform_scope(struct xdr_stream *xdr, fattr4_acl_trueform_scope *ptr)
{
	return xdrgen_decode_aclscope4(xdr, ptr);
}

static bool __maybe_unused
xdrgen_decode_fattr4_posix_default_acl(struct xdr_stream *xdr, fattr4_posix_default_acl *ptr)
{
	if (xdr_stream_decode_u32(xdr, &ptr->count) < 0)
		return false;
	for (u32 i = 0; i < ptr->count; i++)
		if (!xdrgen_decode_posixace4(xdr, &ptr->element[i]))
			return false;
	return true;
}

static bool __maybe_unused
xdrgen_decode_fattr4_posix_access_acl(struct xdr_stream *xdr, fattr4_posix_access_acl *ptr)
{
	if (xdr_stream_decode_u32(xdr, &ptr->count) < 0)
		return false;
	for (u32 i = 0; i < ptr->count; i++)
		if (!xdrgen_decode_posixace4(xdr, &ptr->element[i]))
			return false;
	return true;
}

/*
 * New for POSIX ACL extension
 */

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

static bool __maybe_unused
xdrgen_encode_uint32_t(struct xdr_stream *xdr, const uint32_t value)
{
	return xdrgen_encode_unsigned_int(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_bitmap4(struct xdr_stream *xdr, const bitmap4 value)
{
	if (xdr_stream_encode_u32(xdr, value.count) != XDR_UNIT)
		return false;
	for (u32 i = 0; i < value.count; i++)
		if (!xdrgen_encode_uint32_t(xdr, value.element[i]))
			return false;
	return true;
}

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

static bool __maybe_unused
xdrgen_encode_utf8str_cis(struct xdr_stream *xdr, const utf8str_cis value)
{
	return xdrgen_encode_utf8string(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_utf8str_cs(struct xdr_stream *xdr, const utf8str_cs value)
{
	return xdrgen_encode_utf8string(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_utf8str_mixed(struct xdr_stream *xdr, const utf8str_mixed value)
{
	return xdrgen_encode_utf8string(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_nfstime4(struct xdr_stream *xdr, const struct nfstime4 *value)
{
	if (!xdrgen_encode_int64_t(xdr, value->seconds))
		return false;
	if (!xdrgen_encode_uint32_t(xdr, value->nseconds))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_fattr4_offline(struct xdr_stream *xdr, const fattr4_offline value)
{
	return xdrgen_encode_bool(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_open_arguments4(struct xdr_stream *xdr, const struct open_arguments4 *value)
{
	if (!xdrgen_encode_bitmap4(xdr, value->oa_share_access))
		return false;
	if (!xdrgen_encode_bitmap4(xdr, value->oa_share_deny))
		return false;
	if (!xdrgen_encode_bitmap4(xdr, value->oa_share_access_want))
		return false;
	if (!xdrgen_encode_bitmap4(xdr, value->oa_open_claim))
		return false;
	if (!xdrgen_encode_bitmap4(xdr, value->oa_create_mode))
		return false;
	return true;
}

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

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

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

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

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

bool
xdrgen_encode_fattr4_open_arguments(struct xdr_stream *xdr, const fattr4_open_arguments *value)
{
	return xdrgen_encode_open_arguments4(xdr, value);
}

bool
xdrgen_encode_fattr4_time_deleg_access(struct xdr_stream *xdr, const fattr4_time_deleg_access *value)
{
	return xdrgen_encode_nfstime4(xdr, value);
}

bool
xdrgen_encode_fattr4_time_deleg_modify(struct xdr_stream *xdr, const fattr4_time_deleg_modify *value)
{
	return xdrgen_encode_nfstime4(xdr, value);
}

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

bool
xdrgen_encode_aclmodel4(struct xdr_stream *xdr, aclmodel4 value)
{
	return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
}

bool
xdrgen_encode_aclscope4(struct xdr_stream *xdr, aclscope4 value)
{
	return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
}

bool
xdrgen_encode_posixacetag4(struct xdr_stream *xdr, posixacetag4 value)
{
	return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
}

bool
xdrgen_encode_posixaceperm4(struct xdr_stream *xdr, const posixaceperm4 value)
{
	return xdrgen_encode_uint32_t(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_posixace4(struct xdr_stream *xdr, const struct posixace4 *value)
{
	if (!xdrgen_encode_posixacetag4(xdr, value->tag))
		return false;
	if (!xdrgen_encode_posixaceperm4(xdr, value->perm))
		return false;
	if (!xdrgen_encode_utf8str_mixed(xdr, value->who))
		return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_fattr4_acl_trueform(struct xdr_stream *xdr, const fattr4_acl_trueform value)
{
	return xdrgen_encode_aclmodel4(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_fattr4_acl_trueform_scope(struct xdr_stream *xdr, const fattr4_acl_trueform_scope value)
{
	return xdrgen_encode_aclscope4(xdr, value);
}

static bool __maybe_unused
xdrgen_encode_fattr4_posix_default_acl(struct xdr_stream *xdr, const fattr4_posix_default_acl value)
{
	if (xdr_stream_encode_u32(xdr, value.count) != XDR_UNIT)
		return false;
	for (u32 i = 0; i < value.count; i++)
		if (!xdrgen_encode_posixace4(xdr, &value.element[i]))
			return false;
	return true;
}

static bool __maybe_unused
xdrgen_encode_fattr4_posix_access_acl(struct xdr_stream *xdr, const fattr4_posix_access_acl value)
{
	if (xdr_stream_encode_u32(xdr, value.count) != XDR_UNIT)
		return false;
	for (u32 i = 0; i < value.count; i++)
		if (!xdrgen_encode_posixace4(xdr, &value.element[i]))
			return false;
	return true;
}