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