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/slab.h> 43 #include <linux/sunrpc/clnt.h> 44 #include <linux/sunrpc/gss_api.h> 45 #include <linux/nfs.h> 46 #include <linux/nfs4.h> 47 #include <linux/nfs_fs.h> 48 #include <linux/nfs_page.h> 49 #include <linux/nfs_mount.h> 50 #include <linux/namei.h> 51 #include <linux/mount.h> 52 #include <linux/module.h> 53 #include <linux/sunrpc/bc_xprt.h> 54 #include <linux/xattr.h> 55 #include <linux/utsname.h> 56 57 #include "nfs4_fs.h" 58 #include "delegation.h" 59 #include "internal.h" 60 #include "iostat.h" 61 #include "callback.h" 62 #include "pnfs.h" 63 64 #define NFSDBG_FACILITY NFSDBG_PROC 65 66 #define NFS4_POLL_RETRY_MIN (HZ/10) 67 #define NFS4_POLL_RETRY_MAX (15*HZ) 68 69 #define NFS4_MAX_LOOP_ON_RECOVER (10) 70 71 struct nfs4_opendata; 72 static int _nfs4_proc_open(struct nfs4_opendata *data); 73 static int _nfs4_recover_proc_open(struct nfs4_opendata *data); 74 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); 75 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *); 76 static int _nfs4_proc_lookup(struct rpc_clnt *client, struct inode *dir, 77 const struct qstr *name, struct nfs_fh *fhandle, 78 struct nfs_fattr *fattr); 79 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr); 80 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 81 struct nfs_fattr *fattr, struct iattr *sattr, 82 struct nfs4_state *state); 83 #ifdef CONFIG_NFS_V4_1 84 static int nfs41_test_stateid(struct nfs_server *, struct nfs4_state *); 85 static int nfs41_free_stateid(struct nfs_server *, struct nfs4_state *); 86 #endif 87 /* Prevent leaks of NFSv4 errors into userland */ 88 static int nfs4_map_errors(int err) 89 { 90 if (err >= -1000) 91 return err; 92 switch (err) { 93 case -NFS4ERR_RESOURCE: 94 return -EREMOTEIO; 95 case -NFS4ERR_WRONGSEC: 96 return -EPERM; 97 case -NFS4ERR_BADOWNER: 98 case -NFS4ERR_BADNAME: 99 return -EINVAL; 100 default: 101 dprintk("%s could not handle NFSv4 error %d\n", 102 __func__, -err); 103 break; 104 } 105 return -EIO; 106 } 107 108 /* 109 * This is our standard bitmap for GETATTR requests. 110 */ 111 const u32 nfs4_fattr_bitmap[2] = { 112 FATTR4_WORD0_TYPE 113 | FATTR4_WORD0_CHANGE 114 | FATTR4_WORD0_SIZE 115 | FATTR4_WORD0_FSID 116 | FATTR4_WORD0_FILEID, 117 FATTR4_WORD1_MODE 118 | FATTR4_WORD1_NUMLINKS 119 | FATTR4_WORD1_OWNER 120 | FATTR4_WORD1_OWNER_GROUP 121 | FATTR4_WORD1_RAWDEV 122 | FATTR4_WORD1_SPACE_USED 123 | FATTR4_WORD1_TIME_ACCESS 124 | FATTR4_WORD1_TIME_METADATA 125 | FATTR4_WORD1_TIME_MODIFY 126 }; 127 128 const u32 nfs4_statfs_bitmap[2] = { 129 FATTR4_WORD0_FILES_AVAIL 130 | FATTR4_WORD0_FILES_FREE 131 | FATTR4_WORD0_FILES_TOTAL, 132 FATTR4_WORD1_SPACE_AVAIL 133 | FATTR4_WORD1_SPACE_FREE 134 | FATTR4_WORD1_SPACE_TOTAL 135 }; 136 137 const u32 nfs4_pathconf_bitmap[2] = { 138 FATTR4_WORD0_MAXLINK 139 | FATTR4_WORD0_MAXNAME, 140 0 141 }; 142 143 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE 144 | FATTR4_WORD0_MAXREAD 145 | FATTR4_WORD0_MAXWRITE 146 | FATTR4_WORD0_LEASE_TIME, 147 FATTR4_WORD1_TIME_DELTA 148 | FATTR4_WORD1_FS_LAYOUT_TYPES, 149 FATTR4_WORD2_LAYOUT_BLKSIZE 150 }; 151 152 const u32 nfs4_fs_locations_bitmap[2] = { 153 FATTR4_WORD0_TYPE 154 | FATTR4_WORD0_CHANGE 155 | FATTR4_WORD0_SIZE 156 | FATTR4_WORD0_FSID 157 | FATTR4_WORD0_FILEID 158 | FATTR4_WORD0_FS_LOCATIONS, 159 FATTR4_WORD1_MODE 160 | FATTR4_WORD1_NUMLINKS 161 | FATTR4_WORD1_OWNER 162 | FATTR4_WORD1_OWNER_GROUP 163 | FATTR4_WORD1_RAWDEV 164 | FATTR4_WORD1_SPACE_USED 165 | FATTR4_WORD1_TIME_ACCESS 166 | FATTR4_WORD1_TIME_METADATA 167 | FATTR4_WORD1_TIME_MODIFY 168 | FATTR4_WORD1_MOUNTED_ON_FILEID 169 }; 170 171 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry, 172 struct nfs4_readdir_arg *readdir) 173 { 174 __be32 *start, *p; 175 176 BUG_ON(readdir->count < 80); 177 if (cookie > 2) { 178 readdir->cookie = cookie; 179 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); 180 return; 181 } 182 183 readdir->cookie = 0; 184 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); 185 if (cookie == 2) 186 return; 187 188 /* 189 * NFSv4 servers do not return entries for '.' and '..' 190 * Therefore, we fake these entries here. We let '.' 191 * have cookie 0 and '..' have cookie 1. Note that 192 * when talking to the server, we always send cookie 0 193 * instead of 1 or 2. 194 */ 195 start = p = kmap_atomic(*readdir->pages, KM_USER0); 196 197 if (cookie == 0) { 198 *p++ = xdr_one; /* next */ 199 *p++ = xdr_zero; /* cookie, first word */ 200 *p++ = xdr_one; /* cookie, second word */ 201 *p++ = xdr_one; /* entry len */ 202 memcpy(p, ".\0\0\0", 4); /* entry */ 203 p++; 204 *p++ = xdr_one; /* bitmap length */ 205 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 206 *p++ = htonl(8); /* attribute buffer length */ 207 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); 208 } 209 210 *p++ = xdr_one; /* next */ 211 *p++ = xdr_zero; /* cookie, first word */ 212 *p++ = xdr_two; /* cookie, second word */ 213 *p++ = xdr_two; /* entry len */ 214 memcpy(p, "..\0\0", 4); /* entry */ 215 p++; 216 *p++ = xdr_one; /* bitmap length */ 217 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 218 *p++ = htonl(8); /* attribute buffer length */ 219 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); 220 221 readdir->pgbase = (char *)p - (char *)start; 222 readdir->count -= readdir->pgbase; 223 kunmap_atomic(start, KM_USER0); 224 } 225 226 static int nfs4_wait_clnt_recover(struct nfs_client *clp) 227 { 228 int res; 229 230 might_sleep(); 231 232 res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, 233 nfs_wait_bit_killable, TASK_KILLABLE); 234 return res; 235 } 236 237 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout) 238 { 239 int res = 0; 240 241 might_sleep(); 242 243 if (*timeout <= 0) 244 *timeout = NFS4_POLL_RETRY_MIN; 245 if (*timeout > NFS4_POLL_RETRY_MAX) 246 *timeout = NFS4_POLL_RETRY_MAX; 247 schedule_timeout_killable(*timeout); 248 if (fatal_signal_pending(current)) 249 res = -ERESTARTSYS; 250 *timeout <<= 1; 251 return res; 252 } 253 254 /* This is the error handling routine for processes that are allowed 255 * to sleep. 256 */ 257 static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception) 258 { 259 struct nfs_client *clp = server->nfs_client; 260 struct nfs4_state *state = exception->state; 261 int ret = errorcode; 262 263 exception->retry = 0; 264 switch(errorcode) { 265 case 0: 266 return 0; 267 case -NFS4ERR_ADMIN_REVOKED: 268 case -NFS4ERR_BAD_STATEID: 269 case -NFS4ERR_OPENMODE: 270 if (state == NULL) 271 break; 272 nfs4_schedule_stateid_recovery(server, state); 273 goto wait_on_recovery; 274 case -NFS4ERR_EXPIRED: 275 if (state != NULL) 276 nfs4_schedule_stateid_recovery(server, state); 277 case -NFS4ERR_STALE_STATEID: 278 case -NFS4ERR_STALE_CLIENTID: 279 nfs4_schedule_lease_recovery(clp); 280 goto wait_on_recovery; 281 #if defined(CONFIG_NFS_V4_1) 282 case -NFS4ERR_BADSESSION: 283 case -NFS4ERR_BADSLOT: 284 case -NFS4ERR_BAD_HIGH_SLOT: 285 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 286 case -NFS4ERR_DEADSESSION: 287 case -NFS4ERR_SEQ_FALSE_RETRY: 288 case -NFS4ERR_SEQ_MISORDERED: 289 dprintk("%s ERROR: %d Reset session\n", __func__, 290 errorcode); 291 nfs4_schedule_session_recovery(clp->cl_session); 292 exception->retry = 1; 293 break; 294 #endif /* defined(CONFIG_NFS_V4_1) */ 295 case -NFS4ERR_FILE_OPEN: 296 if (exception->timeout > HZ) { 297 /* We have retried a decent amount, time to 298 * fail 299 */ 300 ret = -EBUSY; 301 break; 302 } 303 case -NFS4ERR_GRACE: 304 case -NFS4ERR_DELAY: 305 case -EKEYEXPIRED: 306 ret = nfs4_delay(server->client, &exception->timeout); 307 if (ret != 0) 308 break; 309 case -NFS4ERR_RETRY_UNCACHED_REP: 310 case -NFS4ERR_OLD_STATEID: 311 exception->retry = 1; 312 break; 313 case -NFS4ERR_BADOWNER: 314 /* The following works around a Linux server bug! */ 315 case -NFS4ERR_BADNAME: 316 if (server->caps & NFS_CAP_UIDGID_NOMAP) { 317 server->caps &= ~NFS_CAP_UIDGID_NOMAP; 318 exception->retry = 1; 319 printk(KERN_WARNING "NFS: v4 server %s " 320 "does not accept raw " 321 "uid/gids. " 322 "Reenabling the idmapper.\n", 323 server->nfs_client->cl_hostname); 324 } 325 } 326 /* We failed to handle the error */ 327 return nfs4_map_errors(ret); 328 wait_on_recovery: 329 ret = nfs4_wait_clnt_recover(clp); 330 if (ret == 0) 331 exception->retry = 1; 332 return ret; 333 } 334 335 336 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp) 337 { 338 spin_lock(&clp->cl_lock); 339 if (time_before(clp->cl_last_renewal,timestamp)) 340 clp->cl_last_renewal = timestamp; 341 spin_unlock(&clp->cl_lock); 342 } 343 344 static void renew_lease(const struct nfs_server *server, unsigned long timestamp) 345 { 346 do_renew_lease(server->nfs_client, timestamp); 347 } 348 349 #if defined(CONFIG_NFS_V4_1) 350 351 /* 352 * nfs4_free_slot - free a slot and efficiently update slot table. 353 * 354 * freeing a slot is trivially done by clearing its respective bit 355 * in the bitmap. 356 * If the freed slotid equals highest_used_slotid we want to update it 357 * so that the server would be able to size down the slot table if needed, 358 * otherwise we know that the highest_used_slotid is still in use. 359 * When updating highest_used_slotid there may be "holes" in the bitmap 360 * so we need to scan down from highest_used_slotid to 0 looking for the now 361 * highest slotid in use. 362 * If none found, highest_used_slotid is set to -1. 363 * 364 * Must be called while holding tbl->slot_tbl_lock 365 */ 366 static void 367 nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *free_slot) 368 { 369 int free_slotid = free_slot - tbl->slots; 370 int slotid = free_slotid; 371 372 BUG_ON(slotid < 0 || slotid >= NFS4_MAX_SLOT_TABLE); 373 /* clear used bit in bitmap */ 374 __clear_bit(slotid, tbl->used_slots); 375 376 /* update highest_used_slotid when it is freed */ 377 if (slotid == tbl->highest_used_slotid) { 378 slotid = find_last_bit(tbl->used_slots, tbl->max_slots); 379 if (slotid < tbl->max_slots) 380 tbl->highest_used_slotid = slotid; 381 else 382 tbl->highest_used_slotid = -1; 383 } 384 dprintk("%s: free_slotid %u highest_used_slotid %d\n", __func__, 385 free_slotid, tbl->highest_used_slotid); 386 } 387 388 /* 389 * Signal state manager thread if session fore channel is drained 390 */ 391 static void nfs4_check_drain_fc_complete(struct nfs4_session *ses) 392 { 393 struct rpc_task *task; 394 395 if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state)) { 396 task = rpc_wake_up_next(&ses->fc_slot_table.slot_tbl_waitq); 397 if (task) 398 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 399 return; 400 } 401 402 if (ses->fc_slot_table.highest_used_slotid != -1) 403 return; 404 405 dprintk("%s COMPLETE: Session Fore Channel Drained\n", __func__); 406 complete(&ses->fc_slot_table.complete); 407 } 408 409 /* 410 * Signal state manager thread if session back channel is drained 411 */ 412 void nfs4_check_drain_bc_complete(struct nfs4_session *ses) 413 { 414 if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state) || 415 ses->bc_slot_table.highest_used_slotid != -1) 416 return; 417 dprintk("%s COMPLETE: Session Back Channel Drained\n", __func__); 418 complete(&ses->bc_slot_table.complete); 419 } 420 421 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res) 422 { 423 struct nfs4_slot_table *tbl; 424 425 tbl = &res->sr_session->fc_slot_table; 426 if (!res->sr_slot) { 427 /* just wake up the next guy waiting since 428 * we may have not consumed a slot after all */ 429 dprintk("%s: No slot\n", __func__); 430 return; 431 } 432 433 spin_lock(&tbl->slot_tbl_lock); 434 nfs4_free_slot(tbl, res->sr_slot); 435 nfs4_check_drain_fc_complete(res->sr_session); 436 spin_unlock(&tbl->slot_tbl_lock); 437 res->sr_slot = NULL; 438 } 439 440 static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res) 441 { 442 unsigned long timestamp; 443 struct nfs_client *clp; 444 445 /* 446 * sr_status remains 1 if an RPC level error occurred. The server 447 * may or may not have processed the sequence operation.. 448 * Proceed as if the server received and processed the sequence 449 * operation. 450 */ 451 if (res->sr_status == 1) 452 res->sr_status = NFS_OK; 453 454 /* don't increment the sequence number if the task wasn't sent */ 455 if (!RPC_WAS_SENT(task)) 456 goto out; 457 458 /* Check the SEQUENCE operation status */ 459 switch (res->sr_status) { 460 case 0: 461 /* Update the slot's sequence and clientid lease timer */ 462 ++res->sr_slot->seq_nr; 463 timestamp = res->sr_renewal_time; 464 clp = res->sr_session->clp; 465 do_renew_lease(clp, timestamp); 466 /* Check sequence flags */ 467 if (res->sr_status_flags != 0) 468 nfs4_schedule_lease_recovery(clp); 469 break; 470 case -NFS4ERR_DELAY: 471 /* The server detected a resend of the RPC call and 472 * returned NFS4ERR_DELAY as per Section 2.10.6.2 473 * of RFC5661. 474 */ 475 dprintk("%s: slot=%td seq=%d: Operation in progress\n", 476 __func__, 477 res->sr_slot - res->sr_session->fc_slot_table.slots, 478 res->sr_slot->seq_nr); 479 goto out_retry; 480 default: 481 /* Just update the slot sequence no. */ 482 ++res->sr_slot->seq_nr; 483 } 484 out: 485 /* The session may be reset by one of the error handlers. */ 486 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status); 487 nfs41_sequence_free_slot(res); 488 return 1; 489 out_retry: 490 if (!rpc_restart_call(task)) 491 goto out; 492 rpc_delay(task, NFS4_POLL_RETRY_MAX); 493 return 0; 494 } 495 496 static int nfs4_sequence_done(struct rpc_task *task, 497 struct nfs4_sequence_res *res) 498 { 499 if (res->sr_session == NULL) 500 return 1; 501 return nfs41_sequence_done(task, res); 502 } 503 504 /* 505 * nfs4_find_slot - efficiently look for a free slot 506 * 507 * nfs4_find_slot looks for an unset bit in the used_slots bitmap. 508 * If found, we mark the slot as used, update the highest_used_slotid, 509 * and respectively set up the sequence operation args. 510 * The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise. 511 * 512 * Note: must be called with under the slot_tbl_lock. 513 */ 514 static u8 515 nfs4_find_slot(struct nfs4_slot_table *tbl) 516 { 517 int slotid; 518 u8 ret_id = NFS4_MAX_SLOT_TABLE; 519 BUILD_BUG_ON((u8)NFS4_MAX_SLOT_TABLE != (int)NFS4_MAX_SLOT_TABLE); 520 521 dprintk("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n", 522 __func__, tbl->used_slots[0], tbl->highest_used_slotid, 523 tbl->max_slots); 524 slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slots); 525 if (slotid >= tbl->max_slots) 526 goto out; 527 __set_bit(slotid, tbl->used_slots); 528 if (slotid > tbl->highest_used_slotid) 529 tbl->highest_used_slotid = slotid; 530 ret_id = slotid; 531 out: 532 dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n", 533 __func__, tbl->used_slots[0], tbl->highest_used_slotid, ret_id); 534 return ret_id; 535 } 536 537 int nfs41_setup_sequence(struct nfs4_session *session, 538 struct nfs4_sequence_args *args, 539 struct nfs4_sequence_res *res, 540 int cache_reply, 541 struct rpc_task *task) 542 { 543 struct nfs4_slot *slot; 544 struct nfs4_slot_table *tbl; 545 u8 slotid; 546 547 dprintk("--> %s\n", __func__); 548 /* slot already allocated? */ 549 if (res->sr_slot != NULL) 550 return 0; 551 552 tbl = &session->fc_slot_table; 553 554 spin_lock(&tbl->slot_tbl_lock); 555 if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) && 556 !rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) { 557 /* 558 * The state manager will wait until the slot table is empty. 559 * Schedule the reset thread 560 */ 561 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 562 spin_unlock(&tbl->slot_tbl_lock); 563 dprintk("%s Schedule Session Reset\n", __func__); 564 return -EAGAIN; 565 } 566 567 if (!rpc_queue_empty(&tbl->slot_tbl_waitq) && 568 !rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) { 569 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 570 spin_unlock(&tbl->slot_tbl_lock); 571 dprintk("%s enforce FIFO order\n", __func__); 572 return -EAGAIN; 573 } 574 575 slotid = nfs4_find_slot(tbl); 576 if (slotid == NFS4_MAX_SLOT_TABLE) { 577 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); 578 spin_unlock(&tbl->slot_tbl_lock); 579 dprintk("<-- %s: no free slots\n", __func__); 580 return -EAGAIN; 581 } 582 spin_unlock(&tbl->slot_tbl_lock); 583 584 rpc_task_set_priority(task, RPC_PRIORITY_NORMAL); 585 slot = tbl->slots + slotid; 586 args->sa_session = session; 587 args->sa_slotid = slotid; 588 args->sa_cache_this = cache_reply; 589 590 dprintk("<-- %s slotid=%d seqid=%d\n", __func__, slotid, slot->seq_nr); 591 592 res->sr_session = session; 593 res->sr_slot = slot; 594 res->sr_renewal_time = jiffies; 595 res->sr_status_flags = 0; 596 /* 597 * sr_status is only set in decode_sequence, and so will remain 598 * set to 1 if an rpc level failure occurs. 599 */ 600 res->sr_status = 1; 601 return 0; 602 } 603 EXPORT_SYMBOL_GPL(nfs41_setup_sequence); 604 605 int nfs4_setup_sequence(const struct nfs_server *server, 606 struct nfs4_sequence_args *args, 607 struct nfs4_sequence_res *res, 608 int cache_reply, 609 struct rpc_task *task) 610 { 611 struct nfs4_session *session = nfs4_get_session(server); 612 int ret = 0; 613 614 if (session == NULL) { 615 args->sa_session = NULL; 616 res->sr_session = NULL; 617 goto out; 618 } 619 620 dprintk("--> %s clp %p session %p sr_slot %td\n", 621 __func__, session->clp, session, res->sr_slot ? 622 res->sr_slot - session->fc_slot_table.slots : -1); 623 624 ret = nfs41_setup_sequence(session, args, res, cache_reply, 625 task); 626 out: 627 dprintk("<-- %s status=%d\n", __func__, ret); 628 return ret; 629 } 630 631 struct nfs41_call_sync_data { 632 const struct nfs_server *seq_server; 633 struct nfs4_sequence_args *seq_args; 634 struct nfs4_sequence_res *seq_res; 635 int cache_reply; 636 }; 637 638 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata) 639 { 640 struct nfs41_call_sync_data *data = calldata; 641 642 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server); 643 644 if (nfs4_setup_sequence(data->seq_server, data->seq_args, 645 data->seq_res, data->cache_reply, task)) 646 return; 647 rpc_call_start(task); 648 } 649 650 static void nfs41_call_priv_sync_prepare(struct rpc_task *task, void *calldata) 651 { 652 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 653 nfs41_call_sync_prepare(task, calldata); 654 } 655 656 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata) 657 { 658 struct nfs41_call_sync_data *data = calldata; 659 660 nfs41_sequence_done(task, data->seq_res); 661 } 662 663 struct rpc_call_ops nfs41_call_sync_ops = { 664 .rpc_call_prepare = nfs41_call_sync_prepare, 665 .rpc_call_done = nfs41_call_sync_done, 666 }; 667 668 struct rpc_call_ops nfs41_call_priv_sync_ops = { 669 .rpc_call_prepare = nfs41_call_priv_sync_prepare, 670 .rpc_call_done = nfs41_call_sync_done, 671 }; 672 673 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt, 674 struct nfs_server *server, 675 struct rpc_message *msg, 676 struct nfs4_sequence_args *args, 677 struct nfs4_sequence_res *res, 678 int cache_reply, 679 int privileged) 680 { 681 int ret; 682 struct rpc_task *task; 683 struct nfs41_call_sync_data data = { 684 .seq_server = server, 685 .seq_args = args, 686 .seq_res = res, 687 .cache_reply = cache_reply, 688 }; 689 struct rpc_task_setup task_setup = { 690 .rpc_client = clnt, 691 .rpc_message = msg, 692 .callback_ops = &nfs41_call_sync_ops, 693 .callback_data = &data 694 }; 695 696 res->sr_slot = NULL; 697 if (privileged) 698 task_setup.callback_ops = &nfs41_call_priv_sync_ops; 699 task = rpc_run_task(&task_setup); 700 if (IS_ERR(task)) 701 ret = PTR_ERR(task); 702 else { 703 ret = task->tk_status; 704 rpc_put_task(task); 705 } 706 return ret; 707 } 708 709 int _nfs4_call_sync_session(struct rpc_clnt *clnt, 710 struct nfs_server *server, 711 struct rpc_message *msg, 712 struct nfs4_sequence_args *args, 713 struct nfs4_sequence_res *res, 714 int cache_reply) 715 { 716 return nfs4_call_sync_sequence(clnt, server, msg, args, res, cache_reply, 0); 717 } 718 719 #else 720 static int nfs4_sequence_done(struct rpc_task *task, 721 struct nfs4_sequence_res *res) 722 { 723 return 1; 724 } 725 #endif /* CONFIG_NFS_V4_1 */ 726 727 int _nfs4_call_sync(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 int cache_reply) 733 { 734 args->sa_session = res->sr_session = NULL; 735 return rpc_call_sync(clnt, msg, 0); 736 } 737 738 static inline 739 int nfs4_call_sync(struct rpc_clnt *clnt, 740 struct nfs_server *server, 741 struct rpc_message *msg, 742 struct nfs4_sequence_args *args, 743 struct nfs4_sequence_res *res, 744 int cache_reply) 745 { 746 return server->nfs_client->cl_mvops->call_sync(clnt, server, msg, 747 args, res, cache_reply); 748 } 749 750 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo) 751 { 752 struct nfs_inode *nfsi = NFS_I(dir); 753 754 spin_lock(&dir->i_lock); 755 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA; 756 if (!cinfo->atomic || cinfo->before != nfsi->change_attr) 757 nfs_force_lookup_revalidate(dir); 758 nfsi->change_attr = cinfo->after; 759 spin_unlock(&dir->i_lock); 760 } 761 762 struct nfs4_opendata { 763 struct kref kref; 764 struct nfs_openargs o_arg; 765 struct nfs_openres o_res; 766 struct nfs_open_confirmargs c_arg; 767 struct nfs_open_confirmres c_res; 768 struct nfs_fattr f_attr; 769 struct nfs_fattr dir_attr; 770 struct dentry *dir; 771 struct dentry *dentry; 772 struct nfs4_state_owner *owner; 773 struct nfs4_state *state; 774 struct iattr attrs; 775 unsigned long timestamp; 776 unsigned int rpc_done : 1; 777 int rpc_status; 778 int cancelled; 779 }; 780 781 782 static void nfs4_init_opendata_res(struct nfs4_opendata *p) 783 { 784 p->o_res.f_attr = &p->f_attr; 785 p->o_res.dir_attr = &p->dir_attr; 786 p->o_res.seqid = p->o_arg.seqid; 787 p->c_res.seqid = p->c_arg.seqid; 788 p->o_res.server = p->o_arg.server; 789 nfs_fattr_init(&p->f_attr); 790 nfs_fattr_init(&p->dir_attr); 791 } 792 793 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry, 794 struct nfs4_state_owner *sp, fmode_t fmode, int flags, 795 const struct iattr *attrs, 796 gfp_t gfp_mask) 797 { 798 struct dentry *parent = dget_parent(dentry); 799 struct inode *dir = parent->d_inode; 800 struct nfs_server *server = NFS_SERVER(dir); 801 struct nfs4_opendata *p; 802 803 p = kzalloc(sizeof(*p), gfp_mask); 804 if (p == NULL) 805 goto err; 806 p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask); 807 if (p->o_arg.seqid == NULL) 808 goto err_free; 809 nfs_sb_active(dentry->d_sb); 810 p->dentry = dget(dentry); 811 p->dir = parent; 812 p->owner = sp; 813 atomic_inc(&sp->so_count); 814 p->o_arg.fh = NFS_FH(dir); 815 p->o_arg.open_flags = flags; 816 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); 817 p->o_arg.clientid = server->nfs_client->cl_clientid; 818 p->o_arg.id = sp->so_owner_id.id; 819 p->o_arg.name = &dentry->d_name; 820 p->o_arg.server = server; 821 p->o_arg.bitmask = server->attr_bitmask; 822 p->o_arg.claim = NFS4_OPEN_CLAIM_NULL; 823 if (flags & O_CREAT) { 824 u32 *s; 825 826 p->o_arg.u.attrs = &p->attrs; 827 memcpy(&p->attrs, attrs, sizeof(p->attrs)); 828 s = (u32 *) p->o_arg.u.verifier.data; 829 s[0] = jiffies; 830 s[1] = current->pid; 831 } 832 p->c_arg.fh = &p->o_res.fh; 833 p->c_arg.stateid = &p->o_res.stateid; 834 p->c_arg.seqid = p->o_arg.seqid; 835 nfs4_init_opendata_res(p); 836 kref_init(&p->kref); 837 return p; 838 err_free: 839 kfree(p); 840 err: 841 dput(parent); 842 return NULL; 843 } 844 845 static void nfs4_opendata_free(struct kref *kref) 846 { 847 struct nfs4_opendata *p = container_of(kref, 848 struct nfs4_opendata, kref); 849 struct super_block *sb = p->dentry->d_sb; 850 851 nfs_free_seqid(p->o_arg.seqid); 852 if (p->state != NULL) 853 nfs4_put_open_state(p->state); 854 nfs4_put_state_owner(p->owner); 855 dput(p->dir); 856 dput(p->dentry); 857 nfs_sb_deactive(sb); 858 kfree(p); 859 } 860 861 static void nfs4_opendata_put(struct nfs4_opendata *p) 862 { 863 if (p != NULL) 864 kref_put(&p->kref, nfs4_opendata_free); 865 } 866 867 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) 868 { 869 int ret; 870 871 ret = rpc_wait_for_completion_task(task); 872 return ret; 873 } 874 875 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode) 876 { 877 int ret = 0; 878 879 if (open_mode & O_EXCL) 880 goto out; 881 switch (mode & (FMODE_READ|FMODE_WRITE)) { 882 case FMODE_READ: 883 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 884 && state->n_rdonly != 0; 885 break; 886 case FMODE_WRITE: 887 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 888 && state->n_wronly != 0; 889 break; 890 case FMODE_READ|FMODE_WRITE: 891 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 892 && state->n_rdwr != 0; 893 } 894 out: 895 return ret; 896 } 897 898 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode) 899 { 900 if ((delegation->type & fmode) != fmode) 901 return 0; 902 if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) 903 return 0; 904 nfs_mark_delegation_referenced(delegation); 905 return 1; 906 } 907 908 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode) 909 { 910 switch (fmode) { 911 case FMODE_WRITE: 912 state->n_wronly++; 913 break; 914 case FMODE_READ: 915 state->n_rdonly++; 916 break; 917 case FMODE_READ|FMODE_WRITE: 918 state->n_rdwr++; 919 } 920 nfs4_state_set_mode_locked(state, state->state | fmode); 921 } 922 923 static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 924 { 925 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 926 memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); 927 memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); 928 switch (fmode) { 929 case FMODE_READ: 930 set_bit(NFS_O_RDONLY_STATE, &state->flags); 931 break; 932 case FMODE_WRITE: 933 set_bit(NFS_O_WRONLY_STATE, &state->flags); 934 break; 935 case FMODE_READ|FMODE_WRITE: 936 set_bit(NFS_O_RDWR_STATE, &state->flags); 937 } 938 } 939 940 static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 941 { 942 write_seqlock(&state->seqlock); 943 nfs_set_open_stateid_locked(state, stateid, fmode); 944 write_sequnlock(&state->seqlock); 945 } 946 947 static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode) 948 { 949 /* 950 * Protect the call to nfs4_state_set_mode_locked and 951 * serialise the stateid update 952 */ 953 write_seqlock(&state->seqlock); 954 if (deleg_stateid != NULL) { 955 memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data)); 956 set_bit(NFS_DELEGATED_STATE, &state->flags); 957 } 958 if (open_stateid != NULL) 959 nfs_set_open_stateid_locked(state, open_stateid, fmode); 960 write_sequnlock(&state->seqlock); 961 spin_lock(&state->owner->so_lock); 962 update_open_stateflags(state, fmode); 963 spin_unlock(&state->owner->so_lock); 964 } 965 966 static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode) 967 { 968 struct nfs_inode *nfsi = NFS_I(state->inode); 969 struct nfs_delegation *deleg_cur; 970 int ret = 0; 971 972 fmode &= (FMODE_READ|FMODE_WRITE); 973 974 rcu_read_lock(); 975 deleg_cur = rcu_dereference(nfsi->delegation); 976 if (deleg_cur == NULL) 977 goto no_delegation; 978 979 spin_lock(&deleg_cur->lock); 980 if (nfsi->delegation != deleg_cur || 981 (deleg_cur->type & fmode) != fmode) 982 goto no_delegation_unlock; 983 984 if (delegation == NULL) 985 delegation = &deleg_cur->stateid; 986 else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0) 987 goto no_delegation_unlock; 988 989 nfs_mark_delegation_referenced(deleg_cur); 990 __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); 991 ret = 1; 992 no_delegation_unlock: 993 spin_unlock(&deleg_cur->lock); 994 no_delegation: 995 rcu_read_unlock(); 996 997 if (!ret && open_stateid != NULL) { 998 __update_open_stateid(state, open_stateid, NULL, fmode); 999 ret = 1; 1000 } 1001 1002 return ret; 1003 } 1004 1005 1006 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode) 1007 { 1008 struct nfs_delegation *delegation; 1009 1010 rcu_read_lock(); 1011 delegation = rcu_dereference(NFS_I(inode)->delegation); 1012 if (delegation == NULL || (delegation->type & fmode) == fmode) { 1013 rcu_read_unlock(); 1014 return; 1015 } 1016 rcu_read_unlock(); 1017 nfs_inode_return_delegation(inode); 1018 } 1019 1020 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata) 1021 { 1022 struct nfs4_state *state = opendata->state; 1023 struct nfs_inode *nfsi = NFS_I(state->inode); 1024 struct nfs_delegation *delegation; 1025 int open_mode = opendata->o_arg.open_flags & O_EXCL; 1026 fmode_t fmode = opendata->o_arg.fmode; 1027 nfs4_stateid stateid; 1028 int ret = -EAGAIN; 1029 1030 for (;;) { 1031 if (can_open_cached(state, fmode, open_mode)) { 1032 spin_lock(&state->owner->so_lock); 1033 if (can_open_cached(state, fmode, open_mode)) { 1034 update_open_stateflags(state, fmode); 1035 spin_unlock(&state->owner->so_lock); 1036 goto out_return_state; 1037 } 1038 spin_unlock(&state->owner->so_lock); 1039 } 1040 rcu_read_lock(); 1041 delegation = rcu_dereference(nfsi->delegation); 1042 if (delegation == NULL || 1043 !can_open_delegated(delegation, fmode)) { 1044 rcu_read_unlock(); 1045 break; 1046 } 1047 /* Save the delegation */ 1048 memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data)); 1049 rcu_read_unlock(); 1050 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); 1051 if (ret != 0) 1052 goto out; 1053 ret = -EAGAIN; 1054 1055 /* Try to update the stateid using the delegation */ 1056 if (update_open_stateid(state, NULL, &stateid, fmode)) 1057 goto out_return_state; 1058 } 1059 out: 1060 return ERR_PTR(ret); 1061 out_return_state: 1062 atomic_inc(&state->count); 1063 return state; 1064 } 1065 1066 static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 1067 { 1068 struct inode *inode; 1069 struct nfs4_state *state = NULL; 1070 struct nfs_delegation *delegation; 1071 int ret; 1072 1073 if (!data->rpc_done) { 1074 state = nfs4_try_open_cached(data); 1075 goto out; 1076 } 1077 1078 ret = -EAGAIN; 1079 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) 1080 goto err; 1081 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr); 1082 ret = PTR_ERR(inode); 1083 if (IS_ERR(inode)) 1084 goto err; 1085 ret = -ENOMEM; 1086 state = nfs4_get_open_state(inode, data->owner); 1087 if (state == NULL) 1088 goto err_put_inode; 1089 if (data->o_res.delegation_type != 0) { 1090 int delegation_flags = 0; 1091 1092 rcu_read_lock(); 1093 delegation = rcu_dereference(NFS_I(inode)->delegation); 1094 if (delegation) 1095 delegation_flags = delegation->flags; 1096 rcu_read_unlock(); 1097 if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0) 1098 nfs_inode_set_delegation(state->inode, 1099 data->owner->so_cred, 1100 &data->o_res); 1101 else 1102 nfs_inode_reclaim_delegation(state->inode, 1103 data->owner->so_cred, 1104 &data->o_res); 1105 } 1106 1107 update_open_stateid(state, &data->o_res.stateid, NULL, 1108 data->o_arg.fmode); 1109 iput(inode); 1110 out: 1111 return state; 1112 err_put_inode: 1113 iput(inode); 1114 err: 1115 return ERR_PTR(ret); 1116 } 1117 1118 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state) 1119 { 1120 struct nfs_inode *nfsi = NFS_I(state->inode); 1121 struct nfs_open_context *ctx; 1122 1123 spin_lock(&state->inode->i_lock); 1124 list_for_each_entry(ctx, &nfsi->open_files, list) { 1125 if (ctx->state != state) 1126 continue; 1127 get_nfs_open_context(ctx); 1128 spin_unlock(&state->inode->i_lock); 1129 return ctx; 1130 } 1131 spin_unlock(&state->inode->i_lock); 1132 return ERR_PTR(-ENOENT); 1133 } 1134 1135 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state) 1136 { 1137 struct nfs4_opendata *opendata; 1138 1139 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, NULL, GFP_NOFS); 1140 if (opendata == NULL) 1141 return ERR_PTR(-ENOMEM); 1142 opendata->state = state; 1143 atomic_inc(&state->count); 1144 return opendata; 1145 } 1146 1147 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res) 1148 { 1149 struct nfs4_state *newstate; 1150 int ret; 1151 1152 opendata->o_arg.open_flags = 0; 1153 opendata->o_arg.fmode = fmode; 1154 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); 1155 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); 1156 nfs4_init_opendata_res(opendata); 1157 ret = _nfs4_recover_proc_open(opendata); 1158 if (ret != 0) 1159 return ret; 1160 newstate = nfs4_opendata_to_nfs4_state(opendata); 1161 if (IS_ERR(newstate)) 1162 return PTR_ERR(newstate); 1163 nfs4_close_state(newstate, fmode); 1164 *res = newstate; 1165 return 0; 1166 } 1167 1168 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state) 1169 { 1170 struct nfs4_state *newstate; 1171 int ret; 1172 1173 /* memory barrier prior to reading state->n_* */ 1174 clear_bit(NFS_DELEGATED_STATE, &state->flags); 1175 smp_rmb(); 1176 if (state->n_rdwr != 0) { 1177 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1178 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate); 1179 if (ret != 0) 1180 return ret; 1181 if (newstate != state) 1182 return -ESTALE; 1183 } 1184 if (state->n_wronly != 0) { 1185 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1186 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate); 1187 if (ret != 0) 1188 return ret; 1189 if (newstate != state) 1190 return -ESTALE; 1191 } 1192 if (state->n_rdonly != 0) { 1193 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1194 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate); 1195 if (ret != 0) 1196 return ret; 1197 if (newstate != state) 1198 return -ESTALE; 1199 } 1200 /* 1201 * We may have performed cached opens for all three recoveries. 1202 * Check if we need to update the current stateid. 1203 */ 1204 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && 1205 memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) { 1206 write_seqlock(&state->seqlock); 1207 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 1208 memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)); 1209 write_sequnlock(&state->seqlock); 1210 } 1211 return 0; 1212 } 1213 1214 /* 1215 * OPEN_RECLAIM: 1216 * reclaim state on the server after a reboot. 1217 */ 1218 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1219 { 1220 struct nfs_delegation *delegation; 1221 struct nfs4_opendata *opendata; 1222 fmode_t delegation_type = 0; 1223 int status; 1224 1225 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1226 if (IS_ERR(opendata)) 1227 return PTR_ERR(opendata); 1228 opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS; 1229 opendata->o_arg.fh = NFS_FH(state->inode); 1230 rcu_read_lock(); 1231 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 1232 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) 1233 delegation_type = delegation->type; 1234 rcu_read_unlock(); 1235 opendata->o_arg.u.delegation_type = delegation_type; 1236 status = nfs4_open_recover(opendata, state); 1237 nfs4_opendata_put(opendata); 1238 return status; 1239 } 1240 1241 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 1242 { 1243 struct nfs_server *server = NFS_SERVER(state->inode); 1244 struct nfs4_exception exception = { }; 1245 int err; 1246 do { 1247 err = _nfs4_do_open_reclaim(ctx, state); 1248 if (err != -NFS4ERR_DELAY) 1249 break; 1250 nfs4_handle_exception(server, err, &exception); 1251 } while (exception.retry); 1252 return err; 1253 } 1254 1255 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state) 1256 { 1257 struct nfs_open_context *ctx; 1258 int ret; 1259 1260 ctx = nfs4_state_find_open_context(state); 1261 if (IS_ERR(ctx)) 1262 return PTR_ERR(ctx); 1263 ret = nfs4_do_open_reclaim(ctx, state); 1264 put_nfs_open_context(ctx); 1265 return ret; 1266 } 1267 1268 static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 1269 { 1270 struct nfs4_opendata *opendata; 1271 int ret; 1272 1273 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1274 if (IS_ERR(opendata)) 1275 return PTR_ERR(opendata); 1276 opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR; 1277 memcpy(opendata->o_arg.u.delegation.data, stateid->data, 1278 sizeof(opendata->o_arg.u.delegation.data)); 1279 ret = nfs4_open_recover(opendata, state); 1280 nfs4_opendata_put(opendata); 1281 return ret; 1282 } 1283 1284 int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 1285 { 1286 struct nfs4_exception exception = { }; 1287 struct nfs_server *server = NFS_SERVER(state->inode); 1288 int err; 1289 do { 1290 err = _nfs4_open_delegation_recall(ctx, state, stateid); 1291 switch (err) { 1292 case 0: 1293 case -ENOENT: 1294 case -ESTALE: 1295 goto out; 1296 case -NFS4ERR_BADSESSION: 1297 case -NFS4ERR_BADSLOT: 1298 case -NFS4ERR_BAD_HIGH_SLOT: 1299 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1300 case -NFS4ERR_DEADSESSION: 1301 nfs4_schedule_session_recovery(server->nfs_client->cl_session); 1302 goto out; 1303 case -NFS4ERR_STALE_CLIENTID: 1304 case -NFS4ERR_STALE_STATEID: 1305 case -NFS4ERR_EXPIRED: 1306 /* Don't recall a delegation if it was lost */ 1307 nfs4_schedule_lease_recovery(server->nfs_client); 1308 goto out; 1309 case -ERESTARTSYS: 1310 /* 1311 * The show must go on: exit, but mark the 1312 * stateid as needing recovery. 1313 */ 1314 case -NFS4ERR_ADMIN_REVOKED: 1315 case -NFS4ERR_BAD_STATEID: 1316 nfs4_schedule_stateid_recovery(server, state); 1317 case -EKEYEXPIRED: 1318 /* 1319 * User RPCSEC_GSS context has expired. 1320 * We cannot recover this stateid now, so 1321 * skip it and allow recovery thread to 1322 * proceed. 1323 */ 1324 case -ENOMEM: 1325 err = 0; 1326 goto out; 1327 } 1328 err = nfs4_handle_exception(server, err, &exception); 1329 } while (exception.retry); 1330 out: 1331 return err; 1332 } 1333 1334 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) 1335 { 1336 struct nfs4_opendata *data = calldata; 1337 1338 data->rpc_status = task->tk_status; 1339 if (data->rpc_status == 0) { 1340 memcpy(data->o_res.stateid.data, data->c_res.stateid.data, 1341 sizeof(data->o_res.stateid.data)); 1342 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1343 renew_lease(data->o_res.server, data->timestamp); 1344 data->rpc_done = 1; 1345 } 1346 } 1347 1348 static void nfs4_open_confirm_release(void *calldata) 1349 { 1350 struct nfs4_opendata *data = calldata; 1351 struct nfs4_state *state = NULL; 1352 1353 /* If this request hasn't been cancelled, do nothing */ 1354 if (data->cancelled == 0) 1355 goto out_free; 1356 /* In case of error, no cleanup! */ 1357 if (!data->rpc_done) 1358 goto out_free; 1359 state = nfs4_opendata_to_nfs4_state(data); 1360 if (!IS_ERR(state)) 1361 nfs4_close_state(state, data->o_arg.fmode); 1362 out_free: 1363 nfs4_opendata_put(data); 1364 } 1365 1366 static const struct rpc_call_ops nfs4_open_confirm_ops = { 1367 .rpc_call_done = nfs4_open_confirm_done, 1368 .rpc_release = nfs4_open_confirm_release, 1369 }; 1370 1371 /* 1372 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata 1373 */ 1374 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 1375 { 1376 struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 1377 struct rpc_task *task; 1378 struct rpc_message msg = { 1379 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM], 1380 .rpc_argp = &data->c_arg, 1381 .rpc_resp = &data->c_res, 1382 .rpc_cred = data->owner->so_cred, 1383 }; 1384 struct rpc_task_setup task_setup_data = { 1385 .rpc_client = server->client, 1386 .rpc_message = &msg, 1387 .callback_ops = &nfs4_open_confirm_ops, 1388 .callback_data = data, 1389 .workqueue = nfsiod_workqueue, 1390 .flags = RPC_TASK_ASYNC, 1391 }; 1392 int status; 1393 1394 kref_get(&data->kref); 1395 data->rpc_done = 0; 1396 data->rpc_status = 0; 1397 data->timestamp = jiffies; 1398 task = rpc_run_task(&task_setup_data); 1399 if (IS_ERR(task)) 1400 return PTR_ERR(task); 1401 status = nfs4_wait_for_completion_rpc_task(task); 1402 if (status != 0) { 1403 data->cancelled = 1; 1404 smp_wmb(); 1405 } else 1406 status = data->rpc_status; 1407 rpc_put_task(task); 1408 return status; 1409 } 1410 1411 static void nfs4_open_prepare(struct rpc_task *task, void *calldata) 1412 { 1413 struct nfs4_opendata *data = calldata; 1414 struct nfs4_state_owner *sp = data->owner; 1415 1416 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) 1417 return; 1418 /* 1419 * Check if we still need to send an OPEN call, or if we can use 1420 * a delegation instead. 1421 */ 1422 if (data->state != NULL) { 1423 struct nfs_delegation *delegation; 1424 1425 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) 1426 goto out_no_action; 1427 rcu_read_lock(); 1428 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); 1429 if (delegation != NULL && 1430 test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) { 1431 rcu_read_unlock(); 1432 goto out_no_action; 1433 } 1434 rcu_read_unlock(); 1435 } 1436 /* Update sequence id. */ 1437 data->o_arg.id = sp->so_owner_id.id; 1438 data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid; 1439 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) { 1440 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; 1441 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); 1442 } 1443 data->timestamp = jiffies; 1444 if (nfs4_setup_sequence(data->o_arg.server, 1445 &data->o_arg.seq_args, 1446 &data->o_res.seq_res, 1, task)) 1447 return; 1448 rpc_call_start(task); 1449 return; 1450 out_no_action: 1451 task->tk_action = NULL; 1452 1453 } 1454 1455 static void nfs4_recover_open_prepare(struct rpc_task *task, void *calldata) 1456 { 1457 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 1458 nfs4_open_prepare(task, calldata); 1459 } 1460 1461 static void nfs4_open_done(struct rpc_task *task, void *calldata) 1462 { 1463 struct nfs4_opendata *data = calldata; 1464 1465 data->rpc_status = task->tk_status; 1466 1467 if (!nfs4_sequence_done(task, &data->o_res.seq_res)) 1468 return; 1469 1470 if (task->tk_status == 0) { 1471 switch (data->o_res.f_attr->mode & S_IFMT) { 1472 case S_IFREG: 1473 break; 1474 case S_IFLNK: 1475 data->rpc_status = -ELOOP; 1476 break; 1477 case S_IFDIR: 1478 data->rpc_status = -EISDIR; 1479 break; 1480 default: 1481 data->rpc_status = -ENOTDIR; 1482 } 1483 renew_lease(data->o_res.server, data->timestamp); 1484 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) 1485 nfs_confirm_seqid(&data->owner->so_seqid, 0); 1486 } 1487 data->rpc_done = 1; 1488 } 1489 1490 static void nfs4_open_release(void *calldata) 1491 { 1492 struct nfs4_opendata *data = calldata; 1493 struct nfs4_state *state = NULL; 1494 1495 /* If this request hasn't been cancelled, do nothing */ 1496 if (data->cancelled == 0) 1497 goto out_free; 1498 /* In case of error, no cleanup! */ 1499 if (data->rpc_status != 0 || !data->rpc_done) 1500 goto out_free; 1501 /* In case we need an open_confirm, no cleanup! */ 1502 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) 1503 goto out_free; 1504 state = nfs4_opendata_to_nfs4_state(data); 1505 if (!IS_ERR(state)) 1506 nfs4_close_state(state, data->o_arg.fmode); 1507 out_free: 1508 nfs4_opendata_put(data); 1509 } 1510 1511 static const struct rpc_call_ops nfs4_open_ops = { 1512 .rpc_call_prepare = nfs4_open_prepare, 1513 .rpc_call_done = nfs4_open_done, 1514 .rpc_release = nfs4_open_release, 1515 }; 1516 1517 static const struct rpc_call_ops nfs4_recover_open_ops = { 1518 .rpc_call_prepare = nfs4_recover_open_prepare, 1519 .rpc_call_done = nfs4_open_done, 1520 .rpc_release = nfs4_open_release, 1521 }; 1522 1523 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover) 1524 { 1525 struct inode *dir = data->dir->d_inode; 1526 struct nfs_server *server = NFS_SERVER(dir); 1527 struct nfs_openargs *o_arg = &data->o_arg; 1528 struct nfs_openres *o_res = &data->o_res; 1529 struct rpc_task *task; 1530 struct rpc_message msg = { 1531 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN], 1532 .rpc_argp = o_arg, 1533 .rpc_resp = o_res, 1534 .rpc_cred = data->owner->so_cred, 1535 }; 1536 struct rpc_task_setup task_setup_data = { 1537 .rpc_client = server->client, 1538 .rpc_message = &msg, 1539 .callback_ops = &nfs4_open_ops, 1540 .callback_data = data, 1541 .workqueue = nfsiod_workqueue, 1542 .flags = RPC_TASK_ASYNC, 1543 }; 1544 int status; 1545 1546 kref_get(&data->kref); 1547 data->rpc_done = 0; 1548 data->rpc_status = 0; 1549 data->cancelled = 0; 1550 if (isrecover) 1551 task_setup_data.callback_ops = &nfs4_recover_open_ops; 1552 task = rpc_run_task(&task_setup_data); 1553 if (IS_ERR(task)) 1554 return PTR_ERR(task); 1555 status = nfs4_wait_for_completion_rpc_task(task); 1556 if (status != 0) { 1557 data->cancelled = 1; 1558 smp_wmb(); 1559 } else 1560 status = data->rpc_status; 1561 rpc_put_task(task); 1562 1563 return status; 1564 } 1565 1566 static int _nfs4_recover_proc_open(struct nfs4_opendata *data) 1567 { 1568 struct inode *dir = data->dir->d_inode; 1569 struct nfs_openres *o_res = &data->o_res; 1570 int status; 1571 1572 status = nfs4_run_open_task(data, 1); 1573 if (status != 0 || !data->rpc_done) 1574 return status; 1575 1576 nfs_refresh_inode(dir, o_res->dir_attr); 1577 1578 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 1579 status = _nfs4_proc_open_confirm(data); 1580 if (status != 0) 1581 return status; 1582 } 1583 1584 return status; 1585 } 1586 1587 /* 1588 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata 1589 */ 1590 static int _nfs4_proc_open(struct nfs4_opendata *data) 1591 { 1592 struct inode *dir = data->dir->d_inode; 1593 struct nfs_server *server = NFS_SERVER(dir); 1594 struct nfs_openargs *o_arg = &data->o_arg; 1595 struct nfs_openres *o_res = &data->o_res; 1596 int status; 1597 1598 status = nfs4_run_open_task(data, 0); 1599 if (status != 0 || !data->rpc_done) 1600 return status; 1601 1602 if (o_arg->open_flags & O_CREAT) { 1603 update_changeattr(dir, &o_res->cinfo); 1604 nfs_post_op_update_inode(dir, o_res->dir_attr); 1605 } else 1606 nfs_refresh_inode(dir, o_res->dir_attr); 1607 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) 1608 server->caps &= ~NFS_CAP_POSIX_LOCK; 1609 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 1610 status = _nfs4_proc_open_confirm(data); 1611 if (status != 0) 1612 return status; 1613 } 1614 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) 1615 _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr); 1616 return 0; 1617 } 1618 1619 static int nfs4_client_recover_expired_lease(struct nfs_client *clp) 1620 { 1621 unsigned int loop; 1622 int ret; 1623 1624 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { 1625 ret = nfs4_wait_clnt_recover(clp); 1626 if (ret != 0) 1627 break; 1628 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && 1629 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) 1630 break; 1631 nfs4_schedule_state_manager(clp); 1632 ret = -EIO; 1633 } 1634 return ret; 1635 } 1636 1637 static int nfs4_recover_expired_lease(struct nfs_server *server) 1638 { 1639 return nfs4_client_recover_expired_lease(server->nfs_client); 1640 } 1641 1642 /* 1643 * OPEN_EXPIRED: 1644 * reclaim state on the server after a network partition. 1645 * Assumes caller holds the appropriate lock 1646 */ 1647 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 1648 { 1649 struct nfs4_opendata *opendata; 1650 int ret; 1651 1652 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1653 if (IS_ERR(opendata)) 1654 return PTR_ERR(opendata); 1655 ret = nfs4_open_recover(opendata, state); 1656 if (ret == -ESTALE) 1657 d_drop(ctx->dentry); 1658 nfs4_opendata_put(opendata); 1659 return ret; 1660 } 1661 1662 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 1663 { 1664 struct nfs_server *server = NFS_SERVER(state->inode); 1665 struct nfs4_exception exception = { }; 1666 int err; 1667 1668 do { 1669 err = _nfs4_open_expired(ctx, state); 1670 switch (err) { 1671 default: 1672 goto out; 1673 case -NFS4ERR_GRACE: 1674 case -NFS4ERR_DELAY: 1675 nfs4_handle_exception(server, err, &exception); 1676 err = 0; 1677 } 1678 } while (exception.retry); 1679 out: 1680 return err; 1681 } 1682 1683 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 1684 { 1685 struct nfs_open_context *ctx; 1686 int ret; 1687 1688 ctx = nfs4_state_find_open_context(state); 1689 if (IS_ERR(ctx)) 1690 return PTR_ERR(ctx); 1691 ret = nfs4_do_open_expired(ctx, state); 1692 put_nfs_open_context(ctx); 1693 return ret; 1694 } 1695 1696 #if defined(CONFIG_NFS_V4_1) 1697 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 1698 { 1699 int status; 1700 struct nfs_server *server = NFS_SERVER(state->inode); 1701 1702 status = nfs41_test_stateid(server, state); 1703 if (status == NFS_OK) 1704 return 0; 1705 nfs41_free_stateid(server, state); 1706 return nfs4_open_expired(sp, state); 1707 } 1708 #endif 1709 1710 /* 1711 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-* 1712 * fields corresponding to attributes that were used to store the verifier. 1713 * Make sure we clobber those fields in the later setattr call 1714 */ 1715 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr) 1716 { 1717 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) && 1718 !(sattr->ia_valid & ATTR_ATIME_SET)) 1719 sattr->ia_valid |= ATTR_ATIME; 1720 1721 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) && 1722 !(sattr->ia_valid & ATTR_MTIME_SET)) 1723 sattr->ia_valid |= ATTR_MTIME; 1724 } 1725 1726 /* 1727 * Returns a referenced nfs4_state 1728 */ 1729 static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res) 1730 { 1731 struct nfs4_state_owner *sp; 1732 struct nfs4_state *state = NULL; 1733 struct nfs_server *server = NFS_SERVER(dir); 1734 struct nfs4_opendata *opendata; 1735 int status; 1736 1737 /* Protect against reboot recovery conflicts */ 1738 status = -ENOMEM; 1739 if (!(sp = nfs4_get_state_owner(server, cred))) { 1740 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n"); 1741 goto out_err; 1742 } 1743 status = nfs4_recover_expired_lease(server); 1744 if (status != 0) 1745 goto err_put_state_owner; 1746 if (dentry->d_inode != NULL) 1747 nfs4_return_incompatible_delegation(dentry->d_inode, fmode); 1748 status = -ENOMEM; 1749 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, GFP_KERNEL); 1750 if (opendata == NULL) 1751 goto err_put_state_owner; 1752 1753 if (dentry->d_inode != NULL) 1754 opendata->state = nfs4_get_open_state(dentry->d_inode, sp); 1755 1756 status = _nfs4_proc_open(opendata); 1757 if (status != 0) 1758 goto err_opendata_put; 1759 1760 state = nfs4_opendata_to_nfs4_state(opendata); 1761 status = PTR_ERR(state); 1762 if (IS_ERR(state)) 1763 goto err_opendata_put; 1764 if (server->caps & NFS_CAP_POSIX_LOCK) 1765 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); 1766 1767 if (opendata->o_arg.open_flags & O_EXCL) { 1768 nfs4_exclusive_attrset(opendata, sattr); 1769 1770 nfs_fattr_init(opendata->o_res.f_attr); 1771 status = nfs4_do_setattr(state->inode, cred, 1772 opendata->o_res.f_attr, sattr, 1773 state); 1774 if (status == 0) 1775 nfs_setattr_update_inode(state->inode, sattr); 1776 nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr); 1777 } 1778 nfs4_opendata_put(opendata); 1779 nfs4_put_state_owner(sp); 1780 *res = state; 1781 return 0; 1782 err_opendata_put: 1783 nfs4_opendata_put(opendata); 1784 err_put_state_owner: 1785 nfs4_put_state_owner(sp); 1786 out_err: 1787 *res = NULL; 1788 return status; 1789 } 1790 1791 1792 static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred) 1793 { 1794 struct nfs4_exception exception = { }; 1795 struct nfs4_state *res; 1796 int status; 1797 1798 do { 1799 status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred, &res); 1800 if (status == 0) 1801 break; 1802 /* NOTE: BAD_SEQID means the server and client disagree about the 1803 * book-keeping w.r.t. state-changing operations 1804 * (OPEN/CLOSE/LOCK/LOCKU...) 1805 * It is actually a sign of a bug on the client or on the server. 1806 * 1807 * If we receive a BAD_SEQID error in the particular case of 1808 * doing an OPEN, we assume that nfs_increment_open_seqid() will 1809 * have unhashed the old state_owner for us, and that we can 1810 * therefore safely retry using a new one. We should still warn 1811 * the user though... 1812 */ 1813 if (status == -NFS4ERR_BAD_SEQID) { 1814 printk(KERN_WARNING "NFS: v4 server %s " 1815 " returned a bad sequence-id error!\n", 1816 NFS_SERVER(dir)->nfs_client->cl_hostname); 1817 exception.retry = 1; 1818 continue; 1819 } 1820 /* 1821 * BAD_STATEID on OPEN means that the server cancelled our 1822 * state before it received the OPEN_CONFIRM. 1823 * Recover by retrying the request as per the discussion 1824 * on Page 181 of RFC3530. 1825 */ 1826 if (status == -NFS4ERR_BAD_STATEID) { 1827 exception.retry = 1; 1828 continue; 1829 } 1830 if (status == -EAGAIN) { 1831 /* We must have found a delegation */ 1832 exception.retry = 1; 1833 continue; 1834 } 1835 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir), 1836 status, &exception)); 1837 } while (exception.retry); 1838 return res; 1839 } 1840 1841 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 1842 struct nfs_fattr *fattr, struct iattr *sattr, 1843 struct nfs4_state *state) 1844 { 1845 struct nfs_server *server = NFS_SERVER(inode); 1846 struct nfs_setattrargs arg = { 1847 .fh = NFS_FH(inode), 1848 .iap = sattr, 1849 .server = server, 1850 .bitmask = server->attr_bitmask, 1851 }; 1852 struct nfs_setattrres res = { 1853 .fattr = fattr, 1854 .server = server, 1855 }; 1856 struct rpc_message msg = { 1857 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 1858 .rpc_argp = &arg, 1859 .rpc_resp = &res, 1860 .rpc_cred = cred, 1861 }; 1862 unsigned long timestamp = jiffies; 1863 int status; 1864 1865 nfs_fattr_init(fattr); 1866 1867 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) { 1868 /* Use that stateid */ 1869 } else if (state != NULL) { 1870 nfs4_copy_stateid(&arg.stateid, state, current->files, current->tgid); 1871 } else 1872 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid)); 1873 1874 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 1875 if (status == 0 && state != NULL) 1876 renew_lease(server, timestamp); 1877 return status; 1878 } 1879 1880 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 1881 struct nfs_fattr *fattr, struct iattr *sattr, 1882 struct nfs4_state *state) 1883 { 1884 struct nfs_server *server = NFS_SERVER(inode); 1885 struct nfs4_exception exception = { }; 1886 int err; 1887 do { 1888 err = nfs4_handle_exception(server, 1889 _nfs4_do_setattr(inode, cred, fattr, sattr, state), 1890 &exception); 1891 } while (exception.retry); 1892 return err; 1893 } 1894 1895 struct nfs4_closedata { 1896 struct inode *inode; 1897 struct nfs4_state *state; 1898 struct nfs_closeargs arg; 1899 struct nfs_closeres res; 1900 struct nfs_fattr fattr; 1901 unsigned long timestamp; 1902 bool roc; 1903 u32 roc_barrier; 1904 }; 1905 1906 static void nfs4_free_closedata(void *data) 1907 { 1908 struct nfs4_closedata *calldata = data; 1909 struct nfs4_state_owner *sp = calldata->state->owner; 1910 struct super_block *sb = calldata->state->inode->i_sb; 1911 1912 if (calldata->roc) 1913 pnfs_roc_release(calldata->state->inode); 1914 nfs4_put_open_state(calldata->state); 1915 nfs_free_seqid(calldata->arg.seqid); 1916 nfs4_put_state_owner(sp); 1917 nfs_sb_deactive(sb); 1918 kfree(calldata); 1919 } 1920 1921 static void nfs4_close_clear_stateid_flags(struct nfs4_state *state, 1922 fmode_t fmode) 1923 { 1924 spin_lock(&state->owner->so_lock); 1925 if (!(fmode & FMODE_READ)) 1926 clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1927 if (!(fmode & FMODE_WRITE)) 1928 clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1929 clear_bit(NFS_O_RDWR_STATE, &state->flags); 1930 spin_unlock(&state->owner->so_lock); 1931 } 1932 1933 static void nfs4_close_done(struct rpc_task *task, void *data) 1934 { 1935 struct nfs4_closedata *calldata = data; 1936 struct nfs4_state *state = calldata->state; 1937 struct nfs_server *server = NFS_SERVER(calldata->inode); 1938 1939 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 1940 return; 1941 /* hmm. we are done with the inode, and in the process of freeing 1942 * the state_owner. we keep this around to process errors 1943 */ 1944 switch (task->tk_status) { 1945 case 0: 1946 if (calldata->roc) 1947 pnfs_roc_set_barrier(state->inode, 1948 calldata->roc_barrier); 1949 nfs_set_open_stateid(state, &calldata->res.stateid, 0); 1950 renew_lease(server, calldata->timestamp); 1951 nfs4_close_clear_stateid_flags(state, 1952 calldata->arg.fmode); 1953 break; 1954 case -NFS4ERR_STALE_STATEID: 1955 case -NFS4ERR_OLD_STATEID: 1956 case -NFS4ERR_BAD_STATEID: 1957 case -NFS4ERR_EXPIRED: 1958 if (calldata->arg.fmode == 0) 1959 break; 1960 default: 1961 if (nfs4_async_handle_error(task, server, state) == -EAGAIN) 1962 rpc_restart_call_prepare(task); 1963 } 1964 nfs_release_seqid(calldata->arg.seqid); 1965 nfs_refresh_inode(calldata->inode, calldata->res.fattr); 1966 } 1967 1968 static void nfs4_close_prepare(struct rpc_task *task, void *data) 1969 { 1970 struct nfs4_closedata *calldata = data; 1971 struct nfs4_state *state = calldata->state; 1972 int call_close = 0; 1973 1974 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 1975 return; 1976 1977 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 1978 calldata->arg.fmode = FMODE_READ|FMODE_WRITE; 1979 spin_lock(&state->owner->so_lock); 1980 /* Calculate the change in open mode */ 1981 if (state->n_rdwr == 0) { 1982 if (state->n_rdonly == 0) { 1983 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags); 1984 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 1985 calldata->arg.fmode &= ~FMODE_READ; 1986 } 1987 if (state->n_wronly == 0) { 1988 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags); 1989 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags); 1990 calldata->arg.fmode &= ~FMODE_WRITE; 1991 } 1992 } 1993 spin_unlock(&state->owner->so_lock); 1994 1995 if (!call_close) { 1996 /* Note: exit _without_ calling nfs4_close_done */ 1997 task->tk_action = NULL; 1998 return; 1999 } 2000 2001 if (calldata->arg.fmode == 0) { 2002 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; 2003 if (calldata->roc && 2004 pnfs_roc_drain(calldata->inode, &calldata->roc_barrier)) { 2005 rpc_sleep_on(&NFS_SERVER(calldata->inode)->roc_rpcwaitq, 2006 task, NULL); 2007 return; 2008 } 2009 } 2010 2011 nfs_fattr_init(calldata->res.fattr); 2012 calldata->timestamp = jiffies; 2013 if (nfs4_setup_sequence(NFS_SERVER(calldata->inode), 2014 &calldata->arg.seq_args, &calldata->res.seq_res, 2015 1, task)) 2016 return; 2017 rpc_call_start(task); 2018 } 2019 2020 static const struct rpc_call_ops nfs4_close_ops = { 2021 .rpc_call_prepare = nfs4_close_prepare, 2022 .rpc_call_done = nfs4_close_done, 2023 .rpc_release = nfs4_free_closedata, 2024 }; 2025 2026 /* 2027 * It is possible for data to be read/written from a mem-mapped file 2028 * after the sys_close call (which hits the vfs layer as a flush). 2029 * This means that we can't safely call nfsv4 close on a file until 2030 * the inode is cleared. This in turn means that we are not good 2031 * NFSv4 citizens - we do not indicate to the server to update the file's 2032 * share state even when we are done with one of the three share 2033 * stateid's in the inode. 2034 * 2035 * NOTE: Caller must be holding the sp->so_owner semaphore! 2036 */ 2037 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc) 2038 { 2039 struct nfs_server *server = NFS_SERVER(state->inode); 2040 struct nfs4_closedata *calldata; 2041 struct nfs4_state_owner *sp = state->owner; 2042 struct rpc_task *task; 2043 struct rpc_message msg = { 2044 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE], 2045 .rpc_cred = state->owner->so_cred, 2046 }; 2047 struct rpc_task_setup task_setup_data = { 2048 .rpc_client = server->client, 2049 .rpc_message = &msg, 2050 .callback_ops = &nfs4_close_ops, 2051 .workqueue = nfsiod_workqueue, 2052 .flags = RPC_TASK_ASYNC, 2053 }; 2054 int status = -ENOMEM; 2055 2056 calldata = kzalloc(sizeof(*calldata), gfp_mask); 2057 if (calldata == NULL) 2058 goto out; 2059 calldata->inode = state->inode; 2060 calldata->state = state; 2061 calldata->arg.fh = NFS_FH(state->inode); 2062 calldata->arg.stateid = &state->open_stateid; 2063 /* Serialization for the sequence id */ 2064 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask); 2065 if (calldata->arg.seqid == NULL) 2066 goto out_free_calldata; 2067 calldata->arg.fmode = 0; 2068 calldata->arg.bitmask = server->cache_consistency_bitmask; 2069 calldata->res.fattr = &calldata->fattr; 2070 calldata->res.seqid = calldata->arg.seqid; 2071 calldata->res.server = server; 2072 calldata->roc = roc; 2073 nfs_sb_active(calldata->inode->i_sb); 2074 2075 msg.rpc_argp = &calldata->arg; 2076 msg.rpc_resp = &calldata->res; 2077 task_setup_data.callback_data = calldata; 2078 task = rpc_run_task(&task_setup_data); 2079 if (IS_ERR(task)) 2080 return PTR_ERR(task); 2081 status = 0; 2082 if (wait) 2083 status = rpc_wait_for_completion_task(task); 2084 rpc_put_task(task); 2085 return status; 2086 out_free_calldata: 2087 kfree(calldata); 2088 out: 2089 if (roc) 2090 pnfs_roc_release(state->inode); 2091 nfs4_put_open_state(state); 2092 nfs4_put_state_owner(sp); 2093 return status; 2094 } 2095 2096 static struct inode * 2097 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr) 2098 { 2099 struct nfs4_state *state; 2100 2101 /* Protect against concurrent sillydeletes */ 2102 state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, ctx->cred); 2103 if (IS_ERR(state)) 2104 return ERR_CAST(state); 2105 ctx->state = state; 2106 return igrab(state->inode); 2107 } 2108 2109 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync) 2110 { 2111 if (ctx->state == NULL) 2112 return; 2113 if (is_sync) 2114 nfs4_close_sync(ctx->state, ctx->mode); 2115 else 2116 nfs4_close_state(ctx->state, ctx->mode); 2117 } 2118 2119 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2120 { 2121 struct nfs4_server_caps_arg args = { 2122 .fhandle = fhandle, 2123 }; 2124 struct nfs4_server_caps_res res = {}; 2125 struct rpc_message msg = { 2126 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS], 2127 .rpc_argp = &args, 2128 .rpc_resp = &res, 2129 }; 2130 int status; 2131 2132 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2133 if (status == 0) { 2134 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); 2135 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS| 2136 NFS_CAP_SYMLINKS|NFS_CAP_FILEID| 2137 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER| 2138 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME| 2139 NFS_CAP_CTIME|NFS_CAP_MTIME); 2140 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL) 2141 server->caps |= NFS_CAP_ACLS; 2142 if (res.has_links != 0) 2143 server->caps |= NFS_CAP_HARDLINKS; 2144 if (res.has_symlinks != 0) 2145 server->caps |= NFS_CAP_SYMLINKS; 2146 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID) 2147 server->caps |= NFS_CAP_FILEID; 2148 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE) 2149 server->caps |= NFS_CAP_MODE; 2150 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS) 2151 server->caps |= NFS_CAP_NLINK; 2152 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER) 2153 server->caps |= NFS_CAP_OWNER; 2154 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP) 2155 server->caps |= NFS_CAP_OWNER_GROUP; 2156 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS) 2157 server->caps |= NFS_CAP_ATIME; 2158 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA) 2159 server->caps |= NFS_CAP_CTIME; 2160 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY) 2161 server->caps |= NFS_CAP_MTIME; 2162 2163 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); 2164 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; 2165 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; 2166 server->acl_bitmask = res.acl_bitmask; 2167 } 2168 2169 return status; 2170 } 2171 2172 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 2173 { 2174 struct nfs4_exception exception = { }; 2175 int err; 2176 do { 2177 err = nfs4_handle_exception(server, 2178 _nfs4_server_capabilities(server, fhandle), 2179 &exception); 2180 } while (exception.retry); 2181 return err; 2182 } 2183 2184 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2185 struct nfs_fsinfo *info) 2186 { 2187 struct nfs4_lookup_root_arg args = { 2188 .bitmask = nfs4_fattr_bitmap, 2189 }; 2190 struct nfs4_lookup_res res = { 2191 .server = server, 2192 .fattr = info->fattr, 2193 .fh = fhandle, 2194 }; 2195 struct rpc_message msg = { 2196 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT], 2197 .rpc_argp = &args, 2198 .rpc_resp = &res, 2199 }; 2200 2201 nfs_fattr_init(info->fattr); 2202 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2203 } 2204 2205 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 2206 struct nfs_fsinfo *info) 2207 { 2208 struct nfs4_exception exception = { }; 2209 int err; 2210 do { 2211 err = _nfs4_lookup_root(server, fhandle, info); 2212 switch (err) { 2213 case 0: 2214 case -NFS4ERR_WRONGSEC: 2215 break; 2216 default: 2217 err = nfs4_handle_exception(server, err, &exception); 2218 } 2219 } while (exception.retry); 2220 return err; 2221 } 2222 2223 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 2224 struct nfs_fsinfo *info, rpc_authflavor_t flavor) 2225 { 2226 struct rpc_auth *auth; 2227 int ret; 2228 2229 auth = rpcauth_create(flavor, server->client); 2230 if (!auth) { 2231 ret = -EIO; 2232 goto out; 2233 } 2234 ret = nfs4_lookup_root(server, fhandle, info); 2235 out: 2236 return ret; 2237 } 2238 2239 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 2240 struct nfs_fsinfo *info) 2241 { 2242 int i, len, status = 0; 2243 rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS]; 2244 2245 len = gss_mech_list_pseudoflavors(&flav_array[0]); 2246 flav_array[len] = RPC_AUTH_NULL; 2247 len += 1; 2248 2249 for (i = 0; i < len; i++) { 2250 status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]); 2251 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) 2252 continue; 2253 break; 2254 } 2255 /* 2256 * -EACCESS could mean that the user doesn't have correct permissions 2257 * to access the mount. It could also mean that we tried to mount 2258 * with a gss auth flavor, but rpc.gssd isn't running. Either way, 2259 * existing mount programs don't handle -EACCES very well so it should 2260 * be mapped to -EPERM instead. 2261 */ 2262 if (status == -EACCES) 2263 status = -EPERM; 2264 return status; 2265 } 2266 2267 /* 2268 * get the file handle for the "/" directory on the server 2269 */ 2270 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 2271 struct nfs_fsinfo *info) 2272 { 2273 int minor_version = server->nfs_client->cl_minorversion; 2274 int status = nfs4_lookup_root(server, fhandle, info); 2275 if ((status == -NFS4ERR_WRONGSEC) && !(server->flags & NFS_MOUNT_SECFLAVOUR)) 2276 /* 2277 * A status of -NFS4ERR_WRONGSEC will be mapped to -EPERM 2278 * by nfs4_map_errors() as this function exits. 2279 */ 2280 status = nfs_v4_minor_ops[minor_version]->find_root_sec(server, fhandle, info); 2281 if (status == 0) 2282 status = nfs4_server_capabilities(server, fhandle); 2283 if (status == 0) 2284 status = nfs4_do_fsinfo(server, fhandle, info); 2285 return nfs4_map_errors(status); 2286 } 2287 2288 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr); 2289 /* 2290 * Get locations and (maybe) other attributes of a referral. 2291 * Note that we'll actually follow the referral later when 2292 * we detect fsid mismatch in inode revalidation 2293 */ 2294 static int nfs4_get_referral(struct inode *dir, const struct qstr *name, 2295 struct nfs_fattr *fattr, struct nfs_fh *fhandle) 2296 { 2297 int status = -ENOMEM; 2298 struct page *page = NULL; 2299 struct nfs4_fs_locations *locations = NULL; 2300 2301 page = alloc_page(GFP_KERNEL); 2302 if (page == NULL) 2303 goto out; 2304 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 2305 if (locations == NULL) 2306 goto out; 2307 2308 status = nfs4_proc_fs_locations(dir, name, locations, page); 2309 if (status != 0) 2310 goto out; 2311 /* Make sure server returned a different fsid for the referral */ 2312 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 2313 dprintk("%s: server did not return a different fsid for" 2314 " a referral at %s\n", __func__, name->name); 2315 status = -EIO; 2316 goto out; 2317 } 2318 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */ 2319 nfs_fixup_referral_attributes(&locations->fattr); 2320 2321 /* replace the lookup nfs_fattr with the locations nfs_fattr */ 2322 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr)); 2323 memset(fhandle, 0, sizeof(struct nfs_fh)); 2324 out: 2325 if (page) 2326 __free_page(page); 2327 kfree(locations); 2328 return status; 2329 } 2330 2331 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2332 { 2333 struct nfs4_getattr_arg args = { 2334 .fh = fhandle, 2335 .bitmask = server->attr_bitmask, 2336 }; 2337 struct nfs4_getattr_res res = { 2338 .fattr = fattr, 2339 .server = server, 2340 }; 2341 struct rpc_message msg = { 2342 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 2343 .rpc_argp = &args, 2344 .rpc_resp = &res, 2345 }; 2346 2347 nfs_fattr_init(fattr); 2348 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2349 } 2350 2351 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2352 { 2353 struct nfs4_exception exception = { }; 2354 int err; 2355 do { 2356 err = nfs4_handle_exception(server, 2357 _nfs4_proc_getattr(server, fhandle, fattr), 2358 &exception); 2359 } while (exception.retry); 2360 return err; 2361 } 2362 2363 /* 2364 * The file is not closed if it is opened due to the a request to change 2365 * the size of the file. The open call will not be needed once the 2366 * VFS layer lookup-intents are implemented. 2367 * 2368 * Close is called when the inode is destroyed. 2369 * If we haven't opened the file for O_WRONLY, we 2370 * need to in the size_change case to obtain a stateid. 2371 * 2372 * Got race? 2373 * Because OPEN is always done by name in nfsv4, it is 2374 * possible that we opened a different file by the same 2375 * name. We can recognize this race condition, but we 2376 * can't do anything about it besides returning an error. 2377 * 2378 * This will be fixed with VFS changes (lookup-intent). 2379 */ 2380 static int 2381 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 2382 struct iattr *sattr) 2383 { 2384 struct inode *inode = dentry->d_inode; 2385 struct rpc_cred *cred = NULL; 2386 struct nfs4_state *state = NULL; 2387 int status; 2388 2389 if (pnfs_ld_layoutret_on_setattr(inode)) 2390 pnfs_return_layout(inode); 2391 2392 nfs_fattr_init(fattr); 2393 2394 /* Search for an existing open(O_WRITE) file */ 2395 if (sattr->ia_valid & ATTR_FILE) { 2396 struct nfs_open_context *ctx; 2397 2398 ctx = nfs_file_open_context(sattr->ia_file); 2399 if (ctx) { 2400 cred = ctx->cred; 2401 state = ctx->state; 2402 } 2403 } 2404 2405 status = nfs4_do_setattr(inode, cred, fattr, sattr, state); 2406 if (status == 0) 2407 nfs_setattr_update_inode(inode, sattr); 2408 return status; 2409 } 2410 2411 static int _nfs4_proc_lookupfh(struct rpc_clnt *clnt, struct nfs_server *server, 2412 const struct nfs_fh *dirfh, const struct qstr *name, 2413 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2414 { 2415 int status; 2416 struct nfs4_lookup_arg args = { 2417 .bitmask = server->attr_bitmask, 2418 .dir_fh = dirfh, 2419 .name = name, 2420 }; 2421 struct nfs4_lookup_res res = { 2422 .server = server, 2423 .fattr = fattr, 2424 .fh = fhandle, 2425 }; 2426 struct rpc_message msg = { 2427 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 2428 .rpc_argp = &args, 2429 .rpc_resp = &res, 2430 }; 2431 2432 nfs_fattr_init(fattr); 2433 2434 dprintk("NFS call lookupfh %s\n", name->name); 2435 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0); 2436 dprintk("NFS reply lookupfh: %d\n", status); 2437 return status; 2438 } 2439 2440 static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh, 2441 struct qstr *name, struct nfs_fh *fhandle, 2442 struct nfs_fattr *fattr) 2443 { 2444 struct nfs4_exception exception = { }; 2445 int err; 2446 do { 2447 err = _nfs4_proc_lookupfh(server->client, server, dirfh, name, fhandle, fattr); 2448 /* FIXME: !!!! */ 2449 if (err == -NFS4ERR_MOVED) { 2450 err = -EREMOTE; 2451 break; 2452 } 2453 err = nfs4_handle_exception(server, err, &exception); 2454 } while (exception.retry); 2455 return err; 2456 } 2457 2458 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, 2459 const struct qstr *name, struct nfs_fh *fhandle, 2460 struct nfs_fattr *fattr) 2461 { 2462 int status; 2463 2464 dprintk("NFS call lookup %s\n", name->name); 2465 status = _nfs4_proc_lookupfh(clnt, NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr); 2466 if (status == -NFS4ERR_MOVED) 2467 status = nfs4_get_referral(dir, name, fattr, fhandle); 2468 dprintk("NFS reply lookup: %d\n", status); 2469 return status; 2470 } 2471 2472 void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr, struct nfs_fh *fh) 2473 { 2474 memset(fh, 0, sizeof(struct nfs_fh)); 2475 fattr->fsid.major = 1; 2476 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 2477 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_FSID | NFS_ATTR_FATTR_MOUNTPOINT; 2478 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 2479 fattr->nlink = 2; 2480 } 2481 2482 static int nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, struct qstr *name, 2483 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 2484 { 2485 struct nfs4_exception exception = { }; 2486 int err; 2487 do { 2488 err = nfs4_handle_exception(NFS_SERVER(dir), 2489 _nfs4_proc_lookup(clnt, dir, name, fhandle, fattr), 2490 &exception); 2491 if (err == -EPERM) 2492 nfs_fixup_secinfo_attributes(fattr, fhandle); 2493 } while (exception.retry); 2494 return err; 2495 } 2496 2497 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 2498 { 2499 struct nfs_server *server = NFS_SERVER(inode); 2500 struct nfs4_accessargs args = { 2501 .fh = NFS_FH(inode), 2502 .bitmask = server->attr_bitmask, 2503 }; 2504 struct nfs4_accessres res = { 2505 .server = server, 2506 }; 2507 struct rpc_message msg = { 2508 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], 2509 .rpc_argp = &args, 2510 .rpc_resp = &res, 2511 .rpc_cred = entry->cred, 2512 }; 2513 int mode = entry->mask; 2514 int status; 2515 2516 /* 2517 * Determine which access bits we want to ask for... 2518 */ 2519 if (mode & MAY_READ) 2520 args.access |= NFS4_ACCESS_READ; 2521 if (S_ISDIR(inode->i_mode)) { 2522 if (mode & MAY_WRITE) 2523 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE; 2524 if (mode & MAY_EXEC) 2525 args.access |= NFS4_ACCESS_LOOKUP; 2526 } else { 2527 if (mode & MAY_WRITE) 2528 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND; 2529 if (mode & MAY_EXEC) 2530 args.access |= NFS4_ACCESS_EXECUTE; 2531 } 2532 2533 res.fattr = nfs_alloc_fattr(); 2534 if (res.fattr == NULL) 2535 return -ENOMEM; 2536 2537 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 2538 if (!status) { 2539 entry->mask = 0; 2540 if (res.access & NFS4_ACCESS_READ) 2541 entry->mask |= MAY_READ; 2542 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE)) 2543 entry->mask |= MAY_WRITE; 2544 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE)) 2545 entry->mask |= MAY_EXEC; 2546 nfs_refresh_inode(inode, res.fattr); 2547 } 2548 nfs_free_fattr(res.fattr); 2549 return status; 2550 } 2551 2552 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 2553 { 2554 struct nfs4_exception exception = { }; 2555 int err; 2556 do { 2557 err = nfs4_handle_exception(NFS_SERVER(inode), 2558 _nfs4_proc_access(inode, entry), 2559 &exception); 2560 } while (exception.retry); 2561 return err; 2562 } 2563 2564 /* 2565 * TODO: For the time being, we don't try to get any attributes 2566 * along with any of the zero-copy operations READ, READDIR, 2567 * READLINK, WRITE. 2568 * 2569 * In the case of the first three, we want to put the GETATTR 2570 * after the read-type operation -- this is because it is hard 2571 * to predict the length of a GETATTR response in v4, and thus 2572 * align the READ data correctly. This means that the GETATTR 2573 * may end up partially falling into the page cache, and we should 2574 * shift it into the 'tail' of the xdr_buf before processing. 2575 * To do this efficiently, we need to know the total length 2576 * of data received, which doesn't seem to be available outside 2577 * of the RPC layer. 2578 * 2579 * In the case of WRITE, we also want to put the GETATTR after 2580 * the operation -- in this case because we want to make sure 2581 * we get the post-operation mtime and size. This means that 2582 * we can't use xdr_encode_pages() as written: we need a variant 2583 * of it which would leave room in the 'tail' iovec. 2584 * 2585 * Both of these changes to the XDR layer would in fact be quite 2586 * minor, but I decided to leave them for a subsequent patch. 2587 */ 2588 static int _nfs4_proc_readlink(struct inode *inode, struct page *page, 2589 unsigned int pgbase, unsigned int pglen) 2590 { 2591 struct nfs4_readlink args = { 2592 .fh = NFS_FH(inode), 2593 .pgbase = pgbase, 2594 .pglen = pglen, 2595 .pages = &page, 2596 }; 2597 struct nfs4_readlink_res res; 2598 struct rpc_message msg = { 2599 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK], 2600 .rpc_argp = &args, 2601 .rpc_resp = &res, 2602 }; 2603 2604 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0); 2605 } 2606 2607 static int nfs4_proc_readlink(struct inode *inode, struct page *page, 2608 unsigned int pgbase, unsigned int pglen) 2609 { 2610 struct nfs4_exception exception = { }; 2611 int err; 2612 do { 2613 err = nfs4_handle_exception(NFS_SERVER(inode), 2614 _nfs4_proc_readlink(inode, page, pgbase, pglen), 2615 &exception); 2616 } while (exception.retry); 2617 return err; 2618 } 2619 2620 /* 2621 * Got race? 2622 * We will need to arrange for the VFS layer to provide an atomic open. 2623 * Until then, this create/open method is prone to inefficiency and race 2624 * conditions due to the lookup, create, and open VFS calls from sys_open() 2625 * placed on the wire. 2626 * 2627 * Given the above sorry state of affairs, I'm simply sending an OPEN. 2628 * The file will be opened again in the subsequent VFS open call 2629 * (nfs4_proc_file_open). 2630 * 2631 * The open for read will just hang around to be used by any process that 2632 * opens the file O_RDONLY. This will all be resolved with the VFS changes. 2633 */ 2634 2635 static int 2636 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 2637 int flags, struct nfs_open_context *ctx) 2638 { 2639 struct dentry *de = dentry; 2640 struct nfs4_state *state; 2641 struct rpc_cred *cred = NULL; 2642 fmode_t fmode = 0; 2643 int status = 0; 2644 2645 if (ctx != NULL) { 2646 cred = ctx->cred; 2647 de = ctx->dentry; 2648 fmode = ctx->mode; 2649 } 2650 sattr->ia_mode &= ~current_umask(); 2651 state = nfs4_do_open(dir, de, fmode, flags, sattr, cred); 2652 d_drop(dentry); 2653 if (IS_ERR(state)) { 2654 status = PTR_ERR(state); 2655 goto out; 2656 } 2657 d_add(dentry, igrab(state->inode)); 2658 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2659 if (ctx != NULL) 2660 ctx->state = state; 2661 else 2662 nfs4_close_sync(state, fmode); 2663 out: 2664 return status; 2665 } 2666 2667 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name) 2668 { 2669 struct nfs_server *server = NFS_SERVER(dir); 2670 struct nfs_removeargs args = { 2671 .fh = NFS_FH(dir), 2672 .name.len = name->len, 2673 .name.name = name->name, 2674 .bitmask = server->attr_bitmask, 2675 }; 2676 struct nfs_removeres res = { 2677 .server = server, 2678 }; 2679 struct rpc_message msg = { 2680 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE], 2681 .rpc_argp = &args, 2682 .rpc_resp = &res, 2683 }; 2684 int status = -ENOMEM; 2685 2686 res.dir_attr = nfs_alloc_fattr(); 2687 if (res.dir_attr == NULL) 2688 goto out; 2689 2690 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); 2691 if (status == 0) { 2692 update_changeattr(dir, &res.cinfo); 2693 nfs_post_op_update_inode(dir, res.dir_attr); 2694 } 2695 nfs_free_fattr(res.dir_attr); 2696 out: 2697 return status; 2698 } 2699 2700 static int nfs4_proc_remove(struct inode *dir, struct qstr *name) 2701 { 2702 struct nfs4_exception exception = { }; 2703 int err; 2704 do { 2705 err = nfs4_handle_exception(NFS_SERVER(dir), 2706 _nfs4_proc_remove(dir, name), 2707 &exception); 2708 } while (exception.retry); 2709 return err; 2710 } 2711 2712 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 2713 { 2714 struct nfs_server *server = NFS_SERVER(dir); 2715 struct nfs_removeargs *args = msg->rpc_argp; 2716 struct nfs_removeres *res = msg->rpc_resp; 2717 2718 args->bitmask = server->cache_consistency_bitmask; 2719 res->server = server; 2720 res->seq_res.sr_slot = NULL; 2721 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; 2722 } 2723 2724 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir) 2725 { 2726 struct nfs_removeres *res = task->tk_msg.rpc_resp; 2727 2728 if (!nfs4_sequence_done(task, &res->seq_res)) 2729 return 0; 2730 if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN) 2731 return 0; 2732 update_changeattr(dir, &res->cinfo); 2733 nfs_post_op_update_inode(dir, res->dir_attr); 2734 return 1; 2735 } 2736 2737 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir) 2738 { 2739 struct nfs_server *server = NFS_SERVER(dir); 2740 struct nfs_renameargs *arg = msg->rpc_argp; 2741 struct nfs_renameres *res = msg->rpc_resp; 2742 2743 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME]; 2744 arg->bitmask = server->attr_bitmask; 2745 res->server = server; 2746 } 2747 2748 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 2749 struct inode *new_dir) 2750 { 2751 struct nfs_renameres *res = task->tk_msg.rpc_resp; 2752 2753 if (!nfs4_sequence_done(task, &res->seq_res)) 2754 return 0; 2755 if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN) 2756 return 0; 2757 2758 update_changeattr(old_dir, &res->old_cinfo); 2759 nfs_post_op_update_inode(old_dir, res->old_fattr); 2760 update_changeattr(new_dir, &res->new_cinfo); 2761 nfs_post_op_update_inode(new_dir, res->new_fattr); 2762 return 1; 2763 } 2764 2765 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 2766 struct inode *new_dir, struct qstr *new_name) 2767 { 2768 struct nfs_server *server = NFS_SERVER(old_dir); 2769 struct nfs_renameargs arg = { 2770 .old_dir = NFS_FH(old_dir), 2771 .new_dir = NFS_FH(new_dir), 2772 .old_name = old_name, 2773 .new_name = new_name, 2774 .bitmask = server->attr_bitmask, 2775 }; 2776 struct nfs_renameres res = { 2777 .server = server, 2778 }; 2779 struct rpc_message msg = { 2780 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME], 2781 .rpc_argp = &arg, 2782 .rpc_resp = &res, 2783 }; 2784 int status = -ENOMEM; 2785 2786 res.old_fattr = nfs_alloc_fattr(); 2787 res.new_fattr = nfs_alloc_fattr(); 2788 if (res.old_fattr == NULL || res.new_fattr == NULL) 2789 goto out; 2790 2791 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 2792 if (!status) { 2793 update_changeattr(old_dir, &res.old_cinfo); 2794 nfs_post_op_update_inode(old_dir, res.old_fattr); 2795 update_changeattr(new_dir, &res.new_cinfo); 2796 nfs_post_op_update_inode(new_dir, res.new_fattr); 2797 } 2798 out: 2799 nfs_free_fattr(res.new_fattr); 2800 nfs_free_fattr(res.old_fattr); 2801 return status; 2802 } 2803 2804 static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 2805 struct inode *new_dir, struct qstr *new_name) 2806 { 2807 struct nfs4_exception exception = { }; 2808 int err; 2809 do { 2810 err = nfs4_handle_exception(NFS_SERVER(old_dir), 2811 _nfs4_proc_rename(old_dir, old_name, 2812 new_dir, new_name), 2813 &exception); 2814 } while (exception.retry); 2815 return err; 2816 } 2817 2818 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 2819 { 2820 struct nfs_server *server = NFS_SERVER(inode); 2821 struct nfs4_link_arg arg = { 2822 .fh = NFS_FH(inode), 2823 .dir_fh = NFS_FH(dir), 2824 .name = name, 2825 .bitmask = server->attr_bitmask, 2826 }; 2827 struct nfs4_link_res res = { 2828 .server = server, 2829 }; 2830 struct rpc_message msg = { 2831 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK], 2832 .rpc_argp = &arg, 2833 .rpc_resp = &res, 2834 }; 2835 int status = -ENOMEM; 2836 2837 res.fattr = nfs_alloc_fattr(); 2838 res.dir_attr = nfs_alloc_fattr(); 2839 if (res.fattr == NULL || res.dir_attr == NULL) 2840 goto out; 2841 2842 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 2843 if (!status) { 2844 update_changeattr(dir, &res.cinfo); 2845 nfs_post_op_update_inode(dir, res.dir_attr); 2846 nfs_post_op_update_inode(inode, res.fattr); 2847 } 2848 out: 2849 nfs_free_fattr(res.dir_attr); 2850 nfs_free_fattr(res.fattr); 2851 return status; 2852 } 2853 2854 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 2855 { 2856 struct nfs4_exception exception = { }; 2857 int err; 2858 do { 2859 err = nfs4_handle_exception(NFS_SERVER(inode), 2860 _nfs4_proc_link(inode, dir, name), 2861 &exception); 2862 } while (exception.retry); 2863 return err; 2864 } 2865 2866 struct nfs4_createdata { 2867 struct rpc_message msg; 2868 struct nfs4_create_arg arg; 2869 struct nfs4_create_res res; 2870 struct nfs_fh fh; 2871 struct nfs_fattr fattr; 2872 struct nfs_fattr dir_fattr; 2873 }; 2874 2875 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir, 2876 struct qstr *name, struct iattr *sattr, u32 ftype) 2877 { 2878 struct nfs4_createdata *data; 2879 2880 data = kzalloc(sizeof(*data), GFP_KERNEL); 2881 if (data != NULL) { 2882 struct nfs_server *server = NFS_SERVER(dir); 2883 2884 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; 2885 data->msg.rpc_argp = &data->arg; 2886 data->msg.rpc_resp = &data->res; 2887 data->arg.dir_fh = NFS_FH(dir); 2888 data->arg.server = server; 2889 data->arg.name = name; 2890 data->arg.attrs = sattr; 2891 data->arg.ftype = ftype; 2892 data->arg.bitmask = server->attr_bitmask; 2893 data->res.server = server; 2894 data->res.fh = &data->fh; 2895 data->res.fattr = &data->fattr; 2896 data->res.dir_fattr = &data->dir_fattr; 2897 nfs_fattr_init(data->res.fattr); 2898 nfs_fattr_init(data->res.dir_fattr); 2899 } 2900 return data; 2901 } 2902 2903 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data) 2904 { 2905 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg, 2906 &data->arg.seq_args, &data->res.seq_res, 1); 2907 if (status == 0) { 2908 update_changeattr(dir, &data->res.dir_cinfo); 2909 nfs_post_op_update_inode(dir, data->res.dir_fattr); 2910 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); 2911 } 2912 return status; 2913 } 2914 2915 static void nfs4_free_createdata(struct nfs4_createdata *data) 2916 { 2917 kfree(data); 2918 } 2919 2920 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2921 struct page *page, unsigned int len, struct iattr *sattr) 2922 { 2923 struct nfs4_createdata *data; 2924 int status = -ENAMETOOLONG; 2925 2926 if (len > NFS4_MAXPATHLEN) 2927 goto out; 2928 2929 status = -ENOMEM; 2930 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); 2931 if (data == NULL) 2932 goto out; 2933 2934 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; 2935 data->arg.u.symlink.pages = &page; 2936 data->arg.u.symlink.len = len; 2937 2938 status = nfs4_do_create(dir, dentry, data); 2939 2940 nfs4_free_createdata(data); 2941 out: 2942 return status; 2943 } 2944 2945 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2946 struct page *page, unsigned int len, struct iattr *sattr) 2947 { 2948 struct nfs4_exception exception = { }; 2949 int err; 2950 do { 2951 err = nfs4_handle_exception(NFS_SERVER(dir), 2952 _nfs4_proc_symlink(dir, dentry, page, 2953 len, sattr), 2954 &exception); 2955 } while (exception.retry); 2956 return err; 2957 } 2958 2959 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2960 struct iattr *sattr) 2961 { 2962 struct nfs4_createdata *data; 2963 int status = -ENOMEM; 2964 2965 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); 2966 if (data == NULL) 2967 goto out; 2968 2969 status = nfs4_do_create(dir, dentry, data); 2970 2971 nfs4_free_createdata(data); 2972 out: 2973 return status; 2974 } 2975 2976 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2977 struct iattr *sattr) 2978 { 2979 struct nfs4_exception exception = { }; 2980 int err; 2981 2982 sattr->ia_mode &= ~current_umask(); 2983 do { 2984 err = nfs4_handle_exception(NFS_SERVER(dir), 2985 _nfs4_proc_mkdir(dir, dentry, sattr), 2986 &exception); 2987 } while (exception.retry); 2988 return err; 2989 } 2990 2991 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2992 u64 cookie, struct page **pages, unsigned int count, int plus) 2993 { 2994 struct inode *dir = dentry->d_inode; 2995 struct nfs4_readdir_arg args = { 2996 .fh = NFS_FH(dir), 2997 .pages = pages, 2998 .pgbase = 0, 2999 .count = count, 3000 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask, 3001 .plus = plus, 3002 }; 3003 struct nfs4_readdir_res res; 3004 struct rpc_message msg = { 3005 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], 3006 .rpc_argp = &args, 3007 .rpc_resp = &res, 3008 .rpc_cred = cred, 3009 }; 3010 int status; 3011 3012 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__, 3013 dentry->d_parent->d_name.name, 3014 dentry->d_name.name, 3015 (unsigned long long)cookie); 3016 nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args); 3017 res.pgbase = args.pgbase; 3018 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0); 3019 if (status >= 0) { 3020 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE); 3021 status += args.pgbase; 3022 } 3023 3024 nfs_invalidate_atime(dir); 3025 3026 dprintk("%s: returns %d\n", __func__, status); 3027 return status; 3028 } 3029 3030 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 3031 u64 cookie, struct page **pages, unsigned int count, int plus) 3032 { 3033 struct nfs4_exception exception = { }; 3034 int err; 3035 do { 3036 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), 3037 _nfs4_proc_readdir(dentry, cred, cookie, 3038 pages, count, plus), 3039 &exception); 3040 } while (exception.retry); 3041 return err; 3042 } 3043 3044 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 3045 struct iattr *sattr, dev_t rdev) 3046 { 3047 struct nfs4_createdata *data; 3048 int mode = sattr->ia_mode; 3049 int status = -ENOMEM; 3050 3051 BUG_ON(!(sattr->ia_valid & ATTR_MODE)); 3052 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode)); 3053 3054 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); 3055 if (data == NULL) 3056 goto out; 3057 3058 if (S_ISFIFO(mode)) 3059 data->arg.ftype = NF4FIFO; 3060 else if (S_ISBLK(mode)) { 3061 data->arg.ftype = NF4BLK; 3062 data->arg.u.device.specdata1 = MAJOR(rdev); 3063 data->arg.u.device.specdata2 = MINOR(rdev); 3064 } 3065 else if (S_ISCHR(mode)) { 3066 data->arg.ftype = NF4CHR; 3067 data->arg.u.device.specdata1 = MAJOR(rdev); 3068 data->arg.u.device.specdata2 = MINOR(rdev); 3069 } 3070 3071 status = nfs4_do_create(dir, dentry, data); 3072 3073 nfs4_free_createdata(data); 3074 out: 3075 return status; 3076 } 3077 3078 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 3079 struct iattr *sattr, dev_t rdev) 3080 { 3081 struct nfs4_exception exception = { }; 3082 int err; 3083 3084 sattr->ia_mode &= ~current_umask(); 3085 do { 3086 err = nfs4_handle_exception(NFS_SERVER(dir), 3087 _nfs4_proc_mknod(dir, dentry, sattr, rdev), 3088 &exception); 3089 } while (exception.retry); 3090 return err; 3091 } 3092 3093 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 3094 struct nfs_fsstat *fsstat) 3095 { 3096 struct nfs4_statfs_arg args = { 3097 .fh = fhandle, 3098 .bitmask = server->attr_bitmask, 3099 }; 3100 struct nfs4_statfs_res res = { 3101 .fsstat = fsstat, 3102 }; 3103 struct rpc_message msg = { 3104 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS], 3105 .rpc_argp = &args, 3106 .rpc_resp = &res, 3107 }; 3108 3109 nfs_fattr_init(fsstat->fattr); 3110 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3111 } 3112 3113 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat) 3114 { 3115 struct nfs4_exception exception = { }; 3116 int err; 3117 do { 3118 err = nfs4_handle_exception(server, 3119 _nfs4_proc_statfs(server, fhandle, fsstat), 3120 &exception); 3121 } while (exception.retry); 3122 return err; 3123 } 3124 3125 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 3126 struct nfs_fsinfo *fsinfo) 3127 { 3128 struct nfs4_fsinfo_arg args = { 3129 .fh = fhandle, 3130 .bitmask = server->attr_bitmask, 3131 }; 3132 struct nfs4_fsinfo_res res = { 3133 .fsinfo = fsinfo, 3134 }; 3135 struct rpc_message msg = { 3136 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO], 3137 .rpc_argp = &args, 3138 .rpc_resp = &res, 3139 }; 3140 3141 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3142 } 3143 3144 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 3145 { 3146 struct nfs4_exception exception = { }; 3147 int err; 3148 3149 do { 3150 err = nfs4_handle_exception(server, 3151 _nfs4_do_fsinfo(server, fhandle, fsinfo), 3152 &exception); 3153 } while (exception.retry); 3154 return err; 3155 } 3156 3157 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 3158 { 3159 nfs_fattr_init(fsinfo->fattr); 3160 return nfs4_do_fsinfo(server, fhandle, fsinfo); 3161 } 3162 3163 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 3164 struct nfs_pathconf *pathconf) 3165 { 3166 struct nfs4_pathconf_arg args = { 3167 .fh = fhandle, 3168 .bitmask = server->attr_bitmask, 3169 }; 3170 struct nfs4_pathconf_res res = { 3171 .pathconf = pathconf, 3172 }; 3173 struct rpc_message msg = { 3174 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF], 3175 .rpc_argp = &args, 3176 .rpc_resp = &res, 3177 }; 3178 3179 /* None of the pathconf attributes are mandatory to implement */ 3180 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) { 3181 memset(pathconf, 0, sizeof(*pathconf)); 3182 return 0; 3183 } 3184 3185 nfs_fattr_init(pathconf->fattr); 3186 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 3187 } 3188 3189 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 3190 struct nfs_pathconf *pathconf) 3191 { 3192 struct nfs4_exception exception = { }; 3193 int err; 3194 3195 do { 3196 err = nfs4_handle_exception(server, 3197 _nfs4_proc_pathconf(server, fhandle, pathconf), 3198 &exception); 3199 } while (exception.retry); 3200 return err; 3201 } 3202 3203 void __nfs4_read_done_cb(struct nfs_read_data *data) 3204 { 3205 nfs_invalidate_atime(data->inode); 3206 } 3207 3208 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data) 3209 { 3210 struct nfs_server *server = NFS_SERVER(data->inode); 3211 3212 if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) { 3213 nfs_restart_rpc(task, server->nfs_client); 3214 return -EAGAIN; 3215 } 3216 3217 __nfs4_read_done_cb(data); 3218 if (task->tk_status > 0) 3219 renew_lease(server, data->timestamp); 3220 return 0; 3221 } 3222 3223 static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data) 3224 { 3225 3226 dprintk("--> %s\n", __func__); 3227 3228 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3229 return -EAGAIN; 3230 3231 return data->read_done_cb ? data->read_done_cb(task, data) : 3232 nfs4_read_done_cb(task, data); 3233 } 3234 3235 static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 3236 { 3237 data->timestamp = jiffies; 3238 data->read_done_cb = nfs4_read_done_cb; 3239 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; 3240 } 3241 3242 /* Reset the the nfs_read_data to send the read to the MDS. */ 3243 void nfs4_reset_read(struct rpc_task *task, struct nfs_read_data *data) 3244 { 3245 dprintk("%s Reset task for i/o through\n", __func__); 3246 put_lseg(data->lseg); 3247 data->lseg = NULL; 3248 /* offsets will differ in the dense stripe case */ 3249 data->args.offset = data->mds_offset; 3250 data->ds_clp = NULL; 3251 data->args.fh = NFS_FH(data->inode); 3252 data->read_done_cb = nfs4_read_done_cb; 3253 task->tk_ops = data->mds_ops; 3254 rpc_task_reset_client(task, NFS_CLIENT(data->inode)); 3255 } 3256 EXPORT_SYMBOL_GPL(nfs4_reset_read); 3257 3258 static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data) 3259 { 3260 struct inode *inode = data->inode; 3261 3262 if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) { 3263 nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client); 3264 return -EAGAIN; 3265 } 3266 if (task->tk_status >= 0) { 3267 renew_lease(NFS_SERVER(inode), data->timestamp); 3268 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr); 3269 } 3270 return 0; 3271 } 3272 3273 static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data) 3274 { 3275 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3276 return -EAGAIN; 3277 return data->write_done_cb ? data->write_done_cb(task, data) : 3278 nfs4_write_done_cb(task, data); 3279 } 3280 3281 /* Reset the the nfs_write_data to send the write to the MDS. */ 3282 void nfs4_reset_write(struct rpc_task *task, struct nfs_write_data *data) 3283 { 3284 dprintk("%s Reset task for i/o through\n", __func__); 3285 put_lseg(data->lseg); 3286 data->lseg = NULL; 3287 data->ds_clp = NULL; 3288 data->write_done_cb = nfs4_write_done_cb; 3289 data->args.fh = NFS_FH(data->inode); 3290 data->args.bitmask = data->res.server->cache_consistency_bitmask; 3291 data->args.offset = data->mds_offset; 3292 data->res.fattr = &data->fattr; 3293 task->tk_ops = data->mds_ops; 3294 rpc_task_reset_client(task, NFS_CLIENT(data->inode)); 3295 } 3296 EXPORT_SYMBOL_GPL(nfs4_reset_write); 3297 3298 static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 3299 { 3300 struct nfs_server *server = NFS_SERVER(data->inode); 3301 3302 if (data->lseg) { 3303 data->args.bitmask = NULL; 3304 data->res.fattr = NULL; 3305 } else 3306 data->args.bitmask = server->cache_consistency_bitmask; 3307 if (!data->write_done_cb) 3308 data->write_done_cb = nfs4_write_done_cb; 3309 data->res.server = server; 3310 data->timestamp = jiffies; 3311 3312 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; 3313 } 3314 3315 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_write_data *data) 3316 { 3317 struct inode *inode = data->inode; 3318 3319 if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) { 3320 nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client); 3321 return -EAGAIN; 3322 } 3323 nfs_refresh_inode(inode, data->res.fattr); 3324 return 0; 3325 } 3326 3327 static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data) 3328 { 3329 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3330 return -EAGAIN; 3331 return data->write_done_cb(task, data); 3332 } 3333 3334 static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) 3335 { 3336 struct nfs_server *server = NFS_SERVER(data->inode); 3337 3338 if (data->lseg) { 3339 data->args.bitmask = NULL; 3340 data->res.fattr = NULL; 3341 } else 3342 data->args.bitmask = server->cache_consistency_bitmask; 3343 if (!data->write_done_cb) 3344 data->write_done_cb = nfs4_commit_done_cb; 3345 data->res.server = server; 3346 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; 3347 } 3348 3349 struct nfs4_renewdata { 3350 struct nfs_client *client; 3351 unsigned long timestamp; 3352 }; 3353 3354 /* 3355 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special 3356 * standalone procedure for queueing an asynchronous RENEW. 3357 */ 3358 static void nfs4_renew_release(void *calldata) 3359 { 3360 struct nfs4_renewdata *data = calldata; 3361 struct nfs_client *clp = data->client; 3362 3363 if (atomic_read(&clp->cl_count) > 1) 3364 nfs4_schedule_state_renewal(clp); 3365 nfs_put_client(clp); 3366 kfree(data); 3367 } 3368 3369 static void nfs4_renew_done(struct rpc_task *task, void *calldata) 3370 { 3371 struct nfs4_renewdata *data = calldata; 3372 struct nfs_client *clp = data->client; 3373 unsigned long timestamp = data->timestamp; 3374 3375 if (task->tk_status < 0) { 3376 /* Unless we're shutting down, schedule state recovery! */ 3377 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) != 0) 3378 nfs4_schedule_lease_recovery(clp); 3379 return; 3380 } 3381 do_renew_lease(clp, timestamp); 3382 } 3383 3384 static const struct rpc_call_ops nfs4_renew_ops = { 3385 .rpc_call_done = nfs4_renew_done, 3386 .rpc_release = nfs4_renew_release, 3387 }; 3388 3389 int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred) 3390 { 3391 struct rpc_message msg = { 3392 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 3393 .rpc_argp = clp, 3394 .rpc_cred = cred, 3395 }; 3396 struct nfs4_renewdata *data; 3397 3398 if (!atomic_inc_not_zero(&clp->cl_count)) 3399 return -EIO; 3400 data = kmalloc(sizeof(*data), GFP_KERNEL); 3401 if (data == NULL) 3402 return -ENOMEM; 3403 data->client = clp; 3404 data->timestamp = jiffies; 3405 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT, 3406 &nfs4_renew_ops, data); 3407 } 3408 3409 int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) 3410 { 3411 struct rpc_message msg = { 3412 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 3413 .rpc_argp = clp, 3414 .rpc_cred = cred, 3415 }; 3416 unsigned long now = jiffies; 3417 int status; 3418 3419 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 3420 if (status < 0) 3421 return status; 3422 do_renew_lease(clp, now); 3423 return 0; 3424 } 3425 3426 static inline int nfs4_server_supports_acls(struct nfs_server *server) 3427 { 3428 return (server->caps & NFS_CAP_ACLS) 3429 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL) 3430 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL); 3431 } 3432 3433 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that 3434 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on 3435 * the stack. 3436 */ 3437 #define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT) 3438 3439 static void buf_to_pages(const void *buf, size_t buflen, 3440 struct page **pages, unsigned int *pgbase) 3441 { 3442 const void *p = buf; 3443 3444 *pgbase = offset_in_page(buf); 3445 p -= *pgbase; 3446 while (p < buf + buflen) { 3447 *(pages++) = virt_to_page(p); 3448 p += PAGE_CACHE_SIZE; 3449 } 3450 } 3451 3452 static int buf_to_pages_noslab(const void *buf, size_t buflen, 3453 struct page **pages, unsigned int *pgbase) 3454 { 3455 struct page *newpage, **spages; 3456 int rc = 0; 3457 size_t len; 3458 spages = pages; 3459 3460 do { 3461 len = min_t(size_t, PAGE_CACHE_SIZE, buflen); 3462 newpage = alloc_page(GFP_KERNEL); 3463 3464 if (newpage == NULL) 3465 goto unwind; 3466 memcpy(page_address(newpage), buf, len); 3467 buf += len; 3468 buflen -= len; 3469 *pages++ = newpage; 3470 rc++; 3471 } while (buflen != 0); 3472 3473 return rc; 3474 3475 unwind: 3476 for(; rc > 0; rc--) 3477 __free_page(spages[rc-1]); 3478 return -ENOMEM; 3479 } 3480 3481 struct nfs4_cached_acl { 3482 int cached; 3483 size_t len; 3484 char data[0]; 3485 }; 3486 3487 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) 3488 { 3489 struct nfs_inode *nfsi = NFS_I(inode); 3490 3491 spin_lock(&inode->i_lock); 3492 kfree(nfsi->nfs4_acl); 3493 nfsi->nfs4_acl = acl; 3494 spin_unlock(&inode->i_lock); 3495 } 3496 3497 static void nfs4_zap_acl_attr(struct inode *inode) 3498 { 3499 nfs4_set_cached_acl(inode, NULL); 3500 } 3501 3502 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen) 3503 { 3504 struct nfs_inode *nfsi = NFS_I(inode); 3505 struct nfs4_cached_acl *acl; 3506 int ret = -ENOENT; 3507 3508 spin_lock(&inode->i_lock); 3509 acl = nfsi->nfs4_acl; 3510 if (acl == NULL) 3511 goto out; 3512 if (buf == NULL) /* user is just asking for length */ 3513 goto out_len; 3514 if (acl->cached == 0) 3515 goto out; 3516 ret = -ERANGE; /* see getxattr(2) man page */ 3517 if (acl->len > buflen) 3518 goto out; 3519 memcpy(buf, acl->data, acl->len); 3520 out_len: 3521 ret = acl->len; 3522 out: 3523 spin_unlock(&inode->i_lock); 3524 return ret; 3525 } 3526 3527 static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len) 3528 { 3529 struct nfs4_cached_acl *acl; 3530 3531 if (buf && acl_len <= PAGE_SIZE) { 3532 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL); 3533 if (acl == NULL) 3534 goto out; 3535 acl->cached = 1; 3536 memcpy(acl->data, buf, acl_len); 3537 } else { 3538 acl = kmalloc(sizeof(*acl), GFP_KERNEL); 3539 if (acl == NULL) 3540 goto out; 3541 acl->cached = 0; 3542 } 3543 acl->len = acl_len; 3544 out: 3545 nfs4_set_cached_acl(inode, acl); 3546 } 3547 3548 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 3549 { 3550 struct page *pages[NFS4ACL_MAXPAGES]; 3551 struct nfs_getaclargs args = { 3552 .fh = NFS_FH(inode), 3553 .acl_pages = pages, 3554 .acl_len = buflen, 3555 }; 3556 struct nfs_getaclres res = { 3557 .acl_len = buflen, 3558 }; 3559 void *resp_buf; 3560 struct rpc_message msg = { 3561 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL], 3562 .rpc_argp = &args, 3563 .rpc_resp = &res, 3564 }; 3565 struct page *localpage = NULL; 3566 int ret; 3567 3568 if (buflen < PAGE_SIZE) { 3569 /* As long as we're doing a round trip to the server anyway, 3570 * let's be prepared for a page of acl data. */ 3571 localpage = alloc_page(GFP_KERNEL); 3572 resp_buf = page_address(localpage); 3573 if (localpage == NULL) 3574 return -ENOMEM; 3575 args.acl_pages[0] = localpage; 3576 args.acl_pgbase = 0; 3577 args.acl_len = PAGE_SIZE; 3578 } else { 3579 resp_buf = buf; 3580 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase); 3581 } 3582 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0); 3583 if (ret) 3584 goto out_free; 3585 if (res.acl_len > args.acl_len) 3586 nfs4_write_cached_acl(inode, NULL, res.acl_len); 3587 else 3588 nfs4_write_cached_acl(inode, resp_buf, res.acl_len); 3589 if (buf) { 3590 ret = -ERANGE; 3591 if (res.acl_len > buflen) 3592 goto out_free; 3593 if (localpage) 3594 memcpy(buf, resp_buf, res.acl_len); 3595 } 3596 ret = res.acl_len; 3597 out_free: 3598 if (localpage) 3599 __free_page(localpage); 3600 return ret; 3601 } 3602 3603 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 3604 { 3605 struct nfs4_exception exception = { }; 3606 ssize_t ret; 3607 do { 3608 ret = __nfs4_get_acl_uncached(inode, buf, buflen); 3609 if (ret >= 0) 3610 break; 3611 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception); 3612 } while (exception.retry); 3613 return ret; 3614 } 3615 3616 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen) 3617 { 3618 struct nfs_server *server = NFS_SERVER(inode); 3619 int ret; 3620 3621 if (!nfs4_server_supports_acls(server)) 3622 return -EOPNOTSUPP; 3623 ret = nfs_revalidate_inode(server, inode); 3624 if (ret < 0) 3625 return ret; 3626 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) 3627 nfs_zap_acl_cache(inode); 3628 ret = nfs4_read_cached_acl(inode, buf, buflen); 3629 if (ret != -ENOENT) 3630 return ret; 3631 return nfs4_get_acl_uncached(inode, buf, buflen); 3632 } 3633 3634 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 3635 { 3636 struct nfs_server *server = NFS_SERVER(inode); 3637 struct page *pages[NFS4ACL_MAXPAGES]; 3638 struct nfs_setaclargs arg = { 3639 .fh = NFS_FH(inode), 3640 .acl_pages = pages, 3641 .acl_len = buflen, 3642 }; 3643 struct nfs_setaclres res; 3644 struct rpc_message msg = { 3645 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL], 3646 .rpc_argp = &arg, 3647 .rpc_resp = &res, 3648 }; 3649 int ret, i; 3650 3651 if (!nfs4_server_supports_acls(server)) 3652 return -EOPNOTSUPP; 3653 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 3654 if (i < 0) 3655 return i; 3656 nfs_inode_return_delegation(inode); 3657 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 3658 3659 /* 3660 * Free each page after tx, so the only ref left is 3661 * held by the network stack 3662 */ 3663 for (; i > 0; i--) 3664 put_page(pages[i-1]); 3665 3666 /* 3667 * Acl update can result in inode attribute update. 3668 * so mark the attribute cache invalid. 3669 */ 3670 spin_lock(&inode->i_lock); 3671 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR; 3672 spin_unlock(&inode->i_lock); 3673 nfs_access_zap_cache(inode); 3674 nfs_zap_acl_cache(inode); 3675 return ret; 3676 } 3677 3678 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 3679 { 3680 struct nfs4_exception exception = { }; 3681 int err; 3682 do { 3683 err = nfs4_handle_exception(NFS_SERVER(inode), 3684 __nfs4_proc_set_acl(inode, buf, buflen), 3685 &exception); 3686 } while (exception.retry); 3687 return err; 3688 } 3689 3690 static int 3691 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state) 3692 { 3693 struct nfs_client *clp = server->nfs_client; 3694 3695 if (task->tk_status >= 0) 3696 return 0; 3697 switch(task->tk_status) { 3698 case -NFS4ERR_ADMIN_REVOKED: 3699 case -NFS4ERR_BAD_STATEID: 3700 case -NFS4ERR_OPENMODE: 3701 if (state == NULL) 3702 break; 3703 nfs4_schedule_stateid_recovery(server, state); 3704 goto wait_on_recovery; 3705 case -NFS4ERR_EXPIRED: 3706 if (state != NULL) 3707 nfs4_schedule_stateid_recovery(server, state); 3708 case -NFS4ERR_STALE_STATEID: 3709 case -NFS4ERR_STALE_CLIENTID: 3710 nfs4_schedule_lease_recovery(clp); 3711 goto wait_on_recovery; 3712 #if defined(CONFIG_NFS_V4_1) 3713 case -NFS4ERR_BADSESSION: 3714 case -NFS4ERR_BADSLOT: 3715 case -NFS4ERR_BAD_HIGH_SLOT: 3716 case -NFS4ERR_DEADSESSION: 3717 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 3718 case -NFS4ERR_SEQ_FALSE_RETRY: 3719 case -NFS4ERR_SEQ_MISORDERED: 3720 dprintk("%s ERROR %d, Reset session\n", __func__, 3721 task->tk_status); 3722 nfs4_schedule_session_recovery(clp->cl_session); 3723 task->tk_status = 0; 3724 return -EAGAIN; 3725 #endif /* CONFIG_NFS_V4_1 */ 3726 case -NFS4ERR_DELAY: 3727 nfs_inc_server_stats(server, NFSIOS_DELAY); 3728 case -NFS4ERR_GRACE: 3729 case -EKEYEXPIRED: 3730 rpc_delay(task, NFS4_POLL_RETRY_MAX); 3731 task->tk_status = 0; 3732 return -EAGAIN; 3733 case -NFS4ERR_RETRY_UNCACHED_REP: 3734 case -NFS4ERR_OLD_STATEID: 3735 task->tk_status = 0; 3736 return -EAGAIN; 3737 } 3738 task->tk_status = nfs4_map_errors(task->tk_status); 3739 return 0; 3740 wait_on_recovery: 3741 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); 3742 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) 3743 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); 3744 task->tk_status = 0; 3745 return -EAGAIN; 3746 } 3747 3748 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, 3749 unsigned short port, struct rpc_cred *cred, 3750 struct nfs4_setclientid_res *res) 3751 { 3752 nfs4_verifier sc_verifier; 3753 struct nfs4_setclientid setclientid = { 3754 .sc_verifier = &sc_verifier, 3755 .sc_prog = program, 3756 .sc_cb_ident = clp->cl_cb_ident, 3757 }; 3758 struct rpc_message msg = { 3759 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], 3760 .rpc_argp = &setclientid, 3761 .rpc_resp = res, 3762 .rpc_cred = cred, 3763 }; 3764 __be32 *p; 3765 int loop = 0; 3766 int status; 3767 3768 p = (__be32*)sc_verifier.data; 3769 *p++ = htonl((u32)clp->cl_boot_time.tv_sec); 3770 *p = htonl((u32)clp->cl_boot_time.tv_nsec); 3771 3772 for(;;) { 3773 setclientid.sc_name_len = scnprintf(setclientid.sc_name, 3774 sizeof(setclientid.sc_name), "%s/%s %s %s %u", 3775 clp->cl_ipaddr, 3776 rpc_peeraddr2str(clp->cl_rpcclient, 3777 RPC_DISPLAY_ADDR), 3778 rpc_peeraddr2str(clp->cl_rpcclient, 3779 RPC_DISPLAY_PROTO), 3780 clp->cl_rpcclient->cl_auth->au_ops->au_name, 3781 clp->cl_id_uniquifier); 3782 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid, 3783 sizeof(setclientid.sc_netid), 3784 rpc_peeraddr2str(clp->cl_rpcclient, 3785 RPC_DISPLAY_NETID)); 3786 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, 3787 sizeof(setclientid.sc_uaddr), "%s.%u.%u", 3788 clp->cl_ipaddr, port >> 8, port & 255); 3789 3790 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 3791 if (status != -NFS4ERR_CLID_INUSE) 3792 break; 3793 if (loop != 0) { 3794 ++clp->cl_id_uniquifier; 3795 break; 3796 } 3797 ++loop; 3798 ssleep(clp->cl_lease_time / HZ + 1); 3799 } 3800 return status; 3801 } 3802 3803 int nfs4_proc_setclientid_confirm(struct nfs_client *clp, 3804 struct nfs4_setclientid_res *arg, 3805 struct rpc_cred *cred) 3806 { 3807 struct nfs_fsinfo fsinfo; 3808 struct rpc_message msg = { 3809 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], 3810 .rpc_argp = arg, 3811 .rpc_resp = &fsinfo, 3812 .rpc_cred = cred, 3813 }; 3814 unsigned long now; 3815 int status; 3816 3817 now = jiffies; 3818 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 3819 if (status == 0) { 3820 spin_lock(&clp->cl_lock); 3821 clp->cl_lease_time = fsinfo.lease_time * HZ; 3822 clp->cl_last_renewal = now; 3823 spin_unlock(&clp->cl_lock); 3824 } 3825 return status; 3826 } 3827 3828 struct nfs4_delegreturndata { 3829 struct nfs4_delegreturnargs args; 3830 struct nfs4_delegreturnres res; 3831 struct nfs_fh fh; 3832 nfs4_stateid stateid; 3833 unsigned long timestamp; 3834 struct nfs_fattr fattr; 3835 int rpc_status; 3836 }; 3837 3838 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) 3839 { 3840 struct nfs4_delegreturndata *data = calldata; 3841 3842 if (!nfs4_sequence_done(task, &data->res.seq_res)) 3843 return; 3844 3845 switch (task->tk_status) { 3846 case -NFS4ERR_STALE_STATEID: 3847 case -NFS4ERR_EXPIRED: 3848 case 0: 3849 renew_lease(data->res.server, data->timestamp); 3850 break; 3851 default: 3852 if (nfs4_async_handle_error(task, data->res.server, NULL) == 3853 -EAGAIN) { 3854 nfs_restart_rpc(task, data->res.server->nfs_client); 3855 return; 3856 } 3857 } 3858 data->rpc_status = task->tk_status; 3859 } 3860 3861 static void nfs4_delegreturn_release(void *calldata) 3862 { 3863 kfree(calldata); 3864 } 3865 3866 #if defined(CONFIG_NFS_V4_1) 3867 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data) 3868 { 3869 struct nfs4_delegreturndata *d_data; 3870 3871 d_data = (struct nfs4_delegreturndata *)data; 3872 3873 if (nfs4_setup_sequence(d_data->res.server, 3874 &d_data->args.seq_args, 3875 &d_data->res.seq_res, 1, task)) 3876 return; 3877 rpc_call_start(task); 3878 } 3879 #endif /* CONFIG_NFS_V4_1 */ 3880 3881 static const struct rpc_call_ops nfs4_delegreturn_ops = { 3882 #if defined(CONFIG_NFS_V4_1) 3883 .rpc_call_prepare = nfs4_delegreturn_prepare, 3884 #endif /* CONFIG_NFS_V4_1 */ 3885 .rpc_call_done = nfs4_delegreturn_done, 3886 .rpc_release = nfs4_delegreturn_release, 3887 }; 3888 3889 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 3890 { 3891 struct nfs4_delegreturndata *data; 3892 struct nfs_server *server = NFS_SERVER(inode); 3893 struct rpc_task *task; 3894 struct rpc_message msg = { 3895 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN], 3896 .rpc_cred = cred, 3897 }; 3898 struct rpc_task_setup task_setup_data = { 3899 .rpc_client = server->client, 3900 .rpc_message = &msg, 3901 .callback_ops = &nfs4_delegreturn_ops, 3902 .flags = RPC_TASK_ASYNC, 3903 }; 3904 int status = 0; 3905 3906 data = kzalloc(sizeof(*data), GFP_NOFS); 3907 if (data == NULL) 3908 return -ENOMEM; 3909 data->args.fhandle = &data->fh; 3910 data->args.stateid = &data->stateid; 3911 data->args.bitmask = server->attr_bitmask; 3912 nfs_copy_fh(&data->fh, NFS_FH(inode)); 3913 memcpy(&data->stateid, stateid, sizeof(data->stateid)); 3914 data->res.fattr = &data->fattr; 3915 data->res.server = server; 3916 nfs_fattr_init(data->res.fattr); 3917 data->timestamp = jiffies; 3918 data->rpc_status = 0; 3919 3920 task_setup_data.callback_data = data; 3921 msg.rpc_argp = &data->args; 3922 msg.rpc_resp = &data->res; 3923 task = rpc_run_task(&task_setup_data); 3924 if (IS_ERR(task)) 3925 return PTR_ERR(task); 3926 if (!issync) 3927 goto out; 3928 status = nfs4_wait_for_completion_rpc_task(task); 3929 if (status != 0) 3930 goto out; 3931 status = data->rpc_status; 3932 if (status != 0) 3933 goto out; 3934 nfs_refresh_inode(inode, &data->fattr); 3935 out: 3936 rpc_put_task(task); 3937 return status; 3938 } 3939 3940 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 3941 { 3942 struct nfs_server *server = NFS_SERVER(inode); 3943 struct nfs4_exception exception = { }; 3944 int err; 3945 do { 3946 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync); 3947 switch (err) { 3948 case -NFS4ERR_STALE_STATEID: 3949 case -NFS4ERR_EXPIRED: 3950 case 0: 3951 return 0; 3952 } 3953 err = nfs4_handle_exception(server, err, &exception); 3954 } while (exception.retry); 3955 return err; 3956 } 3957 3958 #define NFS4_LOCK_MINTIMEOUT (1 * HZ) 3959 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ) 3960 3961 /* 3962 * sleep, with exponential backoff, and retry the LOCK operation. 3963 */ 3964 static unsigned long 3965 nfs4_set_lock_task_retry(unsigned long timeout) 3966 { 3967 schedule_timeout_killable(timeout); 3968 timeout <<= 1; 3969 if (timeout > NFS4_LOCK_MAXTIMEOUT) 3970 return NFS4_LOCK_MAXTIMEOUT; 3971 return timeout; 3972 } 3973 3974 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3975 { 3976 struct inode *inode = state->inode; 3977 struct nfs_server *server = NFS_SERVER(inode); 3978 struct nfs_client *clp = server->nfs_client; 3979 struct nfs_lockt_args arg = { 3980 .fh = NFS_FH(inode), 3981 .fl = request, 3982 }; 3983 struct nfs_lockt_res res = { 3984 .denied = request, 3985 }; 3986 struct rpc_message msg = { 3987 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT], 3988 .rpc_argp = &arg, 3989 .rpc_resp = &res, 3990 .rpc_cred = state->owner->so_cred, 3991 }; 3992 struct nfs4_lock_state *lsp; 3993 int status; 3994 3995 arg.lock_owner.clientid = clp->cl_clientid; 3996 status = nfs4_set_lock_state(state, request); 3997 if (status != 0) 3998 goto out; 3999 lsp = request->fl_u.nfs4_fl.owner; 4000 arg.lock_owner.id = lsp->ls_id.id; 4001 arg.lock_owner.s_dev = server->s_dev; 4002 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); 4003 switch (status) { 4004 case 0: 4005 request->fl_type = F_UNLCK; 4006 break; 4007 case -NFS4ERR_DENIED: 4008 status = 0; 4009 } 4010 request->fl_ops->fl_release_private(request); 4011 out: 4012 return status; 4013 } 4014 4015 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 4016 { 4017 struct nfs4_exception exception = { }; 4018 int err; 4019 4020 do { 4021 err = nfs4_handle_exception(NFS_SERVER(state->inode), 4022 _nfs4_proc_getlk(state, cmd, request), 4023 &exception); 4024 } while (exception.retry); 4025 return err; 4026 } 4027 4028 static int do_vfs_lock(struct file *file, struct file_lock *fl) 4029 { 4030 int res = 0; 4031 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 4032 case FL_POSIX: 4033 res = posix_lock_file_wait(file, fl); 4034 break; 4035 case FL_FLOCK: 4036 res = flock_lock_file_wait(file, fl); 4037 break; 4038 default: 4039 BUG(); 4040 } 4041 return res; 4042 } 4043 4044 struct nfs4_unlockdata { 4045 struct nfs_locku_args arg; 4046 struct nfs_locku_res res; 4047 struct nfs4_lock_state *lsp; 4048 struct nfs_open_context *ctx; 4049 struct file_lock fl; 4050 const struct nfs_server *server; 4051 unsigned long timestamp; 4052 }; 4053 4054 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, 4055 struct nfs_open_context *ctx, 4056 struct nfs4_lock_state *lsp, 4057 struct nfs_seqid *seqid) 4058 { 4059 struct nfs4_unlockdata *p; 4060 struct inode *inode = lsp->ls_state->inode; 4061 4062 p = kzalloc(sizeof(*p), GFP_NOFS); 4063 if (p == NULL) 4064 return NULL; 4065 p->arg.fh = NFS_FH(inode); 4066 p->arg.fl = &p->fl; 4067 p->arg.seqid = seqid; 4068 p->res.seqid = seqid; 4069 p->arg.stateid = &lsp->ls_stateid; 4070 p->lsp = lsp; 4071 atomic_inc(&lsp->ls_count); 4072 /* Ensure we don't close file until we're done freeing locks! */ 4073 p->ctx = get_nfs_open_context(ctx); 4074 memcpy(&p->fl, fl, sizeof(p->fl)); 4075 p->server = NFS_SERVER(inode); 4076 return p; 4077 } 4078 4079 static void nfs4_locku_release_calldata(void *data) 4080 { 4081 struct nfs4_unlockdata *calldata = data; 4082 nfs_free_seqid(calldata->arg.seqid); 4083 nfs4_put_lock_state(calldata->lsp); 4084 put_nfs_open_context(calldata->ctx); 4085 kfree(calldata); 4086 } 4087 4088 static void nfs4_locku_done(struct rpc_task *task, void *data) 4089 { 4090 struct nfs4_unlockdata *calldata = data; 4091 4092 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) 4093 return; 4094 switch (task->tk_status) { 4095 case 0: 4096 memcpy(calldata->lsp->ls_stateid.data, 4097 calldata->res.stateid.data, 4098 sizeof(calldata->lsp->ls_stateid.data)); 4099 renew_lease(calldata->server, calldata->timestamp); 4100 break; 4101 case -NFS4ERR_BAD_STATEID: 4102 case -NFS4ERR_OLD_STATEID: 4103 case -NFS4ERR_STALE_STATEID: 4104 case -NFS4ERR_EXPIRED: 4105 break; 4106 default: 4107 if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN) 4108 nfs_restart_rpc(task, 4109 calldata->server->nfs_client); 4110 } 4111 } 4112 4113 static void nfs4_locku_prepare(struct rpc_task *task, void *data) 4114 { 4115 struct nfs4_unlockdata *calldata = data; 4116 4117 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 4118 return; 4119 if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) { 4120 /* Note: exit _without_ running nfs4_locku_done */ 4121 task->tk_action = NULL; 4122 return; 4123 } 4124 calldata->timestamp = jiffies; 4125 if (nfs4_setup_sequence(calldata->server, 4126 &calldata->arg.seq_args, 4127 &calldata->res.seq_res, 1, task)) 4128 return; 4129 rpc_call_start(task); 4130 } 4131 4132 static const struct rpc_call_ops nfs4_locku_ops = { 4133 .rpc_call_prepare = nfs4_locku_prepare, 4134 .rpc_call_done = nfs4_locku_done, 4135 .rpc_release = nfs4_locku_release_calldata, 4136 }; 4137 4138 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 4139 struct nfs_open_context *ctx, 4140 struct nfs4_lock_state *lsp, 4141 struct nfs_seqid *seqid) 4142 { 4143 struct nfs4_unlockdata *data; 4144 struct rpc_message msg = { 4145 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU], 4146 .rpc_cred = ctx->cred, 4147 }; 4148 struct rpc_task_setup task_setup_data = { 4149 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), 4150 .rpc_message = &msg, 4151 .callback_ops = &nfs4_locku_ops, 4152 .workqueue = nfsiod_workqueue, 4153 .flags = RPC_TASK_ASYNC, 4154 }; 4155 4156 /* Ensure this is an unlock - when canceling a lock, the 4157 * canceled lock is passed in, and it won't be an unlock. 4158 */ 4159 fl->fl_type = F_UNLCK; 4160 4161 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); 4162 if (data == NULL) { 4163 nfs_free_seqid(seqid); 4164 return ERR_PTR(-ENOMEM); 4165 } 4166 4167 msg.rpc_argp = &data->arg; 4168 msg.rpc_resp = &data->res; 4169 task_setup_data.callback_data = data; 4170 return rpc_run_task(&task_setup_data); 4171 } 4172 4173 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request) 4174 { 4175 struct nfs_inode *nfsi = NFS_I(state->inode); 4176 struct nfs_seqid *seqid; 4177 struct nfs4_lock_state *lsp; 4178 struct rpc_task *task; 4179 int status = 0; 4180 unsigned char fl_flags = request->fl_flags; 4181 4182 status = nfs4_set_lock_state(state, request); 4183 /* Unlock _before_ we do the RPC call */ 4184 request->fl_flags |= FL_EXISTS; 4185 down_read(&nfsi->rwsem); 4186 if (do_vfs_lock(request->fl_file, request) == -ENOENT) { 4187 up_read(&nfsi->rwsem); 4188 goto out; 4189 } 4190 up_read(&nfsi->rwsem); 4191 if (status != 0) 4192 goto out; 4193 /* Is this a delegated lock? */ 4194 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) 4195 goto out; 4196 lsp = request->fl_u.nfs4_fl.owner; 4197 seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL); 4198 status = -ENOMEM; 4199 if (seqid == NULL) 4200 goto out; 4201 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); 4202 status = PTR_ERR(task); 4203 if (IS_ERR(task)) 4204 goto out; 4205 status = nfs4_wait_for_completion_rpc_task(task); 4206 rpc_put_task(task); 4207 out: 4208 request->fl_flags = fl_flags; 4209 return status; 4210 } 4211 4212 struct nfs4_lockdata { 4213 struct nfs_lock_args arg; 4214 struct nfs_lock_res res; 4215 struct nfs4_lock_state *lsp; 4216 struct nfs_open_context *ctx; 4217 struct file_lock fl; 4218 unsigned long timestamp; 4219 int rpc_status; 4220 int cancelled; 4221 struct nfs_server *server; 4222 }; 4223 4224 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, 4225 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp, 4226 gfp_t gfp_mask) 4227 { 4228 struct nfs4_lockdata *p; 4229 struct inode *inode = lsp->ls_state->inode; 4230 struct nfs_server *server = NFS_SERVER(inode); 4231 4232 p = kzalloc(sizeof(*p), gfp_mask); 4233 if (p == NULL) 4234 return NULL; 4235 4236 p->arg.fh = NFS_FH(inode); 4237 p->arg.fl = &p->fl; 4238 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask); 4239 if (p->arg.open_seqid == NULL) 4240 goto out_free; 4241 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask); 4242 if (p->arg.lock_seqid == NULL) 4243 goto out_free_seqid; 4244 p->arg.lock_stateid = &lsp->ls_stateid; 4245 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; 4246 p->arg.lock_owner.id = lsp->ls_id.id; 4247 p->arg.lock_owner.s_dev = server->s_dev; 4248 p->res.lock_seqid = p->arg.lock_seqid; 4249 p->lsp = lsp; 4250 p->server = server; 4251 atomic_inc(&lsp->ls_count); 4252 p->ctx = get_nfs_open_context(ctx); 4253 memcpy(&p->fl, fl, sizeof(p->fl)); 4254 return p; 4255 out_free_seqid: 4256 nfs_free_seqid(p->arg.open_seqid); 4257 out_free: 4258 kfree(p); 4259 return NULL; 4260 } 4261 4262 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) 4263 { 4264 struct nfs4_lockdata *data = calldata; 4265 struct nfs4_state *state = data->lsp->ls_state; 4266 4267 dprintk("%s: begin!\n", __func__); 4268 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 4269 return; 4270 /* Do we need to do an open_to_lock_owner? */ 4271 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) { 4272 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) 4273 return; 4274 data->arg.open_stateid = &state->stateid; 4275 data->arg.new_lock_owner = 1; 4276 data->res.open_seqid = data->arg.open_seqid; 4277 } else 4278 data->arg.new_lock_owner = 0; 4279 data->timestamp = jiffies; 4280 if (nfs4_setup_sequence(data->server, 4281 &data->arg.seq_args, 4282 &data->res.seq_res, 1, task)) 4283 return; 4284 rpc_call_start(task); 4285 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status); 4286 } 4287 4288 static void nfs4_recover_lock_prepare(struct rpc_task *task, void *calldata) 4289 { 4290 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 4291 nfs4_lock_prepare(task, calldata); 4292 } 4293 4294 static void nfs4_lock_done(struct rpc_task *task, void *calldata) 4295 { 4296 struct nfs4_lockdata *data = calldata; 4297 4298 dprintk("%s: begin!\n", __func__); 4299 4300 if (!nfs4_sequence_done(task, &data->res.seq_res)) 4301 return; 4302 4303 data->rpc_status = task->tk_status; 4304 if (data->arg.new_lock_owner != 0) { 4305 if (data->rpc_status == 0) 4306 nfs_confirm_seqid(&data->lsp->ls_seqid, 0); 4307 else 4308 goto out; 4309 } 4310 if (data->rpc_status == 0) { 4311 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data, 4312 sizeof(data->lsp->ls_stateid.data)); 4313 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED; 4314 renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp); 4315 } 4316 out: 4317 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status); 4318 } 4319 4320 static void nfs4_lock_release(void *calldata) 4321 { 4322 struct nfs4_lockdata *data = calldata; 4323 4324 dprintk("%s: begin!\n", __func__); 4325 nfs_free_seqid(data->arg.open_seqid); 4326 if (data->cancelled != 0) { 4327 struct rpc_task *task; 4328 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, 4329 data->arg.lock_seqid); 4330 if (!IS_ERR(task)) 4331 rpc_put_task_async(task); 4332 dprintk("%s: cancelling lock!\n", __func__); 4333 } else 4334 nfs_free_seqid(data->arg.lock_seqid); 4335 nfs4_put_lock_state(data->lsp); 4336 put_nfs_open_context(data->ctx); 4337 kfree(data); 4338 dprintk("%s: done!\n", __func__); 4339 } 4340 4341 static const struct rpc_call_ops nfs4_lock_ops = { 4342 .rpc_call_prepare = nfs4_lock_prepare, 4343 .rpc_call_done = nfs4_lock_done, 4344 .rpc_release = nfs4_lock_release, 4345 }; 4346 4347 static const struct rpc_call_ops nfs4_recover_lock_ops = { 4348 .rpc_call_prepare = nfs4_recover_lock_prepare, 4349 .rpc_call_done = nfs4_lock_done, 4350 .rpc_release = nfs4_lock_release, 4351 }; 4352 4353 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error) 4354 { 4355 switch (error) { 4356 case -NFS4ERR_ADMIN_REVOKED: 4357 case -NFS4ERR_BAD_STATEID: 4358 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 4359 if (new_lock_owner != 0 || 4360 (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0) 4361 nfs4_schedule_stateid_recovery(server, lsp->ls_state); 4362 break; 4363 case -NFS4ERR_STALE_STATEID: 4364 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; 4365 case -NFS4ERR_EXPIRED: 4366 nfs4_schedule_lease_recovery(server->nfs_client); 4367 }; 4368 } 4369 4370 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type) 4371 { 4372 struct nfs4_lockdata *data; 4373 struct rpc_task *task; 4374 struct rpc_message msg = { 4375 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK], 4376 .rpc_cred = state->owner->so_cred, 4377 }; 4378 struct rpc_task_setup task_setup_data = { 4379 .rpc_client = NFS_CLIENT(state->inode), 4380 .rpc_message = &msg, 4381 .callback_ops = &nfs4_lock_ops, 4382 .workqueue = nfsiod_workqueue, 4383 .flags = RPC_TASK_ASYNC, 4384 }; 4385 int ret; 4386 4387 dprintk("%s: begin!\n", __func__); 4388 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), 4389 fl->fl_u.nfs4_fl.owner, 4390 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS); 4391 if (data == NULL) 4392 return -ENOMEM; 4393 if (IS_SETLKW(cmd)) 4394 data->arg.block = 1; 4395 if (recovery_type > NFS_LOCK_NEW) { 4396 if (recovery_type == NFS_LOCK_RECLAIM) 4397 data->arg.reclaim = NFS_LOCK_RECLAIM; 4398 task_setup_data.callback_ops = &nfs4_recover_lock_ops; 4399 } 4400 msg.rpc_argp = &data->arg; 4401 msg.rpc_resp = &data->res; 4402 task_setup_data.callback_data = data; 4403 task = rpc_run_task(&task_setup_data); 4404 if (IS_ERR(task)) 4405 return PTR_ERR(task); 4406 ret = nfs4_wait_for_completion_rpc_task(task); 4407 if (ret == 0) { 4408 ret = data->rpc_status; 4409 if (ret) 4410 nfs4_handle_setlk_error(data->server, data->lsp, 4411 data->arg.new_lock_owner, ret); 4412 } else 4413 data->cancelled = 1; 4414 rpc_put_task(task); 4415 dprintk("%s: done, ret = %d!\n", __func__, ret); 4416 return ret; 4417 } 4418 4419 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request) 4420 { 4421 struct nfs_server *server = NFS_SERVER(state->inode); 4422 struct nfs4_exception exception = { }; 4423 int err; 4424 4425 do { 4426 /* Cache the lock if possible... */ 4427 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 4428 return 0; 4429 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM); 4430 if (err != -NFS4ERR_DELAY) 4431 break; 4432 nfs4_handle_exception(server, err, &exception); 4433 } while (exception.retry); 4434 return err; 4435 } 4436 4437 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request) 4438 { 4439 struct nfs_server *server = NFS_SERVER(state->inode); 4440 struct nfs4_exception exception = { }; 4441 int err; 4442 4443 err = nfs4_set_lock_state(state, request); 4444 if (err != 0) 4445 return err; 4446 do { 4447 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 4448 return 0; 4449 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED); 4450 switch (err) { 4451 default: 4452 goto out; 4453 case -NFS4ERR_GRACE: 4454 case -NFS4ERR_DELAY: 4455 nfs4_handle_exception(server, err, &exception); 4456 err = 0; 4457 } 4458 } while (exception.retry); 4459 out: 4460 return err; 4461 } 4462 4463 #if defined(CONFIG_NFS_V4_1) 4464 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request) 4465 { 4466 int status; 4467 struct nfs_server *server = NFS_SERVER(state->inode); 4468 4469 status = nfs41_test_stateid(server, state); 4470 if (status == NFS_OK) 4471 return 0; 4472 nfs41_free_stateid(server, state); 4473 return nfs4_lock_expired(state, request); 4474 } 4475 #endif 4476 4477 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 4478 { 4479 struct nfs_inode *nfsi = NFS_I(state->inode); 4480 unsigned char fl_flags = request->fl_flags; 4481 int status = -ENOLCK; 4482 4483 if ((fl_flags & FL_POSIX) && 4484 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) 4485 goto out; 4486 /* Is this a delegated open? */ 4487 status = nfs4_set_lock_state(state, request); 4488 if (status != 0) 4489 goto out; 4490 request->fl_flags |= FL_ACCESS; 4491 status = do_vfs_lock(request->fl_file, request); 4492 if (status < 0) 4493 goto out; 4494 down_read(&nfsi->rwsem); 4495 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 4496 /* Yes: cache locks! */ 4497 /* ...but avoid races with delegation recall... */ 4498 request->fl_flags = fl_flags & ~FL_SLEEP; 4499 status = do_vfs_lock(request->fl_file, request); 4500 goto out_unlock; 4501 } 4502 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW); 4503 if (status != 0) 4504 goto out_unlock; 4505 /* Note: we always want to sleep here! */ 4506 request->fl_flags = fl_flags | FL_SLEEP; 4507 if (do_vfs_lock(request->fl_file, request) < 0) 4508 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__); 4509 out_unlock: 4510 up_read(&nfsi->rwsem); 4511 out: 4512 request->fl_flags = fl_flags; 4513 return status; 4514 } 4515 4516 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 4517 { 4518 struct nfs4_exception exception = { }; 4519 int err; 4520 4521 do { 4522 err = _nfs4_proc_setlk(state, cmd, request); 4523 if (err == -NFS4ERR_DENIED) 4524 err = -EAGAIN; 4525 err = nfs4_handle_exception(NFS_SERVER(state->inode), 4526 err, &exception); 4527 } while (exception.retry); 4528 return err; 4529 } 4530 4531 static int 4532 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) 4533 { 4534 struct nfs_open_context *ctx; 4535 struct nfs4_state *state; 4536 unsigned long timeout = NFS4_LOCK_MINTIMEOUT; 4537 int status; 4538 4539 /* verify open state */ 4540 ctx = nfs_file_open_context(filp); 4541 state = ctx->state; 4542 4543 if (request->fl_start < 0 || request->fl_end < 0) 4544 return -EINVAL; 4545 4546 if (IS_GETLK(cmd)) { 4547 if (state != NULL) 4548 return nfs4_proc_getlk(state, F_GETLK, request); 4549 return 0; 4550 } 4551 4552 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) 4553 return -EINVAL; 4554 4555 if (request->fl_type == F_UNLCK) { 4556 if (state != NULL) 4557 return nfs4_proc_unlck(state, cmd, request); 4558 return 0; 4559 } 4560 4561 if (state == NULL) 4562 return -ENOLCK; 4563 do { 4564 status = nfs4_proc_setlk(state, cmd, request); 4565 if ((status != -EAGAIN) || IS_SETLK(cmd)) 4566 break; 4567 timeout = nfs4_set_lock_task_retry(timeout); 4568 status = -ERESTARTSYS; 4569 if (signalled()) 4570 break; 4571 } while(status < 0); 4572 return status; 4573 } 4574 4575 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl) 4576 { 4577 struct nfs_server *server = NFS_SERVER(state->inode); 4578 struct nfs4_exception exception = { }; 4579 int err; 4580 4581 err = nfs4_set_lock_state(state, fl); 4582 if (err != 0) 4583 goto out; 4584 do { 4585 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); 4586 switch (err) { 4587 default: 4588 printk(KERN_ERR "%s: unhandled error %d.\n", 4589 __func__, err); 4590 case 0: 4591 case -ESTALE: 4592 goto out; 4593 case -NFS4ERR_EXPIRED: 4594 nfs4_schedule_stateid_recovery(server, state); 4595 case -NFS4ERR_STALE_CLIENTID: 4596 case -NFS4ERR_STALE_STATEID: 4597 nfs4_schedule_lease_recovery(server->nfs_client); 4598 goto out; 4599 case -NFS4ERR_BADSESSION: 4600 case -NFS4ERR_BADSLOT: 4601 case -NFS4ERR_BAD_HIGH_SLOT: 4602 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 4603 case -NFS4ERR_DEADSESSION: 4604 nfs4_schedule_session_recovery(server->nfs_client->cl_session); 4605 goto out; 4606 case -ERESTARTSYS: 4607 /* 4608 * The show must go on: exit, but mark the 4609 * stateid as needing recovery. 4610 */ 4611 case -NFS4ERR_ADMIN_REVOKED: 4612 case -NFS4ERR_BAD_STATEID: 4613 case -NFS4ERR_OPENMODE: 4614 nfs4_schedule_stateid_recovery(server, state); 4615 err = 0; 4616 goto out; 4617 case -EKEYEXPIRED: 4618 /* 4619 * User RPCSEC_GSS context has expired. 4620 * We cannot recover this stateid now, so 4621 * skip it and allow recovery thread to 4622 * proceed. 4623 */ 4624 err = 0; 4625 goto out; 4626 case -ENOMEM: 4627 case -NFS4ERR_DENIED: 4628 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 4629 err = 0; 4630 goto out; 4631 case -NFS4ERR_DELAY: 4632 break; 4633 } 4634 err = nfs4_handle_exception(server, err, &exception); 4635 } while (exception.retry); 4636 out: 4637 return err; 4638 } 4639 4640 static void nfs4_release_lockowner_release(void *calldata) 4641 { 4642 kfree(calldata); 4643 } 4644 4645 const struct rpc_call_ops nfs4_release_lockowner_ops = { 4646 .rpc_release = nfs4_release_lockowner_release, 4647 }; 4648 4649 void nfs4_release_lockowner(const struct nfs4_lock_state *lsp) 4650 { 4651 struct nfs_server *server = lsp->ls_state->owner->so_server; 4652 struct nfs_release_lockowner_args *args; 4653 struct rpc_message msg = { 4654 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER], 4655 }; 4656 4657 if (server->nfs_client->cl_mvops->minor_version != 0) 4658 return; 4659 args = kmalloc(sizeof(*args), GFP_NOFS); 4660 if (!args) 4661 return; 4662 args->lock_owner.clientid = server->nfs_client->cl_clientid; 4663 args->lock_owner.id = lsp->ls_id.id; 4664 args->lock_owner.s_dev = server->s_dev; 4665 msg.rpc_argp = args; 4666 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, args); 4667 } 4668 4669 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl" 4670 4671 static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key, 4672 const void *buf, size_t buflen, 4673 int flags, int type) 4674 { 4675 if (strcmp(key, "") != 0) 4676 return -EINVAL; 4677 4678 return nfs4_proc_set_acl(dentry->d_inode, buf, buflen); 4679 } 4680 4681 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key, 4682 void *buf, size_t buflen, int type) 4683 { 4684 if (strcmp(key, "") != 0) 4685 return -EINVAL; 4686 4687 return nfs4_proc_get_acl(dentry->d_inode, buf, buflen); 4688 } 4689 4690 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list, 4691 size_t list_len, const char *name, 4692 size_t name_len, int type) 4693 { 4694 size_t len = sizeof(XATTR_NAME_NFSV4_ACL); 4695 4696 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 4697 return 0; 4698 4699 if (list && len <= list_len) 4700 memcpy(list, XATTR_NAME_NFSV4_ACL, len); 4701 return len; 4702 } 4703 4704 /* 4705 * nfs_fhget will use either the mounted_on_fileid or the fileid 4706 */ 4707 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr) 4708 { 4709 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) || 4710 (fattr->valid & NFS_ATTR_FATTR_FILEID)) && 4711 (fattr->valid & NFS_ATTR_FATTR_FSID) && 4712 (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL))) 4713 return; 4714 4715 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 4716 NFS_ATTR_FATTR_NLINK; 4717 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 4718 fattr->nlink = 2; 4719 } 4720 4721 int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name, 4722 struct nfs4_fs_locations *fs_locations, struct page *page) 4723 { 4724 struct nfs_server *server = NFS_SERVER(dir); 4725 u32 bitmask[2] = { 4726 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 4727 }; 4728 struct nfs4_fs_locations_arg args = { 4729 .dir_fh = NFS_FH(dir), 4730 .name = name, 4731 .page = page, 4732 .bitmask = bitmask, 4733 }; 4734 struct nfs4_fs_locations_res res = { 4735 .fs_locations = fs_locations, 4736 }; 4737 struct rpc_message msg = { 4738 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 4739 .rpc_argp = &args, 4740 .rpc_resp = &res, 4741 }; 4742 int status; 4743 4744 dprintk("%s: start\n", __func__); 4745 4746 /* Ask for the fileid of the absent filesystem if mounted_on_fileid 4747 * is not supported */ 4748 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) 4749 bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID; 4750 else 4751 bitmask[0] |= FATTR4_WORD0_FILEID; 4752 4753 nfs_fattr_init(&fs_locations->fattr); 4754 fs_locations->server = server; 4755 fs_locations->nlocations = 0; 4756 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 4757 dprintk("%s: returned status = %d\n", __func__, status); 4758 return status; 4759 } 4760 4761 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors) 4762 { 4763 int status; 4764 struct nfs4_secinfo_arg args = { 4765 .dir_fh = NFS_FH(dir), 4766 .name = name, 4767 }; 4768 struct nfs4_secinfo_res res = { 4769 .flavors = flavors, 4770 }; 4771 struct rpc_message msg = { 4772 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO], 4773 .rpc_argp = &args, 4774 .rpc_resp = &res, 4775 }; 4776 4777 dprintk("NFS call secinfo %s\n", name->name); 4778 status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0); 4779 dprintk("NFS reply secinfo: %d\n", status); 4780 return status; 4781 } 4782 4783 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors) 4784 { 4785 struct nfs4_exception exception = { }; 4786 int err; 4787 do { 4788 err = nfs4_handle_exception(NFS_SERVER(dir), 4789 _nfs4_proc_secinfo(dir, name, flavors), 4790 &exception); 4791 } while (exception.retry); 4792 return err; 4793 } 4794 4795 #ifdef CONFIG_NFS_V4_1 4796 /* 4797 * Check the exchange flags returned by the server for invalid flags, having 4798 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or 4799 * DS flags set. 4800 */ 4801 static int nfs4_check_cl_exchange_flags(u32 flags) 4802 { 4803 if (flags & ~EXCHGID4_FLAG_MASK_R) 4804 goto out_inval; 4805 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) && 4806 (flags & EXCHGID4_FLAG_USE_NON_PNFS)) 4807 goto out_inval; 4808 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS))) 4809 goto out_inval; 4810 return NFS_OK; 4811 out_inval: 4812 return -NFS4ERR_INVAL; 4813 } 4814 4815 static bool 4816 nfs41_same_server_scope(struct server_scope *a, struct server_scope *b) 4817 { 4818 if (a->server_scope_sz == b->server_scope_sz && 4819 memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0) 4820 return true; 4821 4822 return false; 4823 } 4824 4825 /* 4826 * nfs4_proc_exchange_id() 4827 * 4828 * Since the clientid has expired, all compounds using sessions 4829 * associated with the stale clientid will be returning 4830 * NFS4ERR_BADSESSION in the sequence operation, and will therefore 4831 * be in some phase of session reset. 4832 */ 4833 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred) 4834 { 4835 nfs4_verifier verifier; 4836 struct nfs41_exchange_id_args args = { 4837 .client = clp, 4838 .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER, 4839 }; 4840 struct nfs41_exchange_id_res res = { 4841 .client = clp, 4842 }; 4843 int status; 4844 struct rpc_message msg = { 4845 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID], 4846 .rpc_argp = &args, 4847 .rpc_resp = &res, 4848 .rpc_cred = cred, 4849 }; 4850 __be32 *p; 4851 4852 dprintk("--> %s\n", __func__); 4853 BUG_ON(clp == NULL); 4854 4855 p = (u32 *)verifier.data; 4856 *p++ = htonl((u32)clp->cl_boot_time.tv_sec); 4857 *p = htonl((u32)clp->cl_boot_time.tv_nsec); 4858 args.verifier = &verifier; 4859 4860 args.id_len = scnprintf(args.id, sizeof(args.id), 4861 "%s/%s.%s/%u", 4862 clp->cl_ipaddr, 4863 init_utsname()->nodename, 4864 init_utsname()->domainname, 4865 clp->cl_rpcclient->cl_auth->au_flavor); 4866 4867 res.server_scope = kzalloc(sizeof(struct server_scope), GFP_KERNEL); 4868 if (unlikely(!res.server_scope)) 4869 return -ENOMEM; 4870 4871 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 4872 if (!status) 4873 status = nfs4_check_cl_exchange_flags(clp->cl_exchange_flags); 4874 4875 if (!status) { 4876 if (clp->server_scope && 4877 !nfs41_same_server_scope(clp->server_scope, 4878 res.server_scope)) { 4879 dprintk("%s: server_scope mismatch detected\n", 4880 __func__); 4881 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state); 4882 kfree(clp->server_scope); 4883 clp->server_scope = NULL; 4884 } 4885 4886 if (!clp->server_scope) 4887 clp->server_scope = res.server_scope; 4888 else 4889 kfree(res.server_scope); 4890 } 4891 4892 dprintk("<-- %s status= %d\n", __func__, status); 4893 return status; 4894 } 4895 4896 struct nfs4_get_lease_time_data { 4897 struct nfs4_get_lease_time_args *args; 4898 struct nfs4_get_lease_time_res *res; 4899 struct nfs_client *clp; 4900 }; 4901 4902 static void nfs4_get_lease_time_prepare(struct rpc_task *task, 4903 void *calldata) 4904 { 4905 int ret; 4906 struct nfs4_get_lease_time_data *data = 4907 (struct nfs4_get_lease_time_data *)calldata; 4908 4909 dprintk("--> %s\n", __func__); 4910 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 4911 /* just setup sequence, do not trigger session recovery 4912 since we're invoked within one */ 4913 ret = nfs41_setup_sequence(data->clp->cl_session, 4914 &data->args->la_seq_args, 4915 &data->res->lr_seq_res, 0, task); 4916 4917 BUG_ON(ret == -EAGAIN); 4918 rpc_call_start(task); 4919 dprintk("<-- %s\n", __func__); 4920 } 4921 4922 /* 4923 * Called from nfs4_state_manager thread for session setup, so don't recover 4924 * from sequence operation or clientid errors. 4925 */ 4926 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata) 4927 { 4928 struct nfs4_get_lease_time_data *data = 4929 (struct nfs4_get_lease_time_data *)calldata; 4930 4931 dprintk("--> %s\n", __func__); 4932 if (!nfs41_sequence_done(task, &data->res->lr_seq_res)) 4933 return; 4934 switch (task->tk_status) { 4935 case -NFS4ERR_DELAY: 4936 case -NFS4ERR_GRACE: 4937 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status); 4938 rpc_delay(task, NFS4_POLL_RETRY_MIN); 4939 task->tk_status = 0; 4940 /* fall through */ 4941 case -NFS4ERR_RETRY_UNCACHED_REP: 4942 nfs_restart_rpc(task, data->clp); 4943 return; 4944 } 4945 dprintk("<-- %s\n", __func__); 4946 } 4947 4948 struct rpc_call_ops nfs4_get_lease_time_ops = { 4949 .rpc_call_prepare = nfs4_get_lease_time_prepare, 4950 .rpc_call_done = nfs4_get_lease_time_done, 4951 }; 4952 4953 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo) 4954 { 4955 struct rpc_task *task; 4956 struct nfs4_get_lease_time_args args; 4957 struct nfs4_get_lease_time_res res = { 4958 .lr_fsinfo = fsinfo, 4959 }; 4960 struct nfs4_get_lease_time_data data = { 4961 .args = &args, 4962 .res = &res, 4963 .clp = clp, 4964 }; 4965 struct rpc_message msg = { 4966 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME], 4967 .rpc_argp = &args, 4968 .rpc_resp = &res, 4969 }; 4970 struct rpc_task_setup task_setup = { 4971 .rpc_client = clp->cl_rpcclient, 4972 .rpc_message = &msg, 4973 .callback_ops = &nfs4_get_lease_time_ops, 4974 .callback_data = &data, 4975 .flags = RPC_TASK_TIMEOUT, 4976 }; 4977 int status; 4978 4979 dprintk("--> %s\n", __func__); 4980 task = rpc_run_task(&task_setup); 4981 4982 if (IS_ERR(task)) 4983 status = PTR_ERR(task); 4984 else { 4985 status = task->tk_status; 4986 rpc_put_task(task); 4987 } 4988 dprintk("<-- %s return %d\n", __func__, status); 4989 4990 return status; 4991 } 4992 4993 /* 4994 * Reset a slot table 4995 */ 4996 static int nfs4_reset_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs, 4997 int ivalue) 4998 { 4999 struct nfs4_slot *new = NULL; 5000 int i; 5001 int ret = 0; 5002 5003 dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__, 5004 max_reqs, tbl->max_slots); 5005 5006 /* Does the newly negotiated max_reqs match the existing slot table? */ 5007 if (max_reqs != tbl->max_slots) { 5008 ret = -ENOMEM; 5009 new = kmalloc(max_reqs * sizeof(struct nfs4_slot), 5010 GFP_NOFS); 5011 if (!new) 5012 goto out; 5013 ret = 0; 5014 kfree(tbl->slots); 5015 } 5016 spin_lock(&tbl->slot_tbl_lock); 5017 if (new) { 5018 tbl->slots = new; 5019 tbl->max_slots = max_reqs; 5020 } 5021 for (i = 0; i < tbl->max_slots; ++i) 5022 tbl->slots[i].seq_nr = ivalue; 5023 spin_unlock(&tbl->slot_tbl_lock); 5024 dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__, 5025 tbl, tbl->slots, tbl->max_slots); 5026 out: 5027 dprintk("<-- %s: return %d\n", __func__, ret); 5028 return ret; 5029 } 5030 5031 /* 5032 * Reset the forechannel and backchannel slot tables 5033 */ 5034 static int nfs4_reset_slot_tables(struct nfs4_session *session) 5035 { 5036 int status; 5037 5038 status = nfs4_reset_slot_table(&session->fc_slot_table, 5039 session->fc_attrs.max_reqs, 1); 5040 if (status) 5041 return status; 5042 5043 status = nfs4_reset_slot_table(&session->bc_slot_table, 5044 session->bc_attrs.max_reqs, 0); 5045 return status; 5046 } 5047 5048 /* Destroy the slot table */ 5049 static void nfs4_destroy_slot_tables(struct nfs4_session *session) 5050 { 5051 if (session->fc_slot_table.slots != NULL) { 5052 kfree(session->fc_slot_table.slots); 5053 session->fc_slot_table.slots = NULL; 5054 } 5055 if (session->bc_slot_table.slots != NULL) { 5056 kfree(session->bc_slot_table.slots); 5057 session->bc_slot_table.slots = NULL; 5058 } 5059 return; 5060 } 5061 5062 /* 5063 * Initialize slot table 5064 */ 5065 static int nfs4_init_slot_table(struct nfs4_slot_table *tbl, 5066 int max_slots, int ivalue) 5067 { 5068 struct nfs4_slot *slot; 5069 int ret = -ENOMEM; 5070 5071 BUG_ON(max_slots > NFS4_MAX_SLOT_TABLE); 5072 5073 dprintk("--> %s: max_reqs=%u\n", __func__, max_slots); 5074 5075 slot = kcalloc(max_slots, sizeof(struct nfs4_slot), GFP_NOFS); 5076 if (!slot) 5077 goto out; 5078 ret = 0; 5079 5080 spin_lock(&tbl->slot_tbl_lock); 5081 tbl->max_slots = max_slots; 5082 tbl->slots = slot; 5083 tbl->highest_used_slotid = -1; /* no slot is currently used */ 5084 spin_unlock(&tbl->slot_tbl_lock); 5085 dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__, 5086 tbl, tbl->slots, tbl->max_slots); 5087 out: 5088 dprintk("<-- %s: return %d\n", __func__, ret); 5089 return ret; 5090 } 5091 5092 /* 5093 * Initialize the forechannel and backchannel tables 5094 */ 5095 static int nfs4_init_slot_tables(struct nfs4_session *session) 5096 { 5097 struct nfs4_slot_table *tbl; 5098 int status = 0; 5099 5100 tbl = &session->fc_slot_table; 5101 if (tbl->slots == NULL) { 5102 status = nfs4_init_slot_table(tbl, 5103 session->fc_attrs.max_reqs, 1); 5104 if (status) 5105 return status; 5106 } 5107 5108 tbl = &session->bc_slot_table; 5109 if (tbl->slots == NULL) { 5110 status = nfs4_init_slot_table(tbl, 5111 session->bc_attrs.max_reqs, 0); 5112 if (status) 5113 nfs4_destroy_slot_tables(session); 5114 } 5115 5116 return status; 5117 } 5118 5119 struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp) 5120 { 5121 struct nfs4_session *session; 5122 struct nfs4_slot_table *tbl; 5123 5124 session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS); 5125 if (!session) 5126 return NULL; 5127 5128 tbl = &session->fc_slot_table; 5129 tbl->highest_used_slotid = -1; 5130 spin_lock_init(&tbl->slot_tbl_lock); 5131 rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table"); 5132 init_completion(&tbl->complete); 5133 5134 tbl = &session->bc_slot_table; 5135 tbl->highest_used_slotid = -1; 5136 spin_lock_init(&tbl->slot_tbl_lock); 5137 rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table"); 5138 init_completion(&tbl->complete); 5139 5140 session->session_state = 1<<NFS4_SESSION_INITING; 5141 5142 session->clp = clp; 5143 return session; 5144 } 5145 5146 void nfs4_destroy_session(struct nfs4_session *session) 5147 { 5148 nfs4_proc_destroy_session(session); 5149 dprintk("%s Destroy backchannel for xprt %p\n", 5150 __func__, session->clp->cl_rpcclient->cl_xprt); 5151 xprt_destroy_backchannel(session->clp->cl_rpcclient->cl_xprt, 5152 NFS41_BC_MIN_CALLBACKS); 5153 nfs4_destroy_slot_tables(session); 5154 kfree(session); 5155 } 5156 5157 /* 5158 * Initialize the values to be used by the client in CREATE_SESSION 5159 * If nfs4_init_session set the fore channel request and response sizes, 5160 * use them. 5161 * 5162 * Set the back channel max_resp_sz_cached to zero to force the client to 5163 * always set csa_cachethis to FALSE because the current implementation 5164 * of the back channel DRC only supports caching the CB_SEQUENCE operation. 5165 */ 5166 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args) 5167 { 5168 struct nfs4_session *session = args->client->cl_session; 5169 unsigned int mxrqst_sz = session->fc_attrs.max_rqst_sz, 5170 mxresp_sz = session->fc_attrs.max_resp_sz; 5171 5172 if (mxrqst_sz == 0) 5173 mxrqst_sz = NFS_MAX_FILE_IO_SIZE; 5174 if (mxresp_sz == 0) 5175 mxresp_sz = NFS_MAX_FILE_IO_SIZE; 5176 /* Fore channel attributes */ 5177 args->fc_attrs.max_rqst_sz = mxrqst_sz; 5178 args->fc_attrs.max_resp_sz = mxresp_sz; 5179 args->fc_attrs.max_ops = NFS4_MAX_OPS; 5180 args->fc_attrs.max_reqs = session->clp->cl_rpcclient->cl_xprt->max_reqs; 5181 5182 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u " 5183 "max_ops=%u max_reqs=%u\n", 5184 __func__, 5185 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, 5186 args->fc_attrs.max_ops, args->fc_attrs.max_reqs); 5187 5188 /* Back channel attributes */ 5189 args->bc_attrs.max_rqst_sz = PAGE_SIZE; 5190 args->bc_attrs.max_resp_sz = PAGE_SIZE; 5191 args->bc_attrs.max_resp_sz_cached = 0; 5192 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS; 5193 args->bc_attrs.max_reqs = 1; 5194 5195 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u " 5196 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n", 5197 __func__, 5198 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, 5199 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, 5200 args->bc_attrs.max_reqs); 5201 } 5202 5203 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session) 5204 { 5205 struct nfs4_channel_attrs *sent = &args->fc_attrs; 5206 struct nfs4_channel_attrs *rcvd = &session->fc_attrs; 5207 5208 if (rcvd->max_resp_sz > sent->max_resp_sz) 5209 return -EINVAL; 5210 /* 5211 * Our requested max_ops is the minimum we need; we're not 5212 * prepared to break up compounds into smaller pieces than that. 5213 * So, no point even trying to continue if the server won't 5214 * cooperate: 5215 */ 5216 if (rcvd->max_ops < sent->max_ops) 5217 return -EINVAL; 5218 if (rcvd->max_reqs == 0) 5219 return -EINVAL; 5220 return 0; 5221 } 5222 5223 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session) 5224 { 5225 struct nfs4_channel_attrs *sent = &args->bc_attrs; 5226 struct nfs4_channel_attrs *rcvd = &session->bc_attrs; 5227 5228 if (rcvd->max_rqst_sz > sent->max_rqst_sz) 5229 return -EINVAL; 5230 if (rcvd->max_resp_sz < sent->max_resp_sz) 5231 return -EINVAL; 5232 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached) 5233 return -EINVAL; 5234 /* These would render the backchannel useless: */ 5235 if (rcvd->max_ops == 0) 5236 return -EINVAL; 5237 if (rcvd->max_reqs == 0) 5238 return -EINVAL; 5239 return 0; 5240 } 5241 5242 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args, 5243 struct nfs4_session *session) 5244 { 5245 int ret; 5246 5247 ret = nfs4_verify_fore_channel_attrs(args, session); 5248 if (ret) 5249 return ret; 5250 return nfs4_verify_back_channel_attrs(args, session); 5251 } 5252 5253 static int _nfs4_proc_create_session(struct nfs_client *clp) 5254 { 5255 struct nfs4_session *session = clp->cl_session; 5256 struct nfs41_create_session_args args = { 5257 .client = clp, 5258 .cb_program = NFS4_CALLBACK, 5259 }; 5260 struct nfs41_create_session_res res = { 5261 .client = clp, 5262 }; 5263 struct rpc_message msg = { 5264 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION], 5265 .rpc_argp = &args, 5266 .rpc_resp = &res, 5267 }; 5268 int status; 5269 5270 nfs4_init_channel_attrs(&args); 5271 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN); 5272 5273 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 5274 5275 if (!status) 5276 /* Verify the session's negotiated channel_attrs values */ 5277 status = nfs4_verify_channel_attrs(&args, session); 5278 if (!status) { 5279 /* Increment the clientid slot sequence id */ 5280 clp->cl_seqid++; 5281 } 5282 5283 return status; 5284 } 5285 5286 /* 5287 * Issues a CREATE_SESSION operation to the server. 5288 * It is the responsibility of the caller to verify the session is 5289 * expired before calling this routine. 5290 */ 5291 int nfs4_proc_create_session(struct nfs_client *clp) 5292 { 5293 int status; 5294 unsigned *ptr; 5295 struct nfs4_session *session = clp->cl_session; 5296 5297 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); 5298 5299 status = _nfs4_proc_create_session(clp); 5300 if (status) 5301 goto out; 5302 5303 /* Init and reset the fore channel */ 5304 status = nfs4_init_slot_tables(session); 5305 dprintk("slot table initialization returned %d\n", status); 5306 if (status) 5307 goto out; 5308 status = nfs4_reset_slot_tables(session); 5309 dprintk("slot table reset returned %d\n", status); 5310 if (status) 5311 goto out; 5312 5313 ptr = (unsigned *)&session->sess_id.data[0]; 5314 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__, 5315 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); 5316 out: 5317 dprintk("<-- %s\n", __func__); 5318 return status; 5319 } 5320 5321 /* 5322 * Issue the over-the-wire RPC DESTROY_SESSION. 5323 * The caller must serialize access to this routine. 5324 */ 5325 int nfs4_proc_destroy_session(struct nfs4_session *session) 5326 { 5327 int status = 0; 5328 struct rpc_message msg; 5329 5330 dprintk("--> nfs4_proc_destroy_session\n"); 5331 5332 /* session is still being setup */ 5333 if (session->clp->cl_cons_state != NFS_CS_READY) 5334 return status; 5335 5336 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION]; 5337 msg.rpc_argp = session; 5338 msg.rpc_resp = NULL; 5339 msg.rpc_cred = NULL; 5340 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); 5341 5342 if (status) 5343 printk(KERN_WARNING 5344 "Got error %d from the server on DESTROY_SESSION. " 5345 "Session has been destroyed regardless...\n", status); 5346 5347 dprintk("<-- nfs4_proc_destroy_session\n"); 5348 return status; 5349 } 5350 5351 int nfs4_init_session(struct nfs_server *server) 5352 { 5353 struct nfs_client *clp = server->nfs_client; 5354 struct nfs4_session *session; 5355 unsigned int rsize, wsize; 5356 int ret; 5357 5358 if (!nfs4_has_session(clp)) 5359 return 0; 5360 5361 session = clp->cl_session; 5362 if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) 5363 return 0; 5364 5365 rsize = server->rsize; 5366 if (rsize == 0) 5367 rsize = NFS_MAX_FILE_IO_SIZE; 5368 wsize = server->wsize; 5369 if (wsize == 0) 5370 wsize = NFS_MAX_FILE_IO_SIZE; 5371 5372 session->fc_attrs.max_rqst_sz = wsize + nfs41_maxwrite_overhead; 5373 session->fc_attrs.max_resp_sz = rsize + nfs41_maxread_overhead; 5374 5375 ret = nfs4_recover_expired_lease(server); 5376 if (!ret) 5377 ret = nfs4_check_client_ready(clp); 5378 return ret; 5379 } 5380 5381 int nfs4_init_ds_session(struct nfs_client *clp) 5382 { 5383 struct nfs4_session *session = clp->cl_session; 5384 int ret; 5385 5386 if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) 5387 return 0; 5388 5389 ret = nfs4_client_recover_expired_lease(clp); 5390 if (!ret) 5391 /* Test for the DS role */ 5392 if (!is_ds_client(clp)) 5393 ret = -ENODEV; 5394 if (!ret) 5395 ret = nfs4_check_client_ready(clp); 5396 return ret; 5397 5398 } 5399 EXPORT_SYMBOL_GPL(nfs4_init_ds_session); 5400 5401 5402 /* 5403 * Renew the cl_session lease. 5404 */ 5405 struct nfs4_sequence_data { 5406 struct nfs_client *clp; 5407 struct nfs4_sequence_args args; 5408 struct nfs4_sequence_res res; 5409 }; 5410 5411 static void nfs41_sequence_release(void *data) 5412 { 5413 struct nfs4_sequence_data *calldata = data; 5414 struct nfs_client *clp = calldata->clp; 5415 5416 if (atomic_read(&clp->cl_count) > 1) 5417 nfs4_schedule_state_renewal(clp); 5418 nfs_put_client(clp); 5419 kfree(calldata); 5420 } 5421 5422 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp) 5423 { 5424 switch(task->tk_status) { 5425 case -NFS4ERR_DELAY: 5426 rpc_delay(task, NFS4_POLL_RETRY_MAX); 5427 return -EAGAIN; 5428 default: 5429 nfs4_schedule_lease_recovery(clp); 5430 } 5431 return 0; 5432 } 5433 5434 static void nfs41_sequence_call_done(struct rpc_task *task, void *data) 5435 { 5436 struct nfs4_sequence_data *calldata = data; 5437 struct nfs_client *clp = calldata->clp; 5438 5439 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp)) 5440 return; 5441 5442 if (task->tk_status < 0) { 5443 dprintk("%s ERROR %d\n", __func__, task->tk_status); 5444 if (atomic_read(&clp->cl_count) == 1) 5445 goto out; 5446 5447 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { 5448 rpc_restart_call_prepare(task); 5449 return; 5450 } 5451 } 5452 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred); 5453 out: 5454 dprintk("<-- %s\n", __func__); 5455 } 5456 5457 static void nfs41_sequence_prepare(struct rpc_task *task, void *data) 5458 { 5459 struct nfs4_sequence_data *calldata = data; 5460 struct nfs_client *clp = calldata->clp; 5461 struct nfs4_sequence_args *args; 5462 struct nfs4_sequence_res *res; 5463 5464 args = task->tk_msg.rpc_argp; 5465 res = task->tk_msg.rpc_resp; 5466 5467 if (nfs41_setup_sequence(clp->cl_session, args, res, 0, task)) 5468 return; 5469 rpc_call_start(task); 5470 } 5471 5472 static const struct rpc_call_ops nfs41_sequence_ops = { 5473 .rpc_call_done = nfs41_sequence_call_done, 5474 .rpc_call_prepare = nfs41_sequence_prepare, 5475 .rpc_release = nfs41_sequence_release, 5476 }; 5477 5478 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) 5479 { 5480 struct nfs4_sequence_data *calldata; 5481 struct rpc_message msg = { 5482 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE], 5483 .rpc_cred = cred, 5484 }; 5485 struct rpc_task_setup task_setup_data = { 5486 .rpc_client = clp->cl_rpcclient, 5487 .rpc_message = &msg, 5488 .callback_ops = &nfs41_sequence_ops, 5489 .flags = RPC_TASK_ASYNC | RPC_TASK_SOFT, 5490 }; 5491 5492 if (!atomic_inc_not_zero(&clp->cl_count)) 5493 return ERR_PTR(-EIO); 5494 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 5495 if (calldata == NULL) { 5496 nfs_put_client(clp); 5497 return ERR_PTR(-ENOMEM); 5498 } 5499 msg.rpc_argp = &calldata->args; 5500 msg.rpc_resp = &calldata->res; 5501 calldata->clp = clp; 5502 task_setup_data.callback_data = calldata; 5503 5504 return rpc_run_task(&task_setup_data); 5505 } 5506 5507 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred) 5508 { 5509 struct rpc_task *task; 5510 int ret = 0; 5511 5512 task = _nfs41_proc_sequence(clp, cred); 5513 if (IS_ERR(task)) 5514 ret = PTR_ERR(task); 5515 else 5516 rpc_put_task_async(task); 5517 dprintk("<-- %s status=%d\n", __func__, ret); 5518 return ret; 5519 } 5520 5521 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred) 5522 { 5523 struct rpc_task *task; 5524 int ret; 5525 5526 task = _nfs41_proc_sequence(clp, cred); 5527 if (IS_ERR(task)) { 5528 ret = PTR_ERR(task); 5529 goto out; 5530 } 5531 ret = rpc_wait_for_completion_task(task); 5532 if (!ret) { 5533 struct nfs4_sequence_res *res = task->tk_msg.rpc_resp; 5534 5535 if (task->tk_status == 0) 5536 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags); 5537 ret = task->tk_status; 5538 } 5539 rpc_put_task(task); 5540 out: 5541 dprintk("<-- %s status=%d\n", __func__, ret); 5542 return ret; 5543 } 5544 5545 struct nfs4_reclaim_complete_data { 5546 struct nfs_client *clp; 5547 struct nfs41_reclaim_complete_args arg; 5548 struct nfs41_reclaim_complete_res res; 5549 }; 5550 5551 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data) 5552 { 5553 struct nfs4_reclaim_complete_data *calldata = data; 5554 5555 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED); 5556 if (nfs41_setup_sequence(calldata->clp->cl_session, 5557 &calldata->arg.seq_args, 5558 &calldata->res.seq_res, 0, task)) 5559 return; 5560 5561 rpc_call_start(task); 5562 } 5563 5564 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp) 5565 { 5566 switch(task->tk_status) { 5567 case 0: 5568 case -NFS4ERR_COMPLETE_ALREADY: 5569 case -NFS4ERR_WRONG_CRED: /* What to do here? */ 5570 break; 5571 case -NFS4ERR_DELAY: 5572 rpc_delay(task, NFS4_POLL_RETRY_MAX); 5573 /* fall through */ 5574 case -NFS4ERR_RETRY_UNCACHED_REP: 5575 return -EAGAIN; 5576 default: 5577 nfs4_schedule_lease_recovery(clp); 5578 } 5579 return 0; 5580 } 5581 5582 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data) 5583 { 5584 struct nfs4_reclaim_complete_data *calldata = data; 5585 struct nfs_client *clp = calldata->clp; 5586 struct nfs4_sequence_res *res = &calldata->res.seq_res; 5587 5588 dprintk("--> %s\n", __func__); 5589 if (!nfs41_sequence_done(task, res)) 5590 return; 5591 5592 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { 5593 rpc_restart_call_prepare(task); 5594 return; 5595 } 5596 dprintk("<-- %s\n", __func__); 5597 } 5598 5599 static void nfs4_free_reclaim_complete_data(void *data) 5600 { 5601 struct nfs4_reclaim_complete_data *calldata = data; 5602 5603 kfree(calldata); 5604 } 5605 5606 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = { 5607 .rpc_call_prepare = nfs4_reclaim_complete_prepare, 5608 .rpc_call_done = nfs4_reclaim_complete_done, 5609 .rpc_release = nfs4_free_reclaim_complete_data, 5610 }; 5611 5612 /* 5613 * Issue a global reclaim complete. 5614 */ 5615 static int nfs41_proc_reclaim_complete(struct nfs_client *clp) 5616 { 5617 struct nfs4_reclaim_complete_data *calldata; 5618 struct rpc_task *task; 5619 struct rpc_message msg = { 5620 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE], 5621 }; 5622 struct rpc_task_setup task_setup_data = { 5623 .rpc_client = clp->cl_rpcclient, 5624 .rpc_message = &msg, 5625 .callback_ops = &nfs4_reclaim_complete_call_ops, 5626 .flags = RPC_TASK_ASYNC, 5627 }; 5628 int status = -ENOMEM; 5629 5630 dprintk("--> %s\n", __func__); 5631 calldata = kzalloc(sizeof(*calldata), GFP_NOFS); 5632 if (calldata == NULL) 5633 goto out; 5634 calldata->clp = clp; 5635 calldata->arg.one_fs = 0; 5636 5637 msg.rpc_argp = &calldata->arg; 5638 msg.rpc_resp = &calldata->res; 5639 task_setup_data.callback_data = calldata; 5640 task = rpc_run_task(&task_setup_data); 5641 if (IS_ERR(task)) { 5642 status = PTR_ERR(task); 5643 goto out; 5644 } 5645 status = nfs4_wait_for_completion_rpc_task(task); 5646 if (status == 0) 5647 status = task->tk_status; 5648 rpc_put_task(task); 5649 return 0; 5650 out: 5651 dprintk("<-- %s status=%d\n", __func__, status); 5652 return status; 5653 } 5654 5655 static void 5656 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata) 5657 { 5658 struct nfs4_layoutget *lgp = calldata; 5659 struct nfs_server *server = NFS_SERVER(lgp->args.inode); 5660 5661 dprintk("--> %s\n", __func__); 5662 /* Note the is a race here, where a CB_LAYOUTRECALL can come in 5663 * right now covering the LAYOUTGET we are about to send. 5664 * However, that is not so catastrophic, and there seems 5665 * to be no way to prevent it completely. 5666 */ 5667 if (nfs4_setup_sequence(server, &lgp->args.seq_args, 5668 &lgp->res.seq_res, 0, task)) 5669 return; 5670 if (pnfs_choose_layoutget_stateid(&lgp->args.stateid, 5671 NFS_I(lgp->args.inode)->layout, 5672 lgp->args.ctx->state)) { 5673 rpc_exit(task, NFS4_OK); 5674 return; 5675 } 5676 rpc_call_start(task); 5677 } 5678 5679 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata) 5680 { 5681 struct nfs4_layoutget *lgp = calldata; 5682 struct nfs_server *server = NFS_SERVER(lgp->args.inode); 5683 5684 dprintk("--> %s\n", __func__); 5685 5686 if (!nfs4_sequence_done(task, &lgp->res.seq_res)) 5687 return; 5688 5689 switch (task->tk_status) { 5690 case 0: 5691 break; 5692 case -NFS4ERR_LAYOUTTRYLATER: 5693 case -NFS4ERR_RECALLCONFLICT: 5694 task->tk_status = -NFS4ERR_DELAY; 5695 /* Fall through */ 5696 default: 5697 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) { 5698 rpc_restart_call_prepare(task); 5699 return; 5700 } 5701 } 5702 dprintk("<-- %s\n", __func__); 5703 } 5704 5705 static void nfs4_layoutget_release(void *calldata) 5706 { 5707 struct nfs4_layoutget *lgp = calldata; 5708 5709 dprintk("--> %s\n", __func__); 5710 put_nfs_open_context(lgp->args.ctx); 5711 kfree(calldata); 5712 dprintk("<-- %s\n", __func__); 5713 } 5714 5715 static const struct rpc_call_ops nfs4_layoutget_call_ops = { 5716 .rpc_call_prepare = nfs4_layoutget_prepare, 5717 .rpc_call_done = nfs4_layoutget_done, 5718 .rpc_release = nfs4_layoutget_release, 5719 }; 5720 5721 int nfs4_proc_layoutget(struct nfs4_layoutget *lgp) 5722 { 5723 struct nfs_server *server = NFS_SERVER(lgp->args.inode); 5724 struct rpc_task *task; 5725 struct rpc_message msg = { 5726 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET], 5727 .rpc_argp = &lgp->args, 5728 .rpc_resp = &lgp->res, 5729 }; 5730 struct rpc_task_setup task_setup_data = { 5731 .rpc_client = server->client, 5732 .rpc_message = &msg, 5733 .callback_ops = &nfs4_layoutget_call_ops, 5734 .callback_data = lgp, 5735 .flags = RPC_TASK_ASYNC, 5736 }; 5737 int status = 0; 5738 5739 dprintk("--> %s\n", __func__); 5740 5741 lgp->res.layoutp = &lgp->args.layout; 5742 lgp->res.seq_res.sr_slot = NULL; 5743 task = rpc_run_task(&task_setup_data); 5744 if (IS_ERR(task)) 5745 return PTR_ERR(task); 5746 status = nfs4_wait_for_completion_rpc_task(task); 5747 if (status == 0) 5748 status = task->tk_status; 5749 if (status == 0) 5750 status = pnfs_layout_process(lgp); 5751 rpc_put_task(task); 5752 dprintk("<-- %s status=%d\n", __func__, status); 5753 return status; 5754 } 5755 5756 static void 5757 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata) 5758 { 5759 struct nfs4_layoutreturn *lrp = calldata; 5760 5761 dprintk("--> %s\n", __func__); 5762 if (nfs41_setup_sequence(lrp->clp->cl_session, &lrp->args.seq_args, 5763 &lrp->res.seq_res, 0, task)) 5764 return; 5765 rpc_call_start(task); 5766 } 5767 5768 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata) 5769 { 5770 struct nfs4_layoutreturn *lrp = calldata; 5771 struct nfs_server *server; 5772 struct pnfs_layout_hdr *lo = lrp->args.layout; 5773 5774 dprintk("--> %s\n", __func__); 5775 5776 if (!nfs4_sequence_done(task, &lrp->res.seq_res)) 5777 return; 5778 5779 server = NFS_SERVER(lrp->args.inode); 5780 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) { 5781 nfs_restart_rpc(task, lrp->clp); 5782 return; 5783 } 5784 spin_lock(&lo->plh_inode->i_lock); 5785 if (task->tk_status == 0) { 5786 if (lrp->res.lrs_present) { 5787 pnfs_set_layout_stateid(lo, &lrp->res.stateid, true); 5788 } else 5789 BUG_ON(!list_empty(&lo->plh_segs)); 5790 } 5791 lo->plh_block_lgets--; 5792 spin_unlock(&lo->plh_inode->i_lock); 5793 dprintk("<-- %s\n", __func__); 5794 } 5795 5796 static void nfs4_layoutreturn_release(void *calldata) 5797 { 5798 struct nfs4_layoutreturn *lrp = calldata; 5799 5800 dprintk("--> %s\n", __func__); 5801 put_layout_hdr(lrp->args.layout); 5802 kfree(calldata); 5803 dprintk("<-- %s\n", __func__); 5804 } 5805 5806 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = { 5807 .rpc_call_prepare = nfs4_layoutreturn_prepare, 5808 .rpc_call_done = nfs4_layoutreturn_done, 5809 .rpc_release = nfs4_layoutreturn_release, 5810 }; 5811 5812 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp) 5813 { 5814 struct rpc_task *task; 5815 struct rpc_message msg = { 5816 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN], 5817 .rpc_argp = &lrp->args, 5818 .rpc_resp = &lrp->res, 5819 }; 5820 struct rpc_task_setup task_setup_data = { 5821 .rpc_client = lrp->clp->cl_rpcclient, 5822 .rpc_message = &msg, 5823 .callback_ops = &nfs4_layoutreturn_call_ops, 5824 .callback_data = lrp, 5825 }; 5826 int status; 5827 5828 dprintk("--> %s\n", __func__); 5829 task = rpc_run_task(&task_setup_data); 5830 if (IS_ERR(task)) 5831 return PTR_ERR(task); 5832 status = task->tk_status; 5833 dprintk("<-- %s status=%d\n", __func__, status); 5834 rpc_put_task(task); 5835 return status; 5836 } 5837 5838 /* 5839 * Retrieve the list of Data Server devices from the MDS. 5840 */ 5841 static int _nfs4_getdevicelist(struct nfs_server *server, 5842 const struct nfs_fh *fh, 5843 struct pnfs_devicelist *devlist) 5844 { 5845 struct nfs4_getdevicelist_args args = { 5846 .fh = fh, 5847 .layoutclass = server->pnfs_curr_ld->id, 5848 }; 5849 struct nfs4_getdevicelist_res res = { 5850 .devlist = devlist, 5851 }; 5852 struct rpc_message msg = { 5853 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICELIST], 5854 .rpc_argp = &args, 5855 .rpc_resp = &res, 5856 }; 5857 int status; 5858 5859 dprintk("--> %s\n", __func__); 5860 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, 5861 &res.seq_res, 0); 5862 dprintk("<-- %s status=%d\n", __func__, status); 5863 return status; 5864 } 5865 5866 int nfs4_proc_getdevicelist(struct nfs_server *server, 5867 const struct nfs_fh *fh, 5868 struct pnfs_devicelist *devlist) 5869 { 5870 struct nfs4_exception exception = { }; 5871 int err; 5872 5873 do { 5874 err = nfs4_handle_exception(server, 5875 _nfs4_getdevicelist(server, fh, devlist), 5876 &exception); 5877 } while (exception.retry); 5878 5879 dprintk("%s: err=%d, num_devs=%u\n", __func__, 5880 err, devlist->num_devs); 5881 5882 return err; 5883 } 5884 EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist); 5885 5886 static int 5887 _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev) 5888 { 5889 struct nfs4_getdeviceinfo_args args = { 5890 .pdev = pdev, 5891 }; 5892 struct nfs4_getdeviceinfo_res res = { 5893 .pdev = pdev, 5894 }; 5895 struct rpc_message msg = { 5896 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO], 5897 .rpc_argp = &args, 5898 .rpc_resp = &res, 5899 }; 5900 int status; 5901 5902 dprintk("--> %s\n", __func__); 5903 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 5904 dprintk("<-- %s status=%d\n", __func__, status); 5905 5906 return status; 5907 } 5908 5909 int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev) 5910 { 5911 struct nfs4_exception exception = { }; 5912 int err; 5913 5914 do { 5915 err = nfs4_handle_exception(server, 5916 _nfs4_proc_getdeviceinfo(server, pdev), 5917 &exception); 5918 } while (exception.retry); 5919 return err; 5920 } 5921 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo); 5922 5923 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata) 5924 { 5925 struct nfs4_layoutcommit_data *data = calldata; 5926 struct nfs_server *server = NFS_SERVER(data->args.inode); 5927 5928 if (nfs4_setup_sequence(server, &data->args.seq_args, 5929 &data->res.seq_res, 1, task)) 5930 return; 5931 rpc_call_start(task); 5932 } 5933 5934 static void 5935 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata) 5936 { 5937 struct nfs4_layoutcommit_data *data = calldata; 5938 struct nfs_server *server = NFS_SERVER(data->args.inode); 5939 5940 if (!nfs4_sequence_done(task, &data->res.seq_res)) 5941 return; 5942 5943 switch (task->tk_status) { /* Just ignore these failures */ 5944 case NFS4ERR_DELEG_REVOKED: /* layout was recalled */ 5945 case NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */ 5946 case NFS4ERR_BADLAYOUT: /* no layout */ 5947 case NFS4ERR_GRACE: /* loca_recalim always false */ 5948 task->tk_status = 0; 5949 } 5950 5951 if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) { 5952 nfs_restart_rpc(task, server->nfs_client); 5953 return; 5954 } 5955 5956 if (task->tk_status == 0) 5957 nfs_post_op_update_inode_force_wcc(data->args.inode, 5958 data->res.fattr); 5959 } 5960 5961 static void nfs4_layoutcommit_release(void *calldata) 5962 { 5963 struct nfs4_layoutcommit_data *data = calldata; 5964 struct pnfs_layout_segment *lseg, *tmp; 5965 5966 pnfs_cleanup_layoutcommit(data); 5967 /* Matched by references in pnfs_set_layoutcommit */ 5968 list_for_each_entry_safe(lseg, tmp, &data->lseg_list, pls_lc_list) { 5969 list_del_init(&lseg->pls_lc_list); 5970 if (test_and_clear_bit(NFS_LSEG_LAYOUTCOMMIT, 5971 &lseg->pls_flags)) 5972 put_lseg(lseg); 5973 } 5974 put_rpccred(data->cred); 5975 kfree(data); 5976 } 5977 5978 static const struct rpc_call_ops nfs4_layoutcommit_ops = { 5979 .rpc_call_prepare = nfs4_layoutcommit_prepare, 5980 .rpc_call_done = nfs4_layoutcommit_done, 5981 .rpc_release = nfs4_layoutcommit_release, 5982 }; 5983 5984 int 5985 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync) 5986 { 5987 struct rpc_message msg = { 5988 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT], 5989 .rpc_argp = &data->args, 5990 .rpc_resp = &data->res, 5991 .rpc_cred = data->cred, 5992 }; 5993 struct rpc_task_setup task_setup_data = { 5994 .task = &data->task, 5995 .rpc_client = NFS_CLIENT(data->args.inode), 5996 .rpc_message = &msg, 5997 .callback_ops = &nfs4_layoutcommit_ops, 5998 .callback_data = data, 5999 .flags = RPC_TASK_ASYNC, 6000 }; 6001 struct rpc_task *task; 6002 int status = 0; 6003 6004 dprintk("NFS: %4d initiating layoutcommit call. sync %d " 6005 "lbw: %llu inode %lu\n", 6006 data->task.tk_pid, sync, 6007 data->args.lastbytewritten, 6008 data->args.inode->i_ino); 6009 6010 task = rpc_run_task(&task_setup_data); 6011 if (IS_ERR(task)) 6012 return PTR_ERR(task); 6013 if (sync == false) 6014 goto out; 6015 status = nfs4_wait_for_completion_rpc_task(task); 6016 if (status != 0) 6017 goto out; 6018 status = task->tk_status; 6019 out: 6020 dprintk("%s: status %d\n", __func__, status); 6021 rpc_put_task(task); 6022 return status; 6023 } 6024 6025 static int 6026 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, 6027 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors) 6028 { 6029 struct nfs41_secinfo_no_name_args args = { 6030 .style = SECINFO_STYLE_CURRENT_FH, 6031 }; 6032 struct nfs4_secinfo_res res = { 6033 .flavors = flavors, 6034 }; 6035 struct rpc_message msg = { 6036 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME], 6037 .rpc_argp = &args, 6038 .rpc_resp = &res, 6039 }; 6040 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); 6041 } 6042 6043 static int 6044 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle, 6045 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors) 6046 { 6047 struct nfs4_exception exception = { }; 6048 int err; 6049 do { 6050 err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors); 6051 switch (err) { 6052 case 0: 6053 case -NFS4ERR_WRONGSEC: 6054 case -NFS4ERR_NOTSUPP: 6055 break; 6056 default: 6057 err = nfs4_handle_exception(server, err, &exception); 6058 } 6059 } while (exception.retry); 6060 return err; 6061 } 6062 6063 static int 6064 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle, 6065 struct nfs_fsinfo *info) 6066 { 6067 int err; 6068 struct page *page; 6069 rpc_authflavor_t flavor; 6070 struct nfs4_secinfo_flavors *flavors; 6071 6072 page = alloc_page(GFP_KERNEL); 6073 if (!page) { 6074 err = -ENOMEM; 6075 goto out; 6076 } 6077 6078 flavors = page_address(page); 6079 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors); 6080 6081 /* 6082 * Fall back on "guess and check" method if 6083 * the server doesn't support SECINFO_NO_NAME 6084 */ 6085 if (err == -NFS4ERR_WRONGSEC || err == -NFS4ERR_NOTSUPP) { 6086 err = nfs4_find_root_sec(server, fhandle, info); 6087 goto out_freepage; 6088 } 6089 if (err) 6090 goto out_freepage; 6091 6092 flavor = nfs_find_best_sec(flavors); 6093 if (err == 0) 6094 err = nfs4_lookup_root_sec(server, fhandle, info, flavor); 6095 6096 out_freepage: 6097 put_page(page); 6098 if (err == -EACCES) 6099 return -EPERM; 6100 out: 6101 return err; 6102 } 6103 static int _nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state) 6104 { 6105 int status; 6106 struct nfs41_test_stateid_args args = { 6107 .stateid = &state->stateid, 6108 }; 6109 struct nfs41_test_stateid_res res; 6110 struct rpc_message msg = { 6111 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID], 6112 .rpc_argp = &args, 6113 .rpc_resp = &res, 6114 }; 6115 args.seq_args.sa_session = res.seq_res.sr_session = NULL; 6116 status = nfs4_call_sync_sequence(server->client, server, &msg, &args.seq_args, &res.seq_res, 0, 1); 6117 return status; 6118 } 6119 6120 static int nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state) 6121 { 6122 struct nfs4_exception exception = { }; 6123 int err; 6124 do { 6125 err = nfs4_handle_exception(server, 6126 _nfs41_test_stateid(server, state), 6127 &exception); 6128 } while (exception.retry); 6129 return err; 6130 } 6131 6132 static int _nfs4_free_stateid(struct nfs_server *server, struct nfs4_state *state) 6133 { 6134 int status; 6135 struct nfs41_free_stateid_args args = { 6136 .stateid = &state->stateid, 6137 }; 6138 struct nfs41_free_stateid_res res; 6139 struct rpc_message msg = { 6140 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID], 6141 .rpc_argp = &args, 6142 .rpc_resp = &res, 6143 }; 6144 6145 args.seq_args.sa_session = res.seq_res.sr_session = NULL; 6146 status = nfs4_call_sync_sequence(server->client, server, &msg, &args.seq_args, &res.seq_res, 0, 1); 6147 return status; 6148 } 6149 6150 static int nfs41_free_stateid(struct nfs_server *server, struct nfs4_state *state) 6151 { 6152 struct nfs4_exception exception = { }; 6153 int err; 6154 do { 6155 err = nfs4_handle_exception(server, 6156 _nfs4_free_stateid(server, state), 6157 &exception); 6158 } while (exception.retry); 6159 return err; 6160 } 6161 #endif /* CONFIG_NFS_V4_1 */ 6162 6163 struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = { 6164 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 6165 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 6166 .recover_open = nfs4_open_reclaim, 6167 .recover_lock = nfs4_lock_reclaim, 6168 .establish_clid = nfs4_init_clientid, 6169 .get_clid_cred = nfs4_get_setclientid_cred, 6170 }; 6171 6172 #if defined(CONFIG_NFS_V4_1) 6173 struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = { 6174 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 6175 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 6176 .recover_open = nfs4_open_reclaim, 6177 .recover_lock = nfs4_lock_reclaim, 6178 .establish_clid = nfs41_init_clientid, 6179 .get_clid_cred = nfs4_get_exchange_id_cred, 6180 .reclaim_complete = nfs41_proc_reclaim_complete, 6181 }; 6182 #endif /* CONFIG_NFS_V4_1 */ 6183 6184 struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = { 6185 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 6186 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 6187 .recover_open = nfs4_open_expired, 6188 .recover_lock = nfs4_lock_expired, 6189 .establish_clid = nfs4_init_clientid, 6190 .get_clid_cred = nfs4_get_setclientid_cred, 6191 }; 6192 6193 #if defined(CONFIG_NFS_V4_1) 6194 struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = { 6195 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 6196 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 6197 .recover_open = nfs41_open_expired, 6198 .recover_lock = nfs41_lock_expired, 6199 .establish_clid = nfs41_init_clientid, 6200 .get_clid_cred = nfs4_get_exchange_id_cred, 6201 }; 6202 #endif /* CONFIG_NFS_V4_1 */ 6203 6204 struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { 6205 .sched_state_renewal = nfs4_proc_async_renew, 6206 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked, 6207 .renew_lease = nfs4_proc_renew, 6208 }; 6209 6210 #if defined(CONFIG_NFS_V4_1) 6211 struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { 6212 .sched_state_renewal = nfs41_proc_async_sequence, 6213 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked, 6214 .renew_lease = nfs4_proc_sequence, 6215 }; 6216 #endif 6217 6218 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = { 6219 .minor_version = 0, 6220 .call_sync = _nfs4_call_sync, 6221 .validate_stateid = nfs4_validate_delegation_stateid, 6222 .find_root_sec = nfs4_find_root_sec, 6223 .reboot_recovery_ops = &nfs40_reboot_recovery_ops, 6224 .nograce_recovery_ops = &nfs40_nograce_recovery_ops, 6225 .state_renewal_ops = &nfs40_state_renewal_ops, 6226 }; 6227 6228 #if defined(CONFIG_NFS_V4_1) 6229 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = { 6230 .minor_version = 1, 6231 .call_sync = _nfs4_call_sync_session, 6232 .validate_stateid = nfs41_validate_delegation_stateid, 6233 .find_root_sec = nfs41_find_root_sec, 6234 .reboot_recovery_ops = &nfs41_reboot_recovery_ops, 6235 .nograce_recovery_ops = &nfs41_nograce_recovery_ops, 6236 .state_renewal_ops = &nfs41_state_renewal_ops, 6237 }; 6238 #endif 6239 6240 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = { 6241 [0] = &nfs_v4_0_minor_ops, 6242 #if defined(CONFIG_NFS_V4_1) 6243 [1] = &nfs_v4_1_minor_ops, 6244 #endif 6245 }; 6246 6247 static const struct inode_operations nfs4_file_inode_operations = { 6248 .permission = nfs_permission, 6249 .getattr = nfs_getattr, 6250 .setattr = nfs_setattr, 6251 .getxattr = generic_getxattr, 6252 .setxattr = generic_setxattr, 6253 .listxattr = generic_listxattr, 6254 .removexattr = generic_removexattr, 6255 }; 6256 6257 const struct nfs_rpc_ops nfs_v4_clientops = { 6258 .version = 4, /* protocol version */ 6259 .dentry_ops = &nfs4_dentry_operations, 6260 .dir_inode_ops = &nfs4_dir_inode_operations, 6261 .file_inode_ops = &nfs4_file_inode_operations, 6262 .getroot = nfs4_proc_get_root, 6263 .getattr = nfs4_proc_getattr, 6264 .setattr = nfs4_proc_setattr, 6265 .lookupfh = nfs4_proc_lookupfh, 6266 .lookup = nfs4_proc_lookup, 6267 .access = nfs4_proc_access, 6268 .readlink = nfs4_proc_readlink, 6269 .create = nfs4_proc_create, 6270 .remove = nfs4_proc_remove, 6271 .unlink_setup = nfs4_proc_unlink_setup, 6272 .unlink_done = nfs4_proc_unlink_done, 6273 .rename = nfs4_proc_rename, 6274 .rename_setup = nfs4_proc_rename_setup, 6275 .rename_done = nfs4_proc_rename_done, 6276 .link = nfs4_proc_link, 6277 .symlink = nfs4_proc_symlink, 6278 .mkdir = nfs4_proc_mkdir, 6279 .rmdir = nfs4_proc_remove, 6280 .readdir = nfs4_proc_readdir, 6281 .mknod = nfs4_proc_mknod, 6282 .statfs = nfs4_proc_statfs, 6283 .fsinfo = nfs4_proc_fsinfo, 6284 .pathconf = nfs4_proc_pathconf, 6285 .set_capabilities = nfs4_server_capabilities, 6286 .decode_dirent = nfs4_decode_dirent, 6287 .read_setup = nfs4_proc_read_setup, 6288 .read_done = nfs4_read_done, 6289 .write_setup = nfs4_proc_write_setup, 6290 .write_done = nfs4_write_done, 6291 .commit_setup = nfs4_proc_commit_setup, 6292 .commit_done = nfs4_commit_done, 6293 .lock = nfs4_proc_lock, 6294 .clear_acl_cache = nfs4_zap_acl_attr, 6295 .close_context = nfs4_close_context, 6296 .open_context = nfs4_atomic_open, 6297 .init_client = nfs4_init_client, 6298 .secinfo = nfs4_proc_secinfo, 6299 }; 6300 6301 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { 6302 .prefix = XATTR_NAME_NFSV4_ACL, 6303 .list = nfs4_xattr_list_nfs4_acl, 6304 .get = nfs4_xattr_get_nfs4_acl, 6305 .set = nfs4_xattr_set_nfs4_acl, 6306 }; 6307 6308 const struct xattr_handler *nfs4_xattr_handlers[] = { 6309 &nfs4_xattr_nfs4_acl_handler, 6310 NULL 6311 }; 6312 6313 /* 6314 * Local variables: 6315 * c-basic-offset: 8 6316 * End: 6317 */ 6318