Message-ID: <f51cc300fe6be795d8d77b39a0218317bf6f9522.camel@kernel.org>
Date: Fri, 16 Aug 2024 11:45:32 -0400
From: Jeff Layton <jlayton@...nel.org>
To: Chuck Lever <chuck.lever@...cle.com>
Cc: Neil Brown <neilb@...e.de>, Olga Kornievskaia <kolga@...app.com>, Dai
 Ngo <Dai.Ngo@...cle.com>, Tom Talpey <tom@...pey.com>, Trond Myklebust
 <trondmy@...nel.org>, Anna Schumaker <anna@...nel.org>, Tom Haynes
 <loghyr@...il.com>, linux-kernel@...r.kernel.org, linux-nfs@...r.kernel.org
Subject: Re: [PATCH 1/3] nfsd: bring in support for delstid draft XDR
 encoding

On Fri, 2024-08-16 at 11:17 -0400, Chuck Lever wrote:
> On Fri, Aug 16, 2024 at 08:42:07AM -0400, Jeff Layton wrote:
> > This adds support for the "delstid" draft:
> > 
> >     https://datatracker.ietf.org/doc/draft-ietf-nfsv4-delstid/05/
> > 
> > Most of this was autogenerated using Chuck's lkxdrgen tool with
> > some
> > by-hand tweaks to work around some symbol conflicts, and to add
> > some
> > missing pieces that were needed from nfs4_1.x.
> 
> I haven't read delstid closely enough to comment on the approach
> you've taken in 3/3, but I do have some thoughts about code
> organization here. I will try to study that draft soon.
> 
> And, I'm assuming you are continuing to evolve support for the draft
> and will be growing this series. So I will hold off on careful
> inspection of 3/3 for the moment.
> 

Yes. The client pieces are already in place, and I read I get is that
the draft is all but done at this point. 3/3 is probably pretty close
to what should go in. There are really 3 parts to the delstid draft:

1/ the OPEN_XOR_DELEGATION part, which allows the server to avoid
giving out an open stateid when giving out a deleg.

2/ delegated timestamp support (which is the part I'm still looking at)

3/ FATTR4_OPEN_ARGUMENTS (which enables 1 and 2)

This patchset encompasses 1 & 3. Part 2 shouldn't have much bearing on
this set. It's really a separate feature entirely that just happens to
also depend on FATTR4_OPEN_ARGUMENTS support.

> First, I'm pleased that you found xdrgen useful for rapid
> prototyping. That's not something I had envisioned when I created
> the tool, but it's a good match, looks like.
> 

Yeah. It has some bugs that still need fixing, but it was certainly
better than having to roll all of that by hand.

> Here you add a separate set of source files for delstid XDR...  That
> approach might not be scalable for adding subsequent new features in
> general, it occurs to me.
>
> We might end up with a bunch of these little code blurbs with no
> clear understanding of how they inter-relate.  Thoughts about how to
> manage these are welcome: xdrgen could generate only header files
> and then we would #include them where needed, for example.
>
> For now, I suggest folding the new generated XDR code into the
> existing NFSv4 "open" XDR code in fs/nfsd/nfs4xdr.c, when you have
> some time for cleaning up the patches. An alternative would be to
> leave it and I can fold these together before committing.
> 
> (The long term, of course, will hopefully be generating all XDR code
> automatically, but we're a ways out from that, IMO).
> 

This is where I disagree.

The nice thing about lkxdrgen is that most of what it generates is
fairly self-contained. I think we ought to try to keep the new (mostly
autogenerated) and old code (hand-rolled) separate for now.

I'm not sure what makes the most sense for a new naming scheme, but I
really don't think we should paste all of this into nfs4xdr.c, which is
just a huge jumble of hand-rolled XDR code. 

> The generator adds __maybe_unused to some of these functions to
> avoid having to reason about which encoders/decoders are not needed.
> It assumes the C compiler will simply not generate machine code for
> unused functions.
> 
> But that clutters the source code if you plan to mix it with hand-
> written code. You might remove that decorator to identify the
> functions that are actually not used by your implementation.
> 

Yeah, I was planning to remove all of the __maybe_unused designations
once I had timestamp delegation support in place. Some of them can
certainly go away in advance of that though.

> ----
> 
> On an unrelated note, do you know of a plan to add delstid-related
> unit tests to pynfs ?
> 

No. That would be nice to have, but I'm not aware of anyone working on
it.

> 
> > Signed-off-by: Jeff Layton <jlayton@...nel.org>
> > ---
> >  fs/nfsd/Makefile      |   2 +-
> >  fs/nfsd/delstid_xdr.c | 464
> > ++++++++++++++++++++++++++++++++++++++++++++++++++
> >  fs/nfsd/delstid_xdr.h | 102 +++++++++++
> >  fs/nfsd/nfs4xdr.c     |   1 +
> >  4 files changed, 568 insertions(+), 1 deletion(-)
> > 
> > diff --git a/fs/nfsd/Makefile b/fs/nfsd/Makefile
> > index b8736a82e57c..187fa45640e6 100644
> > --- a/fs/nfsd/Makefile
> > +++ b/fs/nfsd/Makefile
> > @@ -18,7 +18,7 @@ nfsd-$(CONFIG_NFSD_V2) += nfsproc.o nfsxdr.o
> >  nfsd-$(CONFIG_NFSD_V2_ACL) += nfs2acl.o
> >  nfsd-$(CONFIG_NFSD_V3_ACL) += nfs3acl.o
> >  nfsd-$(CONFIG_NFSD_V4)	+= nfs4proc.o nfs4xdr.o nfs4state.o
> > nfs4idmap.o \
> > -			   nfs4acl.o nfs4callback.o nfs4recover.o
> > +			   nfs4acl.o nfs4callback.o nfs4recover.o
> > delstid_xdr.o
> >  nfsd-$(CONFIG_NFSD_PNFS) += nfs4layouts.o
> >  nfsd-$(CONFIG_NFSD_BLOCKLAYOUT) += blocklayout.o blocklayoutxdr.o
> >  nfsd-$(CONFIG_NFSD_SCSILAYOUT) += blocklayout.o blocklayoutxdr.o
> > diff --git a/fs/nfsd/delstid_xdr.c b/fs/nfsd/delstid_xdr.c
> > new file mode 100644
> > index 000000000000..63494d14f5d2
> > --- /dev/null
> > +++ b/fs/nfsd/delstid_xdr.c
> > @@ -0,0 +1,464 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +// Generated by lkxdrgen, with hand-edits.
> > +// XDR specification modification time: Wed Aug 14 13:35:03 2024
> > +
> > +#include "delstid_xdr.h"
> > +
> > +static inline bool
> > +xdrgen_decode_void(struct xdr_stream *xdr)
> > +{
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_bool(struct xdr_stream *xdr, bool *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = (*p != xdr_zero);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_int(struct xdr_stream *xdr, s32 *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = be32_to_cpup(p);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_unsigned_int(struct xdr_stream *xdr, u32 *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = be32_to_cpup(p);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_uint32_t(struct xdr_stream *xdr, u32 *ptr)
> > +{
> > +	return xdrgen_decode_unsigned_int(xdr, ptr);
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_long(struct xdr_stream *xdr, s32 *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = be32_to_cpup(p);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_unsigned_long(struct xdr_stream *xdr, u32 *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = be32_to_cpup(p);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_hyper(struct xdr_stream *xdr, s64 *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT * 2);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = get_unaligned_be64(p);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_int64_t(struct xdr_stream *xdr, s64 *ptr)
> > +{
> > +	return xdrgen_decode_hyper(xdr, ptr);
> > +}
> > +
> > +static inline bool
> > +xdrgen_decode_unsigned_hyper(struct xdr_stream *xdr, u64 *ptr)
> > +{
> > +	__be32 *p = xdr_inline_decode(xdr, XDR_UNIT * 2);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*ptr = get_unaligned_be64(p);
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_opaque(struct xdr_stream *xdr, opaque *ptr, u32
> > maxlen)
> > +{
> > +	__be32 *p;
> > +	u32 len;
> > +
> > +	if (unlikely(xdr_stream_decode_u32(xdr, &len) !=
> > XDR_UNIT))
> > +		return false;
> > +	if (unlikely(maxlen && len > maxlen))
> > +		return false;
> > +	if (len != 0) {
> > +		p = xdr_inline_decode(xdr, len);
> > +		if (unlikely(!p))
> > +			return false;
> > +		ptr->data = (u8 *)p;
> > +	}
> > +	ptr->len = len;
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_string(struct xdr_stream *xdr, string *ptr, u32
> > maxlen)
> > +{
> > +	__be32 *p;
> > +	u32 len;
> > +
> > +	if (unlikely(xdr_stream_decode_u32(xdr, &len) !=
> > XDR_UNIT))
> > +		return false;
> > +	if (unlikely(maxlen && len > maxlen))
> > +		return false;
> > +	if (len != 0) {
> > +		p = xdr_inline_decode(xdr, len);
> > +		if (unlikely(!p))
> > +			return false;
> > +		ptr->data = (unsigned char *)p;
> > +	}
> > +	ptr->len = len;
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_void(struct xdr_stream *xdr)
> > +{
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_bool(struct xdr_stream *xdr, bool val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*p = val ? xdr_one : xdr_zero;
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_int(struct xdr_stream *xdr, s32 val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*p = cpu_to_be32(val);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_unsigned_int(struct xdr_stream *xdr, u32 val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*p = cpu_to_be32(val);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_uint32_t(struct xdr_stream *xdr, u32 val)
> > +{
> > +	return xdrgen_encode_unsigned_int(xdr, val);
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_long(struct xdr_stream *xdr, s32 val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*p = cpu_to_be32(val);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_unsigned_long(struct xdr_stream *xdr, u32 val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	*p = cpu_to_be32(val);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_hyper(struct xdr_stream *xdr, s64 val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT * 2);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	put_unaligned_be64(val, p);
> > +	return true;
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_int64_t(struct xdr_stream *xdr, s64 val)
> > +{
> > +	return xdrgen_encode_hyper(xdr, val);
> > +}
> > +
> > +static inline bool
> > +xdrgen_encode_unsigned_hyper(struct xdr_stream *xdr, u64 val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT * 2);
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	put_unaligned_be64(val, p);
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_encode_opaque(struct xdr_stream *xdr, opaque val)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT +
> > xdr_align_size(val.len));
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	xdr_encode_opaque(p, val.data, val.len);
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_encode_string(struct xdr_stream *xdr, string val, u32
> > maxlen)
> > +{
> > +	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT +
> > xdr_align_size(val.len));
> > +
> > +	if (unlikely(!p))
> > +		return false;
> > +	xdr_encode_opaque(p, val.data, val.len);
> > +	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_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_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, enum
> > open_args_share_access4 *ptr)
> > +{
> > +	u32 val;
> > +
> > +	if (xdr_stream_decode_u32(xdr, &val) < 0)
> > +		return false;
> > +	*ptr = val;
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_open_args_share_deny4(struct xdr_stream *xdr, enum
> > open_args_share_deny4 *ptr)
> > +{
> > +	u32 val;
> > +
> > +	if (xdr_stream_decode_u32(xdr, &val) < 0)
> > +		return false;
> > +	*ptr = val;
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_open_args_share_access_want4(struct xdr_stream *xdr,
> > enum open_args_share_access_want4 *ptr)
> > +{
> > +	u32 val;
> > +
> > +	if (xdr_stream_decode_u32(xdr, &val) < 0)
> > +		return false;
> > +	*ptr = val;
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_open_args_open_claim4(struct xdr_stream *xdr, enum
> > open_args_open_claim4 *ptr)
> > +{
> > +	u32 val;
> > +
> > +	if (xdr_stream_decode_u32(xdr, &val) < 0)
> > +		return false;
> > +	*ptr = val;
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_open_args_createmode4(struct xdr_stream *xdr, enum
> > open_args_createmode4 *ptr)
> > +{
> > +	u32 val;
> > +
> > +	if (xdr_stream_decode_u32(xdr, &val) < 0)
> > +		return false;
> > +	*ptr = val;
> > +	return true;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_fattr4_open_arguments(struct xdr_stream *xdr,
> > fattr4_open_arguments *ptr)
> > +{
> > +	return xdrgen_decode_open_arguments4(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_time_deleg_access(struct xdr_stream *xdr,
> > fattr4_time_deleg_access *ptr)
> > +{
> > +	return xdrgen_decode_nfstime4(xdr, ptr);
> > +};
> > +
> > +static bool __maybe_unused
> > +xdrgen_decode_fattr4_time_deleg_modify(struct xdr_stream *xdr,
> > fattr4_time_deleg_modify *ptr)
> > +{
> > +	return xdrgen_decode_nfstime4(xdr, ptr);
> > +};
> > +
> > +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_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_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, enum
> > 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, enum
> > 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,
> > enum 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, enum
> > 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, enum
> > open_args_createmode4 value)
> > +{
> > +	return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
> > +}
> > +
> > +static bool __maybe_unused
> > +xdrgen_encode_fattr4_open_arguments(struct xdr_stream *xdr, const
> > fattr4_open_arguments *value)
> > +{
> > +	return xdrgen_encode_open_arguments4(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_time_deleg_access(struct xdr_stream *xdr,
> > const fattr4_time_deleg_access value)
> > +{
> > +	return xdrgen_encode_nfstime4(xdr, &value);
> > +};
> > +
> > +static bool __maybe_unused
> > +xdrgen_encode_fattr4_time_deleg_modify(struct xdr_stream *xdr,
> > const fattr4_time_deleg_modify value)
> > +{
> > +	return xdrgen_encode_nfstime4(xdr, &value);
> > +};
> > diff --git a/fs/nfsd/delstid_xdr.h b/fs/nfsd/delstid_xdr.h
> > new file mode 100644
> > index 000000000000..3ca8d0cc8569
> > --- /dev/null
> > +++ b/fs/nfsd/delstid_xdr.h
> > @@ -0,0 +1,102 @@
> > +/* SPDX-License-Identifier: GPL-2.0 */
> > +/* Generated by lkxdrgen, with hand edits. */
> > +/* XDR specification modification time: Wed Aug 14 13:35:03 2024
> > */
> > +
> > +#ifndef _DELSTID_H
> > +#define _DELSTID_H
> > +
> > +#include <linux/types.h>
> > +#include <linux/sunrpc/xdr.h>
> > +#include <linux/sunrpc/svc.h>
> > +
> > +typedef struct {
> > +	u32 len;
> > +	unsigned char *data;
> > +} string;
> > +
> > +typedef struct {
> > +	u32 len;
> > +	u8 *data;
> > +} opaque;
> > +
> > +typedef struct {
> > +	u32 count;
> > +	uint32_t *element;
> > +} bitmap4;
> > +
> > +typedef struct _nfstime4 {
> > +	int64_t seconds;
> > +	uint32_t nseconds;
> > +} nfstime4;
> > +
> > +typedef bool fattr4_offline;
> > +
> > +#define FATTR4_OFFLINE (83)
> > +
> > +typedef struct open_arguments4 {
> > +	bitmap4 oa_share_access;
> > +	bitmap4 oa_share_deny;
> > +	bitmap4 oa_share_access_want;
> > +	bitmap4 oa_open_claim;
> > +	bitmap4 oa_create_mode;
> > +} open_arguments4;
> > +
> > +enum open_args_share_access4 {
> > +	OPEN_ARGS_SHARE_ACCESS_READ = 1,
> > +	OPEN_ARGS_SHARE_ACCESS_WRITE = 2,
> > +	OPEN_ARGS_SHARE_ACCESS_BOTH = 3,
> > +};
> > +
> > +enum open_args_share_deny4 {
> > +	OPEN_ARGS_SHARE_DENY_NONE = 0,
> > +	OPEN_ARGS_SHARE_DENY_READ = 1,
> > +	OPEN_ARGS_SHARE_DENY_WRITE = 2,
> > +	OPEN_ARGS_SHARE_DENY_BOTH = 3,
> > +};
> > +
> > +enum open_args_share_access_want4 {
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_ANY_DELEG = 3,
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_NO_DELEG = 4,
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_CANCEL = 5,
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL
> > = 17,
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED =
> > 18,
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_DELEG_TIMESTAMPS = 20,
> > +	OPEN_ARGS_SHARE_ACCESS_WANT_OPEN_XOR_DELEGATION = 21,
> > +};
> > +
> > +enum open_args_open_claim4 {
> > +	OPEN_ARGS_OPEN_CLAIM_NULL = 0,
> > +	OPEN_ARGS_OPEN_CLAIM_PREVIOUS = 1,
> > +	OPEN_ARGS_OPEN_CLAIM_DELEGATE_CUR = 2,
> > +	OPEN_ARGS_OPEN_CLAIM_DELEGATE_PREV = 3,
> > +	OPEN_ARGS_OPEN_CLAIM_FH = 4,
> > +	OPEN_ARGS_OPEN_CLAIM_DELEG_CUR_FH = 5,
> > +	OPEN_ARGS_OPEN_CLAIM_DELEG_PREV_FH = 6,
> > +};
> > +
> > +enum open_args_createmode4 {
> > +	OPEN_ARGS_CREATEMODE_UNCHECKED4 = 0,
> > +	OPEN_ARGS_CREATE_MODE_GUARDED = 1,
> > +	OPEN_ARGS_CREATEMODE_EXCLUSIVE4 = 2,
> > +	OPEN_ARGS_CREATE_MODE_EXCLUSIVE4_1 = 3,
> > +};
> > +
> > +typedef open_arguments4 fattr4_open_arguments;
> > +
> > +#define FATTR4_OPEN_ARGUMENTS (86)
> > +
> > +#define OPEN4_SHARE_ACCESS_WANT_OPEN_XOR_DELEGATION (0x200000)
> > +
> > +#define OPEN4_RESULT_NO_OPEN_STATEID (0x00000010)
> > +
> > +typedef nfstime4 fattr4_time_deleg_access;
> > +
> > +typedef nfstime4 fattr4_time_deleg_modify;
> > +
> > +#define FATTR4_TIME_DELEG_ACCESS (84)
> > +
> > +#define FATTR4_TIME_DELEG_MODIFY (85)
> > +
> > +#define OPEN4_SHARE_ACCESS_WANT_DELEG_TIMESTAMPS (0x100000)
> > +
> > +#endif /* _DELSTID_H */
> > diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
> > index 643ca3f8ebb3..b3d2000c8a08 100644
> > --- a/fs/nfsd/nfs4xdr.c
> > +++ b/fs/nfsd/nfs4xdr.c
> > @@ -55,6 +55,7 @@
> >  #include "netns.h"
> >  #include "pnfs.h"
> >  #include "filecache.h"
> > +#include "delstid_xdr.h"
> >  
> >  #include "trace.h"
> >  
> > 
> > -- 
> > 2.46.0
> > 
> 

-- 
Jeff Layton <jlayton@...nel.org>

Powered by blists - more mailing lists