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