1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * linux/fs/nfs/callback_xdr.c
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 2004 Trond Myklebust
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * NFSv4 callback encode/decode procedures
81da177e4SLinus Torvalds */
91da177e4SLinus Torvalds #include <linux/kernel.h>
101da177e4SLinus Torvalds #include <linux/sunrpc/svc.h>
111da177e4SLinus Torvalds #include <linux/nfs4.h>
121da177e4SLinus Torvalds #include <linux/nfs_fs.h>
139a3ba432STrond Myklebust #include <linux/ratelimit.h>
149a3ba432STrond Myklebust #include <linux/printk.h>
155a0e3ad6STejun Heo #include <linux/slab.h>
16c36fca52SAndy Adamson #include <linux/sunrpc/bc_xprt.h>
174ce79717STrond Myklebust #include "nfs4_fs.h"
181da177e4SLinus Torvalds #include "callback.h"
19c36fca52SAndy Adamson #include "internal.h"
2076e697baSTrond Myklebust #include "nfs4session.h"
212bb50aabSChuck Lever #include "nfs4trace.h"
221da177e4SLinus Torvalds
231da177e4SLinus Torvalds #define CB_OP_TAGLEN_MAXSZ (512)
2445724e8aSKinglong Mee #define CB_OP_HDR_RES_MAXSZ (2 * 4) // opcode, status
2545724e8aSKinglong Mee #define CB_OP_GETATTR_BITMAP_MAXSZ (4 * 4) // bitmap length, 3 bitmaps
261da177e4SLinus Torvalds #define CB_OP_GETATTR_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ + \
271da177e4SLinus Torvalds CB_OP_GETATTR_BITMAP_MAXSZ + \
2845724e8aSKinglong Mee /* change, size, ctime, mtime */\
2945724e8aSKinglong Mee (2 + 2 + 3 + 3) * 4)
301da177e4SLinus Torvalds #define CB_OP_RECALL_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
311da177e4SLinus Torvalds
324aece6a1SBenny Halevy #if defined(CONFIG_NFS_V4_1)
33f2a62561SFred Isaman #define CB_OP_LAYOUTRECALL_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
341be5683bSMarc Eshel #define CB_OP_DEVICENOTIFY_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
354aece6a1SBenny Halevy #define CB_OP_SEQUENCE_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ + \
3645724e8aSKinglong Mee NFS4_MAX_SESSIONID_LEN + \
3745724e8aSKinglong Mee (1 + 3) * 4) // seqid, 3 slotids
3831f09607SAlexandros Batsakis #define CB_OP_RECALLANY_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
39b9efa1b2SAndy Adamson #define CB_OP_RECALLSLOT_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
40db783688SJeff Layton #define CB_OP_NOTIFY_LOCK_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
414aece6a1SBenny Halevy #endif /* CONFIG_NFS_V4_1 */
425178a125SOlga Kornievskaia #ifdef CONFIG_NFS_V4_2
435178a125SOlga Kornievskaia #define CB_OP_OFFLOAD_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
445178a125SOlga Kornievskaia #endif /* CONFIG_NFS_V4_2 */
454aece6a1SBenny Halevy
461da177e4SLinus Torvalds #define NFSDBG_FACILITY NFSDBG_CALLBACK
471da177e4SLinus Torvalds
4831d2b435SAndy Adamson /* Internal error code */
4931d2b435SAndy Adamson #define NFS4ERR_RESOURCE_HDR 11050
5031d2b435SAndy Adamson
511da177e4SLinus Torvalds struct callback_op {
52f4dac4adSChristoph Hellwig __be32 (*process_op)(void *, void *, struct cb_process_state *);
53f4dac4adSChristoph Hellwig __be32 (*decode_args)(struct svc_rqst *, struct xdr_stream *, void *);
54f4dac4adSChristoph Hellwig __be32 (*encode_res)(struct svc_rqst *, struct xdr_stream *,
55f4dac4adSChristoph Hellwig const void *);
561da177e4SLinus Torvalds long res_maxsize;
571da177e4SLinus Torvalds };
581da177e4SLinus Torvalds
591da177e4SLinus Torvalds static struct callback_op callback_ops[];
601da177e4SLinus Torvalds
nfs4_callback_null(struct svc_rqst * rqstp)61a6beb732SChristoph Hellwig static __be32 nfs4_callback_null(struct svc_rqst *rqstp)
621da177e4SLinus Torvalds {
631da177e4SLinus Torvalds return htonl(NFS4_OK);
641da177e4SLinus Torvalds }
651da177e4SLinus Torvalds
66c35a810cSChuck Lever /*
67c35a810cSChuck Lever * svc_process_common() looks for an XDR encoder to know when
68c35a810cSChuck Lever * not to drop a Reply.
69c35a810cSChuck Lever */
nfs4_encode_void(struct svc_rqst * rqstp,struct xdr_stream * xdr)70130e2054SChuck Lever static bool nfs4_encode_void(struct svc_rqst *rqstp, struct xdr_stream *xdr)
711da177e4SLinus Torvalds {
72130e2054SChuck Lever return true;
731da177e4SLinus Torvalds }
741da177e4SLinus Torvalds
decode_string(struct xdr_stream * xdr,unsigned int * len,const char ** str,size_t maxlen)75c065eeeaSTrond Myklebust static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len,
76c065eeeaSTrond Myklebust const char **str, size_t maxlen)
771da177e4SLinus Torvalds {
78c065eeeaSTrond Myklebust ssize_t err;
791da177e4SLinus Torvalds
80c065eeeaSTrond Myklebust err = xdr_stream_decode_opaque_inline(xdr, (void **)str, maxlen);
81c065eeeaSTrond Myklebust if (err < 0)
82c065eeeaSTrond Myklebust return cpu_to_be32(NFS4ERR_RESOURCE);
83c065eeeaSTrond Myklebust *len = err;
841da177e4SLinus Torvalds return 0;
851da177e4SLinus Torvalds }
861da177e4SLinus Torvalds
decode_fh(struct xdr_stream * xdr,struct nfs_fh * fh)87e6f684f6SAl Viro static __be32 decode_fh(struct xdr_stream *xdr, struct nfs_fh *fh)
881da177e4SLinus Torvalds {
895704fdebSAl Viro __be32 *p;
901da177e4SLinus Torvalds
91eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
921da177e4SLinus Torvalds if (unlikely(p == NULL))
931da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
941da177e4SLinus Torvalds fh->size = ntohl(*p);
951da177e4SLinus Torvalds if (fh->size > NFS4_FHSIZE)
961da177e4SLinus Torvalds return htonl(NFS4ERR_BADHANDLE);
97eb72f484SChuck Lever p = xdr_inline_decode(xdr, fh->size);
981da177e4SLinus Torvalds if (unlikely(p == NULL))
991da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
1001da177e4SLinus Torvalds memcpy(&fh->data[0], p, fh->size);
1011da177e4SLinus Torvalds memset(&fh->data[fh->size], 0, sizeof(fh->data) - fh->size);
1021da177e4SLinus Torvalds return 0;
1031da177e4SLinus Torvalds }
1041da177e4SLinus Torvalds
decode_bitmap(struct xdr_stream * xdr,uint32_t * bitmap)105e6f684f6SAl Viro static __be32 decode_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
1061da177e4SLinus Torvalds {
1075704fdebSAl Viro __be32 *p;
1081da177e4SLinus Torvalds unsigned int attrlen;
1091da177e4SLinus Torvalds
110eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
1111da177e4SLinus Torvalds if (unlikely(p == NULL))
1121da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
1131da177e4SLinus Torvalds attrlen = ntohl(*p);
114eb72f484SChuck Lever p = xdr_inline_decode(xdr, attrlen << 2);
1151da177e4SLinus Torvalds if (unlikely(p == NULL))
1161da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
1171da177e4SLinus Torvalds if (likely(attrlen > 0))
1181da177e4SLinus Torvalds bitmap[0] = ntohl(*p++);
1191da177e4SLinus Torvalds if (attrlen > 1)
1201da177e4SLinus Torvalds bitmap[1] = ntohl(*p);
1211da177e4SLinus Torvalds return 0;
1221da177e4SLinus Torvalds }
1231da177e4SLinus Torvalds
decode_stateid(struct xdr_stream * xdr,nfs4_stateid * stateid)124e6f684f6SAl Viro static __be32 decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
1251da177e4SLinus Torvalds {
1265704fdebSAl Viro __be32 *p;
1271da177e4SLinus Torvalds
128eb72f484SChuck Lever p = xdr_inline_decode(xdr, NFS4_STATEID_SIZE);
1291da177e4SLinus Torvalds if (unlikely(p == NULL))
1301da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
13193b717fdSTrond Myklebust memcpy(stateid->data, p, NFS4_STATEID_SIZE);
1321da177e4SLinus Torvalds return 0;
1331da177e4SLinus Torvalds }
1341da177e4SLinus Torvalds
decode_delegation_stateid(struct xdr_stream * xdr,nfs4_stateid * stateid)13593b717fdSTrond Myklebust static __be32 decode_delegation_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
13693b717fdSTrond Myklebust {
13793b717fdSTrond Myklebust stateid->type = NFS4_DELEGATION_STATEID_TYPE;
13893b717fdSTrond Myklebust return decode_stateid(xdr, stateid);
13993b717fdSTrond Myklebust }
14093b717fdSTrond Myklebust
decode_compound_hdr_arg(struct xdr_stream * xdr,struct cb_compound_hdr_arg * hdr)141e6f684f6SAl Viro static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound_hdr_arg *hdr)
1421da177e4SLinus Torvalds {
1435704fdebSAl Viro __be32 *p;
144e6f684f6SAl Viro __be32 status;
1451da177e4SLinus Torvalds
146c065eeeaSTrond Myklebust status = decode_string(xdr, &hdr->taglen, &hdr->tag, CB_OP_TAGLEN_MAXSZ);
1471da177e4SLinus Torvalds if (unlikely(status != 0))
1481da177e4SLinus Torvalds return status;
149eb72f484SChuck Lever p = xdr_inline_decode(xdr, 12);
1501da177e4SLinus Torvalds if (unlikely(p == NULL))
1511da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
152b8f2ef84SBenny Halevy hdr->minorversion = ntohl(*p++);
153459de2edSBryan Schumaker /* Check for minor version support */
154459de2edSBryan Schumaker if (hdr->minorversion <= NFS4_MAX_MINOR_VERSION) {
15542c2c424SSteve Dickson hdr->cb_ident = ntohl(*p++); /* ignored by v4.1 and v4.2 */
15648a9e2d2SBenny Halevy } else {
1579a3ba432STrond Myklebust pr_warn_ratelimited("NFS: %s: NFSv4 server callback with "
158b8f2ef84SBenny Halevy "illegal minor version %u!\n",
159b8f2ef84SBenny Halevy __func__, hdr->minorversion);
1601da177e4SLinus Torvalds return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
1611da177e4SLinus Torvalds }
1621da177e4SLinus Torvalds hdr->nops = ntohl(*p);
1631da177e4SLinus Torvalds return 0;
1641da177e4SLinus Torvalds }
1651da177e4SLinus Torvalds
decode_op_hdr(struct xdr_stream * xdr,unsigned int * op)166e6f684f6SAl Viro static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)
1671da177e4SLinus Torvalds {
1685704fdebSAl Viro __be32 *p;
169eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
1701da177e4SLinus Torvalds if (unlikely(p == NULL))
17131d2b435SAndy Adamson return htonl(NFS4ERR_RESOURCE_HDR);
1721da177e4SLinus Torvalds *op = ntohl(*p);
1731da177e4SLinus Torvalds return 0;
1741da177e4SLinus Torvalds }
1751da177e4SLinus Torvalds
decode_getattr_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)176f4dac4adSChristoph Hellwig static __be32 decode_getattr_args(struct svc_rqst *rqstp,
177f4dac4adSChristoph Hellwig struct xdr_stream *xdr, void *argp)
1781da177e4SLinus Torvalds {
179f4dac4adSChristoph Hellwig struct cb_getattrargs *args = argp;
180e6f684f6SAl Viro __be32 status;
1811da177e4SLinus Torvalds
1821da177e4SLinus Torvalds status = decode_fh(xdr, &args->fh);
1831da177e4SLinus Torvalds if (unlikely(status != 0))
1841da177e4SLinus Torvalds return status;
18556938bb7SAnna Schumaker return decode_bitmap(xdr, args->bitmap);
1861da177e4SLinus Torvalds }
1871da177e4SLinus Torvalds
decode_recall_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)188f4dac4adSChristoph Hellwig static __be32 decode_recall_args(struct svc_rqst *rqstp,
189f4dac4adSChristoph Hellwig struct xdr_stream *xdr, void *argp)
1901da177e4SLinus Torvalds {
191f4dac4adSChristoph Hellwig struct cb_recallargs *args = argp;
1925704fdebSAl Viro __be32 *p;
193e6f684f6SAl Viro __be32 status;
1941da177e4SLinus Torvalds
19593b717fdSTrond Myklebust status = decode_delegation_stateid(xdr, &args->stateid);
1961da177e4SLinus Torvalds if (unlikely(status != 0))
1973873bc50SAlexey Dobriyan return status;
198eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
199135a4ea0SAnna Schumaker if (unlikely(p == NULL))
200135a4ea0SAnna Schumaker return htonl(NFS4ERR_RESOURCE);
201135a4ea0SAnna Schumaker args->truncate = ntohl(*p);
202135a4ea0SAnna Schumaker return decode_fh(xdr, &args->fh);
2031da177e4SLinus Torvalds }
2041da177e4SLinus Torvalds
2054aece6a1SBenny Halevy #if defined(CONFIG_NFS_V4_1)
decode_layout_stateid(struct xdr_stream * xdr,nfs4_stateid * stateid)20693b717fdSTrond Myklebust static __be32 decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
20793b717fdSTrond Myklebust {
20893b717fdSTrond Myklebust stateid->type = NFS4_LAYOUT_STATEID_TYPE;
20993b717fdSTrond Myklebust return decode_stateid(xdr, stateid);
21093b717fdSTrond Myklebust }
2114aece6a1SBenny Halevy
decode_layoutrecall_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)212f2a62561SFred Isaman static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
213f4dac4adSChristoph Hellwig struct xdr_stream *xdr, void *argp)
214f2a62561SFred Isaman {
215f4dac4adSChristoph Hellwig struct cb_layoutrecallargs *args = argp;
216f2a62561SFred Isaman __be32 *p;
217f2a62561SFred Isaman __be32 status = 0;
218f2a62561SFred Isaman uint32_t iomode;
219f2a62561SFred Isaman
220eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4 * sizeof(uint32_t));
221c79d56d2SAnna Schumaker if (unlikely(p == NULL))
222c79d56d2SAnna Schumaker return htonl(NFS4ERR_BADXDR);
223f2a62561SFred Isaman
224f2a62561SFred Isaman args->cbl_layout_type = ntohl(*p++);
225f2a62561SFred Isaman /* Depite the spec's xdr, iomode really belongs in the FILE switch,
22625985edcSLucas De Marchi * as it is unusable and ignored with the other types.
227f2a62561SFred Isaman */
228f2a62561SFred Isaman iomode = ntohl(*p++);
229f2a62561SFred Isaman args->cbl_layoutchanged = ntohl(*p++);
230f2a62561SFred Isaman args->cbl_recall_type = ntohl(*p++);
231f2a62561SFred Isaman
232f2a62561SFred Isaman if (args->cbl_recall_type == RETURN_FILE) {
233f2a62561SFred Isaman args->cbl_range.iomode = iomode;
234f2a62561SFred Isaman status = decode_fh(xdr, &args->cbl_fh);
235f2a62561SFred Isaman if (unlikely(status != 0))
236c79d56d2SAnna Schumaker return status;
237f2a62561SFred Isaman
238eb72f484SChuck Lever p = xdr_inline_decode(xdr, 2 * sizeof(uint64_t));
239c79d56d2SAnna Schumaker if (unlikely(p == NULL))
240c79d56d2SAnna Schumaker return htonl(NFS4ERR_BADXDR);
241f2a62561SFred Isaman p = xdr_decode_hyper(p, &args->cbl_range.offset);
242f2a62561SFred Isaman p = xdr_decode_hyper(p, &args->cbl_range.length);
243c79d56d2SAnna Schumaker return decode_layout_stateid(xdr, &args->cbl_stateid);
244f2a62561SFred Isaman } else if (args->cbl_recall_type == RETURN_FSID) {
245eb72f484SChuck Lever p = xdr_inline_decode(xdr, 2 * sizeof(uint64_t));
246c79d56d2SAnna Schumaker if (unlikely(p == NULL))
247c79d56d2SAnna Schumaker return htonl(NFS4ERR_BADXDR);
248f2a62561SFred Isaman p = xdr_decode_hyper(p, &args->cbl_fsid.major);
249f2a62561SFred Isaman p = xdr_decode_hyper(p, &args->cbl_fsid.minor);
250c79d56d2SAnna Schumaker } else if (args->cbl_recall_type != RETURN_ALL)
251c79d56d2SAnna Schumaker return htonl(NFS4ERR_BADXDR);
252c79d56d2SAnna Schumaker return 0;
253f2a62561SFred Isaman }
254f2a62561SFred Isaman
2551be5683bSMarc Eshel static
decode_devicenotify_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)2561be5683bSMarc Eshel __be32 decode_devicenotify_args(struct svc_rqst *rqstp,
2571be5683bSMarc Eshel struct xdr_stream *xdr,
258f4dac4adSChristoph Hellwig void *argp)
2591be5683bSMarc Eshel {
260f4dac4adSChristoph Hellwig struct cb_devicenotifyargs *args = argp;
261b05bf5c6STrond Myklebust uint32_t tmp, n, i;
2621be5683bSMarc Eshel __be32 *p;
2631be5683bSMarc Eshel __be32 status = 0;
2641be5683bSMarc Eshel
2651be5683bSMarc Eshel /* Num of device notifications */
266eb72f484SChuck Lever p = xdr_inline_decode(xdr, sizeof(uint32_t));
2671be5683bSMarc Eshel if (unlikely(p == NULL)) {
2681be5683bSMarc Eshel status = htonl(NFS4ERR_BADXDR);
2691be5683bSMarc Eshel goto out;
2701be5683bSMarc Eshel }
2711be5683bSMarc Eshel n = ntohl(*p++);
272b05bf5c6STrond Myklebust if (n == 0)
2731be5683bSMarc Eshel goto out;
2741be5683bSMarc Eshel
275a4f743a6STrond Myklebust args->devs = kmalloc_array(n, sizeof(*args->devs), GFP_KERNEL);
2761be5683bSMarc Eshel if (!args->devs) {
2771be5683bSMarc Eshel status = htonl(NFS4ERR_DELAY);
2781be5683bSMarc Eshel goto out;
2791be5683bSMarc Eshel }
2801be5683bSMarc Eshel
2811be5683bSMarc Eshel /* Decode each dev notification */
2821be5683bSMarc Eshel for (i = 0; i < n; i++) {
2831be5683bSMarc Eshel struct cb_devicenotifyitem *dev = &args->devs[i];
2841be5683bSMarc Eshel
285eb72f484SChuck Lever p = xdr_inline_decode(xdr, (4 * sizeof(uint32_t)) +
286eb72f484SChuck Lever NFS4_DEVICEID4_SIZE);
2871be5683bSMarc Eshel if (unlikely(p == NULL)) {
2881be5683bSMarc Eshel status = htonl(NFS4ERR_BADXDR);
2891be5683bSMarc Eshel goto err;
2901be5683bSMarc Eshel }
2911be5683bSMarc Eshel
2921be5683bSMarc Eshel tmp = ntohl(*p++); /* bitmap size */
2931be5683bSMarc Eshel if (tmp != 1) {
2941be5683bSMarc Eshel status = htonl(NFS4ERR_INVAL);
2951be5683bSMarc Eshel goto err;
2961be5683bSMarc Eshel }
2971be5683bSMarc Eshel dev->cbd_notify_type = ntohl(*p++);
2981be5683bSMarc Eshel if (dev->cbd_notify_type != NOTIFY_DEVICEID4_CHANGE &&
2991be5683bSMarc Eshel dev->cbd_notify_type != NOTIFY_DEVICEID4_DELETE) {
3001be5683bSMarc Eshel status = htonl(NFS4ERR_INVAL);
3011be5683bSMarc Eshel goto err;
3021be5683bSMarc Eshel }
3031be5683bSMarc Eshel
3041be5683bSMarc Eshel tmp = ntohl(*p++); /* opaque size */
3051be5683bSMarc Eshel if (((dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE) &&
3061be5683bSMarc Eshel (tmp != NFS4_DEVICEID4_SIZE + 8)) ||
3071be5683bSMarc Eshel ((dev->cbd_notify_type == NOTIFY_DEVICEID4_DELETE) &&
3081be5683bSMarc Eshel (tmp != NFS4_DEVICEID4_SIZE + 4))) {
3091be5683bSMarc Eshel status = htonl(NFS4ERR_INVAL);
3101be5683bSMarc Eshel goto err;
3111be5683bSMarc Eshel }
3121be5683bSMarc Eshel dev->cbd_layout_type = ntohl(*p++);
3131be5683bSMarc Eshel memcpy(dev->cbd_dev_id.data, p, NFS4_DEVICEID4_SIZE);
3141be5683bSMarc Eshel p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
3151be5683bSMarc Eshel
3161be5683bSMarc Eshel if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
317eb72f484SChuck Lever p = xdr_inline_decode(xdr, sizeof(uint32_t));
3181be5683bSMarc Eshel if (unlikely(p == NULL)) {
3191be5683bSMarc Eshel status = htonl(NFS4ERR_BADXDR);
3201be5683bSMarc Eshel goto err;
3211be5683bSMarc Eshel }
3221be5683bSMarc Eshel dev->cbd_immediate = ntohl(*p++);
3231be5683bSMarc Eshel } else {
3241be5683bSMarc Eshel dev->cbd_immediate = 0;
3251be5683bSMarc Eshel }
3261be5683bSMarc Eshel
3271be5683bSMarc Eshel dprintk("%s: type %d layout 0x%x immediate %d\n",
3281be5683bSMarc Eshel __func__, dev->cbd_notify_type, dev->cbd_layout_type,
3291be5683bSMarc Eshel dev->cbd_immediate);
3301be5683bSMarc Eshel }
331b05bf5c6STrond Myklebust args->ndevs = n;
332b05bf5c6STrond Myklebust dprintk("%s: ndevs %d\n", __func__, args->ndevs);
333b05bf5c6STrond Myklebust return 0;
334b05bf5c6STrond Myklebust err:
335b05bf5c6STrond Myklebust kfree(args->devs);
3361be5683bSMarc Eshel out:
337b05bf5c6STrond Myklebust args->devs = NULL;
338b05bf5c6STrond Myklebust args->ndevs = 0;
3391be5683bSMarc Eshel dprintk("%s: status %d ndevs %d\n",
3401be5683bSMarc Eshel __func__, ntohl(status), args->ndevs);
3411be5683bSMarc Eshel return status;
3421be5683bSMarc Eshel }
3431be5683bSMarc Eshel
decode_sessionid(struct xdr_stream * xdr,struct nfs4_sessionid * sid)3449733f0d9SAndy Adamson static __be32 decode_sessionid(struct xdr_stream *xdr,
3454aece6a1SBenny Halevy struct nfs4_sessionid *sid)
3464aece6a1SBenny Halevy {
3479733f0d9SAndy Adamson __be32 *p;
3484aece6a1SBenny Halevy
349eb72f484SChuck Lever p = xdr_inline_decode(xdr, NFS4_MAX_SESSIONID_LEN);
3504aece6a1SBenny Halevy if (unlikely(p == NULL))
351a419aef8SJoe Perches return htonl(NFS4ERR_RESOURCE);
3524aece6a1SBenny Halevy
353590184a6SKinglong Mee memcpy(sid->data, p, NFS4_MAX_SESSIONID_LEN);
3544aece6a1SBenny Halevy return 0;
3554aece6a1SBenny Halevy }
3564aece6a1SBenny Halevy
decode_rc_list(struct xdr_stream * xdr,struct referring_call_list * rc_list)3579733f0d9SAndy Adamson static __be32 decode_rc_list(struct xdr_stream *xdr,
3584aece6a1SBenny Halevy struct referring_call_list *rc_list)
3594aece6a1SBenny Halevy {
3609733f0d9SAndy Adamson __be32 *p;
3614aece6a1SBenny Halevy int i;
3629733f0d9SAndy Adamson __be32 status;
3634aece6a1SBenny Halevy
3644aece6a1SBenny Halevy status = decode_sessionid(xdr, &rc_list->rcl_sessionid);
3654aece6a1SBenny Halevy if (status)
3664aece6a1SBenny Halevy goto out;
3674aece6a1SBenny Halevy
3684aece6a1SBenny Halevy status = htonl(NFS4ERR_RESOURCE);
369eb72f484SChuck Lever p = xdr_inline_decode(xdr, sizeof(uint32_t));
3704aece6a1SBenny Halevy if (unlikely(p == NULL))
3714aece6a1SBenny Halevy goto out;
3724aece6a1SBenny Halevy
3734aece6a1SBenny Halevy rc_list->rcl_nrefcalls = ntohl(*p++);
3744aece6a1SBenny Halevy if (rc_list->rcl_nrefcalls) {
375eb72f484SChuck Lever p = xdr_inline_decode(xdr,
3764aece6a1SBenny Halevy rc_list->rcl_nrefcalls * 2 * sizeof(uint32_t));
3774aece6a1SBenny Halevy if (unlikely(p == NULL))
3784aece6a1SBenny Halevy goto out;
379a4f743a6STrond Myklebust rc_list->rcl_refcalls = kmalloc_array(rc_list->rcl_nrefcalls,
3804aece6a1SBenny Halevy sizeof(*rc_list->rcl_refcalls),
3814aece6a1SBenny Halevy GFP_KERNEL);
3824aece6a1SBenny Halevy if (unlikely(rc_list->rcl_refcalls == NULL))
3834aece6a1SBenny Halevy goto out;
3844aece6a1SBenny Halevy for (i = 0; i < rc_list->rcl_nrefcalls; i++) {
3854aece6a1SBenny Halevy rc_list->rcl_refcalls[i].rc_sequenceid = ntohl(*p++);
3864aece6a1SBenny Halevy rc_list->rcl_refcalls[i].rc_slotid = ntohl(*p++);
3874aece6a1SBenny Halevy }
3884aece6a1SBenny Halevy }
3894aece6a1SBenny Halevy status = 0;
3904aece6a1SBenny Halevy
3914aece6a1SBenny Halevy out:
3924aece6a1SBenny Halevy return status;
3934aece6a1SBenny Halevy }
3944aece6a1SBenny Halevy
decode_cb_sequence_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)3959733f0d9SAndy Adamson static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
3964aece6a1SBenny Halevy struct xdr_stream *xdr,
397f4dac4adSChristoph Hellwig void *argp)
3984aece6a1SBenny Halevy {
399f4dac4adSChristoph Hellwig struct cb_sequenceargs *args = argp;
4009733f0d9SAndy Adamson __be32 *p;
4014aece6a1SBenny Halevy int i;
4029733f0d9SAndy Adamson __be32 status;
4034aece6a1SBenny Halevy
4044aece6a1SBenny Halevy status = decode_sessionid(xdr, &args->csa_sessionid);
4054aece6a1SBenny Halevy if (status)
4061796549aSAnna Schumaker return status;
4074aece6a1SBenny Halevy
408eb72f484SChuck Lever p = xdr_inline_decode(xdr, 5 * sizeof(uint32_t));
4094aece6a1SBenny Halevy if (unlikely(p == NULL))
4101796549aSAnna Schumaker return htonl(NFS4ERR_RESOURCE);
4114aece6a1SBenny Halevy
41265fc64e5SRicardo Labiaga args->csa_addr = svc_addr(rqstp);
4134aece6a1SBenny Halevy args->csa_sequenceid = ntohl(*p++);
4144aece6a1SBenny Halevy args->csa_slotid = ntohl(*p++);
4154aece6a1SBenny Halevy args->csa_highestslotid = ntohl(*p++);
4164aece6a1SBenny Halevy args->csa_cachethis = ntohl(*p++);
4174aece6a1SBenny Halevy args->csa_nrclists = ntohl(*p++);
4184aece6a1SBenny Halevy args->csa_rclists = NULL;
4194aece6a1SBenny Halevy if (args->csa_nrclists) {
4200439f31cSDan Carpenter args->csa_rclists = kmalloc_array(args->csa_nrclists,
4214aece6a1SBenny Halevy sizeof(*args->csa_rclists),
4224aece6a1SBenny Halevy GFP_KERNEL);
4234aece6a1SBenny Halevy if (unlikely(args->csa_rclists == NULL))
4241796549aSAnna Schumaker return htonl(NFS4ERR_RESOURCE);
4254aece6a1SBenny Halevy
4264aece6a1SBenny Halevy for (i = 0; i < args->csa_nrclists; i++) {
4274aece6a1SBenny Halevy status = decode_rc_list(xdr, &args->csa_rclists[i]);
428d8ba1f97STrond Myklebust if (status) {
429d8ba1f97STrond Myklebust args->csa_nrclists = i;
4304aece6a1SBenny Halevy goto out_free;
4314aece6a1SBenny Halevy }
4324aece6a1SBenny Halevy }
433d8ba1f97STrond Myklebust }
4341796549aSAnna Schumaker return 0;
4354aece6a1SBenny Halevy
4364aece6a1SBenny Halevy out_free:
4374aece6a1SBenny Halevy for (i = 0; i < args->csa_nrclists; i++)
4384aece6a1SBenny Halevy kfree(args->csa_rclists[i].rcl_refcalls);
4394aece6a1SBenny Halevy kfree(args->csa_rclists);
4401796549aSAnna Schumaker return status;
4414aece6a1SBenny Halevy }
4424aece6a1SBenny Halevy
decode_recallany_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)4439733f0d9SAndy Adamson static __be32 decode_recallany_args(struct svc_rqst *rqstp,
44431f09607SAlexandros Batsakis struct xdr_stream *xdr,
445f4dac4adSChristoph Hellwig void *argp)
44631f09607SAlexandros Batsakis {
447f4dac4adSChristoph Hellwig struct cb_recallanyargs *args = argp;
448d743c3c9SPeng Tao uint32_t bitmap[2];
449d743c3c9SPeng Tao __be32 *p, status;
45031f09607SAlexandros Batsakis
451eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
45231f09607SAlexandros Batsakis if (unlikely(p == NULL))
45331f09607SAlexandros Batsakis return htonl(NFS4ERR_BADXDR);
45431f09607SAlexandros Batsakis args->craa_objs_to_keep = ntohl(*p++);
455d743c3c9SPeng Tao status = decode_bitmap(xdr, bitmap);
456d743c3c9SPeng Tao if (unlikely(status))
457d743c3c9SPeng Tao return status;
458d743c3c9SPeng Tao args->craa_type_mask = bitmap[0];
45931f09607SAlexandros Batsakis
46031f09607SAlexandros Batsakis return 0;
46131f09607SAlexandros Batsakis }
46231f09607SAlexandros Batsakis
decode_recallslot_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)4639733f0d9SAndy Adamson static __be32 decode_recallslot_args(struct svc_rqst *rqstp,
464b9efa1b2SAndy Adamson struct xdr_stream *xdr,
465f4dac4adSChristoph Hellwig void *argp)
466b9efa1b2SAndy Adamson {
467f4dac4adSChristoph Hellwig struct cb_recallslotargs *args = argp;
468b9efa1b2SAndy Adamson __be32 *p;
469b9efa1b2SAndy Adamson
470eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
471b9efa1b2SAndy Adamson if (unlikely(p == NULL))
472b9efa1b2SAndy Adamson return htonl(NFS4ERR_BADXDR);
473d5fb4ce3STrond Myklebust args->crsa_target_highest_slotid = ntohl(*p++);
474b9efa1b2SAndy Adamson return 0;
475b9efa1b2SAndy Adamson }
476b9efa1b2SAndy Adamson
decode_lockowner(struct xdr_stream * xdr,struct cb_notify_lock_args * args)477db783688SJeff Layton static __be32 decode_lockowner(struct xdr_stream *xdr, struct cb_notify_lock_args *args)
478db783688SJeff Layton {
479db783688SJeff Layton __be32 *p;
480db783688SJeff Layton unsigned int len;
481db783688SJeff Layton
482eb72f484SChuck Lever p = xdr_inline_decode(xdr, 12);
483db783688SJeff Layton if (unlikely(p == NULL))
484db783688SJeff Layton return htonl(NFS4ERR_BADXDR);
485db783688SJeff Layton
486db783688SJeff Layton p = xdr_decode_hyper(p, &args->cbnl_owner.clientid);
487db783688SJeff Layton len = be32_to_cpu(*p);
488db783688SJeff Layton
489eb72f484SChuck Lever p = xdr_inline_decode(xdr, len);
490db783688SJeff Layton if (unlikely(p == NULL))
491db783688SJeff Layton return htonl(NFS4ERR_BADXDR);
492db783688SJeff Layton
493db783688SJeff Layton /* Only try to decode if the length is right */
494db783688SJeff Layton if (len == 20) {
495db783688SJeff Layton p += 2; /* skip "lock id:" */
496db783688SJeff Layton args->cbnl_owner.s_dev = be32_to_cpu(*p++);
497db783688SJeff Layton xdr_decode_hyper(p, &args->cbnl_owner.id);
498db783688SJeff Layton args->cbnl_valid = true;
499db783688SJeff Layton } else {
500db783688SJeff Layton args->cbnl_owner.s_dev = 0;
501db783688SJeff Layton args->cbnl_owner.id = 0;
502db783688SJeff Layton args->cbnl_valid = false;
503db783688SJeff Layton }
504db783688SJeff Layton return 0;
505db783688SJeff Layton }
506db783688SJeff Layton
decode_notify_lock_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * argp)507f4dac4adSChristoph Hellwig static __be32 decode_notify_lock_args(struct svc_rqst *rqstp,
508f4dac4adSChristoph Hellwig struct xdr_stream *xdr, void *argp)
509db783688SJeff Layton {
510f4dac4adSChristoph Hellwig struct cb_notify_lock_args *args = argp;
511db783688SJeff Layton __be32 status;
512db783688SJeff Layton
513db783688SJeff Layton status = decode_fh(xdr, &args->cbnl_fh);
514db783688SJeff Layton if (unlikely(status != 0))
515db783688SJeff Layton return status;
516535ece2bSAnna Schumaker return decode_lockowner(xdr, args);
517db783688SJeff Layton }
518db783688SJeff Layton
5194aece6a1SBenny Halevy #endif /* CONFIG_NFS_V4_1 */
5205178a125SOlga Kornievskaia #ifdef CONFIG_NFS_V4_2
decode_write_response(struct xdr_stream * xdr,struct cb_offloadargs * args)5215178a125SOlga Kornievskaia static __be32 decode_write_response(struct xdr_stream *xdr,
5225178a125SOlga Kornievskaia struct cb_offloadargs *args)
5235178a125SOlga Kornievskaia {
5245178a125SOlga Kornievskaia __be32 *p;
5254aece6a1SBenny Halevy
5265178a125SOlga Kornievskaia /* skip the always zero field */
527eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
5285178a125SOlga Kornievskaia if (unlikely(!p))
5295178a125SOlga Kornievskaia goto out;
5305178a125SOlga Kornievskaia p++;
5315178a125SOlga Kornievskaia
5325178a125SOlga Kornievskaia /* decode count, stable_how, verifier */
5335178a125SOlga Kornievskaia p = xdr_inline_decode(xdr, 8 + 4);
5345178a125SOlga Kornievskaia if (unlikely(!p))
5355178a125SOlga Kornievskaia goto out;
5365178a125SOlga Kornievskaia p = xdr_decode_hyper(p, &args->wr_count);
5375178a125SOlga Kornievskaia args->wr_writeverf.committed = be32_to_cpup(p);
5385178a125SOlga Kornievskaia p = xdr_inline_decode(xdr, NFS4_VERIFIER_SIZE);
5395178a125SOlga Kornievskaia if (likely(p)) {
5405178a125SOlga Kornievskaia memcpy(&args->wr_writeverf.verifier.data[0], p,
5415178a125SOlga Kornievskaia NFS4_VERIFIER_SIZE);
5425178a125SOlga Kornievskaia return 0;
5435178a125SOlga Kornievskaia }
5445178a125SOlga Kornievskaia out:
5455178a125SOlga Kornievskaia return htonl(NFS4ERR_RESOURCE);
5465178a125SOlga Kornievskaia }
5475178a125SOlga Kornievskaia
decode_offload_args(struct svc_rqst * rqstp,struct xdr_stream * xdr,void * data)5485178a125SOlga Kornievskaia static __be32 decode_offload_args(struct svc_rqst *rqstp,
5495178a125SOlga Kornievskaia struct xdr_stream *xdr,
5505178a125SOlga Kornievskaia void *data)
5515178a125SOlga Kornievskaia {
5525178a125SOlga Kornievskaia struct cb_offloadargs *args = data;
5535178a125SOlga Kornievskaia __be32 *p;
5545178a125SOlga Kornievskaia __be32 status;
5555178a125SOlga Kornievskaia
5565178a125SOlga Kornievskaia /* decode fh */
5575178a125SOlga Kornievskaia status = decode_fh(xdr, &args->coa_fh);
5585178a125SOlga Kornievskaia if (unlikely(status != 0))
5595178a125SOlga Kornievskaia return status;
5605178a125SOlga Kornievskaia
5615178a125SOlga Kornievskaia /* decode stateid */
5625178a125SOlga Kornievskaia status = decode_stateid(xdr, &args->coa_stateid);
5635178a125SOlga Kornievskaia if (unlikely(status != 0))
5645178a125SOlga Kornievskaia return status;
5655178a125SOlga Kornievskaia
5665178a125SOlga Kornievskaia /* decode status */
567eb72f484SChuck Lever p = xdr_inline_decode(xdr, 4);
5685178a125SOlga Kornievskaia if (unlikely(!p))
5695178a125SOlga Kornievskaia goto out;
5705178a125SOlga Kornievskaia args->error = ntohl(*p++);
5715178a125SOlga Kornievskaia if (!args->error) {
5725178a125SOlga Kornievskaia status = decode_write_response(xdr, args);
5735178a125SOlga Kornievskaia if (unlikely(status != 0))
5745178a125SOlga Kornievskaia return status;
5755178a125SOlga Kornievskaia } else {
5765178a125SOlga Kornievskaia p = xdr_inline_decode(xdr, 8);
5775178a125SOlga Kornievskaia if (unlikely(!p))
5785178a125SOlga Kornievskaia goto out;
5795178a125SOlga Kornievskaia p = xdr_decode_hyper(p, &args->wr_count);
5805178a125SOlga Kornievskaia }
5815178a125SOlga Kornievskaia return 0;
5825178a125SOlga Kornievskaia out:
5835178a125SOlga Kornievskaia return htonl(NFS4ERR_RESOURCE);
5845178a125SOlga Kornievskaia }
5855178a125SOlga Kornievskaia #endif /* CONFIG_NFS_V4_2 */
encode_string(struct xdr_stream * xdr,unsigned int len,const char * str)586e6f684f6SAl Viro static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
5871da177e4SLinus Torvalds {
588ab6e9aafSTrond Myklebust if (unlikely(xdr_stream_encode_opaque(xdr, str, len) < 0))
589ab6e9aafSTrond Myklebust return cpu_to_be32(NFS4ERR_RESOURCE);
5901da177e4SLinus Torvalds return 0;
5911da177e4SLinus Torvalds }
5921da177e4SLinus Torvalds
encode_attr_bitmap(struct xdr_stream * xdr,const uint32_t * bitmap,size_t sz)5938b064946STrond Myklebust static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, size_t sz)
5941da177e4SLinus Torvalds {
5958b064946STrond Myklebust if (xdr_stream_encode_uint32_array(xdr, bitmap, sz) < 0)
5968b064946STrond Myklebust return cpu_to_be32(NFS4ERR_RESOURCE);
5971da177e4SLinus Torvalds return 0;
5981da177e4SLinus Torvalds }
5991da177e4SLinus Torvalds
encode_attr_change(struct xdr_stream * xdr,const uint32_t * bitmap,uint64_t change)600e6f684f6SAl Viro static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change)
6011da177e4SLinus Torvalds {
6025704fdebSAl Viro __be32 *p;
6031da177e4SLinus Torvalds
6041da177e4SLinus Torvalds if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
6051da177e4SLinus Torvalds return 0;
6061da177e4SLinus Torvalds p = xdr_reserve_space(xdr, 8);
60790dc7d27SHarvey Harrison if (unlikely(!p))
6081da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
6091da177e4SLinus Torvalds p = xdr_encode_hyper(p, change);
6101da177e4SLinus Torvalds return 0;
6111da177e4SLinus Torvalds }
6121da177e4SLinus Torvalds
encode_attr_size(struct xdr_stream * xdr,const uint32_t * bitmap,uint64_t size)613e6f684f6SAl Viro static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size)
6141da177e4SLinus Torvalds {
6155704fdebSAl Viro __be32 *p;
6161da177e4SLinus Torvalds
6171da177e4SLinus Torvalds if (!(bitmap[0] & FATTR4_WORD0_SIZE))
6181da177e4SLinus Torvalds return 0;
6191da177e4SLinus Torvalds p = xdr_reserve_space(xdr, 8);
62090dc7d27SHarvey Harrison if (unlikely(!p))
6211da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
6221da177e4SLinus Torvalds p = xdr_encode_hyper(p, size);
6231da177e4SLinus Torvalds return 0;
6241da177e4SLinus Torvalds }
6251da177e4SLinus Torvalds
encode_attr_time(struct xdr_stream * xdr,const struct timespec64 * time)6267d34ff51STrond Myklebust static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec64 *time)
6271da177e4SLinus Torvalds {
6285704fdebSAl Viro __be32 *p;
6291da177e4SLinus Torvalds
6301da177e4SLinus Torvalds p = xdr_reserve_space(xdr, 12);
63190dc7d27SHarvey Harrison if (unlikely(!p))
6321da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
6331da177e4SLinus Torvalds p = xdr_encode_hyper(p, time->tv_sec);
6341da177e4SLinus Torvalds *p = htonl(time->tv_nsec);
6351da177e4SLinus Torvalds return 0;
6361da177e4SLinus Torvalds }
6371da177e4SLinus Torvalds
encode_attr_ctime(struct xdr_stream * xdr,const uint32_t * bitmap,const struct timespec64 * time)6387d34ff51STrond Myklebust static __be32 encode_attr_ctime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec64 *time)
6391da177e4SLinus Torvalds {
6401da177e4SLinus Torvalds if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))
6411da177e4SLinus Torvalds return 0;
6421da177e4SLinus Torvalds return encode_attr_time(xdr,time);
6431da177e4SLinus Torvalds }
6441da177e4SLinus Torvalds
encode_attr_mtime(struct xdr_stream * xdr,const uint32_t * bitmap,const struct timespec64 * time)6457d34ff51STrond Myklebust static __be32 encode_attr_mtime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec64 *time)
6461da177e4SLinus Torvalds {
6471da177e4SLinus Torvalds if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))
6481da177e4SLinus Torvalds return 0;
6491da177e4SLinus Torvalds return encode_attr_time(xdr,time);
6501da177e4SLinus Torvalds }
6511da177e4SLinus Torvalds
encode_compound_hdr_res(struct xdr_stream * xdr,struct cb_compound_hdr_res * hdr)652e6f684f6SAl Viro static __be32 encode_compound_hdr_res(struct xdr_stream *xdr, struct cb_compound_hdr_res *hdr)
6531da177e4SLinus Torvalds {
654e6f684f6SAl Viro __be32 status;
6551da177e4SLinus Torvalds
6561da177e4SLinus Torvalds hdr->status = xdr_reserve_space(xdr, 4);
6571da177e4SLinus Torvalds if (unlikely(hdr->status == NULL))
6581da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
6591da177e4SLinus Torvalds status = encode_string(xdr, hdr->taglen, hdr->tag);
6601da177e4SLinus Torvalds if (unlikely(status != 0))
6611da177e4SLinus Torvalds return status;
6621da177e4SLinus Torvalds hdr->nops = xdr_reserve_space(xdr, 4);
6631da177e4SLinus Torvalds if (unlikely(hdr->nops == NULL))
6641da177e4SLinus Torvalds return htonl(NFS4ERR_RESOURCE);
6651da177e4SLinus Torvalds return 0;
6661da177e4SLinus Torvalds }
6671da177e4SLinus Torvalds
encode_op_hdr(struct xdr_stream * xdr,uint32_t op,__be32 res)668e6f684f6SAl Viro static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
6691da177e4SLinus Torvalds {
6705704fdebSAl Viro __be32 *p;
6711da177e4SLinus Torvalds
6721da177e4SLinus Torvalds p = xdr_reserve_space(xdr, 8);
6731da177e4SLinus Torvalds if (unlikely(p == NULL))
67431d2b435SAndy Adamson return htonl(NFS4ERR_RESOURCE_HDR);
6751da177e4SLinus Torvalds *p++ = htonl(op);
6761da177e4SLinus Torvalds *p = res;
6771da177e4SLinus Torvalds return 0;
6781da177e4SLinus Torvalds }
6791da177e4SLinus Torvalds
encode_getattr_res(struct svc_rqst * rqstp,struct xdr_stream * xdr,const void * resp)680f4dac4adSChristoph Hellwig static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr,
681f4dac4adSChristoph Hellwig const void *resp)
6821da177e4SLinus Torvalds {
683f4dac4adSChristoph Hellwig const struct cb_getattrres *res = resp;
6845704fdebSAl Viro __be32 *savep = NULL;
685e6f684f6SAl Viro __be32 status = res->status;
6861da177e4SLinus Torvalds
6871da177e4SLinus Torvalds if (unlikely(status != 0))
6881da177e4SLinus Torvalds goto out;
6898b064946STrond Myklebust status = encode_attr_bitmap(xdr, res->bitmap, ARRAY_SIZE(res->bitmap));
6901da177e4SLinus Torvalds if (unlikely(status != 0))
6911da177e4SLinus Torvalds goto out;
6928b064946STrond Myklebust status = cpu_to_be32(NFS4ERR_RESOURCE);
6938b064946STrond Myklebust savep = xdr_reserve_space(xdr, sizeof(*savep));
6948b064946STrond Myklebust if (unlikely(!savep))
6958b064946STrond Myklebust goto out;
6961da177e4SLinus Torvalds status = encode_attr_change(xdr, res->bitmap, res->change_attr);
6971da177e4SLinus Torvalds if (unlikely(status != 0))
6981da177e4SLinus Torvalds goto out;
6991da177e4SLinus Torvalds status = encode_attr_size(xdr, res->bitmap, res->size);
7001da177e4SLinus Torvalds if (unlikely(status != 0))
7011da177e4SLinus Torvalds goto out;
7021da177e4SLinus Torvalds status = encode_attr_ctime(xdr, res->bitmap, &res->ctime);
7031da177e4SLinus Torvalds if (unlikely(status != 0))
7041da177e4SLinus Torvalds goto out;
7051da177e4SLinus Torvalds status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
7061da177e4SLinus Torvalds *savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1)));
7071da177e4SLinus Torvalds out:
7081da177e4SLinus Torvalds return status;
7091da177e4SLinus Torvalds }
7101da177e4SLinus Torvalds
71134bc47c9SBenny Halevy #if defined(CONFIG_NFS_V4_1)
71234bc47c9SBenny Halevy
encode_sessionid(struct xdr_stream * xdr,const struct nfs4_sessionid * sid)7139733f0d9SAndy Adamson static __be32 encode_sessionid(struct xdr_stream *xdr,
7144aece6a1SBenny Halevy const struct nfs4_sessionid *sid)
7154aece6a1SBenny Halevy {
7169733f0d9SAndy Adamson __be32 *p;
7174aece6a1SBenny Halevy
718590184a6SKinglong Mee p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN);
7194aece6a1SBenny Halevy if (unlikely(p == NULL))
7204aece6a1SBenny Halevy return htonl(NFS4ERR_RESOURCE);
7214aece6a1SBenny Halevy
722590184a6SKinglong Mee memcpy(p, sid, NFS4_MAX_SESSIONID_LEN);
7234aece6a1SBenny Halevy return 0;
7244aece6a1SBenny Halevy }
7254aece6a1SBenny Halevy
encode_cb_sequence_res(struct svc_rqst * rqstp,struct xdr_stream * xdr,const void * resp)7269733f0d9SAndy Adamson static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
7274aece6a1SBenny Halevy struct xdr_stream *xdr,
728f4dac4adSChristoph Hellwig const void *resp)
7294aece6a1SBenny Halevy {
730f4dac4adSChristoph Hellwig const struct cb_sequenceres *res = resp;
7319733f0d9SAndy Adamson __be32 *p;
732e216c8c7SDan Carpenter __be32 status = res->csr_status;
7334aece6a1SBenny Halevy
7344aece6a1SBenny Halevy if (unlikely(status != 0))
7353d0bfaa6SAnna Schumaker return status;
7364aece6a1SBenny Halevy
737e0a63c0bSKinglong Mee status = encode_sessionid(xdr, &res->csr_sessionid);
738e0a63c0bSKinglong Mee if (status)
7393d0bfaa6SAnna Schumaker return status;
7404aece6a1SBenny Halevy
7414aece6a1SBenny Halevy p = xdr_reserve_space(xdr, 4 * sizeof(uint32_t));
7424aece6a1SBenny Halevy if (unlikely(p == NULL))
7434aece6a1SBenny Halevy return htonl(NFS4ERR_RESOURCE);
7444aece6a1SBenny Halevy
7454aece6a1SBenny Halevy *p++ = htonl(res->csr_sequenceid);
7464aece6a1SBenny Halevy *p++ = htonl(res->csr_slotid);
7474aece6a1SBenny Halevy *p++ = htonl(res->csr_highestslotid);
7484aece6a1SBenny Halevy *p++ = htonl(res->csr_target_highestslotid);
7493d0bfaa6SAnna Schumaker return 0;
7504aece6a1SBenny Halevy }
7514aece6a1SBenny Halevy
75234bc47c9SBenny Halevy static __be32
preprocess_nfs41_op(int nop,unsigned int op_nr,struct callback_op ** op)75334bc47c9SBenny Halevy preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
75434bc47c9SBenny Halevy {
755281fe15dSBenny Halevy if (op_nr == OP_CB_SEQUENCE) {
756281fe15dSBenny Halevy if (nop != 0)
757281fe15dSBenny Halevy return htonl(NFS4ERR_SEQUENCE_POS);
758281fe15dSBenny Halevy } else {
759281fe15dSBenny Halevy if (nop == 0)
760281fe15dSBenny Halevy return htonl(NFS4ERR_OP_NOT_IN_SESSION);
761281fe15dSBenny Halevy }
762281fe15dSBenny Halevy
76334bc47c9SBenny Halevy switch (op_nr) {
76434bc47c9SBenny Halevy case OP_CB_GETATTR:
76534bc47c9SBenny Halevy case OP_CB_RECALL:
7664aece6a1SBenny Halevy case OP_CB_SEQUENCE:
76731f09607SAlexandros Batsakis case OP_CB_RECALL_ANY:
768b9efa1b2SAndy Adamson case OP_CB_RECALL_SLOT:
769f2a62561SFred Isaman case OP_CB_LAYOUTRECALL:
7701be5683bSMarc Eshel case OP_CB_NOTIFY_DEVICEID:
771db783688SJeff Layton case OP_CB_NOTIFY_LOCK:
77234bc47c9SBenny Halevy *op = &callback_ops[op_nr];
77334bc47c9SBenny Halevy break;
77434bc47c9SBenny Halevy
77534bc47c9SBenny Halevy case OP_CB_NOTIFY:
77634bc47c9SBenny Halevy case OP_CB_PUSH_DELEG:
77734bc47c9SBenny Halevy case OP_CB_RECALLABLE_OBJ_AVAIL:
77834bc47c9SBenny Halevy case OP_CB_WANTS_CANCELLED:
77934bc47c9SBenny Halevy return htonl(NFS4ERR_NOTSUPP);
78034bc47c9SBenny Halevy
78134bc47c9SBenny Halevy default:
78234bc47c9SBenny Halevy return htonl(NFS4ERR_OP_ILLEGAL);
78334bc47c9SBenny Halevy }
78434bc47c9SBenny Halevy
78534bc47c9SBenny Halevy return htonl(NFS_OK);
78634bc47c9SBenny Halevy }
78734bc47c9SBenny Halevy
nfs4_callback_free_slot(struct nfs4_session * session,struct nfs4_slot * slot)788810d82e6STrond Myklebust static void nfs4_callback_free_slot(struct nfs4_session *session,
789810d82e6STrond Myklebust struct nfs4_slot *slot)
79042acd021SAndy Adamson {
79142acd021SAndy Adamson struct nfs4_slot_table *tbl = &session->bc_slot_table;
79242acd021SAndy Adamson
79342acd021SAndy Adamson spin_lock(&tbl->slot_tbl_lock);
79442acd021SAndy Adamson /*
79542acd021SAndy Adamson * Let the state manager know callback processing done.
79642acd021SAndy Adamson * A single slot, so highest used slotid is either 0 or -1
79742acd021SAndy Adamson */
798810d82e6STrond Myklebust nfs4_free_slot(tbl, slot);
79942acd021SAndy Adamson spin_unlock(&tbl->slot_tbl_lock);
80042acd021SAndy Adamson }
80142acd021SAndy Adamson
nfs4_cb_free_slot(struct cb_process_state * cps)80255a67399STrond Myklebust static void nfs4_cb_free_slot(struct cb_process_state *cps)
80342acd021SAndy Adamson {
804810d82e6STrond Myklebust if (cps->slot) {
805810d82e6STrond Myklebust nfs4_callback_free_slot(cps->clp->cl_session, cps->slot);
806810d82e6STrond Myklebust cps->slot = NULL;
807810d82e6STrond Myklebust }
80842acd021SAndy Adamson }
80942acd021SAndy Adamson
81034bc47c9SBenny Halevy #else /* CONFIG_NFS_V4_1 */
81134bc47c9SBenny Halevy
81234bc47c9SBenny Halevy static __be32
preprocess_nfs41_op(int nop,unsigned int op_nr,struct callback_op ** op)81334bc47c9SBenny Halevy preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
81434bc47c9SBenny Halevy {
81534bc47c9SBenny Halevy return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
81634bc47c9SBenny Halevy }
81734bc47c9SBenny Halevy
nfs4_cb_free_slot(struct cb_process_state * cps)81855a67399STrond Myklebust static void nfs4_cb_free_slot(struct cb_process_state *cps)
81942acd021SAndy Adamson {
82042acd021SAndy Adamson }
82134bc47c9SBenny Halevy #endif /* CONFIG_NFS_V4_1 */
82234bc47c9SBenny Halevy
8236b140b85SBryan Schumaker #ifdef CONFIG_NFS_V4_2
8246b140b85SBryan Schumaker static __be32
preprocess_nfs42_op(int nop,unsigned int op_nr,struct callback_op ** op)8256b140b85SBryan Schumaker preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
8266b140b85SBryan Schumaker {
8276b140b85SBryan Schumaker __be32 status = preprocess_nfs41_op(nop, op_nr, op);
8286b140b85SBryan Schumaker if (status != htonl(NFS4ERR_OP_ILLEGAL))
8296b140b85SBryan Schumaker return status;
8306b140b85SBryan Schumaker
8315178a125SOlga Kornievskaia if (op_nr == OP_CB_OFFLOAD) {
8325178a125SOlga Kornievskaia *op = &callback_ops[op_nr];
8335178a125SOlga Kornievskaia return htonl(NFS_OK);
8345178a125SOlga Kornievskaia } else
8356b140b85SBryan Schumaker return htonl(NFS4ERR_NOTSUPP);
8366b140b85SBryan Schumaker return htonl(NFS4ERR_OP_ILLEGAL);
8376b140b85SBryan Schumaker }
8386b140b85SBryan Schumaker #else /* CONFIG_NFS_V4_2 */
8396b140b85SBryan Schumaker static __be32
preprocess_nfs42_op(int nop,unsigned int op_nr,struct callback_op ** op)8406b140b85SBryan Schumaker preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
8416b140b85SBryan Schumaker {
8426b140b85SBryan Schumaker return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
8436b140b85SBryan Schumaker }
8446b140b85SBryan Schumaker #endif /* CONFIG_NFS_V4_2 */
8456b140b85SBryan Schumaker
84634bc47c9SBenny Halevy static __be32
preprocess_nfs4_op(unsigned int op_nr,struct callback_op ** op)84734bc47c9SBenny Halevy preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
84834bc47c9SBenny Halevy {
84934bc47c9SBenny Halevy switch (op_nr) {
85034bc47c9SBenny Halevy case OP_CB_GETATTR:
85134bc47c9SBenny Halevy case OP_CB_RECALL:
85234bc47c9SBenny Halevy *op = &callback_ops[op_nr];
85334bc47c9SBenny Halevy break;
85434bc47c9SBenny Halevy default:
85534bc47c9SBenny Halevy return htonl(NFS4ERR_OP_ILLEGAL);
85634bc47c9SBenny Halevy }
85734bc47c9SBenny Halevy
85834bc47c9SBenny Halevy return htonl(NFS_OK);
85934bc47c9SBenny Halevy }
86034bc47c9SBenny Halevy
process_op(int nop,struct svc_rqst * rqstp,struct cb_process_state * cps)861459de2edSBryan Schumaker static __be32 process_op(int nop, struct svc_rqst *rqstp,
862c36fca52SAndy Adamson struct cb_process_state *cps)
8631da177e4SLinus Torvalds {
8649eff97abSChuck Lever struct xdr_stream *xdr_out = &rqstp->rq_res_stream;
865a162a6b8STrond Myklebust struct callback_op *op = &callback_ops[0];
86631d2b435SAndy Adamson unsigned int op_nr;
86734bc47c9SBenny Halevy __be32 status;
8681da177e4SLinus Torvalds long maxlen;
869e6f684f6SAl Viro __be32 res;
8701da177e4SLinus Torvalds
8719eff97abSChuck Lever status = decode_op_hdr(&rqstp->rq_arg_stream, &op_nr);
87231d2b435SAndy Adamson if (unlikely(status))
87331d2b435SAndy Adamson return status;
8741da177e4SLinus Torvalds
8756b140b85SBryan Schumaker switch (cps->minorversion) {
8766b140b85SBryan Schumaker case 0:
8776b140b85SBryan Schumaker status = preprocess_nfs4_op(op_nr, &op);
8786b140b85SBryan Schumaker break;
8796b140b85SBryan Schumaker case 1:
8806b140b85SBryan Schumaker status = preprocess_nfs41_op(nop, op_nr, &op);
8816b140b85SBryan Schumaker break;
8826b140b85SBryan Schumaker case 2:
8836b140b85SBryan Schumaker status = preprocess_nfs42_op(nop, op_nr, &op);
8846b140b85SBryan Schumaker break;
8856b140b85SBryan Schumaker default:
8866b140b85SBryan Schumaker status = htonl(NFS4ERR_MINOR_VERS_MISMATCH);
8876b140b85SBryan Schumaker }
8886b140b85SBryan Schumaker
88934bc47c9SBenny Halevy if (status == htonl(NFS4ERR_OP_ILLEGAL))
89034bc47c9SBenny Halevy op_nr = OP_CB_ILLEGAL;
891b92b3019SAndy Adamson if (status)
892b92b3019SAndy Adamson goto encode_hdr;
89331d2b435SAndy Adamson
894c36fca52SAndy Adamson if (cps->drc_status) {
895c36fca52SAndy Adamson status = cps->drc_status;
8964911096fSAndy Adamson goto encode_hdr;
8974911096fSAndy Adamson }
8984911096fSAndy Adamson
8991da177e4SLinus Torvalds maxlen = xdr_out->end - xdr_out->p;
9001da177e4SLinus Torvalds if (maxlen > 0 && maxlen < PAGE_SIZE) {
9019eff97abSChuck Lever status = op->decode_args(rqstp, &rqstp->rq_arg_stream,
9029eff97abSChuck Lever rqstp->rq_argp);
903e95e60daSAndy Adamson if (likely(status == 0))
9049eff97abSChuck Lever status = op->process_op(rqstp->rq_argp, rqstp->rq_resp,
9059eff97abSChuck Lever cps);
9061da177e4SLinus Torvalds } else
9071da177e4SLinus Torvalds status = htonl(NFS4ERR_RESOURCE);
9081da177e4SLinus Torvalds
909b92b3019SAndy Adamson encode_hdr:
9101da177e4SLinus Torvalds res = encode_op_hdr(xdr_out, op_nr, status);
91131d2b435SAndy Adamson if (unlikely(res))
91231d2b435SAndy Adamson return res;
9131da177e4SLinus Torvalds if (op->encode_res != NULL && status == 0)
9149eff97abSChuck Lever status = op->encode_res(rqstp, xdr_out, rqstp->rq_resp);
9151da177e4SLinus Torvalds return status;
9161da177e4SLinus Torvalds }
9171da177e4SLinus Torvalds
9181da177e4SLinus Torvalds /*
9191da177e4SLinus Torvalds * Decode, process and encode a COMPOUND
9201da177e4SLinus Torvalds */
nfs4_callback_compound(struct svc_rqst * rqstp)921a6beb732SChristoph Hellwig static __be32 nfs4_callback_compound(struct svc_rqst *rqstp)
9221da177e4SLinus Torvalds {
9233a6258e1STrond Myklebust struct cb_compound_hdr_arg hdr_arg = { 0 };
9243a6258e1STrond Myklebust struct cb_compound_hdr_res hdr_res = { NULL };
925c36fca52SAndy Adamson struct cb_process_state cps = {
926c36fca52SAndy Adamson .drc_status = 0,
927c36fca52SAndy Adamson .clp = NULL,
9289695c705SStanislav Kinsbursky .net = SVC_NET(rqstp),
929c36fca52SAndy Adamson };
9303a6258e1STrond Myklebust unsigned int nops = 0;
93189ef17b6SChuck Lever __be32 status;
9321da177e4SLinus Torvalds
93389ef17b6SChuck Lever status = decode_compound_hdr_arg(&rqstp->rq_arg_stream, &hdr_arg);
9344ed0d83dSVaishali Thakkar if (status == htonl(NFS4ERR_RESOURCE))
9353a6258e1STrond Myklebust return rpc_garbage_args;
9363a6258e1STrond Myklebust
937c36fca52SAndy Adamson if (hdr_arg.minorversion == 0) {
9389695c705SStanislav Kinsbursky cps.clp = nfs4_find_client_ident(SVC_NET(rqstp), hdr_arg.cb_ident);
9392bb50aabSChuck Lever if (!cps.clp) {
9402bb50aabSChuck Lever trace_nfs_cb_no_clp(rqstp->rq_xid, hdr_arg.cb_ident);
9412bb50aabSChuck Lever goto out_invalidcred;
9422bb50aabSChuck Lever }
9432bb50aabSChuck Lever if (!check_gss_callback_principal(cps.clp, rqstp)) {
9442bb50aabSChuck Lever trace_nfs_cb_badprinc(rqstp->rq_xid, hdr_arg.cb_ident);
94532cd3ee5SOlga Kornievskaia nfs_put_client(cps.clp);
946a4e187d8SChuck Lever goto out_invalidcred;
947778be232SAndy Adamson }
94832cd3ee5SOlga Kornievskaia }
949c36fca52SAndy Adamson
950459de2edSBryan Schumaker cps.minorversion = hdr_arg.minorversion;
9511da177e4SLinus Torvalds hdr_res.taglen = hdr_arg.taglen;
9521da177e4SLinus Torvalds hdr_res.tag = hdr_arg.tag;
95389ef17b6SChuck Lever if (encode_compound_hdr_res(&rqstp->rq_res_stream, &hdr_res) != 0) {
95432cd3ee5SOlga Kornievskaia if (cps.clp)
95532cd3ee5SOlga Kornievskaia nfs_put_client(cps.clp);
9563a6258e1STrond Myklebust return rpc_system_err;
95732cd3ee5SOlga Kornievskaia }
9583a6258e1STrond Myklebust while (status == 0 && nops != hdr_arg.nops) {
9599eff97abSChuck Lever status = process_op(nops, rqstp, &cps);
9601da177e4SLinus Torvalds nops++;
9611da177e4SLinus Torvalds }
9623a6258e1STrond Myklebust
96331d2b435SAndy Adamson /* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return
96431d2b435SAndy Adamson * resource error in cb_compound status without returning op */
96531d2b435SAndy Adamson if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
96631d2b435SAndy Adamson status = htonl(NFS4ERR_RESOURCE);
96731d2b435SAndy Adamson nops--;
96831d2b435SAndy Adamson }
96931d2b435SAndy Adamson
9701da177e4SLinus Torvalds *hdr_res.status = status;
9711da177e4SLinus Torvalds *hdr_res.nops = htonl(nops);
97255a67399STrond Myklebust nfs4_cb_free_slot(&cps);
973c36fca52SAndy Adamson nfs_put_client(cps.clp);
9741da177e4SLinus Torvalds return rpc_success;
975a4e187d8SChuck Lever
976a4e187d8SChuck Lever out_invalidcred:
977a4e187d8SChuck Lever pr_warn_ratelimited("NFS: NFSv4 callback contains invalid cred\n");
9789082e1d9SChuck Lever rqstp->rq_auth_stat = rpc_autherr_badcred;
9799082e1d9SChuck Lever return rpc_success;
9801da177e4SLinus Torvalds }
9811da177e4SLinus Torvalds
9827d34c962SChuck Lever static int
nfs_callback_dispatch(struct svc_rqst * rqstp)983cee4db19SChuck Lever nfs_callback_dispatch(struct svc_rqst *rqstp)
9847d34c962SChuck Lever {
9857d34c962SChuck Lever const struct svc_procedure *procp = rqstp->rq_procinfo;
9867d34c962SChuck Lever
987cee4db19SChuck Lever *rqstp->rq_accept_statp = procp->pc_func(rqstp);
9887d34c962SChuck Lever return 1;
9897d34c962SChuck Lever }
9907d34c962SChuck Lever
9911da177e4SLinus Torvalds /*
9921da177e4SLinus Torvalds * Define NFS4 callback COMPOUND ops.
9931da177e4SLinus Torvalds */
9941da177e4SLinus Torvalds static struct callback_op callback_ops[] = {
9951da177e4SLinus Torvalds [0] = {
9961da177e4SLinus Torvalds .res_maxsize = CB_OP_HDR_RES_MAXSZ,
9971da177e4SLinus Torvalds },
9981da177e4SLinus Torvalds [OP_CB_GETATTR] = {
999f4dac4adSChristoph Hellwig .process_op = nfs4_callback_getattr,
1000f4dac4adSChristoph Hellwig .decode_args = decode_getattr_args,
1001f4dac4adSChristoph Hellwig .encode_res = encode_getattr_res,
10021da177e4SLinus Torvalds .res_maxsize = CB_OP_GETATTR_RES_MAXSZ,
10031da177e4SLinus Torvalds },
10041da177e4SLinus Torvalds [OP_CB_RECALL] = {
1005f4dac4adSChristoph Hellwig .process_op = nfs4_callback_recall,
1006f4dac4adSChristoph Hellwig .decode_args = decode_recall_args,
10071da177e4SLinus Torvalds .res_maxsize = CB_OP_RECALL_RES_MAXSZ,
10084aece6a1SBenny Halevy },
10094aece6a1SBenny Halevy #if defined(CONFIG_NFS_V4_1)
1010f2a62561SFred Isaman [OP_CB_LAYOUTRECALL] = {
1011f4dac4adSChristoph Hellwig .process_op = nfs4_callback_layoutrecall,
1012f4dac4adSChristoph Hellwig .decode_args = decode_layoutrecall_args,
1013f2a62561SFred Isaman .res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
1014f2a62561SFred Isaman },
10151be5683bSMarc Eshel [OP_CB_NOTIFY_DEVICEID] = {
1016f4dac4adSChristoph Hellwig .process_op = nfs4_callback_devicenotify,
1017f4dac4adSChristoph Hellwig .decode_args = decode_devicenotify_args,
10181be5683bSMarc Eshel .res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
10191be5683bSMarc Eshel },
10204aece6a1SBenny Halevy [OP_CB_SEQUENCE] = {
1021f4dac4adSChristoph Hellwig .process_op = nfs4_callback_sequence,
1022f4dac4adSChristoph Hellwig .decode_args = decode_cb_sequence_args,
1023f4dac4adSChristoph Hellwig .encode_res = encode_cb_sequence_res,
10244aece6a1SBenny Halevy .res_maxsize = CB_OP_SEQUENCE_RES_MAXSZ,
10254aece6a1SBenny Halevy },
102631f09607SAlexandros Batsakis [OP_CB_RECALL_ANY] = {
1027f4dac4adSChristoph Hellwig .process_op = nfs4_callback_recallany,
1028f4dac4adSChristoph Hellwig .decode_args = decode_recallany_args,
102931f09607SAlexandros Batsakis .res_maxsize = CB_OP_RECALLANY_RES_MAXSZ,
103031f09607SAlexandros Batsakis },
1031b9efa1b2SAndy Adamson [OP_CB_RECALL_SLOT] = {
1032f4dac4adSChristoph Hellwig .process_op = nfs4_callback_recallslot,
1033f4dac4adSChristoph Hellwig .decode_args = decode_recallslot_args,
1034b9efa1b2SAndy Adamson .res_maxsize = CB_OP_RECALLSLOT_RES_MAXSZ,
1035b9efa1b2SAndy Adamson },
1036db783688SJeff Layton [OP_CB_NOTIFY_LOCK] = {
1037f4dac4adSChristoph Hellwig .process_op = nfs4_callback_notify_lock,
1038f4dac4adSChristoph Hellwig .decode_args = decode_notify_lock_args,
1039db783688SJeff Layton .res_maxsize = CB_OP_NOTIFY_LOCK_RES_MAXSZ,
1040db783688SJeff Layton },
10414aece6a1SBenny Halevy #endif /* CONFIG_NFS_V4_1 */
10425178a125SOlga Kornievskaia #ifdef CONFIG_NFS_V4_2
10435178a125SOlga Kornievskaia [OP_CB_OFFLOAD] = {
10445178a125SOlga Kornievskaia .process_op = nfs4_callback_offload,
10455178a125SOlga Kornievskaia .decode_args = decode_offload_args,
10465178a125SOlga Kornievskaia .res_maxsize = CB_OP_OFFLOAD_RES_MAXSZ,
10475178a125SOlga Kornievskaia },
10485178a125SOlga Kornievskaia #endif /* CONFIG_NFS_V4_2 */
10491da177e4SLinus Torvalds };
10501da177e4SLinus Torvalds
10511da177e4SLinus Torvalds /*
10521da177e4SLinus Torvalds * Define NFS4 callback procedures
10531da177e4SLinus Torvalds */
1054860bda29SChristoph Hellwig static const struct svc_procedure nfs4_callback_procedures1[] = {
10551da177e4SLinus Torvalds [CB_NULL] = {
10561da177e4SLinus Torvalds .pc_func = nfs4_callback_null,
105763f8de37SChristoph Hellwig .pc_encode = nfs4_encode_void,
10581da177e4SLinus Torvalds .pc_xdrressize = 1,
10592289e87bSChuck Lever .pc_name = "NULL",
10601da177e4SLinus Torvalds },
10611da177e4SLinus Torvalds [CB_COMPOUND] = {
10621da177e4SLinus Torvalds .pc_func = nfs4_callback_compound,
106363f8de37SChristoph Hellwig .pc_encode = nfs4_encode_void,
10641da177e4SLinus Torvalds .pc_argsize = 256,
1065103cc1faSChuck Lever .pc_argzero = 256,
10661da177e4SLinus Torvalds .pc_ressize = 256,
10671da177e4SLinus Torvalds .pc_xdrressize = NFS4_CALLBACK_BUFSIZE,
10682289e87bSChuck Lever .pc_name = "COMPOUND",
10691da177e4SLinus Torvalds }
10701da177e4SLinus Torvalds };
10711da177e4SLinus Torvalds
1072*65ba3d24SChuck Lever static DEFINE_PER_CPU_ALIGNED(unsigned long,
1073*65ba3d24SChuck Lever nfs4_callback_count1[ARRAY_SIZE(nfs4_callback_procedures1)]);
1074e9679189SChristoph Hellwig const struct svc_version nfs4_callback_version1 = {
10751da177e4SLinus Torvalds .vs_vers = 1,
10761da177e4SLinus Torvalds .vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
10771da177e4SLinus Torvalds .vs_proc = nfs4_callback_procedures1,
10787fd38af9SChristoph Hellwig .vs_count = nfs4_callback_count1,
10791da177e4SLinus Torvalds .vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
10807d34c962SChuck Lever .vs_dispatch = nfs_callback_dispatch,
108105a45a2dSJeff Layton .vs_hidden = true,
10825283b03eSJeff Layton .vs_need_cong_ctrl = true,
10831da177e4SLinus Torvalds };
10841da177e4SLinus Torvalds
1085*65ba3d24SChuck Lever static DEFINE_PER_CPU_ALIGNED(unsigned long,
1086*65ba3d24SChuck Lever nfs4_callback_count4[ARRAY_SIZE(nfs4_callback_procedures1)]);
1087e9679189SChristoph Hellwig const struct svc_version nfs4_callback_version4 = {
108807bccc2dSAlexandros Batsakis .vs_vers = 4,
108907bccc2dSAlexandros Batsakis .vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
109007bccc2dSAlexandros Batsakis .vs_proc = nfs4_callback_procedures1,
10917fd38af9SChristoph Hellwig .vs_count = nfs4_callback_count4,
109207bccc2dSAlexandros Batsakis .vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
10937d34c962SChuck Lever .vs_dispatch = nfs_callback_dispatch,
109405a45a2dSJeff Layton .vs_hidden = true,
10955283b03eSJeff Layton .vs_need_cong_ctrl = true,
109607bccc2dSAlexandros Batsakis };
1097