1 /* 2 * fs/nfs/nfs4proc.c 3 * 4 * Client-side procedure declarations 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/mm.h> 39 #include <linux/delay.h> 40 #include <linux/errno.h> 41 #include <linux/string.h> 42 #include <linux/ratelimit.h> 43 #include <linux/printk.h> 44 #include <linux/slab.h> 45 #include <linux/sunrpc/clnt.h> 46 #include <linux/nfs.h> 47 #include <linux/nfs4.h> 48 #include <linux/nfs_fs.h> 49 #include <linux/nfs_page.h> 50 #include <linux/nfs_mount.h> 51 #include <linux/namei.h> 52 #include <linux/mount.h> 53 #include <linux/module.h> 54 #include <linux/nfs_idmap.h> 55 #include <linux/xattr.h> 56 #include <linux/utsname.h> 57 #include <linux/freezer.h> 58 59 #include "nfs4_fs.h" 60 #include "delegation.h" 61 #include "internal.h" 62 #include "iostat.h" 63 #include "callback.h" 64 #include "pnfs.h" 65 #include "netns.h" 66 #include "nfs4session.h" 67 #include "fscache.h" 68 69 #include "nfs4trace.h" 70 71 #define NFSDBG_FACILITY NFSDBG_PROC 72 73 #define NFS4_POLL_RETRY_MIN (HZ/10) 74 #define NFS4_POLL_RETRY_MAX (15*HZ) 75 76 struct nfs4_opendata; 77 static int _nfs4_proc_open(struct nfs4_opendata *data); 78 static int _nfs4_recover_proc_open(struct nfs4_opendata *data); 79 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); 80 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *, long *); 81 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr); 82 static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label); 83 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label); 84 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 85 struct nfs_fattr *fattr, struct iattr *sattr, 86 struct nfs4_state *state, struct nfs4_label *ilabel, 87 struct nfs4_label *olabel); 88 #ifdef CONFIG_NFS_V4_1 89 static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *, 90 struct rpc_cred *); 91 static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *, 92 struct rpc_cred *); 93 #endif 94 95 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 96 static inline struct nfs4_label * 97 nfs4_label_init_security(struct inode *dir, struct dentry *dentry, 98 struct iattr *sattr, struct nfs4_label *label) 99 { 100 int err; 101 102 if (label == NULL) 103 return NULL; 104 105 if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0) 106 return NULL; 107 108 err = security_dentry_init_security(dentry, sattr->ia_mode, 109 &dentry->d_name, (void **)&label->label, &label->len); 110 if (err == 0) 111 return label; 112 113 return NULL; 114 } 115 static inline void 116 nfs4_label_release_security(struct nfs4_label *label) 117 { 118 if (label) 119 security_release_secctx(label->label, label->len); 120 } 121 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) 122 { 123 if (label) 124 return server->attr_bitmask; 125 126 return server->attr_bitmask_nl; 127 } 128 #else 129 static inline struct nfs4_label * 130 nfs4_label_init_security(struct inode *dir, struct dentry *dentry, 131 struct iattr *sattr, struct nfs4_label *l) 132 { return NULL; } 133 static inline void 134 nfs4_label_release_security(struct nfs4_label *label) 135 { return; } 136 static inline u32 * 137 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label) 138 { return server->attr_bitmask; } 139 #endif 140 141 /* Prevent leaks of NFSv4 errors into userland */ 142 static int nfs4_map_errors(int err) 143 { 144 if (err >= -1000) 145 return err; 146 switch (err) { 147 case -NFS4ERR_RESOURCE: 148 case -NFS4ERR_LAYOUTTRYLATER: 149 case -NFS4ERR_RECALLCONFLICT: 150 return -EREMOTEIO; 151 case -NFS4ERR_WRONGSEC: 152 case -NFS4ERR_WRONG_CRED: 153 return -EPERM; 154 case -NFS4ERR_BADOWNER: 155 case -NFS4ERR_BADNAME: 156 return -EINVAL; 157 case -NFS4ERR_SHARE_DENIED: 158 return -EACCES; 159 case -NFS4ERR_MINOR_VERS_MISMATCH: 160 return -EPROTONOSUPPORT; 161 case -NFS4ERR_FILE_OPEN: 162 return -EBUSY; 163 default: 164 dprintk("%s could not handle NFSv4 error %d\n", 165 __func__, -err); 166 break; 167 } 168 return -EIO; 169 } 170 171 /* 172 * This is our standard bitmap for GETATTR requests. 173 */ 174 const u32 nfs4_fattr_bitmap[3] = { 175 FATTR4_WORD0_TYPE 176 | FATTR4_WORD0_CHANGE 177 | FATTR4_WORD0_SIZE 178 | FATTR4_WORD0_FSID 179 | FATTR4_WORD0_FILEID, 180 FATTR4_WORD1_MODE 181 | FATTR4_WORD1_NUMLINKS 182 | FATTR4_WORD1_OWNER 183 | FATTR4_WORD1_OWNER_GROUP 184 | FATTR4_WORD1_RAWDEV 185 | FATTR4_WORD1_SPACE_USED 186 | FATTR4_WORD1_TIME_ACCESS 187 | FATTR4_WORD1_TIME_METADATA 188 | FATTR4_WORD1_TIME_MODIFY, 189 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 190 FATTR4_WORD2_SECURITY_LABEL 191 #endif 192 }; 193 194 static const u32 nfs4_pnfs_open_bitmap[3] = { 195 FATTR4_WORD0_TYPE 196 | FATTR4_WORD0_CHANGE 197 | FATTR4_WORD0_SIZE 198 | FATTR4_WORD0_FSID 199 | FATTR4_WORD0_FILEID, 200 FATTR4_WORD1_MODE 201 | FATTR4_WORD1_NUMLINKS 202 | FATTR4_WORD1_OWNER 203 | FATTR4_WORD1_OWNER_GROUP 204 | FATTR4_WORD1_RAWDEV 205 | FATTR4_WORD1_SPACE_USED 206 | FATTR4_WORD1_TIME_ACCESS 207 | FATTR4_WORD1_TIME_METADATA 208 | FATTR4_WORD1_TIME_MODIFY, 209 FATTR4_WORD2_MDSTHRESHOLD 210 }; 211 212 static const u32 nfs4_open_noattr_bitmap[3] = { 213 FATTR4_WORD0_TYPE 214 | FATTR4_WORD0_CHANGE 215 | FATTR4_WORD0_FILEID, 216 }; 217 218 const u32 nfs4_statfs_bitmap[3] = { 219 FATTR4_WORD0_FILES_AVAIL 220 | FATTR4_WORD0_FILES_FREE 221 | FATTR4_WORD0_FILES_TOTAL, 222 FATTR4_WORD1_SPACE_AVAIL 223 | FATTR4_WORD1_SPACE_FREE 224 | FATTR4_WORD1_SPACE_TOTAL 225 }; 226 227 const u32 nfs4_pathconf_bitmap[3] = { 228 FATTR4_WORD0_MAXLINK 229 | FATTR4_WORD0_MAXNAME, 230 0 231 }; 232 233 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE 234 | FATTR4_WORD0_MAXREAD 235 | FATTR4_WORD0_MAXWRITE 236 | FATTR4_WORD0_LEASE_TIME, 237 FATTR4_WORD1_TIME_DELTA 238 | FATTR4_WORD1_FS_LAYOUT_TYPES, 239 FATTR4_WORD2_LAYOUT_BLKSIZE 240 }; 241 242 const u32 nfs4_fs_locations_bitmap[3] = { 243 FATTR4_WORD0_TYPE 244 | FATTR4_WORD0_CHANGE 245 | FATTR4_WORD0_SIZE 246 | FATTR4_WORD0_FSID 247 | FATTR4_WORD0_FILEID 248 | FATTR4_WORD0_FS_LOCATIONS, 249 FATTR4_WORD1_MODE 250 | FATTR4_WORD1_NUMLINKS 251 | FATTR4_WORD1_OWNER 252 | FATTR4_WORD1_OWNER_GROUP 253 | FATTR4_WORD1_RAWDEV 254 | FATTR4_WORD1_SPACE_USED 255 | FATTR4_WORD1_TIME_ACCESS 256 | FATTR4_WORD1_TIME_METADATA 257 | FATTR4_WORD1_TIME_MODIFY 258 | FATTR4_WORD1_MOUNTED_ON_FILEID, 259 }; 260 261 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry, 262 struct nfs4_readdir_arg *readdir) 263 { 264 __be32 *start, *p; 265 266 if (cookie > 2) { 267 readdir->cookie = cookie; 268 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); 269 return; 270 } 271 272 readdir->cookie = 0; 273 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); 274 if (cookie == 2) 275 return; 276 277 /* 278 * NFSv4 servers do not return entries for '.' and '..' 279 * Therefore, we fake these entries here. We let '.' 280 * have cookie 0 and '..' have cookie 1. Note that 281 * when talking to the server, we always send cookie 0 282 * instead of 1 or 2. 283 */ 284 start = p = kmap_atomic(*readdir->pages); 285 286 if (cookie == 0) { 287 *p++ = xdr_one; /* next */ 288 *p++ = xdr_zero; /* cookie, first word */ 289 *p++ = xdr_one; /* cookie, second word */ 290 *p++ = xdr_one; /* entry len */ 291 memcpy(p, ".\0\0\0", 4); /* entry */ 292 p++; 293 *p++ = xdr_one; /* bitmap length */ 294 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 295 *p++ = htonl(8); /* attribute buffer length */ 296 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); 297 } 298 299 *p++ = xdr_one; /* next */ 300 *p++ = xdr_zero; /* cookie, first word */ 301 *p++ = xdr_two; /* cookie, second word */ 302 *p++ = xdr_two; /* entry len */ 303 memcpy(p, "..\0\0", 4); /* entry */ 304 p++; 305 *p++ = xdr_one; /* bitmap length */ 306 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 307 *p++ = htonl(8); /* attribute buffer length */ 308 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); 309 310 readdir->pgbase = (char *)p - (char *)start; 311 readdir->count -= readdir->pgbase; 312 kunmap_atomic(start); 313 } 314 315 static long nfs4_update_delay(long *timeout) 316 { 317 long ret; 318 if (!timeout) 319 return NFS4_POLL_RETRY_MAX; 320 if (*timeout <= 0) 321 *timeout = NFS4_POLL_RETRY_MIN; 322 if (*timeout > NFS4_POLL_RETRY_MAX) 323 *timeout = NFS4_POLL_RETRY_MAX; 324 ret = *timeout; 325 *timeout <<= 1; 326 return ret; 327 } 328 329 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout) 330 { 331 int res = 0; 332 333 might_sleep(); 334 335 freezable_schedule_timeout_killable_unsafe( 336 nfs4_update_delay(timeout)); 337 if (fatal_signal_pending(current)) 338 res = -ERESTARTSYS; 339 return res; 340 } 341 342 /* This is the error handling routine for processes that are allowed 343 * to sleep. 344 */ 345 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception) 346 { 347 struct nfs_client *clp = server->nfs_client; 348 struct nfs4_state *state = exception->state; 349 struct inode *inode = exception->inode; 350 int ret = errorcode; 351 352 exception->retry = 0; 353 switch(errorcode) { 354 case 0: 355 return 0; 356 case -NFS4ERR_OPENMODE: 357 if (inode && nfs4_have_delegation(inode, FMODE_READ)) { 358 nfs4_inode_return_delegation(inode); 359 exception->retry = 1; 360 return 0; 361 } 362 if (state == NULL) 363 break; 364 ret = nfs4_schedule_stateid_recovery(server, state); 365 if (ret < 0) 366 break; 367 goto wait_on_recovery; 368 case -NFS4ERR_DELEG_REVOKED: 369 case -NFS4ERR_ADMIN_REVOKED: 370 case -NFS4ERR_BAD_STATEID: 371 if (state == NULL) 372 break; 373 ret = nfs4_schedule_stateid_recovery(server, state); 374 if (ret < 0) 375 break; 376 goto wait_on_recovery; 377 case -NFS4ERR_EXPIRED: 378 if (state != NULL) { 379 ret = nfs4_schedule_stateid_recovery(server, state); 380 if (ret < 0) 381 break; 382 } 383 case -NFS4ERR_STALE_STATEID: 384 case -NFS4ERR_STALE_CLIENTID: 385 nfs4_schedule_lease_recovery(clp); 386 goto wait_on_recovery; 387 case -NFS4ERR_MOVED: 388 ret = nfs4_schedule_migration_recovery(server); 389 if (ret < 0) 390 break; 391 goto wait_on_recovery; 392 case -NFS4ERR_LEASE_MOVED: 393 nfs4_schedule_lease_moved_recovery(clp); 394 goto wait_on_recovery; 395 #if defined(CONFIG_NFS_V4_1) 396 case -NFS4ERR_BADSESSION: 397 case -NFS4ERR_BADSLOT: 398 case -NFS4ERR_BAD_HIGH_SLOT: 399 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 400 case -NFS4ERR_DEADSESSION: 401 case -NFS4ERR_SEQ_FALSE_RETRY: 402 case -NFS4ERR_SEQ_MISORDERED: 403 dprintk("%s ERROR: %d Reset session\n", __func__, 404 errorcode); 405 nfs4_schedule_session_recovery(clp->cl_session, errorcode); 406 goto wait_on_recovery; 407 #endif /* defined(CONFIG_NFS_V4_1) */ 408 case -NFS4ERR_FILE_OPEN: 409 if (exception->timeout > HZ) { 410 /* We have retried a decent amount, time to 411 * fail 412 */ 413 ret = -EBUSY; 414 break; 415 } 416 case -NFS4ERR_GRACE: 417 case -NFS4ERR_DELAY: 418 ret = nfs4_delay(server->client, &exception->timeout); 419 if (ret != 0) 420 break; 421 case -NFS4ERR_RETRY_UNCACHED_REP: 422 case -NFS4ERR_OLD_STATEID: 423 exception->retry = 1; 424 break; 425 case -NFS4ERR_BADOWNER: 426 /* The following works around a Linux server bug! */ 427 case -NFS4ERR_BADNAME: 428 if (server->caps & NFS_CAP_UIDGID_NOMAP) { 429 server->caps &= ~NFS_CAP_UIDGID_NOMAP; 430 exception->retry = 1; 431 printk(KERN_WARNING "NFS: v4 server %s " 432 "does not accept raw " 433 "uid/gids. " 434 "Reenabling the idmapper.\n", 435 server->nfs_client->cl_hostname); 436 } 437 } 438 /* We failed to handle the error */ 439 return nfs4_map_errors(ret); 440 wait_on_recovery: 441 ret = nfs4_wait_clnt_recover(clp); 442 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 443 return -EIO; 444 if (ret == 0) 445 exception->retry = 1; 446 return ret; 447 } 448 449 /* 450 * Return 'true' if 'clp' is using an rpc_client that is integrity protected 451 * or 'false' otherwise. 452 */ 453 static bool _nfs4_is_integrity_protected(struct nfs_client *clp) 454 { 455 rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor; 456 457 if (flavor == RPC_AUTH_GSS_KRB5I || 458 flavor == RPC_AUTH_GSS_KRB5P) 459 return true; 460 461 return false; 462 } 463 464 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp) 465 { 466 spin_lock(&clp->cl_lock); 467 if (time_before(clp->cl_last_renewal,timestamp)) 468 clp->cl_last_renewal = timestamp; 469 spin_unlock(&clp->cl_lock); 470 } 471 472 static void renew_lease(const struct nfs_server *server, unsigned long timestamp) 473 { 474 do_renew_lease(server->nfs_client, timestamp); 475 } 476 477 struct nfs4_call_sync_data { 478 const struct nfs_server *seq_server; 479 struct nfs4_sequence_args *seq_args; 480 struct nfs4_sequence_res *seq_res; 481 }; 482 483 static void nfs4_init_sequence(struct nfs4_sequence_args *args, 484 struct nfs4_sequence_res *res, int cache_reply) 485 { 486 args->sa_slot = NULL; 487 args->sa_cache_this = cache_reply; 488 args->sa_privileged = 0; 489 490 res->sr_slot = NULL; 491 } 492 493 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args) 494 { 495 args->sa_privileged = 1; 496 } 497 498 static int nfs40_setup_sequence(const struct nfs_server *server, 499 struct nfs4_sequence_args *args, 500 struct nfs4_sequence_res *res, 501 struct rpc_task *task) 502 { 503 struct nfs4_slot_table *tbl = server->nfs_client->cl_slot_tbl; 504 struct nfs4_slot *slot; 505 506 /* slot already allocated? */ 507 if (res->sr_slot != NULL) 508 goto out_start; 509 510 spin_lock(&tbl->slot_tbl_lock); 511 if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged) 512 goto out_sleep; 513 514 slot = nfs4_alloc_slot(tbl); 515 if (IS_ERR(slot)) { 516 if (slot == ERR_PTR(-ENOMEM)) 517 task->tk_timeout = HZ >> 2; 518 goto out_sleep; 519 } 520 spin_unlock(&tbl->slot_tbl_lock); 521 522 args->sa_slot = slot; 523 res->sr_slot = slot; 524 525 out_start: 526 rpc_call_start(task); 527 return 0; 528 529 out_sleep: 530 if (args->sa_privileged) 531 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task, 532 NULL, RPC_PRIORITY_PRIVILEGED); 533 else 534 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 535 spin_unlock(&tbl->slot_tbl_lock); 536 return -EAGAIN; 537 } 538 539 static int nfs40_sequence_done(struct rpc_task *task, 540 struct nfs4_sequence_res *res) 541 { 542 struct nfs4_slot *slot = res->sr_slot; 543 struct nfs4_slot_table *tbl; 544 545 if (slot == NULL) 546 goto out; 547 548 tbl = slot->table; 549 spin_lock(&tbl->slot_tbl_lock); 550 if (!nfs41_wake_and_assign_slot(tbl, slot)) 551 nfs4_free_slot(tbl, slot); 552 spin_unlock(&tbl->slot_tbl_lock); 553 554 res->sr_slot = NULL; 555 out: 556 return 1; 557 } 558 559 #if defined(CONFIG_NFS_V4_1) 560 561 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res) 562 { 563 struct nfs4_session *session; 564 struct nfs4_slot_table *tbl; 565 struct nfs4_slot *slot = res->sr_slot; 566 bool send_new_highest_used_slotid = false; 567 568 tbl = slot->table; 569 session = tbl->session; 570 571 spin_lock(&tbl->slot_tbl_lock); 572 /* Be nice to the server: try to ensure that the last transmitted 573 * value for highest_user_slotid <= target_highest_slotid 574 */ 575 if (tbl->highest_used_slotid > tbl->target_highest_slotid) 576 send_new_highest_used_slotid = true; 577 578 if (nfs41_wake_and_assign_slot(tbl, slot)) { 579 send_new_highest_used_slotid = false; 580 goto out_unlock; 581 } 582 nfs4_free_slot(tbl, slot); 583 584 if (tbl->highest_used_slotid != NFS4_NO_SLOT) 585 send_new_highest_used_slotid = false; 586 out_unlock: 587 spin_unlock(&tbl->slot_tbl_lock); 588 res->sr_slot = NULL; 589 if (send_new_highest_used_slotid) 590 nfs41_server_notify_highest_slotid_update(session->clp); 591 } 592 593 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res) 594 { 595 struct nfs4_session *session; 596 struct nfs4_slot *slot = res->sr_slot; 597 struct nfs_client *clp; 598 bool interrupted = false; 599 int ret = 1; 600 601 if (slot == NULL) 602 goto out_noaction; 603 /* don't increment the sequence number if the task wasn't sent */ 604 if (!RPC_WAS_SENT(task)) 605 goto out; 606 607 session = slot->table->session; 608 609 if (slot->interrupted) { 610 slot->interrupted = 0; 611 interrupted = true; 612 } 613 614 trace_nfs4_sequence_done(session, res); 615 /* Check the SEQUENCE operation status */ 616 switch (res->sr_status) { 617 case 0: 618 /* Update the slot's sequence and clientid lease timer */ 619 ++slot->seq_nr; 620 clp = session->clp; 621 do_renew_lease(clp, res->sr_timestamp); 622 /* Check sequence flags */ 623 if (res->sr_status_flags != 0) 624 nfs4_schedule_lease_recovery(clp); 625 nfs41_update_target_slotid(slot->table, slot, res); 626 break; 627 case 1: 628 /* 629 * sr_status remains 1 if an RPC level error occurred. 630 * The server may or may not have processed the sequence 631 * operation.. 632 * Mark the slot as having hosted an interrupted RPC call. 633 */ 634 slot->interrupted = 1; 635 goto out; 636 case -NFS4ERR_DELAY: 637 /* The server detected a resend of the RPC call and 638 * returned NFS4ERR_DELAY as per Section 2.10.6.2 639 * of RFC5661. 640 */ 641 dprintk("%s: slot=%u seq=%u: Operation in progress\n", 642 __func__, 643 slot->slot_nr, 644 slot->seq_nr); 645 goto out_retry; 646 case -NFS4ERR_BADSLOT: 647 /* 648 * The slot id we used was probably retired. Try again 649 * using a different slot id. 650 */ 651 goto retry_nowait; 652 case -NFS4ERR_SEQ_MISORDERED: 653 /* 654 * Was the last operation on this sequence interrupted? 655 * If so, retry after bumping the sequence number. 656 */ 657 if (interrupted) { 658 ++slot->seq_nr; 659 goto retry_nowait; 660 } 661 /* 662 * Could this slot have been previously retired? 663 * If so, then the server may be expecting seq_nr = 1! 664 */ 665 if (slot->seq_nr != 1) { 666 slot->seq_nr = 1; 667 goto retry_nowait; 668 } 669 break; 670 case -NFS4ERR_SEQ_FALSE_RETRY: 671 ++slot->seq_nr; 672 goto retry_nowait; 673 default: 674 /* Just update the slot sequence no. */ 675 ++slot->seq_nr; 676 } 677 out: 678 /* The session may be reset by one of the error handlers. */ 679 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status); 680 nfs41_sequence_free_slot(res); 681 out_noaction: 682 return ret; 683 retry_nowait: 684 if (rpc_restart_call_prepare(task)) { 685 task->tk_status = 0; 686 ret = 0; 687 } 688 goto out; 689 out_retry: 690 if (!rpc_restart_call(task)) 691 goto out; 692 rpc_delay(task, NFS4_POLL_RETRY_MAX); 693 return 0; 694 } 695 EXPORT_SYMBOL_GPL(nfs41_sequence_done); 696 697 static int nfs4_sequence_done(struct rpc_task *task, 698 struct nfs4_sequence_res *res) 699 { 700 if (res->sr_slot == NULL) 701 return 1; 702 if (!res->sr_slot->table->session) 703 return nfs40_sequence_done(task, res); 704 return nfs41_sequence_done(task, res); 705 } 706 707 int nfs41_setup_sequence(struct nfs4_session *session, 708 struct nfs4_sequence_args *args, 709 struct nfs4_sequence_res *res, 710 struct rpc_task *task) 711 { 712 struct nfs4_slot *slot; 713 struct nfs4_slot_table *tbl; 714 715 dprintk("--> %s\n", __func__); 716 /* slot already allocated? */ 717 if (res->sr_slot != NULL) 718 goto out_success; 719 720 tbl = &session->fc_slot_table; 721 722 task->tk_timeout = 0; 723 724 spin_lock(&tbl->slot_tbl_lock); 725 if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) && 726 !args->sa_privileged) { 727 /* The state manager will wait until the slot table is empty */ 728 dprintk("%s session is draining\n", __func__); 729 goto out_sleep; 730 } 731 732 slot = nfs4_alloc_slot(tbl); 733 if (IS_ERR(slot)) { 734 /* If out of memory, try again in 1/4 second */ 735 if (slot == ERR_PTR(-ENOMEM)) 736 task->tk_timeout = HZ >> 2; 737 dprintk("<-- %s: no free slots\n", __func__); 738 goto out_sleep; 739 } 740 spin_unlock(&tbl->slot_tbl_lock); 741 742 args->sa_slot = slot; 743 744 dprintk("<-- %s slotid=%u seqid=%u\n", __func__, 745 slot->slot_nr, slot->seq_nr); 746 747 res->sr_slot = slot; 748 res->sr_timestamp = jiffies; 749 res->sr_status_flags = 0; 750 /* 751 * sr_status is only set in decode_sequence, and so will remain 752 * set to 1 if an rpc level failure occurs. 753 */ 754 res->sr_status = 1; 755 trace_nfs4_setup_sequence(session, args); 756 out_success: 757 rpc_call_start(task); 758 return 0; 759 out_sleep: 760 /* Privileged tasks are queued with top priority */ 761 if (args->sa_privileged) 762 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task, 763 NULL, RPC_PRIORITY_PRIVILEGED); 764 else 765 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 766 spin_unlock(&tbl->slot_tbl_lock); 767 return -EAGAIN; 768 } 769 EXPORT_SYMBOL_GPL(nfs41_setup_sequence); 770 771 static int nfs4_setup_sequence(const struct nfs_server *server, 772 struct nfs4_sequence_args *args, 773 struct nfs4_sequence_res *res, 774 struct rpc_task *task) 775 { 776 struct nfs4_session *session = nfs4_get_session(server); 777 int ret = 0; 778 779 if (!session) 780 return nfs40_setup_sequence(server, args, res, task); 781 782 dprintk("--> %s clp %p session %p sr_slot %u\n", 783 __func__, session->clp, session, res->sr_slot ? 784 res->sr_slot->slot_nr : NFS4_NO_SLOT); 785 786 ret = nfs41_setup_sequence(session, args, res, task); 787 788 dprintk("<-- %s status=%d\n", __func__, ret); 789 return ret; 790 } 791 792 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata) 793 { 794 struct nfs4_call_sync_data *data = calldata; 795 struct nfs4_session *session = nfs4_get_session(data->seq_server); 796 797 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server); 798 799 nfs41_setup_sequence(session, data->seq_args, data->seq_res, task); 800 } 801 802 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata) 803 { 804 struct nfs4_call_sync_data *data = calldata; 805 806 nfs41_sequence_done(task, data->seq_res); 807 } 808 809 static const struct rpc_call_ops nfs41_call_sync_ops = { 810 .rpc_call_prepare = nfs41_call_sync_prepare, 811 .rpc_call_done = nfs41_call_sync_done, 812 }; 813 814 #else /* !CONFIG_NFS_V4_1 */ 815 816 static int nfs4_setup_sequence(const struct nfs_server *server, 817 struct nfs4_sequence_args *args, 818 struct nfs4_sequence_res *res, 819 struct rpc_task *task) 820 { 821 return nfs40_setup_sequence(server, args, res, task); 822 } 823 824 static int nfs4_sequence_done(struct rpc_task *task, 825 struct nfs4_sequence_res *res) 826 { 827 return nfs40_sequence_done(task, res); 828 } 829 830 #endif /* !CONFIG_NFS_V4_1 */ 831 832 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata) 833 { 834 struct nfs4_call_sync_data *data = calldata; 835 nfs4_setup_sequence(data->seq_server, 836 data->seq_args, data->seq_res, task); 837 } 838 839 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata) 840 { 841 struct nfs4_call_sync_data *data = calldata; 842 nfs4_sequence_done(task, data->seq_res); 843 } 844 845 static const struct rpc_call_ops nfs40_call_sync_ops = { 846 .rpc_call_prepare = nfs40_call_sync_prepare, 847 .rpc_call_done = nfs40_call_sync_done, 848 }; 849 850 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt, 851 struct nfs_server *server, 852 struct rpc_message *msg, 853 struct nfs4_sequence_args *args, 854 struct nfs4_sequence_res *res) 855 { 856 int ret; 857 struct rpc_task *task; 858 struct nfs_client *clp = server->nfs_client; 859 struct nfs4_call_sync_data data = { 860 .seq_server = server, 861 .seq_args = args, 862 .seq_res = res, 863 }; 864 struct rpc_task_setup task_setup = { 865 .rpc_client = clnt, 866 .rpc_message = msg, 867 .callback_ops = clp->cl_mvops->call_sync_ops, 868 .callback_data = &data 869 }; 870 871 task = rpc_run_task(&task_setup); 872 if (IS_ERR(task)) 873 ret = PTR_ERR(task); 874 else { 875 ret = task->tk_status; 876 rpc_put_task(task); 877 } 878 return ret; 879 } 880 881 int nfs4_call_sync(struct rpc_clnt *clnt, 882 struct nfs_server *server, 883 struct rpc_message *msg, 884 struct nfs4_sequence_args *args, 885 struct nfs4_sequence_res *res, 886 int cache_reply) 887 { 888 nfs4_init_sequence(args, res, cache_reply); 889 return nfs4_call_sync_sequence(clnt, server, msg, args, res); 890 } 891 892 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo) 893 { 894 struct nfs_inode *nfsi = NFS_I(dir); 895 896 spin_lock(&dir->i_lock); 897 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA; 898 if (!cinfo->atomic || cinfo->before != dir->i_version) 899 nfs_force_lookup_revalidate(dir); 900 dir->i_version = cinfo->after; 901 nfs_fscache_invalidate(dir); 902 spin_unlock(&dir->i_lock); 903 } 904 905 struct nfs4_opendata { 906 struct kref kref; 907 struct nfs_openargs o_arg; 908 struct nfs_openres o_res; 909 struct nfs_open_confirmargs c_arg; 910 struct nfs_open_confirmres c_res; 911 struct nfs4_string owner_name; 912 struct nfs4_string group_name; 913 struct nfs_fattr f_attr; 914 struct nfs4_label *f_label; 915 struct dentry *dir; 916 struct dentry *dentry; 917 struct nfs4_state_owner *owner; 918 struct nfs4_state *state; 919 struct iattr attrs; 920 unsigned long timestamp; 921 unsigned int rpc_done : 1; 922 unsigned int file_created : 1; 923 unsigned int is_recover : 1; 924 int rpc_status; 925 int cancelled; 926 }; 927 928 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server, 929 int err, struct nfs4_exception *exception) 930 { 931 if (err != -EINVAL) 932 return false; 933 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) 934 return false; 935 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1; 936 exception->retry = 1; 937 return true; 938 } 939 940 static enum open_claim_type4 941 nfs4_map_atomic_open_claim(struct nfs_server *server, 942 enum open_claim_type4 claim) 943 { 944 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1) 945 return claim; 946 switch (claim) { 947 default: 948 return claim; 949 case NFS4_OPEN_CLAIM_FH: 950 return NFS4_OPEN_CLAIM_NULL; 951 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 952 return NFS4_OPEN_CLAIM_DELEGATE_CUR; 953 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 954 return NFS4_OPEN_CLAIM_DELEGATE_PREV; 955 } 956 } 957 958 static void nfs4_init_opendata_res(struct nfs4_opendata *p) 959 { 960 p->o_res.f_attr = &p->f_attr; 961 p->o_res.f_label = p->f_label; 962 p->o_res.seqid = p->o_arg.seqid; 963 p->c_res.seqid = p->c_arg.seqid; 964 p->o_res.server = p->o_arg.server; 965 p->o_res.access_request = p->o_arg.access; 966 nfs_fattr_init(&p->f_attr); 967 nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name); 968 } 969 970 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry, 971 struct nfs4_state_owner *sp, fmode_t fmode, int flags, 972 const struct iattr *attrs, 973 struct nfs4_label *label, 974 enum open_claim_type4 claim, 975 gfp_t gfp_mask) 976 { 977 struct dentry *parent = dget_parent(dentry); 978 struct inode *dir = parent->d_inode; 979 struct nfs_server *server = NFS_SERVER(dir); 980 struct nfs4_opendata *p; 981 982 p = kzalloc(sizeof(*p), gfp_mask); 983 if (p == NULL) 984 goto err; 985 986 p->f_label = nfs4_label_alloc(server, gfp_mask); 987 if (IS_ERR(p->f_label)) 988 goto err_free_p; 989 990 p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask); 991 if (p->o_arg.seqid == NULL) 992 goto err_free_label; 993 nfs_sb_active(dentry->d_sb); 994 p->dentry = dget(dentry); 995 p->dir = parent; 996 p->owner = sp; 997 atomic_inc(&sp->so_count); 998 p->o_arg.open_flags = flags; 999 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); 1000 /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS 1001 * will return permission denied for all bits until close */ 1002 if (!(flags & O_EXCL)) { 1003 /* ask server to check for all possible rights as results 1004 * are cached */ 1005 p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY | 1006 NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE; 1007 } 1008 p->o_arg.clientid = server->nfs_client->cl_clientid; 1009 p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time); 1010 p->o_arg.id.uniquifier = sp->so_seqid.owner_id; 1011 p->o_arg.name = &dentry->d_name; 1012 p->o_arg.server = server; 1013 p->o_arg.bitmask = nfs4_bitmask(server, label); 1014 p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0]; 1015 p->o_arg.label = label; 1016 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim); 1017 switch (p->o_arg.claim) { 1018 case NFS4_OPEN_CLAIM_NULL: 1019 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 1020 case NFS4_OPEN_CLAIM_DELEGATE_PREV: 1021 p->o_arg.fh = NFS_FH(dir); 1022 break; 1023 case NFS4_OPEN_CLAIM_PREVIOUS: 1024 case NFS4_OPEN_CLAIM_FH: 1025 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 1026 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 1027 p->o_arg.fh = NFS_FH(dentry->d_inode); 1028 } 1029 if (attrs != NULL && attrs->ia_valid != 0) { 1030 __u32 verf[2]; 1031 1032 p->o_arg.u.attrs = &p->attrs; 1033 memcpy(&p->attrs, attrs, sizeof(p->attrs)); 1034 1035 verf[0] = jiffies; 1036 verf[1] = current->pid; 1037 memcpy(p->o_arg.u.verifier.data, verf, 1038 sizeof(p->o_arg.u.verifier.data)); 1039 } 1040 p->c_arg.fh = &p->o_res.fh; 1041 p->c_arg.stateid = &p->o_res.stateid; 1042 p->c_arg.seqid = p->o_arg.seqid; 1043 nfs4_init_opendata_res(p); 1044 kref_init(&p->kref); 1045 return p; 1046 1047 err_free_label: 1048 nfs4_label_free(p->f_label); 1049 err_free_p: 1050 kfree(p); 1051 err: 1052 dput(parent); 1053 return NULL; 1054 } 1055 1056 static void nfs4_opendata_free(struct kref *kref) 1057 { 1058 struct nfs4_opendata *p = container_of(kref, 1059 struct nfs4_opendata, kref); 1060 struct super_block *sb = p->dentry->d_sb; 1061 1062 nfs_free_seqid(p->o_arg.seqid); 1063 if (p->state != NULL) 1064 nfs4_put_open_state(p->state); 1065 nfs4_put_state_owner(p->owner); 1066 1067 nfs4_label_free(p->f_label); 1068 1069 dput(p->dir); 1070 dput(p->dentry); 1071 nfs_sb_deactive(sb); 1072 nfs_fattr_free_names(&p->f_attr); 1073 kfree(p->f_attr.mdsthreshold); 1074 kfree(p); 1075 } 1076 1077 static void nfs4_opendata_put(struct nfs4_opendata *p) 1078 { 1079 if (p != NULL) 1080 kref_put(&p->kref, nfs4_opendata_free); 1081 } 1082 1083 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) 1084 { 1085 int ret; 1086 1087 ret = rpc_wait_for_completion_task(task); 1088 return ret; 1089 } 1090 1091 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode) 1092 { 1093 int ret = 0; 1094 1095 if (open_mode & (O_EXCL|O_TRUNC)) 1096 goto out; 1097 switch (mode & (FMODE_READ|FMODE_WRITE)) { 1098 case FMODE_READ: 1099 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 1100 && state->n_rdonly != 0; 1101 break; 1102 case FMODE_WRITE: 1103 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 1104 && state->n_wronly != 0; 1105 break; 1106 case FMODE_READ|FMODE_WRITE: 1107 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 1108 && state->n_rdwr != 0; 1109 } 1110 out: 1111 return ret; 1112 } 1113 1114 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode) 1115 { 1116 if (delegation == NULL) 1117 return 0; 1118 if ((delegation->type & fmode) != fmode) 1119 return 0; 1120 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) 1121 return 0; 1122 nfs_mark_delegation_referenced(delegation); 1123 return 1; 1124 } 1125 1126 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode) 1127 { 1128 switch (fmode) { 1129 case FMODE_WRITE: 1130 state->n_wronly++; 1131 break; 1132 case FMODE_READ: 1133 state->n_rdonly++; 1134 break; 1135 case FMODE_READ|FMODE_WRITE: 1136 state->n_rdwr++; 1137 } 1138 nfs4_state_set_mode_locked(state, state->state | fmode); 1139 } 1140 1141 static void nfs_test_and_clear_all_open_stateid(struct nfs4_state *state) 1142 { 1143 struct nfs_client *clp = state->owner->so_server->nfs_client; 1144 bool need_recover = false; 1145 1146 if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly) 1147 need_recover = true; 1148 if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly) 1149 need_recover = true; 1150 if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr) 1151 need_recover = true; 1152 if (need_recover) 1153 nfs4_state_mark_reclaim_nograce(clp, state); 1154 } 1155 1156 static bool nfs_need_update_open_stateid(struct nfs4_state *state, 1157 nfs4_stateid *stateid) 1158 { 1159 if (test_and_set_bit(NFS_OPEN_STATE, &state->flags) == 0) 1160 return true; 1161 if (!nfs4_stateid_match_other(stateid, &state->open_stateid)) { 1162 nfs_test_and_clear_all_open_stateid(state); 1163 return true; 1164 } 1165 if (nfs4_stateid_is_newer(stateid, &state->open_stateid)) 1166 return true; 1167 return false; 1168 } 1169 1170 static void nfs_clear_open_stateid_locked(struct nfs4_state *state, 1171 nfs4_stateid *stateid, fmode_t fmode) 1172 { 1173 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1174 switch (fmode & (FMODE_READ|FMODE_WRITE)) { 1175 case FMODE_WRITE: 1176 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1177 break; 1178 case FMODE_READ: 1179 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1180 break; 1181 case 0: 1182 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1183 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1184 clear_bit(NFS_OPEN_STATE, &state->flags); 1185 } 1186 if (stateid == NULL) 1187 return; 1188 if (!nfs_need_update_open_stateid(state, stateid)) 1189 return; 1190 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1191 nfs4_stateid_copy(&state->stateid, stateid); 1192 nfs4_stateid_copy(&state->open_stateid, stateid); 1193 } 1194 1195 static void nfs_clear_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 1196 { 1197 write_seqlock(&state->seqlock); 1198 nfs_clear_open_stateid_locked(state, stateid, fmode); 1199 write_sequnlock(&state->seqlock); 1200 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) 1201 nfs4_schedule_state_manager(state->owner->so_server->nfs_client); 1202 } 1203 1204 static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 1205 { 1206 switch (fmode) { 1207 case FMODE_READ: 1208 set_bit(NFS_O_RDONLY_STATE, &state->flags); 1209 break; 1210 case FMODE_WRITE: 1211 set_bit(NFS_O_WRONLY_STATE, &state->flags); 1212 break; 1213 case FMODE_READ|FMODE_WRITE: 1214 set_bit(NFS_O_RDWR_STATE, &state->flags); 1215 } 1216 if (!nfs_need_update_open_stateid(state, stateid)) 1217 return; 1218 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1219 nfs4_stateid_copy(&state->stateid, stateid); 1220 nfs4_stateid_copy(&state->open_stateid, stateid); 1221 } 1222 1223 static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode) 1224 { 1225 /* 1226 * Protect the call to nfs4_state_set_mode_locked and 1227 * serialise the stateid update 1228 */ 1229 write_seqlock(&state->seqlock); 1230 if (deleg_stateid != NULL) { 1231 nfs4_stateid_copy(&state->stateid, deleg_stateid); 1232 set_bit(NFS_DELEGATED_STATE, &state->flags); 1233 } 1234 if (open_stateid != NULL) 1235 nfs_set_open_stateid_locked(state, open_stateid, fmode); 1236 write_sequnlock(&state->seqlock); 1237 spin_lock(&state->owner->so_lock); 1238 update_open_stateflags(state, fmode); 1239 spin_unlock(&state->owner->so_lock); 1240 } 1241 1242 static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode) 1243 { 1244 struct nfs_inode *nfsi = NFS_I(state->inode); 1245 struct nfs_delegation *deleg_cur; 1246 int ret = 0; 1247 1248 fmode &= (FMODE_READ|FMODE_WRITE); 1249 1250 rcu_read_lock(); 1251 deleg_cur = rcu_dereference(nfsi->delegation); 1252 if (deleg_cur == NULL) 1253 goto no_delegation; 1254 1255 spin_lock(&deleg_cur->lock); 1256 if (rcu_dereference(nfsi->delegation) != deleg_cur || 1257 test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) || 1258 (deleg_cur->type & fmode) != fmode) 1259 goto no_delegation_unlock; 1260 1261 if (delegation == NULL) 1262 delegation = &deleg_cur->stateid; 1263 else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation)) 1264 goto no_delegation_unlock; 1265 1266 nfs_mark_delegation_referenced(deleg_cur); 1267 __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); 1268 ret = 1; 1269 no_delegation_unlock: 1270 spin_unlock(&deleg_cur->lock); 1271 no_delegation: 1272 rcu_read_unlock(); 1273 1274 if (!ret && open_stateid != NULL) { 1275 __update_open_stateid(state, open_stateid, NULL, fmode); 1276 ret = 1; 1277 } 1278 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) 1279 nfs4_schedule_state_manager(state->owner->so_server->nfs_client); 1280 1281 return ret; 1282 } 1283 1284 1285 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode) 1286 { 1287 struct nfs_delegation *delegation; 1288 1289 rcu_read_lock(); 1290 delegation = rcu_dereference(NFS_I(inode)->delegation); 1291 if (delegation == NULL || (delegation->type & fmode) == fmode) { 1292 rcu_read_unlock(); 1293 return; 1294 } 1295 rcu_read_unlock(); 1296 nfs4_inode_return_delegation(inode); 1297 } 1298 1299 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata) 1300 { 1301 struct nfs4_state *state = opendata->state; 1302 struct nfs_inode *nfsi = NFS_I(state->inode); 1303 struct nfs_delegation *delegation; 1304 int open_mode = opendata->o_arg.open_flags; 1305 fmode_t fmode = opendata->o_arg.fmode; 1306 nfs4_stateid stateid; 1307 int ret = -EAGAIN; 1308 1309 for (;;) { 1310 spin_lock(&state->owner->so_lock); 1311 if (can_open_cached(state, fmode, open_mode)) { 1312 update_open_stateflags(state, fmode); 1313 spin_unlock(&state->owner->so_lock); 1314 goto out_return_state; 1315 } 1316 spin_unlock(&state->owner->so_lock); 1317 rcu_read_lock(); 1318 delegation = rcu_dereference(nfsi->delegation); 1319 if (!can_open_delegated(delegation, fmode)) { 1320 rcu_read_unlock(); 1321 break; 1322 } 1323 /* Save the delegation */ 1324 nfs4_stateid_copy(&stateid, &delegation->stateid); 1325 rcu_read_unlock(); 1326 nfs_release_seqid(opendata->o_arg.seqid); 1327 if (!opendata->is_recover) { 1328 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); 1329 if (ret != 0) 1330 goto out; 1331 } 1332 ret = -EAGAIN; 1333 1334 /* Try to update the stateid using the delegation */ 1335 if (update_open_stateid(state, NULL, &stateid, fmode)) 1336 goto out_return_state; 1337 } 1338 out: 1339 return ERR_PTR(ret); 1340 out_return_state: 1341 atomic_inc(&state->count); 1342 return state; 1343 } 1344 1345 static void 1346 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state) 1347 { 1348 struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client; 1349 struct nfs_delegation *delegation; 1350 int delegation_flags = 0; 1351 1352 rcu_read_lock(); 1353 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 1354 if (delegation) 1355 delegation_flags = delegation->flags; 1356 rcu_read_unlock(); 1357 if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) { 1358 pr_err_ratelimited("NFS: Broken NFSv4 server %s is " 1359 "returning a delegation for " 1360 "OPEN(CLAIM_DELEGATE_CUR)\n", 1361 clp->cl_hostname); 1362 } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0) 1363 nfs_inode_set_delegation(state->inode, 1364 data->owner->so_cred, 1365 &data->o_res); 1366 else 1367 nfs_inode_reclaim_delegation(state->inode, 1368 data->owner->so_cred, 1369 &data->o_res); 1370 } 1371 1372 /* 1373 * Check the inode attributes against the CLAIM_PREVIOUS returned attributes 1374 * and update the nfs4_state. 1375 */ 1376 static struct nfs4_state * 1377 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data) 1378 { 1379 struct inode *inode = data->state->inode; 1380 struct nfs4_state *state = data->state; 1381 int ret; 1382 1383 if (!data->rpc_done) { 1384 if (data->rpc_status) { 1385 ret = data->rpc_status; 1386 goto err; 1387 } 1388 /* cached opens have already been processed */ 1389 goto update; 1390 } 1391 1392 ret = nfs_refresh_inode(inode, &data->f_attr); 1393 if (ret) 1394 goto err; 1395 1396 if (data->o_res.delegation_type != 0) 1397 nfs4_opendata_check_deleg(data, state); 1398 update: 1399 update_open_stateid(state, &data->o_res.stateid, NULL, 1400 data->o_arg.fmode); 1401 atomic_inc(&state->count); 1402 1403 return state; 1404 err: 1405 return ERR_PTR(ret); 1406 1407 } 1408 1409 static struct nfs4_state * 1410 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 1411 { 1412 struct inode *inode; 1413 struct nfs4_state *state = NULL; 1414 int ret; 1415 1416 if (!data->rpc_done) { 1417 state = nfs4_try_open_cached(data); 1418 goto out; 1419 } 1420 1421 ret = -EAGAIN; 1422 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) 1423 goto err; 1424 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label); 1425 ret = PTR_ERR(inode); 1426 if (IS_ERR(inode)) 1427 goto err; 1428 ret = -ENOMEM; 1429 state = nfs4_get_open_state(inode, data->owner); 1430 if (state == NULL) 1431 goto err_put_inode; 1432 if (data->o_res.delegation_type != 0) 1433 nfs4_opendata_check_deleg(data, state); 1434 update_open_stateid(state, &data->o_res.stateid, NULL, 1435 data->o_arg.fmode); 1436 iput(inode); 1437 out: 1438 nfs_release_seqid(data->o_arg.seqid); 1439 return state; 1440 err_put_inode: 1441 iput(inode); 1442 err: 1443 return ERR_PTR(ret); 1444 } 1445 1446 static struct nfs4_state * 1447 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 1448 { 1449 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) 1450 return _nfs4_opendata_reclaim_to_nfs4_state(data); 1451 return _nfs4_opendata_to_nfs4_state(data); 1452 } 1453 1454 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state) 1455 { 1456 struct nfs_inode *nfsi = NFS_I(state->inode); 1457 struct nfs_open_context *ctx; 1458 1459 spin_lock(&state->inode->i_lock); 1460 list_for_each_entry(ctx, &nfsi->open_files, list) { 1461 if (ctx->state != state) 1462 continue; 1463 get_nfs_open_context(ctx); 1464 spin_unlock(&state->inode->i_lock); 1465 return ctx; 1466 } 1467 spin_unlock(&state->inode->i_lock); 1468 return ERR_PTR(-ENOENT); 1469 } 1470 1471 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, 1472 struct nfs4_state *state, enum open_claim_type4 claim) 1473 { 1474 struct nfs4_opendata *opendata; 1475 1476 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, 1477 NULL, NULL, claim, GFP_NOFS); 1478 if (opendata == NULL) 1479 return ERR_PTR(-ENOMEM); 1480 opendata->state = state; 1481 atomic_inc(&state->count); 1482 return opendata; 1483 } 1484 1485 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res) 1486 { 1487 struct nfs4_state *newstate; 1488 int ret; 1489 1490 opendata->o_arg.open_flags = 0; 1491 opendata->o_arg.fmode = fmode; 1492 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); 1493 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); 1494 nfs4_init_opendata_res(opendata); 1495 ret = _nfs4_recover_proc_open(opendata); 1496 if (ret != 0) 1497 return ret; 1498 newstate = nfs4_opendata_to_nfs4_state(opendata); 1499 if (IS_ERR(newstate)) 1500 return PTR_ERR(newstate); 1501 nfs4_close_state(newstate, fmode); 1502 *res = newstate; 1503 return 0; 1504 } 1505 1506 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state) 1507 { 1508 struct nfs4_state *newstate; 1509 int ret; 1510 1511 /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */ 1512 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1513 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1514 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1515 /* memory barrier prior to reading state->n_* */ 1516 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1517 clear_bit(NFS_OPEN_STATE, &state->flags); 1518 smp_rmb(); 1519 if (state->n_rdwr != 0) { 1520 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate); 1521 if (ret != 0) 1522 return ret; 1523 if (newstate != state) 1524 return -ESTALE; 1525 } 1526 if (state->n_wronly != 0) { 1527 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate); 1528 if (ret != 0) 1529 return ret; 1530 if (newstate != state) 1531 return -ESTALE; 1532 } 1533 if (state->n_rdonly != 0) { 1534 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate); 1535 if (ret != 0) 1536 return ret; 1537 if (newstate != state) 1538 return -ESTALE; 1539 } 1540 /* 1541 * We may have performed cached opens for all three recoveries. 1542 * Check if we need to update the current stateid. 1543 */ 1544 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && 1545 !nfs4_stateid_match(&state->stateid, &state->open_stateid)) { 1546 write_seqlock(&state->seqlock); 1547 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1548 nfs4_stateid_copy(&state->stateid, &state->open_stateid); 1549 write_sequnlock(&state->seqlock); 1550 } 1551 return 0; 1552 } 1553 1554 /* 1555 * OPEN_RECLAIM: 1556 * reclaim state on the server after a reboot. 1557 */ 1558 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1559 { 1560 struct nfs_delegation *delegation; 1561 struct nfs4_opendata *opendata; 1562 fmode_t delegation_type = 0; 1563 int status; 1564 1565 opendata = nfs4_open_recoverdata_alloc(ctx, state, 1566 NFS4_OPEN_CLAIM_PREVIOUS); 1567 if (IS_ERR(opendata)) 1568 return PTR_ERR(opendata); 1569 rcu_read_lock(); 1570 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 1571 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) 1572 delegation_type = delegation->type; 1573 rcu_read_unlock(); 1574 opendata->o_arg.u.delegation_type = delegation_type; 1575 status = nfs4_open_recover(opendata, state); 1576 nfs4_opendata_put(opendata); 1577 return status; 1578 } 1579 1580 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1581 { 1582 struct nfs_server *server = NFS_SERVER(state->inode); 1583 struct nfs4_exception exception = { }; 1584 int err; 1585 do { 1586 err = _nfs4_do_open_reclaim(ctx, state); 1587 trace_nfs4_open_reclaim(ctx, 0, err); 1588 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) 1589 continue; 1590 if (err != -NFS4ERR_DELAY) 1591 break; 1592 nfs4_handle_exception(server, err, &exception); 1593 } while (exception.retry); 1594 return err; 1595 } 1596 1597 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state) 1598 { 1599 struct nfs_open_context *ctx; 1600 int ret; 1601 1602 ctx = nfs4_state_find_open_context(state); 1603 if (IS_ERR(ctx)) 1604 return -EAGAIN; 1605 ret = nfs4_do_open_reclaim(ctx, state); 1606 put_nfs_open_context(ctx); 1607 return ret; 1608 } 1609 1610 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err) 1611 { 1612 switch (err) { 1613 default: 1614 printk(KERN_ERR "NFS: %s: unhandled error " 1615 "%d.\n", __func__, err); 1616 case 0: 1617 case -ENOENT: 1618 case -ESTALE: 1619 break; 1620 case -NFS4ERR_BADSESSION: 1621 case -NFS4ERR_BADSLOT: 1622 case -NFS4ERR_BAD_HIGH_SLOT: 1623 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1624 case -NFS4ERR_DEADSESSION: 1625 set_bit(NFS_DELEGATED_STATE, &state->flags); 1626 nfs4_schedule_session_recovery(server->nfs_client->cl_session, err); 1627 return -EAGAIN; 1628 case -NFS4ERR_STALE_CLIENTID: 1629 case -NFS4ERR_STALE_STATEID: 1630 set_bit(NFS_DELEGATED_STATE, &state->flags); 1631 case -NFS4ERR_EXPIRED: 1632 /* Don't recall a delegation if it was lost */ 1633 nfs4_schedule_lease_recovery(server->nfs_client); 1634 return -EAGAIN; 1635 case -NFS4ERR_MOVED: 1636 nfs4_schedule_migration_recovery(server); 1637 return -EAGAIN; 1638 case -NFS4ERR_LEASE_MOVED: 1639 nfs4_schedule_lease_moved_recovery(server->nfs_client); 1640 return -EAGAIN; 1641 case -NFS4ERR_DELEG_REVOKED: 1642 case -NFS4ERR_ADMIN_REVOKED: 1643 case -NFS4ERR_BAD_STATEID: 1644 case -NFS4ERR_OPENMODE: 1645 nfs_inode_find_state_and_recover(state->inode, 1646 stateid); 1647 nfs4_schedule_stateid_recovery(server, state); 1648 return -EAGAIN; 1649 case -NFS4ERR_DELAY: 1650 case -NFS4ERR_GRACE: 1651 set_bit(NFS_DELEGATED_STATE, &state->flags); 1652 ssleep(1); 1653 return -EAGAIN; 1654 case -ENOMEM: 1655 case -NFS4ERR_DENIED: 1656 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 1657 return 0; 1658 } 1659 return err; 1660 } 1661 1662 int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 1663 { 1664 struct nfs_server *server = NFS_SERVER(state->inode); 1665 struct nfs4_opendata *opendata; 1666 int err; 1667 1668 opendata = nfs4_open_recoverdata_alloc(ctx, state, 1669 NFS4_OPEN_CLAIM_DELEG_CUR_FH); 1670 if (IS_ERR(opendata)) 1671 return PTR_ERR(opendata); 1672 nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid); 1673 err = nfs4_open_recover(opendata, state); 1674 nfs4_opendata_put(opendata); 1675 return nfs4_handle_delegation_recall_error(server, state, stateid, err); 1676 } 1677 1678 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata) 1679 { 1680 struct nfs4_opendata *data = calldata; 1681 1682 nfs40_setup_sequence(data->o_arg.server, &data->c_arg.seq_args, 1683 &data->c_res.seq_res, task); 1684 } 1685 1686 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) 1687 { 1688 struct nfs4_opendata *data = calldata; 1689 1690 nfs40_sequence_done(task, &data->c_res.seq_res); 1691 1692 data->rpc_status = task->tk_status; 1693 if (data->rpc_status == 0) { 1694 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid); 1695 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1696 renew_lease(data->o_res.server, data->timestamp); 1697 data->rpc_done = 1; 1698 } 1699 } 1700 1701 static void nfs4_open_confirm_release(void *calldata) 1702 { 1703 struct nfs4_opendata *data = calldata; 1704 struct nfs4_state *state = NULL; 1705 1706 /* If this request hasn't been cancelled, do nothing */ 1707 if (data->cancelled == 0) 1708 goto out_free; 1709 /* In case of error, no cleanup! */ 1710 if (!data->rpc_done) 1711 goto out_free; 1712 state = nfs4_opendata_to_nfs4_state(data); 1713 if (!IS_ERR(state)) 1714 nfs4_close_state(state, data->o_arg.fmode); 1715 out_free: 1716 nfs4_opendata_put(data); 1717 } 1718 1719 static const struct rpc_call_ops nfs4_open_confirm_ops = { 1720 .rpc_call_prepare = nfs4_open_confirm_prepare, 1721 .rpc_call_done = nfs4_open_confirm_done, 1722 .rpc_release = nfs4_open_confirm_release, 1723 }; 1724 1725 /* 1726 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata 1727 */ 1728 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 1729 { 1730 struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 1731 struct rpc_task *task; 1732 struct rpc_message msg = { 1733 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM], 1734 .rpc_argp = &data->c_arg, 1735 .rpc_resp = &data->c_res, 1736 .rpc_cred = data->owner->so_cred, 1737 }; 1738 struct rpc_task_setup task_setup_data = { 1739 .rpc_client = server->client, 1740 .rpc_message = &msg, 1741 .callback_ops = &nfs4_open_confirm_ops, 1742 .callback_data = data, 1743 .workqueue = nfsiod_workqueue, 1744 .flags = RPC_TASK_ASYNC, 1745 }; 1746 int status; 1747 1748 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1); 1749 kref_get(&data->kref); 1750 data->rpc_done = 0; 1751 data->rpc_status = 0; 1752 data->timestamp = jiffies; 1753 task = rpc_run_task(&task_setup_data); 1754 if (IS_ERR(task)) 1755 return PTR_ERR(task); 1756 status = nfs4_wait_for_completion_rpc_task(task); 1757 if (status != 0) { 1758 data->cancelled = 1; 1759 smp_wmb(); 1760 } else 1761 status = data->rpc_status; 1762 rpc_put_task(task); 1763 return status; 1764 } 1765 1766 static void nfs4_open_prepare(struct rpc_task *task, void *calldata) 1767 { 1768 struct nfs4_opendata *data = calldata; 1769 struct nfs4_state_owner *sp = data->owner; 1770 struct nfs_client *clp = sp->so_server->nfs_client; 1771 1772 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) 1773 goto out_wait; 1774 /* 1775 * Check if we still need to send an OPEN call, or if we can use 1776 * a delegation instead. 1777 */ 1778 if (data->state != NULL) { 1779 struct nfs_delegation *delegation; 1780 1781 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) 1782 goto out_no_action; 1783 rcu_read_lock(); 1784 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); 1785 if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR && 1786 data->o_arg.claim != NFS4_OPEN_CLAIM_DELEG_CUR_FH && 1787 can_open_delegated(delegation, data->o_arg.fmode)) 1788 goto unlock_no_action; 1789 rcu_read_unlock(); 1790 } 1791 /* Update client id. */ 1792 data->o_arg.clientid = clp->cl_clientid; 1793 switch (data->o_arg.claim) { 1794 case NFS4_OPEN_CLAIM_PREVIOUS: 1795 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 1796 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 1797 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0]; 1798 case NFS4_OPEN_CLAIM_FH: 1799 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; 1800 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); 1801 } 1802 data->timestamp = jiffies; 1803 if (nfs4_setup_sequence(data->o_arg.server, 1804 &data->o_arg.seq_args, 1805 &data->o_res.seq_res, 1806 task) != 0) 1807 nfs_release_seqid(data->o_arg.seqid); 1808 1809 /* Set the create mode (note dependency on the session type) */ 1810 data->o_arg.createmode = NFS4_CREATE_UNCHECKED; 1811 if (data->o_arg.open_flags & O_EXCL) { 1812 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE; 1813 if (nfs4_has_persistent_session(clp)) 1814 data->o_arg.createmode = NFS4_CREATE_GUARDED; 1815 else if (clp->cl_mvops->minor_version > 0) 1816 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1; 1817 } 1818 return; 1819 unlock_no_action: 1820 rcu_read_unlock(); 1821 out_no_action: 1822 task->tk_action = NULL; 1823 out_wait: 1824 nfs4_sequence_done(task, &data->o_res.seq_res); 1825 } 1826 1827 static void nfs4_open_done(struct rpc_task *task, void *calldata) 1828 { 1829 struct nfs4_opendata *data = calldata; 1830 1831 data->rpc_status = task->tk_status; 1832 1833 if (!nfs4_sequence_done(task, &data->o_res.seq_res)) 1834 return; 1835 1836 if (task->tk_status == 0) { 1837 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) { 1838 switch (data->o_res.f_attr->mode & S_IFMT) { 1839 case S_IFREG: 1840 break; 1841 case S_IFLNK: 1842 data->rpc_status = -ELOOP; 1843 break; 1844 case S_IFDIR: 1845 data->rpc_status = -EISDIR; 1846 break; 1847 default: 1848 data->rpc_status = -ENOTDIR; 1849 } 1850 } 1851 renew_lease(data->o_res.server, data->timestamp); 1852 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) 1853 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1854 } 1855 data->rpc_done = 1; 1856 } 1857 1858 static void nfs4_open_release(void *calldata) 1859 { 1860 struct nfs4_opendata *data = calldata; 1861 struct nfs4_state *state = NULL; 1862 1863 /* If this request hasn't been cancelled, do nothing */ 1864 if (data->cancelled == 0) 1865 goto out_free; 1866 /* In case of error, no cleanup! */ 1867 if (data->rpc_status != 0 || !data->rpc_done) 1868 goto out_free; 1869 /* In case we need an open_confirm, no cleanup! */ 1870 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) 1871 goto out_free; 1872 state = nfs4_opendata_to_nfs4_state(data); 1873 if (!IS_ERR(state)) 1874 nfs4_close_state(state, data->o_arg.fmode); 1875 out_free: 1876 nfs4_opendata_put(data); 1877 } 1878 1879 static const struct rpc_call_ops nfs4_open_ops = { 1880 .rpc_call_prepare = nfs4_open_prepare, 1881 .rpc_call_done = nfs4_open_done, 1882 .rpc_release = nfs4_open_release, 1883 }; 1884 1885 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover) 1886 { 1887 struct inode *dir = data->dir->d_inode; 1888 struct nfs_server *server = NFS_SERVER(dir); 1889 struct nfs_openargs *o_arg = &data->o_arg; 1890 struct nfs_openres *o_res = &data->o_res; 1891 struct rpc_task *task; 1892 struct rpc_message msg = { 1893 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN], 1894 .rpc_argp = o_arg, 1895 .rpc_resp = o_res, 1896 .rpc_cred = data->owner->so_cred, 1897 }; 1898 struct rpc_task_setup task_setup_data = { 1899 .rpc_client = server->client, 1900 .rpc_message = &msg, 1901 .callback_ops = &nfs4_open_ops, 1902 .callback_data = data, 1903 .workqueue = nfsiod_workqueue, 1904 .flags = RPC_TASK_ASYNC, 1905 }; 1906 int status; 1907 1908 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1); 1909 kref_get(&data->kref); 1910 data->rpc_done = 0; 1911 data->rpc_status = 0; 1912 data->cancelled = 0; 1913 data->is_recover = 0; 1914 if (isrecover) { 1915 nfs4_set_sequence_privileged(&o_arg->seq_args); 1916 data->is_recover = 1; 1917 } 1918 task = rpc_run_task(&task_setup_data); 1919 if (IS_ERR(task)) 1920 return PTR_ERR(task); 1921 status = nfs4_wait_for_completion_rpc_task(task); 1922 if (status != 0) { 1923 data->cancelled = 1; 1924 smp_wmb(); 1925 } else 1926 status = data->rpc_status; 1927 rpc_put_task(task); 1928 1929 return status; 1930 } 1931 1932 static int _nfs4_recover_proc_open(struct nfs4_opendata *data) 1933 { 1934 struct inode *dir = data->dir->d_inode; 1935 struct nfs_openres *o_res = &data->o_res; 1936 int status; 1937 1938 status = nfs4_run_open_task(data, 1); 1939 if (status != 0 || !data->rpc_done) 1940 return status; 1941 1942 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr); 1943 1944 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 1945 status = _nfs4_proc_open_confirm(data); 1946 if (status != 0) 1947 return status; 1948 } 1949 1950 return status; 1951 } 1952 1953 /* 1954 * Additional permission checks in order to distinguish between an 1955 * open for read, and an open for execute. This works around the 1956 * fact that NFSv4 OPEN treats read and execute permissions as being 1957 * the same. 1958 * Note that in the non-execute case, we want to turn off permission 1959 * checking if we just created a new file (POSIX open() semantics). 1960 */ 1961 static int nfs4_opendata_access(struct rpc_cred *cred, 1962 struct nfs4_opendata *opendata, 1963 struct nfs4_state *state, fmode_t fmode, 1964 int openflags) 1965 { 1966 struct nfs_access_entry cache; 1967 u32 mask; 1968 1969 /* access call failed or for some reason the server doesn't 1970 * support any access modes -- defer access call until later */ 1971 if (opendata->o_res.access_supported == 0) 1972 return 0; 1973 1974 mask = 0; 1975 /* 1976 * Use openflags to check for exec, because fmode won't 1977 * always have FMODE_EXEC set when file open for exec. 1978 */ 1979 if (openflags & __FMODE_EXEC) { 1980 /* ONLY check for exec rights */ 1981 mask = MAY_EXEC; 1982 } else if ((fmode & FMODE_READ) && !opendata->file_created) 1983 mask = MAY_READ; 1984 1985 cache.cred = cred; 1986 cache.jiffies = jiffies; 1987 nfs_access_set_mask(&cache, opendata->o_res.access_result); 1988 nfs_access_add_cache(state->inode, &cache); 1989 1990 if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0) 1991 return 0; 1992 1993 /* even though OPEN succeeded, access is denied. Close the file */ 1994 nfs4_close_state(state, fmode); 1995 return -EACCES; 1996 } 1997 1998 /* 1999 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata 2000 */ 2001 static int _nfs4_proc_open(struct nfs4_opendata *data) 2002 { 2003 struct inode *dir = data->dir->d_inode; 2004 struct nfs_server *server = NFS_SERVER(dir); 2005 struct nfs_openargs *o_arg = &data->o_arg; 2006 struct nfs_openres *o_res = &data->o_res; 2007 int status; 2008 2009 status = nfs4_run_open_task(data, 0); 2010 if (!data->rpc_done) 2011 return status; 2012 if (status != 0) { 2013 if (status == -NFS4ERR_BADNAME && 2014 !(o_arg->open_flags & O_CREAT)) 2015 return -ENOENT; 2016 return status; 2017 } 2018 2019 nfs_fattr_map_and_free_names(server, &data->f_attr); 2020 2021 if (o_arg->open_flags & O_CREAT) { 2022 update_changeattr(dir, &o_res->cinfo); 2023 if (o_arg->open_flags & O_EXCL) 2024 data->file_created = 1; 2025 else if (o_res->cinfo.before != o_res->cinfo.after) 2026 data->file_created = 1; 2027 } 2028 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) 2029 server->caps &= ~NFS_CAP_POSIX_LOCK; 2030 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 2031 status = _nfs4_proc_open_confirm(data); 2032 if (status != 0) 2033 return status; 2034 } 2035 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) 2036 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label); 2037 return 0; 2038 } 2039 2040 static int nfs4_recover_expired_lease(struct nfs_server *server) 2041 { 2042 return nfs4_client_recover_expired_lease(server->nfs_client); 2043 } 2044 2045 /* 2046 * OPEN_EXPIRED: 2047 * reclaim state on the server after a network partition. 2048 * Assumes caller holds the appropriate lock 2049 */ 2050 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 2051 { 2052 struct nfs4_opendata *opendata; 2053 int ret; 2054 2055 opendata = nfs4_open_recoverdata_alloc(ctx, state, 2056 NFS4_OPEN_CLAIM_FH); 2057 if (IS_ERR(opendata)) 2058 return PTR_ERR(opendata); 2059 ret = nfs4_open_recover(opendata, state); 2060 if (ret == -ESTALE) 2061 d_drop(ctx->dentry); 2062 nfs4_opendata_put(opendata); 2063 return ret; 2064 } 2065 2066 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 2067 { 2068 struct nfs_server *server = NFS_SERVER(state->inode); 2069 struct nfs4_exception exception = { }; 2070 int err; 2071 2072 do { 2073 err = _nfs4_open_expired(ctx, state); 2074 trace_nfs4_open_expired(ctx, 0, err); 2075 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception)) 2076 continue; 2077 switch (err) { 2078 default: 2079 goto out; 2080 case -NFS4ERR_GRACE: 2081 case -NFS4ERR_DELAY: 2082 nfs4_handle_exception(server, err, &exception); 2083 err = 0; 2084 } 2085 } while (exception.retry); 2086 out: 2087 return err; 2088 } 2089 2090 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 2091 { 2092 struct nfs_open_context *ctx; 2093 int ret; 2094 2095 ctx = nfs4_state_find_open_context(state); 2096 if (IS_ERR(ctx)) 2097 return -EAGAIN; 2098 ret = nfs4_do_open_expired(ctx, state); 2099 put_nfs_open_context(ctx); 2100 return ret; 2101 } 2102 2103 static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state) 2104 { 2105 nfs_remove_bad_delegation(state->inode); 2106 write_seqlock(&state->seqlock); 2107 nfs4_stateid_copy(&state->stateid, &state->open_stateid); 2108 write_sequnlock(&state->seqlock); 2109 clear_bit(NFS_DELEGATED_STATE, &state->flags); 2110 } 2111 2112 static void nfs40_clear_delegation_stateid(struct nfs4_state *state) 2113 { 2114 if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL) 2115 nfs_finish_clear_delegation_stateid(state); 2116 } 2117 2118 static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 2119 { 2120 /* NFSv4.0 doesn't allow for delegation recovery on open expire */ 2121 nfs40_clear_delegation_stateid(state); 2122 return nfs4_open_expired(sp, state); 2123 } 2124 2125 #if defined(CONFIG_NFS_V4_1) 2126 static void nfs41_check_delegation_stateid(struct nfs4_state *state) 2127 { 2128 struct nfs_server *server = NFS_SERVER(state->inode); 2129 nfs4_stateid stateid; 2130 struct nfs_delegation *delegation; 2131 struct rpc_cred *cred; 2132 int status; 2133 2134 /* Get the delegation credential for use by test/free_stateid */ 2135 rcu_read_lock(); 2136 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 2137 if (delegation == NULL) { 2138 rcu_read_unlock(); 2139 return; 2140 } 2141 2142 nfs4_stateid_copy(&stateid, &delegation->stateid); 2143 cred = get_rpccred(delegation->cred); 2144 rcu_read_unlock(); 2145 status = nfs41_test_stateid(server, &stateid, cred); 2146 trace_nfs4_test_delegation_stateid(state, NULL, status); 2147 2148 if (status != NFS_OK) { 2149 /* Free the stateid unless the server explicitly 2150 * informs us the stateid is unrecognized. */ 2151 if (status != -NFS4ERR_BAD_STATEID) 2152 nfs41_free_stateid(server, &stateid, cred); 2153 nfs_finish_clear_delegation_stateid(state); 2154 } 2155 2156 put_rpccred(cred); 2157 } 2158 2159 /** 2160 * nfs41_check_open_stateid - possibly free an open stateid 2161 * 2162 * @state: NFSv4 state for an inode 2163 * 2164 * Returns NFS_OK if recovery for this stateid is now finished. 2165 * Otherwise a negative NFS4ERR value is returned. 2166 */ 2167 static int nfs41_check_open_stateid(struct nfs4_state *state) 2168 { 2169 struct nfs_server *server = NFS_SERVER(state->inode); 2170 nfs4_stateid *stateid = &state->open_stateid; 2171 struct rpc_cred *cred = state->owner->so_cred; 2172 int status; 2173 2174 /* If a state reset has been done, test_stateid is unneeded */ 2175 if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) && 2176 (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) && 2177 (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0)) 2178 return -NFS4ERR_BAD_STATEID; 2179 2180 status = nfs41_test_stateid(server, stateid, cred); 2181 trace_nfs4_test_open_stateid(state, NULL, status); 2182 if (status != NFS_OK) { 2183 /* Free the stateid unless the server explicitly 2184 * informs us the stateid is unrecognized. */ 2185 if (status != -NFS4ERR_BAD_STATEID) 2186 nfs41_free_stateid(server, stateid, cred); 2187 2188 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 2189 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 2190 clear_bit(NFS_O_RDWR_STATE, &state->flags); 2191 clear_bit(NFS_OPEN_STATE, &state->flags); 2192 } 2193 return status; 2194 } 2195 2196 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 2197 { 2198 int status; 2199 2200 nfs41_check_delegation_stateid(state); 2201 status = nfs41_check_open_stateid(state); 2202 if (status != NFS_OK) 2203 status = nfs4_open_expired(sp, state); 2204 return status; 2205 } 2206 #endif 2207 2208 /* 2209 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-* 2210 * fields corresponding to attributes that were used to store the verifier. 2211 * Make sure we clobber those fields in the later setattr call 2212 */ 2213 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr) 2214 { 2215 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) && 2216 !(sattr->ia_valid & ATTR_ATIME_SET)) 2217 sattr->ia_valid |= ATTR_ATIME; 2218 2219 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) && 2220 !(sattr->ia_valid & ATTR_MTIME_SET)) 2221 sattr->ia_valid |= ATTR_MTIME; 2222 } 2223 2224 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata, 2225 fmode_t fmode, 2226 int flags, 2227 struct nfs_open_context *ctx) 2228 { 2229 struct nfs4_state_owner *sp = opendata->owner; 2230 struct nfs_server *server = sp->so_server; 2231 struct dentry *dentry; 2232 struct nfs4_state *state; 2233 unsigned int seq; 2234 int ret; 2235 2236 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 2237 2238 ret = _nfs4_proc_open(opendata); 2239 if (ret != 0) 2240 goto out; 2241 2242 state = nfs4_opendata_to_nfs4_state(opendata); 2243 ret = PTR_ERR(state); 2244 if (IS_ERR(state)) 2245 goto out; 2246 if (server->caps & NFS_CAP_POSIX_LOCK) 2247 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); 2248 2249 dentry = opendata->dentry; 2250 if (dentry->d_inode == NULL) { 2251 /* FIXME: Is this d_drop() ever needed? */ 2252 d_drop(dentry); 2253 dentry = d_add_unique(dentry, igrab(state->inode)); 2254 if (dentry == NULL) { 2255 dentry = opendata->dentry; 2256 } else if (dentry != ctx->dentry) { 2257 dput(ctx->dentry); 2258 ctx->dentry = dget(dentry); 2259 } 2260 nfs_set_verifier(dentry, 2261 nfs_save_change_attribute(opendata->dir->d_inode)); 2262 } 2263 2264 ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags); 2265 if (ret != 0) 2266 goto out; 2267 2268 ctx->state = state; 2269 if (dentry->d_inode == state->inode) { 2270 nfs_inode_attach_open_context(ctx); 2271 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 2272 nfs4_schedule_stateid_recovery(server, state); 2273 } 2274 out: 2275 return ret; 2276 } 2277 2278 /* 2279 * Returns a referenced nfs4_state 2280 */ 2281 static int _nfs4_do_open(struct inode *dir, 2282 struct nfs_open_context *ctx, 2283 int flags, 2284 struct iattr *sattr, 2285 struct nfs4_label *label, 2286 int *opened) 2287 { 2288 struct nfs4_state_owner *sp; 2289 struct nfs4_state *state = NULL; 2290 struct nfs_server *server = NFS_SERVER(dir); 2291 struct nfs4_opendata *opendata; 2292 struct dentry *dentry = ctx->dentry; 2293 struct rpc_cred *cred = ctx->cred; 2294 struct nfs4_threshold **ctx_th = &ctx->mdsthreshold; 2295 fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC); 2296 enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL; 2297 struct nfs4_label *olabel = NULL; 2298 int status; 2299 2300 /* Protect against reboot recovery conflicts */ 2301 status = -ENOMEM; 2302 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL); 2303 if (sp == NULL) { 2304 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n"); 2305 goto out_err; 2306 } 2307 status = nfs4_recover_expired_lease(server); 2308 if (status != 0) 2309 goto err_put_state_owner; 2310 if (dentry->d_inode != NULL) 2311 nfs4_return_incompatible_delegation(dentry->d_inode, fmode); 2312 status = -ENOMEM; 2313 if (dentry->d_inode) 2314 claim = NFS4_OPEN_CLAIM_FH; 2315 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, 2316 label, claim, GFP_KERNEL); 2317 if (opendata == NULL) 2318 goto err_put_state_owner; 2319 2320 if (label) { 2321 olabel = nfs4_label_alloc(server, GFP_KERNEL); 2322 if (IS_ERR(olabel)) { 2323 status = PTR_ERR(olabel); 2324 goto err_opendata_put; 2325 } 2326 } 2327 2328 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) { 2329 if (!opendata->f_attr.mdsthreshold) { 2330 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc(); 2331 if (!opendata->f_attr.mdsthreshold) 2332 goto err_free_label; 2333 } 2334 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0]; 2335 } 2336 if (dentry->d_inode != NULL) 2337 opendata->state = nfs4_get_open_state(dentry->d_inode, sp); 2338 2339 status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx); 2340 if (status != 0) 2341 goto err_free_label; 2342 state = ctx->state; 2343 2344 if ((opendata->o_arg.open_flags & O_EXCL) && 2345 (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) { 2346 nfs4_exclusive_attrset(opendata, sattr); 2347 2348 nfs_fattr_init(opendata->o_res.f_attr); 2349 status = nfs4_do_setattr(state->inode, cred, 2350 opendata->o_res.f_attr, sattr, 2351 state, label, olabel); 2352 if (status == 0) { 2353 nfs_setattr_update_inode(state->inode, sattr); 2354 nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr); 2355 nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel); 2356 } 2357 } 2358 if (opendata->file_created) 2359 *opened |= FILE_CREATED; 2360 2361 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) { 2362 *ctx_th = opendata->f_attr.mdsthreshold; 2363 opendata->f_attr.mdsthreshold = NULL; 2364 } 2365 2366 nfs4_label_free(olabel); 2367 2368 nfs4_opendata_put(opendata); 2369 nfs4_put_state_owner(sp); 2370 return 0; 2371 err_free_label: 2372 nfs4_label_free(olabel); 2373 err_opendata_put: 2374 nfs4_opendata_put(opendata); 2375 err_put_state_owner: 2376 nfs4_put_state_owner(sp); 2377 out_err: 2378 return status; 2379 } 2380 2381 2382 static struct nfs4_state *nfs4_do_open(struct inode *dir, 2383 struct nfs_open_context *ctx, 2384 int flags, 2385 struct iattr *sattr, 2386 struct nfs4_label *label, 2387 int *opened) 2388 { 2389 struct nfs_server *server = NFS_SERVER(dir); 2390 struct nfs4_exception exception = { }; 2391 struct nfs4_state *res; 2392 int status; 2393 2394 do { 2395 status = _nfs4_do_open(dir, ctx, flags, sattr, label, opened); 2396 res = ctx->state; 2397 trace_nfs4_open_file(ctx, flags, status); 2398 if (status == 0) 2399 break; 2400 /* NOTE: BAD_SEQID means the server and client disagree about the 2401 * book-keeping w.r.t. state-changing operations 2402 * (OPEN/CLOSE/LOCK/LOCKU...) 2403 * It is actually a sign of a bug on the client or on the server. 2404 * 2405 * If we receive a BAD_SEQID error in the particular case of 2406 * doing an OPEN, we assume that nfs_increment_open_seqid() will 2407 * have unhashed the old state_owner for us, and that we can 2408 * therefore safely retry using a new one. We should still warn 2409 * the user though... 2410 */ 2411 if (status == -NFS4ERR_BAD_SEQID) { 2412 pr_warn_ratelimited("NFS: v4 server %s " 2413 " returned a bad sequence-id error!\n", 2414 NFS_SERVER(dir)->nfs_client->cl_hostname); 2415 exception.retry = 1; 2416 continue; 2417 } 2418 /* 2419 * BAD_STATEID on OPEN means that the server cancelled our 2420 * state before it received the OPEN_CONFIRM. 2421 * Recover by retrying the request as per the discussion 2422 * on Page 181 of RFC3530. 2423 */ 2424 if (status == -NFS4ERR_BAD_STATEID) { 2425 exception.retry = 1; 2426 continue; 2427 } 2428 if (status == -EAGAIN) { 2429 /* We must have found a delegation */ 2430 exception.retry = 1; 2431 continue; 2432 } 2433 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception)) 2434 continue; 2435 res = ERR_PTR(nfs4_handle_exception(server, 2436 status, &exception)); 2437 } while (exception.retry); 2438 return res; 2439 } 2440 2441 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 2442 struct nfs_fattr *fattr, struct iattr *sattr, 2443 struct nfs4_state *state, struct nfs4_label *ilabel, 2444 struct nfs4_label *olabel) 2445 { 2446 struct nfs_server *server = NFS_SERVER(inode); 2447 struct nfs_setattrargs arg = { 2448 .fh = NFS_FH(inode), 2449 .iap = sattr, 2450 .server = server, 2451 .bitmask = server->attr_bitmask, 2452 .label = ilabel, 2453 }; 2454 struct nfs_setattrres res = { 2455 .fattr = fattr, 2456 .label = olabel, 2457 .server = server, 2458 }; 2459 struct rpc_message msg = { 2460 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 2461 .rpc_argp = &arg, 2462 .rpc_resp = &res, 2463 .rpc_cred = cred, 2464 }; 2465 unsigned long timestamp = jiffies; 2466 fmode_t fmode; 2467 bool truncate; 2468 int status; 2469 2470 arg.bitmask = nfs4_bitmask(server, ilabel); 2471 if (ilabel) 2472 arg.bitmask = nfs4_bitmask(server, olabel); 2473 2474 nfs_fattr_init(fattr); 2475 2476 /* Servers should only apply open mode checks for file size changes */ 2477 truncate = (sattr->ia_valid & ATTR_SIZE) ? true : false; 2478 fmode = truncate ? FMODE_WRITE : FMODE_READ; 2479 2480 if (nfs4_copy_delegation_stateid(&arg.stateid, inode, fmode)) { 2481 /* Use that stateid */ 2482 } else if (truncate && state != NULL) { 2483 struct nfs_lockowner lockowner = { 2484 .l_owner = current->files, 2485 .l_pid = current->tgid, 2486 }; 2487 if (!nfs4_valid_open_stateid(state)) 2488 return -EBADF; 2489 if (nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE, 2490 &lockowner) == -EIO) 2491 return -EBADF; 2492 } else 2493 nfs4_stateid_copy(&arg.stateid, &zero_stateid); 2494 2495 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 2496 if (status == 0 && state != NULL) 2497 renew_lease(server, timestamp); 2498 return status; 2499 } 2500 2501 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 2502 struct nfs_fattr *fattr, struct iattr *sattr, 2503 struct nfs4_state *state, struct nfs4_label *ilabel, 2504 struct nfs4_label *olabel) 2505 { 2506 struct nfs_server *server = NFS_SERVER(inode); 2507 struct nfs4_exception exception = { 2508 .state = state, 2509 .inode = inode, 2510 }; 2511 int err; 2512 do { 2513 err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel); 2514 trace_nfs4_setattr(inode, err); 2515 switch (err) { 2516 case -NFS4ERR_OPENMODE: 2517 if (!(sattr->ia_valid & ATTR_SIZE)) { 2518 pr_warn_once("NFSv4: server %s is incorrectly " 2519 "applying open mode checks to " 2520 "a SETATTR that is not " 2521 "changing file size.\n", 2522 server->nfs_client->cl_hostname); 2523 } 2524 if (state && !(state->state & FMODE_WRITE)) { 2525 err = -EBADF; 2526 if (sattr->ia_valid & ATTR_OPEN) 2527 err = -EACCES; 2528 goto out; 2529 } 2530 } 2531 err = nfs4_handle_exception(server, err, &exception); 2532 } while (exception.retry); 2533 out: 2534 return err; 2535 } 2536 2537 struct nfs4_closedata { 2538 struct inode *inode; 2539 struct nfs4_state *state; 2540 struct nfs_closeargs arg; 2541 struct nfs_closeres res; 2542 struct nfs_fattr fattr; 2543 unsigned long timestamp; 2544 bool roc; 2545 u32 roc_barrier; 2546 }; 2547 2548 static void nfs4_free_closedata(void *data) 2549 { 2550 struct nfs4_closedata *calldata = data; 2551 struct nfs4_state_owner *sp = calldata->state->owner; 2552 struct super_block *sb = calldata->state->inode->i_sb; 2553 2554 if (calldata->roc) 2555 pnfs_roc_release(calldata->state->inode); 2556 nfs4_put_open_state(calldata->state); 2557 nfs_free_seqid(calldata->arg.seqid); 2558 nfs4_put_state_owner(sp); 2559 nfs_sb_deactive(sb); 2560 kfree(calldata); 2561 } 2562 2563 static void nfs4_close_done(struct rpc_task *task, void *data) 2564 { 2565 struct nfs4_closedata *calldata = data; 2566 struct nfs4_state *state = calldata->state; 2567 struct nfs_server *server = NFS_SERVER(calldata->inode); 2568 nfs4_stateid *res_stateid = NULL; 2569 2570 dprintk("%s: begin!\n", __func__); 2571 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 2572 return; 2573 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status); 2574 /* hmm. we are done with the inode, and in the process of freeing 2575 * the state_owner. we keep this around to process errors 2576 */ 2577 switch (task->tk_status) { 2578 case 0: 2579 res_stateid = &calldata->res.stateid; 2580 if (calldata->arg.fmode == 0 && calldata->roc) 2581 pnfs_roc_set_barrier(state->inode, 2582 calldata->roc_barrier); 2583 renew_lease(server, calldata->timestamp); 2584 break; 2585 case -NFS4ERR_ADMIN_REVOKED: 2586 case -NFS4ERR_STALE_STATEID: 2587 case -NFS4ERR_OLD_STATEID: 2588 case -NFS4ERR_BAD_STATEID: 2589 case -NFS4ERR_EXPIRED: 2590 if (calldata->arg.fmode == 0) 2591 break; 2592 default: 2593 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) { 2594 rpc_restart_call_prepare(task); 2595 goto out_release; 2596 } 2597 } 2598 nfs_clear_open_stateid(state, res_stateid, calldata->arg.fmode); 2599 out_release: 2600 nfs_release_seqid(calldata->arg.seqid); 2601 nfs_refresh_inode(calldata->inode, calldata->res.fattr); 2602 dprintk("%s: done, ret = %d!\n", __func__, task->tk_status); 2603 } 2604 2605 static void nfs4_close_prepare(struct rpc_task *task, void *data) 2606 { 2607 struct nfs4_closedata *calldata = data; 2608 struct nfs4_state *state = calldata->state; 2609 struct inode *inode = calldata->inode; 2610 bool is_rdonly, is_wronly, is_rdwr; 2611 int call_close = 0; 2612 2613 dprintk("%s: begin!\n", __func__); 2614 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 2615 goto out_wait; 2616 2617 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 2618 spin_lock(&state->owner->so_lock); 2619 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags); 2620 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags); 2621 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags); 2622 /* Calculate the change in open mode */ 2623 calldata->arg.fmode = 0; 2624 if (state->n_rdwr == 0) { 2625 if (state->n_rdonly == 0) 2626 call_close |= is_rdonly; 2627 else if (is_rdonly) 2628 calldata->arg.fmode |= FMODE_READ; 2629 if (state->n_wronly == 0) 2630 call_close |= is_wronly; 2631 else if (is_wronly) 2632 calldata->arg.fmode |= FMODE_WRITE; 2633 } else if (is_rdwr) 2634 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE; 2635 2636 if (calldata->arg.fmode == 0) 2637 call_close |= is_rdwr; 2638 2639 if (!nfs4_valid_open_stateid(state)) 2640 call_close = 0; 2641 spin_unlock(&state->owner->so_lock); 2642 2643 if (!call_close) { 2644 /* Note: exit _without_ calling nfs4_close_done */ 2645 goto out_no_action; 2646 } 2647 2648 if (calldata->arg.fmode == 0) { 2649 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; 2650 if (calldata->roc && 2651 pnfs_roc_drain(inode, &calldata->roc_barrier, task)) { 2652 nfs_release_seqid(calldata->arg.seqid); 2653 goto out_wait; 2654 } 2655 } 2656 2657 nfs_fattr_init(calldata->res.fattr); 2658 calldata->timestamp = jiffies; 2659 if (nfs4_setup_sequence(NFS_SERVER(inode), 2660 &calldata->arg.seq_args, 2661 &calldata->res.seq_res, 2662 task) != 0) 2663 nfs_release_seqid(calldata->arg.seqid); 2664 dprintk("%s: done!\n", __func__); 2665 return; 2666 out_no_action: 2667 task->tk_action = NULL; 2668 out_wait: 2669 nfs4_sequence_done(task, &calldata->res.seq_res); 2670 } 2671 2672 static const struct rpc_call_ops nfs4_close_ops = { 2673 .rpc_call_prepare = nfs4_close_prepare, 2674 .rpc_call_done = nfs4_close_done, 2675 .rpc_release = nfs4_free_closedata, 2676 }; 2677 2678 static bool nfs4_state_has_opener(struct nfs4_state *state) 2679 { 2680 /* first check existing openers */ 2681 if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 && 2682 state->n_rdonly != 0) 2683 return true; 2684 2685 if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 && 2686 state->n_wronly != 0) 2687 return true; 2688 2689 if (test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 && 2690 state->n_rdwr != 0) 2691 return true; 2692 2693 return false; 2694 } 2695 2696 static bool nfs4_roc(struct inode *inode) 2697 { 2698 struct nfs_inode *nfsi = NFS_I(inode); 2699 struct nfs_open_context *ctx; 2700 struct nfs4_state *state; 2701 2702 spin_lock(&inode->i_lock); 2703 list_for_each_entry(ctx, &nfsi->open_files, list) { 2704 state = ctx->state; 2705 if (state == NULL) 2706 continue; 2707 if (nfs4_state_has_opener(state)) { 2708 spin_unlock(&inode->i_lock); 2709 return false; 2710 } 2711 } 2712 spin_unlock(&inode->i_lock); 2713 2714 if (nfs4_check_delegation(inode, FMODE_READ)) 2715 return false; 2716 2717 return pnfs_roc(inode); 2718 } 2719 2720 /* 2721 * It is possible for data to be read/written from a mem-mapped file 2722 * after the sys_close call (which hits the vfs layer as a flush). 2723 * This means that we can't safely call nfsv4 close on a file until 2724 * the inode is cleared. This in turn means that we are not good 2725 * NFSv4 citizens - we do not indicate to the server to update the file's 2726 * share state even when we are done with one of the three share 2727 * stateid's in the inode. 2728 * 2729 * NOTE: Caller must be holding the sp->so_owner semaphore! 2730 */ 2731 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait) 2732 { 2733 struct nfs_server *server = NFS_SERVER(state->inode); 2734 struct nfs4_closedata *calldata; 2735 struct nfs4_state_owner *sp = state->owner; 2736 struct rpc_task *task; 2737 struct rpc_message msg = { 2738 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE], 2739 .rpc_cred = state->owner->so_cred, 2740 }; 2741 struct rpc_task_setup task_setup_data = { 2742 .rpc_client = server->client, 2743 .rpc_message = &msg, 2744 .callback_ops = &nfs4_close_ops, 2745 .workqueue = nfsiod_workqueue, 2746 .flags = RPC_TASK_ASYNC, 2747 }; 2748 int status = -ENOMEM; 2749 2750 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP, 2751 &task_setup_data.rpc_client, &msg); 2752 2753 calldata = kzalloc(sizeof(*calldata), gfp_mask); 2754 if (calldata == NULL) 2755 goto out; 2756 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1); 2757 calldata->inode = state->inode; 2758 calldata->state = state; 2759 calldata->arg.fh = NFS_FH(state->inode); 2760 calldata->arg.stateid = &state->open_stateid; 2761 /* Serialization for the sequence id */ 2762 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask); 2763 if (calldata->arg.seqid == NULL) 2764 goto out_free_calldata; 2765 calldata->arg.fmode = 0; 2766 calldata->arg.bitmask = server->cache_consistency_bitmask; 2767 calldata->res.fattr = &calldata->fattr; 2768 calldata->res.seqid = calldata->arg.seqid; 2769 calldata->res.server = server; 2770 calldata->roc = nfs4_roc(state->inode); 2771 nfs_sb_active(calldata->inode->i_sb); 2772 2773 msg.rpc_argp = &calldata->arg; 2774 msg.rpc_resp = &calldata->res; 2775 task_setup_data.callback_data = calldata; 2776 task = rpc_run_task(&task_setup_data); 2777 if (IS_ERR(task)) 2778 return PTR_ERR(task); 2779 status = 0; 2780 if (wait) 2781 status = rpc_wait_for_completion_task(task); 2782 rpc_put_task(task); 2783 return status; 2784 out_free_calldata: 2785 kfree(calldata); 2786 out: 2787 nfs4_put_open_state(state); 2788 nfs4_put_state_owner(sp); 2789 return status; 2790 } 2791 2792 static struct inode * 2793 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, 2794 int open_flags, struct iattr *attr, int *opened) 2795 { 2796 struct nfs4_state *state; 2797 struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL; 2798 2799 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l); 2800 2801 /* Protect against concurrent sillydeletes */ 2802 state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened); 2803 2804 nfs4_label_release_security(label); 2805 2806 if (IS_ERR(state)) 2807 return ERR_CAST(state); 2808 return state->inode; 2809 } 2810 2811 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync) 2812 { 2813 if (ctx->state == NULL) 2814 return; 2815 if (is_sync) 2816 nfs4_close_sync(ctx->state, ctx->mode); 2817 else 2818 nfs4_close_state(ctx->state, ctx->mode); 2819 } 2820 2821 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL) 2822 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL) 2823 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_SECURITY_LABEL - 1UL) 2824 2825 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2826 { 2827 struct nfs4_server_caps_arg args = { 2828 .fhandle = fhandle, 2829 }; 2830 struct nfs4_server_caps_res res = {}; 2831 struct rpc_message msg = { 2832 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS], 2833 .rpc_argp = &args, 2834 .rpc_resp = &res, 2835 }; 2836 int status; 2837 2838 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2839 if (status == 0) { 2840 /* Sanity check the server answers */ 2841 switch (server->nfs_client->cl_minorversion) { 2842 case 0: 2843 res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK; 2844 res.attr_bitmask[2] = 0; 2845 break; 2846 case 1: 2847 res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK; 2848 break; 2849 case 2: 2850 res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK; 2851 } 2852 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); 2853 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS| 2854 NFS_CAP_SYMLINKS|NFS_CAP_FILEID| 2855 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER| 2856 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME| 2857 NFS_CAP_CTIME|NFS_CAP_MTIME| 2858 NFS_CAP_SECURITY_LABEL); 2859 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL && 2860 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL) 2861 server->caps |= NFS_CAP_ACLS; 2862 if (res.has_links != 0) 2863 server->caps |= NFS_CAP_HARDLINKS; 2864 if (res.has_symlinks != 0) 2865 server->caps |= NFS_CAP_SYMLINKS; 2866 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID) 2867 server->caps |= NFS_CAP_FILEID; 2868 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE) 2869 server->caps |= NFS_CAP_MODE; 2870 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS) 2871 server->caps |= NFS_CAP_NLINK; 2872 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER) 2873 server->caps |= NFS_CAP_OWNER; 2874 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP) 2875 server->caps |= NFS_CAP_OWNER_GROUP; 2876 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS) 2877 server->caps |= NFS_CAP_ATIME; 2878 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA) 2879 server->caps |= NFS_CAP_CTIME; 2880 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY) 2881 server->caps |= NFS_CAP_MTIME; 2882 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 2883 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL) 2884 server->caps |= NFS_CAP_SECURITY_LABEL; 2885 #endif 2886 memcpy(server->attr_bitmask_nl, res.attr_bitmask, 2887 sizeof(server->attr_bitmask)); 2888 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL; 2889 2890 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); 2891 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; 2892 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; 2893 server->cache_consistency_bitmask[2] = 0; 2894 server->acl_bitmask = res.acl_bitmask; 2895 server->fh_expire_type = res.fh_expire_type; 2896 } 2897 2898 return status; 2899 } 2900 2901 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2902 { 2903 struct nfs4_exception exception = { }; 2904 int err; 2905 do { 2906 err = nfs4_handle_exception(server, 2907 _nfs4_server_capabilities(server, fhandle), 2908 &exception); 2909 } while (exception.retry); 2910 return err; 2911 } 2912 2913 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2914 struct nfs_fsinfo *info) 2915 { 2916 u32 bitmask[3]; 2917 struct nfs4_lookup_root_arg args = { 2918 .bitmask = bitmask, 2919 }; 2920 struct nfs4_lookup_res res = { 2921 .server = server, 2922 .fattr = info->fattr, 2923 .fh = fhandle, 2924 }; 2925 struct rpc_message msg = { 2926 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT], 2927 .rpc_argp = &args, 2928 .rpc_resp = &res, 2929 }; 2930 2931 bitmask[0] = nfs4_fattr_bitmap[0]; 2932 bitmask[1] = nfs4_fattr_bitmap[1]; 2933 /* 2934 * Process the label in the upcoming getfattr 2935 */ 2936 bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL; 2937 2938 nfs_fattr_init(info->fattr); 2939 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2940 } 2941 2942 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2943 struct nfs_fsinfo *info) 2944 { 2945 struct nfs4_exception exception = { }; 2946 int err; 2947 do { 2948 err = _nfs4_lookup_root(server, fhandle, info); 2949 trace_nfs4_lookup_root(server, fhandle, info->fattr, err); 2950 switch (err) { 2951 case 0: 2952 case -NFS4ERR_WRONGSEC: 2953 goto out; 2954 default: 2955 err = nfs4_handle_exception(server, err, &exception); 2956 } 2957 } while (exception.retry); 2958 out: 2959 return err; 2960 } 2961 2962 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 2963 struct nfs_fsinfo *info, rpc_authflavor_t flavor) 2964 { 2965 struct rpc_auth_create_args auth_args = { 2966 .pseudoflavor = flavor, 2967 }; 2968 struct rpc_auth *auth; 2969 int ret; 2970 2971 auth = rpcauth_create(&auth_args, server->client); 2972 if (IS_ERR(auth)) { 2973 ret = -EACCES; 2974 goto out; 2975 } 2976 ret = nfs4_lookup_root(server, fhandle, info); 2977 out: 2978 return ret; 2979 } 2980 2981 /* 2982 * Retry pseudoroot lookup with various security flavors. We do this when: 2983 * 2984 * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC 2985 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation 2986 * 2987 * Returns zero on success, or a negative NFS4ERR value, or a 2988 * negative errno value. 2989 */ 2990 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 2991 struct nfs_fsinfo *info) 2992 { 2993 /* Per 3530bis 15.33.5 */ 2994 static const rpc_authflavor_t flav_array[] = { 2995 RPC_AUTH_GSS_KRB5P, 2996 RPC_AUTH_GSS_KRB5I, 2997 RPC_AUTH_GSS_KRB5, 2998 RPC_AUTH_UNIX, /* courtesy */ 2999 RPC_AUTH_NULL, 3000 }; 3001 int status = -EPERM; 3002 size_t i; 3003 3004 if (server->auth_info.flavor_len > 0) { 3005 /* try each flavor specified by user */ 3006 for (i = 0; i < server->auth_info.flavor_len; i++) { 3007 status = nfs4_lookup_root_sec(server, fhandle, info, 3008 server->auth_info.flavors[i]); 3009 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) 3010 continue; 3011 break; 3012 } 3013 } else { 3014 /* no flavors specified by user, try default list */ 3015 for (i = 0; i < ARRAY_SIZE(flav_array); i++) { 3016 status = nfs4_lookup_root_sec(server, fhandle, info, 3017 flav_array[i]); 3018 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) 3019 continue; 3020 break; 3021 } 3022 } 3023 3024 /* 3025 * -EACCESS could mean that the user doesn't have correct permissions 3026 * to access the mount. It could also mean that we tried to mount 3027 * with a gss auth flavor, but rpc.gssd isn't running. Either way, 3028 * existing mount programs don't handle -EACCES very well so it should 3029 * be mapped to -EPERM instead. 3030 */ 3031 if (status == -EACCES) 3032 status = -EPERM; 3033 return status; 3034 } 3035 3036 static int nfs4_do_find_root_sec(struct nfs_server *server, 3037 struct nfs_fh *fhandle, struct nfs_fsinfo *info) 3038 { 3039 int mv = server->nfs_client->cl_minorversion; 3040 return nfs_v4_minor_ops[mv]->find_root_sec(server, fhandle, info); 3041 } 3042 3043 /** 3044 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot 3045 * @server: initialized nfs_server handle 3046 * @fhandle: we fill in the pseudo-fs root file handle 3047 * @info: we fill in an FSINFO struct 3048 * @auth_probe: probe the auth flavours 3049 * 3050 * Returns zero on success, or a negative errno. 3051 */ 3052 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle, 3053 struct nfs_fsinfo *info, 3054 bool auth_probe) 3055 { 3056 int status; 3057 3058 switch (auth_probe) { 3059 case false: 3060 status = nfs4_lookup_root(server, fhandle, info); 3061 if (status != -NFS4ERR_WRONGSEC) 3062 break; 3063 default: 3064 status = nfs4_do_find_root_sec(server, fhandle, info); 3065 } 3066 3067 if (status == 0) 3068 status = nfs4_server_capabilities(server, fhandle); 3069 if (status == 0) 3070 status = nfs4_do_fsinfo(server, fhandle, info); 3071 3072 return nfs4_map_errors(status); 3073 } 3074 3075 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh, 3076 struct nfs_fsinfo *info) 3077 { 3078 int error; 3079 struct nfs_fattr *fattr = info->fattr; 3080 struct nfs4_label *label = NULL; 3081 3082 error = nfs4_server_capabilities(server, mntfh); 3083 if (error < 0) { 3084 dprintk("nfs4_get_root: getcaps error = %d\n", -error); 3085 return error; 3086 } 3087 3088 label = nfs4_label_alloc(server, GFP_KERNEL); 3089 if (IS_ERR(label)) 3090 return PTR_ERR(label); 3091 3092 error = nfs4_proc_getattr(server, mntfh, fattr, label); 3093 if (error < 0) { 3094 dprintk("nfs4_get_root: getattr error = %d\n", -error); 3095 goto err_free_label; 3096 } 3097 3098 if (fattr->valid & NFS_ATTR_FATTR_FSID && 3099 !nfs_fsid_equal(&server->fsid, &fattr->fsid)) 3100 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid)); 3101 3102 err_free_label: 3103 nfs4_label_free(label); 3104 3105 return error; 3106 } 3107 3108 /* 3109 * Get locations and (maybe) other attributes of a referral. 3110 * Note that we'll actually follow the referral later when 3111 * we detect fsid mismatch in inode revalidation 3112 */ 3113 static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir, 3114 const struct qstr *name, struct nfs_fattr *fattr, 3115 struct nfs_fh *fhandle) 3116 { 3117 int status = -ENOMEM; 3118 struct page *page = NULL; 3119 struct nfs4_fs_locations *locations = NULL; 3120 3121 page = alloc_page(GFP_KERNEL); 3122 if (page == NULL) 3123 goto out; 3124 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 3125 if (locations == NULL) 3126 goto out; 3127 3128 status = nfs4_proc_fs_locations(client, dir, name, locations, page); 3129 if (status != 0) 3130 goto out; 3131 3132 /* 3133 * If the fsid didn't change, this is a migration event, not a 3134 * referral. Cause us to drop into the exception handler, which 3135 * will kick off migration recovery. 3136 */ 3137 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 3138 dprintk("%s: server did not return a different fsid for" 3139 " a referral at %s\n", __func__, name->name); 3140 status = -NFS4ERR_MOVED; 3141 goto out; 3142 } 3143 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */ 3144 nfs_fixup_referral_attributes(&locations->fattr); 3145 3146 /* replace the lookup nfs_fattr with the locations nfs_fattr */ 3147 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr)); 3148 memset(fhandle, 0, sizeof(struct nfs_fh)); 3149 out: 3150 if (page) 3151 __free_page(page); 3152 kfree(locations); 3153 return status; 3154 } 3155 3156 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, 3157 struct nfs_fattr *fattr, struct nfs4_label *label) 3158 { 3159 struct nfs4_getattr_arg args = { 3160 .fh = fhandle, 3161 .bitmask = server->attr_bitmask, 3162 }; 3163 struct nfs4_getattr_res res = { 3164 .fattr = fattr, 3165 .label = label, 3166 .server = server, 3167 }; 3168 struct rpc_message msg = { 3169 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 3170 .rpc_argp = &args, 3171 .rpc_resp = &res, 3172 }; 3173 3174 args.bitmask = nfs4_bitmask(server, label); 3175 3176 nfs_fattr_init(fattr); 3177 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3178 } 3179 3180 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, 3181 struct nfs_fattr *fattr, struct nfs4_label *label) 3182 { 3183 struct nfs4_exception exception = { }; 3184 int err; 3185 do { 3186 err = _nfs4_proc_getattr(server, fhandle, fattr, label); 3187 trace_nfs4_getattr(server, fhandle, fattr, err); 3188 err = nfs4_handle_exception(server, err, 3189 &exception); 3190 } while (exception.retry); 3191 return err; 3192 } 3193 3194 /* 3195 * The file is not closed if it is opened due to the a request to change 3196 * the size of the file. The open call will not be needed once the 3197 * VFS layer lookup-intents are implemented. 3198 * 3199 * Close is called when the inode is destroyed. 3200 * If we haven't opened the file for O_WRONLY, we 3201 * need to in the size_change case to obtain a stateid. 3202 * 3203 * Got race? 3204 * Because OPEN is always done by name in nfsv4, it is 3205 * possible that we opened a different file by the same 3206 * name. We can recognize this race condition, but we 3207 * can't do anything about it besides returning an error. 3208 * 3209 * This will be fixed with VFS changes (lookup-intent). 3210 */ 3211 static int 3212 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 3213 struct iattr *sattr) 3214 { 3215 struct inode *inode = dentry->d_inode; 3216 struct rpc_cred *cred = NULL; 3217 struct nfs4_state *state = NULL; 3218 struct nfs4_label *label = NULL; 3219 int status; 3220 3221 if (pnfs_ld_layoutret_on_setattr(inode) && 3222 sattr->ia_valid & ATTR_SIZE && 3223 sattr->ia_size < i_size_read(inode)) 3224 pnfs_commit_and_return_layout(inode); 3225 3226 nfs_fattr_init(fattr); 3227 3228 /* Deal with open(O_TRUNC) */ 3229 if (sattr->ia_valid & ATTR_OPEN) 3230 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME); 3231 3232 /* Optimization: if the end result is no change, don't RPC */ 3233 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0) 3234 return 0; 3235 3236 /* Search for an existing open(O_WRITE) file */ 3237 if (sattr->ia_valid & ATTR_FILE) { 3238 struct nfs_open_context *ctx; 3239 3240 ctx = nfs_file_open_context(sattr->ia_file); 3241 if (ctx) { 3242 cred = ctx->cred; 3243 state = ctx->state; 3244 } 3245 } 3246 3247 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); 3248 if (IS_ERR(label)) 3249 return PTR_ERR(label); 3250 3251 status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label); 3252 if (status == 0) { 3253 nfs_setattr_update_inode(inode, sattr); 3254 nfs_setsecurity(inode, fattr, label); 3255 } 3256 nfs4_label_free(label); 3257 return status; 3258 } 3259 3260 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, 3261 const struct qstr *name, struct nfs_fh *fhandle, 3262 struct nfs_fattr *fattr, struct nfs4_label *label) 3263 { 3264 struct nfs_server *server = NFS_SERVER(dir); 3265 int status; 3266 struct nfs4_lookup_arg args = { 3267 .bitmask = server->attr_bitmask, 3268 .dir_fh = NFS_FH(dir), 3269 .name = name, 3270 }; 3271 struct nfs4_lookup_res res = { 3272 .server = server, 3273 .fattr = fattr, 3274 .label = label, 3275 .fh = fhandle, 3276 }; 3277 struct rpc_message msg = { 3278 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 3279 .rpc_argp = &args, 3280 .rpc_resp = &res, 3281 }; 3282 3283 args.bitmask = nfs4_bitmask(server, label); 3284 3285 nfs_fattr_init(fattr); 3286 3287 dprintk("NFS call lookup %s\n", name->name); 3288 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0); 3289 dprintk("NFS reply lookup: %d\n", status); 3290 return status; 3291 } 3292 3293 static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr) 3294 { 3295 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 3296 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT; 3297 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 3298 fattr->nlink = 2; 3299 } 3300 3301 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir, 3302 struct qstr *name, struct nfs_fh *fhandle, 3303 struct nfs_fattr *fattr, struct nfs4_label *label) 3304 { 3305 struct nfs4_exception exception = { }; 3306 struct rpc_clnt *client = *clnt; 3307 int err; 3308 do { 3309 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label); 3310 trace_nfs4_lookup(dir, name, err); 3311 switch (err) { 3312 case -NFS4ERR_BADNAME: 3313 err = -ENOENT; 3314 goto out; 3315 case -NFS4ERR_MOVED: 3316 err = nfs4_get_referral(client, dir, name, fattr, fhandle); 3317 goto out; 3318 case -NFS4ERR_WRONGSEC: 3319 err = -EPERM; 3320 if (client != *clnt) 3321 goto out; 3322 client = nfs4_negotiate_security(client, dir, name); 3323 if (IS_ERR(client)) 3324 return PTR_ERR(client); 3325 3326 exception.retry = 1; 3327 break; 3328 default: 3329 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception); 3330 } 3331 } while (exception.retry); 3332 3333 out: 3334 if (err == 0) 3335 *clnt = client; 3336 else if (client != *clnt) 3337 rpc_shutdown_client(client); 3338 3339 return err; 3340 } 3341 3342 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, 3343 struct nfs_fh *fhandle, struct nfs_fattr *fattr, 3344 struct nfs4_label *label) 3345 { 3346 int status; 3347 struct rpc_clnt *client = NFS_CLIENT(dir); 3348 3349 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label); 3350 if (client != NFS_CLIENT(dir)) { 3351 rpc_shutdown_client(client); 3352 nfs_fixup_secinfo_attributes(fattr); 3353 } 3354 return status; 3355 } 3356 3357 struct rpc_clnt * 3358 nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name, 3359 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 3360 { 3361 struct rpc_clnt *client = NFS_CLIENT(dir); 3362 int status; 3363 3364 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL); 3365 if (status < 0) 3366 return ERR_PTR(status); 3367 return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client; 3368 } 3369 3370 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 3371 { 3372 struct nfs_server *server = NFS_SERVER(inode); 3373 struct nfs4_accessargs args = { 3374 .fh = NFS_FH(inode), 3375 .bitmask = server->cache_consistency_bitmask, 3376 }; 3377 struct nfs4_accessres res = { 3378 .server = server, 3379 }; 3380 struct rpc_message msg = { 3381 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], 3382 .rpc_argp = &args, 3383 .rpc_resp = &res, 3384 .rpc_cred = entry->cred, 3385 }; 3386 int mode = entry->mask; 3387 int status = 0; 3388 3389 /* 3390 * Determine which access bits we want to ask for... 3391 */ 3392 if (mode & MAY_READ) 3393 args.access |= NFS4_ACCESS_READ; 3394 if (S_ISDIR(inode->i_mode)) { 3395 if (mode & MAY_WRITE) 3396 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE; 3397 if (mode & MAY_EXEC) 3398 args.access |= NFS4_ACCESS_LOOKUP; 3399 } else { 3400 if (mode & MAY_WRITE) 3401 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND; 3402 if (mode & MAY_EXEC) 3403 args.access |= NFS4_ACCESS_EXECUTE; 3404 } 3405 3406 res.fattr = nfs_alloc_fattr(); 3407 if (res.fattr == NULL) 3408 return -ENOMEM; 3409 3410 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3411 if (!status) { 3412 nfs_access_set_mask(entry, res.access); 3413 nfs_refresh_inode(inode, res.fattr); 3414 } 3415 nfs_free_fattr(res.fattr); 3416 return status; 3417 } 3418 3419 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 3420 { 3421 struct nfs4_exception exception = { }; 3422 int err; 3423 do { 3424 err = _nfs4_proc_access(inode, entry); 3425 trace_nfs4_access(inode, err); 3426 err = nfs4_handle_exception(NFS_SERVER(inode), err, 3427 &exception); 3428 } while (exception.retry); 3429 return err; 3430 } 3431 3432 /* 3433 * TODO: For the time being, we don't try to get any attributes 3434 * along with any of the zero-copy operations READ, READDIR, 3435 * READLINK, WRITE. 3436 * 3437 * In the case of the first three, we want to put the GETATTR 3438 * after the read-type operation -- this is because it is hard 3439 * to predict the length of a GETATTR response in v4, and thus 3440 * align the READ data correctly. This means that the GETATTR 3441 * may end up partially falling into the page cache, and we should 3442 * shift it into the 'tail' of the xdr_buf before processing. 3443 * To do this efficiently, we need to know the total length 3444 * of data received, which doesn't seem to be available outside 3445 * of the RPC layer. 3446 * 3447 * In the case of WRITE, we also want to put the GETATTR after 3448 * the operation -- in this case because we want to make sure 3449 * we get the post-operation mtime and size. 3450 * 3451 * Both of these changes to the XDR layer would in fact be quite 3452 * minor, but I decided to leave them for a subsequent patch. 3453 */ 3454 static int _nfs4_proc_readlink(struct inode *inode, struct page *page, 3455 unsigned int pgbase, unsigned int pglen) 3456 { 3457 struct nfs4_readlink args = { 3458 .fh = NFS_FH(inode), 3459 .pgbase = pgbase, 3460 .pglen = pglen, 3461 .pages = &page, 3462 }; 3463 struct nfs4_readlink_res res; 3464 struct rpc_message msg = { 3465 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK], 3466 .rpc_argp = &args, 3467 .rpc_resp = &res, 3468 }; 3469 3470 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0); 3471 } 3472 3473 static int nfs4_proc_readlink(struct inode *inode, struct page *page, 3474 unsigned int pgbase, unsigned int pglen) 3475 { 3476 struct nfs4_exception exception = { }; 3477 int err; 3478 do { 3479 err = _nfs4_proc_readlink(inode, page, pgbase, pglen); 3480 trace_nfs4_readlink(inode, err); 3481 err = nfs4_handle_exception(NFS_SERVER(inode), err, 3482 &exception); 3483 } while (exception.retry); 3484 return err; 3485 } 3486 3487 /* 3488 * This is just for mknod. open(O_CREAT) will always do ->open_context(). 3489 */ 3490 static int 3491 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 3492 int flags) 3493 { 3494 struct nfs4_label l, *ilabel = NULL; 3495 struct nfs_open_context *ctx; 3496 struct nfs4_state *state; 3497 int opened = 0; 3498 int status = 0; 3499 3500 ctx = alloc_nfs_open_context(dentry, FMODE_READ); 3501 if (IS_ERR(ctx)) 3502 return PTR_ERR(ctx); 3503 3504 ilabel = nfs4_label_init_security(dir, dentry, sattr, &l); 3505 3506 sattr->ia_mode &= ~current_umask(); 3507 state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, &opened); 3508 if (IS_ERR(state)) { 3509 status = PTR_ERR(state); 3510 goto out; 3511 } 3512 out: 3513 nfs4_label_release_security(ilabel); 3514 put_nfs_open_context(ctx); 3515 return status; 3516 } 3517 3518 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name) 3519 { 3520 struct nfs_server *server = NFS_SERVER(dir); 3521 struct nfs_removeargs args = { 3522 .fh = NFS_FH(dir), 3523 .name = *name, 3524 }; 3525 struct nfs_removeres res = { 3526 .server = server, 3527 }; 3528 struct rpc_message msg = { 3529 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE], 3530 .rpc_argp = &args, 3531 .rpc_resp = &res, 3532 }; 3533 int status; 3534 3535 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); 3536 if (status == 0) 3537 update_changeattr(dir, &res.cinfo); 3538 return status; 3539 } 3540 3541 static int nfs4_proc_remove(struct inode *dir, struct qstr *name) 3542 { 3543 struct nfs4_exception exception = { }; 3544 int err; 3545 do { 3546 err = _nfs4_proc_remove(dir, name); 3547 trace_nfs4_remove(dir, name, err); 3548 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3549 &exception); 3550 } while (exception.retry); 3551 return err; 3552 } 3553 3554 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 3555 { 3556 struct nfs_server *server = NFS_SERVER(dir); 3557 struct nfs_removeargs *args = msg->rpc_argp; 3558 struct nfs_removeres *res = msg->rpc_resp; 3559 3560 res->server = server; 3561 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; 3562 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1); 3563 3564 nfs_fattr_init(res->dir_attr); 3565 } 3566 3567 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 3568 { 3569 nfs4_setup_sequence(NFS_SERVER(data->dir), 3570 &data->args.seq_args, 3571 &data->res.seq_res, 3572 task); 3573 } 3574 3575 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir) 3576 { 3577 struct nfs_unlinkdata *data = task->tk_calldata; 3578 struct nfs_removeres *res = &data->res; 3579 3580 if (!nfs4_sequence_done(task, &res->seq_res)) 3581 return 0; 3582 if (nfs4_async_handle_error(task, res->server, NULL, 3583 &data->timeout) == -EAGAIN) 3584 return 0; 3585 update_changeattr(dir, &res->cinfo); 3586 return 1; 3587 } 3588 3589 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir) 3590 { 3591 struct nfs_server *server = NFS_SERVER(dir); 3592 struct nfs_renameargs *arg = msg->rpc_argp; 3593 struct nfs_renameres *res = msg->rpc_resp; 3594 3595 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME]; 3596 res->server = server; 3597 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1); 3598 } 3599 3600 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 3601 { 3602 nfs4_setup_sequence(NFS_SERVER(data->old_dir), 3603 &data->args.seq_args, 3604 &data->res.seq_res, 3605 task); 3606 } 3607 3608 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 3609 struct inode *new_dir) 3610 { 3611 struct nfs_renamedata *data = task->tk_calldata; 3612 struct nfs_renameres *res = &data->res; 3613 3614 if (!nfs4_sequence_done(task, &res->seq_res)) 3615 return 0; 3616 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN) 3617 return 0; 3618 3619 update_changeattr(old_dir, &res->old_cinfo); 3620 update_changeattr(new_dir, &res->new_cinfo); 3621 return 1; 3622 } 3623 3624 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 3625 { 3626 struct nfs_server *server = NFS_SERVER(inode); 3627 struct nfs4_link_arg arg = { 3628 .fh = NFS_FH(inode), 3629 .dir_fh = NFS_FH(dir), 3630 .name = name, 3631 .bitmask = server->attr_bitmask, 3632 }; 3633 struct nfs4_link_res res = { 3634 .server = server, 3635 .label = NULL, 3636 }; 3637 struct rpc_message msg = { 3638 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK], 3639 .rpc_argp = &arg, 3640 .rpc_resp = &res, 3641 }; 3642 int status = -ENOMEM; 3643 3644 res.fattr = nfs_alloc_fattr(); 3645 if (res.fattr == NULL) 3646 goto out; 3647 3648 res.label = nfs4_label_alloc(server, GFP_KERNEL); 3649 if (IS_ERR(res.label)) { 3650 status = PTR_ERR(res.label); 3651 goto out; 3652 } 3653 arg.bitmask = nfs4_bitmask(server, res.label); 3654 3655 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 3656 if (!status) { 3657 update_changeattr(dir, &res.cinfo); 3658 status = nfs_post_op_update_inode(inode, res.fattr); 3659 if (!status) 3660 nfs_setsecurity(inode, res.fattr, res.label); 3661 } 3662 3663 3664 nfs4_label_free(res.label); 3665 3666 out: 3667 nfs_free_fattr(res.fattr); 3668 return status; 3669 } 3670 3671 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 3672 { 3673 struct nfs4_exception exception = { }; 3674 int err; 3675 do { 3676 err = nfs4_handle_exception(NFS_SERVER(inode), 3677 _nfs4_proc_link(inode, dir, name), 3678 &exception); 3679 } while (exception.retry); 3680 return err; 3681 } 3682 3683 struct nfs4_createdata { 3684 struct rpc_message msg; 3685 struct nfs4_create_arg arg; 3686 struct nfs4_create_res res; 3687 struct nfs_fh fh; 3688 struct nfs_fattr fattr; 3689 struct nfs4_label *label; 3690 }; 3691 3692 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir, 3693 struct qstr *name, struct iattr *sattr, u32 ftype) 3694 { 3695 struct nfs4_createdata *data; 3696 3697 data = kzalloc(sizeof(*data), GFP_KERNEL); 3698 if (data != NULL) { 3699 struct nfs_server *server = NFS_SERVER(dir); 3700 3701 data->label = nfs4_label_alloc(server, GFP_KERNEL); 3702 if (IS_ERR(data->label)) 3703 goto out_free; 3704 3705 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; 3706 data->msg.rpc_argp = &data->arg; 3707 data->msg.rpc_resp = &data->res; 3708 data->arg.dir_fh = NFS_FH(dir); 3709 data->arg.server = server; 3710 data->arg.name = name; 3711 data->arg.attrs = sattr; 3712 data->arg.ftype = ftype; 3713 data->arg.bitmask = nfs4_bitmask(server, data->label); 3714 data->res.server = server; 3715 data->res.fh = &data->fh; 3716 data->res.fattr = &data->fattr; 3717 data->res.label = data->label; 3718 nfs_fattr_init(data->res.fattr); 3719 } 3720 return data; 3721 out_free: 3722 kfree(data); 3723 return NULL; 3724 } 3725 3726 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data) 3727 { 3728 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg, 3729 &data->arg.seq_args, &data->res.seq_res, 1); 3730 if (status == 0) { 3731 update_changeattr(dir, &data->res.dir_cinfo); 3732 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label); 3733 } 3734 return status; 3735 } 3736 3737 static void nfs4_free_createdata(struct nfs4_createdata *data) 3738 { 3739 nfs4_label_free(data->label); 3740 kfree(data); 3741 } 3742 3743 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 3744 struct page *page, unsigned int len, struct iattr *sattr, 3745 struct nfs4_label *label) 3746 { 3747 struct nfs4_createdata *data; 3748 int status = -ENAMETOOLONG; 3749 3750 if (len > NFS4_MAXPATHLEN) 3751 goto out; 3752 3753 status = -ENOMEM; 3754 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); 3755 if (data == NULL) 3756 goto out; 3757 3758 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; 3759 data->arg.u.symlink.pages = &page; 3760 data->arg.u.symlink.len = len; 3761 data->arg.label = label; 3762 3763 status = nfs4_do_create(dir, dentry, data); 3764 3765 nfs4_free_createdata(data); 3766 out: 3767 return status; 3768 } 3769 3770 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 3771 struct page *page, unsigned int len, struct iattr *sattr) 3772 { 3773 struct nfs4_exception exception = { }; 3774 struct nfs4_label l, *label = NULL; 3775 int err; 3776 3777 label = nfs4_label_init_security(dir, dentry, sattr, &l); 3778 3779 do { 3780 err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label); 3781 trace_nfs4_symlink(dir, &dentry->d_name, err); 3782 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3783 &exception); 3784 } while (exception.retry); 3785 3786 nfs4_label_release_security(label); 3787 return err; 3788 } 3789 3790 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 3791 struct iattr *sattr, struct nfs4_label *label) 3792 { 3793 struct nfs4_createdata *data; 3794 int status = -ENOMEM; 3795 3796 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); 3797 if (data == NULL) 3798 goto out; 3799 3800 data->arg.label = label; 3801 status = nfs4_do_create(dir, dentry, data); 3802 3803 nfs4_free_createdata(data); 3804 out: 3805 return status; 3806 } 3807 3808 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 3809 struct iattr *sattr) 3810 { 3811 struct nfs4_exception exception = { }; 3812 struct nfs4_label l, *label = NULL; 3813 int err; 3814 3815 label = nfs4_label_init_security(dir, dentry, sattr, &l); 3816 3817 sattr->ia_mode &= ~current_umask(); 3818 do { 3819 err = _nfs4_proc_mkdir(dir, dentry, sattr, label); 3820 trace_nfs4_mkdir(dir, &dentry->d_name, err); 3821 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3822 &exception); 3823 } while (exception.retry); 3824 nfs4_label_release_security(label); 3825 3826 return err; 3827 } 3828 3829 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 3830 u64 cookie, struct page **pages, unsigned int count, int plus) 3831 { 3832 struct inode *dir = dentry->d_inode; 3833 struct nfs4_readdir_arg args = { 3834 .fh = NFS_FH(dir), 3835 .pages = pages, 3836 .pgbase = 0, 3837 .count = count, 3838 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask, 3839 .plus = plus, 3840 }; 3841 struct nfs4_readdir_res res; 3842 struct rpc_message msg = { 3843 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], 3844 .rpc_argp = &args, 3845 .rpc_resp = &res, 3846 .rpc_cred = cred, 3847 }; 3848 int status; 3849 3850 dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__, 3851 dentry, 3852 (unsigned long long)cookie); 3853 nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args); 3854 res.pgbase = args.pgbase; 3855 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0); 3856 if (status >= 0) { 3857 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE); 3858 status += args.pgbase; 3859 } 3860 3861 nfs_invalidate_atime(dir); 3862 3863 dprintk("%s: returns %d\n", __func__, status); 3864 return status; 3865 } 3866 3867 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 3868 u64 cookie, struct page **pages, unsigned int count, int plus) 3869 { 3870 struct nfs4_exception exception = { }; 3871 int err; 3872 do { 3873 err = _nfs4_proc_readdir(dentry, cred, cookie, 3874 pages, count, plus); 3875 trace_nfs4_readdir(dentry->d_inode, err); 3876 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err, 3877 &exception); 3878 } while (exception.retry); 3879 return err; 3880 } 3881 3882 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 3883 struct iattr *sattr, struct nfs4_label *label, dev_t rdev) 3884 { 3885 struct nfs4_createdata *data; 3886 int mode = sattr->ia_mode; 3887 int status = -ENOMEM; 3888 3889 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); 3890 if (data == NULL) 3891 goto out; 3892 3893 if (S_ISFIFO(mode)) 3894 data->arg.ftype = NF4FIFO; 3895 else if (S_ISBLK(mode)) { 3896 data->arg.ftype = NF4BLK; 3897 data->arg.u.device.specdata1 = MAJOR(rdev); 3898 data->arg.u.device.specdata2 = MINOR(rdev); 3899 } 3900 else if (S_ISCHR(mode)) { 3901 data->arg.ftype = NF4CHR; 3902 data->arg.u.device.specdata1 = MAJOR(rdev); 3903 data->arg.u.device.specdata2 = MINOR(rdev); 3904 } else if (!S_ISSOCK(mode)) { 3905 status = -EINVAL; 3906 goto out_free; 3907 } 3908 3909 data->arg.label = label; 3910 status = nfs4_do_create(dir, dentry, data); 3911 out_free: 3912 nfs4_free_createdata(data); 3913 out: 3914 return status; 3915 } 3916 3917 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 3918 struct iattr *sattr, dev_t rdev) 3919 { 3920 struct nfs4_exception exception = { }; 3921 struct nfs4_label l, *label = NULL; 3922 int err; 3923 3924 label = nfs4_label_init_security(dir, dentry, sattr, &l); 3925 3926 sattr->ia_mode &= ~current_umask(); 3927 do { 3928 err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev); 3929 trace_nfs4_mknod(dir, &dentry->d_name, err); 3930 err = nfs4_handle_exception(NFS_SERVER(dir), err, 3931 &exception); 3932 } while (exception.retry); 3933 3934 nfs4_label_release_security(label); 3935 3936 return err; 3937 } 3938 3939 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 3940 struct nfs_fsstat *fsstat) 3941 { 3942 struct nfs4_statfs_arg args = { 3943 .fh = fhandle, 3944 .bitmask = server->attr_bitmask, 3945 }; 3946 struct nfs4_statfs_res res = { 3947 .fsstat = fsstat, 3948 }; 3949 struct rpc_message msg = { 3950 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS], 3951 .rpc_argp = &args, 3952 .rpc_resp = &res, 3953 }; 3954 3955 nfs_fattr_init(fsstat->fattr); 3956 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3957 } 3958 3959 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat) 3960 { 3961 struct nfs4_exception exception = { }; 3962 int err; 3963 do { 3964 err = nfs4_handle_exception(server, 3965 _nfs4_proc_statfs(server, fhandle, fsstat), 3966 &exception); 3967 } while (exception.retry); 3968 return err; 3969 } 3970 3971 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 3972 struct nfs_fsinfo *fsinfo) 3973 { 3974 struct nfs4_fsinfo_arg args = { 3975 .fh = fhandle, 3976 .bitmask = server->attr_bitmask, 3977 }; 3978 struct nfs4_fsinfo_res res = { 3979 .fsinfo = fsinfo, 3980 }; 3981 struct rpc_message msg = { 3982 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO], 3983 .rpc_argp = &args, 3984 .rpc_resp = &res, 3985 }; 3986 3987 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3988 } 3989 3990 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 3991 { 3992 struct nfs4_exception exception = { }; 3993 unsigned long now = jiffies; 3994 int err; 3995 3996 do { 3997 err = _nfs4_do_fsinfo(server, fhandle, fsinfo); 3998 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err); 3999 if (err == 0) { 4000 struct nfs_client *clp = server->nfs_client; 4001 4002 spin_lock(&clp->cl_lock); 4003 clp->cl_lease_time = fsinfo->lease_time * HZ; 4004 clp->cl_last_renewal = now; 4005 spin_unlock(&clp->cl_lock); 4006 break; 4007 } 4008 err = nfs4_handle_exception(server, err, &exception); 4009 } while (exception.retry); 4010 return err; 4011 } 4012 4013 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 4014 { 4015 int error; 4016 4017 nfs_fattr_init(fsinfo->fattr); 4018 error = nfs4_do_fsinfo(server, fhandle, fsinfo); 4019 if (error == 0) { 4020 /* block layout checks this! */ 4021 server->pnfs_blksize = fsinfo->blksize; 4022 set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype); 4023 } 4024 4025 return error; 4026 } 4027 4028 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 4029 struct nfs_pathconf *pathconf) 4030 { 4031 struct nfs4_pathconf_arg args = { 4032 .fh = fhandle, 4033 .bitmask = server->attr_bitmask, 4034 }; 4035 struct nfs4_pathconf_res res = { 4036 .pathconf = pathconf, 4037 }; 4038 struct rpc_message msg = { 4039 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF], 4040 .rpc_argp = &args, 4041 .rpc_resp = &res, 4042 }; 4043 4044 /* None of the pathconf attributes are mandatory to implement */ 4045 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) { 4046 memset(pathconf, 0, sizeof(*pathconf)); 4047 return 0; 4048 } 4049 4050 nfs_fattr_init(pathconf->fattr); 4051 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 4052 } 4053 4054 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 4055 struct nfs_pathconf *pathconf) 4056 { 4057 struct nfs4_exception exception = { }; 4058 int err; 4059 4060 do { 4061 err = nfs4_handle_exception(server, 4062 _nfs4_proc_pathconf(server, fhandle, pathconf), 4063 &exception); 4064 } while (exception.retry); 4065 return err; 4066 } 4067 4068 int nfs4_set_rw_stateid(nfs4_stateid *stateid, 4069 const struct nfs_open_context *ctx, 4070 const struct nfs_lock_context *l_ctx, 4071 fmode_t fmode) 4072 { 4073 const struct nfs_lockowner *lockowner = NULL; 4074 4075 if (l_ctx != NULL) 4076 lockowner = &l_ctx->lockowner; 4077 return nfs4_select_rw_stateid(stateid, ctx->state, fmode, lockowner); 4078 } 4079 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid); 4080 4081 static bool nfs4_stateid_is_current(nfs4_stateid *stateid, 4082 const struct nfs_open_context *ctx, 4083 const struct nfs_lock_context *l_ctx, 4084 fmode_t fmode) 4085 { 4086 nfs4_stateid current_stateid; 4087 4088 /* If the current stateid represents a lost lock, then exit */ 4089 if (nfs4_set_rw_stateid(¤t_stateid, ctx, l_ctx, fmode) == -EIO) 4090 return true; 4091 return nfs4_stateid_match(stateid, ¤t_stateid); 4092 } 4093 4094 static bool nfs4_error_stateid_expired(int err) 4095 { 4096 switch (err) { 4097 case -NFS4ERR_DELEG_REVOKED: 4098 case -NFS4ERR_ADMIN_REVOKED: 4099 case -NFS4ERR_BAD_STATEID: 4100 case -NFS4ERR_STALE_STATEID: 4101 case -NFS4ERR_OLD_STATEID: 4102 case -NFS4ERR_OPENMODE: 4103 case -NFS4ERR_EXPIRED: 4104 return true; 4105 } 4106 return false; 4107 } 4108 4109 void __nfs4_read_done_cb(struct nfs_pgio_header *hdr) 4110 { 4111 nfs_invalidate_atime(hdr->inode); 4112 } 4113 4114 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr) 4115 { 4116 struct nfs_server *server = NFS_SERVER(hdr->inode); 4117 4118 trace_nfs4_read(hdr, task->tk_status); 4119 if (nfs4_async_handle_error(task, server, 4120 hdr->args.context->state, 4121 NULL) == -EAGAIN) { 4122 rpc_restart_call_prepare(task); 4123 return -EAGAIN; 4124 } 4125 4126 __nfs4_read_done_cb(hdr); 4127 if (task->tk_status > 0) 4128 renew_lease(server, hdr->timestamp); 4129 return 0; 4130 } 4131 4132 static bool nfs4_read_stateid_changed(struct rpc_task *task, 4133 struct nfs_pgio_args *args) 4134 { 4135 4136 if (!nfs4_error_stateid_expired(task->tk_status) || 4137 nfs4_stateid_is_current(&args->stateid, 4138 args->context, 4139 args->lock_context, 4140 FMODE_READ)) 4141 return false; 4142 rpc_restart_call_prepare(task); 4143 return true; 4144 } 4145 4146 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 4147 { 4148 4149 dprintk("--> %s\n", __func__); 4150 4151 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) 4152 return -EAGAIN; 4153 if (nfs4_read_stateid_changed(task, &hdr->args)) 4154 return -EAGAIN; 4155 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : 4156 nfs4_read_done_cb(task, hdr); 4157 } 4158 4159 static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr, 4160 struct rpc_message *msg) 4161 { 4162 hdr->timestamp = jiffies; 4163 hdr->pgio_done_cb = nfs4_read_done_cb; 4164 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; 4165 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0); 4166 } 4167 4168 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task, 4169 struct nfs_pgio_header *hdr) 4170 { 4171 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode), 4172 &hdr->args.seq_args, 4173 &hdr->res.seq_res, 4174 task)) 4175 return 0; 4176 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, 4177 hdr->args.lock_context, 4178 hdr->rw_ops->rw_mode) == -EIO) 4179 return -EIO; 4180 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) 4181 return -EIO; 4182 return 0; 4183 } 4184 4185 static int nfs4_write_done_cb(struct rpc_task *task, 4186 struct nfs_pgio_header *hdr) 4187 { 4188 struct inode *inode = hdr->inode; 4189 4190 trace_nfs4_write(hdr, task->tk_status); 4191 if (nfs4_async_handle_error(task, NFS_SERVER(inode), 4192 hdr->args.context->state, 4193 NULL) == -EAGAIN) { 4194 rpc_restart_call_prepare(task); 4195 return -EAGAIN; 4196 } 4197 if (task->tk_status >= 0) { 4198 renew_lease(NFS_SERVER(inode), hdr->timestamp); 4199 nfs_post_op_update_inode_force_wcc(inode, &hdr->fattr); 4200 } 4201 return 0; 4202 } 4203 4204 static bool nfs4_write_stateid_changed(struct rpc_task *task, 4205 struct nfs_pgio_args *args) 4206 { 4207 4208 if (!nfs4_error_stateid_expired(task->tk_status) || 4209 nfs4_stateid_is_current(&args->stateid, 4210 args->context, 4211 args->lock_context, 4212 FMODE_WRITE)) 4213 return false; 4214 rpc_restart_call_prepare(task); 4215 return true; 4216 } 4217 4218 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 4219 { 4220 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) 4221 return -EAGAIN; 4222 if (nfs4_write_stateid_changed(task, &hdr->args)) 4223 return -EAGAIN; 4224 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : 4225 nfs4_write_done_cb(task, hdr); 4226 } 4227 4228 static 4229 bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr) 4230 { 4231 /* Don't request attributes for pNFS or O_DIRECT writes */ 4232 if (hdr->ds_clp != NULL || hdr->dreq != NULL) 4233 return false; 4234 /* Otherwise, request attributes if and only if we don't hold 4235 * a delegation 4236 */ 4237 return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0; 4238 } 4239 4240 static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr, 4241 struct rpc_message *msg) 4242 { 4243 struct nfs_server *server = NFS_SERVER(hdr->inode); 4244 4245 if (!nfs4_write_need_cache_consistency_data(hdr)) { 4246 hdr->args.bitmask = NULL; 4247 hdr->res.fattr = NULL; 4248 } else 4249 hdr->args.bitmask = server->cache_consistency_bitmask; 4250 4251 if (!hdr->pgio_done_cb) 4252 hdr->pgio_done_cb = nfs4_write_done_cb; 4253 hdr->res.server = server; 4254 hdr->timestamp = jiffies; 4255 4256 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; 4257 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1); 4258 } 4259 4260 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 4261 { 4262 nfs4_setup_sequence(NFS_SERVER(data->inode), 4263 &data->args.seq_args, 4264 &data->res.seq_res, 4265 task); 4266 } 4267 4268 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data) 4269 { 4270 struct inode *inode = data->inode; 4271 4272 trace_nfs4_commit(data, task->tk_status); 4273 if (nfs4_async_handle_error(task, NFS_SERVER(inode), 4274 NULL, NULL) == -EAGAIN) { 4275 rpc_restart_call_prepare(task); 4276 return -EAGAIN; 4277 } 4278 return 0; 4279 } 4280 4281 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data) 4282 { 4283 if (!nfs4_sequence_done(task, &data->res.seq_res)) 4284 return -EAGAIN; 4285 return data->commit_done_cb(task, data); 4286 } 4287 4288 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg) 4289 { 4290 struct nfs_server *server = NFS_SERVER(data->inode); 4291 4292 if (data->commit_done_cb == NULL) 4293 data->commit_done_cb = nfs4_commit_done_cb; 4294 data->res.server = server; 4295 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; 4296 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1); 4297 } 4298 4299 struct nfs4_renewdata { 4300 struct nfs_client *client; 4301 unsigned long timestamp; 4302 }; 4303 4304 /* 4305 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special 4306 * standalone procedure for queueing an asynchronous RENEW. 4307 */ 4308 static void nfs4_renew_release(void *calldata) 4309 { 4310 struct nfs4_renewdata *data = calldata; 4311 struct nfs_client *clp = data->client; 4312 4313 if (atomic_read(&clp->cl_count) > 1) 4314 nfs4_schedule_state_renewal(clp); 4315 nfs_put_client(clp); 4316 kfree(data); 4317 } 4318 4319 static void nfs4_renew_done(struct rpc_task *task, void *calldata) 4320 { 4321 struct nfs4_renewdata *data = calldata; 4322 struct nfs_client *clp = data->client; 4323 unsigned long timestamp = data->timestamp; 4324 4325 trace_nfs4_renew_async(clp, task->tk_status); 4326 switch (task->tk_status) { 4327 case 0: 4328 break; 4329 case -NFS4ERR_LEASE_MOVED: 4330 nfs4_schedule_lease_moved_recovery(clp); 4331 break; 4332 default: 4333 /* Unless we're shutting down, schedule state recovery! */ 4334 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0) 4335 return; 4336 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) { 4337 nfs4_schedule_lease_recovery(clp); 4338 return; 4339 } 4340 nfs4_schedule_path_down_recovery(clp); 4341 } 4342 do_renew_lease(clp, timestamp); 4343 } 4344 4345 static const struct rpc_call_ops nfs4_renew_ops = { 4346 .rpc_call_done = nfs4_renew_done, 4347 .rpc_release = nfs4_renew_release, 4348 }; 4349 4350 static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags) 4351 { 4352 struct rpc_message msg = { 4353 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 4354 .rpc_argp = clp, 4355 .rpc_cred = cred, 4356 }; 4357 struct nfs4_renewdata *data; 4358 4359 if (renew_flags == 0) 4360 return 0; 4361 if (!atomic_inc_not_zero(&clp->cl_count)) 4362 return -EIO; 4363 data = kmalloc(sizeof(*data), GFP_NOFS); 4364 if (data == NULL) 4365 return -ENOMEM; 4366 data->client = clp; 4367 data->timestamp = jiffies; 4368 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT, 4369 &nfs4_renew_ops, data); 4370 } 4371 4372 static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) 4373 { 4374 struct rpc_message msg = { 4375 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 4376 .rpc_argp = clp, 4377 .rpc_cred = cred, 4378 }; 4379 unsigned long now = jiffies; 4380 int status; 4381 4382 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 4383 if (status < 0) 4384 return status; 4385 do_renew_lease(clp, now); 4386 return 0; 4387 } 4388 4389 static inline int nfs4_server_supports_acls(struct nfs_server *server) 4390 { 4391 return server->caps & NFS_CAP_ACLS; 4392 } 4393 4394 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that 4395 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on 4396 * the stack. 4397 */ 4398 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE) 4399 4400 static int buf_to_pages_noslab(const void *buf, size_t buflen, 4401 struct page **pages, unsigned int *pgbase) 4402 { 4403 struct page *newpage, **spages; 4404 int rc = 0; 4405 size_t len; 4406 spages = pages; 4407 4408 do { 4409 len = min_t(size_t, PAGE_SIZE, buflen); 4410 newpage = alloc_page(GFP_KERNEL); 4411 4412 if (newpage == NULL) 4413 goto unwind; 4414 memcpy(page_address(newpage), buf, len); 4415 buf += len; 4416 buflen -= len; 4417 *pages++ = newpage; 4418 rc++; 4419 } while (buflen != 0); 4420 4421 return rc; 4422 4423 unwind: 4424 for(; rc > 0; rc--) 4425 __free_page(spages[rc-1]); 4426 return -ENOMEM; 4427 } 4428 4429 struct nfs4_cached_acl { 4430 int cached; 4431 size_t len; 4432 char data[0]; 4433 }; 4434 4435 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) 4436 { 4437 struct nfs_inode *nfsi = NFS_I(inode); 4438 4439 spin_lock(&inode->i_lock); 4440 kfree(nfsi->nfs4_acl); 4441 nfsi->nfs4_acl = acl; 4442 spin_unlock(&inode->i_lock); 4443 } 4444 4445 static void nfs4_zap_acl_attr(struct inode *inode) 4446 { 4447 nfs4_set_cached_acl(inode, NULL); 4448 } 4449 4450 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen) 4451 { 4452 struct nfs_inode *nfsi = NFS_I(inode); 4453 struct nfs4_cached_acl *acl; 4454 int ret = -ENOENT; 4455 4456 spin_lock(&inode->i_lock); 4457 acl = nfsi->nfs4_acl; 4458 if (acl == NULL) 4459 goto out; 4460 if (buf == NULL) /* user is just asking for length */ 4461 goto out_len; 4462 if (acl->cached == 0) 4463 goto out; 4464 ret = -ERANGE; /* see getxattr(2) man page */ 4465 if (acl->len > buflen) 4466 goto out; 4467 memcpy(buf, acl->data, acl->len); 4468 out_len: 4469 ret = acl->len; 4470 out: 4471 spin_unlock(&inode->i_lock); 4472 return ret; 4473 } 4474 4475 static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len) 4476 { 4477 struct nfs4_cached_acl *acl; 4478 size_t buflen = sizeof(*acl) + acl_len; 4479 4480 if (buflen <= PAGE_SIZE) { 4481 acl = kmalloc(buflen, GFP_KERNEL); 4482 if (acl == NULL) 4483 goto out; 4484 acl->cached = 1; 4485 _copy_from_pages(acl->data, pages, pgbase, acl_len); 4486 } else { 4487 acl = kmalloc(sizeof(*acl), GFP_KERNEL); 4488 if (acl == NULL) 4489 goto out; 4490 acl->cached = 0; 4491 } 4492 acl->len = acl_len; 4493 out: 4494 nfs4_set_cached_acl(inode, acl); 4495 } 4496 4497 /* 4498 * The getxattr API returns the required buffer length when called with a 4499 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating 4500 * the required buf. On a NULL buf, we send a page of data to the server 4501 * guessing that the ACL request can be serviced by a page. If so, we cache 4502 * up to the page of ACL data, and the 2nd call to getxattr is serviced by 4503 * the cache. If not so, we throw away the page, and cache the required 4504 * length. The next getxattr call will then produce another round trip to 4505 * the server, this time with the input buf of the required size. 4506 */ 4507 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 4508 { 4509 struct page *pages[NFS4ACL_MAXPAGES] = {NULL, }; 4510 struct nfs_getaclargs args = { 4511 .fh = NFS_FH(inode), 4512 .acl_pages = pages, 4513 .acl_len = buflen, 4514 }; 4515 struct nfs_getaclres res = { 4516 .acl_len = buflen, 4517 }; 4518 struct rpc_message msg = { 4519 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL], 4520 .rpc_argp = &args, 4521 .rpc_resp = &res, 4522 }; 4523 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE); 4524 int ret = -ENOMEM, i; 4525 4526 /* As long as we're doing a round trip to the server anyway, 4527 * let's be prepared for a page of acl data. */ 4528 if (npages == 0) 4529 npages = 1; 4530 if (npages > ARRAY_SIZE(pages)) 4531 return -ERANGE; 4532 4533 for (i = 0; i < npages; i++) { 4534 pages[i] = alloc_page(GFP_KERNEL); 4535 if (!pages[i]) 4536 goto out_free; 4537 } 4538 4539 /* for decoding across pages */ 4540 res.acl_scratch = alloc_page(GFP_KERNEL); 4541 if (!res.acl_scratch) 4542 goto out_free; 4543 4544 args.acl_len = npages * PAGE_SIZE; 4545 args.acl_pgbase = 0; 4546 4547 dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n", 4548 __func__, buf, buflen, npages, args.acl_len); 4549 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), 4550 &msg, &args.seq_args, &res.seq_res, 0); 4551 if (ret) 4552 goto out_free; 4553 4554 /* Handle the case where the passed-in buffer is too short */ 4555 if (res.acl_flags & NFS4_ACL_TRUNC) { 4556 /* Did the user only issue a request for the acl length? */ 4557 if (buf == NULL) 4558 goto out_ok; 4559 ret = -ERANGE; 4560 goto out_free; 4561 } 4562 nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len); 4563 if (buf) { 4564 if (res.acl_len > buflen) { 4565 ret = -ERANGE; 4566 goto out_free; 4567 } 4568 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len); 4569 } 4570 out_ok: 4571 ret = res.acl_len; 4572 out_free: 4573 for (i = 0; i < npages; i++) 4574 if (pages[i]) 4575 __free_page(pages[i]); 4576 if (res.acl_scratch) 4577 __free_page(res.acl_scratch); 4578 return ret; 4579 } 4580 4581 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 4582 { 4583 struct nfs4_exception exception = { }; 4584 ssize_t ret; 4585 do { 4586 ret = __nfs4_get_acl_uncached(inode, buf, buflen); 4587 trace_nfs4_get_acl(inode, ret); 4588 if (ret >= 0) 4589 break; 4590 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception); 4591 } while (exception.retry); 4592 return ret; 4593 } 4594 4595 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen) 4596 { 4597 struct nfs_server *server = NFS_SERVER(inode); 4598 int ret; 4599 4600 if (!nfs4_server_supports_acls(server)) 4601 return -EOPNOTSUPP; 4602 ret = nfs_revalidate_inode(server, inode); 4603 if (ret < 0) 4604 return ret; 4605 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) 4606 nfs_zap_acl_cache(inode); 4607 ret = nfs4_read_cached_acl(inode, buf, buflen); 4608 if (ret != -ENOENT) 4609 /* -ENOENT is returned if there is no ACL or if there is an ACL 4610 * but no cached acl data, just the acl length */ 4611 return ret; 4612 return nfs4_get_acl_uncached(inode, buf, buflen); 4613 } 4614 4615 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 4616 { 4617 struct nfs_server *server = NFS_SERVER(inode); 4618 struct page *pages[NFS4ACL_MAXPAGES]; 4619 struct nfs_setaclargs arg = { 4620 .fh = NFS_FH(inode), 4621 .acl_pages = pages, 4622 .acl_len = buflen, 4623 }; 4624 struct nfs_setaclres res; 4625 struct rpc_message msg = { 4626 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL], 4627 .rpc_argp = &arg, 4628 .rpc_resp = &res, 4629 }; 4630 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE); 4631 int ret, i; 4632 4633 if (!nfs4_server_supports_acls(server)) 4634 return -EOPNOTSUPP; 4635 if (npages > ARRAY_SIZE(pages)) 4636 return -ERANGE; 4637 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 4638 if (i < 0) 4639 return i; 4640 nfs4_inode_return_delegation(inode); 4641 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 4642 4643 /* 4644 * Free each page after tx, so the only ref left is 4645 * held by the network stack 4646 */ 4647 for (; i > 0; i--) 4648 put_page(pages[i-1]); 4649 4650 /* 4651 * Acl update can result in inode attribute update. 4652 * so mark the attribute cache invalid. 4653 */ 4654 spin_lock(&inode->i_lock); 4655 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR; 4656 spin_unlock(&inode->i_lock); 4657 nfs_access_zap_cache(inode); 4658 nfs_zap_acl_cache(inode); 4659 return ret; 4660 } 4661 4662 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 4663 { 4664 struct nfs4_exception exception = { }; 4665 int err; 4666 do { 4667 err = __nfs4_proc_set_acl(inode, buf, buflen); 4668 trace_nfs4_set_acl(inode, err); 4669 err = nfs4_handle_exception(NFS_SERVER(inode), err, 4670 &exception); 4671 } while (exception.retry); 4672 return err; 4673 } 4674 4675 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 4676 static int _nfs4_get_security_label(struct inode *inode, void *buf, 4677 size_t buflen) 4678 { 4679 struct nfs_server *server = NFS_SERVER(inode); 4680 struct nfs_fattr fattr; 4681 struct nfs4_label label = {0, 0, buflen, buf}; 4682 4683 u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL }; 4684 struct nfs4_getattr_arg arg = { 4685 .fh = NFS_FH(inode), 4686 .bitmask = bitmask, 4687 }; 4688 struct nfs4_getattr_res res = { 4689 .fattr = &fattr, 4690 .label = &label, 4691 .server = server, 4692 }; 4693 struct rpc_message msg = { 4694 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 4695 .rpc_argp = &arg, 4696 .rpc_resp = &res, 4697 }; 4698 int ret; 4699 4700 nfs_fattr_init(&fattr); 4701 4702 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0); 4703 if (ret) 4704 return ret; 4705 if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL)) 4706 return -ENOENT; 4707 if (buflen < label.len) 4708 return -ERANGE; 4709 return 0; 4710 } 4711 4712 static int nfs4_get_security_label(struct inode *inode, void *buf, 4713 size_t buflen) 4714 { 4715 struct nfs4_exception exception = { }; 4716 int err; 4717 4718 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) 4719 return -EOPNOTSUPP; 4720 4721 do { 4722 err = _nfs4_get_security_label(inode, buf, buflen); 4723 trace_nfs4_get_security_label(inode, err); 4724 err = nfs4_handle_exception(NFS_SERVER(inode), err, 4725 &exception); 4726 } while (exception.retry); 4727 return err; 4728 } 4729 4730 static int _nfs4_do_set_security_label(struct inode *inode, 4731 struct nfs4_label *ilabel, 4732 struct nfs_fattr *fattr, 4733 struct nfs4_label *olabel) 4734 { 4735 4736 struct iattr sattr = {0}; 4737 struct nfs_server *server = NFS_SERVER(inode); 4738 const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL }; 4739 struct nfs_setattrargs arg = { 4740 .fh = NFS_FH(inode), 4741 .iap = &sattr, 4742 .server = server, 4743 .bitmask = bitmask, 4744 .label = ilabel, 4745 }; 4746 struct nfs_setattrres res = { 4747 .fattr = fattr, 4748 .label = olabel, 4749 .server = server, 4750 }; 4751 struct rpc_message msg = { 4752 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 4753 .rpc_argp = &arg, 4754 .rpc_resp = &res, 4755 }; 4756 int status; 4757 4758 nfs4_stateid_copy(&arg.stateid, &zero_stateid); 4759 4760 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 4761 if (status) 4762 dprintk("%s failed: %d\n", __func__, status); 4763 4764 return status; 4765 } 4766 4767 static int nfs4_do_set_security_label(struct inode *inode, 4768 struct nfs4_label *ilabel, 4769 struct nfs_fattr *fattr, 4770 struct nfs4_label *olabel) 4771 { 4772 struct nfs4_exception exception = { }; 4773 int err; 4774 4775 do { 4776 err = _nfs4_do_set_security_label(inode, ilabel, 4777 fattr, olabel); 4778 trace_nfs4_set_security_label(inode, err); 4779 err = nfs4_handle_exception(NFS_SERVER(inode), err, 4780 &exception); 4781 } while (exception.retry); 4782 return err; 4783 } 4784 4785 static int 4786 nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen) 4787 { 4788 struct nfs4_label ilabel, *olabel = NULL; 4789 struct nfs_fattr fattr; 4790 struct rpc_cred *cred; 4791 struct inode *inode = dentry->d_inode; 4792 int status; 4793 4794 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) 4795 return -EOPNOTSUPP; 4796 4797 nfs_fattr_init(&fattr); 4798 4799 ilabel.pi = 0; 4800 ilabel.lfs = 0; 4801 ilabel.label = (char *)buf; 4802 ilabel.len = buflen; 4803 4804 cred = rpc_lookup_cred(); 4805 if (IS_ERR(cred)) 4806 return PTR_ERR(cred); 4807 4808 olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL); 4809 if (IS_ERR(olabel)) { 4810 status = -PTR_ERR(olabel); 4811 goto out; 4812 } 4813 4814 status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel); 4815 if (status == 0) 4816 nfs_setsecurity(inode, &fattr, olabel); 4817 4818 nfs4_label_free(olabel); 4819 out: 4820 put_rpccred(cred); 4821 return status; 4822 } 4823 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */ 4824 4825 4826 static int 4827 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, 4828 struct nfs4_state *state, long *timeout) 4829 { 4830 struct nfs_client *clp = server->nfs_client; 4831 4832 if (task->tk_status >= 0) 4833 return 0; 4834 switch(task->tk_status) { 4835 case -NFS4ERR_DELEG_REVOKED: 4836 case -NFS4ERR_ADMIN_REVOKED: 4837 case -NFS4ERR_BAD_STATEID: 4838 case -NFS4ERR_OPENMODE: 4839 if (state == NULL) 4840 break; 4841 if (nfs4_schedule_stateid_recovery(server, state) < 0) 4842 goto recovery_failed; 4843 goto wait_on_recovery; 4844 case -NFS4ERR_EXPIRED: 4845 if (state != NULL) { 4846 if (nfs4_schedule_stateid_recovery(server, state) < 0) 4847 goto recovery_failed; 4848 } 4849 case -NFS4ERR_STALE_STATEID: 4850 case -NFS4ERR_STALE_CLIENTID: 4851 nfs4_schedule_lease_recovery(clp); 4852 goto wait_on_recovery; 4853 case -NFS4ERR_MOVED: 4854 if (nfs4_schedule_migration_recovery(server) < 0) 4855 goto recovery_failed; 4856 goto wait_on_recovery; 4857 case -NFS4ERR_LEASE_MOVED: 4858 nfs4_schedule_lease_moved_recovery(clp); 4859 goto wait_on_recovery; 4860 #if defined(CONFIG_NFS_V4_1) 4861 case -NFS4ERR_BADSESSION: 4862 case -NFS4ERR_BADSLOT: 4863 case -NFS4ERR_BAD_HIGH_SLOT: 4864 case -NFS4ERR_DEADSESSION: 4865 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 4866 case -NFS4ERR_SEQ_FALSE_RETRY: 4867 case -NFS4ERR_SEQ_MISORDERED: 4868 dprintk("%s ERROR %d, Reset session\n", __func__, 4869 task->tk_status); 4870 nfs4_schedule_session_recovery(clp->cl_session, task->tk_status); 4871 goto wait_on_recovery; 4872 #endif /* CONFIG_NFS_V4_1 */ 4873 case -NFS4ERR_DELAY: 4874 nfs_inc_server_stats(server, NFSIOS_DELAY); 4875 rpc_delay(task, nfs4_update_delay(timeout)); 4876 goto restart_call; 4877 case -NFS4ERR_GRACE: 4878 rpc_delay(task, NFS4_POLL_RETRY_MAX); 4879 case -NFS4ERR_RETRY_UNCACHED_REP: 4880 case -NFS4ERR_OLD_STATEID: 4881 goto restart_call; 4882 } 4883 task->tk_status = nfs4_map_errors(task->tk_status); 4884 return 0; 4885 recovery_failed: 4886 task->tk_status = -EIO; 4887 return 0; 4888 wait_on_recovery: 4889 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); 4890 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) 4891 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); 4892 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) 4893 goto recovery_failed; 4894 restart_call: 4895 task->tk_status = 0; 4896 return -EAGAIN; 4897 } 4898 4899 static void nfs4_init_boot_verifier(const struct nfs_client *clp, 4900 nfs4_verifier *bootverf) 4901 { 4902 __be32 verf[2]; 4903 4904 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { 4905 /* An impossible timestamp guarantees this value 4906 * will never match a generated boot time. */ 4907 verf[0] = 0; 4908 verf[1] = cpu_to_be32(NSEC_PER_SEC + 1); 4909 } else { 4910 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); 4911 verf[0] = cpu_to_be32(nn->boot_time.tv_sec); 4912 verf[1] = cpu_to_be32(nn->boot_time.tv_nsec); 4913 } 4914 memcpy(bootverf->data, verf, sizeof(bootverf->data)); 4915 } 4916 4917 static unsigned int 4918 nfs4_init_nonuniform_client_string(struct nfs_client *clp, 4919 char *buf, size_t len) 4920 { 4921 unsigned int result; 4922 4923 if (clp->cl_owner_id != NULL) 4924 return strlcpy(buf, clp->cl_owner_id, len); 4925 4926 rcu_read_lock(); 4927 result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s", 4928 clp->cl_ipaddr, 4929 rpc_peeraddr2str(clp->cl_rpcclient, 4930 RPC_DISPLAY_ADDR), 4931 rpc_peeraddr2str(clp->cl_rpcclient, 4932 RPC_DISPLAY_PROTO)); 4933 rcu_read_unlock(); 4934 clp->cl_owner_id = kstrdup(buf, GFP_KERNEL); 4935 return result; 4936 } 4937 4938 static unsigned int 4939 nfs4_init_uniform_client_string(struct nfs_client *clp, 4940 char *buf, size_t len) 4941 { 4942 const char *nodename = clp->cl_rpcclient->cl_nodename; 4943 unsigned int result; 4944 4945 if (clp->cl_owner_id != NULL) 4946 return strlcpy(buf, clp->cl_owner_id, len); 4947 4948 if (nfs4_client_id_uniquifier[0] != '\0') 4949 result = scnprintf(buf, len, "Linux NFSv%u.%u %s/%s", 4950 clp->rpc_ops->version, 4951 clp->cl_minorversion, 4952 nfs4_client_id_uniquifier, 4953 nodename); 4954 else 4955 result = scnprintf(buf, len, "Linux NFSv%u.%u %s", 4956 clp->rpc_ops->version, clp->cl_minorversion, 4957 nodename); 4958 clp->cl_owner_id = kstrdup(buf, GFP_KERNEL); 4959 return result; 4960 } 4961 4962 /* 4963 * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback 4964 * services. Advertise one based on the address family of the 4965 * clientaddr. 4966 */ 4967 static unsigned int 4968 nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len) 4969 { 4970 if (strchr(clp->cl_ipaddr, ':') != NULL) 4971 return scnprintf(buf, len, "tcp6"); 4972 else 4973 return scnprintf(buf, len, "tcp"); 4974 } 4975 4976 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata) 4977 { 4978 struct nfs4_setclientid *sc = calldata; 4979 4980 if (task->tk_status == 0) 4981 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred); 4982 } 4983 4984 static const struct rpc_call_ops nfs4_setclientid_ops = { 4985 .rpc_call_done = nfs4_setclientid_done, 4986 }; 4987 4988 /** 4989 * nfs4_proc_setclientid - Negotiate client ID 4990 * @clp: state data structure 4991 * @program: RPC program for NFSv4 callback service 4992 * @port: IP port number for NFS4 callback service 4993 * @cred: RPC credential to use for this call 4994 * @res: where to place the result 4995 * 4996 * Returns zero, a negative errno, or a negative NFS4ERR status code. 4997 */ 4998 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, 4999 unsigned short port, struct rpc_cred *cred, 5000 struct nfs4_setclientid_res *res) 5001 { 5002 nfs4_verifier sc_verifier; 5003 struct nfs4_setclientid setclientid = { 5004 .sc_verifier = &sc_verifier, 5005 .sc_prog = program, 5006 .sc_cb_ident = clp->cl_cb_ident, 5007 }; 5008 struct rpc_message msg = { 5009 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], 5010 .rpc_argp = &setclientid, 5011 .rpc_resp = res, 5012 .rpc_cred = cred, 5013 }; 5014 struct rpc_task *task; 5015 struct rpc_task_setup task_setup_data = { 5016 .rpc_client = clp->cl_rpcclient, 5017 .rpc_message = &msg, 5018 .callback_ops = &nfs4_setclientid_ops, 5019 .callback_data = &setclientid, 5020 .flags = RPC_TASK_TIMEOUT, 5021 }; 5022 int status; 5023 5024 /* nfs_client_id4 */ 5025 nfs4_init_boot_verifier(clp, &sc_verifier); 5026 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags)) 5027 setclientid.sc_name_len = 5028 nfs4_init_uniform_client_string(clp, 5029 setclientid.sc_name, 5030 sizeof(setclientid.sc_name)); 5031 else 5032 setclientid.sc_name_len = 5033 nfs4_init_nonuniform_client_string(clp, 5034 setclientid.sc_name, 5035 sizeof(setclientid.sc_name)); 5036 /* cb_client4 */ 5037 setclientid.sc_netid_len = 5038 nfs4_init_callback_netid(clp, 5039 setclientid.sc_netid, 5040 sizeof(setclientid.sc_netid)); 5041 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, 5042 sizeof(setclientid.sc_uaddr), "%s.%u.%u", 5043 clp->cl_ipaddr, port >> 8, port & 255); 5044 5045 dprintk("NFS call setclientid auth=%s, '%.*s'\n", 5046 clp->cl_rpcclient->cl_auth->au_ops->au_name, 5047 setclientid.sc_name_len, setclientid.sc_name); 5048 task = rpc_run_task(&task_setup_data); 5049 if (IS_ERR(task)) { 5050 status = PTR_ERR(task); 5051 goto out; 5052 } 5053 status = task->tk_status; 5054 if (setclientid.sc_cred) { 5055 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred); 5056 put_rpccred(setclientid.sc_cred); 5057 } 5058 rpc_put_task(task); 5059 out: 5060 trace_nfs4_setclientid(clp, status); 5061 dprintk("NFS reply setclientid: %d\n", status); 5062 return status; 5063 } 5064 5065 /** 5066 * nfs4_proc_setclientid_confirm - Confirm client ID 5067 * @clp: state data structure 5068 * @res: result of a previous SETCLIENTID 5069 * @cred: RPC credential to use for this call 5070 * 5071 * Returns zero, a negative errno, or a negative NFS4ERR status code. 5072 */ 5073 int nfs4_proc_setclientid_confirm(struct nfs_client *clp, 5074 struct nfs4_setclientid_res *arg, 5075 struct rpc_cred *cred) 5076 { 5077 struct rpc_message msg = { 5078 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], 5079 .rpc_argp = arg, 5080 .rpc_cred = cred, 5081 }; 5082 int status; 5083 5084 dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n", 5085 clp->cl_rpcclient->cl_auth->au_ops->au_name, 5086 clp->cl_clientid); 5087 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 5088 trace_nfs4_setclientid_confirm(clp, status); 5089 dprintk("NFS reply setclientid_confirm: %d\n", status); 5090 return status; 5091 } 5092 5093 struct nfs4_delegreturndata { 5094 struct nfs4_delegreturnargs args; 5095 struct nfs4_delegreturnres res; 5096 struct nfs_fh fh; 5097 nfs4_stateid stateid; 5098 unsigned long timestamp; 5099 struct nfs_fattr fattr; 5100 int rpc_status; 5101 struct inode *inode; 5102 bool roc; 5103 u32 roc_barrier; 5104 }; 5105 5106 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) 5107 { 5108 struct nfs4_delegreturndata *data = calldata; 5109 5110 if (!nfs4_sequence_done(task, &data->res.seq_res)) 5111 return; 5112 5113 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status); 5114 switch (task->tk_status) { 5115 case 0: 5116 renew_lease(data->res.server, data->timestamp); 5117 case -NFS4ERR_ADMIN_REVOKED: 5118 case -NFS4ERR_DELEG_REVOKED: 5119 case -NFS4ERR_BAD_STATEID: 5120 case -NFS4ERR_OLD_STATEID: 5121 case -NFS4ERR_STALE_STATEID: 5122 case -NFS4ERR_EXPIRED: 5123 task->tk_status = 0; 5124 if (data->roc) 5125 pnfs_roc_set_barrier(data->inode, data->roc_barrier); 5126 break; 5127 default: 5128 if (nfs4_async_handle_error(task, data->res.server, 5129 NULL, NULL) == -EAGAIN) { 5130 rpc_restart_call_prepare(task); 5131 return; 5132 } 5133 } 5134 data->rpc_status = task->tk_status; 5135 } 5136 5137 static void nfs4_delegreturn_release(void *calldata) 5138 { 5139 struct nfs4_delegreturndata *data = calldata; 5140 5141 if (data->roc) 5142 pnfs_roc_release(data->inode); 5143 kfree(calldata); 5144 } 5145 5146 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data) 5147 { 5148 struct nfs4_delegreturndata *d_data; 5149 5150 d_data = (struct nfs4_delegreturndata *)data; 5151 5152 if (d_data->roc && 5153 pnfs_roc_drain(d_data->inode, &d_data->roc_barrier, task)) 5154 return; 5155 5156 nfs4_setup_sequence(d_data->res.server, 5157 &d_data->args.seq_args, 5158 &d_data->res.seq_res, 5159 task); 5160 } 5161 5162 static const struct rpc_call_ops nfs4_delegreturn_ops = { 5163 .rpc_call_prepare = nfs4_delegreturn_prepare, 5164 .rpc_call_done = nfs4_delegreturn_done, 5165 .rpc_release = nfs4_delegreturn_release, 5166 }; 5167 5168 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 5169 { 5170 struct nfs4_delegreturndata *data; 5171 struct nfs_server *server = NFS_SERVER(inode); 5172 struct rpc_task *task; 5173 struct rpc_message msg = { 5174 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN], 5175 .rpc_cred = cred, 5176 }; 5177 struct rpc_task_setup task_setup_data = { 5178 .rpc_client = server->client, 5179 .rpc_message = &msg, 5180 .callback_ops = &nfs4_delegreturn_ops, 5181 .flags = RPC_TASK_ASYNC, 5182 }; 5183 int status = 0; 5184 5185 data = kzalloc(sizeof(*data), GFP_NOFS); 5186 if (data == NULL) 5187 return -ENOMEM; 5188 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1); 5189 data->args.fhandle = &data->fh; 5190 data->args.stateid = &data->stateid; 5191 data->args.bitmask = server->cache_consistency_bitmask; 5192 nfs_copy_fh(&data->fh, NFS_FH(inode)); 5193 nfs4_stateid_copy(&data->stateid, stateid); 5194 data->res.fattr = &data->fattr; 5195 data->res.server = server; 5196 nfs_fattr_init(data->res.fattr); 5197 data->timestamp = jiffies; 5198 data->rpc_status = 0; 5199 data->inode = inode; 5200 data->roc = list_empty(&NFS_I(inode)->open_files) ? 5201 pnfs_roc(inode) : false; 5202 5203 task_setup_data.callback_data = data; 5204 msg.rpc_argp = &data->args; 5205 msg.rpc_resp = &data->res; 5206 task = rpc_run_task(&task_setup_data); 5207 if (IS_ERR(task)) 5208 return PTR_ERR(task); 5209 if (!issync) 5210 goto out; 5211 status = nfs4_wait_for_completion_rpc_task(task); 5212 if (status != 0) 5213 goto out; 5214 status = data->rpc_status; 5215 if (status == 0) 5216 nfs_post_op_update_inode_force_wcc(inode, &data->fattr); 5217 else 5218 nfs_refresh_inode(inode, &data->fattr); 5219 out: 5220 rpc_put_task(task); 5221 return status; 5222 } 5223 5224 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 5225 { 5226 struct nfs_server *server = NFS_SERVER(inode); 5227 struct nfs4_exception exception = { }; 5228 int err; 5229 do { 5230 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync); 5231 trace_nfs4_delegreturn(inode, err); 5232 switch (err) { 5233 case -NFS4ERR_STALE_STATEID: 5234 case -NFS4ERR_EXPIRED: 5235 case 0: 5236 return 0; 5237 } 5238 err = nfs4_handle_exception(server, err, &exception); 5239 } while (exception.retry); 5240 return err; 5241 } 5242 5243 #define NFS4_LOCK_MINTIMEOUT (1 * HZ) 5244 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ) 5245 5246 /* 5247 * sleep, with exponential backoff, and retry the LOCK operation. 5248 */ 5249 static unsigned long 5250 nfs4_set_lock_task_retry(unsigned long timeout) 5251 { 5252 freezable_schedule_timeout_killable_unsafe(timeout); 5253 timeout <<= 1; 5254 if (timeout > NFS4_LOCK_MAXTIMEOUT) 5255 return NFS4_LOCK_MAXTIMEOUT; 5256 return timeout; 5257 } 5258 5259 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5260 { 5261 struct inode *inode = state->inode; 5262 struct nfs_server *server = NFS_SERVER(inode); 5263 struct nfs_client *clp = server->nfs_client; 5264 struct nfs_lockt_args arg = { 5265 .fh = NFS_FH(inode), 5266 .fl = request, 5267 }; 5268 struct nfs_lockt_res res = { 5269 .denied = request, 5270 }; 5271 struct rpc_message msg = { 5272 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT], 5273 .rpc_argp = &arg, 5274 .rpc_resp = &res, 5275 .rpc_cred = state->owner->so_cred, 5276 }; 5277 struct nfs4_lock_state *lsp; 5278 int status; 5279 5280 arg.lock_owner.clientid = clp->cl_clientid; 5281 status = nfs4_set_lock_state(state, request); 5282 if (status != 0) 5283 goto out; 5284 lsp = request->fl_u.nfs4_fl.owner; 5285 arg.lock_owner.id = lsp->ls_seqid.owner_id; 5286 arg.lock_owner.s_dev = server->s_dev; 5287 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 5288 switch (status) { 5289 case 0: 5290 request->fl_type = F_UNLCK; 5291 break; 5292 case -NFS4ERR_DENIED: 5293 status = 0; 5294 } 5295 request->fl_ops->fl_release_private(request); 5296 request->fl_ops = NULL; 5297 out: 5298 return status; 5299 } 5300 5301 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5302 { 5303 struct nfs4_exception exception = { }; 5304 int err; 5305 5306 do { 5307 err = _nfs4_proc_getlk(state, cmd, request); 5308 trace_nfs4_get_lock(request, state, cmd, err); 5309 err = nfs4_handle_exception(NFS_SERVER(state->inode), err, 5310 &exception); 5311 } while (exception.retry); 5312 return err; 5313 } 5314 5315 static int do_vfs_lock(struct file *file, struct file_lock *fl) 5316 { 5317 int res = 0; 5318 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 5319 case FL_POSIX: 5320 res = posix_lock_file_wait(file, fl); 5321 break; 5322 case FL_FLOCK: 5323 res = flock_lock_file_wait(file, fl); 5324 break; 5325 default: 5326 BUG(); 5327 } 5328 return res; 5329 } 5330 5331 struct nfs4_unlockdata { 5332 struct nfs_locku_args arg; 5333 struct nfs_locku_res res; 5334 struct nfs4_lock_state *lsp; 5335 struct nfs_open_context *ctx; 5336 struct file_lock fl; 5337 const struct nfs_server *server; 5338 unsigned long timestamp; 5339 }; 5340 5341 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, 5342 struct nfs_open_context *ctx, 5343 struct nfs4_lock_state *lsp, 5344 struct nfs_seqid *seqid) 5345 { 5346 struct nfs4_unlockdata *p; 5347 struct inode *inode = lsp->ls_state->inode; 5348 5349 p = kzalloc(sizeof(*p), GFP_NOFS); 5350 if (p == NULL) 5351 return NULL; 5352 p->arg.fh = NFS_FH(inode); 5353 p->arg.fl = &p->fl; 5354 p->arg.seqid = seqid; 5355 p->res.seqid = seqid; 5356 p->arg.stateid = &lsp->ls_stateid; 5357 p->lsp = lsp; 5358 atomic_inc(&lsp->ls_count); 5359 /* Ensure we don't close file until we're done freeing locks! */ 5360 p->ctx = get_nfs_open_context(ctx); 5361 memcpy(&p->fl, fl, sizeof(p->fl)); 5362 p->server = NFS_SERVER(inode); 5363 return p; 5364 } 5365 5366 static void nfs4_locku_release_calldata(void *data) 5367 { 5368 struct nfs4_unlockdata *calldata = data; 5369 nfs_free_seqid(calldata->arg.seqid); 5370 nfs4_put_lock_state(calldata->lsp); 5371 put_nfs_open_context(calldata->ctx); 5372 kfree(calldata); 5373 } 5374 5375 static void nfs4_locku_done(struct rpc_task *task, void *data) 5376 { 5377 struct nfs4_unlockdata *calldata = data; 5378 5379 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 5380 return; 5381 switch (task->tk_status) { 5382 case 0: 5383 nfs4_stateid_copy(&calldata->lsp->ls_stateid, 5384 &calldata->res.stateid); 5385 renew_lease(calldata->server, calldata->timestamp); 5386 break; 5387 case -NFS4ERR_BAD_STATEID: 5388 case -NFS4ERR_OLD_STATEID: 5389 case -NFS4ERR_STALE_STATEID: 5390 case -NFS4ERR_EXPIRED: 5391 break; 5392 default: 5393 if (nfs4_async_handle_error(task, calldata->server, 5394 NULL, NULL) == -EAGAIN) 5395 rpc_restart_call_prepare(task); 5396 } 5397 nfs_release_seqid(calldata->arg.seqid); 5398 } 5399 5400 static void nfs4_locku_prepare(struct rpc_task *task, void *data) 5401 { 5402 struct nfs4_unlockdata *calldata = data; 5403 5404 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 5405 goto out_wait; 5406 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) { 5407 /* Note: exit _without_ running nfs4_locku_done */ 5408 goto out_no_action; 5409 } 5410 calldata->timestamp = jiffies; 5411 if (nfs4_setup_sequence(calldata->server, 5412 &calldata->arg.seq_args, 5413 &calldata->res.seq_res, 5414 task) != 0) 5415 nfs_release_seqid(calldata->arg.seqid); 5416 return; 5417 out_no_action: 5418 task->tk_action = NULL; 5419 out_wait: 5420 nfs4_sequence_done(task, &calldata->res.seq_res); 5421 } 5422 5423 static const struct rpc_call_ops nfs4_locku_ops = { 5424 .rpc_call_prepare = nfs4_locku_prepare, 5425 .rpc_call_done = nfs4_locku_done, 5426 .rpc_release = nfs4_locku_release_calldata, 5427 }; 5428 5429 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 5430 struct nfs_open_context *ctx, 5431 struct nfs4_lock_state *lsp, 5432 struct nfs_seqid *seqid) 5433 { 5434 struct nfs4_unlockdata *data; 5435 struct rpc_message msg = { 5436 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU], 5437 .rpc_cred = ctx->cred, 5438 }; 5439 struct rpc_task_setup task_setup_data = { 5440 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), 5441 .rpc_message = &msg, 5442 .callback_ops = &nfs4_locku_ops, 5443 .workqueue = nfsiod_workqueue, 5444 .flags = RPC_TASK_ASYNC, 5445 }; 5446 5447 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client, 5448 NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg); 5449 5450 /* Ensure this is an unlock - when canceling a lock, the 5451 * canceled lock is passed in, and it won't be an unlock. 5452 */ 5453 fl->fl_type = F_UNLCK; 5454 5455 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); 5456 if (data == NULL) { 5457 nfs_free_seqid(seqid); 5458 return ERR_PTR(-ENOMEM); 5459 } 5460 5461 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1); 5462 msg.rpc_argp = &data->arg; 5463 msg.rpc_resp = &data->res; 5464 task_setup_data.callback_data = data; 5465 return rpc_run_task(&task_setup_data); 5466 } 5467 5468 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request) 5469 { 5470 struct inode *inode = state->inode; 5471 struct nfs4_state_owner *sp = state->owner; 5472 struct nfs_inode *nfsi = NFS_I(inode); 5473 struct nfs_seqid *seqid; 5474 struct nfs4_lock_state *lsp; 5475 struct rpc_task *task; 5476 int status = 0; 5477 unsigned char fl_flags = request->fl_flags; 5478 5479 status = nfs4_set_lock_state(state, request); 5480 /* Unlock _before_ we do the RPC call */ 5481 request->fl_flags |= FL_EXISTS; 5482 /* Exclude nfs_delegation_claim_locks() */ 5483 mutex_lock(&sp->so_delegreturn_mutex); 5484 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */ 5485 down_read(&nfsi->rwsem); 5486 if (do_vfs_lock(request->fl_file, request) == -ENOENT) { 5487 up_read(&nfsi->rwsem); 5488 mutex_unlock(&sp->so_delegreturn_mutex); 5489 goto out; 5490 } 5491 up_read(&nfsi->rwsem); 5492 mutex_unlock(&sp->so_delegreturn_mutex); 5493 if (status != 0) 5494 goto out; 5495 /* Is this a delegated lock? */ 5496 lsp = request->fl_u.nfs4_fl.owner; 5497 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0) 5498 goto out; 5499 seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL); 5500 status = -ENOMEM; 5501 if (seqid == NULL) 5502 goto out; 5503 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); 5504 status = PTR_ERR(task); 5505 if (IS_ERR(task)) 5506 goto out; 5507 status = nfs4_wait_for_completion_rpc_task(task); 5508 rpc_put_task(task); 5509 out: 5510 request->fl_flags = fl_flags; 5511 trace_nfs4_unlock(request, state, F_SETLK, status); 5512 return status; 5513 } 5514 5515 struct nfs4_lockdata { 5516 struct nfs_lock_args arg; 5517 struct nfs_lock_res res; 5518 struct nfs4_lock_state *lsp; 5519 struct nfs_open_context *ctx; 5520 struct file_lock fl; 5521 unsigned long timestamp; 5522 int rpc_status; 5523 int cancelled; 5524 struct nfs_server *server; 5525 }; 5526 5527 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, 5528 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp, 5529 gfp_t gfp_mask) 5530 { 5531 struct nfs4_lockdata *p; 5532 struct inode *inode = lsp->ls_state->inode; 5533 struct nfs_server *server = NFS_SERVER(inode); 5534 5535 p = kzalloc(sizeof(*p), gfp_mask); 5536 if (p == NULL) 5537 return NULL; 5538 5539 p->arg.fh = NFS_FH(inode); 5540 p->arg.fl = &p->fl; 5541 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask); 5542 if (p->arg.open_seqid == NULL) 5543 goto out_free; 5544 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask); 5545 if (p->arg.lock_seqid == NULL) 5546 goto out_free_seqid; 5547 p->arg.lock_stateid = &lsp->ls_stateid; 5548 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; 5549 p->arg.lock_owner.id = lsp->ls_seqid.owner_id; 5550 p->arg.lock_owner.s_dev = server->s_dev; 5551 p->res.lock_seqid = p->arg.lock_seqid; 5552 p->lsp = lsp; 5553 p->server = server; 5554 atomic_inc(&lsp->ls_count); 5555 p->ctx = get_nfs_open_context(ctx); 5556 memcpy(&p->fl, fl, sizeof(p->fl)); 5557 return p; 5558 out_free_seqid: 5559 nfs_free_seqid(p->arg.open_seqid); 5560 out_free: 5561 kfree(p); 5562 return NULL; 5563 } 5564 5565 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) 5566 { 5567 struct nfs4_lockdata *data = calldata; 5568 struct nfs4_state *state = data->lsp->ls_state; 5569 5570 dprintk("%s: begin!\n", __func__); 5571 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 5572 goto out_wait; 5573 /* Do we need to do an open_to_lock_owner? */ 5574 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) { 5575 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) { 5576 goto out_release_lock_seqid; 5577 } 5578 data->arg.open_stateid = &state->open_stateid; 5579 data->arg.new_lock_owner = 1; 5580 data->res.open_seqid = data->arg.open_seqid; 5581 } else 5582 data->arg.new_lock_owner = 0; 5583 if (!nfs4_valid_open_stateid(state)) { 5584 data->rpc_status = -EBADF; 5585 task->tk_action = NULL; 5586 goto out_release_open_seqid; 5587 } 5588 data->timestamp = jiffies; 5589 if (nfs4_setup_sequence(data->server, 5590 &data->arg.seq_args, 5591 &data->res.seq_res, 5592 task) == 0) 5593 return; 5594 out_release_open_seqid: 5595 nfs_release_seqid(data->arg.open_seqid); 5596 out_release_lock_seqid: 5597 nfs_release_seqid(data->arg.lock_seqid); 5598 out_wait: 5599 nfs4_sequence_done(task, &data->res.seq_res); 5600 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status); 5601 } 5602 5603 static void nfs4_lock_done(struct rpc_task *task, void *calldata) 5604 { 5605 struct nfs4_lockdata *data = calldata; 5606 5607 dprintk("%s: begin!\n", __func__); 5608 5609 if (!nfs4_sequence_done(task, &data->res.seq_res)) 5610 return; 5611 5612 data->rpc_status = task->tk_status; 5613 if (data->arg.new_lock_owner != 0) { 5614 if (data->rpc_status == 0) 5615 nfs_confirm_seqid(&data->lsp->ls_seqid, 0); 5616 else 5617 goto out; 5618 } 5619 if (data->rpc_status == 0) { 5620 nfs4_stateid_copy(&data->lsp->ls_stateid, &data->res.stateid); 5621 set_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags); 5622 renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp); 5623 } 5624 out: 5625 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status); 5626 } 5627 5628 static void nfs4_lock_release(void *calldata) 5629 { 5630 struct nfs4_lockdata *data = calldata; 5631 5632 dprintk("%s: begin!\n", __func__); 5633 nfs_free_seqid(data->arg.open_seqid); 5634 if (data->cancelled != 0) { 5635 struct rpc_task *task; 5636 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, 5637 data->arg.lock_seqid); 5638 if (!IS_ERR(task)) 5639 rpc_put_task_async(task); 5640 dprintk("%s: cancelling lock!\n", __func__); 5641 } else 5642 nfs_free_seqid(data->arg.lock_seqid); 5643 nfs4_put_lock_state(data->lsp); 5644 put_nfs_open_context(data->ctx); 5645 kfree(data); 5646 dprintk("%s: done!\n", __func__); 5647 } 5648 5649 static const struct rpc_call_ops nfs4_lock_ops = { 5650 .rpc_call_prepare = nfs4_lock_prepare, 5651 .rpc_call_done = nfs4_lock_done, 5652 .rpc_release = nfs4_lock_release, 5653 }; 5654 5655 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error) 5656 { 5657 switch (error) { 5658 case -NFS4ERR_ADMIN_REVOKED: 5659 case -NFS4ERR_BAD_STATEID: 5660 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 5661 if (new_lock_owner != 0 || 5662 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) 5663 nfs4_schedule_stateid_recovery(server, lsp->ls_state); 5664 break; 5665 case -NFS4ERR_STALE_STATEID: 5666 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 5667 case -NFS4ERR_EXPIRED: 5668 nfs4_schedule_lease_recovery(server->nfs_client); 5669 }; 5670 } 5671 5672 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type) 5673 { 5674 struct nfs4_lockdata *data; 5675 struct rpc_task *task; 5676 struct rpc_message msg = { 5677 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK], 5678 .rpc_cred = state->owner->so_cred, 5679 }; 5680 struct rpc_task_setup task_setup_data = { 5681 .rpc_client = NFS_CLIENT(state->inode), 5682 .rpc_message = &msg, 5683 .callback_ops = &nfs4_lock_ops, 5684 .workqueue = nfsiod_workqueue, 5685 .flags = RPC_TASK_ASYNC, 5686 }; 5687 int ret; 5688 5689 dprintk("%s: begin!\n", __func__); 5690 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), 5691 fl->fl_u.nfs4_fl.owner, 5692 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS); 5693 if (data == NULL) 5694 return -ENOMEM; 5695 if (IS_SETLKW(cmd)) 5696 data->arg.block = 1; 5697 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1); 5698 msg.rpc_argp = &data->arg; 5699 msg.rpc_resp = &data->res; 5700 task_setup_data.callback_data = data; 5701 if (recovery_type > NFS_LOCK_NEW) { 5702 if (recovery_type == NFS_LOCK_RECLAIM) 5703 data->arg.reclaim = NFS_LOCK_RECLAIM; 5704 nfs4_set_sequence_privileged(&data->arg.seq_args); 5705 } 5706 task = rpc_run_task(&task_setup_data); 5707 if (IS_ERR(task)) 5708 return PTR_ERR(task); 5709 ret = nfs4_wait_for_completion_rpc_task(task); 5710 if (ret == 0) { 5711 ret = data->rpc_status; 5712 if (ret) 5713 nfs4_handle_setlk_error(data->server, data->lsp, 5714 data->arg.new_lock_owner, ret); 5715 } else 5716 data->cancelled = 1; 5717 rpc_put_task(task); 5718 dprintk("%s: done, ret = %d!\n", __func__, ret); 5719 return ret; 5720 } 5721 5722 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request) 5723 { 5724 struct nfs_server *server = NFS_SERVER(state->inode); 5725 struct nfs4_exception exception = { 5726 .inode = state->inode, 5727 }; 5728 int err; 5729 5730 do { 5731 /* Cache the lock if possible... */ 5732 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 5733 return 0; 5734 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM); 5735 trace_nfs4_lock_reclaim(request, state, F_SETLK, err); 5736 if (err != -NFS4ERR_DELAY) 5737 break; 5738 nfs4_handle_exception(server, err, &exception); 5739 } while (exception.retry); 5740 return err; 5741 } 5742 5743 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request) 5744 { 5745 struct nfs_server *server = NFS_SERVER(state->inode); 5746 struct nfs4_exception exception = { 5747 .inode = state->inode, 5748 }; 5749 int err; 5750 5751 err = nfs4_set_lock_state(state, request); 5752 if (err != 0) 5753 return err; 5754 if (!recover_lost_locks) { 5755 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags); 5756 return 0; 5757 } 5758 do { 5759 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 5760 return 0; 5761 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED); 5762 trace_nfs4_lock_expired(request, state, F_SETLK, err); 5763 switch (err) { 5764 default: 5765 goto out; 5766 case -NFS4ERR_GRACE: 5767 case -NFS4ERR_DELAY: 5768 nfs4_handle_exception(server, err, &exception); 5769 err = 0; 5770 } 5771 } while (exception.retry); 5772 out: 5773 return err; 5774 } 5775 5776 #if defined(CONFIG_NFS_V4_1) 5777 /** 5778 * nfs41_check_expired_locks - possibly free a lock stateid 5779 * 5780 * @state: NFSv4 state for an inode 5781 * 5782 * Returns NFS_OK if recovery for this stateid is now finished. 5783 * Otherwise a negative NFS4ERR value is returned. 5784 */ 5785 static int nfs41_check_expired_locks(struct nfs4_state *state) 5786 { 5787 int status, ret = -NFS4ERR_BAD_STATEID; 5788 struct nfs4_lock_state *lsp; 5789 struct nfs_server *server = NFS_SERVER(state->inode); 5790 5791 list_for_each_entry(lsp, &state->lock_states, ls_locks) { 5792 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) { 5793 struct rpc_cred *cred = lsp->ls_state->owner->so_cred; 5794 5795 status = nfs41_test_stateid(server, 5796 &lsp->ls_stateid, 5797 cred); 5798 trace_nfs4_test_lock_stateid(state, lsp, status); 5799 if (status != NFS_OK) { 5800 /* Free the stateid unless the server 5801 * informs us the stateid is unrecognized. */ 5802 if (status != -NFS4ERR_BAD_STATEID) 5803 nfs41_free_stateid(server, 5804 &lsp->ls_stateid, 5805 cred); 5806 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); 5807 ret = status; 5808 } 5809 } 5810 }; 5811 5812 return ret; 5813 } 5814 5815 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request) 5816 { 5817 int status = NFS_OK; 5818 5819 if (test_bit(LK_STATE_IN_USE, &state->flags)) 5820 status = nfs41_check_expired_locks(state); 5821 if (status != NFS_OK) 5822 status = nfs4_lock_expired(state, request); 5823 return status; 5824 } 5825 #endif 5826 5827 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5828 { 5829 struct nfs4_state_owner *sp = state->owner; 5830 struct nfs_inode *nfsi = NFS_I(state->inode); 5831 unsigned char fl_flags = request->fl_flags; 5832 unsigned int seq; 5833 int status = -ENOLCK; 5834 5835 if ((fl_flags & FL_POSIX) && 5836 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) 5837 goto out; 5838 /* Is this a delegated open? */ 5839 status = nfs4_set_lock_state(state, request); 5840 if (status != 0) 5841 goto out; 5842 request->fl_flags |= FL_ACCESS; 5843 status = do_vfs_lock(request->fl_file, request); 5844 if (status < 0) 5845 goto out; 5846 down_read(&nfsi->rwsem); 5847 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 5848 /* Yes: cache locks! */ 5849 /* ...but avoid races with delegation recall... */ 5850 request->fl_flags = fl_flags & ~FL_SLEEP; 5851 status = do_vfs_lock(request->fl_file, request); 5852 goto out_unlock; 5853 } 5854 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 5855 up_read(&nfsi->rwsem); 5856 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW); 5857 if (status != 0) 5858 goto out; 5859 down_read(&nfsi->rwsem); 5860 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) { 5861 status = -NFS4ERR_DELAY; 5862 goto out_unlock; 5863 } 5864 /* Note: we always want to sleep here! */ 5865 request->fl_flags = fl_flags | FL_SLEEP; 5866 if (do_vfs_lock(request->fl_file, request) < 0) 5867 printk(KERN_WARNING "NFS: %s: VFS is out of sync with lock " 5868 "manager!\n", __func__); 5869 out_unlock: 5870 up_read(&nfsi->rwsem); 5871 out: 5872 request->fl_flags = fl_flags; 5873 return status; 5874 } 5875 5876 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 5877 { 5878 struct nfs4_exception exception = { 5879 .state = state, 5880 .inode = state->inode, 5881 }; 5882 int err; 5883 5884 do { 5885 err = _nfs4_proc_setlk(state, cmd, request); 5886 trace_nfs4_set_lock(request, state, cmd, err); 5887 if (err == -NFS4ERR_DENIED) 5888 err = -EAGAIN; 5889 err = nfs4_handle_exception(NFS_SERVER(state->inode), 5890 err, &exception); 5891 } while (exception.retry); 5892 return err; 5893 } 5894 5895 static int 5896 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) 5897 { 5898 struct nfs_open_context *ctx; 5899 struct nfs4_state *state; 5900 unsigned long timeout = NFS4_LOCK_MINTIMEOUT; 5901 int status; 5902 5903 /* verify open state */ 5904 ctx = nfs_file_open_context(filp); 5905 state = ctx->state; 5906 5907 if (request->fl_start < 0 || request->fl_end < 0) 5908 return -EINVAL; 5909 5910 if (IS_GETLK(cmd)) { 5911 if (state != NULL) 5912 return nfs4_proc_getlk(state, F_GETLK, request); 5913 return 0; 5914 } 5915 5916 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) 5917 return -EINVAL; 5918 5919 if (request->fl_type == F_UNLCK) { 5920 if (state != NULL) 5921 return nfs4_proc_unlck(state, cmd, request); 5922 return 0; 5923 } 5924 5925 if (state == NULL) 5926 return -ENOLCK; 5927 /* 5928 * Don't rely on the VFS having checked the file open mode, 5929 * since it won't do this for flock() locks. 5930 */ 5931 switch (request->fl_type) { 5932 case F_RDLCK: 5933 if (!(filp->f_mode & FMODE_READ)) 5934 return -EBADF; 5935 break; 5936 case F_WRLCK: 5937 if (!(filp->f_mode & FMODE_WRITE)) 5938 return -EBADF; 5939 } 5940 5941 do { 5942 status = nfs4_proc_setlk(state, cmd, request); 5943 if ((status != -EAGAIN) || IS_SETLK(cmd)) 5944 break; 5945 timeout = nfs4_set_lock_task_retry(timeout); 5946 status = -ERESTARTSYS; 5947 if (signalled()) 5948 break; 5949 } while(status < 0); 5950 return status; 5951 } 5952 5953 int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid) 5954 { 5955 struct nfs_server *server = NFS_SERVER(state->inode); 5956 int err; 5957 5958 err = nfs4_set_lock_state(state, fl); 5959 if (err != 0) 5960 return err; 5961 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); 5962 return nfs4_handle_delegation_recall_error(server, state, stateid, err); 5963 } 5964 5965 struct nfs_release_lockowner_data { 5966 struct nfs4_lock_state *lsp; 5967 struct nfs_server *server; 5968 struct nfs_release_lockowner_args args; 5969 struct nfs_release_lockowner_res res; 5970 unsigned long timestamp; 5971 }; 5972 5973 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata) 5974 { 5975 struct nfs_release_lockowner_data *data = calldata; 5976 struct nfs_server *server = data->server; 5977 nfs40_setup_sequence(server, &data->args.seq_args, 5978 &data->res.seq_res, task); 5979 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; 5980 data->timestamp = jiffies; 5981 } 5982 5983 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata) 5984 { 5985 struct nfs_release_lockowner_data *data = calldata; 5986 struct nfs_server *server = data->server; 5987 5988 nfs40_sequence_done(task, &data->res.seq_res); 5989 5990 switch (task->tk_status) { 5991 case 0: 5992 renew_lease(server, data->timestamp); 5993 break; 5994 case -NFS4ERR_STALE_CLIENTID: 5995 case -NFS4ERR_EXPIRED: 5996 nfs4_schedule_lease_recovery(server->nfs_client); 5997 break; 5998 case -NFS4ERR_LEASE_MOVED: 5999 case -NFS4ERR_DELAY: 6000 if (nfs4_async_handle_error(task, server, 6001 NULL, NULL) == -EAGAIN) 6002 rpc_restart_call_prepare(task); 6003 } 6004 } 6005 6006 static void nfs4_release_lockowner_release(void *calldata) 6007 { 6008 struct nfs_release_lockowner_data *data = calldata; 6009 nfs4_free_lock_state(data->server, data->lsp); 6010 kfree(calldata); 6011 } 6012 6013 static const struct rpc_call_ops nfs4_release_lockowner_ops = { 6014 .rpc_call_prepare = nfs4_release_lockowner_prepare, 6015 .rpc_call_done = nfs4_release_lockowner_done, 6016 .rpc_release = nfs4_release_lockowner_release, 6017 }; 6018 6019 static void 6020 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp) 6021 { 6022 struct nfs_release_lockowner_data *data; 6023 struct rpc_message msg = { 6024 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER], 6025 }; 6026 6027 if (server->nfs_client->cl_mvops->minor_version != 0) 6028 return; 6029 6030 data = kmalloc(sizeof(*data), GFP_NOFS); 6031 if (!data) 6032 return; 6033 data->lsp = lsp; 6034 data->server = server; 6035 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; 6036 data->args.lock_owner.id = lsp->ls_seqid.owner_id; 6037 data->args.lock_owner.s_dev = server->s_dev; 6038 6039 msg.rpc_argp = &data->args; 6040 msg.rpc_resp = &data->res; 6041 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0); 6042 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data); 6043 } 6044 6045 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl" 6046 6047 static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key, 6048 const void *buf, size_t buflen, 6049 int flags, int type) 6050 { 6051 if (strcmp(key, "") != 0) 6052 return -EINVAL; 6053 6054 return nfs4_proc_set_acl(dentry->d_inode, buf, buflen); 6055 } 6056 6057 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key, 6058 void *buf, size_t buflen, int type) 6059 { 6060 if (strcmp(key, "") != 0) 6061 return -EINVAL; 6062 6063 return nfs4_proc_get_acl(dentry->d_inode, buf, buflen); 6064 } 6065 6066 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list, 6067 size_t list_len, const char *name, 6068 size_t name_len, int type) 6069 { 6070 size_t len = sizeof(XATTR_NAME_NFSV4_ACL); 6071 6072 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 6073 return 0; 6074 6075 if (list && len <= list_len) 6076 memcpy(list, XATTR_NAME_NFSV4_ACL, len); 6077 return len; 6078 } 6079 6080 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 6081 static inline int nfs4_server_supports_labels(struct nfs_server *server) 6082 { 6083 return server->caps & NFS_CAP_SECURITY_LABEL; 6084 } 6085 6086 static int nfs4_xattr_set_nfs4_label(struct dentry *dentry, const char *key, 6087 const void *buf, size_t buflen, 6088 int flags, int type) 6089 { 6090 if (security_ismaclabel(key)) 6091 return nfs4_set_security_label(dentry, buf, buflen); 6092 6093 return -EOPNOTSUPP; 6094 } 6095 6096 static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key, 6097 void *buf, size_t buflen, int type) 6098 { 6099 if (security_ismaclabel(key)) 6100 return nfs4_get_security_label(dentry->d_inode, buf, buflen); 6101 return -EOPNOTSUPP; 6102 } 6103 6104 static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list, 6105 size_t list_len, const char *name, 6106 size_t name_len, int type) 6107 { 6108 size_t len = 0; 6109 6110 if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) { 6111 len = security_inode_listsecurity(dentry->d_inode, NULL, 0); 6112 if (list && len <= list_len) 6113 security_inode_listsecurity(dentry->d_inode, list, len); 6114 } 6115 return len; 6116 } 6117 6118 static const struct xattr_handler nfs4_xattr_nfs4_label_handler = { 6119 .prefix = XATTR_SECURITY_PREFIX, 6120 .list = nfs4_xattr_list_nfs4_label, 6121 .get = nfs4_xattr_get_nfs4_label, 6122 .set = nfs4_xattr_set_nfs4_label, 6123 }; 6124 #endif 6125 6126 6127 /* 6128 * nfs_fhget will use either the mounted_on_fileid or the fileid 6129 */ 6130 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr) 6131 { 6132 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) || 6133 (fattr->valid & NFS_ATTR_FATTR_FILEID)) && 6134 (fattr->valid & NFS_ATTR_FATTR_FSID) && 6135 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS))) 6136 return; 6137 6138 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 6139 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL; 6140 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 6141 fattr->nlink = 2; 6142 } 6143 6144 static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir, 6145 const struct qstr *name, 6146 struct nfs4_fs_locations *fs_locations, 6147 struct page *page) 6148 { 6149 struct nfs_server *server = NFS_SERVER(dir); 6150 u32 bitmask[3] = { 6151 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 6152 }; 6153 struct nfs4_fs_locations_arg args = { 6154 .dir_fh = NFS_FH(dir), 6155 .name = name, 6156 .page = page, 6157 .bitmask = bitmask, 6158 }; 6159 struct nfs4_fs_locations_res res = { 6160 .fs_locations = fs_locations, 6161 }; 6162 struct rpc_message msg = { 6163 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 6164 .rpc_argp = &args, 6165 .rpc_resp = &res, 6166 }; 6167 int status; 6168 6169 dprintk("%s: start\n", __func__); 6170 6171 /* Ask for the fileid of the absent filesystem if mounted_on_fileid 6172 * is not supported */ 6173 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) 6174 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID; 6175 else 6176 bitmask[0] |= FATTR4_WORD0_FILEID; 6177 6178 nfs_fattr_init(&fs_locations->fattr); 6179 fs_locations->server = server; 6180 fs_locations->nlocations = 0; 6181 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0); 6182 dprintk("%s: returned status = %d\n", __func__, status); 6183 return status; 6184 } 6185 6186 int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir, 6187 const struct qstr *name, 6188 struct nfs4_fs_locations *fs_locations, 6189 struct page *page) 6190 { 6191 struct nfs4_exception exception = { }; 6192 int err; 6193 do { 6194 err = _nfs4_proc_fs_locations(client, dir, name, 6195 fs_locations, page); 6196 trace_nfs4_get_fs_locations(dir, name, err); 6197 err = nfs4_handle_exception(NFS_SERVER(dir), err, 6198 &exception); 6199 } while (exception.retry); 6200 return err; 6201 } 6202 6203 /* 6204 * This operation also signals the server that this client is 6205 * performing migration recovery. The server can stop returning 6206 * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is 6207 * appended to this compound to identify the client ID which is 6208 * performing recovery. 6209 */ 6210 static int _nfs40_proc_get_locations(struct inode *inode, 6211 struct nfs4_fs_locations *locations, 6212 struct page *page, struct rpc_cred *cred) 6213 { 6214 struct nfs_server *server = NFS_SERVER(inode); 6215 struct rpc_clnt *clnt = server->client; 6216 u32 bitmask[2] = { 6217 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 6218 }; 6219 struct nfs4_fs_locations_arg args = { 6220 .clientid = server->nfs_client->cl_clientid, 6221 .fh = NFS_FH(inode), 6222 .page = page, 6223 .bitmask = bitmask, 6224 .migration = 1, /* skip LOOKUP */ 6225 .renew = 1, /* append RENEW */ 6226 }; 6227 struct nfs4_fs_locations_res res = { 6228 .fs_locations = locations, 6229 .migration = 1, 6230 .renew = 1, 6231 }; 6232 struct rpc_message msg = { 6233 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 6234 .rpc_argp = &args, 6235 .rpc_resp = &res, 6236 .rpc_cred = cred, 6237 }; 6238 unsigned long now = jiffies; 6239 int status; 6240 6241 nfs_fattr_init(&locations->fattr); 6242 locations->server = server; 6243 locations->nlocations = 0; 6244 6245 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6246 nfs4_set_sequence_privileged(&args.seq_args); 6247 status = nfs4_call_sync_sequence(clnt, server, &msg, 6248 &args.seq_args, &res.seq_res); 6249 if (status) 6250 return status; 6251 6252 renew_lease(server, now); 6253 return 0; 6254 } 6255 6256 #ifdef CONFIG_NFS_V4_1 6257 6258 /* 6259 * This operation also signals the server that this client is 6260 * performing migration recovery. The server can stop asserting 6261 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID 6262 * performing this operation is identified in the SEQUENCE 6263 * operation in this compound. 6264 * 6265 * When the client supports GETATTR(fs_locations_info), it can 6266 * be plumbed in here. 6267 */ 6268 static int _nfs41_proc_get_locations(struct inode *inode, 6269 struct nfs4_fs_locations *locations, 6270 struct page *page, struct rpc_cred *cred) 6271 { 6272 struct nfs_server *server = NFS_SERVER(inode); 6273 struct rpc_clnt *clnt = server->client; 6274 u32 bitmask[2] = { 6275 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 6276 }; 6277 struct nfs4_fs_locations_arg args = { 6278 .fh = NFS_FH(inode), 6279 .page = page, 6280 .bitmask = bitmask, 6281 .migration = 1, /* skip LOOKUP */ 6282 }; 6283 struct nfs4_fs_locations_res res = { 6284 .fs_locations = locations, 6285 .migration = 1, 6286 }; 6287 struct rpc_message msg = { 6288 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 6289 .rpc_argp = &args, 6290 .rpc_resp = &res, 6291 .rpc_cred = cred, 6292 }; 6293 int status; 6294 6295 nfs_fattr_init(&locations->fattr); 6296 locations->server = server; 6297 locations->nlocations = 0; 6298 6299 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6300 nfs4_set_sequence_privileged(&args.seq_args); 6301 status = nfs4_call_sync_sequence(clnt, server, &msg, 6302 &args.seq_args, &res.seq_res); 6303 if (status == NFS4_OK && 6304 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED) 6305 status = -NFS4ERR_LEASE_MOVED; 6306 return status; 6307 } 6308 6309 #endif /* CONFIG_NFS_V4_1 */ 6310 6311 /** 6312 * nfs4_proc_get_locations - discover locations for a migrated FSID 6313 * @inode: inode on FSID that is migrating 6314 * @locations: result of query 6315 * @page: buffer 6316 * @cred: credential to use for this operation 6317 * 6318 * Returns NFS4_OK on success, a negative NFS4ERR status code if the 6319 * operation failed, or a negative errno if a local error occurred. 6320 * 6321 * On success, "locations" is filled in, but if the server has 6322 * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not 6323 * asserted. 6324 * 6325 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases 6326 * from this client that require migration recovery. 6327 */ 6328 int nfs4_proc_get_locations(struct inode *inode, 6329 struct nfs4_fs_locations *locations, 6330 struct page *page, struct rpc_cred *cred) 6331 { 6332 struct nfs_server *server = NFS_SERVER(inode); 6333 struct nfs_client *clp = server->nfs_client; 6334 const struct nfs4_mig_recovery_ops *ops = 6335 clp->cl_mvops->mig_recovery_ops; 6336 struct nfs4_exception exception = { }; 6337 int status; 6338 6339 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__, 6340 (unsigned long long)server->fsid.major, 6341 (unsigned long long)server->fsid.minor, 6342 clp->cl_hostname); 6343 nfs_display_fhandle(NFS_FH(inode), __func__); 6344 6345 do { 6346 status = ops->get_locations(inode, locations, page, cred); 6347 if (status != -NFS4ERR_DELAY) 6348 break; 6349 nfs4_handle_exception(server, status, &exception); 6350 } while (exception.retry); 6351 return status; 6352 } 6353 6354 /* 6355 * This operation also signals the server that this client is 6356 * performing "lease moved" recovery. The server can stop 6357 * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation 6358 * is appended to this compound to identify the client ID which is 6359 * performing recovery. 6360 */ 6361 static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) 6362 { 6363 struct nfs_server *server = NFS_SERVER(inode); 6364 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; 6365 struct rpc_clnt *clnt = server->client; 6366 struct nfs4_fsid_present_arg args = { 6367 .fh = NFS_FH(inode), 6368 .clientid = clp->cl_clientid, 6369 .renew = 1, /* append RENEW */ 6370 }; 6371 struct nfs4_fsid_present_res res = { 6372 .renew = 1, 6373 }; 6374 struct rpc_message msg = { 6375 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT], 6376 .rpc_argp = &args, 6377 .rpc_resp = &res, 6378 .rpc_cred = cred, 6379 }; 6380 unsigned long now = jiffies; 6381 int status; 6382 6383 res.fh = nfs_alloc_fhandle(); 6384 if (res.fh == NULL) 6385 return -ENOMEM; 6386 6387 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6388 nfs4_set_sequence_privileged(&args.seq_args); 6389 status = nfs4_call_sync_sequence(clnt, server, &msg, 6390 &args.seq_args, &res.seq_res); 6391 nfs_free_fhandle(res.fh); 6392 if (status) 6393 return status; 6394 6395 do_renew_lease(clp, now); 6396 return 0; 6397 } 6398 6399 #ifdef CONFIG_NFS_V4_1 6400 6401 /* 6402 * This operation also signals the server that this client is 6403 * performing "lease moved" recovery. The server can stop asserting 6404 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing 6405 * this operation is identified in the SEQUENCE operation in this 6406 * compound. 6407 */ 6408 static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) 6409 { 6410 struct nfs_server *server = NFS_SERVER(inode); 6411 struct rpc_clnt *clnt = server->client; 6412 struct nfs4_fsid_present_arg args = { 6413 .fh = NFS_FH(inode), 6414 }; 6415 struct nfs4_fsid_present_res res = { 6416 }; 6417 struct rpc_message msg = { 6418 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT], 6419 .rpc_argp = &args, 6420 .rpc_resp = &res, 6421 .rpc_cred = cred, 6422 }; 6423 int status; 6424 6425 res.fh = nfs_alloc_fhandle(); 6426 if (res.fh == NULL) 6427 return -ENOMEM; 6428 6429 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 6430 nfs4_set_sequence_privileged(&args.seq_args); 6431 status = nfs4_call_sync_sequence(clnt, server, &msg, 6432 &args.seq_args, &res.seq_res); 6433 nfs_free_fhandle(res.fh); 6434 if (status == NFS4_OK && 6435 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED) 6436 status = -NFS4ERR_LEASE_MOVED; 6437 return status; 6438 } 6439 6440 #endif /* CONFIG_NFS_V4_1 */ 6441 6442 /** 6443 * nfs4_proc_fsid_present - Is this FSID present or absent on server? 6444 * @inode: inode on FSID to check 6445 * @cred: credential to use for this operation 6446 * 6447 * Server indicates whether the FSID is present, moved, or not 6448 * recognized. This operation is necessary to clear a LEASE_MOVED 6449 * condition for this client ID. 6450 * 6451 * Returns NFS4_OK if the FSID is present on this server, 6452 * -NFS4ERR_MOVED if the FSID is no longer present, a negative 6453 * NFS4ERR code if some error occurred on the server, or a 6454 * negative errno if a local failure occurred. 6455 */ 6456 int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred) 6457 { 6458 struct nfs_server *server = NFS_SERVER(inode); 6459 struct nfs_client *clp = server->nfs_client; 6460 const struct nfs4_mig_recovery_ops *ops = 6461 clp->cl_mvops->mig_recovery_ops; 6462 struct nfs4_exception exception = { }; 6463 int status; 6464 6465 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__, 6466 (unsigned long long)server->fsid.major, 6467 (unsigned long long)server->fsid.minor, 6468 clp->cl_hostname); 6469 nfs_display_fhandle(NFS_FH(inode), __func__); 6470 6471 do { 6472 status = ops->fsid_present(inode, cred); 6473 if (status != -NFS4ERR_DELAY) 6474 break; 6475 nfs4_handle_exception(server, status, &exception); 6476 } while (exception.retry); 6477 return status; 6478 } 6479 6480 /** 6481 * If 'use_integrity' is true and the state managment nfs_client 6482 * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient 6483 * and the machine credential as per RFC3530bis and RFC5661 Security 6484 * Considerations sections. Otherwise, just use the user cred with the 6485 * filesystem's rpc_client. 6486 */ 6487 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity) 6488 { 6489 int status; 6490 struct nfs4_secinfo_arg args = { 6491 .dir_fh = NFS_FH(dir), 6492 .name = name, 6493 }; 6494 struct nfs4_secinfo_res res = { 6495 .flavors = flavors, 6496 }; 6497 struct rpc_message msg = { 6498 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO], 6499 .rpc_argp = &args, 6500 .rpc_resp = &res, 6501 }; 6502 struct rpc_clnt *clnt = NFS_SERVER(dir)->client; 6503 struct rpc_cred *cred = NULL; 6504 6505 if (use_integrity) { 6506 clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient; 6507 cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client); 6508 msg.rpc_cred = cred; 6509 } 6510 6511 dprintk("NFS call secinfo %s\n", name->name); 6512 6513 nfs4_state_protect(NFS_SERVER(dir)->nfs_client, 6514 NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg); 6515 6516 status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args, 6517 &res.seq_res, 0); 6518 dprintk("NFS reply secinfo: %d\n", status); 6519 6520 if (cred) 6521 put_rpccred(cred); 6522 6523 return status; 6524 } 6525 6526 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, 6527 struct nfs4_secinfo_flavors *flavors) 6528 { 6529 struct nfs4_exception exception = { }; 6530 int err; 6531 do { 6532 err = -NFS4ERR_WRONGSEC; 6533 6534 /* try to use integrity protection with machine cred */ 6535 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client)) 6536 err = _nfs4_proc_secinfo(dir, name, flavors, true); 6537 6538 /* 6539 * if unable to use integrity protection, or SECINFO with 6540 * integrity protection returns NFS4ERR_WRONGSEC (which is 6541 * disallowed by spec, but exists in deployed servers) use 6542 * the current filesystem's rpc_client and the user cred. 6543 */ 6544 if (err == -NFS4ERR_WRONGSEC) 6545 err = _nfs4_proc_secinfo(dir, name, flavors, false); 6546 6547 trace_nfs4_secinfo(dir, name, err); 6548 err = nfs4_handle_exception(NFS_SERVER(dir), err, 6549 &exception); 6550 } while (exception.retry); 6551 return err; 6552 } 6553 6554 #ifdef CONFIG_NFS_V4_1 6555 /* 6556 * Check the exchange flags returned by the server for invalid flags, having 6557 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or 6558 * DS flags set. 6559 */ 6560 static int nfs4_check_cl_exchange_flags(u32 flags) 6561 { 6562 if (flags & ~EXCHGID4_FLAG_MASK_R) 6563 goto out_inval; 6564 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) && 6565 (flags & EXCHGID4_FLAG_USE_NON_PNFS)) 6566 goto out_inval; 6567 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS))) 6568 goto out_inval; 6569 return NFS_OK; 6570 out_inval: 6571 return -NFS4ERR_INVAL; 6572 } 6573 6574 static bool 6575 nfs41_same_server_scope(struct nfs41_server_scope *a, 6576 struct nfs41_server_scope *b) 6577 { 6578 if (a->server_scope_sz == b->server_scope_sz && 6579 memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0) 6580 return true; 6581 6582 return false; 6583 } 6584 6585 /* 6586 * nfs4_proc_bind_conn_to_session() 6587 * 6588 * The 4.1 client currently uses the same TCP connection for the 6589 * fore and backchannel. 6590 */ 6591 int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred) 6592 { 6593 int status; 6594 struct nfs41_bind_conn_to_session_res res; 6595 struct rpc_message msg = { 6596 .rpc_proc = 6597 &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION], 6598 .rpc_argp = clp, 6599 .rpc_resp = &res, 6600 .rpc_cred = cred, 6601 }; 6602 6603 dprintk("--> %s\n", __func__); 6604 6605 res.session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS); 6606 if (unlikely(res.session == NULL)) { 6607 status = -ENOMEM; 6608 goto out; 6609 } 6610 6611 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 6612 trace_nfs4_bind_conn_to_session(clp, status); 6613 if (status == 0) { 6614 if (memcmp(res.session->sess_id.data, 6615 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) { 6616 dprintk("NFS: %s: Session ID mismatch\n", __func__); 6617 status = -EIO; 6618 goto out_session; 6619 } 6620 if (res.dir != NFS4_CDFS4_BOTH) { 6621 dprintk("NFS: %s: Unexpected direction from server\n", 6622 __func__); 6623 status = -EIO; 6624 goto out_session; 6625 } 6626 if (res.use_conn_in_rdma_mode) { 6627 dprintk("NFS: %s: Server returned RDMA mode = true\n", 6628 __func__); 6629 status = -EIO; 6630 goto out_session; 6631 } 6632 } 6633 out_session: 6634 kfree(res.session); 6635 out: 6636 dprintk("<-- %s status= %d\n", __func__, status); 6637 return status; 6638 } 6639 6640 /* 6641 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map 6642 * and operations we'd like to see to enable certain features in the allow map 6643 */ 6644 static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = { 6645 .how = SP4_MACH_CRED, 6646 .enforce.u.words = { 6647 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | 6648 1 << (OP_EXCHANGE_ID - 32) | 6649 1 << (OP_CREATE_SESSION - 32) | 6650 1 << (OP_DESTROY_SESSION - 32) | 6651 1 << (OP_DESTROY_CLIENTID - 32) 6652 }, 6653 .allow.u.words = { 6654 [0] = 1 << (OP_CLOSE) | 6655 1 << (OP_LOCKU) | 6656 1 << (OP_COMMIT), 6657 [1] = 1 << (OP_SECINFO - 32) | 6658 1 << (OP_SECINFO_NO_NAME - 32) | 6659 1 << (OP_TEST_STATEID - 32) | 6660 1 << (OP_FREE_STATEID - 32) | 6661 1 << (OP_WRITE - 32) 6662 } 6663 }; 6664 6665 /* 6666 * Select the state protection mode for client `clp' given the server results 6667 * from exchange_id in `sp'. 6668 * 6669 * Returns 0 on success, negative errno otherwise. 6670 */ 6671 static int nfs4_sp4_select_mode(struct nfs_client *clp, 6672 struct nfs41_state_protection *sp) 6673 { 6674 static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = { 6675 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | 6676 1 << (OP_EXCHANGE_ID - 32) | 6677 1 << (OP_CREATE_SESSION - 32) | 6678 1 << (OP_DESTROY_SESSION - 32) | 6679 1 << (OP_DESTROY_CLIENTID - 32) 6680 }; 6681 unsigned int i; 6682 6683 if (sp->how == SP4_MACH_CRED) { 6684 /* Print state protect result */ 6685 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n"); 6686 for (i = 0; i <= LAST_NFS4_OP; i++) { 6687 if (test_bit(i, sp->enforce.u.longs)) 6688 dfprintk(MOUNT, " enforce op %d\n", i); 6689 if (test_bit(i, sp->allow.u.longs)) 6690 dfprintk(MOUNT, " allow op %d\n", i); 6691 } 6692 6693 /* make sure nothing is on enforce list that isn't supported */ 6694 for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) { 6695 if (sp->enforce.u.words[i] & ~supported_enforce[i]) { 6696 dfprintk(MOUNT, "sp4_mach_cred: disabled\n"); 6697 return -EINVAL; 6698 } 6699 } 6700 6701 /* 6702 * Minimal mode - state operations are allowed to use machine 6703 * credential. Note this already happens by default, so the 6704 * client doesn't have to do anything more than the negotiation. 6705 * 6706 * NOTE: we don't care if EXCHANGE_ID is in the list - 6707 * we're already using the machine cred for exchange_id 6708 * and will never use a different cred. 6709 */ 6710 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) && 6711 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) && 6712 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) && 6713 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) { 6714 dfprintk(MOUNT, "sp4_mach_cred:\n"); 6715 dfprintk(MOUNT, " minimal mode enabled\n"); 6716 set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags); 6717 } else { 6718 dfprintk(MOUNT, "sp4_mach_cred: disabled\n"); 6719 return -EINVAL; 6720 } 6721 6722 if (test_bit(OP_CLOSE, sp->allow.u.longs) && 6723 test_bit(OP_LOCKU, sp->allow.u.longs)) { 6724 dfprintk(MOUNT, " cleanup mode enabled\n"); 6725 set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags); 6726 } 6727 6728 if (test_bit(OP_SECINFO, sp->allow.u.longs) && 6729 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) { 6730 dfprintk(MOUNT, " secinfo mode enabled\n"); 6731 set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags); 6732 } 6733 6734 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) && 6735 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) { 6736 dfprintk(MOUNT, " stateid mode enabled\n"); 6737 set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags); 6738 } 6739 6740 if (test_bit(OP_WRITE, sp->allow.u.longs)) { 6741 dfprintk(MOUNT, " write mode enabled\n"); 6742 set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags); 6743 } 6744 6745 if (test_bit(OP_COMMIT, sp->allow.u.longs)) { 6746 dfprintk(MOUNT, " commit mode enabled\n"); 6747 set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags); 6748 } 6749 } 6750 6751 return 0; 6752 } 6753 6754 /* 6755 * _nfs4_proc_exchange_id() 6756 * 6757 * Wrapper for EXCHANGE_ID operation. 6758 */ 6759 static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred, 6760 u32 sp4_how) 6761 { 6762 nfs4_verifier verifier; 6763 struct nfs41_exchange_id_args args = { 6764 .verifier = &verifier, 6765 .client = clp, 6766 #ifdef CONFIG_NFS_V4_1_MIGRATION 6767 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER | 6768 EXCHGID4_FLAG_BIND_PRINC_STATEID | 6769 EXCHGID4_FLAG_SUPP_MOVED_MIGR, 6770 #else 6771 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER | 6772 EXCHGID4_FLAG_BIND_PRINC_STATEID, 6773 #endif 6774 }; 6775 struct nfs41_exchange_id_res res = { 6776 0 6777 }; 6778 int status; 6779 struct rpc_message msg = { 6780 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID], 6781 .rpc_argp = &args, 6782 .rpc_resp = &res, 6783 .rpc_cred = cred, 6784 }; 6785 6786 nfs4_init_boot_verifier(clp, &verifier); 6787 args.id_len = nfs4_init_uniform_client_string(clp, args.id, 6788 sizeof(args.id)); 6789 dprintk("NFS call exchange_id auth=%s, '%.*s'\n", 6790 clp->cl_rpcclient->cl_auth->au_ops->au_name, 6791 args.id_len, args.id); 6792 6793 res.server_owner = kzalloc(sizeof(struct nfs41_server_owner), 6794 GFP_NOFS); 6795 if (unlikely(res.server_owner == NULL)) { 6796 status = -ENOMEM; 6797 goto out; 6798 } 6799 6800 res.server_scope = kzalloc(sizeof(struct nfs41_server_scope), 6801 GFP_NOFS); 6802 if (unlikely(res.server_scope == NULL)) { 6803 status = -ENOMEM; 6804 goto out_server_owner; 6805 } 6806 6807 res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS); 6808 if (unlikely(res.impl_id == NULL)) { 6809 status = -ENOMEM; 6810 goto out_server_scope; 6811 } 6812 6813 switch (sp4_how) { 6814 case SP4_NONE: 6815 args.state_protect.how = SP4_NONE; 6816 break; 6817 6818 case SP4_MACH_CRED: 6819 args.state_protect = nfs4_sp4_mach_cred_request; 6820 break; 6821 6822 default: 6823 /* unsupported! */ 6824 WARN_ON_ONCE(1); 6825 status = -EINVAL; 6826 goto out_server_scope; 6827 } 6828 6829 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 6830 trace_nfs4_exchange_id(clp, status); 6831 if (status == 0) 6832 status = nfs4_check_cl_exchange_flags(res.flags); 6833 6834 if (status == 0) 6835 status = nfs4_sp4_select_mode(clp, &res.state_protect); 6836 6837 if (status == 0) { 6838 clp->cl_clientid = res.clientid; 6839 clp->cl_exchange_flags = (res.flags & ~EXCHGID4_FLAG_CONFIRMED_R); 6840 if (!(res.flags & EXCHGID4_FLAG_CONFIRMED_R)) 6841 clp->cl_seqid = res.seqid; 6842 6843 kfree(clp->cl_serverowner); 6844 clp->cl_serverowner = res.server_owner; 6845 res.server_owner = NULL; 6846 6847 /* use the most recent implementation id */ 6848 kfree(clp->cl_implid); 6849 clp->cl_implid = res.impl_id; 6850 6851 if (clp->cl_serverscope != NULL && 6852 !nfs41_same_server_scope(clp->cl_serverscope, 6853 res.server_scope)) { 6854 dprintk("%s: server_scope mismatch detected\n", 6855 __func__); 6856 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state); 6857 kfree(clp->cl_serverscope); 6858 clp->cl_serverscope = NULL; 6859 } 6860 6861 if (clp->cl_serverscope == NULL) { 6862 clp->cl_serverscope = res.server_scope; 6863 goto out; 6864 } 6865 } else 6866 kfree(res.impl_id); 6867 6868 out_server_owner: 6869 kfree(res.server_owner); 6870 out_server_scope: 6871 kfree(res.server_scope); 6872 out: 6873 if (clp->cl_implid != NULL) 6874 dprintk("NFS reply exchange_id: Server Implementation ID: " 6875 "domain: %s, name: %s, date: %llu,%u\n", 6876 clp->cl_implid->domain, clp->cl_implid->name, 6877 clp->cl_implid->date.seconds, 6878 clp->cl_implid->date.nseconds); 6879 dprintk("NFS reply exchange_id: %d\n", status); 6880 return status; 6881 } 6882 6883 /* 6884 * nfs4_proc_exchange_id() 6885 * 6886 * Returns zero, a negative errno, or a negative NFS4ERR status code. 6887 * 6888 * Since the clientid has expired, all compounds using sessions 6889 * associated with the stale clientid will be returning 6890 * NFS4ERR_BADSESSION in the sequence operation, and will therefore 6891 * be in some phase of session reset. 6892 * 6893 * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used. 6894 */ 6895 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred) 6896 { 6897 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor; 6898 int status; 6899 6900 /* try SP4_MACH_CRED if krb5i/p */ 6901 if (authflavor == RPC_AUTH_GSS_KRB5I || 6902 authflavor == RPC_AUTH_GSS_KRB5P) { 6903 status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED); 6904 if (!status) 6905 return 0; 6906 } 6907 6908 /* try SP4_NONE */ 6909 return _nfs4_proc_exchange_id(clp, cred, SP4_NONE); 6910 } 6911 6912 static int _nfs4_proc_destroy_clientid(struct nfs_client *clp, 6913 struct rpc_cred *cred) 6914 { 6915 struct rpc_message msg = { 6916 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID], 6917 .rpc_argp = clp, 6918 .rpc_cred = cred, 6919 }; 6920 int status; 6921 6922 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 6923 trace_nfs4_destroy_clientid(clp, status); 6924 if (status) 6925 dprintk("NFS: Got error %d from the server %s on " 6926 "DESTROY_CLIENTID.", status, clp->cl_hostname); 6927 return status; 6928 } 6929 6930 static int nfs4_proc_destroy_clientid(struct nfs_client *clp, 6931 struct rpc_cred *cred) 6932 { 6933 unsigned int loop; 6934 int ret; 6935 6936 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { 6937 ret = _nfs4_proc_destroy_clientid(clp, cred); 6938 switch (ret) { 6939 case -NFS4ERR_DELAY: 6940 case -NFS4ERR_CLIENTID_BUSY: 6941 ssleep(1); 6942 break; 6943 default: 6944 return ret; 6945 } 6946 } 6947 return 0; 6948 } 6949 6950 int nfs4_destroy_clientid(struct nfs_client *clp) 6951 { 6952 struct rpc_cred *cred; 6953 int ret = 0; 6954 6955 if (clp->cl_mvops->minor_version < 1) 6956 goto out; 6957 if (clp->cl_exchange_flags == 0) 6958 goto out; 6959 if (clp->cl_preserve_clid) 6960 goto out; 6961 cred = nfs4_get_clid_cred(clp); 6962 ret = nfs4_proc_destroy_clientid(clp, cred); 6963 if (cred) 6964 put_rpccred(cred); 6965 switch (ret) { 6966 case 0: 6967 case -NFS4ERR_STALE_CLIENTID: 6968 clp->cl_exchange_flags = 0; 6969 } 6970 out: 6971 return ret; 6972 } 6973 6974 struct nfs4_get_lease_time_data { 6975 struct nfs4_get_lease_time_args *args; 6976 struct nfs4_get_lease_time_res *res; 6977 struct nfs_client *clp; 6978 }; 6979 6980 static void nfs4_get_lease_time_prepare(struct rpc_task *task, 6981 void *calldata) 6982 { 6983 struct nfs4_get_lease_time_data *data = 6984 (struct nfs4_get_lease_time_data *)calldata; 6985 6986 dprintk("--> %s\n", __func__); 6987 /* just setup sequence, do not trigger session recovery 6988 since we're invoked within one */ 6989 nfs41_setup_sequence(data->clp->cl_session, 6990 &data->args->la_seq_args, 6991 &data->res->lr_seq_res, 6992 task); 6993 dprintk("<-- %s\n", __func__); 6994 } 6995 6996 /* 6997 * Called from nfs4_state_manager thread for session setup, so don't recover 6998 * from sequence operation or clientid errors. 6999 */ 7000 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata) 7001 { 7002 struct nfs4_get_lease_time_data *data = 7003 (struct nfs4_get_lease_time_data *)calldata; 7004 7005 dprintk("--> %s\n", __func__); 7006 if (!nfs41_sequence_done(task, &data->res->lr_seq_res)) 7007 return; 7008 switch (task->tk_status) { 7009 case -NFS4ERR_DELAY: 7010 case -NFS4ERR_GRACE: 7011 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status); 7012 rpc_delay(task, NFS4_POLL_RETRY_MIN); 7013 task->tk_status = 0; 7014 /* fall through */ 7015 case -NFS4ERR_RETRY_UNCACHED_REP: 7016 rpc_restart_call_prepare(task); 7017 return; 7018 } 7019 dprintk("<-- %s\n", __func__); 7020 } 7021 7022 static const struct rpc_call_ops nfs4_get_lease_time_ops = { 7023 .rpc_call_prepare = nfs4_get_lease_time_prepare, 7024 .rpc_call_done = nfs4_get_lease_time_done, 7025 }; 7026 7027 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo) 7028 { 7029 struct rpc_task *task; 7030 struct nfs4_get_lease_time_args args; 7031 struct nfs4_get_lease_time_res res = { 7032 .lr_fsinfo = fsinfo, 7033 }; 7034 struct nfs4_get_lease_time_data data = { 7035 .args = &args, 7036 .res = &res, 7037 .clp = clp, 7038 }; 7039 struct rpc_message msg = { 7040 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME], 7041 .rpc_argp = &args, 7042 .rpc_resp = &res, 7043 }; 7044 struct rpc_task_setup task_setup = { 7045 .rpc_client = clp->cl_rpcclient, 7046 .rpc_message = &msg, 7047 .callback_ops = &nfs4_get_lease_time_ops, 7048 .callback_data = &data, 7049 .flags = RPC_TASK_TIMEOUT, 7050 }; 7051 int status; 7052 7053 nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0); 7054 nfs4_set_sequence_privileged(&args.la_seq_args); 7055 dprintk("--> %s\n", __func__); 7056 task = rpc_run_task(&task_setup); 7057 7058 if (IS_ERR(task)) 7059 status = PTR_ERR(task); 7060 else { 7061 status = task->tk_status; 7062 rpc_put_task(task); 7063 } 7064 dprintk("<-- %s return %d\n", __func__, status); 7065 7066 return status; 7067 } 7068 7069 /* 7070 * Initialize the values to be used by the client in CREATE_SESSION 7071 * If nfs4_init_session set the fore channel request and response sizes, 7072 * use them. 7073 * 7074 * Set the back channel max_resp_sz_cached to zero to force the client to 7075 * always set csa_cachethis to FALSE because the current implementation 7076 * of the back channel DRC only supports caching the CB_SEQUENCE operation. 7077 */ 7078 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args) 7079 { 7080 unsigned int max_rqst_sz, max_resp_sz; 7081 7082 max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead; 7083 max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead; 7084 7085 /* Fore channel attributes */ 7086 args->fc_attrs.max_rqst_sz = max_rqst_sz; 7087 args->fc_attrs.max_resp_sz = max_resp_sz; 7088 args->fc_attrs.max_ops = NFS4_MAX_OPS; 7089 args->fc_attrs.max_reqs = max_session_slots; 7090 7091 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u " 7092 "max_ops=%u max_reqs=%u\n", 7093 __func__, 7094 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, 7095 args->fc_attrs.max_ops, args->fc_attrs.max_reqs); 7096 7097 /* Back channel attributes */ 7098 args->bc_attrs.max_rqst_sz = PAGE_SIZE; 7099 args->bc_attrs.max_resp_sz = PAGE_SIZE; 7100 args->bc_attrs.max_resp_sz_cached = 0; 7101 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS; 7102 args->bc_attrs.max_reqs = 1; 7103 7104 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u " 7105 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n", 7106 __func__, 7107 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, 7108 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, 7109 args->bc_attrs.max_reqs); 7110 } 7111 7112 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session) 7113 { 7114 struct nfs4_channel_attrs *sent = &args->fc_attrs; 7115 struct nfs4_channel_attrs *rcvd = &session->fc_attrs; 7116 7117 if (rcvd->max_resp_sz > sent->max_resp_sz) 7118 return -EINVAL; 7119 /* 7120 * Our requested max_ops is the minimum we need; we're not 7121 * prepared to break up compounds into smaller pieces than that. 7122 * So, no point even trying to continue if the server won't 7123 * cooperate: 7124 */ 7125 if (rcvd->max_ops < sent->max_ops) 7126 return -EINVAL; 7127 if (rcvd->max_reqs == 0) 7128 return -EINVAL; 7129 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE) 7130 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE; 7131 return 0; 7132 } 7133 7134 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session) 7135 { 7136 struct nfs4_channel_attrs *sent = &args->bc_attrs; 7137 struct nfs4_channel_attrs *rcvd = &session->bc_attrs; 7138 7139 if (rcvd->max_rqst_sz > sent->max_rqst_sz) 7140 return -EINVAL; 7141 if (rcvd->max_resp_sz < sent->max_resp_sz) 7142 return -EINVAL; 7143 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached) 7144 return -EINVAL; 7145 /* These would render the backchannel useless: */ 7146 if (rcvd->max_ops != sent->max_ops) 7147 return -EINVAL; 7148 if (rcvd->max_reqs != sent->max_reqs) 7149 return -EINVAL; 7150 return 0; 7151 } 7152 7153 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args, 7154 struct nfs4_session *session) 7155 { 7156 int ret; 7157 7158 ret = nfs4_verify_fore_channel_attrs(args, session); 7159 if (ret) 7160 return ret; 7161 return nfs4_verify_back_channel_attrs(args, session); 7162 } 7163 7164 static int _nfs4_proc_create_session(struct nfs_client *clp, 7165 struct rpc_cred *cred) 7166 { 7167 struct nfs4_session *session = clp->cl_session; 7168 struct nfs41_create_session_args args = { 7169 .client = clp, 7170 .cb_program = NFS4_CALLBACK, 7171 }; 7172 struct nfs41_create_session_res res = { 7173 .client = clp, 7174 }; 7175 struct rpc_message msg = { 7176 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION], 7177 .rpc_argp = &args, 7178 .rpc_resp = &res, 7179 .rpc_cred = cred, 7180 }; 7181 int status; 7182 7183 nfs4_init_channel_attrs(&args); 7184 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN); 7185 7186 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 7187 trace_nfs4_create_session(clp, status); 7188 7189 if (!status) { 7190 /* Verify the session's negotiated channel_attrs values */ 7191 status = nfs4_verify_channel_attrs(&args, session); 7192 /* Increment the clientid slot sequence id */ 7193 clp->cl_seqid++; 7194 } 7195 7196 return status; 7197 } 7198 7199 /* 7200 * Issues a CREATE_SESSION operation to the server. 7201 * It is the responsibility of the caller to verify the session is 7202 * expired before calling this routine. 7203 */ 7204 int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred) 7205 { 7206 int status; 7207 unsigned *ptr; 7208 struct nfs4_session *session = clp->cl_session; 7209 7210 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); 7211 7212 status = _nfs4_proc_create_session(clp, cred); 7213 if (status) 7214 goto out; 7215 7216 /* Init or reset the session slot tables */ 7217 status = nfs4_setup_session_slot_tables(session); 7218 dprintk("slot table setup returned %d\n", status); 7219 if (status) 7220 goto out; 7221 7222 ptr = (unsigned *)&session->sess_id.data[0]; 7223 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__, 7224 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); 7225 out: 7226 dprintk("<-- %s\n", __func__); 7227 return status; 7228 } 7229 7230 /* 7231 * Issue the over-the-wire RPC DESTROY_SESSION. 7232 * The caller must serialize access to this routine. 7233 */ 7234 int nfs4_proc_destroy_session(struct nfs4_session *session, 7235 struct rpc_cred *cred) 7236 { 7237 struct rpc_message msg = { 7238 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION], 7239 .rpc_argp = session, 7240 .rpc_cred = cred, 7241 }; 7242 int status = 0; 7243 7244 dprintk("--> nfs4_proc_destroy_session\n"); 7245 7246 /* session is still being setup */ 7247 if (session->clp->cl_cons_state != NFS_CS_READY) 7248 return status; 7249 7250 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 7251 trace_nfs4_destroy_session(session->clp, status); 7252 7253 if (status) 7254 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. " 7255 "Session has been destroyed regardless...\n", status); 7256 7257 dprintk("<-- nfs4_proc_destroy_session\n"); 7258 return status; 7259 } 7260 7261 /* 7262 * Renew the cl_session lease. 7263 */ 7264 struct nfs4_sequence_data { 7265 struct nfs_client *clp; 7266 struct nfs4_sequence_args args; 7267 struct nfs4_sequence_res res; 7268 }; 7269 7270 static void nfs41_sequence_release(void *data) 7271 { 7272 struct nfs4_sequence_data *calldata = data; 7273 struct nfs_client *clp = calldata->clp; 7274 7275 if (atomic_read(&clp->cl_count) > 1) 7276 nfs4_schedule_state_renewal(clp); 7277 nfs_put_client(clp); 7278 kfree(calldata); 7279 } 7280 7281 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp) 7282 { 7283 switch(task->tk_status) { 7284 case -NFS4ERR_DELAY: 7285 rpc_delay(task, NFS4_POLL_RETRY_MAX); 7286 return -EAGAIN; 7287 default: 7288 nfs4_schedule_lease_recovery(clp); 7289 } 7290 return 0; 7291 } 7292 7293 static void nfs41_sequence_call_done(struct rpc_task *task, void *data) 7294 { 7295 struct nfs4_sequence_data *calldata = data; 7296 struct nfs_client *clp = calldata->clp; 7297 7298 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp)) 7299 return; 7300 7301 trace_nfs4_sequence(clp, task->tk_status); 7302 if (task->tk_status < 0) { 7303 dprintk("%s ERROR %d\n", __func__, task->tk_status); 7304 if (atomic_read(&clp->cl_count) == 1) 7305 goto out; 7306 7307 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { 7308 rpc_restart_call_prepare(task); 7309 return; 7310 } 7311 } 7312 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred); 7313 out: 7314 dprintk("<-- %s\n", __func__); 7315 } 7316 7317 static void nfs41_sequence_prepare(struct rpc_task *task, void *data) 7318 { 7319 struct nfs4_sequence_data *calldata = data; 7320 struct nfs_client *clp = calldata->clp; 7321 struct nfs4_sequence_args *args; 7322 struct nfs4_sequence_res *res; 7323 7324 args = task->tk_msg.rpc_argp; 7325 res = task->tk_msg.rpc_resp; 7326 7327 nfs41_setup_sequence(clp->cl_session, args, res, task); 7328 } 7329 7330 static const struct rpc_call_ops nfs41_sequence_ops = { 7331 .rpc_call_done = nfs41_sequence_call_done, 7332 .rpc_call_prepare = nfs41_sequence_prepare, 7333 .rpc_release = nfs41_sequence_release, 7334 }; 7335 7336 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, 7337 struct rpc_cred *cred, 7338 bool is_privileged) 7339 { 7340 struct nfs4_sequence_data *calldata; 7341 struct rpc_message msg = { 7342 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE], 7343 .rpc_cred = cred, 7344 }; 7345 struct rpc_task_setup task_setup_data = { 7346 .rpc_client = clp->cl_rpcclient, 7347 .rpc_message = &msg, 7348 .callback_ops = &nfs41_sequence_ops, 7349 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT, 7350 }; 7351 7352 if (!atomic_inc_not_zero(&clp->cl_count)) 7353 return ERR_PTR(-EIO); 7354 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 7355 if (calldata == NULL) { 7356 nfs_put_client(clp); 7357 return ERR_PTR(-ENOMEM); 7358 } 7359 nfs4_init_sequence(&calldata->args, &calldata->res, 0); 7360 if (is_privileged) 7361 nfs4_set_sequence_privileged(&calldata->args); 7362 msg.rpc_argp = &calldata->args; 7363 msg.rpc_resp = &calldata->res; 7364 calldata->clp = clp; 7365 task_setup_data.callback_data = calldata; 7366 7367 return rpc_run_task(&task_setup_data); 7368 } 7369 7370 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags) 7371 { 7372 struct rpc_task *task; 7373 int ret = 0; 7374 7375 if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0) 7376 return -EAGAIN; 7377 task = _nfs41_proc_sequence(clp, cred, false); 7378 if (IS_ERR(task)) 7379 ret = PTR_ERR(task); 7380 else 7381 rpc_put_task_async(task); 7382 dprintk("<-- %s status=%d\n", __func__, ret); 7383 return ret; 7384 } 7385 7386 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) 7387 { 7388 struct rpc_task *task; 7389 int ret; 7390 7391 task = _nfs41_proc_sequence(clp, cred, true); 7392 if (IS_ERR(task)) { 7393 ret = PTR_ERR(task); 7394 goto out; 7395 } 7396 ret = rpc_wait_for_completion_task(task); 7397 if (!ret) { 7398 struct nfs4_sequence_res *res = task->tk_msg.rpc_resp; 7399 7400 if (task->tk_status == 0) 7401 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags); 7402 ret = task->tk_status; 7403 } 7404 rpc_put_task(task); 7405 out: 7406 dprintk("<-- %s status=%d\n", __func__, ret); 7407 return ret; 7408 } 7409 7410 struct nfs4_reclaim_complete_data { 7411 struct nfs_client *clp; 7412 struct nfs41_reclaim_complete_args arg; 7413 struct nfs41_reclaim_complete_res res; 7414 }; 7415 7416 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data) 7417 { 7418 struct nfs4_reclaim_complete_data *calldata = data; 7419 7420 nfs41_setup_sequence(calldata->clp->cl_session, 7421 &calldata->arg.seq_args, 7422 &calldata->res.seq_res, 7423 task); 7424 } 7425 7426 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp) 7427 { 7428 switch(task->tk_status) { 7429 case 0: 7430 case -NFS4ERR_COMPLETE_ALREADY: 7431 case -NFS4ERR_WRONG_CRED: /* What to do here? */ 7432 break; 7433 case -NFS4ERR_DELAY: 7434 rpc_delay(task, NFS4_POLL_RETRY_MAX); 7435 /* fall through */ 7436 case -NFS4ERR_RETRY_UNCACHED_REP: 7437 return -EAGAIN; 7438 default: 7439 nfs4_schedule_lease_recovery(clp); 7440 } 7441 return 0; 7442 } 7443 7444 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data) 7445 { 7446 struct nfs4_reclaim_complete_data *calldata = data; 7447 struct nfs_client *clp = calldata->clp; 7448 struct nfs4_sequence_res *res = &calldata->res.seq_res; 7449 7450 dprintk("--> %s\n", __func__); 7451 if (!nfs41_sequence_done(task, res)) 7452 return; 7453 7454 trace_nfs4_reclaim_complete(clp, task->tk_status); 7455 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { 7456 rpc_restart_call_prepare(task); 7457 return; 7458 } 7459 dprintk("<-- %s\n", __func__); 7460 } 7461 7462 static void nfs4_free_reclaim_complete_data(void *data) 7463 { 7464 struct nfs4_reclaim_complete_data *calldata = data; 7465 7466 kfree(calldata); 7467 } 7468 7469 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = { 7470 .rpc_call_prepare = nfs4_reclaim_complete_prepare, 7471 .rpc_call_done = nfs4_reclaim_complete_done, 7472 .rpc_release = nfs4_free_reclaim_complete_data, 7473 }; 7474 7475 /* 7476 * Issue a global reclaim complete. 7477 */ 7478 static int nfs41_proc_reclaim_complete(struct nfs_client *clp, 7479 struct rpc_cred *cred) 7480 { 7481 struct nfs4_reclaim_complete_data *calldata; 7482 struct rpc_task *task; 7483 struct rpc_message msg = { 7484 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE], 7485 .rpc_cred = cred, 7486 }; 7487 struct rpc_task_setup task_setup_data = { 7488 .rpc_client = clp->cl_rpcclient, 7489 .rpc_message = &msg, 7490 .callback_ops = &nfs4_reclaim_complete_call_ops, 7491 .flags = RPC_TASK_ASYNC, 7492 }; 7493 int status = -ENOMEM; 7494 7495 dprintk("--> %s\n", __func__); 7496 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 7497 if (calldata == NULL) 7498 goto out; 7499 calldata->clp = clp; 7500 calldata->arg.one_fs = 0; 7501 7502 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0); 7503 nfs4_set_sequence_privileged(&calldata->arg.seq_args); 7504 msg.rpc_argp = &calldata->arg; 7505 msg.rpc_resp = &calldata->res; 7506 task_setup_data.callback_data = calldata; 7507 task = rpc_run_task(&task_setup_data); 7508 if (IS_ERR(task)) { 7509 status = PTR_ERR(task); 7510 goto out; 7511 } 7512 status = nfs4_wait_for_completion_rpc_task(task); 7513 if (status == 0) 7514 status = task->tk_status; 7515 rpc_put_task(task); 7516 return 0; 7517 out: 7518 dprintk("<-- %s status=%d\n", __func__, status); 7519 return status; 7520 } 7521 7522 static void 7523 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata) 7524 { 7525 struct nfs4_layoutget *lgp = calldata; 7526 struct nfs_server *server = NFS_SERVER(lgp->args.inode); 7527 struct nfs4_session *session = nfs4_get_session(server); 7528 7529 dprintk("--> %s\n", __func__); 7530 /* Note the is a race here, where a CB_LAYOUTRECALL can come in 7531 * right now covering the LAYOUTGET we are about to send. 7532 * However, that is not so catastrophic, and there seems 7533 * to be no way to prevent it completely. 7534 */ 7535 if (nfs41_setup_sequence(session, &lgp->args.seq_args, 7536 &lgp->res.seq_res, task)) 7537 return; 7538 if (pnfs_choose_layoutget_stateid(&lgp->args.stateid, 7539 NFS_I(lgp->args.inode)->layout, 7540 lgp->args.ctx->state)) { 7541 rpc_exit(task, NFS4_OK); 7542 } 7543 } 7544 7545 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata) 7546 { 7547 struct nfs4_layoutget *lgp = calldata; 7548 struct inode *inode = lgp->args.inode; 7549 struct nfs_server *server = NFS_SERVER(inode); 7550 struct pnfs_layout_hdr *lo; 7551 struct nfs4_state *state = NULL; 7552 unsigned long timeo, now, giveup; 7553 7554 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status); 7555 7556 if (!nfs41_sequence_done(task, &lgp->res.seq_res)) 7557 goto out; 7558 7559 switch (task->tk_status) { 7560 case 0: 7561 goto out; 7562 /* 7563 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client 7564 * (or clients) writing to the same RAID stripe 7565 */ 7566 case -NFS4ERR_LAYOUTTRYLATER: 7567 /* 7568 * NFS4ERR_RECALLCONFLICT is when conflict with self (must recall 7569 * existing layout before getting a new one). 7570 */ 7571 case -NFS4ERR_RECALLCONFLICT: 7572 timeo = rpc_get_timeout(task->tk_client); 7573 giveup = lgp->args.timestamp + timeo; 7574 now = jiffies; 7575 if (time_after(giveup, now)) { 7576 unsigned long delay; 7577 7578 /* Delay for: 7579 * - Not less then NFS4_POLL_RETRY_MIN. 7580 * - One last time a jiffie before we give up 7581 * - exponential backoff (time_now minus start_attempt) 7582 */ 7583 delay = max_t(unsigned long, NFS4_POLL_RETRY_MIN, 7584 min((giveup - now - 1), 7585 now - lgp->args.timestamp)); 7586 7587 dprintk("%s: NFS4ERR_RECALLCONFLICT waiting %lu\n", 7588 __func__, delay); 7589 rpc_delay(task, delay); 7590 task->tk_status = 0; 7591 rpc_restart_call_prepare(task); 7592 goto out; /* Do not call nfs4_async_handle_error() */ 7593 } 7594 break; 7595 case -NFS4ERR_EXPIRED: 7596 case -NFS4ERR_BAD_STATEID: 7597 spin_lock(&inode->i_lock); 7598 lo = NFS_I(inode)->layout; 7599 if (!lo || list_empty(&lo->plh_segs)) { 7600 spin_unlock(&inode->i_lock); 7601 /* If the open stateid was bad, then recover it. */ 7602 state = lgp->args.ctx->state; 7603 } else { 7604 LIST_HEAD(head); 7605 7606 /* 7607 * Mark the bad layout state as invalid, then retry 7608 * with the current stateid. 7609 */ 7610 pnfs_mark_matching_lsegs_invalid(lo, &head, NULL); 7611 spin_unlock(&inode->i_lock); 7612 pnfs_free_lseg_list(&head); 7613 7614 task->tk_status = 0; 7615 rpc_restart_call_prepare(task); 7616 } 7617 } 7618 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) 7619 rpc_restart_call_prepare(task); 7620 out: 7621 dprintk("<-- %s\n", __func__); 7622 } 7623 7624 static size_t max_response_pages(struct nfs_server *server) 7625 { 7626 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz; 7627 return nfs_page_array_len(0, max_resp_sz); 7628 } 7629 7630 static void nfs4_free_pages(struct page **pages, size_t size) 7631 { 7632 int i; 7633 7634 if (!pages) 7635 return; 7636 7637 for (i = 0; i < size; i++) { 7638 if (!pages[i]) 7639 break; 7640 __free_page(pages[i]); 7641 } 7642 kfree(pages); 7643 } 7644 7645 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags) 7646 { 7647 struct page **pages; 7648 int i; 7649 7650 pages = kcalloc(size, sizeof(struct page *), gfp_flags); 7651 if (!pages) { 7652 dprintk("%s: can't alloc array of %zu pages\n", __func__, size); 7653 return NULL; 7654 } 7655 7656 for (i = 0; i < size; i++) { 7657 pages[i] = alloc_page(gfp_flags); 7658 if (!pages[i]) { 7659 dprintk("%s: failed to allocate page\n", __func__); 7660 nfs4_free_pages(pages, size); 7661 return NULL; 7662 } 7663 } 7664 7665 return pages; 7666 } 7667 7668 static void nfs4_layoutget_release(void *calldata) 7669 { 7670 struct nfs4_layoutget *lgp = calldata; 7671 struct inode *inode = lgp->args.inode; 7672 struct nfs_server *server = NFS_SERVER(inode); 7673 size_t max_pages = max_response_pages(server); 7674 7675 dprintk("--> %s\n", __func__); 7676 nfs4_free_pages(lgp->args.layout.pages, max_pages); 7677 pnfs_put_layout_hdr(NFS_I(inode)->layout); 7678 put_nfs_open_context(lgp->args.ctx); 7679 kfree(calldata); 7680 dprintk("<-- %s\n", __func__); 7681 } 7682 7683 static const struct rpc_call_ops nfs4_layoutget_call_ops = { 7684 .rpc_call_prepare = nfs4_layoutget_prepare, 7685 .rpc_call_done = nfs4_layoutget_done, 7686 .rpc_release = nfs4_layoutget_release, 7687 }; 7688 7689 struct pnfs_layout_segment * 7690 nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags) 7691 { 7692 struct inode *inode = lgp->args.inode; 7693 struct nfs_server *server = NFS_SERVER(inode); 7694 size_t max_pages = max_response_pages(server); 7695 struct rpc_task *task; 7696 struct rpc_message msg = { 7697 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET], 7698 .rpc_argp = &lgp->args, 7699 .rpc_resp = &lgp->res, 7700 .rpc_cred = lgp->cred, 7701 }; 7702 struct rpc_task_setup task_setup_data = { 7703 .rpc_client = server->client, 7704 .rpc_message = &msg, 7705 .callback_ops = &nfs4_layoutget_call_ops, 7706 .callback_data = lgp, 7707 .flags = RPC_TASK_ASYNC, 7708 }; 7709 struct pnfs_layout_segment *lseg = NULL; 7710 int status = 0; 7711 7712 dprintk("--> %s\n", __func__); 7713 7714 /* nfs4_layoutget_release calls pnfs_put_layout_hdr */ 7715 pnfs_get_layout_hdr(NFS_I(inode)->layout); 7716 7717 lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags); 7718 if (!lgp->args.layout.pages) { 7719 nfs4_layoutget_release(lgp); 7720 return ERR_PTR(-ENOMEM); 7721 } 7722 lgp->args.layout.pglen = max_pages * PAGE_SIZE; 7723 lgp->args.timestamp = jiffies; 7724 7725 lgp->res.layoutp = &lgp->args.layout; 7726 lgp->res.seq_res.sr_slot = NULL; 7727 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0); 7728 7729 task = rpc_run_task(&task_setup_data); 7730 if (IS_ERR(task)) 7731 return ERR_CAST(task); 7732 status = nfs4_wait_for_completion_rpc_task(task); 7733 if (status == 0) 7734 status = task->tk_status; 7735 trace_nfs4_layoutget(lgp->args.ctx, 7736 &lgp->args.range, 7737 &lgp->res.range, 7738 status); 7739 /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */ 7740 if (status == 0 && lgp->res.layoutp->len) 7741 lseg = pnfs_layout_process(lgp); 7742 rpc_put_task(task); 7743 dprintk("<-- %s status=%d\n", __func__, status); 7744 if (status) 7745 return ERR_PTR(status); 7746 return lseg; 7747 } 7748 7749 static void 7750 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata) 7751 { 7752 struct nfs4_layoutreturn *lrp = calldata; 7753 7754 dprintk("--> %s\n", __func__); 7755 nfs41_setup_sequence(lrp->clp->cl_session, 7756 &lrp->args.seq_args, 7757 &lrp->res.seq_res, 7758 task); 7759 } 7760 7761 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata) 7762 { 7763 struct nfs4_layoutreturn *lrp = calldata; 7764 struct nfs_server *server; 7765 7766 dprintk("--> %s\n", __func__); 7767 7768 if (!nfs41_sequence_done(task, &lrp->res.seq_res)) 7769 return; 7770 7771 server = NFS_SERVER(lrp->args.inode); 7772 switch (task->tk_status) { 7773 default: 7774 task->tk_status = 0; 7775 case 0: 7776 break; 7777 case -NFS4ERR_DELAY: 7778 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN) 7779 break; 7780 rpc_restart_call_prepare(task); 7781 return; 7782 } 7783 dprintk("<-- %s\n", __func__); 7784 } 7785 7786 static void nfs4_layoutreturn_release(void *calldata) 7787 { 7788 struct nfs4_layoutreturn *lrp = calldata; 7789 struct pnfs_layout_hdr *lo = lrp->args.layout; 7790 7791 dprintk("--> %s\n", __func__); 7792 spin_lock(&lo->plh_inode->i_lock); 7793 if (lrp->res.lrs_present) 7794 pnfs_set_layout_stateid(lo, &lrp->res.stateid, true); 7795 lo->plh_block_lgets--; 7796 spin_unlock(&lo->plh_inode->i_lock); 7797 pnfs_put_layout_hdr(lrp->args.layout); 7798 kfree(calldata); 7799 dprintk("<-- %s\n", __func__); 7800 } 7801 7802 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = { 7803 .rpc_call_prepare = nfs4_layoutreturn_prepare, 7804 .rpc_call_done = nfs4_layoutreturn_done, 7805 .rpc_release = nfs4_layoutreturn_release, 7806 }; 7807 7808 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp) 7809 { 7810 struct rpc_task *task; 7811 struct rpc_message msg = { 7812 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN], 7813 .rpc_argp = &lrp->args, 7814 .rpc_resp = &lrp->res, 7815 .rpc_cred = lrp->cred, 7816 }; 7817 struct rpc_task_setup task_setup_data = { 7818 .rpc_client = NFS_SERVER(lrp->args.inode)->client, 7819 .rpc_message = &msg, 7820 .callback_ops = &nfs4_layoutreturn_call_ops, 7821 .callback_data = lrp, 7822 }; 7823 int status; 7824 7825 dprintk("--> %s\n", __func__); 7826 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1); 7827 task = rpc_run_task(&task_setup_data); 7828 if (IS_ERR(task)) 7829 return PTR_ERR(task); 7830 status = task->tk_status; 7831 trace_nfs4_layoutreturn(lrp->args.inode, status); 7832 dprintk("<-- %s status=%d\n", __func__, status); 7833 rpc_put_task(task); 7834 return status; 7835 } 7836 7837 static int 7838 _nfs4_proc_getdeviceinfo(struct nfs_server *server, 7839 struct pnfs_device *pdev, 7840 struct rpc_cred *cred) 7841 { 7842 struct nfs4_getdeviceinfo_args args = { 7843 .pdev = pdev, 7844 }; 7845 struct nfs4_getdeviceinfo_res res = { 7846 .pdev = pdev, 7847 }; 7848 struct rpc_message msg = { 7849 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO], 7850 .rpc_argp = &args, 7851 .rpc_resp = &res, 7852 .rpc_cred = cred, 7853 }; 7854 int status; 7855 7856 dprintk("--> %s\n", __func__); 7857 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 7858 dprintk("<-- %s status=%d\n", __func__, status); 7859 7860 return status; 7861 } 7862 7863 int nfs4_proc_getdeviceinfo(struct nfs_server *server, 7864 struct pnfs_device *pdev, 7865 struct rpc_cred *cred) 7866 { 7867 struct nfs4_exception exception = { }; 7868 int err; 7869 7870 do { 7871 err = nfs4_handle_exception(server, 7872 _nfs4_proc_getdeviceinfo(server, pdev, cred), 7873 &exception); 7874 } while (exception.retry); 7875 return err; 7876 } 7877 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo); 7878 7879 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata) 7880 { 7881 struct nfs4_layoutcommit_data *data = calldata; 7882 struct nfs_server *server = NFS_SERVER(data->args.inode); 7883 struct nfs4_session *session = nfs4_get_session(server); 7884 7885 nfs41_setup_sequence(session, 7886 &data->args.seq_args, 7887 &data->res.seq_res, 7888 task); 7889 } 7890 7891 static void 7892 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata) 7893 { 7894 struct nfs4_layoutcommit_data *data = calldata; 7895 struct nfs_server *server = NFS_SERVER(data->args.inode); 7896 7897 if (!nfs41_sequence_done(task, &data->res.seq_res)) 7898 return; 7899 7900 switch (task->tk_status) { /* Just ignore these failures */ 7901 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */ 7902 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */ 7903 case -NFS4ERR_BADLAYOUT: /* no layout */ 7904 case -NFS4ERR_GRACE: /* loca_recalim always false */ 7905 task->tk_status = 0; 7906 case 0: 7907 break; 7908 default: 7909 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) { 7910 rpc_restart_call_prepare(task); 7911 return; 7912 } 7913 } 7914 } 7915 7916 static void nfs4_layoutcommit_release(void *calldata) 7917 { 7918 struct nfs4_layoutcommit_data *data = calldata; 7919 7920 pnfs_cleanup_layoutcommit(data); 7921 nfs_post_op_update_inode_force_wcc(data->args.inode, 7922 data->res.fattr); 7923 put_rpccred(data->cred); 7924 kfree(data); 7925 } 7926 7927 static const struct rpc_call_ops nfs4_layoutcommit_ops = { 7928 .rpc_call_prepare = nfs4_layoutcommit_prepare, 7929 .rpc_call_done = nfs4_layoutcommit_done, 7930 .rpc_release = nfs4_layoutcommit_release, 7931 }; 7932 7933 int 7934 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync) 7935 { 7936 struct rpc_message msg = { 7937 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT], 7938 .rpc_argp = &data->args, 7939 .rpc_resp = &data->res, 7940 .rpc_cred = data->cred, 7941 }; 7942 struct rpc_task_setup task_setup_data = { 7943 .task = &data->task, 7944 .rpc_client = NFS_CLIENT(data->args.inode), 7945 .rpc_message = &msg, 7946 .callback_ops = &nfs4_layoutcommit_ops, 7947 .callback_data = data, 7948 .flags = RPC_TASK_ASYNC, 7949 }; 7950 struct rpc_task *task; 7951 int status = 0; 7952 7953 dprintk("NFS: %4d initiating layoutcommit call. sync %d " 7954 "lbw: %llu inode %lu\n", 7955 data->task.tk_pid, sync, 7956 data->args.lastbytewritten, 7957 data->args.inode->i_ino); 7958 7959 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1); 7960 task = rpc_run_task(&task_setup_data); 7961 if (IS_ERR(task)) 7962 return PTR_ERR(task); 7963 if (sync == false) 7964 goto out; 7965 status = nfs4_wait_for_completion_rpc_task(task); 7966 if (status != 0) 7967 goto out; 7968 status = task->tk_status; 7969 trace_nfs4_layoutcommit(data->args.inode, status); 7970 out: 7971 dprintk("%s: status %d\n", __func__, status); 7972 rpc_put_task(task); 7973 return status; 7974 } 7975 7976 /** 7977 * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if 7978 * possible) as per RFC3530bis and RFC5661 Security Considerations sections 7979 */ 7980 static int 7981 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, 7982 struct nfs_fsinfo *info, 7983 struct nfs4_secinfo_flavors *flavors, bool use_integrity) 7984 { 7985 struct nfs41_secinfo_no_name_args args = { 7986 .style = SECINFO_STYLE_CURRENT_FH, 7987 }; 7988 struct nfs4_secinfo_res res = { 7989 .flavors = flavors, 7990 }; 7991 struct rpc_message msg = { 7992 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME], 7993 .rpc_argp = &args, 7994 .rpc_resp = &res, 7995 }; 7996 struct rpc_clnt *clnt = server->client; 7997 struct rpc_cred *cred = NULL; 7998 int status; 7999 8000 if (use_integrity) { 8001 clnt = server->nfs_client->cl_rpcclient; 8002 cred = nfs4_get_clid_cred(server->nfs_client); 8003 msg.rpc_cred = cred; 8004 } 8005 8006 dprintk("--> %s\n", __func__); 8007 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, 8008 &res.seq_res, 0); 8009 dprintk("<-- %s status=%d\n", __func__, status); 8010 8011 if (cred) 8012 put_rpccred(cred); 8013 8014 return status; 8015 } 8016 8017 static int 8018 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, 8019 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors) 8020 { 8021 struct nfs4_exception exception = { }; 8022 int err; 8023 do { 8024 /* first try using integrity protection */ 8025 err = -NFS4ERR_WRONGSEC; 8026 8027 /* try to use integrity protection with machine cred */ 8028 if (_nfs4_is_integrity_protected(server->nfs_client)) 8029 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, 8030 flavors, true); 8031 8032 /* 8033 * if unable to use integrity protection, or SECINFO with 8034 * integrity protection returns NFS4ERR_WRONGSEC (which is 8035 * disallowed by spec, but exists in deployed servers) use 8036 * the current filesystem's rpc_client and the user cred. 8037 */ 8038 if (err == -NFS4ERR_WRONGSEC) 8039 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, 8040 flavors, false); 8041 8042 switch (err) { 8043 case 0: 8044 case -NFS4ERR_WRONGSEC: 8045 case -ENOTSUPP: 8046 goto out; 8047 default: 8048 err = nfs4_handle_exception(server, err, &exception); 8049 } 8050 } while (exception.retry); 8051 out: 8052 return err; 8053 } 8054 8055 static int 8056 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 8057 struct nfs_fsinfo *info) 8058 { 8059 int err; 8060 struct page *page; 8061 rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR; 8062 struct nfs4_secinfo_flavors *flavors; 8063 struct nfs4_secinfo4 *secinfo; 8064 int i; 8065 8066 page = alloc_page(GFP_KERNEL); 8067 if (!page) { 8068 err = -ENOMEM; 8069 goto out; 8070 } 8071 8072 flavors = page_address(page); 8073 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors); 8074 8075 /* 8076 * Fall back on "guess and check" method if 8077 * the server doesn't support SECINFO_NO_NAME 8078 */ 8079 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) { 8080 err = nfs4_find_root_sec(server, fhandle, info); 8081 goto out_freepage; 8082 } 8083 if (err) 8084 goto out_freepage; 8085 8086 for (i = 0; i < flavors->num_flavors; i++) { 8087 secinfo = &flavors->flavors[i]; 8088 8089 switch (secinfo->flavor) { 8090 case RPC_AUTH_NULL: 8091 case RPC_AUTH_UNIX: 8092 case RPC_AUTH_GSS: 8093 flavor = rpcauth_get_pseudoflavor(secinfo->flavor, 8094 &secinfo->flavor_info); 8095 break; 8096 default: 8097 flavor = RPC_AUTH_MAXFLAVOR; 8098 break; 8099 } 8100 8101 if (!nfs_auth_info_match(&server->auth_info, flavor)) 8102 flavor = RPC_AUTH_MAXFLAVOR; 8103 8104 if (flavor != RPC_AUTH_MAXFLAVOR) { 8105 err = nfs4_lookup_root_sec(server, fhandle, 8106 info, flavor); 8107 if (!err) 8108 break; 8109 } 8110 } 8111 8112 if (flavor == RPC_AUTH_MAXFLAVOR) 8113 err = -EPERM; 8114 8115 out_freepage: 8116 put_page(page); 8117 if (err == -EACCES) 8118 return -EPERM; 8119 out: 8120 return err; 8121 } 8122 8123 static int _nfs41_test_stateid(struct nfs_server *server, 8124 nfs4_stateid *stateid, 8125 struct rpc_cred *cred) 8126 { 8127 int status; 8128 struct nfs41_test_stateid_args args = { 8129 .stateid = stateid, 8130 }; 8131 struct nfs41_test_stateid_res res; 8132 struct rpc_message msg = { 8133 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID], 8134 .rpc_argp = &args, 8135 .rpc_resp = &res, 8136 .rpc_cred = cred, 8137 }; 8138 struct rpc_clnt *rpc_client = server->client; 8139 8140 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, 8141 &rpc_client, &msg); 8142 8143 dprintk("NFS call test_stateid %p\n", stateid); 8144 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0); 8145 nfs4_set_sequence_privileged(&args.seq_args); 8146 status = nfs4_call_sync_sequence(rpc_client, server, &msg, 8147 &args.seq_args, &res.seq_res); 8148 if (status != NFS_OK) { 8149 dprintk("NFS reply test_stateid: failed, %d\n", status); 8150 return status; 8151 } 8152 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status); 8153 return -res.status; 8154 } 8155 8156 /** 8157 * nfs41_test_stateid - perform a TEST_STATEID operation 8158 * 8159 * @server: server / transport on which to perform the operation 8160 * @stateid: state ID to test 8161 * @cred: credential 8162 * 8163 * Returns NFS_OK if the server recognizes that "stateid" is valid. 8164 * Otherwise a negative NFS4ERR value is returned if the operation 8165 * failed or the state ID is not currently valid. 8166 */ 8167 static int nfs41_test_stateid(struct nfs_server *server, 8168 nfs4_stateid *stateid, 8169 struct rpc_cred *cred) 8170 { 8171 struct nfs4_exception exception = { }; 8172 int err; 8173 do { 8174 err = _nfs41_test_stateid(server, stateid, cred); 8175 if (err != -NFS4ERR_DELAY) 8176 break; 8177 nfs4_handle_exception(server, err, &exception); 8178 } while (exception.retry); 8179 return err; 8180 } 8181 8182 struct nfs_free_stateid_data { 8183 struct nfs_server *server; 8184 struct nfs41_free_stateid_args args; 8185 struct nfs41_free_stateid_res res; 8186 }; 8187 8188 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata) 8189 { 8190 struct nfs_free_stateid_data *data = calldata; 8191 nfs41_setup_sequence(nfs4_get_session(data->server), 8192 &data->args.seq_args, 8193 &data->res.seq_res, 8194 task); 8195 } 8196 8197 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata) 8198 { 8199 struct nfs_free_stateid_data *data = calldata; 8200 8201 nfs41_sequence_done(task, &data->res.seq_res); 8202 8203 switch (task->tk_status) { 8204 case -NFS4ERR_DELAY: 8205 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN) 8206 rpc_restart_call_prepare(task); 8207 } 8208 } 8209 8210 static void nfs41_free_stateid_release(void *calldata) 8211 { 8212 kfree(calldata); 8213 } 8214 8215 static const struct rpc_call_ops nfs41_free_stateid_ops = { 8216 .rpc_call_prepare = nfs41_free_stateid_prepare, 8217 .rpc_call_done = nfs41_free_stateid_done, 8218 .rpc_release = nfs41_free_stateid_release, 8219 }; 8220 8221 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server, 8222 nfs4_stateid *stateid, 8223 struct rpc_cred *cred, 8224 bool privileged) 8225 { 8226 struct rpc_message msg = { 8227 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID], 8228 .rpc_cred = cred, 8229 }; 8230 struct rpc_task_setup task_setup = { 8231 .rpc_client = server->client, 8232 .rpc_message = &msg, 8233 .callback_ops = &nfs41_free_stateid_ops, 8234 .flags = RPC_TASK_ASYNC, 8235 }; 8236 struct nfs_free_stateid_data *data; 8237 8238 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, 8239 &task_setup.rpc_client, &msg); 8240 8241 dprintk("NFS call free_stateid %p\n", stateid); 8242 data = kmalloc(sizeof(*data), GFP_NOFS); 8243 if (!data) 8244 return ERR_PTR(-ENOMEM); 8245 data->server = server; 8246 nfs4_stateid_copy(&data->args.stateid, stateid); 8247 8248 task_setup.callback_data = data; 8249 8250 msg.rpc_argp = &data->args; 8251 msg.rpc_resp = &data->res; 8252 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0); 8253 if (privileged) 8254 nfs4_set_sequence_privileged(&data->args.seq_args); 8255 8256 return rpc_run_task(&task_setup); 8257 } 8258 8259 /** 8260 * nfs41_free_stateid - perform a FREE_STATEID operation 8261 * 8262 * @server: server / transport on which to perform the operation 8263 * @stateid: state ID to release 8264 * @cred: credential 8265 * 8266 * Returns NFS_OK if the server freed "stateid". Otherwise a 8267 * negative NFS4ERR value is returned. 8268 */ 8269 static int nfs41_free_stateid(struct nfs_server *server, 8270 nfs4_stateid *stateid, 8271 struct rpc_cred *cred) 8272 { 8273 struct rpc_task *task; 8274 int ret; 8275 8276 task = _nfs41_free_stateid(server, stateid, cred, true); 8277 if (IS_ERR(task)) 8278 return PTR_ERR(task); 8279 ret = rpc_wait_for_completion_task(task); 8280 if (!ret) 8281 ret = task->tk_status; 8282 rpc_put_task(task); 8283 return ret; 8284 } 8285 8286 static void 8287 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp) 8288 { 8289 struct rpc_task *task; 8290 struct rpc_cred *cred = lsp->ls_state->owner->so_cred; 8291 8292 task = _nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); 8293 nfs4_free_lock_state(server, lsp); 8294 if (IS_ERR(task)) 8295 return; 8296 rpc_put_task(task); 8297 } 8298 8299 static bool nfs41_match_stateid(const nfs4_stateid *s1, 8300 const nfs4_stateid *s2) 8301 { 8302 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0) 8303 return false; 8304 8305 if (s1->seqid == s2->seqid) 8306 return true; 8307 if (s1->seqid == 0 || s2->seqid == 0) 8308 return true; 8309 8310 return false; 8311 } 8312 8313 #endif /* CONFIG_NFS_V4_1 */ 8314 8315 static bool nfs4_match_stateid(const nfs4_stateid *s1, 8316 const nfs4_stateid *s2) 8317 { 8318 return nfs4_stateid_match(s1, s2); 8319 } 8320 8321 8322 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = { 8323 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 8324 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 8325 .recover_open = nfs4_open_reclaim, 8326 .recover_lock = nfs4_lock_reclaim, 8327 .establish_clid = nfs4_init_clientid, 8328 .detect_trunking = nfs40_discover_server_trunking, 8329 }; 8330 8331 #if defined(CONFIG_NFS_V4_1) 8332 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = { 8333 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 8334 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 8335 .recover_open = nfs4_open_reclaim, 8336 .recover_lock = nfs4_lock_reclaim, 8337 .establish_clid = nfs41_init_clientid, 8338 .reclaim_complete = nfs41_proc_reclaim_complete, 8339 .detect_trunking = nfs41_discover_server_trunking, 8340 }; 8341 #endif /* CONFIG_NFS_V4_1 */ 8342 8343 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = { 8344 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 8345 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 8346 .recover_open = nfs40_open_expired, 8347 .recover_lock = nfs4_lock_expired, 8348 .establish_clid = nfs4_init_clientid, 8349 }; 8350 8351 #if defined(CONFIG_NFS_V4_1) 8352 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = { 8353 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 8354 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 8355 .recover_open = nfs41_open_expired, 8356 .recover_lock = nfs41_lock_expired, 8357 .establish_clid = nfs41_init_clientid, 8358 }; 8359 #endif /* CONFIG_NFS_V4_1 */ 8360 8361 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { 8362 .sched_state_renewal = nfs4_proc_async_renew, 8363 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked, 8364 .renew_lease = nfs4_proc_renew, 8365 }; 8366 8367 #if defined(CONFIG_NFS_V4_1) 8368 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { 8369 .sched_state_renewal = nfs41_proc_async_sequence, 8370 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked, 8371 .renew_lease = nfs4_proc_sequence, 8372 }; 8373 #endif 8374 8375 static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = { 8376 .get_locations = _nfs40_proc_get_locations, 8377 .fsid_present = _nfs40_proc_fsid_present, 8378 }; 8379 8380 #if defined(CONFIG_NFS_V4_1) 8381 static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = { 8382 .get_locations = _nfs41_proc_get_locations, 8383 .fsid_present = _nfs41_proc_fsid_present, 8384 }; 8385 #endif /* CONFIG_NFS_V4_1 */ 8386 8387 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = { 8388 .minor_version = 0, 8389 .init_caps = NFS_CAP_READDIRPLUS 8390 | NFS_CAP_ATOMIC_OPEN 8391 | NFS_CAP_CHANGE_ATTR 8392 | NFS_CAP_POSIX_LOCK, 8393 .init_client = nfs40_init_client, 8394 .shutdown_client = nfs40_shutdown_client, 8395 .match_stateid = nfs4_match_stateid, 8396 .find_root_sec = nfs4_find_root_sec, 8397 .free_lock_state = nfs4_release_lockowner, 8398 .call_sync_ops = &nfs40_call_sync_ops, 8399 .reboot_recovery_ops = &nfs40_reboot_recovery_ops, 8400 .nograce_recovery_ops = &nfs40_nograce_recovery_ops, 8401 .state_renewal_ops = &nfs40_state_renewal_ops, 8402 .mig_recovery_ops = &nfs40_mig_recovery_ops, 8403 }; 8404 8405 #if defined(CONFIG_NFS_V4_1) 8406 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = { 8407 .minor_version = 1, 8408 .init_caps = NFS_CAP_READDIRPLUS 8409 | NFS_CAP_ATOMIC_OPEN 8410 | NFS_CAP_CHANGE_ATTR 8411 | NFS_CAP_POSIX_LOCK 8412 | NFS_CAP_STATEID_NFSV41 8413 | NFS_CAP_ATOMIC_OPEN_V1, 8414 .init_client = nfs41_init_client, 8415 .shutdown_client = nfs41_shutdown_client, 8416 .match_stateid = nfs41_match_stateid, 8417 .find_root_sec = nfs41_find_root_sec, 8418 .free_lock_state = nfs41_free_lock_state, 8419 .call_sync_ops = &nfs41_call_sync_ops, 8420 .reboot_recovery_ops = &nfs41_reboot_recovery_ops, 8421 .nograce_recovery_ops = &nfs41_nograce_recovery_ops, 8422 .state_renewal_ops = &nfs41_state_renewal_ops, 8423 .mig_recovery_ops = &nfs41_mig_recovery_ops, 8424 }; 8425 #endif 8426 8427 #if defined(CONFIG_NFS_V4_2) 8428 static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = { 8429 .minor_version = 2, 8430 .init_caps = NFS_CAP_READDIRPLUS 8431 | NFS_CAP_ATOMIC_OPEN 8432 | NFS_CAP_CHANGE_ATTR 8433 | NFS_CAP_POSIX_LOCK 8434 | NFS_CAP_STATEID_NFSV41 8435 | NFS_CAP_ATOMIC_OPEN_V1 8436 | NFS_CAP_ALLOCATE 8437 | NFS_CAP_DEALLOCATE 8438 | NFS_CAP_SEEK, 8439 .init_client = nfs41_init_client, 8440 .shutdown_client = nfs41_shutdown_client, 8441 .match_stateid = nfs41_match_stateid, 8442 .find_root_sec = nfs41_find_root_sec, 8443 .free_lock_state = nfs41_free_lock_state, 8444 .call_sync_ops = &nfs41_call_sync_ops, 8445 .reboot_recovery_ops = &nfs41_reboot_recovery_ops, 8446 .nograce_recovery_ops = &nfs41_nograce_recovery_ops, 8447 .state_renewal_ops = &nfs41_state_renewal_ops, 8448 }; 8449 #endif 8450 8451 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = { 8452 [0] = &nfs_v4_0_minor_ops, 8453 #if defined(CONFIG_NFS_V4_1) 8454 [1] = &nfs_v4_1_minor_ops, 8455 #endif 8456 #if defined(CONFIG_NFS_V4_2) 8457 [2] = &nfs_v4_2_minor_ops, 8458 #endif 8459 }; 8460 8461 static const struct inode_operations nfs4_dir_inode_operations = { 8462 .create = nfs_create, 8463 .lookup = nfs_lookup, 8464 .atomic_open = nfs_atomic_open, 8465 .link = nfs_link, 8466 .unlink = nfs_unlink, 8467 .symlink = nfs_symlink, 8468 .mkdir = nfs_mkdir, 8469 .rmdir = nfs_rmdir, 8470 .mknod = nfs_mknod, 8471 .rename = nfs_rename, 8472 .permission = nfs_permission, 8473 .getattr = nfs_getattr, 8474 .setattr = nfs_setattr, 8475 .getxattr = generic_getxattr, 8476 .setxattr = generic_setxattr, 8477 .listxattr = generic_listxattr, 8478 .removexattr = generic_removexattr, 8479 }; 8480 8481 static const struct inode_operations nfs4_file_inode_operations = { 8482 .permission = nfs_permission, 8483 .getattr = nfs_getattr, 8484 .setattr = nfs_setattr, 8485 .getxattr = generic_getxattr, 8486 .setxattr = generic_setxattr, 8487 .listxattr = generic_listxattr, 8488 .removexattr = generic_removexattr, 8489 }; 8490 8491 const struct nfs_rpc_ops nfs_v4_clientops = { 8492 .version = 4, /* protocol version */ 8493 .dentry_ops = &nfs4_dentry_operations, 8494 .dir_inode_ops = &nfs4_dir_inode_operations, 8495 .file_inode_ops = &nfs4_file_inode_operations, 8496 .file_ops = &nfs4_file_operations, 8497 .getroot = nfs4_proc_get_root, 8498 .submount = nfs4_submount, 8499 .try_mount = nfs4_try_mount, 8500 .getattr = nfs4_proc_getattr, 8501 .setattr = nfs4_proc_setattr, 8502 .lookup = nfs4_proc_lookup, 8503 .access = nfs4_proc_access, 8504 .readlink = nfs4_proc_readlink, 8505 .create = nfs4_proc_create, 8506 .remove = nfs4_proc_remove, 8507 .unlink_setup = nfs4_proc_unlink_setup, 8508 .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare, 8509 .unlink_done = nfs4_proc_unlink_done, 8510 .rename_setup = nfs4_proc_rename_setup, 8511 .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare, 8512 .rename_done = nfs4_proc_rename_done, 8513 .link = nfs4_proc_link, 8514 .symlink = nfs4_proc_symlink, 8515 .mkdir = nfs4_proc_mkdir, 8516 .rmdir = nfs4_proc_remove, 8517 .readdir = nfs4_proc_readdir, 8518 .mknod = nfs4_proc_mknod, 8519 .statfs = nfs4_proc_statfs, 8520 .fsinfo = nfs4_proc_fsinfo, 8521 .pathconf = nfs4_proc_pathconf, 8522 .set_capabilities = nfs4_server_capabilities, 8523 .decode_dirent = nfs4_decode_dirent, 8524 .pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare, 8525 .read_setup = nfs4_proc_read_setup, 8526 .read_done = nfs4_read_done, 8527 .write_setup = nfs4_proc_write_setup, 8528 .write_done = nfs4_write_done, 8529 .commit_setup = nfs4_proc_commit_setup, 8530 .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare, 8531 .commit_done = nfs4_commit_done, 8532 .lock = nfs4_proc_lock, 8533 .clear_acl_cache = nfs4_zap_acl_attr, 8534 .close_context = nfs4_close_context, 8535 .open_context = nfs4_atomic_open, 8536 .have_delegation = nfs4_have_delegation, 8537 .return_delegation = nfs4_inode_return_delegation, 8538 .alloc_client = nfs4_alloc_client, 8539 .init_client = nfs4_init_client, 8540 .free_client = nfs4_free_client, 8541 .create_server = nfs4_create_server, 8542 .clone_server = nfs_clone_server, 8543 }; 8544 8545 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { 8546 .prefix = XATTR_NAME_NFSV4_ACL, 8547 .list = nfs4_xattr_list_nfs4_acl, 8548 .get = nfs4_xattr_get_nfs4_acl, 8549 .set = nfs4_xattr_set_nfs4_acl, 8550 }; 8551 8552 const struct xattr_handler *nfs4_xattr_handlers[] = { 8553 &nfs4_xattr_nfs4_acl_handler, 8554 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 8555 &nfs4_xattr_nfs4_label_handler, 8556 #endif 8557 NULL 8558 }; 8559 8560 /* 8561 * Local variables: 8562 * c-basic-offset: 8 8563 * End: 8564 */ 8565