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