~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/callback_xdr.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * linux/fs/nfs/callback_xdr.c
  4  *
  5  * Copyright (C) 2004 Trond Myklebust
  6  *
  7  * NFSv4 callback encode/decode procedures
  8  */
  9 #include <linux/kernel.h>
 10 #include <linux/sunrpc/svc.h>
 11 #include <linux/nfs4.h>
 12 #include <linux/nfs_fs.h>
 13 #include <linux/ratelimit.h>
 14 #include <linux/printk.h>
 15 #include <linux/slab.h>
 16 #include <linux/sunrpc/bc_xprt.h>
 17 #include "nfs4_fs.h"
 18 #include "callback.h"
 19 #include "internal.h"
 20 #include "nfs4session.h"
 21 
 22 #define CB_OP_TAGLEN_MAXSZ              (512)
 23 #define CB_OP_HDR_RES_MAXSZ             (2 * 4) // opcode, status
 24 #define CB_OP_GETATTR_BITMAP_MAXSZ      (4 * 4) // bitmap length, 3 bitmaps
 25 #define CB_OP_GETATTR_RES_MAXSZ         (CB_OP_HDR_RES_MAXSZ + \
 26                                          CB_OP_GETATTR_BITMAP_MAXSZ + \
 27                                          /* change, size, ctime, mtime */\
 28                                          (2 + 2 + 3 + 3) * 4)
 29 #define CB_OP_RECALL_RES_MAXSZ          (CB_OP_HDR_RES_MAXSZ)
 30 
 31 #if defined(CONFIG_NFS_V4_1)
 32 #define CB_OP_LAYOUTRECALL_RES_MAXSZ    (CB_OP_HDR_RES_MAXSZ)
 33 #define CB_OP_DEVICENOTIFY_RES_MAXSZ    (CB_OP_HDR_RES_MAXSZ)
 34 #define CB_OP_SEQUENCE_RES_MAXSZ        (CB_OP_HDR_RES_MAXSZ + \
 35                                          NFS4_MAX_SESSIONID_LEN + \
 36                                          (1 + 3) * 4) // seqid, 3 slotids
 37 #define CB_OP_RECALLANY_RES_MAXSZ       (CB_OP_HDR_RES_MAXSZ)
 38 #define CB_OP_RECALLSLOT_RES_MAXSZ      (CB_OP_HDR_RES_MAXSZ)
 39 #define CB_OP_NOTIFY_LOCK_RES_MAXSZ     (CB_OP_HDR_RES_MAXSZ)
 40 #endif /* CONFIG_NFS_V4_1 */
 41 
 42 #define NFSDBG_FACILITY NFSDBG_CALLBACK
 43 
 44 /* Internal error code */
 45 #define NFS4ERR_RESOURCE_HDR    11050
 46 
 47 struct callback_op {
 48         __be32 (*process_op)(void *, void *, struct cb_process_state *);
 49         __be32 (*decode_args)(struct svc_rqst *, struct xdr_stream *, void *);
 50         __be32 (*encode_res)(struct svc_rqst *, struct xdr_stream *,
 51                         const void *);
 52         long res_maxsize;
 53 };
 54 
 55 static struct callback_op callback_ops[];
 56 
 57 static __be32 nfs4_callback_null(struct svc_rqst *rqstp)
 58 {
 59         return htonl(NFS4_OK);
 60 }
 61 
 62 static int nfs4_decode_void(struct svc_rqst *rqstp, __be32 *p)
 63 {
 64         return xdr_argsize_check(rqstp, p);
 65 }
 66 
 67 static int nfs4_encode_void(struct svc_rqst *rqstp, __be32 *p)
 68 {
 69         return xdr_ressize_check(rqstp, p);
 70 }
 71 
 72 static __be32 *read_buf(struct xdr_stream *xdr, size_t nbytes)
 73 {
 74         __be32 *p;
 75 
 76         p = xdr_inline_decode(xdr, nbytes);
 77         if (unlikely(p == NULL))
 78                 printk(KERN_WARNING "NFS: NFSv4 callback reply buffer overflowed!\n");
 79         return p;
 80 }
 81 
 82 static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len,
 83                 const char **str, size_t maxlen)
 84 {
 85         ssize_t err;
 86 
 87         err = xdr_stream_decode_opaque_inline(xdr, (void **)str, maxlen);
 88         if (err < 0)
 89                 return cpu_to_be32(NFS4ERR_RESOURCE);
 90         *len = err;
 91         return 0;
 92 }
 93 
 94 static __be32 decode_fh(struct xdr_stream *xdr, struct nfs_fh *fh)
 95 {
 96         __be32 *p;
 97 
 98         p = read_buf(xdr, 4);
 99         if (unlikely(p == NULL))
100                 return htonl(NFS4ERR_RESOURCE);
101         fh->size = ntohl(*p);
102         if (fh->size > NFS4_FHSIZE)
103                 return htonl(NFS4ERR_BADHANDLE);
104         p = read_buf(xdr, fh->size);
105         if (unlikely(p == NULL))
106                 return htonl(NFS4ERR_RESOURCE);
107         memcpy(&fh->data[0], p, fh->size);
108         memset(&fh->data[fh->size], 0, sizeof(fh->data) - fh->size);
109         return 0;
110 }
111 
112 static __be32 decode_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
113 {
114         __be32 *p;
115         unsigned int attrlen;
116 
117         p = read_buf(xdr, 4);
118         if (unlikely(p == NULL))
119                 return htonl(NFS4ERR_RESOURCE);
120         attrlen = ntohl(*p);
121         p = read_buf(xdr, attrlen << 2);
122         if (unlikely(p == NULL))
123                 return htonl(NFS4ERR_RESOURCE);
124         if (likely(attrlen > 0))
125                 bitmap[0] = ntohl(*p++);
126         if (attrlen > 1)
127                 bitmap[1] = ntohl(*p);
128         return 0;
129 }
130 
131 static __be32 decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
132 {
133         __be32 *p;
134 
135         p = read_buf(xdr, NFS4_STATEID_SIZE);
136         if (unlikely(p == NULL))
137                 return htonl(NFS4ERR_RESOURCE);
138         memcpy(stateid->data, p, NFS4_STATEID_SIZE);
139         return 0;
140 }
141 
142 static __be32 decode_delegation_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
143 {
144         stateid->type = NFS4_DELEGATION_STATEID_TYPE;
145         return decode_stateid(xdr, stateid);
146 }
147 
148 static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound_hdr_arg *hdr)
149 {
150         __be32 *p;
151         __be32 status;
152 
153         status = decode_string(xdr, &hdr->taglen, &hdr->tag, CB_OP_TAGLEN_MAXSZ);
154         if (unlikely(status != 0))
155                 return status;
156         p = read_buf(xdr, 12);
157         if (unlikely(p == NULL))
158                 return htonl(NFS4ERR_RESOURCE);
159         hdr->minorversion = ntohl(*p++);
160         /* Check for minor version support */
161         if (hdr->minorversion <= NFS4_MAX_MINOR_VERSION) {
162                 hdr->cb_ident = ntohl(*p++); /* ignored by v4.1 and v4.2 */
163         } else {
164                 pr_warn_ratelimited("NFS: %s: NFSv4 server callback with "
165                         "illegal minor version %u!\n",
166                         __func__, hdr->minorversion);
167                 return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
168         }
169         hdr->nops = ntohl(*p);
170         return 0;
171 }
172 
173 static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)
174 {
175         __be32 *p;
176         p = read_buf(xdr, 4);
177         if (unlikely(p == NULL))
178                 return htonl(NFS4ERR_RESOURCE_HDR);
179         *op = ntohl(*p);
180         return 0;
181 }
182 
183 static __be32 decode_getattr_args(struct svc_rqst *rqstp,
184                 struct xdr_stream *xdr, void *argp)
185 {
186         struct cb_getattrargs *args = argp;
187         __be32 status;
188 
189         status = decode_fh(xdr, &args->fh);
190         if (unlikely(status != 0))
191                 return status;
192         return decode_bitmap(xdr, args->bitmap);
193 }
194 
195 static __be32 decode_recall_args(struct svc_rqst *rqstp,
196                 struct xdr_stream *xdr, void *argp)
197 {
198         struct cb_recallargs *args = argp;
199         __be32 *p;
200         __be32 status;
201 
202         status = decode_delegation_stateid(xdr, &args->stateid);
203         if (unlikely(status != 0))
204                 return status;
205         p = read_buf(xdr, 4);
206         if (unlikely(p == NULL))
207                 return htonl(NFS4ERR_RESOURCE);
208         args->truncate = ntohl(*p);
209         return decode_fh(xdr, &args->fh);
210 }
211 
212 #if defined(CONFIG_NFS_V4_1)
213 static __be32 decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
214 {
215         stateid->type = NFS4_LAYOUT_STATEID_TYPE;
216         return decode_stateid(xdr, stateid);
217 }
218 
219 static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
220                                        struct xdr_stream *xdr, void *argp)
221 {
222         struct cb_layoutrecallargs *args = argp;
223         __be32 *p;
224         __be32 status = 0;
225         uint32_t iomode;
226 
227         p = read_buf(xdr, 4 * sizeof(uint32_t));
228         if (unlikely(p == NULL))
229                 return htonl(NFS4ERR_BADXDR);
230 
231         args->cbl_layout_type = ntohl(*p++);
232         /* Depite the spec's xdr, iomode really belongs in the FILE switch,
233          * as it is unusable and ignored with the other types.
234          */
235         iomode = ntohl(*p++);
236         args->cbl_layoutchanged = ntohl(*p++);
237         args->cbl_recall_type = ntohl(*p++);
238 
239         if (args->cbl_recall_type == RETURN_FILE) {
240                 args->cbl_range.iomode = iomode;
241                 status = decode_fh(xdr, &args->cbl_fh);
242                 if (unlikely(status != 0))
243                         return status;
244 
245                 p = read_buf(xdr, 2 * sizeof(uint64_t));
246                 if (unlikely(p == NULL))
247                         return htonl(NFS4ERR_BADXDR);
248                 p = xdr_decode_hyper(p, &args->cbl_range.offset);
249                 p = xdr_decode_hyper(p, &args->cbl_range.length);
250                 return decode_layout_stateid(xdr, &args->cbl_stateid);
251         } else if (args->cbl_recall_type == RETURN_FSID) {
252                 p = read_buf(xdr, 2 * sizeof(uint64_t));
253                 if (unlikely(p == NULL))
254                         return htonl(NFS4ERR_BADXDR);
255                 p = xdr_decode_hyper(p, &args->cbl_fsid.major);
256                 p = xdr_decode_hyper(p, &args->cbl_fsid.minor);
257         } else if (args->cbl_recall_type != RETURN_ALL)
258                 return htonl(NFS4ERR_BADXDR);
259         return 0;
260 }
261 
262 static
263 __be32 decode_devicenotify_args(struct svc_rqst *rqstp,
264                                 struct xdr_stream *xdr,
265                                 void *argp)
266 {
267         struct cb_devicenotifyargs *args = argp;
268         __be32 *p;
269         __be32 status = 0;
270         u32 tmp;
271         int n, i;
272         args->ndevs = 0;
273 
274         /* Num of device notifications */
275         p = read_buf(xdr, sizeof(uint32_t));
276         if (unlikely(p == NULL)) {
277                 status = htonl(NFS4ERR_BADXDR);
278                 goto out;
279         }
280         n = ntohl(*p++);
281         if (n <= 0)
282                 goto out;
283         if (n > ULONG_MAX / sizeof(*args->devs)) {
284                 status = htonl(NFS4ERR_BADXDR);
285                 goto out;
286         }
287 
288         args->devs = kmalloc_array(n, sizeof(*args->devs), GFP_KERNEL);
289         if (!args->devs) {
290                 status = htonl(NFS4ERR_DELAY);
291                 goto out;
292         }
293 
294         /* Decode each dev notification */
295         for (i = 0; i < n; i++) {
296                 struct cb_devicenotifyitem *dev = &args->devs[i];
297 
298                 p = read_buf(xdr, (4 * sizeof(uint32_t)) + NFS4_DEVICEID4_SIZE);
299                 if (unlikely(p == NULL)) {
300                         status = htonl(NFS4ERR_BADXDR);
301                         goto err;
302                 }
303 
304                 tmp = ntohl(*p++);      /* bitmap size */
305                 if (tmp != 1) {
306                         status = htonl(NFS4ERR_INVAL);
307                         goto err;
308                 }
309                 dev->cbd_notify_type = ntohl(*p++);
310                 if (dev->cbd_notify_type != NOTIFY_DEVICEID4_CHANGE &&
311                     dev->cbd_notify_type != NOTIFY_DEVICEID4_DELETE) {
312                         status = htonl(NFS4ERR_INVAL);
313                         goto err;
314                 }
315 
316                 tmp = ntohl(*p++);      /* opaque size */
317                 if (((dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE) &&
318                      (tmp != NFS4_DEVICEID4_SIZE + 8)) ||
319                     ((dev->cbd_notify_type == NOTIFY_DEVICEID4_DELETE) &&
320                      (tmp != NFS4_DEVICEID4_SIZE + 4))) {
321                         status = htonl(NFS4ERR_INVAL);
322                         goto err;
323                 }
324                 dev->cbd_layout_type = ntohl(*p++);
325                 memcpy(dev->cbd_dev_id.data, p, NFS4_DEVICEID4_SIZE);
326                 p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
327 
328                 if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
329                         p = read_buf(xdr, sizeof(uint32_t));
330                         if (unlikely(p == NULL)) {
331                                 status = htonl(NFS4ERR_BADXDR);
332                                 goto err;
333                         }
334                         dev->cbd_immediate = ntohl(*p++);
335                 } else {
336                         dev->cbd_immediate = 0;
337                 }
338 
339                 args->ndevs++;
340 
341                 dprintk("%s: type %d layout 0x%x immediate %d\n",
342                         __func__, dev->cbd_notify_type, dev->cbd_layout_type,
343                         dev->cbd_immediate);
344         }
345 out:
346         dprintk("%s: status %d ndevs %d\n",
347                 __func__, ntohl(status), args->ndevs);
348         return status;
349 err:
350         kfree(args->devs);
351         goto out;
352 }
353 
354 static __be32 decode_sessionid(struct xdr_stream *xdr,
355                                  struct nfs4_sessionid *sid)
356 {
357         __be32 *p;
358 
359         p = read_buf(xdr, NFS4_MAX_SESSIONID_LEN);
360         if (unlikely(p == NULL))
361                 return htonl(NFS4ERR_RESOURCE);
362 
363         memcpy(sid->data, p, NFS4_MAX_SESSIONID_LEN);
364         return 0;
365 }
366 
367 static __be32 decode_rc_list(struct xdr_stream *xdr,
368                                struct referring_call_list *rc_list)
369 {
370         __be32 *p;
371         int i;
372         __be32 status;
373 
374         status = decode_sessionid(xdr, &rc_list->rcl_sessionid);
375         if (status)
376                 goto out;
377 
378         status = htonl(NFS4ERR_RESOURCE);
379         p = read_buf(xdr, sizeof(uint32_t));
380         if (unlikely(p == NULL))
381                 goto out;
382 
383         rc_list->rcl_nrefcalls = ntohl(*p++);
384         if (rc_list->rcl_nrefcalls) {
385                 p = read_buf(xdr,
386                              rc_list->rcl_nrefcalls * 2 * sizeof(uint32_t));
387                 if (unlikely(p == NULL))
388                         goto out;
389                 rc_list->rcl_refcalls = kmalloc_array(rc_list->rcl_nrefcalls,
390                                                 sizeof(*rc_list->rcl_refcalls),
391                                                 GFP_KERNEL);
392                 if (unlikely(rc_list->rcl_refcalls == NULL))
393                         goto out;
394                 for (i = 0; i < rc_list->rcl_nrefcalls; i++) {
395                         rc_list->rcl_refcalls[i].rc_sequenceid = ntohl(*p++);
396                         rc_list->rcl_refcalls[i].rc_slotid = ntohl(*p++);
397                 }
398         }
399         status = 0;
400 
401 out:
402         return status;
403 }
404 
405 static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
406                                         struct xdr_stream *xdr,
407                                         void *argp)
408 {
409         struct cb_sequenceargs *args = argp;
410         __be32 *p;
411         int i;
412         __be32 status;
413 
414         status = decode_sessionid(xdr, &args->csa_sessionid);
415         if (status)
416                 return status;
417 
418         p = read_buf(xdr, 5 * sizeof(uint32_t));
419         if (unlikely(p == NULL))
420                 return htonl(NFS4ERR_RESOURCE);
421 
422         args->csa_addr = svc_addr(rqstp);
423         args->csa_sequenceid = ntohl(*p++);
424         args->csa_slotid = ntohl(*p++);
425         args->csa_highestslotid = ntohl(*p++);
426         args->csa_cachethis = ntohl(*p++);
427         args->csa_nrclists = ntohl(*p++);
428         args->csa_rclists = NULL;
429         if (args->csa_nrclists) {
430                 args->csa_rclists = kmalloc_array(args->csa_nrclists,
431                                                   sizeof(*args->csa_rclists),
432                                                   GFP_KERNEL);
433                 if (unlikely(args->csa_rclists == NULL))
434                         return htonl(NFS4ERR_RESOURCE);
435 
436                 for (i = 0; i < args->csa_nrclists; i++) {
437                         status = decode_rc_list(xdr, &args->csa_rclists[i]);
438                         if (status) {
439                                 args->csa_nrclists = i;
440                                 goto out_free;
441                         }
442                 }
443         }
444         return 0;
445 
446 out_free:
447         for (i = 0; i < args->csa_nrclists; i++)
448                 kfree(args->csa_rclists[i].rcl_refcalls);
449         kfree(args->csa_rclists);
450         return status;
451 }
452 
453 static __be32 decode_recallany_args(struct svc_rqst *rqstp,
454                                       struct xdr_stream *xdr,
455                                       void *argp)
456 {
457         struct cb_recallanyargs *args = argp;
458         uint32_t bitmap[2];
459         __be32 *p, status;
460 
461         p = read_buf(xdr, 4);
462         if (unlikely(p == NULL))
463                 return htonl(NFS4ERR_BADXDR);
464         args->craa_objs_to_keep = ntohl(*p++);
465         status = decode_bitmap(xdr, bitmap);
466         if (unlikely(status))
467                 return status;
468         args->craa_type_mask = bitmap[0];
469 
470         return 0;
471 }
472 
473 static __be32 decode_recallslot_args(struct svc_rqst *rqstp,
474                                         struct xdr_stream *xdr,
475                                         void *argp)
476 {
477         struct cb_recallslotargs *args = argp;
478         __be32 *p;
479 
480         p = read_buf(xdr, 4);
481         if (unlikely(p == NULL))
482                 return htonl(NFS4ERR_BADXDR);
483         args->crsa_target_highest_slotid = ntohl(*p++);
484         return 0;
485 }
486 
487 static __be32 decode_lockowner(struct xdr_stream *xdr, struct cb_notify_lock_args *args)
488 {
489         __be32          *p;
490         unsigned int    len;
491 
492         p = read_buf(xdr, 12);
493         if (unlikely(p == NULL))
494                 return htonl(NFS4ERR_BADXDR);
495 
496         p = xdr_decode_hyper(p, &args->cbnl_owner.clientid);
497         len = be32_to_cpu(*p);
498 
499         p = read_buf(xdr, len);
500         if (unlikely(p == NULL))
501                 return htonl(NFS4ERR_BADXDR);
502 
503         /* Only try to decode if the length is right */
504         if (len == 20) {
505                 p += 2; /* skip "lock id:" */
506                 args->cbnl_owner.s_dev = be32_to_cpu(*p++);
507                 xdr_decode_hyper(p, &args->cbnl_owner.id);
508                 args->cbnl_valid = true;
509         } else {
510                 args->cbnl_owner.s_dev = 0;
511                 args->cbnl_owner.id = 0;
512                 args->cbnl_valid = false;
513         }
514         return 0;
515 }
516 
517 static __be32 decode_notify_lock_args(struct svc_rqst *rqstp,
518                 struct xdr_stream *xdr, void *argp)
519 {
520         struct cb_notify_lock_args *args = argp;
521         __be32 status;
522 
523         status = decode_fh(xdr, &args->cbnl_fh);
524         if (unlikely(status != 0))
525                 return status;
526         return decode_lockowner(xdr, args);
527 }
528 
529 #endif /* CONFIG_NFS_V4_1 */
530 
531 static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
532 {
533         if (unlikely(xdr_stream_encode_opaque(xdr, str, len) < 0))
534                 return cpu_to_be32(NFS4ERR_RESOURCE);
535         return 0;
536 }
537 
538 #define CB_SUPPORTED_ATTR0 (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE)
539 #define CB_SUPPORTED_ATTR1 (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY)
540 static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, __be32 **savep)
541 {
542         __be32 bm[2];
543         __be32 *p;
544 
545         bm[0] = htonl(bitmap[0] & CB_SUPPORTED_ATTR0);
546         bm[1] = htonl(bitmap[1] & CB_SUPPORTED_ATTR1);
547         if (bm[1] != 0) {
548                 p = xdr_reserve_space(xdr, 16);
549                 if (unlikely(p == NULL))
550                         return htonl(NFS4ERR_RESOURCE);
551                 *p++ = htonl(2);
552                 *p++ = bm[0];
553                 *p++ = bm[1];
554         } else if (bm[0] != 0) {
555                 p = xdr_reserve_space(xdr, 12);
556                 if (unlikely(p == NULL))
557                         return htonl(NFS4ERR_RESOURCE);
558                 *p++ = htonl(1);
559                 *p++ = bm[0];
560         } else {
561                 p = xdr_reserve_space(xdr, 8);
562                 if (unlikely(p == NULL))
563                         return htonl(NFS4ERR_RESOURCE);
564                 *p++ = htonl(0);
565         }
566         *savep = p;
567         return 0;
568 }
569 
570 static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change)
571 {
572         __be32 *p;
573 
574         if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
575                 return 0;
576         p = xdr_reserve_space(xdr, 8);
577         if (unlikely(!p))
578                 return htonl(NFS4ERR_RESOURCE);
579         p = xdr_encode_hyper(p, change);
580         return 0;
581 }
582 
583 static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size)
584 {
585         __be32 *p;
586 
587         if (!(bitmap[0] & FATTR4_WORD0_SIZE))
588                 return 0;
589         p = xdr_reserve_space(xdr, 8);
590         if (unlikely(!p))
591                 return htonl(NFS4ERR_RESOURCE);
592         p = xdr_encode_hyper(p, size);
593         return 0;
594 }
595 
596 static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *time)
597 {
598         __be32 *p;
599 
600         p = xdr_reserve_space(xdr, 12);
601         if (unlikely(!p))
602                 return htonl(NFS4ERR_RESOURCE);
603         p = xdr_encode_hyper(p, time->tv_sec);
604         *p = htonl(time->tv_nsec);
605         return 0;
606 }
607 
608 static __be32 encode_attr_ctime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
609 {
610         if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))
611                 return 0;
612         return encode_attr_time(xdr,time);
613 }
614 
615 static __be32 encode_attr_mtime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
616 {
617         if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))
618                 return 0;
619         return encode_attr_time(xdr,time);
620 }
621 
622 static __be32 encode_compound_hdr_res(struct xdr_stream *xdr, struct cb_compound_hdr_res *hdr)
623 {
624         __be32 status;
625 
626         hdr->status = xdr_reserve_space(xdr, 4);
627         if (unlikely(hdr->status == NULL))
628                 return htonl(NFS4ERR_RESOURCE);
629         status = encode_string(xdr, hdr->taglen, hdr->tag);
630         if (unlikely(status != 0))
631                 return status;
632         hdr->nops = xdr_reserve_space(xdr, 4);
633         if (unlikely(hdr->nops == NULL))
634                 return htonl(NFS4ERR_RESOURCE);
635         return 0;
636 }
637 
638 static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
639 {
640         __be32 *p;
641         
642         p = xdr_reserve_space(xdr, 8);
643         if (unlikely(p == NULL))
644                 return htonl(NFS4ERR_RESOURCE_HDR);
645         *p++ = htonl(op);
646         *p = res;
647         return 0;
648 }
649 
650 static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr,
651                 const void *resp)
652 {
653         const struct cb_getattrres *res = resp;
654         __be32 *savep = NULL;
655         __be32 status = res->status;
656         
657         if (unlikely(status != 0))
658                 goto out;
659         status = encode_attr_bitmap(xdr, res->bitmap, &savep);
660         if (unlikely(status != 0))
661                 goto out;
662         status = encode_attr_change(xdr, res->bitmap, res->change_attr);
663         if (unlikely(status != 0))
664                 goto out;
665         status = encode_attr_size(xdr, res->bitmap, res->size);
666         if (unlikely(status != 0))
667                 goto out;
668         status = encode_attr_ctime(xdr, res->bitmap, &res->ctime);
669         if (unlikely(status != 0))
670                 goto out;
671         status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
672         *savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1)));
673 out:
674         return status;
675 }
676 
677 #if defined(CONFIG_NFS_V4_1)
678 
679 static __be32 encode_sessionid(struct xdr_stream *xdr,
680                                  const struct nfs4_sessionid *sid)
681 {
682         __be32 *p;
683 
684         p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN);
685         if (unlikely(p == NULL))
686                 return htonl(NFS4ERR_RESOURCE);
687 
688         memcpy(p, sid, NFS4_MAX_SESSIONID_LEN);
689         return 0;
690 }
691 
692 static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
693                                        struct xdr_stream *xdr,
694                                        const void *resp)
695 {
696         const struct cb_sequenceres *res = resp;
697         __be32 *p;
698         __be32 status = res->csr_status;
699 
700         if (unlikely(status != 0))
701                 return status;
702 
703         status = encode_sessionid(xdr, &res->csr_sessionid);
704         if (status)
705                 return status;
706 
707         p = xdr_reserve_space(xdr, 4 * sizeof(uint32_t));
708         if (unlikely(p == NULL))
709                 return htonl(NFS4ERR_RESOURCE);
710 
711         *p++ = htonl(res->csr_sequenceid);
712         *p++ = htonl(res->csr_slotid);
713         *p++ = htonl(res->csr_highestslotid);
714         *p++ = htonl(res->csr_target_highestslotid);
715         return 0;
716 }
717 
718 static __be32
719 preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
720 {
721         if (op_nr == OP_CB_SEQUENCE) {
722                 if (nop != 0)
723                         return htonl(NFS4ERR_SEQUENCE_POS);
724         } else {
725                 if (nop == 0)
726                         return htonl(NFS4ERR_OP_NOT_IN_SESSION);
727         }
728 
729         switch (op_nr) {
730         case OP_CB_GETATTR:
731         case OP_CB_RECALL:
732         case OP_CB_SEQUENCE:
733         case OP_CB_RECALL_ANY:
734         case OP_CB_RECALL_SLOT:
735         case OP_CB_LAYOUTRECALL:
736         case OP_CB_NOTIFY_DEVICEID:
737         case OP_CB_NOTIFY_LOCK:
738                 *op = &callback_ops[op_nr];
739                 break;
740 
741         case OP_CB_NOTIFY:
742         case OP_CB_PUSH_DELEG:
743         case OP_CB_RECALLABLE_OBJ_AVAIL:
744         case OP_CB_WANTS_CANCELLED:
745                 return htonl(NFS4ERR_NOTSUPP);
746 
747         default:
748                 return htonl(NFS4ERR_OP_ILLEGAL);
749         }
750 
751         return htonl(NFS_OK);
752 }
753 
754 static void nfs4_callback_free_slot(struct nfs4_session *session,
755                 struct nfs4_slot *slot)
756 {
757         struct nfs4_slot_table *tbl = &session->bc_slot_table;
758 
759         spin_lock(&tbl->slot_tbl_lock);
760         /*
761          * Let the state manager know callback processing done.
762          * A single slot, so highest used slotid is either 0 or -1
763          */
764         nfs4_free_slot(tbl, slot);
765         spin_unlock(&tbl->slot_tbl_lock);
766 }
767 
768 static void nfs4_cb_free_slot(struct cb_process_state *cps)
769 {
770         if (cps->slot) {
771                 nfs4_callback_free_slot(cps->clp->cl_session, cps->slot);
772                 cps->slot = NULL;
773         }
774 }
775 
776 #else /* CONFIG_NFS_V4_1 */
777 
778 static __be32
779 preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
780 {
781         return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
782 }
783 
784 static void nfs4_cb_free_slot(struct cb_process_state *cps)
785 {
786 }
787 #endif /* CONFIG_NFS_V4_1 */
788 
789 #ifdef CONFIG_NFS_V4_2
790 static __be32
791 preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
792 {
793         __be32 status = preprocess_nfs41_op(nop, op_nr, op);
794         if (status != htonl(NFS4ERR_OP_ILLEGAL))
795                 return status;
796 
797         if (op_nr == OP_CB_OFFLOAD)
798                 return htonl(NFS4ERR_NOTSUPP);
799         return htonl(NFS4ERR_OP_ILLEGAL);
800 }
801 #else /* CONFIG_NFS_V4_2 */
802 static __be32
803 preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
804 {
805         return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
806 }
807 #endif /* CONFIG_NFS_V4_2 */
808 
809 static __be32
810 preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
811 {
812         switch (op_nr) {
813         case OP_CB_GETATTR:
814         case OP_CB_RECALL:
815                 *op = &callback_ops[op_nr];
816                 break;
817         default:
818                 return htonl(NFS4ERR_OP_ILLEGAL);
819         }
820 
821         return htonl(NFS_OK);
822 }
823 
824 static __be32 process_op(int nop, struct svc_rqst *rqstp,
825                 struct xdr_stream *xdr_in, void *argp,
826                 struct xdr_stream *xdr_out, void *resp,
827                 struct cb_process_state *cps)
828 {
829         struct callback_op *op = &callback_ops[0];
830         unsigned int op_nr;
831         __be32 status;
832         long maxlen;
833         __be32 res;
834 
835         status = decode_op_hdr(xdr_in, &op_nr);
836         if (unlikely(status))
837                 return status;
838 
839         switch (cps->minorversion) {
840         case 0:
841                 status = preprocess_nfs4_op(op_nr, &op);
842                 break;
843         case 1:
844                 status = preprocess_nfs41_op(nop, op_nr, &op);
845                 break;
846         case 2:
847                 status = preprocess_nfs42_op(nop, op_nr, &op);
848                 break;
849         default:
850                 status = htonl(NFS4ERR_MINOR_VERS_MISMATCH);
851         }
852 
853         if (status == htonl(NFS4ERR_OP_ILLEGAL))
854                 op_nr = OP_CB_ILLEGAL;
855         if (status)
856                 goto encode_hdr;
857 
858         if (cps->drc_status) {
859                 status = cps->drc_status;
860                 goto encode_hdr;
861         }
862 
863         maxlen = xdr_out->end - xdr_out->p;
864         if (maxlen > 0 && maxlen < PAGE_SIZE) {
865                 status = op->decode_args(rqstp, xdr_in, argp);
866                 if (likely(status == 0))
867                         status = op->process_op(argp, resp, cps);
868         } else
869                 status = htonl(NFS4ERR_RESOURCE);
870 
871 encode_hdr:
872         res = encode_op_hdr(xdr_out, op_nr, status);
873         if (unlikely(res))
874                 return res;
875         if (op->encode_res != NULL && status == 0)
876                 status = op->encode_res(rqstp, xdr_out, resp);
877         return status;
878 }
879 
880 /*
881  * Decode, process and encode a COMPOUND
882  */
883 static __be32 nfs4_callback_compound(struct svc_rqst *rqstp)
884 {
885         struct cb_compound_hdr_arg hdr_arg = { 0 };
886         struct cb_compound_hdr_res hdr_res = { NULL };
887         struct xdr_stream xdr_in, xdr_out;
888         __be32 *p, status;
889         struct cb_process_state cps = {
890                 .drc_status = 0,
891                 .clp = NULL,
892                 .net = SVC_NET(rqstp),
893         };
894         unsigned int nops = 0;
895 
896         xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
897 
898         p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
899         xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
900 
901         status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
902         if (status == htonl(NFS4ERR_RESOURCE))
903                 return rpc_garbage_args;
904 
905         if (hdr_arg.minorversion == 0) {
906                 cps.clp = nfs4_find_client_ident(SVC_NET(rqstp), hdr_arg.cb_ident);
907                 if (!cps.clp || !check_gss_callback_principal(cps.clp, rqstp))
908                         goto out_invalidcred;
909         }
910 
911         cps.minorversion = hdr_arg.minorversion;
912         hdr_res.taglen = hdr_arg.taglen;
913         hdr_res.tag = hdr_arg.tag;
914         if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
915                 return rpc_system_err;
916 
917         while (status == 0 && nops != hdr_arg.nops) {
918                 status = process_op(nops, rqstp, &xdr_in,
919                                     rqstp->rq_argp, &xdr_out, rqstp->rq_resp,
920                                     &cps);
921                 nops++;
922         }
923 
924         /* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return
925         * resource error in cb_compound status without returning op */
926         if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
927                 status = htonl(NFS4ERR_RESOURCE);
928                 nops--;
929         }
930 
931         *hdr_res.status = status;
932         *hdr_res.nops = htonl(nops);
933         nfs4_cb_free_slot(&cps);
934         nfs_put_client(cps.clp);
935         return rpc_success;
936 
937 out_invalidcred:
938         pr_warn_ratelimited("NFS: NFSv4 callback contains invalid cred\n");
939         return rpc_autherr_badcred;
940 }
941 
942 /*
943  * Define NFS4 callback COMPOUND ops.
944  */
945 static struct callback_op callback_ops[] = {
946         [0] = {
947                 .res_maxsize = CB_OP_HDR_RES_MAXSZ,
948         },
949         [OP_CB_GETATTR] = {
950                 .process_op = nfs4_callback_getattr,
951                 .decode_args = decode_getattr_args,
952                 .encode_res = encode_getattr_res,
953                 .res_maxsize = CB_OP_GETATTR_RES_MAXSZ,
954         },
955         [OP_CB_RECALL] = {
956                 .process_op = nfs4_callback_recall,
957                 .decode_args = decode_recall_args,
958                 .res_maxsize = CB_OP_RECALL_RES_MAXSZ,
959         },
960 #if defined(CONFIG_NFS_V4_1)
961         [OP_CB_LAYOUTRECALL] = {
962                 .process_op = nfs4_callback_layoutrecall,
963                 .decode_args = decode_layoutrecall_args,
964                 .res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
965         },
966         [OP_CB_NOTIFY_DEVICEID] = {
967                 .process_op = nfs4_callback_devicenotify,
968                 .decode_args = decode_devicenotify_args,
969                 .res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
970         },
971         [OP_CB_SEQUENCE] = {
972                 .process_op = nfs4_callback_sequence,
973                 .decode_args = decode_cb_sequence_args,
974                 .encode_res = encode_cb_sequence_res,
975                 .res_maxsize = CB_OP_SEQUENCE_RES_MAXSZ,
976         },
977         [OP_CB_RECALL_ANY] = {
978                 .process_op = nfs4_callback_recallany,
979                 .decode_args = decode_recallany_args,
980                 .res_maxsize = CB_OP_RECALLANY_RES_MAXSZ,
981         },
982         [OP_CB_RECALL_SLOT] = {
983                 .process_op = nfs4_callback_recallslot,
984                 .decode_args = decode_recallslot_args,
985                 .res_maxsize = CB_OP_RECALLSLOT_RES_MAXSZ,
986         },
987         [OP_CB_NOTIFY_LOCK] = {
988                 .process_op = nfs4_callback_notify_lock,
989                 .decode_args = decode_notify_lock_args,
990                 .res_maxsize = CB_OP_NOTIFY_LOCK_RES_MAXSZ,
991         },
992 #endif /* CONFIG_NFS_V4_1 */
993 };
994 
995 /*
996  * Define NFS4 callback procedures
997  */
998 static const struct svc_procedure nfs4_callback_procedures1[] = {
999         [CB_NULL] = {
1000                 .pc_func = nfs4_callback_null,
1001                 .pc_decode = nfs4_decode_void,
1002                 .pc_encode = nfs4_encode_void,
1003                 .pc_xdrressize = 1,
1004         },
1005         [CB_COMPOUND] = {
1006                 .pc_func = nfs4_callback_compound,
1007                 .pc_encode = nfs4_encode_void,
1008                 .pc_argsize = 256,
1009                 .pc_ressize = 256,
1010                 .pc_xdrressize = NFS4_CALLBACK_BUFSIZE,
1011         }
1012 };
1013 
1014 static unsigned int nfs4_callback_count1[ARRAY_SIZE(nfs4_callback_procedures1)];
1015 const struct svc_version nfs4_callback_version1 = {
1016         .vs_vers = 1,
1017         .vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
1018         .vs_proc = nfs4_callback_procedures1,
1019         .vs_count = nfs4_callback_count1,
1020         .vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
1021         .vs_dispatch = NULL,
1022         .vs_hidden = true,
1023         .vs_need_cong_ctrl = true,
1024 };
1025 
1026 static unsigned int nfs4_callback_count4[ARRAY_SIZE(nfs4_callback_procedures1)];
1027 const struct svc_version nfs4_callback_version4 = {
1028         .vs_vers = 4,
1029         .vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
1030         .vs_proc = nfs4_callback_procedures1,
1031         .vs_count = nfs4_callback_count4,
1032         .vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
1033         .vs_dispatch = NULL,
1034         .vs_hidden = true,
1035         .vs_need_cong_ctrl = true,
1036 };
1037 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp