#include <linux/sunrpc/svc.h>
#include "nfs2xdr_gen.h"
static bool __maybe_unused
xdrgen_decode_nfsstat(struct xdr_stream *xdr, nfsstat *ptr)
{
__be32 raw;
u32 val;
if (xdr_stream_decode_be32(xdr, &raw) < 0)
return false;
val = be32_to_cpu(raw);
switch (val) {
case NFS_OK:
case NFSERR_PERM:
case NFSERR_NOENT:
case NFSERR_IO:
case NFSERR_NXIO:
case NFSERR_ACCES:
case NFSERR_EXIST:
case NFSERR_NODEV:
case NFSERR_NOTDIR:
case NFSERR_ISDIR:
case NFSERR_FBIG:
case NFSERR_NOSPC:
case NFSERR_ROFS:
case NFSERR_NAMETOOLONG:
case NFSERR_NOTEMPTY:
case NFSERR_DQUOT:
case NFSERR_STALE:
case NFSERR_WFLUSH:
break;
default:
return false;
}
*ptr = raw;
return true;
}
static bool __maybe_unused
xdrgen_decode_ftype(struct xdr_stream *xdr, ftype *ptr)
{
u32 val;
if (xdr_stream_decode_u32(xdr, &val) < 0)
return false;
switch (val) {
case NFNON:
case NFREG:
case NFDIR:
case NFBLK:
case NFCHR:
case NFLNK:
break;
default:
return false;
}
*ptr = val;
return true;
}
static bool __maybe_unused
xdrgen_decode_fhandle(struct xdr_stream *xdr, fhandle *ptr)
{
return xdr_stream_decode_opaque_fixed(xdr, ptr, NFS_FHSIZE) == 0;
}
static bool __maybe_unused
xdrgen_decode_nfscookie(struct xdr_stream *xdr, nfscookie *ptr)
{
return xdr_stream_decode_opaque_fixed(xdr, ptr, NFS_COOKIESIZE) == 0;
}
static bool __maybe_unused
xdrgen_decode_timeval(struct xdr_stream *xdr, struct timeval *ptr)
{
if (!xdrgen_decode_unsigned_int(xdr, &ptr->seconds))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->useconds))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_fattr(struct xdr_stream *xdr, struct fattr *ptr)
{
if (!xdrgen_decode_ftype(xdr, &ptr->type))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->mode))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->nlink))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->uid))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->gid))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->size))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->blocksize))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->rdev))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->blocks))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->fsid))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->fileid))
return false;
if (!xdrgen_decode_timeval(xdr, &ptr->atime))
return false;
if (!xdrgen_decode_timeval(xdr, &ptr->mtime))
return false;
if (!xdrgen_decode_timeval(xdr, &ptr->ctime))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_sattr(struct xdr_stream *xdr, struct sattr *ptr)
{
if (!xdrgen_decode_unsigned_int(xdr, &ptr->mode))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->uid))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->gid))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->size))
return false;
if (!xdrgen_decode_timeval(xdr, &ptr->atime))
return false;
if (!xdrgen_decode_timeval(xdr, &ptr->mtime))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_filename(struct xdr_stream *xdr, filename *ptr)
{
return xdrgen_decode_string(xdr, ptr, NFS_MAXNAMLEN);
}
static bool __maybe_unused
xdrgen_decode_path(struct xdr_stream *xdr, path *ptr)
{
return xdrgen_decode_string(xdr, ptr, NFS_MAXPATHLEN);
}
static bool __maybe_unused
xdrgen_decode_attrstat(struct xdr_stream *xdr, struct attrstat *ptr)
{
if (!xdrgen_decode_nfsstat(xdr, &ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_decode_fattr(xdr, &ptr->u.attributes))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_decode_diropargs(struct xdr_stream *xdr, struct diropargs *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->dir))
return false;
if (!xdrgen_decode_filename(xdr, &ptr->name))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_diropok(struct xdr_stream *xdr, struct diropok *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->file))
return false;
if (!xdrgen_decode_fattr(xdr, &ptr->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_diropres(struct xdr_stream *xdr, struct diropres *ptr)
{
if (!xdrgen_decode_nfsstat(xdr, &ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_decode_diropok(xdr, &ptr->u.diropok))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_decode_sattrargs(struct xdr_stream *xdr, struct sattrargs *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->file))
return false;
if (!xdrgen_decode_sattr(xdr, &ptr->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_readlinkres(struct xdr_stream *xdr, struct readlinkres *ptr)
{
if (!xdrgen_decode_nfsstat(xdr, &ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_decode_path(xdr, &ptr->u.data))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_decode_readargs(struct xdr_stream *xdr, struct readargs *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->file))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->offset))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->count))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->totalcount))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_readresok(struct xdr_stream *xdr, struct readresok *ptr)
{
if (!xdrgen_decode_fattr(xdr, &ptr->attributes))
return false;
if (!xdrgen_decode_opaque(xdr, &ptr->data, NFS_MAXDATA))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_readres(struct xdr_stream *xdr, struct readres *ptr)
{
if (!xdrgen_decode_nfsstat(xdr, &ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_decode_readresok(xdr, &ptr->u.readresok))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_decode_writeargs(struct xdr_stream *xdr, struct writeargs *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->file))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->beginoffset))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->offset))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->totalcount))
return false;
if (!svcxdr_decode_opaque_payload(xdr, &ptr->data, NFS_MAXDATA))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_createargs(struct xdr_stream *xdr, struct createargs *ptr)
{
if (!xdrgen_decode_diropargs(xdr, &ptr->where))
return false;
if (!xdrgen_decode_sattr(xdr, &ptr->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_renameargs(struct xdr_stream *xdr, struct renameargs *ptr)
{
if (!xdrgen_decode_diropargs(xdr, &ptr->from))
return false;
if (!xdrgen_decode_diropargs(xdr, &ptr->to))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_linkargs(struct xdr_stream *xdr, struct linkargs *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->from))
return false;
if (!xdrgen_decode_diropargs(xdr, &ptr->to))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_symlinkargs(struct xdr_stream *xdr, struct symlinkargs *ptr)
{
if (!xdrgen_decode_diropargs(xdr, &ptr->from))
return false;
if (!svcxdr_decode_opaque_payload(xdr, &ptr->to, NFS_MAXPATHLEN))
return false;
if (!xdrgen_decode_sattr(xdr, &ptr->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_readdirargs(struct xdr_stream *xdr, struct readdirargs *ptr)
{
if (!xdrgen_decode_fhandle(xdr, &ptr->dir))
return false;
if (!xdrgen_decode_nfscookie(xdr, &ptr->cookie))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->count))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_entry(struct xdr_stream *xdr, struct entry *ptr)
{
bool opted;
if (!xdrgen_decode_bool(xdr, &opted))
return false;
if (!opted)
return true;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->fileid))
return false;
if (!xdrgen_decode_filename(xdr, &ptr->name))
return false;
if (!xdrgen_decode_nfscookie(xdr, &ptr->cookie))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_readdirok(struct xdr_stream *xdr, struct readdirok *ptr)
{
return false;
}
static bool __maybe_unused
xdrgen_decode_readdirres(struct xdr_stream *xdr, struct readdirres *ptr)
{
if (!xdrgen_decode_nfsstat(xdr, &ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_decode_readdirok(xdr, &ptr->u.readdirok))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_decode_info(struct xdr_stream *xdr, struct info *ptr)
{
if (!xdrgen_decode_unsigned_int(xdr, &ptr->tsize))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->bsize))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->blocks))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->bfree))
return false;
if (!xdrgen_decode_unsigned_int(xdr, &ptr->bavail))
return false;
return true;
}
static bool __maybe_unused
xdrgen_decode_statfsres(struct xdr_stream *xdr, struct statfsres *ptr)
{
if (!xdrgen_decode_nfsstat(xdr, &ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_decode_info(xdr, &ptr->u.info))
return false;
break;
default:
break;
}
return true;
}
bool nfs_svc_decode_fhandle(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
fhandle *argp = rqstp->rq_argp;
return xdrgen_decode_fhandle(xdr, argp);
}
bool nfs_svc_decode_sattrargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct sattrargs *argp = rqstp->rq_argp;
return xdrgen_decode_sattrargs(xdr, argp);
}
bool nfs_svc_decode_diropargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct diropargs *argp = rqstp->rq_argp;
return xdrgen_decode_diropargs(xdr, argp);
}
bool nfs_svc_decode_readargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct readargs *argp = rqstp->rq_argp;
return xdrgen_decode_readargs(xdr, argp);
}
bool nfs_svc_decode_writeargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct writeargs *argp = rqstp->rq_argp;
return xdrgen_decode_writeargs(xdr, argp);
}
bool nfs_svc_decode_createargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct createargs *argp = rqstp->rq_argp;
return xdrgen_decode_createargs(xdr, argp);
}
bool nfs_svc_decode_renameargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct renameargs *argp = rqstp->rq_argp;
return xdrgen_decode_renameargs(xdr, argp);
}
bool nfs_svc_decode_linkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct linkargs *argp = rqstp->rq_argp;
return xdrgen_decode_linkargs(xdr, argp);
}
bool nfs_svc_decode_symlinkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct symlinkargs *argp = rqstp->rq_argp;
return xdrgen_decode_symlinkargs(xdr, argp);
}
bool nfs_svc_decode_readdirargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct readdirargs *argp = rqstp->rq_argp;
return xdrgen_decode_readdirargs(xdr, argp);
}
static bool __maybe_unused
xdrgen_encode_nfsstat(struct xdr_stream *xdr, nfsstat value)
{
return xdr_stream_encode_be32(xdr, value) == XDR_UNIT;
}
static bool __maybe_unused
xdrgen_encode_ftype(struct xdr_stream *xdr, ftype value)
{
return xdr_stream_encode_u32(xdr, value) == XDR_UNIT;
}
static bool __maybe_unused
xdrgen_encode_fhandle(struct xdr_stream *xdr, const fhandle value)
{
return xdr_stream_encode_opaque_fixed(xdr, value, NFS_FHSIZE) >= 0;
}
static bool __maybe_unused
xdrgen_encode_nfscookie(struct xdr_stream *xdr, const nfscookie value)
{
return xdr_stream_encode_opaque_fixed(xdr, value, NFS_COOKIESIZE) >= 0;
}
static bool __maybe_unused
xdrgen_encode_timeval(struct xdr_stream *xdr, const struct timeval *value)
{
if (!xdrgen_encode_unsigned_int(xdr, value->seconds))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->useconds))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_fattr(struct xdr_stream *xdr, const struct fattr *value)
{
if (!xdrgen_encode_ftype(xdr, value->type))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->mode))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->nlink))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->uid))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->gid))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->size))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->blocksize))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->rdev))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->blocks))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->fsid))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->fileid))
return false;
if (!xdrgen_encode_timeval(xdr, &value->atime))
return false;
if (!xdrgen_encode_timeval(xdr, &value->mtime))
return false;
if (!xdrgen_encode_timeval(xdr, &value->ctime))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_sattr(struct xdr_stream *xdr, const struct sattr *value)
{
if (!xdrgen_encode_unsigned_int(xdr, value->mode))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->uid))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->gid))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->size))
return false;
if (!xdrgen_encode_timeval(xdr, &value->atime))
return false;
if (!xdrgen_encode_timeval(xdr, &value->mtime))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_filename(struct xdr_stream *xdr, const filename value)
{
return xdr_stream_encode_opaque(xdr, value.data, value.len) >= 0;
}
static bool __maybe_unused
xdrgen_encode_path(struct xdr_stream *xdr, const path value)
{
return xdr_stream_encode_opaque(xdr, value.data, value.len) >= 0;
}
static bool __maybe_unused
xdrgen_encode_attrstat(struct xdr_stream *xdr, const struct attrstat *ptr)
{
if (!xdrgen_encode_nfsstat(xdr, ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_encode_fattr(xdr, &ptr->u.attributes))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_encode_diropargs(struct xdr_stream *xdr, const struct diropargs *value)
{
if (!xdrgen_encode_fhandle(xdr, value->dir))
return false;
if (!xdrgen_encode_filename(xdr, value->name))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_diropok(struct xdr_stream *xdr, const struct diropok *value)
{
if (!xdrgen_encode_fhandle(xdr, value->file))
return false;
if (!xdrgen_encode_fattr(xdr, &value->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_diropres(struct xdr_stream *xdr, const struct diropres *ptr)
{
if (!xdrgen_encode_nfsstat(xdr, ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_encode_diropok(xdr, &ptr->u.diropok))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_encode_sattrargs(struct xdr_stream *xdr, const struct sattrargs *value)
{
if (!xdrgen_encode_fhandle(xdr, value->file))
return false;
if (!xdrgen_encode_sattr(xdr, &value->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_readlinkres(struct xdr_stream *xdr, const struct readlinkres *ptr)
{
if (!xdrgen_encode_nfsstat(xdr, ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (ptr->u.data.len > NFS_MAXPATHLEN)
return false;
if (!svcxdr_encode_opaque_payload(xdr, ptr->u.data.len))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_encode_readargs(struct xdr_stream *xdr, const struct readargs *value)
{
if (!xdrgen_encode_fhandle(xdr, value->file))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->offset))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->count))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->totalcount))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_readresok(struct xdr_stream *xdr, const struct readresok *value)
{
if (!xdrgen_encode_fattr(xdr, &value->attributes))
return false;
if (value->data.len > NFS_MAXDATA)
return false;
if (!svcxdr_encode_opaque_payload(xdr, value->data.len))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_readres(struct xdr_stream *xdr, const struct readres *ptr)
{
if (!xdrgen_encode_nfsstat(xdr, ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_encode_readresok(xdr, &ptr->u.readresok))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_encode_writeargs(struct xdr_stream *xdr, const struct writeargs *value)
{
if (!xdrgen_encode_fhandle(xdr, value->file))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->beginoffset))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->offset))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->totalcount))
return false;
if (value->data.len > NFS_MAXDATA)
return false;
if (!svcxdr_encode_opaque_payload(xdr, value->data.len))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_createargs(struct xdr_stream *xdr, const struct createargs *value)
{
if (!xdrgen_encode_diropargs(xdr, &value->where))
return false;
if (!xdrgen_encode_sattr(xdr, &value->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_renameargs(struct xdr_stream *xdr, const struct renameargs *value)
{
if (!xdrgen_encode_diropargs(xdr, &value->from))
return false;
if (!xdrgen_encode_diropargs(xdr, &value->to))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_linkargs(struct xdr_stream *xdr, const struct linkargs *value)
{
if (!xdrgen_encode_fhandle(xdr, value->from))
return false;
if (!xdrgen_encode_diropargs(xdr, &value->to))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_symlinkargs(struct xdr_stream *xdr, const struct symlinkargs *value)
{
if (!xdrgen_encode_diropargs(xdr, &value->from))
return false;
if (value->to.len > NFS_MAXPATHLEN)
return false;
if (!svcxdr_encode_opaque_payload(xdr, value->to.len))
return false;
if (!xdrgen_encode_sattr(xdr, &value->attributes))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_readdirargs(struct xdr_stream *xdr, const struct readdirargs *value)
{
if (!xdrgen_encode_fhandle(xdr, value->dir))
return false;
if (!xdrgen_encode_nfscookie(xdr, value->cookie))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->count))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_entry(struct xdr_stream *xdr, const struct entry *value)
{
if (!xdrgen_encode_bool(xdr, value != NULL))
return false;
if (!value)
return true;
if (!xdrgen_encode_unsigned_int(xdr, value->fileid))
return false;
if (!xdrgen_encode_filename(xdr, value->name))
return false;
if (!xdrgen_encode_nfscookie(xdr, value->cookie))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_readdirok(struct xdr_stream *xdr, const struct readdirok *value)
{
{
struct xdrgen_aggregate_cursor cursor = {
.xdr = xdr,
.member_id = NFS2_READDIROK_ENTRIES,
.ctx = xdr->xdrgen_ctx,
};
bool ok = true;
if (!nfs2_readdirok_encode_begin(&cursor))
return false;
for (cursor.index = 0; ; cursor.index++) {
struct entry element = {};
if (!nfs2_readdirok_encode(&cursor, &element))
break;
if (!xdrgen_encode_entry(xdr, &element)) {
ok = false;
break;
}
}
if (ok && !xdrgen_encode_entry(xdr, NULL))
ok = false;
if (!nfs2_readdirok_encode_end(&cursor, ok) || !ok)
return false;
}
if (!xdrgen_encode_bool(xdr, value->eof))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_readdirres(struct xdr_stream *xdr, const struct readdirres *ptr)
{
if (!xdrgen_encode_nfsstat(xdr, ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_encode_readdirok(xdr, &ptr->u.readdirok))
return false;
break;
default:
break;
}
return true;
}
static bool __maybe_unused
xdrgen_encode_info(struct xdr_stream *xdr, const struct info *value)
{
if (!xdrgen_encode_unsigned_int(xdr, value->tsize))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->bsize))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->blocks))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->bfree))
return false;
if (!xdrgen_encode_unsigned_int(xdr, value->bavail))
return false;
return true;
}
static bool __maybe_unused
xdrgen_encode_statfsres(struct xdr_stream *xdr, const struct statfsres *ptr)
{
if (!xdrgen_encode_nfsstat(xdr, ptr->status))
return false;
switch (ptr->status) {
case __constant_cpu_to_be32(NFS_OK):
if (!xdrgen_encode_info(xdr, &ptr->u.info))
return false;
break;
default:
break;
}
return true;
}
bool nfs_svc_encode_attrstat(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct attrstat *resp = rqstp->rq_resp;
return xdrgen_encode_attrstat(xdr, resp);
}
bool nfs_svc_encode_diropres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct diropres *resp = rqstp->rq_resp;
return xdrgen_encode_diropres(xdr, resp);
}
bool nfs_svc_encode_readlinkres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct readlinkres *resp = rqstp->rq_resp;
return xdrgen_encode_readlinkres(xdr, resp);
}
bool nfs_svc_encode_readres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct readres *resp = rqstp->rq_resp;
return xdrgen_encode_readres(xdr, resp);
}
bool nfs_svc_encode_nfsstat(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
nfsstat *resp = rqstp->rq_resp;
return xdrgen_encode_nfsstat(xdr, *resp);
}
bool nfs_svc_encode_readdirres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct readdirres *resp = rqstp->rq_resp;
return xdrgen_encode_readdirres(xdr, resp);
}
bool nfs_svc_encode_statfsres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
{
struct statfsres *resp = rqstp->rq_resp;
return xdrgen_encode_statfsres(xdr, resp);
}