1 /* 2 * fs/nfs/nfs4xdr.c 3 * 4 * Client-side XDR for NFSv4. 5 * 6 * Copyright (c) 2002 The Regents of the University of Michigan. 7 * All rights reserved. 8 * 9 * Kendrick Smith <kmsmith@umich.edu> 10 * Andy Adamson <andros@umich.edu> 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 #include <linux/param.h> 39 #include <linux/time.h> 40 #include <linux/mm.h> 41 #include <linux/slab.h> 42 #include <linux/utsname.h> 43 #include <linux/errno.h> 44 #include <linux/string.h> 45 #include <linux/in.h> 46 #include <linux/pagemap.h> 47 #include <linux/proc_fs.h> 48 #include <linux/kdev_t.h> 49 #include <linux/sunrpc/clnt.h> 50 #include <linux/nfs.h> 51 #include <linux/nfs4.h> 52 #include <linux/nfs_fs.h> 53 #include <linux/nfs_idmap.h> 54 #include "nfs4_fs.h" 55 56 #define NFSDBG_FACILITY NFSDBG_XDR 57 58 /* Mapping from NFS error code to "errno" error code. */ 59 #define errno_NFSERR_IO EIO 60 61 static int nfs_stat_to_errno(int); 62 63 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */ 64 #ifdef DEBUG 65 #define NFS4_MAXTAGLEN 20 66 #else 67 #define NFS4_MAXTAGLEN 0 68 #endif 69 70 /* lock,open owner id: 71 * we currently use size 1 (u32) out of (NFS4_OPAQUE_LIMIT >> 2) 72 */ 73 #define owner_id_maxsz (1 + 1) 74 #define compound_encode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2)) 75 #define compound_decode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2)) 76 #define op_encode_hdr_maxsz (1) 77 #define op_decode_hdr_maxsz (2) 78 #define encode_putfh_maxsz (op_encode_hdr_maxsz + 1 + \ 79 (NFS4_FHSIZE >> 2)) 80 #define decode_putfh_maxsz (op_decode_hdr_maxsz) 81 #define encode_putrootfh_maxsz (op_encode_hdr_maxsz) 82 #define decode_putrootfh_maxsz (op_decode_hdr_maxsz) 83 #define encode_getfh_maxsz (op_encode_hdr_maxsz) 84 #define decode_getfh_maxsz (op_decode_hdr_maxsz + 1 + \ 85 ((3+NFS4_FHSIZE) >> 2)) 86 #define nfs4_fattr_bitmap_maxsz 3 87 #define encode_getattr_maxsz (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz) 88 #define nfs4_name_maxsz (1 + ((3 + NFS4_MAXNAMLEN) >> 2)) 89 #define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2)) 90 /* This is based on getfattr, which uses the most attributes: */ 91 #define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \ 92 3 + 3 + 3 + 2 * nfs4_name_maxsz)) 93 #define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \ 94 nfs4_fattr_value_maxsz) 95 #define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz) 96 #define encode_savefh_maxsz (op_encode_hdr_maxsz) 97 #define decode_savefh_maxsz (op_decode_hdr_maxsz) 98 #define encode_restorefh_maxsz (op_encode_hdr_maxsz) 99 #define decode_restorefh_maxsz (op_decode_hdr_maxsz) 100 #define encode_fsinfo_maxsz (op_encode_hdr_maxsz + 2) 101 #define decode_fsinfo_maxsz (op_decode_hdr_maxsz + 11) 102 #define encode_renew_maxsz (op_encode_hdr_maxsz + 3) 103 #define decode_renew_maxsz (op_decode_hdr_maxsz) 104 #define encode_setclientid_maxsz \ 105 (op_encode_hdr_maxsz + \ 106 4 /*server->ip_addr*/ + \ 107 1 /*Netid*/ + \ 108 6 /*uaddr*/ + \ 109 6 + (NFS4_VERIFIER_SIZE >> 2)) 110 #define decode_setclientid_maxsz \ 111 (op_decode_hdr_maxsz + \ 112 2 + \ 113 1024) /* large value for CLID_INUSE */ 114 #define encode_setclientid_confirm_maxsz \ 115 (op_encode_hdr_maxsz + \ 116 3 + (NFS4_VERIFIER_SIZE >> 2)) 117 #define decode_setclientid_confirm_maxsz \ 118 (op_decode_hdr_maxsz) 119 #define encode_lookup_maxsz (op_encode_hdr_maxsz + \ 120 1 + ((3 + NFS4_FHSIZE) >> 2)) 121 #define encode_remove_maxsz (op_encode_hdr_maxsz + \ 122 nfs4_name_maxsz) 123 #define encode_rename_maxsz (op_encode_hdr_maxsz + \ 124 2 * nfs4_name_maxsz) 125 #define decode_rename_maxsz (op_decode_hdr_maxsz + 5 + 5) 126 #define encode_link_maxsz (op_encode_hdr_maxsz + \ 127 nfs4_name_maxsz) 128 #define decode_link_maxsz (op_decode_hdr_maxsz + 5) 129 #define encode_symlink_maxsz (op_encode_hdr_maxsz + \ 130 1 + nfs4_name_maxsz + \ 131 nfs4_path_maxsz + \ 132 nfs4_fattr_maxsz) 133 #define decode_symlink_maxsz (op_decode_hdr_maxsz + 8) 134 #define encode_create_maxsz (op_encode_hdr_maxsz + \ 135 2 + nfs4_name_maxsz + \ 136 nfs4_fattr_maxsz) 137 #define decode_create_maxsz (op_decode_hdr_maxsz + 8) 138 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4) 139 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz) 140 #define NFS4_enc_compound_sz (1024) /* XXX: large enough? */ 141 #define NFS4_dec_compound_sz (1024) /* XXX: large enough? */ 142 #define NFS4_enc_read_sz (compound_encode_hdr_maxsz + \ 143 encode_putfh_maxsz + \ 144 op_encode_hdr_maxsz + 7) 145 #define NFS4_dec_read_sz (compound_decode_hdr_maxsz + \ 146 decode_putfh_maxsz + \ 147 op_decode_hdr_maxsz + 2) 148 #define NFS4_enc_readlink_sz (compound_encode_hdr_maxsz + \ 149 encode_putfh_maxsz + \ 150 op_encode_hdr_maxsz) 151 #define NFS4_dec_readlink_sz (compound_decode_hdr_maxsz + \ 152 decode_putfh_maxsz + \ 153 op_decode_hdr_maxsz) 154 #define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \ 155 encode_putfh_maxsz + \ 156 op_encode_hdr_maxsz + 9) 157 #define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \ 158 decode_putfh_maxsz + \ 159 op_decode_hdr_maxsz + 2) 160 #define NFS4_enc_write_sz (compound_encode_hdr_maxsz + \ 161 encode_putfh_maxsz + \ 162 op_encode_hdr_maxsz + 8 + \ 163 encode_getattr_maxsz) 164 #define NFS4_dec_write_sz (compound_decode_hdr_maxsz + \ 165 decode_putfh_maxsz + \ 166 op_decode_hdr_maxsz + 4 + \ 167 decode_getattr_maxsz) 168 #define NFS4_enc_commit_sz (compound_encode_hdr_maxsz + \ 169 encode_putfh_maxsz + \ 170 op_encode_hdr_maxsz + 3 + \ 171 encode_getattr_maxsz) 172 #define NFS4_dec_commit_sz (compound_decode_hdr_maxsz + \ 173 decode_putfh_maxsz + \ 174 op_decode_hdr_maxsz + 2 + \ 175 decode_getattr_maxsz) 176 #define NFS4_enc_open_sz (compound_encode_hdr_maxsz + \ 177 encode_putfh_maxsz + \ 178 op_encode_hdr_maxsz + \ 179 13 + 3 + 2 + 64 + \ 180 encode_getattr_maxsz + \ 181 encode_getfh_maxsz) 182 #define NFS4_dec_open_sz (compound_decode_hdr_maxsz + \ 183 decode_putfh_maxsz + \ 184 op_decode_hdr_maxsz + 4 + 5 + 2 + 3 + \ 185 decode_getattr_maxsz + \ 186 decode_getfh_maxsz) 187 #define NFS4_enc_open_confirm_sz \ 188 (compound_encode_hdr_maxsz + \ 189 encode_putfh_maxsz + \ 190 op_encode_hdr_maxsz + 5) 191 #define NFS4_dec_open_confirm_sz (compound_decode_hdr_maxsz + \ 192 decode_putfh_maxsz + \ 193 op_decode_hdr_maxsz + 4) 194 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \ 195 encode_putfh_maxsz + \ 196 op_encode_hdr_maxsz + \ 197 11) 198 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \ 199 decode_putfh_maxsz + \ 200 op_decode_hdr_maxsz + \ 201 4 + 5 + 2 + 3) 202 #define NFS4_enc_open_downgrade_sz \ 203 (compound_encode_hdr_maxsz + \ 204 encode_putfh_maxsz + \ 205 op_encode_hdr_maxsz + 7 + \ 206 encode_getattr_maxsz) 207 #define NFS4_dec_open_downgrade_sz \ 208 (compound_decode_hdr_maxsz + \ 209 decode_putfh_maxsz + \ 210 op_decode_hdr_maxsz + 4 + \ 211 decode_getattr_maxsz) 212 #define NFS4_enc_close_sz (compound_encode_hdr_maxsz + \ 213 encode_putfh_maxsz + \ 214 op_encode_hdr_maxsz + 5 + \ 215 encode_getattr_maxsz) 216 #define NFS4_dec_close_sz (compound_decode_hdr_maxsz + \ 217 decode_putfh_maxsz + \ 218 op_decode_hdr_maxsz + 4 + \ 219 decode_getattr_maxsz) 220 #define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \ 221 encode_putfh_maxsz + \ 222 op_encode_hdr_maxsz + 4 + \ 223 nfs4_fattr_maxsz + \ 224 encode_getattr_maxsz) 225 #define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \ 226 decode_putfh_maxsz + \ 227 op_decode_hdr_maxsz + 3) 228 #define NFS4_enc_fsinfo_sz (compound_encode_hdr_maxsz + \ 229 encode_putfh_maxsz + \ 230 encode_fsinfo_maxsz) 231 #define NFS4_dec_fsinfo_sz (compound_decode_hdr_maxsz + \ 232 decode_putfh_maxsz + \ 233 decode_fsinfo_maxsz) 234 #define NFS4_enc_renew_sz (compound_encode_hdr_maxsz + \ 235 encode_renew_maxsz) 236 #define NFS4_dec_renew_sz (compound_decode_hdr_maxsz + \ 237 decode_renew_maxsz) 238 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \ 239 encode_setclientid_maxsz) 240 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \ 241 decode_setclientid_maxsz) 242 #define NFS4_enc_setclientid_confirm_sz \ 243 (compound_encode_hdr_maxsz + \ 244 encode_setclientid_confirm_maxsz + \ 245 encode_putrootfh_maxsz + \ 246 encode_fsinfo_maxsz) 247 #define NFS4_dec_setclientid_confirm_sz \ 248 (compound_decode_hdr_maxsz + \ 249 decode_setclientid_confirm_maxsz + \ 250 decode_putrootfh_maxsz + \ 251 decode_fsinfo_maxsz) 252 #define NFS4_enc_lock_sz (compound_encode_hdr_maxsz + \ 253 encode_putfh_maxsz + \ 254 encode_getattr_maxsz + \ 255 op_encode_hdr_maxsz + \ 256 1 + 1 + 2 + 2 + \ 257 1 + 4 + 1 + 2 + \ 258 owner_id_maxsz) 259 #define NFS4_dec_lock_sz (compound_decode_hdr_maxsz + \ 260 decode_putfh_maxsz + \ 261 decode_getattr_maxsz + \ 262 op_decode_hdr_maxsz + \ 263 2 + 2 + 1 + 2 + \ 264 owner_id_maxsz) 265 #define NFS4_enc_lockt_sz (compound_encode_hdr_maxsz + \ 266 encode_putfh_maxsz + \ 267 encode_getattr_maxsz + \ 268 op_encode_hdr_maxsz + \ 269 1 + 2 + 2 + 2 + \ 270 owner_id_maxsz) 271 #define NFS4_dec_lockt_sz (NFS4_dec_lock_sz) 272 #define NFS4_enc_locku_sz (compound_encode_hdr_maxsz + \ 273 encode_putfh_maxsz + \ 274 encode_getattr_maxsz + \ 275 op_encode_hdr_maxsz + \ 276 1 + 1 + 4 + 2 + 2) 277 #define NFS4_dec_locku_sz (compound_decode_hdr_maxsz + \ 278 decode_putfh_maxsz + \ 279 decode_getattr_maxsz + \ 280 op_decode_hdr_maxsz + 4) 281 #define NFS4_enc_access_sz (compound_encode_hdr_maxsz + \ 282 encode_putfh_maxsz + \ 283 op_encode_hdr_maxsz + 1) 284 #define NFS4_dec_access_sz (compound_decode_hdr_maxsz + \ 285 decode_putfh_maxsz + \ 286 op_decode_hdr_maxsz + 2) 287 #define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \ 288 encode_putfh_maxsz + \ 289 encode_getattr_maxsz) 290 #define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \ 291 decode_putfh_maxsz + \ 292 decode_getattr_maxsz) 293 #define NFS4_enc_lookup_sz (compound_encode_hdr_maxsz + \ 294 encode_putfh_maxsz + \ 295 encode_lookup_maxsz + \ 296 encode_getattr_maxsz + \ 297 encode_getfh_maxsz) 298 #define NFS4_dec_lookup_sz (compound_decode_hdr_maxsz + \ 299 decode_putfh_maxsz + \ 300 op_decode_hdr_maxsz + \ 301 decode_getattr_maxsz + \ 302 decode_getfh_maxsz) 303 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \ 304 encode_putrootfh_maxsz + \ 305 encode_getattr_maxsz + \ 306 encode_getfh_maxsz) 307 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \ 308 decode_putrootfh_maxsz + \ 309 decode_getattr_maxsz + \ 310 decode_getfh_maxsz) 311 #define NFS4_enc_remove_sz (compound_encode_hdr_maxsz + \ 312 encode_putfh_maxsz + \ 313 encode_remove_maxsz + \ 314 encode_getattr_maxsz) 315 #define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \ 316 decode_putfh_maxsz + \ 317 op_decode_hdr_maxsz + 5 + \ 318 decode_getattr_maxsz) 319 #define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \ 320 encode_putfh_maxsz + \ 321 encode_savefh_maxsz + \ 322 encode_putfh_maxsz + \ 323 encode_rename_maxsz + \ 324 encode_getattr_maxsz + \ 325 encode_restorefh_maxsz + \ 326 encode_getattr_maxsz) 327 #define NFS4_dec_rename_sz (compound_decode_hdr_maxsz + \ 328 decode_putfh_maxsz + \ 329 decode_savefh_maxsz + \ 330 decode_putfh_maxsz + \ 331 decode_rename_maxsz + \ 332 decode_getattr_maxsz + \ 333 decode_restorefh_maxsz + \ 334 decode_getattr_maxsz) 335 #define NFS4_enc_link_sz (compound_encode_hdr_maxsz + \ 336 encode_putfh_maxsz + \ 337 encode_savefh_maxsz + \ 338 encode_putfh_maxsz + \ 339 encode_link_maxsz + \ 340 decode_getattr_maxsz + \ 341 encode_restorefh_maxsz + \ 342 decode_getattr_maxsz) 343 #define NFS4_dec_link_sz (compound_decode_hdr_maxsz + \ 344 decode_putfh_maxsz + \ 345 decode_savefh_maxsz + \ 346 decode_putfh_maxsz + \ 347 decode_link_maxsz + \ 348 decode_getattr_maxsz + \ 349 decode_restorefh_maxsz + \ 350 decode_getattr_maxsz) 351 #define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \ 352 encode_putfh_maxsz + \ 353 encode_symlink_maxsz + \ 354 encode_getattr_maxsz + \ 355 encode_getfh_maxsz) 356 #define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \ 357 decode_putfh_maxsz + \ 358 decode_symlink_maxsz + \ 359 decode_getattr_maxsz + \ 360 decode_getfh_maxsz) 361 #define NFS4_enc_create_sz (compound_encode_hdr_maxsz + \ 362 encode_putfh_maxsz + \ 363 encode_savefh_maxsz + \ 364 encode_create_maxsz + \ 365 encode_getfh_maxsz + \ 366 encode_getattr_maxsz + \ 367 encode_restorefh_maxsz + \ 368 encode_getattr_maxsz) 369 #define NFS4_dec_create_sz (compound_decode_hdr_maxsz + \ 370 decode_putfh_maxsz + \ 371 decode_savefh_maxsz + \ 372 decode_create_maxsz + \ 373 decode_getfh_maxsz + \ 374 decode_getattr_maxsz + \ 375 decode_restorefh_maxsz + \ 376 decode_getattr_maxsz) 377 #define NFS4_enc_pathconf_sz (compound_encode_hdr_maxsz + \ 378 encode_putfh_maxsz + \ 379 encode_getattr_maxsz) 380 #define NFS4_dec_pathconf_sz (compound_decode_hdr_maxsz + \ 381 decode_putfh_maxsz + \ 382 decode_getattr_maxsz) 383 #define NFS4_enc_statfs_sz (compound_encode_hdr_maxsz + \ 384 encode_putfh_maxsz + \ 385 encode_getattr_maxsz) 386 #define NFS4_dec_statfs_sz (compound_decode_hdr_maxsz + \ 387 decode_putfh_maxsz + \ 388 op_decode_hdr_maxsz + 12) 389 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \ 390 encode_getattr_maxsz) 391 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \ 392 decode_getattr_maxsz) 393 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \ 394 encode_putfh_maxsz + \ 395 encode_delegreturn_maxsz + \ 396 encode_getattr_maxsz) 397 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \ 398 decode_delegreturn_maxsz + \ 399 decode_getattr_maxsz) 400 #define NFS4_enc_getacl_sz (compound_encode_hdr_maxsz + \ 401 encode_putfh_maxsz + \ 402 encode_getattr_maxsz) 403 #define NFS4_dec_getacl_sz (compound_decode_hdr_maxsz + \ 404 decode_putfh_maxsz + \ 405 op_decode_hdr_maxsz + \ 406 nfs4_fattr_bitmap_maxsz + 1) 407 #define NFS4_enc_setacl_sz (compound_encode_hdr_maxsz + \ 408 encode_putfh_maxsz + \ 409 op_encode_hdr_maxsz + 4 + \ 410 nfs4_fattr_bitmap_maxsz + 1) 411 #define NFS4_dec_setacl_sz (compound_decode_hdr_maxsz + \ 412 decode_putfh_maxsz + \ 413 op_decode_hdr_maxsz + nfs4_fattr_bitmap_maxsz) 414 #define NFS4_enc_fs_locations_sz \ 415 (compound_encode_hdr_maxsz + \ 416 encode_putfh_maxsz + \ 417 encode_getattr_maxsz) 418 #define NFS4_dec_fs_locations_sz \ 419 (compound_decode_hdr_maxsz + \ 420 decode_putfh_maxsz + \ 421 op_decode_hdr_maxsz + \ 422 nfs4_fattr_bitmap_maxsz) 423 424 static struct { 425 unsigned int mode; 426 unsigned int nfs2type; 427 } nfs_type2fmt[] = { 428 { 0, NFNON }, 429 { S_IFREG, NFREG }, 430 { S_IFDIR, NFDIR }, 431 { S_IFBLK, NFBLK }, 432 { S_IFCHR, NFCHR }, 433 { S_IFLNK, NFLNK }, 434 { S_IFSOCK, NFSOCK }, 435 { S_IFIFO, NFFIFO }, 436 { 0, NFNON }, 437 { 0, NFNON }, 438 }; 439 440 struct compound_hdr { 441 int32_t status; 442 uint32_t nops; 443 uint32_t taglen; 444 char * tag; 445 }; 446 447 /* 448 * START OF "GENERIC" ENCODE ROUTINES. 449 * These may look a little ugly since they are imported from a "generic" 450 * set of XDR encode/decode routines which are intended to be shared by 451 * all of our NFSv4 implementations (OpenBSD, MacOS X...). 452 * 453 * If the pain of reading these is too great, it should be a straightforward 454 * task to translate them into Linux-specific versions which are more 455 * consistent with the style used in NFSv2/v3... 456 */ 457 #define WRITE32(n) *p++ = htonl(n) 458 #define WRITE64(n) do { \ 459 *p++ = htonl((uint32_t)((n) >> 32)); \ 460 *p++ = htonl((uint32_t)(n)); \ 461 } while (0) 462 #define WRITEMEM(ptr,nbytes) do { \ 463 p = xdr_encode_opaque_fixed(p, ptr, nbytes); \ 464 } while (0) 465 466 #define RESERVE_SPACE(nbytes) do { \ 467 p = xdr_reserve_space(xdr, nbytes); \ 468 if (!p) printk("RESERVE_SPACE(%d) failed in function %s\n", (int) (nbytes), __FUNCTION__); \ 469 BUG_ON(!p); \ 470 } while (0) 471 472 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str) 473 { 474 uint32_t *p; 475 476 p = xdr_reserve_space(xdr, 4 + len); 477 BUG_ON(p == NULL); 478 xdr_encode_opaque(p, str, len); 479 } 480 481 static int encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr) 482 { 483 uint32_t *p; 484 485 dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag); 486 BUG_ON(hdr->taglen > NFS4_MAXTAGLEN); 487 RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2)); 488 WRITE32(hdr->taglen); 489 WRITEMEM(hdr->tag, hdr->taglen); 490 WRITE32(NFS4_MINOR_VERSION); 491 WRITE32(hdr->nops); 492 return 0; 493 } 494 495 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf) 496 { 497 uint32_t *p; 498 499 p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); 500 BUG_ON(p == NULL); 501 xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE); 502 } 503 504 static int encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server) 505 { 506 char owner_name[IDMAP_NAMESZ]; 507 char owner_group[IDMAP_NAMESZ]; 508 int owner_namelen = 0; 509 int owner_grouplen = 0; 510 uint32_t *p; 511 uint32_t *q; 512 int len; 513 uint32_t bmval0 = 0; 514 uint32_t bmval1 = 0; 515 int status; 516 517 /* 518 * We reserve enough space to write the entire attribute buffer at once. 519 * In the worst-case, this would be 520 * 12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime) 521 * = 36 bytes, plus any contribution from variable-length fields 522 * such as owner/group. 523 */ 524 len = 16; 525 526 /* Sigh */ 527 if (iap->ia_valid & ATTR_SIZE) 528 len += 8; 529 if (iap->ia_valid & ATTR_MODE) 530 len += 4; 531 if (iap->ia_valid & ATTR_UID) { 532 owner_namelen = nfs_map_uid_to_name(server->nfs4_state, iap->ia_uid, owner_name); 533 if (owner_namelen < 0) { 534 printk(KERN_WARNING "nfs: couldn't resolve uid %d to string\n", 535 iap->ia_uid); 536 /* XXX */ 537 strcpy(owner_name, "nobody"); 538 owner_namelen = sizeof("nobody") - 1; 539 /* goto out; */ 540 } 541 len += 4 + (XDR_QUADLEN(owner_namelen) << 2); 542 } 543 if (iap->ia_valid & ATTR_GID) { 544 owner_grouplen = nfs_map_gid_to_group(server->nfs4_state, iap->ia_gid, owner_group); 545 if (owner_grouplen < 0) { 546 printk(KERN_WARNING "nfs4: couldn't resolve gid %d to string\n", 547 iap->ia_gid); 548 strcpy(owner_group, "nobody"); 549 owner_grouplen = sizeof("nobody") - 1; 550 /* goto out; */ 551 } 552 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2); 553 } 554 if (iap->ia_valid & ATTR_ATIME_SET) 555 len += 16; 556 else if (iap->ia_valid & ATTR_ATIME) 557 len += 4; 558 if (iap->ia_valid & ATTR_MTIME_SET) 559 len += 16; 560 else if (iap->ia_valid & ATTR_MTIME) 561 len += 4; 562 RESERVE_SPACE(len); 563 564 /* 565 * We write the bitmap length now, but leave the bitmap and the attribute 566 * buffer length to be backfilled at the end of this routine. 567 */ 568 WRITE32(2); 569 q = p; 570 p += 3; 571 572 if (iap->ia_valid & ATTR_SIZE) { 573 bmval0 |= FATTR4_WORD0_SIZE; 574 WRITE64(iap->ia_size); 575 } 576 if (iap->ia_valid & ATTR_MODE) { 577 bmval1 |= FATTR4_WORD1_MODE; 578 WRITE32(iap->ia_mode & S_IALLUGO); 579 } 580 if (iap->ia_valid & ATTR_UID) { 581 bmval1 |= FATTR4_WORD1_OWNER; 582 WRITE32(owner_namelen); 583 WRITEMEM(owner_name, owner_namelen); 584 } 585 if (iap->ia_valid & ATTR_GID) { 586 bmval1 |= FATTR4_WORD1_OWNER_GROUP; 587 WRITE32(owner_grouplen); 588 WRITEMEM(owner_group, owner_grouplen); 589 } 590 if (iap->ia_valid & ATTR_ATIME_SET) { 591 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; 592 WRITE32(NFS4_SET_TO_CLIENT_TIME); 593 WRITE32(0); 594 WRITE32(iap->ia_mtime.tv_sec); 595 WRITE32(iap->ia_mtime.tv_nsec); 596 } 597 else if (iap->ia_valid & ATTR_ATIME) { 598 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; 599 WRITE32(NFS4_SET_TO_SERVER_TIME); 600 } 601 if (iap->ia_valid & ATTR_MTIME_SET) { 602 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; 603 WRITE32(NFS4_SET_TO_CLIENT_TIME); 604 WRITE32(0); 605 WRITE32(iap->ia_mtime.tv_sec); 606 WRITE32(iap->ia_mtime.tv_nsec); 607 } 608 else if (iap->ia_valid & ATTR_MTIME) { 609 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; 610 WRITE32(NFS4_SET_TO_SERVER_TIME); 611 } 612 613 /* 614 * Now we backfill the bitmap and the attribute buffer length. 615 */ 616 if (len != ((char *)p - (char *)q) + 4) { 617 printk ("encode_attr: Attr length calculation error! %u != %Zu\n", 618 len, ((char *)p - (char *)q) + 4); 619 BUG(); 620 } 621 len = (char *)p - (char *)q - 12; 622 *q++ = htonl(bmval0); 623 *q++ = htonl(bmval1); 624 *q++ = htonl(len); 625 626 status = 0; 627 /* out: */ 628 return status; 629 } 630 631 static int encode_access(struct xdr_stream *xdr, u32 access) 632 { 633 uint32_t *p; 634 635 RESERVE_SPACE(8); 636 WRITE32(OP_ACCESS); 637 WRITE32(access); 638 639 return 0; 640 } 641 642 static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg) 643 { 644 uint32_t *p; 645 646 RESERVE_SPACE(8+sizeof(arg->stateid->data)); 647 WRITE32(OP_CLOSE); 648 WRITE32(arg->seqid->sequence->counter); 649 WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data)); 650 651 return 0; 652 } 653 654 static int encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args) 655 { 656 uint32_t *p; 657 658 RESERVE_SPACE(16); 659 WRITE32(OP_COMMIT); 660 WRITE64(args->offset); 661 WRITE32(args->count); 662 663 return 0; 664 } 665 666 static int encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create) 667 { 668 uint32_t *p; 669 670 RESERVE_SPACE(8); 671 WRITE32(OP_CREATE); 672 WRITE32(create->ftype); 673 674 switch (create->ftype) { 675 case NF4LNK: 676 RESERVE_SPACE(4 + create->u.symlink->len); 677 WRITE32(create->u.symlink->len); 678 WRITEMEM(create->u.symlink->name, create->u.symlink->len); 679 break; 680 681 case NF4BLK: case NF4CHR: 682 RESERVE_SPACE(8); 683 WRITE32(create->u.device.specdata1); 684 WRITE32(create->u.device.specdata2); 685 break; 686 687 default: 688 break; 689 } 690 691 RESERVE_SPACE(4 + create->name->len); 692 WRITE32(create->name->len); 693 WRITEMEM(create->name->name, create->name->len); 694 695 return encode_attrs(xdr, create->attrs, create->server); 696 } 697 698 static int encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap) 699 { 700 uint32_t *p; 701 702 RESERVE_SPACE(12); 703 WRITE32(OP_GETATTR); 704 WRITE32(1); 705 WRITE32(bitmap); 706 return 0; 707 } 708 709 static int encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1) 710 { 711 uint32_t *p; 712 713 RESERVE_SPACE(16); 714 WRITE32(OP_GETATTR); 715 WRITE32(2); 716 WRITE32(bm0); 717 WRITE32(bm1); 718 return 0; 719 } 720 721 static int encode_getfattr(struct xdr_stream *xdr, const u32* bitmask) 722 { 723 return encode_getattr_two(xdr, 724 bitmask[0] & nfs4_fattr_bitmap[0], 725 bitmask[1] & nfs4_fattr_bitmap[1]); 726 } 727 728 static int encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask) 729 { 730 return encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0], 731 bitmask[1] & nfs4_fsinfo_bitmap[1]); 732 } 733 734 static int encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask) 735 { 736 return encode_getattr_two(xdr, 737 bitmask[0] & nfs4_fs_locations_bitmap[0], 738 bitmask[1] & nfs4_fs_locations_bitmap[1]); 739 } 740 741 static int encode_getfh(struct xdr_stream *xdr) 742 { 743 uint32_t *p; 744 745 RESERVE_SPACE(4); 746 WRITE32(OP_GETFH); 747 748 return 0; 749 } 750 751 static int encode_link(struct xdr_stream *xdr, const struct qstr *name) 752 { 753 uint32_t *p; 754 755 RESERVE_SPACE(8 + name->len); 756 WRITE32(OP_LINK); 757 WRITE32(name->len); 758 WRITEMEM(name->name, name->len); 759 760 return 0; 761 } 762 763 static inline int nfs4_lock_type(struct file_lock *fl, int block) 764 { 765 if ((fl->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) == F_RDLCK) 766 return block ? NFS4_READW_LT : NFS4_READ_LT; 767 return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT; 768 } 769 770 static inline uint64_t nfs4_lock_length(struct file_lock *fl) 771 { 772 if (fl->fl_end == OFFSET_MAX) 773 return ~(uint64_t)0; 774 return fl->fl_end - fl->fl_start + 1; 775 } 776 777 /* 778 * opcode,type,reclaim,offset,length,new_lock_owner = 32 779 * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40 780 */ 781 static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args) 782 { 783 uint32_t *p; 784 785 RESERVE_SPACE(32); 786 WRITE32(OP_LOCK); 787 WRITE32(nfs4_lock_type(args->fl, args->block)); 788 WRITE32(args->reclaim); 789 WRITE64(args->fl->fl_start); 790 WRITE64(nfs4_lock_length(args->fl)); 791 WRITE32(args->new_lock_owner); 792 if (args->new_lock_owner){ 793 RESERVE_SPACE(40); 794 WRITE32(args->open_seqid->sequence->counter); 795 WRITEMEM(args->open_stateid->data, sizeof(args->open_stateid->data)); 796 WRITE32(args->lock_seqid->sequence->counter); 797 WRITE64(args->lock_owner.clientid); 798 WRITE32(4); 799 WRITE32(args->lock_owner.id); 800 } 801 else { 802 RESERVE_SPACE(20); 803 WRITEMEM(args->lock_stateid->data, sizeof(args->lock_stateid->data)); 804 WRITE32(args->lock_seqid->sequence->counter); 805 } 806 807 return 0; 808 } 809 810 static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args) 811 { 812 uint32_t *p; 813 814 RESERVE_SPACE(40); 815 WRITE32(OP_LOCKT); 816 WRITE32(nfs4_lock_type(args->fl, 0)); 817 WRITE64(args->fl->fl_start); 818 WRITE64(nfs4_lock_length(args->fl)); 819 WRITE64(args->lock_owner.clientid); 820 WRITE32(4); 821 WRITE32(args->lock_owner.id); 822 823 return 0; 824 } 825 826 static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args) 827 { 828 uint32_t *p; 829 830 RESERVE_SPACE(44); 831 WRITE32(OP_LOCKU); 832 WRITE32(nfs4_lock_type(args->fl, 0)); 833 WRITE32(args->seqid->sequence->counter); 834 WRITEMEM(args->stateid->data, sizeof(args->stateid->data)); 835 WRITE64(args->fl->fl_start); 836 WRITE64(nfs4_lock_length(args->fl)); 837 838 return 0; 839 } 840 841 static int encode_lookup(struct xdr_stream *xdr, const struct qstr *name) 842 { 843 int len = name->len; 844 uint32_t *p; 845 846 RESERVE_SPACE(8 + len); 847 WRITE32(OP_LOOKUP); 848 WRITE32(len); 849 WRITEMEM(name->name, len); 850 851 return 0; 852 } 853 854 static void encode_share_access(struct xdr_stream *xdr, int open_flags) 855 { 856 uint32_t *p; 857 858 RESERVE_SPACE(8); 859 switch (open_flags & (FMODE_READ|FMODE_WRITE)) { 860 case FMODE_READ: 861 WRITE32(NFS4_SHARE_ACCESS_READ); 862 break; 863 case FMODE_WRITE: 864 WRITE32(NFS4_SHARE_ACCESS_WRITE); 865 break; 866 case FMODE_READ|FMODE_WRITE: 867 WRITE32(NFS4_SHARE_ACCESS_BOTH); 868 break; 869 default: 870 BUG(); 871 } 872 WRITE32(0); /* for linux, share_deny = 0 always */ 873 } 874 875 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg) 876 { 877 uint32_t *p; 878 /* 879 * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4, 880 * owner 4 = 32 881 */ 882 RESERVE_SPACE(8); 883 WRITE32(OP_OPEN); 884 WRITE32(arg->seqid->sequence->counter); 885 encode_share_access(xdr, arg->open_flags); 886 RESERVE_SPACE(16); 887 WRITE64(arg->clientid); 888 WRITE32(4); 889 WRITE32(arg->id); 890 } 891 892 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg) 893 { 894 uint32_t *p; 895 896 RESERVE_SPACE(4); 897 switch(arg->open_flags & O_EXCL) { 898 case 0: 899 WRITE32(NFS4_CREATE_UNCHECKED); 900 encode_attrs(xdr, arg->u.attrs, arg->server); 901 break; 902 default: 903 WRITE32(NFS4_CREATE_EXCLUSIVE); 904 encode_nfs4_verifier(xdr, &arg->u.verifier); 905 } 906 } 907 908 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg) 909 { 910 uint32_t *p; 911 912 RESERVE_SPACE(4); 913 switch (arg->open_flags & O_CREAT) { 914 case 0: 915 WRITE32(NFS4_OPEN_NOCREATE); 916 break; 917 default: 918 BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL); 919 WRITE32(NFS4_OPEN_CREATE); 920 encode_createmode(xdr, arg); 921 } 922 } 923 924 static inline void encode_delegation_type(struct xdr_stream *xdr, int delegation_type) 925 { 926 uint32_t *p; 927 928 RESERVE_SPACE(4); 929 switch (delegation_type) { 930 case 0: 931 WRITE32(NFS4_OPEN_DELEGATE_NONE); 932 break; 933 case FMODE_READ: 934 WRITE32(NFS4_OPEN_DELEGATE_READ); 935 break; 936 case FMODE_WRITE|FMODE_READ: 937 WRITE32(NFS4_OPEN_DELEGATE_WRITE); 938 break; 939 default: 940 BUG(); 941 } 942 } 943 944 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name) 945 { 946 uint32_t *p; 947 948 RESERVE_SPACE(4); 949 WRITE32(NFS4_OPEN_CLAIM_NULL); 950 encode_string(xdr, name->len, name->name); 951 } 952 953 static inline void encode_claim_previous(struct xdr_stream *xdr, int type) 954 { 955 uint32_t *p; 956 957 RESERVE_SPACE(4); 958 WRITE32(NFS4_OPEN_CLAIM_PREVIOUS); 959 encode_delegation_type(xdr, type); 960 } 961 962 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid) 963 { 964 uint32_t *p; 965 966 RESERVE_SPACE(4+sizeof(stateid->data)); 967 WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR); 968 WRITEMEM(stateid->data, sizeof(stateid->data)); 969 encode_string(xdr, name->len, name->name); 970 } 971 972 static int encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg) 973 { 974 encode_openhdr(xdr, arg); 975 encode_opentype(xdr, arg); 976 switch (arg->claim) { 977 case NFS4_OPEN_CLAIM_NULL: 978 encode_claim_null(xdr, arg->name); 979 break; 980 case NFS4_OPEN_CLAIM_PREVIOUS: 981 encode_claim_previous(xdr, arg->u.delegation_type); 982 break; 983 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 984 encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation); 985 break; 986 default: 987 BUG(); 988 } 989 return 0; 990 } 991 992 static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg) 993 { 994 uint32_t *p; 995 996 RESERVE_SPACE(8+sizeof(arg->stateid->data)); 997 WRITE32(OP_OPEN_CONFIRM); 998 WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data)); 999 WRITE32(arg->seqid->sequence->counter); 1000 1001 return 0; 1002 } 1003 1004 static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg) 1005 { 1006 uint32_t *p; 1007 1008 RESERVE_SPACE(8+sizeof(arg->stateid->data)); 1009 WRITE32(OP_OPEN_DOWNGRADE); 1010 WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data)); 1011 WRITE32(arg->seqid->sequence->counter); 1012 encode_share_access(xdr, arg->open_flags); 1013 return 0; 1014 } 1015 1016 static int 1017 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh) 1018 { 1019 int len = fh->size; 1020 uint32_t *p; 1021 1022 RESERVE_SPACE(8 + len); 1023 WRITE32(OP_PUTFH); 1024 WRITE32(len); 1025 WRITEMEM(fh->data, len); 1026 1027 return 0; 1028 } 1029 1030 static int encode_putrootfh(struct xdr_stream *xdr) 1031 { 1032 uint32_t *p; 1033 1034 RESERVE_SPACE(4); 1035 WRITE32(OP_PUTROOTFH); 1036 1037 return 0; 1038 } 1039 1040 static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx) 1041 { 1042 nfs4_stateid stateid; 1043 uint32_t *p; 1044 1045 RESERVE_SPACE(16); 1046 if (ctx->state != NULL) { 1047 nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner); 1048 WRITEMEM(stateid.data, sizeof(stateid.data)); 1049 } else 1050 WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data)); 1051 } 1052 1053 static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args) 1054 { 1055 uint32_t *p; 1056 1057 RESERVE_SPACE(4); 1058 WRITE32(OP_READ); 1059 1060 encode_stateid(xdr, args->context); 1061 1062 RESERVE_SPACE(12); 1063 WRITE64(args->offset); 1064 WRITE32(args->count); 1065 1066 return 0; 1067 } 1068 1069 static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req) 1070 { 1071 struct rpc_auth *auth = req->rq_task->tk_auth; 1072 uint32_t attrs[2] = { 1073 FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID, 1074 FATTR4_WORD1_MOUNTED_ON_FILEID, 1075 }; 1076 int replen; 1077 uint32_t *p; 1078 1079 RESERVE_SPACE(32+sizeof(nfs4_verifier)); 1080 WRITE32(OP_READDIR); 1081 WRITE64(readdir->cookie); 1082 WRITEMEM(readdir->verifier.data, sizeof(readdir->verifier.data)); 1083 WRITE32(readdir->count >> 1); /* We're not doing readdirplus */ 1084 WRITE32(readdir->count); 1085 WRITE32(2); 1086 /* Switch to mounted_on_fileid if the server supports it */ 1087 if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) 1088 attrs[0] &= ~FATTR4_WORD0_FILEID; 1089 else 1090 attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; 1091 WRITE32(attrs[0] & readdir->bitmask[0]); 1092 WRITE32(attrs[1] & readdir->bitmask[1]); 1093 dprintk("%s: cookie = %Lu, verifier = 0x%x%x, bitmap = 0x%x%x\n", 1094 __FUNCTION__, 1095 (unsigned long long)readdir->cookie, 1096 ((u32 *)readdir->verifier.data)[0], 1097 ((u32 *)readdir->verifier.data)[1], 1098 attrs[0] & readdir->bitmask[0], 1099 attrs[1] & readdir->bitmask[1]); 1100 1101 /* set up reply kvec 1102 * toplevel_status + taglen + rescount + OP_PUTFH + status 1103 * + OP_READDIR + status + verifer(2) = 9 1104 */ 1105 replen = (RPC_REPHDRSIZE + auth->au_rslack + 9) << 2; 1106 xdr_inline_pages(&req->rq_rcv_buf, replen, readdir->pages, 1107 readdir->pgbase, readdir->count); 1108 dprintk("%s: inlined page args = (%u, %p, %u, %u)\n", 1109 __FUNCTION__, replen, readdir->pages, 1110 readdir->pgbase, readdir->count); 1111 1112 return 0; 1113 } 1114 1115 static int encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req) 1116 { 1117 struct rpc_auth *auth = req->rq_task->tk_auth; 1118 unsigned int replen; 1119 uint32_t *p; 1120 1121 RESERVE_SPACE(4); 1122 WRITE32(OP_READLINK); 1123 1124 /* set up reply kvec 1125 * toplevel_status + taglen + rescount + OP_PUTFH + status 1126 * + OP_READLINK + status + string length = 8 1127 */ 1128 replen = (RPC_REPHDRSIZE + auth->au_rslack + 8) << 2; 1129 xdr_inline_pages(&req->rq_rcv_buf, replen, readlink->pages, 1130 readlink->pgbase, readlink->pglen); 1131 1132 return 0; 1133 } 1134 1135 static int encode_remove(struct xdr_stream *xdr, const struct qstr *name) 1136 { 1137 uint32_t *p; 1138 1139 RESERVE_SPACE(8 + name->len); 1140 WRITE32(OP_REMOVE); 1141 WRITE32(name->len); 1142 WRITEMEM(name->name, name->len); 1143 1144 return 0; 1145 } 1146 1147 static int encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname) 1148 { 1149 uint32_t *p; 1150 1151 RESERVE_SPACE(8 + oldname->len); 1152 WRITE32(OP_RENAME); 1153 WRITE32(oldname->len); 1154 WRITEMEM(oldname->name, oldname->len); 1155 1156 RESERVE_SPACE(4 + newname->len); 1157 WRITE32(newname->len); 1158 WRITEMEM(newname->name, newname->len); 1159 1160 return 0; 1161 } 1162 1163 static int encode_renew(struct xdr_stream *xdr, const struct nfs4_client *client_stateid) 1164 { 1165 uint32_t *p; 1166 1167 RESERVE_SPACE(12); 1168 WRITE32(OP_RENEW); 1169 WRITE64(client_stateid->cl_clientid); 1170 1171 return 0; 1172 } 1173 1174 static int 1175 encode_restorefh(struct xdr_stream *xdr) 1176 { 1177 uint32_t *p; 1178 1179 RESERVE_SPACE(4); 1180 WRITE32(OP_RESTOREFH); 1181 1182 return 0; 1183 } 1184 1185 static int 1186 encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg) 1187 { 1188 uint32_t *p; 1189 1190 RESERVE_SPACE(4+sizeof(zero_stateid.data)); 1191 WRITE32(OP_SETATTR); 1192 WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data)); 1193 RESERVE_SPACE(2*4); 1194 WRITE32(1); 1195 WRITE32(FATTR4_WORD0_ACL); 1196 if (arg->acl_len % 4) 1197 return -EINVAL; 1198 RESERVE_SPACE(4); 1199 WRITE32(arg->acl_len); 1200 xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len); 1201 return 0; 1202 } 1203 1204 static int 1205 encode_savefh(struct xdr_stream *xdr) 1206 { 1207 uint32_t *p; 1208 1209 RESERVE_SPACE(4); 1210 WRITE32(OP_SAVEFH); 1211 1212 return 0; 1213 } 1214 1215 static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server) 1216 { 1217 int status; 1218 uint32_t *p; 1219 1220 RESERVE_SPACE(4+sizeof(arg->stateid.data)); 1221 WRITE32(OP_SETATTR); 1222 WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data)); 1223 1224 if ((status = encode_attrs(xdr, arg->iap, server))) 1225 return status; 1226 1227 return 0; 1228 } 1229 1230 static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid) 1231 { 1232 uint32_t *p; 1233 1234 RESERVE_SPACE(4 + sizeof(setclientid->sc_verifier->data)); 1235 WRITE32(OP_SETCLIENTID); 1236 WRITEMEM(setclientid->sc_verifier->data, sizeof(setclientid->sc_verifier->data)); 1237 1238 encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name); 1239 RESERVE_SPACE(4); 1240 WRITE32(setclientid->sc_prog); 1241 encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid); 1242 encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr); 1243 RESERVE_SPACE(4); 1244 WRITE32(setclientid->sc_cb_ident); 1245 1246 return 0; 1247 } 1248 1249 static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs4_client *client_state) 1250 { 1251 uint32_t *p; 1252 1253 RESERVE_SPACE(12 + sizeof(client_state->cl_confirm.data)); 1254 WRITE32(OP_SETCLIENTID_CONFIRM); 1255 WRITE64(client_state->cl_clientid); 1256 WRITEMEM(client_state->cl_confirm.data, sizeof(client_state->cl_confirm.data)); 1257 1258 return 0; 1259 } 1260 1261 static int encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args) 1262 { 1263 uint32_t *p; 1264 1265 RESERVE_SPACE(4); 1266 WRITE32(OP_WRITE); 1267 1268 encode_stateid(xdr, args->context); 1269 1270 RESERVE_SPACE(16); 1271 WRITE64(args->offset); 1272 WRITE32(args->stable); 1273 WRITE32(args->count); 1274 1275 xdr_write_pages(xdr, args->pages, args->pgbase, args->count); 1276 1277 return 0; 1278 } 1279 1280 static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid) 1281 { 1282 uint32_t *p; 1283 1284 RESERVE_SPACE(20); 1285 1286 WRITE32(OP_DELEGRETURN); 1287 WRITEMEM(stateid->data, sizeof(stateid->data)); 1288 return 0; 1289 1290 } 1291 /* 1292 * END OF "GENERIC" ENCODE ROUTINES. 1293 */ 1294 1295 /* 1296 * Encode an ACCESS request 1297 */ 1298 static int nfs4_xdr_enc_access(struct rpc_rqst *req, uint32_t *p, const struct nfs4_accessargs *args) 1299 { 1300 struct xdr_stream xdr; 1301 struct compound_hdr hdr = { 1302 .nops = 2, 1303 }; 1304 int status; 1305 1306 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1307 encode_compound_hdr(&xdr, &hdr); 1308 if ((status = encode_putfh(&xdr, args->fh)) == 0) 1309 status = encode_access(&xdr, args->access); 1310 return status; 1311 } 1312 1313 /* 1314 * Encode LOOKUP request 1315 */ 1316 static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, uint32_t *p, const struct nfs4_lookup_arg *args) 1317 { 1318 struct xdr_stream xdr; 1319 struct compound_hdr hdr = { 1320 .nops = 4, 1321 }; 1322 int status; 1323 1324 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1325 encode_compound_hdr(&xdr, &hdr); 1326 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0) 1327 goto out; 1328 if ((status = encode_lookup(&xdr, args->name)) != 0) 1329 goto out; 1330 if ((status = encode_getfh(&xdr)) != 0) 1331 goto out; 1332 status = encode_getfattr(&xdr, args->bitmask); 1333 out: 1334 return status; 1335 } 1336 1337 /* 1338 * Encode LOOKUP_ROOT request 1339 */ 1340 static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, uint32_t *p, const struct nfs4_lookup_root_arg *args) 1341 { 1342 struct xdr_stream xdr; 1343 struct compound_hdr hdr = { 1344 .nops = 3, 1345 }; 1346 int status; 1347 1348 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1349 encode_compound_hdr(&xdr, &hdr); 1350 if ((status = encode_putrootfh(&xdr)) != 0) 1351 goto out; 1352 if ((status = encode_getfh(&xdr)) == 0) 1353 status = encode_getfattr(&xdr, args->bitmask); 1354 out: 1355 return status; 1356 } 1357 1358 /* 1359 * Encode REMOVE request 1360 */ 1361 static int nfs4_xdr_enc_remove(struct rpc_rqst *req, uint32_t *p, const struct nfs4_remove_arg *args) 1362 { 1363 struct xdr_stream xdr; 1364 struct compound_hdr hdr = { 1365 .nops = 3, 1366 }; 1367 int status; 1368 1369 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1370 encode_compound_hdr(&xdr, &hdr); 1371 if ((status = encode_putfh(&xdr, args->fh)) != 0) 1372 goto out; 1373 if ((status = encode_remove(&xdr, args->name)) != 0) 1374 goto out; 1375 status = encode_getfattr(&xdr, args->bitmask); 1376 out: 1377 return status; 1378 } 1379 1380 /* 1381 * Encode RENAME request 1382 */ 1383 static int nfs4_xdr_enc_rename(struct rpc_rqst *req, uint32_t *p, const struct nfs4_rename_arg *args) 1384 { 1385 struct xdr_stream xdr; 1386 struct compound_hdr hdr = { 1387 .nops = 7, 1388 }; 1389 int status; 1390 1391 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1392 encode_compound_hdr(&xdr, &hdr); 1393 if ((status = encode_putfh(&xdr, args->old_dir)) != 0) 1394 goto out; 1395 if ((status = encode_savefh(&xdr)) != 0) 1396 goto out; 1397 if ((status = encode_putfh(&xdr, args->new_dir)) != 0) 1398 goto out; 1399 if ((status = encode_rename(&xdr, args->old_name, args->new_name)) != 0) 1400 goto out; 1401 if ((status = encode_getfattr(&xdr, args->bitmask)) != 0) 1402 goto out; 1403 if ((status = encode_restorefh(&xdr)) != 0) 1404 goto out; 1405 status = encode_getfattr(&xdr, args->bitmask); 1406 out: 1407 return status; 1408 } 1409 1410 /* 1411 * Encode LINK request 1412 */ 1413 static int nfs4_xdr_enc_link(struct rpc_rqst *req, uint32_t *p, const struct nfs4_link_arg *args) 1414 { 1415 struct xdr_stream xdr; 1416 struct compound_hdr hdr = { 1417 .nops = 7, 1418 }; 1419 int status; 1420 1421 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1422 encode_compound_hdr(&xdr, &hdr); 1423 if ((status = encode_putfh(&xdr, args->fh)) != 0) 1424 goto out; 1425 if ((status = encode_savefh(&xdr)) != 0) 1426 goto out; 1427 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0) 1428 goto out; 1429 if ((status = encode_link(&xdr, args->name)) != 0) 1430 goto out; 1431 if ((status = encode_getfattr(&xdr, args->bitmask)) != 0) 1432 goto out; 1433 if ((status = encode_restorefh(&xdr)) != 0) 1434 goto out; 1435 status = encode_getfattr(&xdr, args->bitmask); 1436 out: 1437 return status; 1438 } 1439 1440 /* 1441 * Encode CREATE request 1442 */ 1443 static int nfs4_xdr_enc_create(struct rpc_rqst *req, uint32_t *p, const struct nfs4_create_arg *args) 1444 { 1445 struct xdr_stream xdr; 1446 struct compound_hdr hdr = { 1447 .nops = 7, 1448 }; 1449 int status; 1450 1451 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1452 encode_compound_hdr(&xdr, &hdr); 1453 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0) 1454 goto out; 1455 if ((status = encode_savefh(&xdr)) != 0) 1456 goto out; 1457 if ((status = encode_create(&xdr, args)) != 0) 1458 goto out; 1459 if ((status = encode_getfh(&xdr)) != 0) 1460 goto out; 1461 if ((status = encode_getfattr(&xdr, args->bitmask)) != 0) 1462 goto out; 1463 if ((status = encode_restorefh(&xdr)) != 0) 1464 goto out; 1465 status = encode_getfattr(&xdr, args->bitmask); 1466 out: 1467 return status; 1468 } 1469 1470 /* 1471 * Encode SYMLINK request 1472 */ 1473 static int nfs4_xdr_enc_symlink(struct rpc_rqst *req, uint32_t *p, const struct nfs4_create_arg *args) 1474 { 1475 return nfs4_xdr_enc_create(req, p, args); 1476 } 1477 1478 /* 1479 * Encode GETATTR request 1480 */ 1481 static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, uint32_t *p, const struct nfs4_getattr_arg *args) 1482 { 1483 struct xdr_stream xdr; 1484 struct compound_hdr hdr = { 1485 .nops = 2, 1486 }; 1487 int status; 1488 1489 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1490 encode_compound_hdr(&xdr, &hdr); 1491 if ((status = encode_putfh(&xdr, args->fh)) == 0) 1492 status = encode_getfattr(&xdr, args->bitmask); 1493 return status; 1494 } 1495 1496 /* 1497 * Encode a CLOSE request 1498 */ 1499 static int nfs4_xdr_enc_close(struct rpc_rqst *req, uint32_t *p, struct nfs_closeargs *args) 1500 { 1501 struct xdr_stream xdr; 1502 struct compound_hdr hdr = { 1503 .nops = 3, 1504 }; 1505 int status; 1506 1507 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1508 encode_compound_hdr(&xdr, &hdr); 1509 status = encode_putfh(&xdr, args->fh); 1510 if(status) 1511 goto out; 1512 status = encode_close(&xdr, args); 1513 if (status != 0) 1514 goto out; 1515 status = encode_getfattr(&xdr, args->bitmask); 1516 out: 1517 return status; 1518 } 1519 1520 /* 1521 * Encode an OPEN request 1522 */ 1523 static int nfs4_xdr_enc_open(struct rpc_rqst *req, uint32_t *p, struct nfs_openargs *args) 1524 { 1525 struct xdr_stream xdr; 1526 struct compound_hdr hdr = { 1527 .nops = 7, 1528 }; 1529 int status; 1530 1531 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1532 encode_compound_hdr(&xdr, &hdr); 1533 status = encode_putfh(&xdr, args->fh); 1534 if (status) 1535 goto out; 1536 status = encode_savefh(&xdr); 1537 if (status) 1538 goto out; 1539 status = encode_open(&xdr, args); 1540 if (status) 1541 goto out; 1542 status = encode_getfh(&xdr); 1543 if (status) 1544 goto out; 1545 status = encode_getfattr(&xdr, args->bitmask); 1546 if (status) 1547 goto out; 1548 status = encode_restorefh(&xdr); 1549 if (status) 1550 goto out; 1551 status = encode_getfattr(&xdr, args->bitmask); 1552 out: 1553 return status; 1554 } 1555 1556 /* 1557 * Encode an OPEN_CONFIRM request 1558 */ 1559 static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, uint32_t *p, struct nfs_open_confirmargs *args) 1560 { 1561 struct xdr_stream xdr; 1562 struct compound_hdr hdr = { 1563 .nops = 2, 1564 }; 1565 int status; 1566 1567 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1568 encode_compound_hdr(&xdr, &hdr); 1569 status = encode_putfh(&xdr, args->fh); 1570 if(status) 1571 goto out; 1572 status = encode_open_confirm(&xdr, args); 1573 out: 1574 return status; 1575 } 1576 1577 /* 1578 * Encode an OPEN request with no attributes. 1579 */ 1580 static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, uint32_t *p, struct nfs_openargs *args) 1581 { 1582 struct xdr_stream xdr; 1583 struct compound_hdr hdr = { 1584 .nops = 3, 1585 }; 1586 int status; 1587 1588 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1589 encode_compound_hdr(&xdr, &hdr); 1590 status = encode_putfh(&xdr, args->fh); 1591 if (status) 1592 goto out; 1593 status = encode_open(&xdr, args); 1594 if (status) 1595 goto out; 1596 status = encode_getfattr(&xdr, args->bitmask); 1597 out: 1598 return status; 1599 } 1600 1601 /* 1602 * Encode an OPEN_DOWNGRADE request 1603 */ 1604 static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, uint32_t *p, struct nfs_closeargs *args) 1605 { 1606 struct xdr_stream xdr; 1607 struct compound_hdr hdr = { 1608 .nops = 3, 1609 }; 1610 int status; 1611 1612 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1613 encode_compound_hdr(&xdr, &hdr); 1614 status = encode_putfh(&xdr, args->fh); 1615 if (status) 1616 goto out; 1617 status = encode_open_downgrade(&xdr, args); 1618 if (status != 0) 1619 goto out; 1620 status = encode_getfattr(&xdr, args->bitmask); 1621 out: 1622 return status; 1623 } 1624 1625 /* 1626 * Encode a LOCK request 1627 */ 1628 static int nfs4_xdr_enc_lock(struct rpc_rqst *req, uint32_t *p, struct nfs_lock_args *args) 1629 { 1630 struct xdr_stream xdr; 1631 struct compound_hdr hdr = { 1632 .nops = 2, 1633 }; 1634 int status; 1635 1636 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1637 encode_compound_hdr(&xdr, &hdr); 1638 status = encode_putfh(&xdr, args->fh); 1639 if(status) 1640 goto out; 1641 status = encode_lock(&xdr, args); 1642 out: 1643 return status; 1644 } 1645 1646 /* 1647 * Encode a LOCKT request 1648 */ 1649 static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, uint32_t *p, struct nfs_lockt_args *args) 1650 { 1651 struct xdr_stream xdr; 1652 struct compound_hdr hdr = { 1653 .nops = 2, 1654 }; 1655 int status; 1656 1657 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1658 encode_compound_hdr(&xdr, &hdr); 1659 status = encode_putfh(&xdr, args->fh); 1660 if(status) 1661 goto out; 1662 status = encode_lockt(&xdr, args); 1663 out: 1664 return status; 1665 } 1666 1667 /* 1668 * Encode a LOCKU request 1669 */ 1670 static int nfs4_xdr_enc_locku(struct rpc_rqst *req, uint32_t *p, struct nfs_locku_args *args) 1671 { 1672 struct xdr_stream xdr; 1673 struct compound_hdr hdr = { 1674 .nops = 2, 1675 }; 1676 int status; 1677 1678 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1679 encode_compound_hdr(&xdr, &hdr); 1680 status = encode_putfh(&xdr, args->fh); 1681 if(status) 1682 goto out; 1683 status = encode_locku(&xdr, args); 1684 out: 1685 return status; 1686 } 1687 1688 /* 1689 * Encode a READLINK request 1690 */ 1691 static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, uint32_t *p, const struct nfs4_readlink *args) 1692 { 1693 struct xdr_stream xdr; 1694 struct compound_hdr hdr = { 1695 .nops = 2, 1696 }; 1697 int status; 1698 1699 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1700 encode_compound_hdr(&xdr, &hdr); 1701 status = encode_putfh(&xdr, args->fh); 1702 if(status) 1703 goto out; 1704 status = encode_readlink(&xdr, args, req); 1705 out: 1706 return status; 1707 } 1708 1709 /* 1710 * Encode a READDIR request 1711 */ 1712 static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, uint32_t *p, const struct nfs4_readdir_arg *args) 1713 { 1714 struct xdr_stream xdr; 1715 struct compound_hdr hdr = { 1716 .nops = 2, 1717 }; 1718 int status; 1719 1720 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1721 encode_compound_hdr(&xdr, &hdr); 1722 status = encode_putfh(&xdr, args->fh); 1723 if(status) 1724 goto out; 1725 status = encode_readdir(&xdr, args, req); 1726 out: 1727 return status; 1728 } 1729 1730 /* 1731 * Encode a READ request 1732 */ 1733 static int nfs4_xdr_enc_read(struct rpc_rqst *req, uint32_t *p, struct nfs_readargs *args) 1734 { 1735 struct rpc_auth *auth = req->rq_task->tk_auth; 1736 struct xdr_stream xdr; 1737 struct compound_hdr hdr = { 1738 .nops = 2, 1739 }; 1740 int replen, status; 1741 1742 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1743 encode_compound_hdr(&xdr, &hdr); 1744 status = encode_putfh(&xdr, args->fh); 1745 if (status) 1746 goto out; 1747 status = encode_read(&xdr, args); 1748 if (status) 1749 goto out; 1750 1751 /* set up reply kvec 1752 * toplevel status + taglen=0 + rescount + OP_PUTFH + status 1753 * + OP_READ + status + eof + datalen = 9 1754 */ 1755 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_read_sz) << 2; 1756 xdr_inline_pages(&req->rq_rcv_buf, replen, 1757 args->pages, args->pgbase, args->count); 1758 out: 1759 return status; 1760 } 1761 1762 /* 1763 * Encode an SETATTR request 1764 */ 1765 static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, uint32_t *p, struct nfs_setattrargs *args) 1766 1767 { 1768 struct xdr_stream xdr; 1769 struct compound_hdr hdr = { 1770 .nops = 3, 1771 }; 1772 int status; 1773 1774 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1775 encode_compound_hdr(&xdr, &hdr); 1776 status = encode_putfh(&xdr, args->fh); 1777 if(status) 1778 goto out; 1779 status = encode_setattr(&xdr, args, args->server); 1780 if(status) 1781 goto out; 1782 status = encode_getfattr(&xdr, args->bitmask); 1783 out: 1784 return status; 1785 } 1786 1787 /* 1788 * Encode a GETACL request 1789 */ 1790 static int 1791 nfs4_xdr_enc_getacl(struct rpc_rqst *req, uint32_t *p, 1792 struct nfs_getaclargs *args) 1793 { 1794 struct xdr_stream xdr; 1795 struct rpc_auth *auth = req->rq_task->tk_auth; 1796 struct compound_hdr hdr = { 1797 .nops = 2, 1798 }; 1799 int replen, status; 1800 1801 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1802 encode_compound_hdr(&xdr, &hdr); 1803 status = encode_putfh(&xdr, args->fh); 1804 if (status) 1805 goto out; 1806 status = encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0); 1807 /* set up reply buffer: */ 1808 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_getacl_sz) << 2; 1809 xdr_inline_pages(&req->rq_rcv_buf, replen, 1810 args->acl_pages, args->acl_pgbase, args->acl_len); 1811 out: 1812 return status; 1813 } 1814 1815 /* 1816 * Encode a WRITE request 1817 */ 1818 static int nfs4_xdr_enc_write(struct rpc_rqst *req, uint32_t *p, struct nfs_writeargs *args) 1819 { 1820 struct xdr_stream xdr; 1821 struct compound_hdr hdr = { 1822 .nops = 3, 1823 }; 1824 int status; 1825 1826 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1827 encode_compound_hdr(&xdr, &hdr); 1828 status = encode_putfh(&xdr, args->fh); 1829 if (status) 1830 goto out; 1831 status = encode_write(&xdr, args); 1832 if (status) 1833 goto out; 1834 status = encode_getfattr(&xdr, args->bitmask); 1835 out: 1836 return status; 1837 } 1838 1839 /* 1840 * a COMMIT request 1841 */ 1842 static int nfs4_xdr_enc_commit(struct rpc_rqst *req, uint32_t *p, struct nfs_writeargs *args) 1843 { 1844 struct xdr_stream xdr; 1845 struct compound_hdr hdr = { 1846 .nops = 3, 1847 }; 1848 int status; 1849 1850 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1851 encode_compound_hdr(&xdr, &hdr); 1852 status = encode_putfh(&xdr, args->fh); 1853 if (status) 1854 goto out; 1855 status = encode_commit(&xdr, args); 1856 if (status) 1857 goto out; 1858 status = encode_getfattr(&xdr, args->bitmask); 1859 out: 1860 return status; 1861 } 1862 1863 /* 1864 * FSINFO request 1865 */ 1866 static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, uint32_t *p, struct nfs4_fsinfo_arg *args) 1867 { 1868 struct xdr_stream xdr; 1869 struct compound_hdr hdr = { 1870 .nops = 2, 1871 }; 1872 int status; 1873 1874 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1875 encode_compound_hdr(&xdr, &hdr); 1876 status = encode_putfh(&xdr, args->fh); 1877 if (!status) 1878 status = encode_fsinfo(&xdr, args->bitmask); 1879 return status; 1880 } 1881 1882 /* 1883 * a PATHCONF request 1884 */ 1885 static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, uint32_t *p, const struct nfs4_pathconf_arg *args) 1886 { 1887 struct xdr_stream xdr; 1888 struct compound_hdr hdr = { 1889 .nops = 2, 1890 }; 1891 int status; 1892 1893 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1894 encode_compound_hdr(&xdr, &hdr); 1895 status = encode_putfh(&xdr, args->fh); 1896 if (!status) 1897 status = encode_getattr_one(&xdr, 1898 args->bitmask[0] & nfs4_pathconf_bitmap[0]); 1899 return status; 1900 } 1901 1902 /* 1903 * a STATFS request 1904 */ 1905 static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, uint32_t *p, const struct nfs4_statfs_arg *args) 1906 { 1907 struct xdr_stream xdr; 1908 struct compound_hdr hdr = { 1909 .nops = 2, 1910 }; 1911 int status; 1912 1913 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1914 encode_compound_hdr(&xdr, &hdr); 1915 status = encode_putfh(&xdr, args->fh); 1916 if (status == 0) 1917 status = encode_getattr_two(&xdr, 1918 args->bitmask[0] & nfs4_statfs_bitmap[0], 1919 args->bitmask[1] & nfs4_statfs_bitmap[1]); 1920 return status; 1921 } 1922 1923 /* 1924 * GETATTR_BITMAP request 1925 */ 1926 static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, uint32_t *p, const struct nfs_fh *fhandle) 1927 { 1928 struct xdr_stream xdr; 1929 struct compound_hdr hdr = { 1930 .nops = 2, 1931 }; 1932 int status; 1933 1934 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1935 encode_compound_hdr(&xdr, &hdr); 1936 status = encode_putfh(&xdr, fhandle); 1937 if (status == 0) 1938 status = encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS| 1939 FATTR4_WORD0_LINK_SUPPORT| 1940 FATTR4_WORD0_SYMLINK_SUPPORT| 1941 FATTR4_WORD0_ACLSUPPORT); 1942 return status; 1943 } 1944 1945 /* 1946 * a RENEW request 1947 */ 1948 static int nfs4_xdr_enc_renew(struct rpc_rqst *req, uint32_t *p, struct nfs4_client *clp) 1949 { 1950 struct xdr_stream xdr; 1951 struct compound_hdr hdr = { 1952 .nops = 1, 1953 }; 1954 1955 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1956 encode_compound_hdr(&xdr, &hdr); 1957 return encode_renew(&xdr, clp); 1958 } 1959 1960 /* 1961 * a SETCLIENTID request 1962 */ 1963 static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, uint32_t *p, struct nfs4_setclientid *sc) 1964 { 1965 struct xdr_stream xdr; 1966 struct compound_hdr hdr = { 1967 .nops = 1, 1968 }; 1969 1970 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1971 encode_compound_hdr(&xdr, &hdr); 1972 return encode_setclientid(&xdr, sc); 1973 } 1974 1975 /* 1976 * a SETCLIENTID_CONFIRM request 1977 */ 1978 static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, uint32_t *p, struct nfs4_client *clp) 1979 { 1980 struct xdr_stream xdr; 1981 struct compound_hdr hdr = { 1982 .nops = 3, 1983 }; 1984 const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 }; 1985 int status; 1986 1987 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 1988 encode_compound_hdr(&xdr, &hdr); 1989 status = encode_setclientid_confirm(&xdr, clp); 1990 if (!status) 1991 status = encode_putrootfh(&xdr); 1992 if (!status) 1993 status = encode_fsinfo(&xdr, lease_bitmap); 1994 return status; 1995 } 1996 1997 /* 1998 * DELEGRETURN request 1999 */ 2000 static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, uint32_t *p, const struct nfs4_delegreturnargs *args) 2001 { 2002 struct xdr_stream xdr; 2003 struct compound_hdr hdr = { 2004 .nops = 3, 2005 }; 2006 int status; 2007 2008 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 2009 encode_compound_hdr(&xdr, &hdr); 2010 status = encode_putfh(&xdr, args->fhandle); 2011 if (status != 0) 2012 goto out; 2013 status = encode_delegreturn(&xdr, args->stateid); 2014 if (status != 0) 2015 goto out; 2016 status = encode_getfattr(&xdr, args->bitmask); 2017 out: 2018 return status; 2019 } 2020 2021 /* 2022 * Encode FS_LOCATIONS request 2023 */ 2024 static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, uint32_t *p, struct nfs4_fs_locations_arg *args) 2025 { 2026 struct xdr_stream xdr; 2027 struct compound_hdr hdr = { 2028 .nops = 3, 2029 }; 2030 struct rpc_auth *auth = req->rq_task->tk_auth; 2031 int replen; 2032 int status; 2033 2034 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 2035 encode_compound_hdr(&xdr, &hdr); 2036 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0) 2037 goto out; 2038 if ((status = encode_lookup(&xdr, args->name)) != 0) 2039 goto out; 2040 if ((status = encode_fs_locations(&xdr, args->bitmask)) != 0) 2041 goto out; 2042 /* set up reply 2043 * toplevel_status + OP_PUTFH + status 2044 * + OP_LOOKUP + status + OP_GETATTR + status = 7 2045 */ 2046 replen = (RPC_REPHDRSIZE + auth->au_rslack + 7) << 2; 2047 xdr_inline_pages(&req->rq_rcv_buf, replen, &args->page, 2048 0, PAGE_SIZE); 2049 out: 2050 return status; 2051 } 2052 2053 /* 2054 * START OF "GENERIC" DECODE ROUTINES. 2055 * These may look a little ugly since they are imported from a "generic" 2056 * set of XDR encode/decode routines which are intended to be shared by 2057 * all of our NFSv4 implementations (OpenBSD, MacOS X...). 2058 * 2059 * If the pain of reading these is too great, it should be a straightforward 2060 * task to translate them into Linux-specific versions which are more 2061 * consistent with the style used in NFSv2/v3... 2062 */ 2063 #define READ32(x) (x) = ntohl(*p++) 2064 #define READ64(x) do { \ 2065 (x) = (u64)ntohl(*p++) << 32; \ 2066 (x) |= ntohl(*p++); \ 2067 } while (0) 2068 #define READTIME(x) do { \ 2069 p++; \ 2070 (x.tv_sec) = ntohl(*p++); \ 2071 (x.tv_nsec) = ntohl(*p++); \ 2072 } while (0) 2073 #define COPYMEM(x,nbytes) do { \ 2074 memcpy((x), p, nbytes); \ 2075 p += XDR_QUADLEN(nbytes); \ 2076 } while (0) 2077 2078 #define READ_BUF(nbytes) do { \ 2079 p = xdr_inline_decode(xdr, nbytes); \ 2080 if (!p) { \ 2081 printk(KERN_WARNING "%s: reply buffer overflowed in line %d.", \ 2082 __FUNCTION__, __LINE__); \ 2083 return -EIO; \ 2084 } \ 2085 } while (0) 2086 2087 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string) 2088 { 2089 uint32_t *p; 2090 2091 READ_BUF(4); 2092 READ32(*len); 2093 READ_BUF(*len); 2094 *string = (char *)p; 2095 return 0; 2096 } 2097 2098 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr) 2099 { 2100 uint32_t *p; 2101 2102 READ_BUF(8); 2103 READ32(hdr->status); 2104 READ32(hdr->taglen); 2105 2106 READ_BUF(hdr->taglen + 4); 2107 hdr->tag = (char *)p; 2108 p += XDR_QUADLEN(hdr->taglen); 2109 READ32(hdr->nops); 2110 return 0; 2111 } 2112 2113 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected) 2114 { 2115 uint32_t *p; 2116 uint32_t opnum; 2117 int32_t nfserr; 2118 2119 READ_BUF(8); 2120 READ32(opnum); 2121 if (opnum != expected) { 2122 printk(KERN_NOTICE 2123 "nfs4_decode_op_hdr: Server returned operation" 2124 " %d but we issued a request for %d\n", 2125 opnum, expected); 2126 return -EIO; 2127 } 2128 READ32(nfserr); 2129 if (nfserr != NFS_OK) 2130 return -nfs_stat_to_errno(nfserr); 2131 return 0; 2132 } 2133 2134 /* Dummy routine */ 2135 static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs4_client *clp) 2136 { 2137 uint32_t *p; 2138 unsigned int strlen; 2139 char *str; 2140 2141 READ_BUF(12); 2142 return decode_opaque_inline(xdr, &strlen, &str); 2143 } 2144 2145 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap) 2146 { 2147 uint32_t bmlen, *p; 2148 2149 READ_BUF(4); 2150 READ32(bmlen); 2151 2152 bitmap[0] = bitmap[1] = 0; 2153 READ_BUF((bmlen << 2)); 2154 if (bmlen > 0) { 2155 READ32(bitmap[0]); 2156 if (bmlen > 1) 2157 READ32(bitmap[1]); 2158 } 2159 return 0; 2160 } 2161 2162 static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, uint32_t **savep) 2163 { 2164 uint32_t *p; 2165 2166 READ_BUF(4); 2167 READ32(*attrlen); 2168 *savep = xdr->p; 2169 return 0; 2170 } 2171 2172 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask) 2173 { 2174 if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) { 2175 decode_attr_bitmap(xdr, bitmask); 2176 bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS; 2177 } else 2178 bitmask[0] = bitmask[1] = 0; 2179 dprintk("%s: bitmask=0x%x%x\n", __FUNCTION__, bitmask[0], bitmask[1]); 2180 return 0; 2181 } 2182 2183 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type) 2184 { 2185 uint32_t *p; 2186 2187 *type = 0; 2188 if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U))) 2189 return -EIO; 2190 if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) { 2191 READ_BUF(4); 2192 READ32(*type); 2193 if (*type < NF4REG || *type > NF4NAMEDATTR) { 2194 dprintk("%s: bad type %d\n", __FUNCTION__, *type); 2195 return -EIO; 2196 } 2197 bitmap[0] &= ~FATTR4_WORD0_TYPE; 2198 } 2199 dprintk("%s: type=0%o\n", __FUNCTION__, nfs_type2fmt[*type].nfs2type); 2200 return 0; 2201 } 2202 2203 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change) 2204 { 2205 uint32_t *p; 2206 2207 *change = 0; 2208 if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U))) 2209 return -EIO; 2210 if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) { 2211 READ_BUF(8); 2212 READ64(*change); 2213 bitmap[0] &= ~FATTR4_WORD0_CHANGE; 2214 } 2215 dprintk("%s: change attribute=%Lu\n", __FUNCTION__, 2216 (unsigned long long)*change); 2217 return 0; 2218 } 2219 2220 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size) 2221 { 2222 uint32_t *p; 2223 2224 *size = 0; 2225 if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U))) 2226 return -EIO; 2227 if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) { 2228 READ_BUF(8); 2229 READ64(*size); 2230 bitmap[0] &= ~FATTR4_WORD0_SIZE; 2231 } 2232 dprintk("%s: file size=%Lu\n", __FUNCTION__, (unsigned long long)*size); 2233 return 0; 2234 } 2235 2236 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) 2237 { 2238 uint32_t *p; 2239 2240 *res = 0; 2241 if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U))) 2242 return -EIO; 2243 if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) { 2244 READ_BUF(4); 2245 READ32(*res); 2246 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT; 2247 } 2248 dprintk("%s: link support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true"); 2249 return 0; 2250 } 2251 2252 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) 2253 { 2254 uint32_t *p; 2255 2256 *res = 0; 2257 if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U))) 2258 return -EIO; 2259 if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) { 2260 READ_BUF(4); 2261 READ32(*res); 2262 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT; 2263 } 2264 dprintk("%s: symlink support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true"); 2265 return 0; 2266 } 2267 2268 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid) 2269 { 2270 uint32_t *p; 2271 2272 fsid->major = 0; 2273 fsid->minor = 0; 2274 if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U))) 2275 return -EIO; 2276 if (likely(bitmap[0] & FATTR4_WORD0_FSID)) { 2277 READ_BUF(16); 2278 READ64(fsid->major); 2279 READ64(fsid->minor); 2280 bitmap[0] &= ~FATTR4_WORD0_FSID; 2281 } 2282 dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __FUNCTION__, 2283 (unsigned long long)fsid->major, 2284 (unsigned long long)fsid->minor); 2285 return 0; 2286 } 2287 2288 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) 2289 { 2290 uint32_t *p; 2291 2292 *res = 60; 2293 if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U))) 2294 return -EIO; 2295 if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) { 2296 READ_BUF(4); 2297 READ32(*res); 2298 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME; 2299 } 2300 dprintk("%s: file size=%u\n", __FUNCTION__, (unsigned int)*res); 2301 return 0; 2302 } 2303 2304 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) 2305 { 2306 uint32_t *p; 2307 2308 *res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL; 2309 if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U))) 2310 return -EIO; 2311 if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) { 2312 READ_BUF(4); 2313 READ32(*res); 2314 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT; 2315 } 2316 dprintk("%s: ACLs supported=%u\n", __FUNCTION__, (unsigned int)*res); 2317 return 0; 2318 } 2319 2320 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid) 2321 { 2322 uint32_t *p; 2323 2324 *fileid = 0; 2325 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U))) 2326 return -EIO; 2327 if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) { 2328 READ_BUF(8); 2329 READ64(*fileid); 2330 bitmap[0] &= ~FATTR4_WORD0_FILEID; 2331 } 2332 dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid); 2333 return 0; 2334 } 2335 2336 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid) 2337 { 2338 uint32_t *p; 2339 2340 *fileid = 0; 2341 if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U))) 2342 return -EIO; 2343 if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) { 2344 READ_BUF(8); 2345 READ64(*fileid); 2346 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; 2347 } 2348 dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid); 2349 return 0; 2350 } 2351 2352 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2353 { 2354 uint32_t *p; 2355 int status = 0; 2356 2357 *res = 0; 2358 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U))) 2359 return -EIO; 2360 if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) { 2361 READ_BUF(8); 2362 READ64(*res); 2363 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL; 2364 } 2365 dprintk("%s: files avail=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2366 return status; 2367 } 2368 2369 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2370 { 2371 uint32_t *p; 2372 int status = 0; 2373 2374 *res = 0; 2375 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U))) 2376 return -EIO; 2377 if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) { 2378 READ_BUF(8); 2379 READ64(*res); 2380 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE; 2381 } 2382 dprintk("%s: files free=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2383 return status; 2384 } 2385 2386 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2387 { 2388 uint32_t *p; 2389 int status = 0; 2390 2391 *res = 0; 2392 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U))) 2393 return -EIO; 2394 if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) { 2395 READ_BUF(8); 2396 READ64(*res); 2397 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL; 2398 } 2399 dprintk("%s: files total=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2400 return status; 2401 } 2402 2403 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path) 2404 { 2405 int n; 2406 uint32_t *p; 2407 int status = 0; 2408 2409 READ_BUF(4); 2410 READ32(n); 2411 if (n < 0) 2412 goto out_eio; 2413 if (n == 0) 2414 goto root_path; 2415 dprintk("path "); 2416 path->ncomponents = 0; 2417 while (path->ncomponents < n) { 2418 struct nfs4_string *component = &path->components[path->ncomponents]; 2419 status = decode_opaque_inline(xdr, &component->len, &component->data); 2420 if (unlikely(status != 0)) 2421 goto out_eio; 2422 if (path->ncomponents != n) 2423 dprintk("/"); 2424 dprintk("%s", component->data); 2425 if (path->ncomponents < NFS4_PATHNAME_MAXCOMPONENTS) 2426 path->ncomponents++; 2427 else { 2428 dprintk("cannot parse %d components in path\n", n); 2429 goto out_eio; 2430 } 2431 } 2432 out: 2433 dprintk("\n"); 2434 return status; 2435 root_path: 2436 /* a root pathname is sent as a zero component4 */ 2437 path->ncomponents = 1; 2438 path->components[0].len=0; 2439 path->components[0].data=NULL; 2440 dprintk("path /\n"); 2441 goto out; 2442 out_eio: 2443 dprintk(" status %d", status); 2444 status = -EIO; 2445 goto out; 2446 } 2447 2448 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res) 2449 { 2450 int n; 2451 uint32_t *p; 2452 int status = -EIO; 2453 2454 if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U))) 2455 goto out; 2456 status = 0; 2457 if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS))) 2458 goto out; 2459 dprintk("%s: fsroot ", __FUNCTION__); 2460 status = decode_pathname(xdr, &res->fs_path); 2461 if (unlikely(status != 0)) 2462 goto out; 2463 READ_BUF(4); 2464 READ32(n); 2465 if (n <= 0) 2466 goto out_eio; 2467 res->nlocations = 0; 2468 while (res->nlocations < n) { 2469 int m; 2470 struct nfs4_fs_location *loc = &res->locations[res->nlocations]; 2471 2472 READ_BUF(4); 2473 READ32(m); 2474 if (m <= 0) 2475 goto out_eio; 2476 2477 loc->nservers = 0; 2478 dprintk("%s: servers ", __FUNCTION__); 2479 while (loc->nservers < m) { 2480 struct nfs4_string *server = &loc->servers[loc->nservers]; 2481 status = decode_opaque_inline(xdr, &server->len, &server->data); 2482 if (unlikely(status != 0)) 2483 goto out_eio; 2484 dprintk("%s ", server->data); 2485 if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS) 2486 loc->nservers++; 2487 else { 2488 int i; 2489 dprintk("%s: using first %d of %d servers returned for location %d\n", __FUNCTION__, NFS4_FS_LOCATION_MAXSERVERS, m, res->nlocations); 2490 for (i = loc->nservers; i < m; i++) { 2491 int len; 2492 char *data; 2493 status = decode_opaque_inline(xdr, &len, &data); 2494 if (unlikely(status != 0)) 2495 goto out_eio; 2496 } 2497 } 2498 } 2499 status = decode_pathname(xdr, &loc->rootpath); 2500 if (unlikely(status != 0)) 2501 goto out_eio; 2502 if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES) 2503 res->nlocations++; 2504 } 2505 out: 2506 dprintk("%s: fs_locations done, error = %d\n", __FUNCTION__, status); 2507 return status; 2508 out_eio: 2509 status = -EIO; 2510 goto out; 2511 } 2512 2513 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2514 { 2515 uint32_t *p; 2516 int status = 0; 2517 2518 *res = 0; 2519 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U))) 2520 return -EIO; 2521 if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) { 2522 READ_BUF(8); 2523 READ64(*res); 2524 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE; 2525 } 2526 dprintk("%s: maxfilesize=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2527 return status; 2528 } 2529 2530 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink) 2531 { 2532 uint32_t *p; 2533 int status = 0; 2534 2535 *maxlink = 1; 2536 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U))) 2537 return -EIO; 2538 if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) { 2539 READ_BUF(4); 2540 READ32(*maxlink); 2541 bitmap[0] &= ~FATTR4_WORD0_MAXLINK; 2542 } 2543 dprintk("%s: maxlink=%u\n", __FUNCTION__, *maxlink); 2544 return status; 2545 } 2546 2547 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname) 2548 { 2549 uint32_t *p; 2550 int status = 0; 2551 2552 *maxname = 1024; 2553 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U))) 2554 return -EIO; 2555 if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) { 2556 READ_BUF(4); 2557 READ32(*maxname); 2558 bitmap[0] &= ~FATTR4_WORD0_MAXNAME; 2559 } 2560 dprintk("%s: maxname=%u\n", __FUNCTION__, *maxname); 2561 return status; 2562 } 2563 2564 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) 2565 { 2566 uint32_t *p; 2567 int status = 0; 2568 2569 *res = 1024; 2570 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U))) 2571 return -EIO; 2572 if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) { 2573 uint64_t maxread; 2574 READ_BUF(8); 2575 READ64(maxread); 2576 if (maxread > 0x7FFFFFFF) 2577 maxread = 0x7FFFFFFF; 2578 *res = (uint32_t)maxread; 2579 bitmap[0] &= ~FATTR4_WORD0_MAXREAD; 2580 } 2581 dprintk("%s: maxread=%lu\n", __FUNCTION__, (unsigned long)*res); 2582 return status; 2583 } 2584 2585 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res) 2586 { 2587 uint32_t *p; 2588 int status = 0; 2589 2590 *res = 1024; 2591 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U))) 2592 return -EIO; 2593 if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) { 2594 uint64_t maxwrite; 2595 READ_BUF(8); 2596 READ64(maxwrite); 2597 if (maxwrite > 0x7FFFFFFF) 2598 maxwrite = 0x7FFFFFFF; 2599 *res = (uint32_t)maxwrite; 2600 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE; 2601 } 2602 dprintk("%s: maxwrite=%lu\n", __FUNCTION__, (unsigned long)*res); 2603 return status; 2604 } 2605 2606 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *mode) 2607 { 2608 uint32_t *p; 2609 2610 *mode = 0; 2611 if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U))) 2612 return -EIO; 2613 if (likely(bitmap[1] & FATTR4_WORD1_MODE)) { 2614 READ_BUF(4); 2615 READ32(*mode); 2616 *mode &= ~S_IFMT; 2617 bitmap[1] &= ~FATTR4_WORD1_MODE; 2618 } 2619 dprintk("%s: file mode=0%o\n", __FUNCTION__, (unsigned int)*mode); 2620 return 0; 2621 } 2622 2623 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink) 2624 { 2625 uint32_t *p; 2626 2627 *nlink = 1; 2628 if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U))) 2629 return -EIO; 2630 if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) { 2631 READ_BUF(4); 2632 READ32(*nlink); 2633 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS; 2634 } 2635 dprintk("%s: nlink=%u\n", __FUNCTION__, (unsigned int)*nlink); 2636 return 0; 2637 } 2638 2639 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_client *clp, int32_t *uid) 2640 { 2641 uint32_t len, *p; 2642 2643 *uid = -2; 2644 if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U))) 2645 return -EIO; 2646 if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) { 2647 READ_BUF(4); 2648 READ32(len); 2649 READ_BUF(len); 2650 if (len < XDR_MAX_NETOBJ) { 2651 if (nfs_map_name_to_uid(clp, (char *)p, len, uid) != 0) 2652 dprintk("%s: nfs_map_name_to_uid failed!\n", 2653 __FUNCTION__); 2654 } else 2655 printk(KERN_WARNING "%s: name too long (%u)!\n", 2656 __FUNCTION__, len); 2657 bitmap[1] &= ~FATTR4_WORD1_OWNER; 2658 } 2659 dprintk("%s: uid=%d\n", __FUNCTION__, (int)*uid); 2660 return 0; 2661 } 2662 2663 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_client *clp, int32_t *gid) 2664 { 2665 uint32_t len, *p; 2666 2667 *gid = -2; 2668 if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U))) 2669 return -EIO; 2670 if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) { 2671 READ_BUF(4); 2672 READ32(len); 2673 READ_BUF(len); 2674 if (len < XDR_MAX_NETOBJ) { 2675 if (nfs_map_group_to_gid(clp, (char *)p, len, gid) != 0) 2676 dprintk("%s: nfs_map_group_to_gid failed!\n", 2677 __FUNCTION__); 2678 } else 2679 printk(KERN_WARNING "%s: name too long (%u)!\n", 2680 __FUNCTION__, len); 2681 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP; 2682 } 2683 dprintk("%s: gid=%d\n", __FUNCTION__, (int)*gid); 2684 return 0; 2685 } 2686 2687 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev) 2688 { 2689 uint32_t major = 0, minor = 0, *p; 2690 2691 *rdev = MKDEV(0,0); 2692 if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U))) 2693 return -EIO; 2694 if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) { 2695 dev_t tmp; 2696 2697 READ_BUF(8); 2698 READ32(major); 2699 READ32(minor); 2700 tmp = MKDEV(major, minor); 2701 if (MAJOR(tmp) == major && MINOR(tmp) == minor) 2702 *rdev = tmp; 2703 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV; 2704 } 2705 dprintk("%s: rdev=(0x%x:0x%x)\n", __FUNCTION__, major, minor); 2706 return 0; 2707 } 2708 2709 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2710 { 2711 uint32_t *p; 2712 int status = 0; 2713 2714 *res = 0; 2715 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U))) 2716 return -EIO; 2717 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) { 2718 READ_BUF(8); 2719 READ64(*res); 2720 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL; 2721 } 2722 dprintk("%s: space avail=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2723 return status; 2724 } 2725 2726 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2727 { 2728 uint32_t *p; 2729 int status = 0; 2730 2731 *res = 0; 2732 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U))) 2733 return -EIO; 2734 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) { 2735 READ_BUF(8); 2736 READ64(*res); 2737 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE; 2738 } 2739 dprintk("%s: space free=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2740 return status; 2741 } 2742 2743 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res) 2744 { 2745 uint32_t *p; 2746 int status = 0; 2747 2748 *res = 0; 2749 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U))) 2750 return -EIO; 2751 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) { 2752 READ_BUF(8); 2753 READ64(*res); 2754 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL; 2755 } 2756 dprintk("%s: space total=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2757 return status; 2758 } 2759 2760 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used) 2761 { 2762 uint32_t *p; 2763 2764 *used = 0; 2765 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U))) 2766 return -EIO; 2767 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) { 2768 READ_BUF(8); 2769 READ64(*used); 2770 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED; 2771 } 2772 dprintk("%s: space used=%Lu\n", __FUNCTION__, 2773 (unsigned long long)*used); 2774 return 0; 2775 } 2776 2777 static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time) 2778 { 2779 uint32_t *p; 2780 uint64_t sec; 2781 uint32_t nsec; 2782 2783 READ_BUF(12); 2784 READ64(sec); 2785 READ32(nsec); 2786 time->tv_sec = (time_t)sec; 2787 time->tv_nsec = (long)nsec; 2788 return 0; 2789 } 2790 2791 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time) 2792 { 2793 int status = 0; 2794 2795 time->tv_sec = 0; 2796 time->tv_nsec = 0; 2797 if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U))) 2798 return -EIO; 2799 if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) { 2800 status = decode_attr_time(xdr, time); 2801 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS; 2802 } 2803 dprintk("%s: atime=%ld\n", __FUNCTION__, (long)time->tv_sec); 2804 return status; 2805 } 2806 2807 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time) 2808 { 2809 int status = 0; 2810 2811 time->tv_sec = 0; 2812 time->tv_nsec = 0; 2813 if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U))) 2814 return -EIO; 2815 if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) { 2816 status = decode_attr_time(xdr, time); 2817 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA; 2818 } 2819 dprintk("%s: ctime=%ld\n", __FUNCTION__, (long)time->tv_sec); 2820 return status; 2821 } 2822 2823 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time) 2824 { 2825 int status = 0; 2826 2827 time->tv_sec = 0; 2828 time->tv_nsec = 0; 2829 if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U))) 2830 return -EIO; 2831 if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) { 2832 status = decode_attr_time(xdr, time); 2833 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY; 2834 } 2835 dprintk("%s: mtime=%ld\n", __FUNCTION__, (long)time->tv_sec); 2836 return status; 2837 } 2838 2839 static int verify_attr_len(struct xdr_stream *xdr, uint32_t *savep, uint32_t attrlen) 2840 { 2841 unsigned int attrwords = XDR_QUADLEN(attrlen); 2842 unsigned int nwords = xdr->p - savep; 2843 2844 if (unlikely(attrwords != nwords)) { 2845 printk(KERN_WARNING "%s: server returned incorrect attribute length: %u %c %u\n", 2846 __FUNCTION__, 2847 attrwords << 2, 2848 (attrwords < nwords) ? '<' : '>', 2849 nwords << 2); 2850 return -EIO; 2851 } 2852 return 0; 2853 } 2854 2855 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) 2856 { 2857 uint32_t *p; 2858 2859 READ_BUF(20); 2860 READ32(cinfo->atomic); 2861 READ64(cinfo->before); 2862 READ64(cinfo->after); 2863 return 0; 2864 } 2865 2866 static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access) 2867 { 2868 uint32_t *p; 2869 uint32_t supp, acc; 2870 int status; 2871 2872 status = decode_op_hdr(xdr, OP_ACCESS); 2873 if (status) 2874 return status; 2875 READ_BUF(8); 2876 READ32(supp); 2877 READ32(acc); 2878 access->supported = supp; 2879 access->access = acc; 2880 return 0; 2881 } 2882 2883 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res) 2884 { 2885 uint32_t *p; 2886 int status; 2887 2888 status = decode_op_hdr(xdr, OP_CLOSE); 2889 if (status) 2890 return status; 2891 READ_BUF(sizeof(res->stateid.data)); 2892 COPYMEM(res->stateid.data, sizeof(res->stateid.data)); 2893 return 0; 2894 } 2895 2896 static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res) 2897 { 2898 uint32_t *p; 2899 int status; 2900 2901 status = decode_op_hdr(xdr, OP_COMMIT); 2902 if (status) 2903 return status; 2904 READ_BUF(8); 2905 COPYMEM(res->verf->verifier, 8); 2906 return 0; 2907 } 2908 2909 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) 2910 { 2911 uint32_t *p; 2912 uint32_t bmlen; 2913 int status; 2914 2915 status = decode_op_hdr(xdr, OP_CREATE); 2916 if (status) 2917 return status; 2918 if ((status = decode_change_info(xdr, cinfo))) 2919 return status; 2920 READ_BUF(4); 2921 READ32(bmlen); 2922 READ_BUF(bmlen << 2); 2923 return 0; 2924 } 2925 2926 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res) 2927 { 2928 uint32_t *savep; 2929 uint32_t attrlen, 2930 bitmap[2] = {0}; 2931 int status; 2932 2933 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 2934 goto xdr_error; 2935 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 2936 goto xdr_error; 2937 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 2938 goto xdr_error; 2939 if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0) 2940 goto xdr_error; 2941 if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0) 2942 goto xdr_error; 2943 if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0) 2944 goto xdr_error; 2945 if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0) 2946 goto xdr_error; 2947 status = verify_attr_len(xdr, savep, attrlen); 2948 xdr_error: 2949 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 2950 return status; 2951 } 2952 2953 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat) 2954 { 2955 uint32_t *savep; 2956 uint32_t attrlen, 2957 bitmap[2] = {0}; 2958 int status; 2959 2960 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 2961 goto xdr_error; 2962 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 2963 goto xdr_error; 2964 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 2965 goto xdr_error; 2966 2967 if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0) 2968 goto xdr_error; 2969 if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0) 2970 goto xdr_error; 2971 if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0) 2972 goto xdr_error; 2973 if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0) 2974 goto xdr_error; 2975 if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0) 2976 goto xdr_error; 2977 if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0) 2978 goto xdr_error; 2979 2980 status = verify_attr_len(xdr, savep, attrlen); 2981 xdr_error: 2982 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 2983 return status; 2984 } 2985 2986 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf) 2987 { 2988 uint32_t *savep; 2989 uint32_t attrlen, 2990 bitmap[2] = {0}; 2991 int status; 2992 2993 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 2994 goto xdr_error; 2995 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 2996 goto xdr_error; 2997 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 2998 goto xdr_error; 2999 3000 if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0) 3001 goto xdr_error; 3002 if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0) 3003 goto xdr_error; 3004 3005 status = verify_attr_len(xdr, savep, attrlen); 3006 xdr_error: 3007 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 3008 return status; 3009 } 3010 3011 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, const struct nfs_server *server) 3012 { 3013 uint32_t *savep; 3014 uint32_t attrlen, 3015 bitmap[2] = {0}, 3016 type; 3017 int status, fmode = 0; 3018 uint64_t fileid; 3019 3020 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 3021 goto xdr_error; 3022 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 3023 goto xdr_error; 3024 3025 fattr->bitmap[0] = bitmap[0]; 3026 fattr->bitmap[1] = bitmap[1]; 3027 3028 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 3029 goto xdr_error; 3030 3031 3032 if ((status = decode_attr_type(xdr, bitmap, &type)) != 0) 3033 goto xdr_error; 3034 fattr->type = nfs_type2fmt[type].nfs2type; 3035 fmode = nfs_type2fmt[type].mode; 3036 3037 if ((status = decode_attr_change(xdr, bitmap, &fattr->change_attr)) != 0) 3038 goto xdr_error; 3039 if ((status = decode_attr_size(xdr, bitmap, &fattr->size)) != 0) 3040 goto xdr_error; 3041 if ((status = decode_attr_fsid(xdr, bitmap, &fattr->fsid)) != 0) 3042 goto xdr_error; 3043 if ((status = decode_attr_fileid(xdr, bitmap, &fattr->fileid)) != 0) 3044 goto xdr_error; 3045 if ((status = decode_attr_fs_locations(xdr, bitmap, container_of(fattr, 3046 struct nfs4_fs_locations, 3047 fattr))) != 0) 3048 goto xdr_error; 3049 if ((status = decode_attr_mode(xdr, bitmap, &fattr->mode)) != 0) 3050 goto xdr_error; 3051 fattr->mode |= fmode; 3052 if ((status = decode_attr_nlink(xdr, bitmap, &fattr->nlink)) != 0) 3053 goto xdr_error; 3054 if ((status = decode_attr_owner(xdr, bitmap, server->nfs4_state, &fattr->uid)) != 0) 3055 goto xdr_error; 3056 if ((status = decode_attr_group(xdr, bitmap, server->nfs4_state, &fattr->gid)) != 0) 3057 goto xdr_error; 3058 if ((status = decode_attr_rdev(xdr, bitmap, &fattr->rdev)) != 0) 3059 goto xdr_error; 3060 if ((status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used)) != 0) 3061 goto xdr_error; 3062 if ((status = decode_attr_time_access(xdr, bitmap, &fattr->atime)) != 0) 3063 goto xdr_error; 3064 if ((status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime)) != 0) 3065 goto xdr_error; 3066 if ((status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime)) != 0) 3067 goto xdr_error; 3068 if ((status = decode_attr_mounted_on_fileid(xdr, bitmap, &fileid)) != 0) 3069 goto xdr_error; 3070 if (fattr->fileid == 0 && fileid != 0) 3071 fattr->fileid = fileid; 3072 if ((status = verify_attr_len(xdr, savep, attrlen)) == 0) 3073 fattr->valid = NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4; 3074 xdr_error: 3075 dprintk("%s: xdr returned %d\n", __FUNCTION__, -status); 3076 return status; 3077 } 3078 3079 3080 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo) 3081 { 3082 uint32_t *savep; 3083 uint32_t attrlen, bitmap[2]; 3084 int status; 3085 3086 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 3087 goto xdr_error; 3088 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 3089 goto xdr_error; 3090 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 3091 goto xdr_error; 3092 3093 fsinfo->rtmult = fsinfo->wtmult = 512; /* ??? */ 3094 3095 if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0) 3096 goto xdr_error; 3097 if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0) 3098 goto xdr_error; 3099 if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0) 3100 goto xdr_error; 3101 fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax; 3102 if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0) 3103 goto xdr_error; 3104 fsinfo->wtpref = fsinfo->wtmax; 3105 3106 status = verify_attr_len(xdr, savep, attrlen); 3107 xdr_error: 3108 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 3109 return status; 3110 } 3111 3112 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh) 3113 { 3114 uint32_t *p; 3115 uint32_t len; 3116 int status; 3117 3118 status = decode_op_hdr(xdr, OP_GETFH); 3119 if (status) 3120 return status; 3121 /* Zero handle first to allow comparisons */ 3122 memset(fh, 0, sizeof(*fh)); 3123 3124 READ_BUF(4); 3125 READ32(len); 3126 if (len > NFS4_FHSIZE) 3127 return -EIO; 3128 fh->size = len; 3129 READ_BUF(len); 3130 COPYMEM(fh->data, len); 3131 return 0; 3132 } 3133 3134 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) 3135 { 3136 int status; 3137 3138 status = decode_op_hdr(xdr, OP_LINK); 3139 if (status) 3140 return status; 3141 return decode_change_info(xdr, cinfo); 3142 } 3143 3144 /* 3145 * We create the owner, so we know a proper owner.id length is 4. 3146 */ 3147 static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl) 3148 { 3149 uint64_t offset, length, clientid; 3150 uint32_t *p; 3151 uint32_t namelen, type; 3152 3153 READ_BUF(32); 3154 READ64(offset); 3155 READ64(length); 3156 READ32(type); 3157 if (fl != NULL) { 3158 fl->fl_start = (loff_t)offset; 3159 fl->fl_end = fl->fl_start + (loff_t)length - 1; 3160 if (length == ~(uint64_t)0) 3161 fl->fl_end = OFFSET_MAX; 3162 fl->fl_type = F_WRLCK; 3163 if (type & 1) 3164 fl->fl_type = F_RDLCK; 3165 fl->fl_pid = 0; 3166 } 3167 READ64(clientid); 3168 READ32(namelen); 3169 READ_BUF(namelen); 3170 return -NFS4ERR_DENIED; 3171 } 3172 3173 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res) 3174 { 3175 uint32_t *p; 3176 int status; 3177 3178 status = decode_op_hdr(xdr, OP_LOCK); 3179 if (status == 0) { 3180 READ_BUF(sizeof(res->stateid.data)); 3181 COPYMEM(res->stateid.data, sizeof(res->stateid.data)); 3182 } else if (status == -NFS4ERR_DENIED) 3183 return decode_lock_denied(xdr, NULL); 3184 return status; 3185 } 3186 3187 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res) 3188 { 3189 int status; 3190 status = decode_op_hdr(xdr, OP_LOCKT); 3191 if (status == -NFS4ERR_DENIED) 3192 return decode_lock_denied(xdr, res->denied); 3193 return status; 3194 } 3195 3196 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res) 3197 { 3198 uint32_t *p; 3199 int status; 3200 3201 status = decode_op_hdr(xdr, OP_LOCKU); 3202 if (status == 0) { 3203 READ_BUF(sizeof(res->stateid.data)); 3204 COPYMEM(res->stateid.data, sizeof(res->stateid.data)); 3205 } 3206 return status; 3207 } 3208 3209 static int decode_lookup(struct xdr_stream *xdr) 3210 { 3211 return decode_op_hdr(xdr, OP_LOOKUP); 3212 } 3213 3214 /* This is too sick! */ 3215 static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize) 3216 { 3217 uint32_t *p; 3218 uint32_t limit_type, nblocks, blocksize; 3219 3220 READ_BUF(12); 3221 READ32(limit_type); 3222 switch (limit_type) { 3223 case 1: 3224 READ64(*maxsize); 3225 break; 3226 case 2: 3227 READ32(nblocks); 3228 READ32(blocksize); 3229 *maxsize = (uint64_t)nblocks * (uint64_t)blocksize; 3230 } 3231 return 0; 3232 } 3233 3234 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res) 3235 { 3236 uint32_t *p; 3237 uint32_t delegation_type; 3238 3239 READ_BUF(4); 3240 READ32(delegation_type); 3241 if (delegation_type == NFS4_OPEN_DELEGATE_NONE) { 3242 res->delegation_type = 0; 3243 return 0; 3244 } 3245 READ_BUF(20); 3246 COPYMEM(res->delegation.data, sizeof(res->delegation.data)); 3247 READ32(res->do_recall); 3248 switch (delegation_type) { 3249 case NFS4_OPEN_DELEGATE_READ: 3250 res->delegation_type = FMODE_READ; 3251 break; 3252 case NFS4_OPEN_DELEGATE_WRITE: 3253 res->delegation_type = FMODE_WRITE|FMODE_READ; 3254 if (decode_space_limit(xdr, &res->maxsize) < 0) 3255 return -EIO; 3256 } 3257 return decode_ace(xdr, NULL, res->server->nfs4_state); 3258 } 3259 3260 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res) 3261 { 3262 uint32_t *p; 3263 uint32_t bmlen; 3264 int status; 3265 3266 status = decode_op_hdr(xdr, OP_OPEN); 3267 if (status) 3268 return status; 3269 READ_BUF(sizeof(res->stateid.data)); 3270 COPYMEM(res->stateid.data, sizeof(res->stateid.data)); 3271 3272 decode_change_info(xdr, &res->cinfo); 3273 3274 READ_BUF(8); 3275 READ32(res->rflags); 3276 READ32(bmlen); 3277 if (bmlen > 10) 3278 goto xdr_error; 3279 3280 READ_BUF(bmlen << 2); 3281 p += bmlen; 3282 return decode_delegation(xdr, res); 3283 xdr_error: 3284 dprintk("%s: Bitmap too large! Length = %u\n", __FUNCTION__, bmlen); 3285 return -EIO; 3286 } 3287 3288 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res) 3289 { 3290 uint32_t *p; 3291 int status; 3292 3293 status = decode_op_hdr(xdr, OP_OPEN_CONFIRM); 3294 if (status) 3295 return status; 3296 READ_BUF(sizeof(res->stateid.data)); 3297 COPYMEM(res->stateid.data, sizeof(res->stateid.data)); 3298 return 0; 3299 } 3300 3301 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res) 3302 { 3303 uint32_t *p; 3304 int status; 3305 3306 status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE); 3307 if (status) 3308 return status; 3309 READ_BUF(sizeof(res->stateid.data)); 3310 COPYMEM(res->stateid.data, sizeof(res->stateid.data)); 3311 return 0; 3312 } 3313 3314 static int decode_putfh(struct xdr_stream *xdr) 3315 { 3316 return decode_op_hdr(xdr, OP_PUTFH); 3317 } 3318 3319 static int decode_putrootfh(struct xdr_stream *xdr) 3320 { 3321 return decode_op_hdr(xdr, OP_PUTROOTFH); 3322 } 3323 3324 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res) 3325 { 3326 struct kvec *iov = req->rq_rcv_buf.head; 3327 uint32_t *p; 3328 uint32_t count, eof, recvd, hdrlen; 3329 int status; 3330 3331 status = decode_op_hdr(xdr, OP_READ); 3332 if (status) 3333 return status; 3334 READ_BUF(8); 3335 READ32(eof); 3336 READ32(count); 3337 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 3338 recvd = req->rq_rcv_buf.len - hdrlen; 3339 if (count > recvd) { 3340 printk(KERN_WARNING "NFS: server cheating in read reply: " 3341 "count %u > recvd %u\n", count, recvd); 3342 count = recvd; 3343 eof = 0; 3344 } 3345 xdr_read_pages(xdr, count); 3346 res->eof = eof; 3347 res->count = count; 3348 return 0; 3349 } 3350 3351 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir) 3352 { 3353 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 3354 struct page *page = *rcvbuf->pages; 3355 struct kvec *iov = rcvbuf->head; 3356 unsigned int nr, pglen = rcvbuf->page_len; 3357 uint32_t *end, *entry, *p, *kaddr; 3358 uint32_t len, attrlen; 3359 int hdrlen, recvd, status; 3360 3361 status = decode_op_hdr(xdr, OP_READDIR); 3362 if (status) 3363 return status; 3364 READ_BUF(8); 3365 COPYMEM(readdir->verifier.data, 8); 3366 dprintk("%s: verifier = 0x%x%x\n", 3367 __FUNCTION__, 3368 ((u32 *)readdir->verifier.data)[0], 3369 ((u32 *)readdir->verifier.data)[1]); 3370 3371 3372 hdrlen = (char *) p - (char *) iov->iov_base; 3373 recvd = rcvbuf->len - hdrlen; 3374 if (pglen > recvd) 3375 pglen = recvd; 3376 xdr_read_pages(xdr, pglen); 3377 3378 BUG_ON(pglen + readdir->pgbase > PAGE_CACHE_SIZE); 3379 kaddr = p = (uint32_t *) kmap_atomic(page, KM_USER0); 3380 end = (uint32_t *) ((char *)p + pglen + readdir->pgbase); 3381 entry = p; 3382 for (nr = 0; *p++; nr++) { 3383 if (p + 3 > end) 3384 goto short_pkt; 3385 dprintk("cookie = %Lu, ", *((unsigned long long *)p)); 3386 p += 2; /* cookie */ 3387 len = ntohl(*p++); /* filename length */ 3388 if (len > NFS4_MAXNAMLEN) { 3389 printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)\n", len); 3390 goto err_unmap; 3391 } 3392 dprintk("filename = %*s\n", len, (char *)p); 3393 p += XDR_QUADLEN(len); 3394 if (p + 1 > end) 3395 goto short_pkt; 3396 len = ntohl(*p++); /* bitmap length */ 3397 p += len; 3398 if (p + 1 > end) 3399 goto short_pkt; 3400 attrlen = XDR_QUADLEN(ntohl(*p++)); 3401 p += attrlen; /* attributes */ 3402 if (p + 2 > end) 3403 goto short_pkt; 3404 entry = p; 3405 } 3406 if (!nr && (entry[0] != 0 || entry[1] == 0)) 3407 goto short_pkt; 3408 out: 3409 kunmap_atomic(kaddr, KM_USER0); 3410 return 0; 3411 short_pkt: 3412 dprintk("%s: short packet at entry %d\n", __FUNCTION__, nr); 3413 entry[0] = entry[1] = 0; 3414 /* truncate listing ? */ 3415 if (!nr) { 3416 printk(KERN_NOTICE "NFS: readdir reply truncated!\n"); 3417 entry[1] = 1; 3418 } 3419 goto out; 3420 err_unmap: 3421 kunmap_atomic(kaddr, KM_USER0); 3422 return -errno_NFSERR_IO; 3423 } 3424 3425 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req) 3426 { 3427 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 3428 struct kvec *iov = rcvbuf->head; 3429 int hdrlen, len, recvd; 3430 uint32_t *p; 3431 char *kaddr; 3432 int status; 3433 3434 status = decode_op_hdr(xdr, OP_READLINK); 3435 if (status) 3436 return status; 3437 3438 /* Convert length of symlink */ 3439 READ_BUF(4); 3440 READ32(len); 3441 if (len >= rcvbuf->page_len || len <= 0) { 3442 dprintk(KERN_WARNING "nfs: server returned giant symlink!\n"); 3443 return -ENAMETOOLONG; 3444 } 3445 hdrlen = (char *) xdr->p - (char *) iov->iov_base; 3446 recvd = req->rq_rcv_buf.len - hdrlen; 3447 if (recvd < len) { 3448 printk(KERN_WARNING "NFS: server cheating in readlink reply: " 3449 "count %u > recvd %u\n", len, recvd); 3450 return -EIO; 3451 } 3452 xdr_read_pages(xdr, len); 3453 /* 3454 * The XDR encode routine has set things up so that 3455 * the link text will be copied directly into the 3456 * buffer. We just have to do overflow-checking, 3457 * and and null-terminate the text (the VFS expects 3458 * null-termination). 3459 */ 3460 kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0); 3461 kaddr[len+rcvbuf->page_base] = '\0'; 3462 kunmap_atomic(kaddr, KM_USER0); 3463 return 0; 3464 } 3465 3466 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) 3467 { 3468 int status; 3469 3470 status = decode_op_hdr(xdr, OP_REMOVE); 3471 if (status) 3472 goto out; 3473 status = decode_change_info(xdr, cinfo); 3474 out: 3475 return status; 3476 } 3477 3478 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo, 3479 struct nfs4_change_info *new_cinfo) 3480 { 3481 int status; 3482 3483 status = decode_op_hdr(xdr, OP_RENAME); 3484 if (status) 3485 goto out; 3486 if ((status = decode_change_info(xdr, old_cinfo))) 3487 goto out; 3488 status = decode_change_info(xdr, new_cinfo); 3489 out: 3490 return status; 3491 } 3492 3493 static int decode_renew(struct xdr_stream *xdr) 3494 { 3495 return decode_op_hdr(xdr, OP_RENEW); 3496 } 3497 3498 static int 3499 decode_restorefh(struct xdr_stream *xdr) 3500 { 3501 return decode_op_hdr(xdr, OP_RESTOREFH); 3502 } 3503 3504 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req, 3505 size_t *acl_len) 3506 { 3507 uint32_t *savep; 3508 uint32_t attrlen, 3509 bitmap[2] = {0}; 3510 struct kvec *iov = req->rq_rcv_buf.head; 3511 int status; 3512 3513 *acl_len = 0; 3514 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 3515 goto out; 3516 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 3517 goto out; 3518 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 3519 goto out; 3520 3521 if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U))) 3522 return -EIO; 3523 if (likely(bitmap[0] & FATTR4_WORD0_ACL)) { 3524 int hdrlen, recvd; 3525 3526 /* We ignore &savep and don't do consistency checks on 3527 * the attr length. Let userspace figure it out.... */ 3528 hdrlen = (u8 *)xdr->p - (u8 *)iov->iov_base; 3529 recvd = req->rq_rcv_buf.len - hdrlen; 3530 if (attrlen > recvd) { 3531 printk(KERN_WARNING "NFS: server cheating in getattr" 3532 " acl reply: attrlen %u > recvd %u\n", 3533 attrlen, recvd); 3534 return -EINVAL; 3535 } 3536 xdr_read_pages(xdr, attrlen); 3537 *acl_len = attrlen; 3538 } else 3539 status = -EOPNOTSUPP; 3540 3541 out: 3542 return status; 3543 } 3544 3545 static int 3546 decode_savefh(struct xdr_stream *xdr) 3547 { 3548 return decode_op_hdr(xdr, OP_SAVEFH); 3549 } 3550 3551 static int decode_setattr(struct xdr_stream *xdr, struct nfs_setattrres *res) 3552 { 3553 uint32_t *p; 3554 uint32_t bmlen; 3555 int status; 3556 3557 3558 status = decode_op_hdr(xdr, OP_SETATTR); 3559 if (status) 3560 return status; 3561 READ_BUF(4); 3562 READ32(bmlen); 3563 READ_BUF(bmlen << 2); 3564 return 0; 3565 } 3566 3567 static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_client *clp) 3568 { 3569 uint32_t *p; 3570 uint32_t opnum; 3571 int32_t nfserr; 3572 3573 READ_BUF(8); 3574 READ32(opnum); 3575 if (opnum != OP_SETCLIENTID) { 3576 printk(KERN_NOTICE 3577 "nfs4_decode_setclientid: Server returned operation" 3578 " %d\n", opnum); 3579 return -EIO; 3580 } 3581 READ32(nfserr); 3582 if (nfserr == NFS_OK) { 3583 READ_BUF(8 + sizeof(clp->cl_confirm.data)); 3584 READ64(clp->cl_clientid); 3585 COPYMEM(clp->cl_confirm.data, sizeof(clp->cl_confirm.data)); 3586 } else if (nfserr == NFSERR_CLID_INUSE) { 3587 uint32_t len; 3588 3589 /* skip netid string */ 3590 READ_BUF(4); 3591 READ32(len); 3592 READ_BUF(len); 3593 3594 /* skip uaddr string */ 3595 READ_BUF(4); 3596 READ32(len); 3597 READ_BUF(len); 3598 return -NFSERR_CLID_INUSE; 3599 } else 3600 return -nfs_stat_to_errno(nfserr); 3601 3602 return 0; 3603 } 3604 3605 static int decode_setclientid_confirm(struct xdr_stream *xdr) 3606 { 3607 return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM); 3608 } 3609 3610 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res) 3611 { 3612 uint32_t *p; 3613 int status; 3614 3615 status = decode_op_hdr(xdr, OP_WRITE); 3616 if (status) 3617 return status; 3618 3619 READ_BUF(16); 3620 READ32(res->count); 3621 READ32(res->verf->committed); 3622 COPYMEM(res->verf->verifier, 8); 3623 return 0; 3624 } 3625 3626 static int decode_delegreturn(struct xdr_stream *xdr) 3627 { 3628 return decode_op_hdr(xdr, OP_DELEGRETURN); 3629 } 3630 3631 /* 3632 * Decode OPEN_DOWNGRADE response 3633 */ 3634 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_closeres *res) 3635 { 3636 struct xdr_stream xdr; 3637 struct compound_hdr hdr; 3638 int status; 3639 3640 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3641 status = decode_compound_hdr(&xdr, &hdr); 3642 if (status) 3643 goto out; 3644 status = decode_putfh(&xdr); 3645 if (status) 3646 goto out; 3647 status = decode_open_downgrade(&xdr, res); 3648 if (status != 0) 3649 goto out; 3650 decode_getfattr(&xdr, res->fattr, res->server); 3651 out: 3652 return status; 3653 } 3654 3655 /* 3656 * END OF "GENERIC" DECODE ROUTINES. 3657 */ 3658 3659 /* 3660 * Decode ACCESS response 3661 */ 3662 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_accessres *res) 3663 { 3664 struct xdr_stream xdr; 3665 struct compound_hdr hdr; 3666 int status; 3667 3668 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3669 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3670 goto out; 3671 if ((status = decode_putfh(&xdr)) == 0) 3672 status = decode_access(&xdr, res); 3673 out: 3674 return status; 3675 } 3676 3677 /* 3678 * Decode LOOKUP response 3679 */ 3680 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_lookup_res *res) 3681 { 3682 struct xdr_stream xdr; 3683 struct compound_hdr hdr; 3684 int status; 3685 3686 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3687 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3688 goto out; 3689 if ((status = decode_putfh(&xdr)) != 0) 3690 goto out; 3691 if ((status = decode_lookup(&xdr)) != 0) 3692 goto out; 3693 if ((status = decode_getfh(&xdr, res->fh)) != 0) 3694 goto out; 3695 status = decode_getfattr(&xdr, res->fattr, res->server); 3696 out: 3697 return status; 3698 } 3699 3700 /* 3701 * Decode LOOKUP_ROOT response 3702 */ 3703 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_lookup_res *res) 3704 { 3705 struct xdr_stream xdr; 3706 struct compound_hdr hdr; 3707 int status; 3708 3709 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3710 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3711 goto out; 3712 if ((status = decode_putrootfh(&xdr)) != 0) 3713 goto out; 3714 if ((status = decode_getfh(&xdr, res->fh)) == 0) 3715 status = decode_getfattr(&xdr, res->fattr, res->server); 3716 out: 3717 return status; 3718 } 3719 3720 /* 3721 * Decode REMOVE response 3722 */ 3723 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_remove_res *res) 3724 { 3725 struct xdr_stream xdr; 3726 struct compound_hdr hdr; 3727 int status; 3728 3729 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3730 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3731 goto out; 3732 if ((status = decode_putfh(&xdr)) != 0) 3733 goto out; 3734 if ((status = decode_remove(&xdr, &res->cinfo)) != 0) 3735 goto out; 3736 decode_getfattr(&xdr, res->dir_attr, res->server); 3737 out: 3738 return status; 3739 } 3740 3741 /* 3742 * Decode RENAME response 3743 */ 3744 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_rename_res *res) 3745 { 3746 struct xdr_stream xdr; 3747 struct compound_hdr hdr; 3748 int status; 3749 3750 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3751 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3752 goto out; 3753 if ((status = decode_putfh(&xdr)) != 0) 3754 goto out; 3755 if ((status = decode_savefh(&xdr)) != 0) 3756 goto out; 3757 if ((status = decode_putfh(&xdr)) != 0) 3758 goto out; 3759 if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0) 3760 goto out; 3761 /* Current FH is target directory */ 3762 if (decode_getfattr(&xdr, res->new_fattr, res->server) != 0) 3763 goto out; 3764 if ((status = decode_restorefh(&xdr)) != 0) 3765 goto out; 3766 decode_getfattr(&xdr, res->old_fattr, res->server); 3767 out: 3768 return status; 3769 } 3770 3771 /* 3772 * Decode LINK response 3773 */ 3774 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_link_res *res) 3775 { 3776 struct xdr_stream xdr; 3777 struct compound_hdr hdr; 3778 int status; 3779 3780 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3781 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3782 goto out; 3783 if ((status = decode_putfh(&xdr)) != 0) 3784 goto out; 3785 if ((status = decode_savefh(&xdr)) != 0) 3786 goto out; 3787 if ((status = decode_putfh(&xdr)) != 0) 3788 goto out; 3789 if ((status = decode_link(&xdr, &res->cinfo)) != 0) 3790 goto out; 3791 /* 3792 * Note order: OP_LINK leaves the directory as the current 3793 * filehandle. 3794 */ 3795 if (decode_getfattr(&xdr, res->dir_attr, res->server) != 0) 3796 goto out; 3797 if ((status = decode_restorefh(&xdr)) != 0) 3798 goto out; 3799 decode_getfattr(&xdr, res->fattr, res->server); 3800 out: 3801 return status; 3802 } 3803 3804 /* 3805 * Decode CREATE response 3806 */ 3807 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_create_res *res) 3808 { 3809 struct xdr_stream xdr; 3810 struct compound_hdr hdr; 3811 int status; 3812 3813 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3814 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3815 goto out; 3816 if ((status = decode_putfh(&xdr)) != 0) 3817 goto out; 3818 if ((status = decode_savefh(&xdr)) != 0) 3819 goto out; 3820 if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0) 3821 goto out; 3822 if ((status = decode_getfh(&xdr, res->fh)) != 0) 3823 goto out; 3824 if (decode_getfattr(&xdr, res->fattr, res->server) != 0) 3825 goto out; 3826 if ((status = decode_restorefh(&xdr)) != 0) 3827 goto out; 3828 decode_getfattr(&xdr, res->dir_fattr, res->server); 3829 out: 3830 return status; 3831 } 3832 3833 /* 3834 * Decode SYMLINK response 3835 */ 3836 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_create_res *res) 3837 { 3838 return nfs4_xdr_dec_create(rqstp, p, res); 3839 } 3840 3841 /* 3842 * Decode GETATTR response 3843 */ 3844 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_getattr_res *res) 3845 { 3846 struct xdr_stream xdr; 3847 struct compound_hdr hdr; 3848 int status; 3849 3850 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3851 status = decode_compound_hdr(&xdr, &hdr); 3852 if (status) 3853 goto out; 3854 status = decode_putfh(&xdr); 3855 if (status) 3856 goto out; 3857 status = decode_getfattr(&xdr, res->fattr, res->server); 3858 out: 3859 return status; 3860 3861 } 3862 3863 /* 3864 * Encode an SETACL request 3865 */ 3866 static int 3867 nfs4_xdr_enc_setacl(struct rpc_rqst *req, uint32_t *p, struct nfs_setaclargs *args) 3868 { 3869 struct xdr_stream xdr; 3870 struct compound_hdr hdr = { 3871 .nops = 2, 3872 }; 3873 int status; 3874 3875 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 3876 encode_compound_hdr(&xdr, &hdr); 3877 status = encode_putfh(&xdr, args->fh); 3878 if (status) 3879 goto out; 3880 status = encode_setacl(&xdr, args); 3881 out: 3882 return status; 3883 } 3884 /* 3885 * Decode SETACL response 3886 */ 3887 static int 3888 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, uint32_t *p, void *res) 3889 { 3890 struct xdr_stream xdr; 3891 struct compound_hdr hdr; 3892 int status; 3893 3894 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3895 status = decode_compound_hdr(&xdr, &hdr); 3896 if (status) 3897 goto out; 3898 status = decode_putfh(&xdr); 3899 if (status) 3900 goto out; 3901 status = decode_setattr(&xdr, res); 3902 out: 3903 return status; 3904 } 3905 3906 /* 3907 * Decode GETACL response 3908 */ 3909 static int 3910 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, uint32_t *p, size_t *acl_len) 3911 { 3912 struct xdr_stream xdr; 3913 struct compound_hdr hdr; 3914 int status; 3915 3916 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3917 status = decode_compound_hdr(&xdr, &hdr); 3918 if (status) 3919 goto out; 3920 status = decode_putfh(&xdr); 3921 if (status) 3922 goto out; 3923 status = decode_getacl(&xdr, rqstp, acl_len); 3924 3925 out: 3926 return status; 3927 } 3928 3929 /* 3930 * Decode CLOSE response 3931 */ 3932 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_closeres *res) 3933 { 3934 struct xdr_stream xdr; 3935 struct compound_hdr hdr; 3936 int status; 3937 3938 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3939 status = decode_compound_hdr(&xdr, &hdr); 3940 if (status) 3941 goto out; 3942 status = decode_putfh(&xdr); 3943 if (status) 3944 goto out; 3945 status = decode_close(&xdr, res); 3946 if (status != 0) 3947 goto out; 3948 /* 3949 * Note: Server may do delete on close for this file 3950 * in which case the getattr call will fail with 3951 * an ESTALE error. Shouldn't be a problem, 3952 * though, since fattr->valid will remain unset. 3953 */ 3954 decode_getfattr(&xdr, res->fattr, res->server); 3955 out: 3956 return status; 3957 } 3958 3959 /* 3960 * Decode OPEN response 3961 */ 3962 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_openres *res) 3963 { 3964 struct xdr_stream xdr; 3965 struct compound_hdr hdr; 3966 int status; 3967 3968 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3969 status = decode_compound_hdr(&xdr, &hdr); 3970 if (status) 3971 goto out; 3972 status = decode_putfh(&xdr); 3973 if (status) 3974 goto out; 3975 status = decode_savefh(&xdr); 3976 if (status) 3977 goto out; 3978 status = decode_open(&xdr, res); 3979 if (status) 3980 goto out; 3981 status = decode_getfh(&xdr, &res->fh); 3982 if (status) 3983 goto out; 3984 if (decode_getfattr(&xdr, res->f_attr, res->server) != 0) 3985 goto out; 3986 if ((status = decode_restorefh(&xdr)) != 0) 3987 goto out; 3988 decode_getfattr(&xdr, res->dir_attr, res->server); 3989 out: 3990 return status; 3991 } 3992 3993 /* 3994 * Decode OPEN_CONFIRM response 3995 */ 3996 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_open_confirmres *res) 3997 { 3998 struct xdr_stream xdr; 3999 struct compound_hdr hdr; 4000 int status; 4001 4002 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4003 status = decode_compound_hdr(&xdr, &hdr); 4004 if (status) 4005 goto out; 4006 status = decode_putfh(&xdr); 4007 if (status) 4008 goto out; 4009 status = decode_open_confirm(&xdr, res); 4010 out: 4011 return status; 4012 } 4013 4014 /* 4015 * Decode OPEN response 4016 */ 4017 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_openres *res) 4018 { 4019 struct xdr_stream xdr; 4020 struct compound_hdr hdr; 4021 int status; 4022 4023 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4024 status = decode_compound_hdr(&xdr, &hdr); 4025 if (status) 4026 goto out; 4027 status = decode_putfh(&xdr); 4028 if (status) 4029 goto out; 4030 status = decode_open(&xdr, res); 4031 if (status) 4032 goto out; 4033 decode_getfattr(&xdr, res->f_attr, res->server); 4034 out: 4035 return status; 4036 } 4037 4038 /* 4039 * Decode SETATTR response 4040 */ 4041 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_setattrres *res) 4042 { 4043 struct xdr_stream xdr; 4044 struct compound_hdr hdr; 4045 int status; 4046 4047 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4048 status = decode_compound_hdr(&xdr, &hdr); 4049 if (status) 4050 goto out; 4051 status = decode_putfh(&xdr); 4052 if (status) 4053 goto out; 4054 status = decode_setattr(&xdr, res); 4055 if (status) 4056 goto out; 4057 status = decode_getfattr(&xdr, res->fattr, res->server); 4058 if (status == NFS4ERR_DELAY) 4059 status = 0; 4060 out: 4061 return status; 4062 } 4063 4064 /* 4065 * Decode LOCK response 4066 */ 4067 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lock_res *res) 4068 { 4069 struct xdr_stream xdr; 4070 struct compound_hdr hdr; 4071 int status; 4072 4073 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4074 status = decode_compound_hdr(&xdr, &hdr); 4075 if (status) 4076 goto out; 4077 status = decode_putfh(&xdr); 4078 if (status) 4079 goto out; 4080 status = decode_lock(&xdr, res); 4081 out: 4082 return status; 4083 } 4084 4085 /* 4086 * Decode LOCKT response 4087 */ 4088 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lockt_res *res) 4089 { 4090 struct xdr_stream xdr; 4091 struct compound_hdr hdr; 4092 int status; 4093 4094 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4095 status = decode_compound_hdr(&xdr, &hdr); 4096 if (status) 4097 goto out; 4098 status = decode_putfh(&xdr); 4099 if (status) 4100 goto out; 4101 status = decode_lockt(&xdr, res); 4102 out: 4103 return status; 4104 } 4105 4106 /* 4107 * Decode LOCKU response 4108 */ 4109 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_locku_res *res) 4110 { 4111 struct xdr_stream xdr; 4112 struct compound_hdr hdr; 4113 int status; 4114 4115 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4116 status = decode_compound_hdr(&xdr, &hdr); 4117 if (status) 4118 goto out; 4119 status = decode_putfh(&xdr); 4120 if (status) 4121 goto out; 4122 status = decode_locku(&xdr, res); 4123 out: 4124 return status; 4125 } 4126 4127 /* 4128 * Decode READLINK response 4129 */ 4130 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, uint32_t *p, void *res) 4131 { 4132 struct xdr_stream xdr; 4133 struct compound_hdr hdr; 4134 int status; 4135 4136 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4137 status = decode_compound_hdr(&xdr, &hdr); 4138 if (status) 4139 goto out; 4140 status = decode_putfh(&xdr); 4141 if (status) 4142 goto out; 4143 status = decode_readlink(&xdr, rqstp); 4144 out: 4145 return status; 4146 } 4147 4148 /* 4149 * Decode READDIR response 4150 */ 4151 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_readdir_res *res) 4152 { 4153 struct xdr_stream xdr; 4154 struct compound_hdr hdr; 4155 int status; 4156 4157 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4158 status = decode_compound_hdr(&xdr, &hdr); 4159 if (status) 4160 goto out; 4161 status = decode_putfh(&xdr); 4162 if (status) 4163 goto out; 4164 status = decode_readdir(&xdr, rqstp, res); 4165 out: 4166 return status; 4167 } 4168 4169 /* 4170 * Decode Read response 4171 */ 4172 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_readres *res) 4173 { 4174 struct xdr_stream xdr; 4175 struct compound_hdr hdr; 4176 int status; 4177 4178 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4179 status = decode_compound_hdr(&xdr, &hdr); 4180 if (status) 4181 goto out; 4182 status = decode_putfh(&xdr); 4183 if (status) 4184 goto out; 4185 status = decode_read(&xdr, rqstp, res); 4186 if (!status) 4187 status = res->count; 4188 out: 4189 return status; 4190 } 4191 4192 /* 4193 * Decode WRITE response 4194 */ 4195 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_writeres *res) 4196 { 4197 struct xdr_stream xdr; 4198 struct compound_hdr hdr; 4199 int status; 4200 4201 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4202 status = decode_compound_hdr(&xdr, &hdr); 4203 if (status) 4204 goto out; 4205 status = decode_putfh(&xdr); 4206 if (status) 4207 goto out; 4208 status = decode_write(&xdr, res); 4209 if (status) 4210 goto out; 4211 decode_getfattr(&xdr, res->fattr, res->server); 4212 if (!status) 4213 status = res->count; 4214 out: 4215 return status; 4216 } 4217 4218 /* 4219 * Decode COMMIT response 4220 */ 4221 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_writeres *res) 4222 { 4223 struct xdr_stream xdr; 4224 struct compound_hdr hdr; 4225 int status; 4226 4227 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4228 status = decode_compound_hdr(&xdr, &hdr); 4229 if (status) 4230 goto out; 4231 status = decode_putfh(&xdr); 4232 if (status) 4233 goto out; 4234 status = decode_commit(&xdr, res); 4235 if (status) 4236 goto out; 4237 decode_getfattr(&xdr, res->fattr, res->server); 4238 out: 4239 return status; 4240 } 4241 4242 /* 4243 * FSINFO request 4244 */ 4245 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, uint32_t *p, struct nfs_fsinfo *fsinfo) 4246 { 4247 struct xdr_stream xdr; 4248 struct compound_hdr hdr; 4249 int status; 4250 4251 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4252 status = decode_compound_hdr(&xdr, &hdr); 4253 if (!status) 4254 status = decode_putfh(&xdr); 4255 if (!status) 4256 status = decode_fsinfo(&xdr, fsinfo); 4257 if (!status) 4258 status = -nfs_stat_to_errno(hdr.status); 4259 return status; 4260 } 4261 4262 /* 4263 * PATHCONF request 4264 */ 4265 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, uint32_t *p, struct nfs_pathconf *pathconf) 4266 { 4267 struct xdr_stream xdr; 4268 struct compound_hdr hdr; 4269 int status; 4270 4271 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4272 status = decode_compound_hdr(&xdr, &hdr); 4273 if (!status) 4274 status = decode_putfh(&xdr); 4275 if (!status) 4276 status = decode_pathconf(&xdr, pathconf); 4277 return status; 4278 } 4279 4280 /* 4281 * STATFS request 4282 */ 4283 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, uint32_t *p, struct nfs_fsstat *fsstat) 4284 { 4285 struct xdr_stream xdr; 4286 struct compound_hdr hdr; 4287 int status; 4288 4289 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4290 status = decode_compound_hdr(&xdr, &hdr); 4291 if (!status) 4292 status = decode_putfh(&xdr); 4293 if (!status) 4294 status = decode_statfs(&xdr, fsstat); 4295 return status; 4296 } 4297 4298 /* 4299 * GETATTR_BITMAP request 4300 */ 4301 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, uint32_t *p, struct nfs4_server_caps_res *res) 4302 { 4303 struct xdr_stream xdr; 4304 struct compound_hdr hdr; 4305 int status; 4306 4307 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4308 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 4309 goto out; 4310 if ((status = decode_putfh(&xdr)) != 0) 4311 goto out; 4312 status = decode_server_caps(&xdr, res); 4313 out: 4314 return status; 4315 } 4316 4317 /* 4318 * Decode RENEW response 4319 */ 4320 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, uint32_t *p, void *dummy) 4321 { 4322 struct xdr_stream xdr; 4323 struct compound_hdr hdr; 4324 int status; 4325 4326 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4327 status = decode_compound_hdr(&xdr, &hdr); 4328 if (!status) 4329 status = decode_renew(&xdr); 4330 return status; 4331 } 4332 4333 /* 4334 * a SETCLIENTID request 4335 */ 4336 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, uint32_t *p, 4337 struct nfs4_client *clp) 4338 { 4339 struct xdr_stream xdr; 4340 struct compound_hdr hdr; 4341 int status; 4342 4343 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4344 status = decode_compound_hdr(&xdr, &hdr); 4345 if (!status) 4346 status = decode_setclientid(&xdr, clp); 4347 if (!status) 4348 status = -nfs_stat_to_errno(hdr.status); 4349 return status; 4350 } 4351 4352 /* 4353 * a SETCLIENTID_CONFIRM request 4354 */ 4355 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, uint32_t *p, struct nfs_fsinfo *fsinfo) 4356 { 4357 struct xdr_stream xdr; 4358 struct compound_hdr hdr; 4359 int status; 4360 4361 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4362 status = decode_compound_hdr(&xdr, &hdr); 4363 if (!status) 4364 status = decode_setclientid_confirm(&xdr); 4365 if (!status) 4366 status = decode_putrootfh(&xdr); 4367 if (!status) 4368 status = decode_fsinfo(&xdr, fsinfo); 4369 if (!status) 4370 status = -nfs_stat_to_errno(hdr.status); 4371 return status; 4372 } 4373 4374 /* 4375 * DELEGRETURN request 4376 */ 4377 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_delegreturnres *res) 4378 { 4379 struct xdr_stream xdr; 4380 struct compound_hdr hdr; 4381 int status; 4382 4383 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4384 status = decode_compound_hdr(&xdr, &hdr); 4385 if (status != 0) 4386 goto out; 4387 status = decode_putfh(&xdr); 4388 if (status != 0) 4389 goto out; 4390 status = decode_delegreturn(&xdr); 4391 decode_getfattr(&xdr, res->fattr, res->server); 4392 out: 4393 return status; 4394 } 4395 4396 /* 4397 * FS_LOCATIONS request 4398 */ 4399 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, uint32_t *p, struct nfs4_fs_locations *res) 4400 { 4401 struct xdr_stream xdr; 4402 struct compound_hdr hdr; 4403 int status; 4404 4405 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4406 status = decode_compound_hdr(&xdr, &hdr); 4407 if (status != 0) 4408 goto out; 4409 if ((status = decode_putfh(&xdr)) != 0) 4410 goto out; 4411 if ((status = decode_lookup(&xdr)) != 0) 4412 goto out; 4413 xdr_enter_page(&xdr, PAGE_SIZE); 4414 status = decode_getfattr(&xdr, &res->fattr, res->server); 4415 out: 4416 return status; 4417 } 4418 4419 uint32_t *nfs4_decode_dirent(uint32_t *p, struct nfs_entry *entry, int plus) 4420 { 4421 uint32_t bitmap[2] = {0}; 4422 uint32_t len; 4423 4424 if (!*p++) { 4425 if (!*p) 4426 return ERR_PTR(-EAGAIN); 4427 entry->eof = 1; 4428 return ERR_PTR(-EBADCOOKIE); 4429 } 4430 4431 entry->prev_cookie = entry->cookie; 4432 p = xdr_decode_hyper(p, &entry->cookie); 4433 entry->len = ntohl(*p++); 4434 entry->name = (const char *) p; 4435 p += XDR_QUADLEN(entry->len); 4436 4437 /* 4438 * In case the server doesn't return an inode number, 4439 * we fake one here. (We don't use inode number 0, 4440 * since glibc seems to choke on it...) 4441 */ 4442 entry->ino = 1; 4443 4444 len = ntohl(*p++); /* bitmap length */ 4445 if (len-- > 0) { 4446 bitmap[0] = ntohl(*p++); 4447 if (len-- > 0) { 4448 bitmap[1] = ntohl(*p++); 4449 p += len; 4450 } 4451 } 4452 len = XDR_QUADLEN(ntohl(*p++)); /* attribute buffer length */ 4453 if (len > 0) { 4454 if (bitmap[0] & FATTR4_WORD0_RDATTR_ERROR) { 4455 bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR; 4456 /* Ignore the return value of rdattr_error for now */ 4457 p++; 4458 len--; 4459 } 4460 if (bitmap[0] == 0 && bitmap[1] == FATTR4_WORD1_MOUNTED_ON_FILEID) 4461 xdr_decode_hyper(p, &entry->ino); 4462 else if (bitmap[0] == FATTR4_WORD0_FILEID) 4463 xdr_decode_hyper(p, &entry->ino); 4464 p += len; 4465 } 4466 4467 entry->eof = !p[0] && p[1]; 4468 return p; 4469 } 4470 4471 /* 4472 * We need to translate between nfs status return values and 4473 * the local errno values which may not be the same. 4474 */ 4475 static struct { 4476 int stat; 4477 int errno; 4478 } nfs_errtbl[] = { 4479 { NFS4_OK, 0 }, 4480 { NFS4ERR_PERM, EPERM }, 4481 { NFS4ERR_NOENT, ENOENT }, 4482 { NFS4ERR_IO, errno_NFSERR_IO }, 4483 { NFS4ERR_NXIO, ENXIO }, 4484 { NFS4ERR_ACCESS, EACCES }, 4485 { NFS4ERR_EXIST, EEXIST }, 4486 { NFS4ERR_XDEV, EXDEV }, 4487 { NFS4ERR_NOTDIR, ENOTDIR }, 4488 { NFS4ERR_ISDIR, EISDIR }, 4489 { NFS4ERR_INVAL, EINVAL }, 4490 { NFS4ERR_FBIG, EFBIG }, 4491 { NFS4ERR_NOSPC, ENOSPC }, 4492 { NFS4ERR_ROFS, EROFS }, 4493 { NFS4ERR_MLINK, EMLINK }, 4494 { NFS4ERR_NAMETOOLONG, ENAMETOOLONG }, 4495 { NFS4ERR_NOTEMPTY, ENOTEMPTY }, 4496 { NFS4ERR_DQUOT, EDQUOT }, 4497 { NFS4ERR_STALE, ESTALE }, 4498 { NFS4ERR_BADHANDLE, EBADHANDLE }, 4499 { NFS4ERR_BADOWNER, EINVAL }, 4500 { NFS4ERR_BADNAME, EINVAL }, 4501 { NFS4ERR_BAD_COOKIE, EBADCOOKIE }, 4502 { NFS4ERR_NOTSUPP, ENOTSUPP }, 4503 { NFS4ERR_TOOSMALL, ETOOSMALL }, 4504 { NFS4ERR_SERVERFAULT, ESERVERFAULT }, 4505 { NFS4ERR_BADTYPE, EBADTYPE }, 4506 { NFS4ERR_LOCKED, EAGAIN }, 4507 { NFS4ERR_RESOURCE, EREMOTEIO }, 4508 { NFS4ERR_SYMLINK, ELOOP }, 4509 { NFS4ERR_OP_ILLEGAL, EOPNOTSUPP }, 4510 { NFS4ERR_DEADLOCK, EDEADLK }, 4511 { NFS4ERR_WRONGSEC, EPERM }, /* FIXME: this needs 4512 * to be handled by a 4513 * middle-layer. 4514 */ 4515 { -1, EIO } 4516 }; 4517 4518 /* 4519 * Convert an NFS error code to a local one. 4520 * This one is used jointly by NFSv2 and NFSv3. 4521 */ 4522 static int 4523 nfs_stat_to_errno(int stat) 4524 { 4525 int i; 4526 for (i = 0; nfs_errtbl[i].stat != -1; i++) { 4527 if (nfs_errtbl[i].stat == stat) 4528 return nfs_errtbl[i].errno; 4529 } 4530 if (stat <= 10000 || stat > 10100) { 4531 /* The server is looney tunes. */ 4532 return ESERVERFAULT; 4533 } 4534 /* If we cannot translate the error, the recovery routines should 4535 * handle it. 4536 * Note: remaining NFSv4 error codes have values > 10000, so should 4537 * not conflict with native Linux error codes. 4538 */ 4539 return stat; 4540 } 4541 4542 #ifndef MAX 4543 # define MAX(a, b) (((a) > (b))? (a) : (b)) 4544 #endif 4545 4546 #define PROC(proc, argtype, restype) \ 4547 [NFSPROC4_CLNT_##proc] = { \ 4548 .p_proc = NFSPROC4_COMPOUND, \ 4549 .p_encode = (kxdrproc_t) nfs4_xdr_##argtype, \ 4550 .p_decode = (kxdrproc_t) nfs4_xdr_##restype, \ 4551 .p_bufsiz = MAX(NFS4_##argtype##_sz,NFS4_##restype##_sz) << 2, \ 4552 .p_statidx = NFSPROC4_CLNT_##proc, \ 4553 .p_name = #proc, \ 4554 } 4555 4556 struct rpc_procinfo nfs4_procedures[] = { 4557 PROC(READ, enc_read, dec_read), 4558 PROC(WRITE, enc_write, dec_write), 4559 PROC(COMMIT, enc_commit, dec_commit), 4560 PROC(OPEN, enc_open, dec_open), 4561 PROC(OPEN_CONFIRM, enc_open_confirm, dec_open_confirm), 4562 PROC(OPEN_NOATTR, enc_open_noattr, dec_open_noattr), 4563 PROC(OPEN_DOWNGRADE, enc_open_downgrade, dec_open_downgrade), 4564 PROC(CLOSE, enc_close, dec_close), 4565 PROC(SETATTR, enc_setattr, dec_setattr), 4566 PROC(FSINFO, enc_fsinfo, dec_fsinfo), 4567 PROC(RENEW, enc_renew, dec_renew), 4568 PROC(SETCLIENTID, enc_setclientid, dec_setclientid), 4569 PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm), 4570 PROC(LOCK, enc_lock, dec_lock), 4571 PROC(LOCKT, enc_lockt, dec_lockt), 4572 PROC(LOCKU, enc_locku, dec_locku), 4573 PROC(ACCESS, enc_access, dec_access), 4574 PROC(GETATTR, enc_getattr, dec_getattr), 4575 PROC(LOOKUP, enc_lookup, dec_lookup), 4576 PROC(LOOKUP_ROOT, enc_lookup_root, dec_lookup_root), 4577 PROC(REMOVE, enc_remove, dec_remove), 4578 PROC(RENAME, enc_rename, dec_rename), 4579 PROC(LINK, enc_link, dec_link), 4580 PROC(SYMLINK, enc_symlink, dec_symlink), 4581 PROC(CREATE, enc_create, dec_create), 4582 PROC(PATHCONF, enc_pathconf, dec_pathconf), 4583 PROC(STATFS, enc_statfs, dec_statfs), 4584 PROC(READLINK, enc_readlink, dec_readlink), 4585 PROC(READDIR, enc_readdir, dec_readdir), 4586 PROC(SERVER_CAPS, enc_server_caps, dec_server_caps), 4587 PROC(DELEGRETURN, enc_delegreturn, dec_delegreturn), 4588 PROC(GETACL, enc_getacl, dec_getacl), 4589 PROC(SETACL, enc_setacl, dec_setacl), 4590 PROC(FS_LOCATIONS, enc_fs_locations, dec_fs_locations), 4591 }; 4592 4593 struct rpc_version nfs_version4 = { 4594 .number = 4, 4595 .nrprocs = ARRAY_SIZE(nfs4_procedures), 4596 .procs = nfs4_procedures 4597 }; 4598 4599 /* 4600 * Local variables: 4601 * c-basic-offset: 8 4602 * End: 4603 */ 4604