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