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