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, xlen; 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 = p + ((pglen + readdir->pgbase) >> 2); 3381 entry = p; 3382 for (nr = 0; *p++; nr++) { 3383 if (end - p < 3) 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 xlen = XDR_QUADLEN(len); 3393 if (end - p < xlen + 1) 3394 goto short_pkt; 3395 dprintk("filename = %*s\n", len, (char *)p); 3396 p += xlen; 3397 len = ntohl(*p++); /* bitmap length */ 3398 if (end - p < len + 1) 3399 goto short_pkt; 3400 p += len; 3401 attrlen = XDR_QUADLEN(ntohl(*p++)); 3402 if (end - p < attrlen + 2) 3403 goto short_pkt; 3404 p += attrlen; /* attributes */ 3405 entry = p; 3406 } 3407 if (!nr && (entry[0] != 0 || entry[1] == 0)) 3408 goto short_pkt; 3409 out: 3410 kunmap_atomic(kaddr, KM_USER0); 3411 return 0; 3412 short_pkt: 3413 dprintk("%s: short packet at entry %d\n", __FUNCTION__, nr); 3414 entry[0] = entry[1] = 0; 3415 /* truncate listing ? */ 3416 if (!nr) { 3417 printk(KERN_NOTICE "NFS: readdir reply truncated!\n"); 3418 entry[1] = 1; 3419 } 3420 goto out; 3421 err_unmap: 3422 kunmap_atomic(kaddr, KM_USER0); 3423 return -errno_NFSERR_IO; 3424 } 3425 3426 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req) 3427 { 3428 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 3429 struct kvec *iov = rcvbuf->head; 3430 int hdrlen, len, recvd; 3431 uint32_t *p; 3432 char *kaddr; 3433 int status; 3434 3435 status = decode_op_hdr(xdr, OP_READLINK); 3436 if (status) 3437 return status; 3438 3439 /* Convert length of symlink */ 3440 READ_BUF(4); 3441 READ32(len); 3442 if (len >= rcvbuf->page_len || len <= 0) { 3443 dprintk(KERN_WARNING "nfs: server returned giant symlink!\n"); 3444 return -ENAMETOOLONG; 3445 } 3446 hdrlen = (char *) xdr->p - (char *) iov->iov_base; 3447 recvd = req->rq_rcv_buf.len - hdrlen; 3448 if (recvd < len) { 3449 printk(KERN_WARNING "NFS: server cheating in readlink reply: " 3450 "count %u > recvd %u\n", len, recvd); 3451 return -EIO; 3452 } 3453 xdr_read_pages(xdr, len); 3454 /* 3455 * The XDR encode routine has set things up so that 3456 * the link text will be copied directly into the 3457 * buffer. We just have to do overflow-checking, 3458 * and and null-terminate the text (the VFS expects 3459 * null-termination). 3460 */ 3461 kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0); 3462 kaddr[len+rcvbuf->page_base] = '\0'; 3463 kunmap_atomic(kaddr, KM_USER0); 3464 return 0; 3465 } 3466 3467 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo) 3468 { 3469 int status; 3470 3471 status = decode_op_hdr(xdr, OP_REMOVE); 3472 if (status) 3473 goto out; 3474 status = decode_change_info(xdr, cinfo); 3475 out: 3476 return status; 3477 } 3478 3479 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo, 3480 struct nfs4_change_info *new_cinfo) 3481 { 3482 int status; 3483 3484 status = decode_op_hdr(xdr, OP_RENAME); 3485 if (status) 3486 goto out; 3487 if ((status = decode_change_info(xdr, old_cinfo))) 3488 goto out; 3489 status = decode_change_info(xdr, new_cinfo); 3490 out: 3491 return status; 3492 } 3493 3494 static int decode_renew(struct xdr_stream *xdr) 3495 { 3496 return decode_op_hdr(xdr, OP_RENEW); 3497 } 3498 3499 static int 3500 decode_restorefh(struct xdr_stream *xdr) 3501 { 3502 return decode_op_hdr(xdr, OP_RESTOREFH); 3503 } 3504 3505 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req, 3506 size_t *acl_len) 3507 { 3508 uint32_t *savep; 3509 uint32_t attrlen, 3510 bitmap[2] = {0}; 3511 struct kvec *iov = req->rq_rcv_buf.head; 3512 int status; 3513 3514 *acl_len = 0; 3515 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0) 3516 goto out; 3517 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0) 3518 goto out; 3519 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0) 3520 goto out; 3521 3522 if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U))) 3523 return -EIO; 3524 if (likely(bitmap[0] & FATTR4_WORD0_ACL)) { 3525 int hdrlen, recvd; 3526 3527 /* We ignore &savep and don't do consistency checks on 3528 * the attr length. Let userspace figure it out.... */ 3529 hdrlen = (u8 *)xdr->p - (u8 *)iov->iov_base; 3530 recvd = req->rq_rcv_buf.len - hdrlen; 3531 if (attrlen > recvd) { 3532 printk(KERN_WARNING "NFS: server cheating in getattr" 3533 " acl reply: attrlen %u > recvd %u\n", 3534 attrlen, recvd); 3535 return -EINVAL; 3536 } 3537 xdr_read_pages(xdr, attrlen); 3538 *acl_len = attrlen; 3539 } else 3540 status = -EOPNOTSUPP; 3541 3542 out: 3543 return status; 3544 } 3545 3546 static int 3547 decode_savefh(struct xdr_stream *xdr) 3548 { 3549 return decode_op_hdr(xdr, OP_SAVEFH); 3550 } 3551 3552 static int decode_setattr(struct xdr_stream *xdr, struct nfs_setattrres *res) 3553 { 3554 uint32_t *p; 3555 uint32_t bmlen; 3556 int status; 3557 3558 3559 status = decode_op_hdr(xdr, OP_SETATTR); 3560 if (status) 3561 return status; 3562 READ_BUF(4); 3563 READ32(bmlen); 3564 READ_BUF(bmlen << 2); 3565 return 0; 3566 } 3567 3568 static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_client *clp) 3569 { 3570 uint32_t *p; 3571 uint32_t opnum; 3572 int32_t nfserr; 3573 3574 READ_BUF(8); 3575 READ32(opnum); 3576 if (opnum != OP_SETCLIENTID) { 3577 printk(KERN_NOTICE 3578 "nfs4_decode_setclientid: Server returned operation" 3579 " %d\n", opnum); 3580 return -EIO; 3581 } 3582 READ32(nfserr); 3583 if (nfserr == NFS_OK) { 3584 READ_BUF(8 + sizeof(clp->cl_confirm.data)); 3585 READ64(clp->cl_clientid); 3586 COPYMEM(clp->cl_confirm.data, sizeof(clp->cl_confirm.data)); 3587 } else if (nfserr == NFSERR_CLID_INUSE) { 3588 uint32_t len; 3589 3590 /* skip netid string */ 3591 READ_BUF(4); 3592 READ32(len); 3593 READ_BUF(len); 3594 3595 /* skip uaddr string */ 3596 READ_BUF(4); 3597 READ32(len); 3598 READ_BUF(len); 3599 return -NFSERR_CLID_INUSE; 3600 } else 3601 return -nfs_stat_to_errno(nfserr); 3602 3603 return 0; 3604 } 3605 3606 static int decode_setclientid_confirm(struct xdr_stream *xdr) 3607 { 3608 return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM); 3609 } 3610 3611 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res) 3612 { 3613 uint32_t *p; 3614 int status; 3615 3616 status = decode_op_hdr(xdr, OP_WRITE); 3617 if (status) 3618 return status; 3619 3620 READ_BUF(16); 3621 READ32(res->count); 3622 READ32(res->verf->committed); 3623 COPYMEM(res->verf->verifier, 8); 3624 return 0; 3625 } 3626 3627 static int decode_delegreturn(struct xdr_stream *xdr) 3628 { 3629 return decode_op_hdr(xdr, OP_DELEGRETURN); 3630 } 3631 3632 /* 3633 * Decode OPEN_DOWNGRADE response 3634 */ 3635 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_closeres *res) 3636 { 3637 struct xdr_stream xdr; 3638 struct compound_hdr hdr; 3639 int status; 3640 3641 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3642 status = decode_compound_hdr(&xdr, &hdr); 3643 if (status) 3644 goto out; 3645 status = decode_putfh(&xdr); 3646 if (status) 3647 goto out; 3648 status = decode_open_downgrade(&xdr, res); 3649 if (status != 0) 3650 goto out; 3651 decode_getfattr(&xdr, res->fattr, res->server); 3652 out: 3653 return status; 3654 } 3655 3656 /* 3657 * END OF "GENERIC" DECODE ROUTINES. 3658 */ 3659 3660 /* 3661 * Decode ACCESS response 3662 */ 3663 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_accessres *res) 3664 { 3665 struct xdr_stream xdr; 3666 struct compound_hdr hdr; 3667 int status; 3668 3669 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3670 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3671 goto out; 3672 if ((status = decode_putfh(&xdr)) == 0) 3673 status = decode_access(&xdr, res); 3674 out: 3675 return status; 3676 } 3677 3678 /* 3679 * Decode LOOKUP response 3680 */ 3681 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_lookup_res *res) 3682 { 3683 struct xdr_stream xdr; 3684 struct compound_hdr hdr; 3685 int status; 3686 3687 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3688 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3689 goto out; 3690 if ((status = decode_putfh(&xdr)) != 0) 3691 goto out; 3692 if ((status = decode_lookup(&xdr)) != 0) 3693 goto out; 3694 if ((status = decode_getfh(&xdr, res->fh)) != 0) 3695 goto out; 3696 status = decode_getfattr(&xdr, res->fattr, res->server); 3697 out: 3698 return status; 3699 } 3700 3701 /* 3702 * Decode LOOKUP_ROOT response 3703 */ 3704 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_lookup_res *res) 3705 { 3706 struct xdr_stream xdr; 3707 struct compound_hdr hdr; 3708 int status; 3709 3710 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3711 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3712 goto out; 3713 if ((status = decode_putrootfh(&xdr)) != 0) 3714 goto out; 3715 if ((status = decode_getfh(&xdr, res->fh)) == 0) 3716 status = decode_getfattr(&xdr, res->fattr, res->server); 3717 out: 3718 return status; 3719 } 3720 3721 /* 3722 * Decode REMOVE response 3723 */ 3724 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_remove_res *res) 3725 { 3726 struct xdr_stream xdr; 3727 struct compound_hdr hdr; 3728 int status; 3729 3730 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3731 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3732 goto out; 3733 if ((status = decode_putfh(&xdr)) != 0) 3734 goto out; 3735 if ((status = decode_remove(&xdr, &res->cinfo)) != 0) 3736 goto out; 3737 decode_getfattr(&xdr, res->dir_attr, res->server); 3738 out: 3739 return status; 3740 } 3741 3742 /* 3743 * Decode RENAME response 3744 */ 3745 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_rename_res *res) 3746 { 3747 struct xdr_stream xdr; 3748 struct compound_hdr hdr; 3749 int status; 3750 3751 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3752 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3753 goto out; 3754 if ((status = decode_putfh(&xdr)) != 0) 3755 goto out; 3756 if ((status = decode_savefh(&xdr)) != 0) 3757 goto out; 3758 if ((status = decode_putfh(&xdr)) != 0) 3759 goto out; 3760 if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0) 3761 goto out; 3762 /* Current FH is target directory */ 3763 if (decode_getfattr(&xdr, res->new_fattr, res->server) != 0) 3764 goto out; 3765 if ((status = decode_restorefh(&xdr)) != 0) 3766 goto out; 3767 decode_getfattr(&xdr, res->old_fattr, res->server); 3768 out: 3769 return status; 3770 } 3771 3772 /* 3773 * Decode LINK response 3774 */ 3775 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_link_res *res) 3776 { 3777 struct xdr_stream xdr; 3778 struct compound_hdr hdr; 3779 int status; 3780 3781 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3782 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3783 goto out; 3784 if ((status = decode_putfh(&xdr)) != 0) 3785 goto out; 3786 if ((status = decode_savefh(&xdr)) != 0) 3787 goto out; 3788 if ((status = decode_putfh(&xdr)) != 0) 3789 goto out; 3790 if ((status = decode_link(&xdr, &res->cinfo)) != 0) 3791 goto out; 3792 /* 3793 * Note order: OP_LINK leaves the directory as the current 3794 * filehandle. 3795 */ 3796 if (decode_getfattr(&xdr, res->dir_attr, res->server) != 0) 3797 goto out; 3798 if ((status = decode_restorefh(&xdr)) != 0) 3799 goto out; 3800 decode_getfattr(&xdr, res->fattr, res->server); 3801 out: 3802 return status; 3803 } 3804 3805 /* 3806 * Decode CREATE response 3807 */ 3808 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_create_res *res) 3809 { 3810 struct xdr_stream xdr; 3811 struct compound_hdr hdr; 3812 int status; 3813 3814 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3815 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 3816 goto out; 3817 if ((status = decode_putfh(&xdr)) != 0) 3818 goto out; 3819 if ((status = decode_savefh(&xdr)) != 0) 3820 goto out; 3821 if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0) 3822 goto out; 3823 if ((status = decode_getfh(&xdr, res->fh)) != 0) 3824 goto out; 3825 if (decode_getfattr(&xdr, res->fattr, res->server) != 0) 3826 goto out; 3827 if ((status = decode_restorefh(&xdr)) != 0) 3828 goto out; 3829 decode_getfattr(&xdr, res->dir_fattr, res->server); 3830 out: 3831 return status; 3832 } 3833 3834 /* 3835 * Decode SYMLINK response 3836 */ 3837 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_create_res *res) 3838 { 3839 return nfs4_xdr_dec_create(rqstp, p, res); 3840 } 3841 3842 /* 3843 * Decode GETATTR response 3844 */ 3845 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_getattr_res *res) 3846 { 3847 struct xdr_stream xdr; 3848 struct compound_hdr hdr; 3849 int status; 3850 3851 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3852 status = decode_compound_hdr(&xdr, &hdr); 3853 if (status) 3854 goto out; 3855 status = decode_putfh(&xdr); 3856 if (status) 3857 goto out; 3858 status = decode_getfattr(&xdr, res->fattr, res->server); 3859 out: 3860 return status; 3861 3862 } 3863 3864 /* 3865 * Encode an SETACL request 3866 */ 3867 static int 3868 nfs4_xdr_enc_setacl(struct rpc_rqst *req, uint32_t *p, struct nfs_setaclargs *args) 3869 { 3870 struct xdr_stream xdr; 3871 struct compound_hdr hdr = { 3872 .nops = 2, 3873 }; 3874 int status; 3875 3876 xdr_init_encode(&xdr, &req->rq_snd_buf, p); 3877 encode_compound_hdr(&xdr, &hdr); 3878 status = encode_putfh(&xdr, args->fh); 3879 if (status) 3880 goto out; 3881 status = encode_setacl(&xdr, args); 3882 out: 3883 return status; 3884 } 3885 /* 3886 * Decode SETACL response 3887 */ 3888 static int 3889 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, uint32_t *p, void *res) 3890 { 3891 struct xdr_stream xdr; 3892 struct compound_hdr hdr; 3893 int status; 3894 3895 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3896 status = decode_compound_hdr(&xdr, &hdr); 3897 if (status) 3898 goto out; 3899 status = decode_putfh(&xdr); 3900 if (status) 3901 goto out; 3902 status = decode_setattr(&xdr, res); 3903 out: 3904 return status; 3905 } 3906 3907 /* 3908 * Decode GETACL response 3909 */ 3910 static int 3911 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, uint32_t *p, size_t *acl_len) 3912 { 3913 struct xdr_stream xdr; 3914 struct compound_hdr hdr; 3915 int status; 3916 3917 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3918 status = decode_compound_hdr(&xdr, &hdr); 3919 if (status) 3920 goto out; 3921 status = decode_putfh(&xdr); 3922 if (status) 3923 goto out; 3924 status = decode_getacl(&xdr, rqstp, acl_len); 3925 3926 out: 3927 return status; 3928 } 3929 3930 /* 3931 * Decode CLOSE response 3932 */ 3933 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_closeres *res) 3934 { 3935 struct xdr_stream xdr; 3936 struct compound_hdr hdr; 3937 int status; 3938 3939 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3940 status = decode_compound_hdr(&xdr, &hdr); 3941 if (status) 3942 goto out; 3943 status = decode_putfh(&xdr); 3944 if (status) 3945 goto out; 3946 status = decode_close(&xdr, res); 3947 if (status != 0) 3948 goto out; 3949 /* 3950 * Note: Server may do delete on close for this file 3951 * in which case the getattr call will fail with 3952 * an ESTALE error. Shouldn't be a problem, 3953 * though, since fattr->valid will remain unset. 3954 */ 3955 decode_getfattr(&xdr, res->fattr, res->server); 3956 out: 3957 return status; 3958 } 3959 3960 /* 3961 * Decode OPEN response 3962 */ 3963 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_openres *res) 3964 { 3965 struct xdr_stream xdr; 3966 struct compound_hdr hdr; 3967 int status; 3968 3969 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 3970 status = decode_compound_hdr(&xdr, &hdr); 3971 if (status) 3972 goto out; 3973 status = decode_putfh(&xdr); 3974 if (status) 3975 goto out; 3976 status = decode_savefh(&xdr); 3977 if (status) 3978 goto out; 3979 status = decode_open(&xdr, res); 3980 if (status) 3981 goto out; 3982 status = decode_getfh(&xdr, &res->fh); 3983 if (status) 3984 goto out; 3985 if (decode_getfattr(&xdr, res->f_attr, res->server) != 0) 3986 goto out; 3987 if ((status = decode_restorefh(&xdr)) != 0) 3988 goto out; 3989 decode_getfattr(&xdr, res->dir_attr, res->server); 3990 out: 3991 return status; 3992 } 3993 3994 /* 3995 * Decode OPEN_CONFIRM response 3996 */ 3997 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_open_confirmres *res) 3998 { 3999 struct xdr_stream xdr; 4000 struct compound_hdr hdr; 4001 int status; 4002 4003 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4004 status = decode_compound_hdr(&xdr, &hdr); 4005 if (status) 4006 goto out; 4007 status = decode_putfh(&xdr); 4008 if (status) 4009 goto out; 4010 status = decode_open_confirm(&xdr, res); 4011 out: 4012 return status; 4013 } 4014 4015 /* 4016 * Decode OPEN response 4017 */ 4018 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_openres *res) 4019 { 4020 struct xdr_stream xdr; 4021 struct compound_hdr hdr; 4022 int status; 4023 4024 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4025 status = decode_compound_hdr(&xdr, &hdr); 4026 if (status) 4027 goto out; 4028 status = decode_putfh(&xdr); 4029 if (status) 4030 goto out; 4031 status = decode_open(&xdr, res); 4032 if (status) 4033 goto out; 4034 decode_getfattr(&xdr, res->f_attr, res->server); 4035 out: 4036 return status; 4037 } 4038 4039 /* 4040 * Decode SETATTR response 4041 */ 4042 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_setattrres *res) 4043 { 4044 struct xdr_stream xdr; 4045 struct compound_hdr hdr; 4046 int status; 4047 4048 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4049 status = decode_compound_hdr(&xdr, &hdr); 4050 if (status) 4051 goto out; 4052 status = decode_putfh(&xdr); 4053 if (status) 4054 goto out; 4055 status = decode_setattr(&xdr, res); 4056 if (status) 4057 goto out; 4058 status = decode_getfattr(&xdr, res->fattr, res->server); 4059 if (status == NFS4ERR_DELAY) 4060 status = 0; 4061 out: 4062 return status; 4063 } 4064 4065 /* 4066 * Decode LOCK response 4067 */ 4068 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lock_res *res) 4069 { 4070 struct xdr_stream xdr; 4071 struct compound_hdr hdr; 4072 int status; 4073 4074 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4075 status = decode_compound_hdr(&xdr, &hdr); 4076 if (status) 4077 goto out; 4078 status = decode_putfh(&xdr); 4079 if (status) 4080 goto out; 4081 status = decode_lock(&xdr, res); 4082 out: 4083 return status; 4084 } 4085 4086 /* 4087 * Decode LOCKT response 4088 */ 4089 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lockt_res *res) 4090 { 4091 struct xdr_stream xdr; 4092 struct compound_hdr hdr; 4093 int status; 4094 4095 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4096 status = decode_compound_hdr(&xdr, &hdr); 4097 if (status) 4098 goto out; 4099 status = decode_putfh(&xdr); 4100 if (status) 4101 goto out; 4102 status = decode_lockt(&xdr, res); 4103 out: 4104 return status; 4105 } 4106 4107 /* 4108 * Decode LOCKU response 4109 */ 4110 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_locku_res *res) 4111 { 4112 struct xdr_stream xdr; 4113 struct compound_hdr hdr; 4114 int status; 4115 4116 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4117 status = decode_compound_hdr(&xdr, &hdr); 4118 if (status) 4119 goto out; 4120 status = decode_putfh(&xdr); 4121 if (status) 4122 goto out; 4123 status = decode_locku(&xdr, res); 4124 out: 4125 return status; 4126 } 4127 4128 /* 4129 * Decode READLINK response 4130 */ 4131 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, uint32_t *p, void *res) 4132 { 4133 struct xdr_stream xdr; 4134 struct compound_hdr hdr; 4135 int status; 4136 4137 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4138 status = decode_compound_hdr(&xdr, &hdr); 4139 if (status) 4140 goto out; 4141 status = decode_putfh(&xdr); 4142 if (status) 4143 goto out; 4144 status = decode_readlink(&xdr, rqstp); 4145 out: 4146 return status; 4147 } 4148 4149 /* 4150 * Decode READDIR response 4151 */ 4152 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_readdir_res *res) 4153 { 4154 struct xdr_stream xdr; 4155 struct compound_hdr hdr; 4156 int status; 4157 4158 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4159 status = decode_compound_hdr(&xdr, &hdr); 4160 if (status) 4161 goto out; 4162 status = decode_putfh(&xdr); 4163 if (status) 4164 goto out; 4165 status = decode_readdir(&xdr, rqstp, res); 4166 out: 4167 return status; 4168 } 4169 4170 /* 4171 * Decode Read response 4172 */ 4173 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_readres *res) 4174 { 4175 struct xdr_stream xdr; 4176 struct compound_hdr hdr; 4177 int status; 4178 4179 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4180 status = decode_compound_hdr(&xdr, &hdr); 4181 if (status) 4182 goto out; 4183 status = decode_putfh(&xdr); 4184 if (status) 4185 goto out; 4186 status = decode_read(&xdr, rqstp, res); 4187 if (!status) 4188 status = res->count; 4189 out: 4190 return status; 4191 } 4192 4193 /* 4194 * Decode WRITE response 4195 */ 4196 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_writeres *res) 4197 { 4198 struct xdr_stream xdr; 4199 struct compound_hdr hdr; 4200 int status; 4201 4202 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4203 status = decode_compound_hdr(&xdr, &hdr); 4204 if (status) 4205 goto out; 4206 status = decode_putfh(&xdr); 4207 if (status) 4208 goto out; 4209 status = decode_write(&xdr, res); 4210 if (status) 4211 goto out; 4212 decode_getfattr(&xdr, res->fattr, res->server); 4213 if (!status) 4214 status = res->count; 4215 out: 4216 return status; 4217 } 4218 4219 /* 4220 * Decode COMMIT response 4221 */ 4222 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_writeres *res) 4223 { 4224 struct xdr_stream xdr; 4225 struct compound_hdr hdr; 4226 int status; 4227 4228 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4229 status = decode_compound_hdr(&xdr, &hdr); 4230 if (status) 4231 goto out; 4232 status = decode_putfh(&xdr); 4233 if (status) 4234 goto out; 4235 status = decode_commit(&xdr, res); 4236 if (status) 4237 goto out; 4238 decode_getfattr(&xdr, res->fattr, res->server); 4239 out: 4240 return status; 4241 } 4242 4243 /* 4244 * FSINFO request 4245 */ 4246 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, uint32_t *p, struct nfs_fsinfo *fsinfo) 4247 { 4248 struct xdr_stream xdr; 4249 struct compound_hdr hdr; 4250 int status; 4251 4252 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4253 status = decode_compound_hdr(&xdr, &hdr); 4254 if (!status) 4255 status = decode_putfh(&xdr); 4256 if (!status) 4257 status = decode_fsinfo(&xdr, fsinfo); 4258 if (!status) 4259 status = -nfs_stat_to_errno(hdr.status); 4260 return status; 4261 } 4262 4263 /* 4264 * PATHCONF request 4265 */ 4266 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, uint32_t *p, struct nfs_pathconf *pathconf) 4267 { 4268 struct xdr_stream xdr; 4269 struct compound_hdr hdr; 4270 int status; 4271 4272 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4273 status = decode_compound_hdr(&xdr, &hdr); 4274 if (!status) 4275 status = decode_putfh(&xdr); 4276 if (!status) 4277 status = decode_pathconf(&xdr, pathconf); 4278 return status; 4279 } 4280 4281 /* 4282 * STATFS request 4283 */ 4284 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, uint32_t *p, struct nfs_fsstat *fsstat) 4285 { 4286 struct xdr_stream xdr; 4287 struct compound_hdr hdr; 4288 int status; 4289 4290 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4291 status = decode_compound_hdr(&xdr, &hdr); 4292 if (!status) 4293 status = decode_putfh(&xdr); 4294 if (!status) 4295 status = decode_statfs(&xdr, fsstat); 4296 return status; 4297 } 4298 4299 /* 4300 * GETATTR_BITMAP request 4301 */ 4302 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, uint32_t *p, struct nfs4_server_caps_res *res) 4303 { 4304 struct xdr_stream xdr; 4305 struct compound_hdr hdr; 4306 int status; 4307 4308 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4309 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0) 4310 goto out; 4311 if ((status = decode_putfh(&xdr)) != 0) 4312 goto out; 4313 status = decode_server_caps(&xdr, res); 4314 out: 4315 return status; 4316 } 4317 4318 /* 4319 * Decode RENEW response 4320 */ 4321 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, uint32_t *p, void *dummy) 4322 { 4323 struct xdr_stream xdr; 4324 struct compound_hdr hdr; 4325 int status; 4326 4327 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4328 status = decode_compound_hdr(&xdr, &hdr); 4329 if (!status) 4330 status = decode_renew(&xdr); 4331 return status; 4332 } 4333 4334 /* 4335 * a SETCLIENTID request 4336 */ 4337 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, uint32_t *p, 4338 struct nfs4_client *clp) 4339 { 4340 struct xdr_stream xdr; 4341 struct compound_hdr hdr; 4342 int status; 4343 4344 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4345 status = decode_compound_hdr(&xdr, &hdr); 4346 if (!status) 4347 status = decode_setclientid(&xdr, clp); 4348 if (!status) 4349 status = -nfs_stat_to_errno(hdr.status); 4350 return status; 4351 } 4352 4353 /* 4354 * a SETCLIENTID_CONFIRM request 4355 */ 4356 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, uint32_t *p, struct nfs_fsinfo *fsinfo) 4357 { 4358 struct xdr_stream xdr; 4359 struct compound_hdr hdr; 4360 int status; 4361 4362 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4363 status = decode_compound_hdr(&xdr, &hdr); 4364 if (!status) 4365 status = decode_setclientid_confirm(&xdr); 4366 if (!status) 4367 status = decode_putrootfh(&xdr); 4368 if (!status) 4369 status = decode_fsinfo(&xdr, fsinfo); 4370 if (!status) 4371 status = -nfs_stat_to_errno(hdr.status); 4372 return status; 4373 } 4374 4375 /* 4376 * DELEGRETURN request 4377 */ 4378 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_delegreturnres *res) 4379 { 4380 struct xdr_stream xdr; 4381 struct compound_hdr hdr; 4382 int status; 4383 4384 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p); 4385 status = decode_compound_hdr(&xdr, &hdr); 4386 if (status != 0) 4387 goto out; 4388 status = decode_putfh(&xdr); 4389 if (status != 0) 4390 goto out; 4391 status = decode_delegreturn(&xdr); 4392 decode_getfattr(&xdr, res->fattr, res->server); 4393 out: 4394 return status; 4395 } 4396 4397 /* 4398 * FS_LOCATIONS request 4399 */ 4400 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, uint32_t *p, struct nfs4_fs_locations *res) 4401 { 4402 struct xdr_stream xdr; 4403 struct compound_hdr hdr; 4404 int status; 4405 4406 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 4407 status = decode_compound_hdr(&xdr, &hdr); 4408 if (status != 0) 4409 goto out; 4410 if ((status = decode_putfh(&xdr)) != 0) 4411 goto out; 4412 if ((status = decode_lookup(&xdr)) != 0) 4413 goto out; 4414 xdr_enter_page(&xdr, PAGE_SIZE); 4415 status = decode_getfattr(&xdr, &res->fattr, res->server); 4416 out: 4417 return status; 4418 } 4419 4420 uint32_t *nfs4_decode_dirent(uint32_t *p, struct nfs_entry *entry, int plus) 4421 { 4422 uint32_t bitmap[2] = {0}; 4423 uint32_t len; 4424 4425 if (!*p++) { 4426 if (!*p) 4427 return ERR_PTR(-EAGAIN); 4428 entry->eof = 1; 4429 return ERR_PTR(-EBADCOOKIE); 4430 } 4431 4432 entry->prev_cookie = entry->cookie; 4433 p = xdr_decode_hyper(p, &entry->cookie); 4434 entry->len = ntohl(*p++); 4435 entry->name = (const char *) p; 4436 p += XDR_QUADLEN(entry->len); 4437 4438 /* 4439 * In case the server doesn't return an inode number, 4440 * we fake one here. (We don't use inode number 0, 4441 * since glibc seems to choke on it...) 4442 */ 4443 entry->ino = 1; 4444 4445 len = ntohl(*p++); /* bitmap length */ 4446 if (len-- > 0) { 4447 bitmap[0] = ntohl(*p++); 4448 if (len-- > 0) { 4449 bitmap[1] = ntohl(*p++); 4450 p += len; 4451 } 4452 } 4453 len = XDR_QUADLEN(ntohl(*p++)); /* attribute buffer length */ 4454 if (len > 0) { 4455 if (bitmap[0] & FATTR4_WORD0_RDATTR_ERROR) { 4456 bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR; 4457 /* Ignore the return value of rdattr_error for now */ 4458 p++; 4459 len--; 4460 } 4461 if (bitmap[0] == 0 && bitmap[1] == FATTR4_WORD1_MOUNTED_ON_FILEID) 4462 xdr_decode_hyper(p, &entry->ino); 4463 else if (bitmap[0] == FATTR4_WORD0_FILEID) 4464 xdr_decode_hyper(p, &entry->ino); 4465 p += len; 4466 } 4467 4468 entry->eof = !p[0] && p[1]; 4469 return p; 4470 } 4471 4472 /* 4473 * We need to translate between nfs status return values and 4474 * the local errno values which may not be the same. 4475 */ 4476 static struct { 4477 int stat; 4478 int errno; 4479 } nfs_errtbl[] = { 4480 { NFS4_OK, 0 }, 4481 { NFS4ERR_PERM, EPERM }, 4482 { NFS4ERR_NOENT, ENOENT }, 4483 { NFS4ERR_IO, errno_NFSERR_IO }, 4484 { NFS4ERR_NXIO, ENXIO }, 4485 { NFS4ERR_ACCESS, EACCES }, 4486 { NFS4ERR_EXIST, EEXIST }, 4487 { NFS4ERR_XDEV, EXDEV }, 4488 { NFS4ERR_NOTDIR, ENOTDIR }, 4489 { NFS4ERR_ISDIR, EISDIR }, 4490 { NFS4ERR_INVAL, EINVAL }, 4491 { NFS4ERR_FBIG, EFBIG }, 4492 { NFS4ERR_NOSPC, ENOSPC }, 4493 { NFS4ERR_ROFS, EROFS }, 4494 { NFS4ERR_MLINK, EMLINK }, 4495 { NFS4ERR_NAMETOOLONG, ENAMETOOLONG }, 4496 { NFS4ERR_NOTEMPTY, ENOTEMPTY }, 4497 { NFS4ERR_DQUOT, EDQUOT }, 4498 { NFS4ERR_STALE, ESTALE }, 4499 { NFS4ERR_BADHANDLE, EBADHANDLE }, 4500 { NFS4ERR_BADOWNER, EINVAL }, 4501 { NFS4ERR_BADNAME, EINVAL }, 4502 { NFS4ERR_BAD_COOKIE, EBADCOOKIE }, 4503 { NFS4ERR_NOTSUPP, ENOTSUPP }, 4504 { NFS4ERR_TOOSMALL, ETOOSMALL }, 4505 { NFS4ERR_SERVERFAULT, ESERVERFAULT }, 4506 { NFS4ERR_BADTYPE, EBADTYPE }, 4507 { NFS4ERR_LOCKED, EAGAIN }, 4508 { NFS4ERR_RESOURCE, EREMOTEIO }, 4509 { NFS4ERR_SYMLINK, ELOOP }, 4510 { NFS4ERR_OP_ILLEGAL, EOPNOTSUPP }, 4511 { NFS4ERR_DEADLOCK, EDEADLK }, 4512 { NFS4ERR_WRONGSEC, EPERM }, /* FIXME: this needs 4513 * to be handled by a 4514 * middle-layer. 4515 */ 4516 { -1, EIO } 4517 }; 4518 4519 /* 4520 * Convert an NFS error code to a local one. 4521 * This one is used jointly by NFSv2 and NFSv3. 4522 */ 4523 static int 4524 nfs_stat_to_errno(int stat) 4525 { 4526 int i; 4527 for (i = 0; nfs_errtbl[i].stat != -1; i++) { 4528 if (nfs_errtbl[i].stat == stat) 4529 return nfs_errtbl[i].errno; 4530 } 4531 if (stat <= 10000 || stat > 10100) { 4532 /* The server is looney tunes. */ 4533 return ESERVERFAULT; 4534 } 4535 /* If we cannot translate the error, the recovery routines should 4536 * handle it. 4537 * Note: remaining NFSv4 error codes have values > 10000, so should 4538 * not conflict with native Linux error codes. 4539 */ 4540 return stat; 4541 } 4542 4543 #ifndef MAX 4544 # define MAX(a, b) (((a) > (b))? (a) : (b)) 4545 #endif 4546 4547 #define PROC(proc, argtype, restype) \ 4548 [NFSPROC4_CLNT_##proc] = { \ 4549 .p_proc = NFSPROC4_COMPOUND, \ 4550 .p_encode = (kxdrproc_t) nfs4_xdr_##argtype, \ 4551 .p_decode = (kxdrproc_t) nfs4_xdr_##restype, \ 4552 .p_bufsiz = MAX(NFS4_##argtype##_sz,NFS4_##restype##_sz) << 2, \ 4553 .p_statidx = NFSPROC4_CLNT_##proc, \ 4554 .p_name = #proc, \ 4555 } 4556 4557 struct rpc_procinfo nfs4_procedures[] = { 4558 PROC(READ, enc_read, dec_read), 4559 PROC(WRITE, enc_write, dec_write), 4560 PROC(COMMIT, enc_commit, dec_commit), 4561 PROC(OPEN, enc_open, dec_open), 4562 PROC(OPEN_CONFIRM, enc_open_confirm, dec_open_confirm), 4563 PROC(OPEN_NOATTR, enc_open_noattr, dec_open_noattr), 4564 PROC(OPEN_DOWNGRADE, enc_open_downgrade, dec_open_downgrade), 4565 PROC(CLOSE, enc_close, dec_close), 4566 PROC(SETATTR, enc_setattr, dec_setattr), 4567 PROC(FSINFO, enc_fsinfo, dec_fsinfo), 4568 PROC(RENEW, enc_renew, dec_renew), 4569 PROC(SETCLIENTID, enc_setclientid, dec_setclientid), 4570 PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm), 4571 PROC(LOCK, enc_lock, dec_lock), 4572 PROC(LOCKT, enc_lockt, dec_lockt), 4573 PROC(LOCKU, enc_locku, dec_locku), 4574 PROC(ACCESS, enc_access, dec_access), 4575 PROC(GETATTR, enc_getattr, dec_getattr), 4576 PROC(LOOKUP, enc_lookup, dec_lookup), 4577 PROC(LOOKUP_ROOT, enc_lookup_root, dec_lookup_root), 4578 PROC(REMOVE, enc_remove, dec_remove), 4579 PROC(RENAME, enc_rename, dec_rename), 4580 PROC(LINK, enc_link, dec_link), 4581 PROC(SYMLINK, enc_symlink, dec_symlink), 4582 PROC(CREATE, enc_create, dec_create), 4583 PROC(PATHCONF, enc_pathconf, dec_pathconf), 4584 PROC(STATFS, enc_statfs, dec_statfs), 4585 PROC(READLINK, enc_readlink, dec_readlink), 4586 PROC(READDIR, enc_readdir, dec_readdir), 4587 PROC(SERVER_CAPS, enc_server_caps, dec_server_caps), 4588 PROC(DELEGRETURN, enc_delegreturn, dec_delegreturn), 4589 PROC(GETACL, enc_getacl, dec_getacl), 4590 PROC(SETACL, enc_setacl, dec_setacl), 4591 PROC(FS_LOCATIONS, enc_fs_locations, dec_fs_locations), 4592 }; 4593 4594 struct rpc_version nfs_version4 = { 4595 .number = 4, 4596 .nrprocs = ARRAY_SIZE(nfs4_procedures), 4597 .procs = nfs4_procedures 4598 }; 4599 4600 /* 4601 * Local variables: 4602 * c-basic-offset: 8 4603 * End: 4604 */ 4605