fs/nfs/nfs42xdr.c

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