fs/nfs/nfs42xdr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
   4  */
   5 #ifndef __LINUX_FS_NFS_NFS4_2XDR_H
   6 #define __LINUX_FS_NFS_NFS4_2XDR_H
   7
   8 #include "nfs42.h"
   9
  10 #define encode_fallocate_maxsz          (encode_stateid_maxsz + \
  11                                          2 /* offset */ + \
  12                                          2 /* length */)
  13 #define NFS42_WRITE_RES_SIZE            (1 /* wr_callback_id size */ +\
  14                                          XDR_QUADLEN(NFS4_STATEID_SIZE) + \
  15                                          2 /* wr_count */ + \
  16                                          1 /* wr_committed */ + \
  17                                          XDR_QUADLEN(NFS4_VERIFIER_SIZE))
  18 #define encode_allocate_maxsz           (op_encode_hdr_maxsz + \
  19                                          encode_fallocate_maxsz)
  20 #define decode_allocate_maxsz           (op_decode_hdr_maxsz)
  21 #define encode_copy_maxsz               (op_encode_hdr_maxsz +          \
  22                                          XDR_QUADLEN(NFS4_STATEID_SIZE) + \
  23                                          XDR_QUADLEN(NFS4_STATEID_SIZE) + \
  24                                          2 + 2 + 2 + 1 + 1 + 1 +\
  25                                          1 + /* One cnr_source_server */\
  26                                          1 + /* nl4_type */ \
  27                                          1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
  28 #define decode_copy_maxsz               (op_decode_hdr_maxsz + \
  29                                          NFS42_WRITE_RES_SIZE + \
  30                                          1 /* cr_consecutive */ + \
  31                                          1 /* cr_synchronous */)
  32 #define encode_offload_cancel_maxsz     (op_encode_hdr_maxsz + \
  33                                          XDR_QUADLEN(NFS4_STATEID_SIZE))
  34 #define decode_offload_cancel_maxsz     (op_decode_hdr_maxsz)
  35 #define encode_copy_notify_maxsz        (op_encode_hdr_maxsz + \
  36                                          XDR_QUADLEN(NFS4_STATEID_SIZE) + \
  37                                          1 + /* nl4_type */ \
  38                                          1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
  39 #define decode_copy_notify_maxsz        (op_decode_hdr_maxsz + \
  40                                          3 + /* cnr_lease_time */\
  41                                          XDR_QUADLEN(NFS4_STATEID_SIZE) + \
  42                                          1 + /* Support 1 cnr_source_server */\
  43                                          1 + /* nl4_type */ \
  44                                          1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
  45 #define encode_deallocate_maxsz         (op_encode_hdr_maxsz + \
  46                                          encode_fallocate_maxsz)
  47 #define decode_deallocate_maxsz         (op_decode_hdr_maxsz)
  48 #define encode_read_plus_maxsz          (op_encode_hdr_maxsz + \
  49                                          encode_stateid_maxsz + 3)
  50 #define NFS42_READ_PLUS_SEGMENT_SIZE    (1 /* data_content4 */ + \
  51                                          2 /* data_info4.di_offset */ + \
  52                                          2 /* data_info4.di_length */)
  53 #define decode_read_plus_maxsz          (op_decode_hdr_maxsz + \
  54                                          1 /* rpr_eof */ + \
  55                                          1 /* rpr_contents count */ + \
  56                                          2 * NFS42_READ_PLUS_SEGMENT_SIZE)
  57 #define encode_seek_maxsz               (op_encode_hdr_maxsz + \
  58                                          encode_stateid_maxsz + \
  59                                          2 /* offset */ + \
  60                                          1 /* whence */)
  61 #define decode_seek_maxsz               (op_decode_hdr_maxsz + \
  62                                          1 /* eof */ + \
  63                                          1 /* whence */ + \
  64                                          2 /* offset */ + \
  65                                          2 /* length */)
  66 #define encode_io_info_maxsz            4
  67 #define encode_layoutstats_maxsz        (op_decode_hdr_maxsz + \
  68                                         2 /* offset */ + \
  69                                         2 /* length */ + \
  70                                         encode_stateid_maxsz + \
  71                                         encode_io_info_maxsz + \
  72                                         encode_io_info_maxsz + \
  73                                         1 /* opaque devaddr4 length */ + \
  74                                         XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
  75 #define decode_layoutstats_maxsz        (op_decode_hdr_maxsz)
  76 #define encode_device_error_maxsz       (XDR_QUADLEN(NFS4_DEVICEID4_SIZE) + \
  77                                         1 /* status */ + 1 /* opnum */)
  78 #define encode_layouterror_maxsz        (op_decode_hdr_maxsz + \
  79                                         2 /* offset */ + \
  80                                         2 /* length */ + \
  81                                         encode_stateid_maxsz + \
  82                                         1 /* Array size */ + \
  83                                         encode_device_error_maxsz)
  84 #define decode_layouterror_maxsz        (op_decode_hdr_maxsz)
  85 #define encode_clone_maxsz              (encode_stateid_maxsz + \
  86                                         encode_stateid_maxsz + \
  87                                         2 /* src offset */ + \
  88                                         2 /* dst offset */ + \
  89                                         2 /* count */)
  90 #define decode_clone_maxsz              (op_decode_hdr_maxsz)
  91
  92 #define NFS4_enc_allocate_sz            (compound_encode_hdr_maxsz + \
  93                                          encode_sequence_maxsz + \
  94                                          encode_putfh_maxsz + \
  95                                          encode_allocate_maxsz + \
  96                                          encode_getattr_maxsz)
  97 #define NFS4_dec_allocate_sz            (compound_decode_hdr_maxsz + \
  98                                          decode_sequence_maxsz + \
  99                                          decode_putfh_maxsz + \
 100                                          decode_allocate_maxsz + \
 101                                          decode_getattr_maxsz)
 102 #define NFS4_enc_copy_sz                (compound_encode_hdr_maxsz + \
 103                                          encode_sequence_maxsz + \
 104                                          encode_putfh_maxsz + \
 105                                          encode_savefh_maxsz + \
 106                                          encode_putfh_maxsz + \
 107                                          encode_copy_maxsz + \
 108                                          encode_commit_maxsz)
 109 #define NFS4_dec_copy_sz                (compound_decode_hdr_maxsz + \
 110                                          decode_sequence_maxsz + \
 111                                          decode_putfh_maxsz + \
 112                                          decode_savefh_maxsz + \
 113                                          decode_putfh_maxsz + \
 114                                          decode_copy_maxsz + \
 115                                          decode_commit_maxsz)
 116 #define NFS4_enc_offload_cancel_sz      (compound_encode_hdr_maxsz + \
 117                                          encode_sequence_maxsz + \
 118                                          encode_putfh_maxsz + \
 119                                          encode_offload_cancel_maxsz)
 120 #define NFS4_dec_offload_cancel_sz      (compound_decode_hdr_maxsz + \
 121                                          decode_sequence_maxsz + \
 122                                          decode_putfh_maxsz + \
 123                                          decode_offload_cancel_maxsz)
 124 #define NFS4_enc_copy_notify_sz         (compound_encode_hdr_maxsz + \
 125                                          encode_putfh_maxsz + \
 126                                          encode_copy_notify_maxsz)
 127 #define NFS4_dec_copy_notify_sz         (compound_decode_hdr_maxsz + \
 128                                          decode_putfh_maxsz + \
 129                                          decode_copy_notify_maxsz)
 130 #define NFS4_enc_deallocate_sz          (compound_encode_hdr_maxsz + \
 131                                          encode_sequence_maxsz + \
 132                                          encode_putfh_maxsz + \
 133                                          encode_deallocate_maxsz + \
 134                                          encode_getattr_maxsz)
 135 #define NFS4_dec_deallocate_sz          (compound_decode_hdr_maxsz + \
 136                                          decode_sequence_maxsz + \
 137                                          decode_putfh_maxsz + \
 138                                          decode_deallocate_maxsz + \
 139                                          decode_getattr_maxsz)
 140 #define NFS4_enc_read_plus_sz           (compound_encode_hdr_maxsz + \
 141                                          encode_sequence_maxsz + \
 142                                          encode_putfh_maxsz + \
 143                                          encode_read_plus_maxsz)
 144 #define NFS4_dec_read_plus_sz           (compound_decode_hdr_maxsz + \
 145                                          decode_sequence_maxsz + \
 146                                          decode_putfh_maxsz + \
 147                                          decode_read_plus_maxsz)
 148 #define NFS4_enc_seek_sz                (compound_encode_hdr_maxsz + \
 149                                          encode_sequence_maxsz + \
 150                                          encode_putfh_maxsz + \
 151                                          encode_seek_maxsz)
 152 #define NFS4_dec_seek_sz                (compound_decode_hdr_maxsz + \
 153                                          decode_sequence_maxsz + \
 154                                          decode_putfh_maxsz + \
 155                                          decode_seek_maxsz)
 156 #define NFS4_enc_layoutstats_sz         (compound_encode_hdr_maxsz + \
 157                                          encode_sequence_maxsz + \
 158                                          encode_putfh_maxsz + \
 159                                          PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
 160 #define NFS4_dec_layoutstats_sz         (compound_decode_hdr_maxsz + \
 161                                          decode_sequence_maxsz + \
 162                                          decode_putfh_maxsz + \
 163                                          PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
 164 #define NFS4_enc_layouterror_sz         (compound_encode_hdr_maxsz + \
 165                                          encode_sequence_maxsz + \
 166                                          encode_putfh_maxsz + \
 167                                          NFS42_LAYOUTERROR_MAX * \
 168                                          encode_layouterror_maxsz)
 169 #define NFS4_dec_layouterror_sz         (compound_decode_hdr_maxsz + \
 170                                          decode_sequence_maxsz + \
 171                                          decode_putfh_maxsz + \
 172                                          NFS42_LAYOUTERROR_MAX * \
 173                                          decode_layouterror_maxsz)
 174 #define NFS4_enc_clone_sz               (compound_encode_hdr_maxsz + \
 175                                          encode_sequence_maxsz + \
 176                                          encode_putfh_maxsz + \
 177                                          encode_savefh_maxsz + \
 178                                          encode_putfh_maxsz + \
 179                                          encode_clone_maxsz + \
 180                                          encode_getattr_maxsz)
 181 #define NFS4_dec_clone_sz               (compound_decode_hdr_maxsz + \
 182                                          decode_sequence_maxsz + \
 183                                          decode_putfh_maxsz + \
 184                                          decode_savefh_maxsz + \
 185                                          decode_putfh_maxsz + \
 186                                          decode_clone_maxsz + \
 187                                          decode_getattr_maxsz)
 188
 189 /* Not limited by NFS itself, limited by the generic xattr code */
 190 #define nfs4_xattr_name_maxsz   XDR_QUADLEN(XATTR_NAME_MAX)
 191
 192 #define encode_getxattr_maxsz   (op_encode_hdr_maxsz + 1 + \
 193                                  nfs4_xattr_name_maxsz)
 194 #define decode_getxattr_maxsz   (op_decode_hdr_maxsz + 1 + pagepad_maxsz)
 195 #define encode_setxattr_maxsz   (op_encode_hdr_maxsz + \
 196                                  1 + nfs4_xattr_name_maxsz + 1)
 197 #define decode_setxattr_maxsz   (op_decode_hdr_maxsz + decode_change_info_maxsz)
 198 #define encode_listxattrs_maxsz  (op_encode_hdr_maxsz + 2 + 1)
 199 #define decode_listxattrs_maxsz  (op_decode_hdr_maxsz + 2 + 1 + 1 + 1)
 200 #define encode_removexattr_maxsz (op_encode_hdr_maxsz + 1 + \
 201                                   nfs4_xattr_name_maxsz)
 202 #define decode_removexattr_maxsz (op_decode_hdr_maxsz + \
 203                                   decode_change_info_maxsz)
 204
 205 #define NFS4_enc_getxattr_sz    (compound_encode_hdr_maxsz + \
 206                                 encode_sequence_maxsz + \
 207                                 encode_putfh_maxsz + \
 208                                 encode_getxattr_maxsz)
 209 #define NFS4_dec_getxattr_sz    (compound_decode_hdr_maxsz + \
 210                                 decode_sequence_maxsz + \
 211                                 decode_putfh_maxsz + \
 212                                 decode_getxattr_maxsz)
 213 #define NFS4_enc_setxattr_sz    (compound_encode_hdr_maxsz + \
 214                                 encode_sequence_maxsz + \
 215                                 encode_putfh_maxsz + \
 216                                 encode_setxattr_maxsz)
 217 #define NFS4_dec_setxattr_sz    (compound_decode_hdr_maxsz + \
 218                                 decode_sequence_maxsz + \
 219                                 decode_putfh_maxsz + \
 220                                 decode_setxattr_maxsz)
 221 #define NFS4_enc_listxattrs_sz  (compound_encode_hdr_maxsz + \
 222                                 encode_sequence_maxsz + \
 223                                 encode_putfh_maxsz + \
 224                                 encode_listxattrs_maxsz)
 225 #define NFS4_dec_listxattrs_sz  (compound_decode_hdr_maxsz + \
 226                                 decode_sequence_maxsz + \
 227                                 decode_putfh_maxsz + \
 228                                 decode_listxattrs_maxsz)
 229 #define NFS4_enc_removexattr_sz (compound_encode_hdr_maxsz + \
 230                                 encode_sequence_maxsz + \
 231                                 encode_putfh_maxsz + \
 232                                 encode_removexattr_maxsz)
 233 #define NFS4_dec_removexattr_sz (compound_decode_hdr_maxsz + \
 234                                 decode_sequence_maxsz + \
 235                                 decode_putfh_maxsz + \
 236                                 decode_removexattr_maxsz)
 237
 238 /*
 239  * These values specify the maximum amount of data that is not
 240  * associated with the extended attribute name or extended
 241  * attribute list in the SETXATTR, GETXATTR and LISTXATTR
 242  * respectively.
 243  */
 244 const u32 nfs42_maxsetxattr_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
 245                                         compound_encode_hdr_maxsz +
 246                                         encode_sequence_maxsz +
 247                                         encode_putfh_maxsz + 1 +
 248                                         nfs4_xattr_name_maxsz)
 249                                         * XDR_UNIT);
 250
 251 const u32 nfs42_maxgetxattr_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
 252                                         compound_decode_hdr_maxsz +
 253                                         decode_sequence_maxsz +
 254                                         decode_putfh_maxsz + 1) * XDR_UNIT);
 255
 256 const u32 nfs42_maxlistxattrs_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
 257                                         compound_decode_hdr_maxsz +
 258                                         decode_sequence_maxsz +
 259                                         decode_putfh_maxsz + 3) * XDR_UNIT);
 260
 261 static void encode_fallocate(struct xdr_stream *xdr,
 262                              const struct nfs42_falloc_args *args)
 263 {
 264         encode_nfs4_stateid(xdr, &args->falloc_stateid);
 265         encode_uint64(xdr, args->falloc_offset);
 266         encode_uint64(xdr, args->falloc_length);
 267 }
 268
 269 static void encode_allocate(struct xdr_stream *xdr,
 270                             const struct nfs42_falloc_args *args,
 271                             struct compound_hdr *hdr)
 272 {
 273         encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
 274         encode_fallocate(xdr, args);
 275 }
 276
 277 static void encode_nl4_server(struct xdr_stream *xdr,
 278                               const struct nl4_server *ns)
 279 {
 280         encode_uint32(xdr, ns->nl4_type);
 281         switch (ns->nl4_type) {
 282         case NL4_NAME:
 283         case NL4_URL:
 284                 encode_string(xdr, ns->u.nl4_str_sz, ns->u.nl4_str);
 285                 break;
 286         case NL4_NETADDR:
 287                 encode_string(xdr, ns->u.nl4_addr.netid_len,
 288                               ns->u.nl4_addr.netid);
 289                 encode_string(xdr, ns->u.nl4_addr.addr_len,
 290                               ns->u.nl4_addr.addr);
 291                 break;
 292         default:
 293                 WARN_ON_ONCE(1);
 294         }
 295 }
 296
 297 static void encode_copy(struct xdr_stream *xdr,
 298                         const struct nfs42_copy_args *args,
 299                         struct compound_hdr *hdr)
 300 {
 301         encode_op_hdr(xdr, OP_COPY, decode_copy_maxsz, hdr);
 302         encode_nfs4_stateid(xdr, &args->src_stateid);
 303         encode_nfs4_stateid(xdr, &args->dst_stateid);
 304
 305         encode_uint64(xdr, args->src_pos);
 306         encode_uint64(xdr, args->dst_pos);
 307         encode_uint64(xdr, args->count);
 308
 309         encode_uint32(xdr, 1); /* consecutive = true */
 310         encode_uint32(xdr, args->sync);
 311         if (args->cp_src == NULL) { /* intra-ssc */
 312                 encode_uint32(xdr, 0); /* no src server list */
 313                 return;
 314         }
 315         encode_uint32(xdr, 1); /* supporting 1 server */
 316         encode_nl4_server(xdr, args->cp_src);
 317 }
 318
 319 static void encode_offload_cancel(struct xdr_stream *xdr,
 320                                   const struct nfs42_offload_status_args *args,
 321                                   struct compound_hdr *hdr)
 322 {
 323         encode_op_hdr(xdr, OP_OFFLOAD_CANCEL, decode_offload_cancel_maxsz, hdr);
 324         encode_nfs4_stateid(xdr, &args->osa_stateid);
 325 }
 326
 327 static void encode_copy_notify(struct xdr_stream *xdr,
 328                                const struct nfs42_copy_notify_args *args,
 329                                struct compound_hdr *hdr)
 330 {
 331         encode_op_hdr(xdr, OP_COPY_NOTIFY, decode_copy_notify_maxsz, hdr);
 332         encode_nfs4_stateid(xdr, &args->cna_src_stateid);
 333         encode_nl4_server(xdr, &args->cna_dst);
 334 }
 335
 336 static void encode_deallocate(struct xdr_stream *xdr,
 337                               const struct nfs42_falloc_args *args,
 338                               struct compound_hdr *hdr)
 339 {
 340         encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
 341         encode_fallocate(xdr, args);
 342 }
 343
 344 static void encode_read_plus(struct xdr_stream *xdr,
 345                              const struct nfs_pgio_args *args,
 346                              struct compound_hdr *hdr)
 347 {
 348         encode_op_hdr(xdr, OP_READ_PLUS, decode_read_plus_maxsz, hdr);
 349         encode_nfs4_stateid(xdr, &args->stateid);
 350         encode_uint64(xdr, args->offset);
 351         encode_uint32(xdr, args->count);
 352 }
 353
 354 static void encode_seek(struct xdr_stream *xdr,
 355                         const struct nfs42_seek_args *args,
 356                         struct compound_hdr *hdr)
 357 {
 358         encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
 359         encode_nfs4_stateid(xdr, &args->sa_stateid);
 360         encode_uint64(xdr, args->sa_offset);
 361         encode_uint32(xdr, args->sa_what);
 362 }
 363
 364 static void encode_layoutstats(struct xdr_stream *xdr,
 365                                const struct nfs42_layoutstat_args *args,
 366                                struct nfs42_layoutstat_devinfo *devinfo,
 367                                struct compound_hdr *hdr)
 368 {
 369         __be32 *p;
 370
 371         encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
 372         p = reserve_space(xdr, 8 + 8);
 373         p = xdr_encode_hyper(p, devinfo->offset);
 374         p = xdr_encode_hyper(p, devinfo->length);
 375         encode_nfs4_stateid(xdr, &args->stateid);
 376         p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
 377         p = xdr_encode_hyper(p, devinfo->read_count);
 378         p = xdr_encode_hyper(p, devinfo->read_bytes);
 379         p = xdr_encode_hyper(p, devinfo->write_count);
 380         p = xdr_encode_hyper(p, devinfo->write_bytes);
 381         p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
 382                         NFS4_DEVICEID4_SIZE);
 383         /* Encode layoutupdate4 */
 384         *p++ = cpu_to_be32(devinfo->layout_type);
 385         if (devinfo->ld_private.ops)
 386                 devinfo->ld_private.ops->encode(xdr, args,
 387                                 &devinfo->ld_private);
 388         else
 389                 encode_uint32(xdr, 0);
 390 }
 391
 392 static void encode_clone(struct xdr_stream *xdr,
 393                          const struct nfs42_clone_args *args,
 394                          struct compound_hdr *hdr)
 395 {
 396         __be32 *p;
 397
 398         encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
 399         encode_nfs4_stateid(xdr, &args->src_stateid);
 400         encode_nfs4_stateid(xdr, &args->dst_stateid);
 401         p = reserve_space(xdr, 3*8);
 402         p = xdr_encode_hyper(p, args->src_offset);
 403         p = xdr_encode_hyper(p, args->dst_offset);
 404         xdr_encode_hyper(p, args->count);
 405 }
 406
 407 static void encode_device_error(struct xdr_stream *xdr,
 408                                 const struct nfs42_device_error *error)
 409 {
 410         __be32 *p;
 411
 412         p = reserve_space(xdr, NFS4_DEVICEID4_SIZE + 2*4);
 413         p = xdr_encode_opaque_fixed(p, error->dev_id.data,
 414                         NFS4_DEVICEID4_SIZE);
 415         *p++ = cpu_to_be32(error->status);
 416         *p = cpu_to_be32(error->opnum);
 417 }
 418
 419 static void encode_layouterror(struct xdr_stream *xdr,
 420                                const struct nfs42_layout_error *args,
 421                                struct compound_hdr *hdr)
 422 {
 423         __be32 *p;
 424
 425         encode_op_hdr(xdr, OP_LAYOUTERROR, decode_layouterror_maxsz, hdr);
 426         p = reserve_space(xdr, 8 + 8);
 427         p = xdr_encode_hyper(p, args->offset);
 428         p = xdr_encode_hyper(p, args->length);
 429         encode_nfs4_stateid(xdr, &args->stateid);
 430         p = reserve_space(xdr, 4);
 431         *p = cpu_to_be32(1);
 432         encode_device_error(xdr, &args->errors[0]);
 433 }
 434
 435 static void encode_setxattr(struct xdr_stream *xdr,
 436                             const struct nfs42_setxattrargs *arg,
 437                             struct compound_hdr *hdr)
 438 {
 439         __be32 *p;
 440
 441         BUILD_BUG_ON(XATTR_CREATE != SETXATTR4_CREATE);
 442         BUILD_BUG_ON(XATTR_REPLACE != SETXATTR4_REPLACE);
 443
 444         encode_op_hdr(xdr, OP_SETXATTR, decode_setxattr_maxsz, hdr);
 445         p = reserve_space(xdr, 4);
 446         *p = cpu_to_be32(arg->xattr_flags);
 447         encode_string(xdr, strlen(arg->xattr_name), arg->xattr_name);
 448         p = reserve_space(xdr, 4);
 449         *p = cpu_to_be32(arg->xattr_len);
 450         if (arg->xattr_len)
 451                 xdr_write_pages(xdr, arg->xattr_pages, 0, arg->xattr_len);
 452 }
 453
 454 static int decode_setxattr(struct xdr_stream *xdr,
 455                            struct nfs4_change_info *cinfo)
 456 {
 457         int status;
 458
 459         status = decode_op_hdr(xdr, OP_SETXATTR);
 460         if (status)
 461                 goto out;
 462         status = decode_change_info(xdr, cinfo);
 463 out:
 464         return status;
 465 }
 466
 467
 468 static void encode_getxattr(struct xdr_stream *xdr, const char *name,
 469                             struct compound_hdr *hdr)
 470 {
 471         encode_op_hdr(xdr, OP_GETXATTR, decode_getxattr_maxsz, hdr);
 472         encode_string(xdr, strlen(name), name);
 473 }
 474
 475 static int decode_getxattr(struct xdr_stream *xdr,
 476                            struct nfs42_getxattrres *res,
 477                            struct rpc_rqst *req)
 478 {
 479         int status;
 480         __be32 *p;
 481         u32 len, rdlen;
 482
 483         status = decode_op_hdr(xdr, OP_GETXATTR);
 484         if (status)
 485                 return status;
 486
 487         p = xdr_inline_decode(xdr, 4);
 488         if (unlikely(!p))
 489                 return -EIO;
 490
 491         len = be32_to_cpup(p);
 492
 493         /*
 494          * Only check against the page length here. The actual
 495          * requested length may be smaller, but that is only
 496          * checked against after possibly caching a valid reply.
 497          */
 498         if (len > req->rq_rcv_buf.page_len)
 499                 return -ERANGE;
 500
 501         res->xattr_len = len;
 502
 503         if (len > 0) {
 504                 rdlen = xdr_read_pages(xdr, len);
 505                 if (rdlen < len)
 506                         return -EIO;
 507         }
 508
 509         return 0;
 510 }
 511
 512 static void encode_removexattr(struct xdr_stream *xdr, const char *name,
 513                                struct compound_hdr *hdr)
 514 {
 515         encode_op_hdr(xdr, OP_REMOVEXATTR, decode_removexattr_maxsz, hdr);
 516         encode_string(xdr, strlen(name), name);
 517 }
 518
 519
 520 static int decode_removexattr(struct xdr_stream *xdr,
 521                            struct nfs4_change_info *cinfo)
 522 {
 523         int status;
 524
 525         status = decode_op_hdr(xdr, OP_REMOVEXATTR);
 526         if (status)
 527                 goto out;
 528
 529         status = decode_change_info(xdr, cinfo);
 530 out:
 531         return status;
 532 }
 533
 534 static void encode_listxattrs(struct xdr_stream *xdr,
 535                              const struct nfs42_listxattrsargs *arg,
 536                              struct compound_hdr *hdr)
 537 {
 538         __be32 *p;
 539
 540         encode_op_hdr(xdr, OP_LISTXATTRS, decode_listxattrs_maxsz, hdr);
 541
 542         p = reserve_space(xdr, 12);
 543         if (unlikely(!p))
 544                 return;
 545
 546         p = xdr_encode_hyper(p, arg->cookie);
 547         /*
 548          * RFC 8276 says to specify the full max length of the LISTXATTRS
 549          * XDR reply. Count is set to the XDR length of the names array
 550          * plus the EOF marker. So, add the cookie and the names count.
 551          */
 552         *p = cpu_to_be32(arg->count + 8 + 4);
 553 }
 554
 555 static int decode_listxattrs(struct xdr_stream *xdr,
 556                             struct nfs42_listxattrsres *res)
 557 {
 558         int status;
 559         __be32 *p;
 560         u32 count, len, ulen;
 561         size_t left, copied;
 562         char *buf;
 563
 564         status = decode_op_hdr(xdr, OP_LISTXATTRS);
 565         if (status) {
 566                 /*
 567                  * Special case: for LISTXATTRS, NFS4ERR_TOOSMALL
 568                  * should be translated to ERANGE.
 569                  */
 570                 if (status == -ETOOSMALL)
 571                         status = -ERANGE;
 572                 goto out;
 573         }
 574
 575         p = xdr_inline_decode(xdr, 8);
 576         if (unlikely(!p))
 577                 return -EIO;
 578
 579         xdr_decode_hyper(p, &res->cookie);
 580
 581         p = xdr_inline_decode(xdr, 4);
 582         if (unlikely(!p))
 583                 return -EIO;
 584
 585         left = res->xattr_len;
 586         buf = res->xattr_buf;
 587
 588         count = be32_to_cpup(p);
 589         copied = 0;
 590
 591         /*
 592          * We have asked for enough room to encode the maximum number
 593          * of possible attribute names, so everything should fit.
 594          *
 595          * But, don't rely on that assumption. Just decode entries
 596          * until they don't fit anymore, just in case the server did
 597          * something odd.
 598          */
 599         while (count--) {
 600                 p = xdr_inline_decode(xdr, 4);
 601                 if (unlikely(!p))
 602                         return -EIO;
 603
 604                 len = be32_to_cpup(p);
 605                 if (len > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) {
 606                         status = -ERANGE;
 607                         goto out;
 608                 }
 609
 610                 p = xdr_inline_decode(xdr, len);
 611                 if (unlikely(!p))
 612                         return -EIO;
 613
 614                 ulen = len + XATTR_USER_PREFIX_LEN + 1;
 615                 if (buf) {
 616                         if (ulen > left) {
 617                                 status = -ERANGE;
 618                                 goto out;
 619                         }
 620
 621                         memcpy(buf, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
 622                         memcpy(buf + XATTR_USER_PREFIX_LEN, p, len);
 623
 624                         buf[ulen - 1] = 0;
 625                         buf += ulen;
 626                         left -= ulen;
 627                 }
 628                 copied += ulen;
 629         }
 630
 631         p = xdr_inline_decode(xdr, 4);
 632         if (unlikely(!p))
 633                 return -EIO;
 634
 635         res->eof = be32_to_cpup(p);
 636         res->copied = copied;
 637
 638 out:
 639         if (status == -ERANGE && res->xattr_len == XATTR_LIST_MAX)
 640                 status = -E2BIG;
 641
 642         return status;
 643 }
 644
 645 /*
 646  * Encode ALLOCATE request
 647  */
 648 static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
 649                                   struct xdr_stream *xdr,
 650                                   const void *data)
 651 {
 652         const struct nfs42_falloc_args *args = data;
 653         struct compound_hdr hdr = {
 654                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 655         };
 656
 657         encode_compound_hdr(xdr, req, &hdr);
 658         encode_sequence(xdr, &args->seq_args, &hdr);
 659         encode_putfh(xdr, args->falloc_fh, &hdr);
 660         encode_allocate(xdr, args, &hdr);
 661         encode_getfattr(xdr, args->falloc_bitmask, &hdr);
 662         encode_nops(&hdr);
 663 }
 664
 665 static void encode_copy_commit(struct xdr_stream *xdr,
 666                           const struct nfs42_copy_args *args,
 667                           struct compound_hdr *hdr)
 668 {
 669         __be32 *p;
 670
 671         encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
 672         p = reserve_space(xdr, 12);
 673         p = xdr_encode_hyper(p, args->dst_pos);
 674         *p = cpu_to_be32(args->count);
 675 }
 676
 677 /*
 678  * Encode COPY request
 679  */
 680 static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
 681                               struct xdr_stream *xdr,
 682                               const void *data)
 683 {
 684         const struct nfs42_copy_args *args = data;
 685         struct compound_hdr hdr = {
 686                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 687         };
 688
 689         encode_compound_hdr(xdr, req, &hdr);
 690         encode_sequence(xdr, &args->seq_args, &hdr);
 691         encode_putfh(xdr, args->src_fh, &hdr);
 692         encode_savefh(xdr, &hdr);
 693         encode_putfh(xdr, args->dst_fh, &hdr);
 694         encode_copy(xdr, args, &hdr);
 695         if (args->sync)
 696                 encode_copy_commit(xdr, args, &hdr);
 697         encode_nops(&hdr);
 698 }
 699
 700 /*
 701  * Encode OFFLOAD_CANEL request
 702  */
 703 static void nfs4_xdr_enc_offload_cancel(struct rpc_rqst *req,
 704                                         struct xdr_stream *xdr,
 705                                         const void *data)
 706 {
 707         const struct nfs42_offload_status_args *args = data;
 708         struct compound_hdr hdr = {
 709                 .minorversion = nfs4_xdr_minorversion(&args->osa_seq_args),
 710         };
 711
 712         encode_compound_hdr(xdr, req, &hdr);
 713         encode_sequence(xdr, &args->osa_seq_args, &hdr);
 714         encode_putfh(xdr, args->osa_src_fh, &hdr);
 715         encode_offload_cancel(xdr, args, &hdr);
 716         encode_nops(&hdr);
 717 }
 718
 719 /*
 720  * Encode COPY_NOTIFY request
 721  */
 722 static void nfs4_xdr_enc_copy_notify(struct rpc_rqst *req,
 723                                      struct xdr_stream *xdr,
 724                                      const void *data)
 725 {
 726         const struct nfs42_copy_notify_args *args = data;
 727         struct compound_hdr hdr = {
 728                 .minorversion = nfs4_xdr_minorversion(&args->cna_seq_args),
 729         };
 730
 731         encode_compound_hdr(xdr, req, &hdr);
 732         encode_sequence(xdr, &args->cna_seq_args, &hdr);
 733         encode_putfh(xdr, args->cna_src_fh, &hdr);
 734         encode_copy_notify(xdr, args, &hdr);
 735         encode_nops(&hdr);
 736 }
 737
 738 /*
 739  * Encode DEALLOCATE request
 740  */
 741 static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
 742                                     struct xdr_stream *xdr,
 743                                     const void *data)
 744 {
 745         const struct nfs42_falloc_args *args = data;
 746         struct compound_hdr hdr = {
 747                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 748         };
 749
 750         encode_compound_hdr(xdr, req, &hdr);
 751         encode_sequence(xdr, &args->seq_args, &hdr);
 752         encode_putfh(xdr, args->falloc_fh, &hdr);
 753         encode_deallocate(xdr, args, &hdr);
 754         encode_getfattr(xdr, args->falloc_bitmask, &hdr);
 755         encode_nops(&hdr);
 756 }
 757
 758 /*
 759  * Encode READ_PLUS request
 760  */
 761 static void nfs4_xdr_enc_read_plus(struct rpc_rqst *req,
 762                                    struct xdr_stream *xdr,
 763                                    const void *data)
 764 {
 765         const struct nfs_pgio_args *args = data;
 766         struct compound_hdr hdr = {
 767                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 768         };
 769
 770         encode_compound_hdr(xdr, req, &hdr);
 771         encode_sequence(xdr, &args->seq_args, &hdr);
 772         encode_putfh(xdr, args->fh, &hdr);
 773         encode_read_plus(xdr, args, &hdr);
 774
 775         rpc_prepare_reply_pages(req, args->pages, args->pgbase,
 776                                 args->count, hdr.replen);
 777         encode_nops(&hdr);
 778 }
 779
 780 /*
 781  * Encode SEEK request
 782  */
 783 static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
 784                               struct xdr_stream *xdr,
 785                               const void *data)
 786 {
 787         const struct nfs42_seek_args *args = data;
 788         struct compound_hdr hdr = {
 789                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 790         };
 791
 792         encode_compound_hdr(xdr, req, &hdr);
 793         encode_sequence(xdr, &args->seq_args, &hdr);
 794         encode_putfh(xdr, args->sa_fh, &hdr);
 795         encode_seek(xdr, args, &hdr);
 796         encode_nops(&hdr);
 797 }
 798
 799 /*
 800  * Encode LAYOUTSTATS request
 801  */
 802 static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
 803                                      struct xdr_stream *xdr,
 804                                      const void *data)
 805 {
 806         const struct nfs42_layoutstat_args *args = data;
 807         int i;
 808
 809         struct compound_hdr hdr = {
 810                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 811         };
 812
 813         encode_compound_hdr(xdr, req, &hdr);
 814         encode_sequence(xdr, &args->seq_args, &hdr);
 815         encode_putfh(xdr, args->fh, &hdr);
 816         WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
 817         for (i = 0; i < args->num_dev; i++)
 818                 encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
 819         encode_nops(&hdr);
 820 }
 821
 822 /*
 823  * Encode CLONE request
 824  */
 825 static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
 826                                struct xdr_stream *xdr,
 827                                const void *data)
 828 {
 829         const struct nfs42_clone_args *args = data;
 830         struct compound_hdr hdr = {
 831                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 832         };
 833
 834         encode_compound_hdr(xdr, req, &hdr);
 835         encode_sequence(xdr, &args->seq_args, &hdr);
 836         encode_putfh(xdr, args->src_fh, &hdr);
 837         encode_savefh(xdr, &hdr);
 838         encode_putfh(xdr, args->dst_fh, &hdr);
 839         encode_clone(xdr, args, &hdr);
 840         encode_getfattr(xdr, args->dst_bitmask, &hdr);
 841         encode_nops(&hdr);
 842 }
 843
 844 /*
 845  * Encode LAYOUTERROR request
 846  */
 847 static void nfs4_xdr_enc_layouterror(struct rpc_rqst *req,
 848                                      struct xdr_stream *xdr,
 849                                      const void *data)
 850 {
 851         const struct nfs42_layouterror_args *args = data;
 852         struct compound_hdr hdr = {
 853                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
 854         };
 855         int i;
 856
 857         encode_compound_hdr(xdr, req, &hdr);
 858         encode_sequence(xdr, &args->seq_args, &hdr);
 859         encode_putfh(xdr, NFS_FH(args->inode), &hdr);
 860         for (i = 0; i < args->num_errors; i++)
 861                 encode_layouterror(xdr, &args->errors[i], &hdr);
 862         encode_nops(&hdr);
 863 }
 864
 865 static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
 866 {
 867         return decode_op_hdr(xdr, OP_ALLOCATE);
 868 }
 869
 870 static int decode_write_response(struct xdr_stream *xdr,
 871                                  struct nfs42_write_res *res)
 872 {
 873         __be32 *p;
 874         int status, count;
 875
 876         p = xdr_inline_decode(xdr, 4);
 877         if (unlikely(!p))
 878                 return -EIO;
 879         count = be32_to_cpup(p);
 880         if (count > 1)
 881                 return -EREMOTEIO;
 882         else if (count == 1) {
 883                 status = decode_opaque_fixed(xdr, &res->stateid,
 884                                 NFS4_STATEID_SIZE);
 885                 if (unlikely(status))
 886                         return -EIO;
 887         }
 888         p = xdr_inline_decode(xdr, 8 + 4);
 889         if (unlikely(!p))
 890                 return -EIO;
 891         p = xdr_decode_hyper(p, &res->count);
 892         res->verifier.committed = be32_to_cpup(p);
 893         return decode_verifier(xdr, &res->verifier.verifier);
 894 }
 895
 896 static int decode_nl4_server(struct xdr_stream *xdr, struct nl4_server *ns)
 897 {
 898         struct nfs42_netaddr *naddr;
 899         uint32_t dummy;
 900         char *dummy_str;
 901         __be32 *p;
 902         int status;
 903
 904         /* nl_type */
 905         p = xdr_inline_decode(xdr, 4);
 906         if (unlikely(!p))
 907                 return -EIO;
 908         ns->nl4_type = be32_to_cpup(p);
 909         switch (ns->nl4_type) {
 910         case NL4_NAME:
 911         case NL4_URL:
 912                 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
 913                 if (unlikely(status))
 914                         return status;
 915                 if (unlikely(dummy > NFS4_OPAQUE_LIMIT))
 916                         return -EIO;
 917                 memcpy(&ns->u.nl4_str, dummy_str, dummy);
 918                 ns->u.nl4_str_sz = dummy;
 919                 break;
 920         case NL4_NETADDR:
 921                 naddr = &ns->u.nl4_addr;
 922
 923                 /* netid string */
 924                 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
 925                 if (unlikely(status))
 926                         return status;
 927                 if (unlikely(dummy > RPCBIND_MAXNETIDLEN))
 928                         return -EIO;
 929                 naddr->netid_len = dummy;
 930                 memcpy(naddr->netid, dummy_str, naddr->netid_len);
 931
 932                 /* uaddr string */
 933                 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
 934                 if (unlikely(status))
 935                         return status;
 936                 if (unlikely(dummy > RPCBIND_MAXUADDRLEN))
 937                         return -EIO;
 938                 naddr->addr_len = dummy;
 939                 memcpy(naddr->addr, dummy_str, naddr->addr_len);
 940                 break;
 941         default:
 942                 WARN_ON_ONCE(1);
 943                 return -EIO;
 944         }
 945         return 0;
 946 }
 947
 948 static int decode_copy_requirements(struct xdr_stream *xdr,
 949                                     struct nfs42_copy_res *res) {
 950         __be32 *p;
 951
 952         p = xdr_inline_decode(xdr, 4 + 4);
 953         if (unlikely(!p))
 954                 return -EIO;
 955
 956         res->consecutive = be32_to_cpup(p++);
 957         res->synchronous = be32_to_cpup(p++);
 958         return 0;
 959 }
 960
 961 static int decode_copy(struct xdr_stream *xdr, struct nfs42_copy_res *res)
 962 {
 963         int status;
 964
 965         status = decode_op_hdr(xdr, OP_COPY);
 966         if (status == NFS4ERR_OFFLOAD_NO_REQS) {
 967                 status = decode_copy_requirements(xdr, res);
 968                 if (status)
 969                         return status;
 970                 return NFS4ERR_OFFLOAD_NO_REQS;
 971         } else if (status)
 972                 return status;
 973
 974         status = decode_write_response(xdr, &res->write_res);
 975         if (status)
 976                 return status;
 977
 978         return decode_copy_requirements(xdr, res);
 979 }
 980
 981 static int decode_offload_cancel(struct xdr_stream *xdr,
 982                                  struct nfs42_offload_status_res *res)
 983 {
 984         return decode_op_hdr(xdr, OP_OFFLOAD_CANCEL);
 985 }
 986
 987 static int decode_copy_notify(struct xdr_stream *xdr,
 988                               struct nfs42_copy_notify_res *res)
 989 {
 990         __be32 *p;
 991         int status, count;
 992
 993         status = decode_op_hdr(xdr, OP_COPY_NOTIFY);
 994         if (status)
 995                 return status;
 996         /* cnr_lease_time */
 997         p = xdr_inline_decode(xdr, 12);
 998         if (unlikely(!p))
 999                 return -EIO;
1000         p = xdr_decode_hyper(p, &res->cnr_lease_time.seconds);
1001         res->cnr_lease_time.nseconds = be32_to_cpup(p);
1002
1003         status = decode_opaque_fixed(xdr, &res->cnr_stateid, NFS4_STATEID_SIZE);
1004         if (unlikely(status))
1005                 return -EIO;
1006
1007         /* number of source addresses */
1008         p = xdr_inline_decode(xdr, 4);
1009         if (unlikely(!p))
1010                 return -EIO;
1011
1012         count = be32_to_cpup(p);
1013         if (count > 1)
1014                 pr_warn("NFS: %s: nsvr %d > Supported. Use first servers\n",
1015                          __func__, count);
1016
1017         status = decode_nl4_server(xdr, &res->cnr_src);
1018         if (unlikely(status))
1019                 return -EIO;
1020         return 0;
1021 }
1022
1023 static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
1024 {
1025         return decode_op_hdr(xdr, OP_DEALLOCATE);
1026 }
1027
1028 static int decode_read_plus_data(struct xdr_stream *xdr,
1029                                  struct nfs_pgio_args *args,
1030                                  struct nfs_pgio_res *res)
1031 {
1032         uint32_t count, recvd;
1033         uint64_t offset;
1034         __be32 *p;
1035
1036         p = xdr_inline_decode(xdr, 8 + 4);
1037         if (!p)
1038                 return 1;
1039
1040         p = xdr_decode_hyper(p, &offset);
1041         count = be32_to_cpup(p);
1042         recvd = xdr_align_data(xdr, res->count, xdr_align_size(count));
1043         if (recvd > count)
1044                 recvd = count;
1045         if (res->count + recvd > args->count) {
1046                 if (args->count > res->count)
1047                         res->count += args->count - res->count;
1048                 return 1;
1049         }
1050         res->count += recvd;
1051         if (count > recvd)
1052                 return 1;
1053         return 0;
1054 }
1055
1056 static int decode_read_plus_hole(struct xdr_stream *xdr,
1057                                  struct nfs_pgio_args *args,
1058                                  struct nfs_pgio_res *res, uint32_t *eof)
1059 {
1060         uint64_t offset, length, recvd;
1061         __be32 *p;
1062
1063         p = xdr_inline_decode(xdr, 8 + 8);
1064         if (!p)
1065                 return 1;
1066
1067         p = xdr_decode_hyper(p, &offset);
1068         p = xdr_decode_hyper(p, &length);
1069         if (offset != args->offset + res->count) {
1070                 /* Server returned an out-of-sequence extent */
1071                 if (offset > args->offset + res->count ||
1072                     offset + length < args->offset + res->count) {
1073                         dprintk("NFS: server returned out of sequence extent: "
1074                                 "offset/size = %llu/%llu != expected %llu\n",
1075                                 (unsigned long long)offset,
1076                                 (unsigned long long)length,
1077                                 (unsigned long long)(args->offset +
1078                                                      res->count));
1079                         return 1;
1080                 }
1081                 length -= args->offset + res->count - offset;
1082         }
1083         if (length + res->count > args->count) {
1084                 *eof = 0;
1085                 if (unlikely(res->count >= args->count))
1086                         return 1;
1087                 length = args->count - res->count;
1088         }
1089         recvd = xdr_expand_hole(xdr, res->count, length);
1090         res->count += recvd;
1091
1092         if (recvd < length)
1093                 return 1;
1094         return 0;
1095 }
1096
1097 static int decode_read_plus(struct xdr_stream *xdr, struct nfs_pgio_res *res)
1098 {
1099         struct nfs_pgio_header *hdr =
1100                 container_of(res, struct nfs_pgio_header, res);
1101         struct nfs_pgio_args *args = &hdr->args;
1102         uint32_t eof, segments, type;
1103         int status, i;
1104         __be32 *p;
1105
1106         status = decode_op_hdr(xdr, OP_READ_PLUS);
1107         if (status)
1108                 return status;
1109
1110         p = xdr_inline_decode(xdr, 4 + 4);
1111         if (unlikely(!p))
1112                 return -EIO;
1113
1114         res->count = 0;
1115         eof = be32_to_cpup(p++);
1116         segments = be32_to_cpup(p++);
1117         if (segments == 0)
1118                 goto out;
1119
1120         for (i = 0; i < segments; i++) {
1121                 p = xdr_inline_decode(xdr, 4);
1122                 if (!p)
1123                         goto early_out;
1124
1125                 type = be32_to_cpup(p++);
1126                 if (type == NFS4_CONTENT_DATA)
1127                         status = decode_read_plus_data(xdr, args, res);
1128                 else if (type == NFS4_CONTENT_HOLE)
1129                         status = decode_read_plus_hole(xdr, args, res, &eof);
1130                 else
1131                         return -EINVAL;
1132
1133                 if (status < 0)
1134                         return status;
1135                 if (status > 0)
1136                         goto early_out;
1137         }
1138
1139 out:
1140         res->eof = eof;
1141         return 0;
1142 early_out:
1143         if (unlikely(!i))
1144                 return -EIO;
1145         res->eof = 0;
1146         return 0;
1147 }
1148
1149 static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
1150 {
1151         int status;
1152         __be32 *p;
1153
1154         status = decode_op_hdr(xdr, OP_SEEK);
1155         if (status)
1156                 return status;
1157
1158         p = xdr_inline_decode(xdr, 4 + 8);
1159         if (unlikely(!p))
1160                 return -EIO;
1161
1162         res->sr_eof = be32_to_cpup(p++);
1163         p = xdr_decode_hyper(p, &res->sr_offset);
1164         return 0;
1165 }
1166
1167 static int decode_layoutstats(struct xdr_stream *xdr)
1168 {
1169         return decode_op_hdr(xdr, OP_LAYOUTSTATS);
1170 }
1171
1172 static int decode_clone(struct xdr_stream *xdr)
1173 {
1174         return decode_op_hdr(xdr, OP_CLONE);
1175 }
1176
1177 static int decode_layouterror(struct xdr_stream *xdr)
1178 {
1179         return decode_op_hdr(xdr, OP_LAYOUTERROR);
1180 }
1181
1182 /*
1183  * Decode ALLOCATE request
1184  */
1185 static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
1186                                  struct xdr_stream *xdr,
1187                                  void *data)
1188 {
1189         struct nfs42_falloc_res *res = data;
1190         struct compound_hdr hdr;
1191         int status;
1192
1193         status = decode_compound_hdr(xdr, &hdr);
1194         if (status)
1195                 goto out;
1196         status = decode_sequence(xdr, &res->seq_res, rqstp);
1197         if (status)
1198                 goto out;
1199         status = decode_putfh(xdr);
1200         if (status)
1201                 goto out;
1202         status = decode_allocate(xdr, res);
1203         if (status)
1204                 goto out;
1205         decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
1206 out:
1207         return status;
1208 }
1209
1210 /*
1211  * Decode COPY response
1212  */
1213 static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp,
1214                              struct xdr_stream *xdr,
1215                              void *data)
1216 {
1217         struct nfs42_copy_res *res = data;
1218         struct compound_hdr hdr;
1219         int status;
1220
1221         status = decode_compound_hdr(xdr, &hdr);
1222         if (status)
1223                 goto out;
1224         status = decode_sequence(xdr, &res->seq_res, rqstp);
1225         if (status)
1226                 goto out;
1227         status = decode_putfh(xdr);
1228         if (status)
1229                 goto out;
1230         status = decode_savefh(xdr);
1231         if (status)
1232                 goto out;
1233         status = decode_putfh(xdr);
1234         if (status)
1235                 goto out;
1236         status = decode_copy(xdr, res);
1237         if (status)
1238                 goto out;
1239         if (res->commit_res.verf)
1240                 status = decode_commit(xdr, &res->commit_res);
1241 out:
1242         return status;
1243 }
1244
1245 /*
1246  * Decode OFFLOAD_CANCEL response
1247  */
1248 static int nfs4_xdr_dec_offload_cancel(struct rpc_rqst *rqstp,
1249                                        struct xdr_stream *xdr,
1250                                        void *data)
1251 {
1252         struct nfs42_offload_status_res *res = data;
1253         struct compound_hdr hdr;
1254         int status;
1255
1256         status = decode_compound_hdr(xdr, &hdr);
1257         if (status)
1258                 goto out;
1259         status = decode_sequence(xdr, &res->osr_seq_res, rqstp);
1260         if (status)
1261                 goto out;
1262         status = decode_putfh(xdr);
1263         if (status)
1264                 goto out;
1265         status = decode_offload_cancel(xdr, res);
1266
1267 out:
1268         return status;
1269 }
1270
1271 /*
1272  * Decode COPY_NOTIFY response
1273  */
1274 static int nfs4_xdr_dec_copy_notify(struct rpc_rqst *rqstp,
1275                                     struct xdr_stream *xdr,
1276                                     void *data)
1277 {
1278         struct nfs42_copy_notify_res *res = data;
1279         struct compound_hdr hdr;
1280         int status;
1281
1282         status = decode_compound_hdr(xdr, &hdr);
1283         if (status)
1284                 goto out;
1285         status = decode_sequence(xdr, &res->cnr_seq_res, rqstp);
1286         if (status)
1287                 goto out;
1288         status = decode_putfh(xdr);
1289         if (status)
1290                 goto out;
1291         status = decode_copy_notify(xdr, res);
1292
1293 out:
1294         return status;
1295 }
1296
1297 /*
1298  * Decode DEALLOCATE request
1299  */
1300 static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
1301                                    struct xdr_stream *xdr,
1302                                    void *data)
1303 {
1304         struct nfs42_falloc_res *res = data;
1305         struct compound_hdr hdr;
1306         int status;
1307
1308         status = decode_compound_hdr(xdr, &hdr);
1309         if (status)
1310                 goto out;
1311         status = decode_sequence(xdr, &res->seq_res, rqstp);
1312         if (status)
1313                 goto out;
1314         status = decode_putfh(xdr);
1315         if (status)
1316                 goto out;
1317         status = decode_deallocate(xdr, res);
1318         if (status)
1319                 goto out;
1320         decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
1321 out:
1322         return status;
1323 }
1324
1325 /*
1326  * Decode READ_PLUS request
1327  */
1328 static int nfs4_xdr_dec_read_plus(struct rpc_rqst *rqstp,
1329                                   struct xdr_stream *xdr,
1330                                   void *data)
1331 {
1332         struct nfs_pgio_res *res = data;
1333         struct compound_hdr hdr;
1334         int status;
1335
1336         status = decode_compound_hdr(xdr, &hdr);
1337         if (status)
1338                 goto out;
1339         status = decode_sequence(xdr, &res->seq_res, rqstp);
1340         if (status)
1341                 goto out;
1342         status = decode_putfh(xdr);
1343         if (status)
1344                 goto out;
1345         status = decode_read_plus(xdr, res);
1346         if (!status)
1347                 status = res->count;
1348 out:
1349         return status;
1350 }
1351
1352 /*
1353  * Decode SEEK request
1354  */
1355 static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
1356                              struct xdr_stream *xdr,
1357                              void *data)
1358 {
1359         struct nfs42_seek_res *res = data;
1360         struct compound_hdr hdr;
1361         int status;
1362
1363         status = decode_compound_hdr(xdr, &hdr);
1364         if (status)
1365                 goto out;
1366         status = decode_sequence(xdr, &res->seq_res, rqstp);
1367         if (status)
1368                 goto out;
1369         status = decode_putfh(xdr);
1370         if (status)
1371                 goto out;
1372         status = decode_seek(xdr, res);
1373 out:
1374         return status;
1375 }
1376
1377 /*
1378  * Decode LAYOUTSTATS request
1379  */
1380 static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
1381                                     struct xdr_stream *xdr,
1382                                     void *data)
1383 {
1384         struct nfs42_layoutstat_res *res = data;
1385         struct compound_hdr hdr;
1386         int status, i;
1387
1388         status = decode_compound_hdr(xdr, &hdr);
1389         if (status)
1390                 goto out;
1391         status = decode_sequence(xdr, &res->seq_res, rqstp);
1392         if (status)
1393                 goto out;
1394         status = decode_putfh(xdr);
1395         if (status)
1396                 goto out;
1397         WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
1398         for (i = 0; i < res->num_dev; i++) {
1399                 status = decode_layoutstats(xdr);
1400                 if (status)
1401                         goto out;
1402         }
1403 out:
1404         res->rpc_status = status;
1405         return status;
1406 }
1407
1408 /*
1409  * Decode CLONE request
1410  */
1411 static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
1412                               struct xdr_stream *xdr,
1413                               void *data)
1414 {
1415         struct nfs42_clone_res *res = data;
1416         struct compound_hdr hdr;
1417         int status;
1418
1419         status = decode_compound_hdr(xdr, &hdr);
1420         if (status)
1421                 goto out;
1422         status = decode_sequence(xdr, &res->seq_res, rqstp);
1423         if (status)
1424                 goto out;
1425         status = decode_putfh(xdr);
1426         if (status)
1427                 goto out;
1428         status = decode_savefh(xdr);
1429         if (status)
1430                 goto out;
1431         status = decode_putfh(xdr);
1432         if (status)
1433                 goto out;
1434         status = decode_clone(xdr);
1435         if (status)
1436                 goto out;
1437         decode_getfattr(xdr, res->dst_fattr, res->server);
1438 out:
1439         res->rpc_status = status;
1440         return status;
1441 }
1442
1443 /*
1444  * Decode LAYOUTERROR request
1445  */
1446 static int nfs4_xdr_dec_layouterror(struct rpc_rqst *rqstp,
1447                                     struct xdr_stream *xdr,
1448                                     void *data)
1449 {
1450         struct nfs42_layouterror_res *res = data;
1451         struct compound_hdr hdr;
1452         int status, i;
1453
1454         status = decode_compound_hdr(xdr, &hdr);
1455         if (status)
1456                 goto out;
1457         status = decode_sequence(xdr, &res->seq_res, rqstp);
1458         if (status)
1459                 goto out;
1460         status = decode_putfh(xdr);
1461
1462         for (i = 0; i < res->num_errors && status == 0; i++)
1463                 status = decode_layouterror(xdr);
1464 out:
1465         res->rpc_status = status;
1466         return status;
1467 }
1468
1469 #ifdef CONFIG_NFS_V4_2
1470 static void nfs4_xdr_enc_setxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
1471                                   const void *data)
1472 {
1473         const struct nfs42_setxattrargs *args = data;
1474         struct compound_hdr hdr = {
1475                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1476         };
1477
1478         encode_compound_hdr(xdr, req, &hdr);
1479         encode_sequence(xdr, &args->seq_args, &hdr);
1480         encode_putfh(xdr, args->fh, &hdr);
1481         encode_setxattr(xdr, args, &hdr);
1482         encode_nops(&hdr);
1483 }
1484
1485 static int nfs4_xdr_dec_setxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
1486                                  void *data)
1487 {
1488         struct nfs42_setxattrres *res = data;
1489         struct compound_hdr hdr;
1490         int status;
1491
1492         status = decode_compound_hdr(xdr, &hdr);
1493         if (status)
1494                 goto out;
1495         status = decode_sequence(xdr, &res->seq_res, req);
1496         if (status)
1497                 goto out;
1498         status = decode_putfh(xdr);
1499         if (status)
1500                 goto out;
1501
1502         status = decode_setxattr(xdr, &res->cinfo);
1503 out:
1504         return status;
1505 }
1506
1507 static void nfs4_xdr_enc_getxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
1508                                   const void *data)
1509 {
1510         const struct nfs42_getxattrargs *args = data;
1511         struct compound_hdr hdr = {
1512                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1513         };
1514         uint32_t replen;
1515
1516         encode_compound_hdr(xdr, req, &hdr);
1517         encode_sequence(xdr, &args->seq_args, &hdr);
1518         encode_putfh(xdr, args->fh, &hdr);
1519         replen = hdr.replen + op_decode_hdr_maxsz + 1;
1520         encode_getxattr(xdr, args->xattr_name, &hdr);
1521
1522         rpc_prepare_reply_pages(req, args->xattr_pages, 0, args->xattr_len,
1523                                 replen);
1524
1525         encode_nops(&hdr);
1526 }
1527
1528 static int nfs4_xdr_dec_getxattr(struct rpc_rqst *rqstp,
1529                                  struct xdr_stream *xdr, void *data)
1530 {
1531         struct nfs42_getxattrres *res = data;
1532         struct compound_hdr hdr;
1533         int status;
1534
1535         status = decode_compound_hdr(xdr, &hdr);
1536         if (status)
1537                 goto out;
1538         status = decode_sequence(xdr, &res->seq_res, rqstp);
1539         if (status)
1540                 goto out;
1541         status = decode_putfh(xdr);
1542         if (status)
1543                 goto out;
1544         status = decode_getxattr(xdr, res, rqstp);
1545 out:
1546         return status;
1547 }
1548
1549 static void nfs4_xdr_enc_listxattrs(struct rpc_rqst *req,
1550                                     struct xdr_stream *xdr, const void *data)
1551 {
1552         const struct nfs42_listxattrsargs *args = data;
1553         struct compound_hdr hdr = {
1554                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1555         };
1556         uint32_t replen;
1557
1558         encode_compound_hdr(xdr, req, &hdr);
1559         encode_sequence(xdr, &args->seq_args, &hdr);
1560         encode_putfh(xdr, args->fh, &hdr);
1561         replen = hdr.replen + op_decode_hdr_maxsz + 2 + 1;
1562         encode_listxattrs(xdr, args, &hdr);
1563
1564         rpc_prepare_reply_pages(req, args->xattr_pages, 0, args->count, replen);
1565
1566         encode_nops(&hdr);
1567 }
1568
1569 static int nfs4_xdr_dec_listxattrs(struct rpc_rqst *rqstp,
1570                                    struct xdr_stream *xdr, void *data)
1571 {
1572         struct nfs42_listxattrsres *res = data;
1573         struct compound_hdr hdr;
1574         int status;
1575
1576         xdr_set_scratch_page(xdr, res->scratch);
1577
1578         status = decode_compound_hdr(xdr, &hdr);
1579         if (status)
1580                 goto out;
1581         status = decode_sequence(xdr, &res->seq_res, rqstp);
1582         if (status)
1583                 goto out;
1584         status = decode_putfh(xdr);
1585         if (status)
1586                 goto out;
1587         status = decode_listxattrs(xdr, res);
1588 out:
1589         return status;
1590 }
1591
1592 static void nfs4_xdr_enc_removexattr(struct rpc_rqst *req,
1593                                      struct xdr_stream *xdr, const void *data)
1594 {
1595         const struct nfs42_removexattrargs *args = data;
1596         struct compound_hdr hdr = {
1597                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1598         };
1599
1600         encode_compound_hdr(xdr, req, &hdr);
1601         encode_sequence(xdr, &args->seq_args, &hdr);
1602         encode_putfh(xdr, args->fh, &hdr);
1603         encode_removexattr(xdr, args->xattr_name, &hdr);
1604         encode_nops(&hdr);
1605 }
1606
1607 static int nfs4_xdr_dec_removexattr(struct rpc_rqst *req,
1608                                     struct xdr_stream *xdr, void *data)
1609 {
1610         struct nfs42_removexattrres *res = data;
1611         struct compound_hdr hdr;
1612         int status;
1613
1614         status = decode_compound_hdr(xdr, &hdr);
1615         if (status)
1616                 goto out;
1617         status = decode_sequence(xdr, &res->seq_res, req);
1618         if (status)
1619                 goto out;
1620         status = decode_putfh(xdr);
1621         if (status)
1622                 goto out;
1623
1624         status = decode_removexattr(xdr, &res->cinfo);
1625 out:
1626         return status;
1627 }
1628 #endif
1629 #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */