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