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