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