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/utsname.h> 40 #include <linux/delay.h> 41 #include <linux/errno.h> 42 #include <linux/string.h> 43 #include <linux/sunrpc/clnt.h> 44 #include <linux/nfs.h> 45 #include <linux/nfs4.h> 46 #include <linux/nfs_fs.h> 47 #include <linux/nfs_page.h> 48 #include <linux/smp_lock.h> 49 #include <linux/namei.h> 50 #include <linux/mount.h> 51 52 #include "nfs4_fs.h" 53 #include "delegation.h" 54 #include "internal.h" 55 #include "iostat.h" 56 57 #define NFSDBG_FACILITY NFSDBG_PROC 58 59 #define NFS4_POLL_RETRY_MIN (HZ/10) 60 #define NFS4_POLL_RETRY_MAX (15*HZ) 61 62 struct nfs4_opendata; 63 static int _nfs4_proc_open(struct nfs4_opendata *data); 64 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); 65 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *); 66 static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr); 67 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr); 68 69 /* Prevent leaks of NFSv4 errors into userland */ 70 static int nfs4_map_errors(int err) 71 { 72 if (err < -1000) { 73 dprintk("%s could not handle NFSv4 error %d\n", 74 __func__, -err); 75 return -EIO; 76 } 77 return err; 78 } 79 80 /* 81 * This is our standard bitmap for GETATTR requests. 82 */ 83 const u32 nfs4_fattr_bitmap[2] = { 84 FATTR4_WORD0_TYPE 85 | FATTR4_WORD0_CHANGE 86 | FATTR4_WORD0_SIZE 87 | FATTR4_WORD0_FSID 88 | FATTR4_WORD0_FILEID, 89 FATTR4_WORD1_MODE 90 | FATTR4_WORD1_NUMLINKS 91 | FATTR4_WORD1_OWNER 92 | FATTR4_WORD1_OWNER_GROUP 93 | FATTR4_WORD1_RAWDEV 94 | FATTR4_WORD1_SPACE_USED 95 | FATTR4_WORD1_TIME_ACCESS 96 | FATTR4_WORD1_TIME_METADATA 97 | FATTR4_WORD1_TIME_MODIFY 98 }; 99 100 const u32 nfs4_statfs_bitmap[2] = { 101 FATTR4_WORD0_FILES_AVAIL 102 | FATTR4_WORD0_FILES_FREE 103 | FATTR4_WORD0_FILES_TOTAL, 104 FATTR4_WORD1_SPACE_AVAIL 105 | FATTR4_WORD1_SPACE_FREE 106 | FATTR4_WORD1_SPACE_TOTAL 107 }; 108 109 const u32 nfs4_pathconf_bitmap[2] = { 110 FATTR4_WORD0_MAXLINK 111 | FATTR4_WORD0_MAXNAME, 112 0 113 }; 114 115 const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE 116 | FATTR4_WORD0_MAXREAD 117 | FATTR4_WORD0_MAXWRITE 118 | FATTR4_WORD0_LEASE_TIME, 119 0 120 }; 121 122 const u32 nfs4_fs_locations_bitmap[2] = { 123 FATTR4_WORD0_TYPE 124 | FATTR4_WORD0_CHANGE 125 | FATTR4_WORD0_SIZE 126 | FATTR4_WORD0_FSID 127 | FATTR4_WORD0_FILEID 128 | FATTR4_WORD0_FS_LOCATIONS, 129 FATTR4_WORD1_MODE 130 | FATTR4_WORD1_NUMLINKS 131 | FATTR4_WORD1_OWNER 132 | FATTR4_WORD1_OWNER_GROUP 133 | FATTR4_WORD1_RAWDEV 134 | FATTR4_WORD1_SPACE_USED 135 | FATTR4_WORD1_TIME_ACCESS 136 | FATTR4_WORD1_TIME_METADATA 137 | FATTR4_WORD1_TIME_MODIFY 138 | FATTR4_WORD1_MOUNTED_ON_FILEID 139 }; 140 141 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry, 142 struct nfs4_readdir_arg *readdir) 143 { 144 __be32 *start, *p; 145 146 BUG_ON(readdir->count < 80); 147 if (cookie > 2) { 148 readdir->cookie = cookie; 149 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); 150 return; 151 } 152 153 readdir->cookie = 0; 154 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); 155 if (cookie == 2) 156 return; 157 158 /* 159 * NFSv4 servers do not return entries for '.' and '..' 160 * Therefore, we fake these entries here. We let '.' 161 * have cookie 0 and '..' have cookie 1. Note that 162 * when talking to the server, we always send cookie 0 163 * instead of 1 or 2. 164 */ 165 start = p = kmap_atomic(*readdir->pages, KM_USER0); 166 167 if (cookie == 0) { 168 *p++ = xdr_one; /* next */ 169 *p++ = xdr_zero; /* cookie, first word */ 170 *p++ = xdr_one; /* cookie, second word */ 171 *p++ = xdr_one; /* entry len */ 172 memcpy(p, ".\0\0\0", 4); /* entry */ 173 p++; 174 *p++ = xdr_one; /* bitmap length */ 175 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 176 *p++ = htonl(8); /* attribute buffer length */ 177 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); 178 } 179 180 *p++ = xdr_one; /* next */ 181 *p++ = xdr_zero; /* cookie, first word */ 182 *p++ = xdr_two; /* cookie, second word */ 183 *p++ = xdr_two; /* entry len */ 184 memcpy(p, "..\0\0", 4); /* entry */ 185 p++; 186 *p++ = xdr_one; /* bitmap length */ 187 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 188 *p++ = htonl(8); /* attribute buffer length */ 189 p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); 190 191 readdir->pgbase = (char *)p - (char *)start; 192 readdir->count -= readdir->pgbase; 193 kunmap_atomic(start, KM_USER0); 194 } 195 196 static int nfs4_wait_clnt_recover(struct nfs_client *clp) 197 { 198 int res; 199 200 might_sleep(); 201 202 res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, 203 nfs_wait_bit_killable, TASK_KILLABLE); 204 return res; 205 } 206 207 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout) 208 { 209 int res = 0; 210 211 might_sleep(); 212 213 if (*timeout <= 0) 214 *timeout = NFS4_POLL_RETRY_MIN; 215 if (*timeout > NFS4_POLL_RETRY_MAX) 216 *timeout = NFS4_POLL_RETRY_MAX; 217 schedule_timeout_killable(*timeout); 218 if (fatal_signal_pending(current)) 219 res = -ERESTARTSYS; 220 *timeout <<= 1; 221 return res; 222 } 223 224 /* This is the error handling routine for processes that are allowed 225 * to sleep. 226 */ 227 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception) 228 { 229 struct nfs_client *clp = server->nfs_client; 230 struct nfs4_state *state = exception->state; 231 int ret = errorcode; 232 233 exception->retry = 0; 234 switch(errorcode) { 235 case 0: 236 return 0; 237 case -NFS4ERR_ADMIN_REVOKED: 238 case -NFS4ERR_BAD_STATEID: 239 case -NFS4ERR_OPENMODE: 240 if (state == NULL) 241 break; 242 nfs4_state_mark_reclaim_nograce(clp, state); 243 case -NFS4ERR_STALE_CLIENTID: 244 case -NFS4ERR_STALE_STATEID: 245 case -NFS4ERR_EXPIRED: 246 nfs4_schedule_state_recovery(clp); 247 ret = nfs4_wait_clnt_recover(clp); 248 if (ret == 0) 249 exception->retry = 1; 250 break; 251 case -NFS4ERR_FILE_OPEN: 252 case -NFS4ERR_GRACE: 253 case -NFS4ERR_DELAY: 254 ret = nfs4_delay(server->client, &exception->timeout); 255 if (ret != 0) 256 break; 257 case -NFS4ERR_OLD_STATEID: 258 exception->retry = 1; 259 } 260 /* We failed to handle the error */ 261 return nfs4_map_errors(ret); 262 } 263 264 265 static void renew_lease(const struct nfs_server *server, unsigned long timestamp) 266 { 267 struct nfs_client *clp = server->nfs_client; 268 spin_lock(&clp->cl_lock); 269 if (time_before(clp->cl_last_renewal,timestamp)) 270 clp->cl_last_renewal = timestamp; 271 spin_unlock(&clp->cl_lock); 272 } 273 274 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo) 275 { 276 struct nfs_inode *nfsi = NFS_I(dir); 277 278 spin_lock(&dir->i_lock); 279 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA; 280 if (!cinfo->atomic || cinfo->before != nfsi->change_attr) 281 nfs_force_lookup_revalidate(dir); 282 nfsi->change_attr = cinfo->after; 283 spin_unlock(&dir->i_lock); 284 } 285 286 struct nfs4_opendata { 287 struct kref kref; 288 struct nfs_openargs o_arg; 289 struct nfs_openres o_res; 290 struct nfs_open_confirmargs c_arg; 291 struct nfs_open_confirmres c_res; 292 struct nfs_fattr f_attr; 293 struct nfs_fattr dir_attr; 294 struct path path; 295 struct dentry *dir; 296 struct nfs4_state_owner *owner; 297 struct nfs4_state *state; 298 struct iattr attrs; 299 unsigned long timestamp; 300 unsigned int rpc_done : 1; 301 int rpc_status; 302 int cancelled; 303 }; 304 305 306 static void nfs4_init_opendata_res(struct nfs4_opendata *p) 307 { 308 p->o_res.f_attr = &p->f_attr; 309 p->o_res.dir_attr = &p->dir_attr; 310 p->o_res.seqid = p->o_arg.seqid; 311 p->c_res.seqid = p->c_arg.seqid; 312 p->o_res.server = p->o_arg.server; 313 nfs_fattr_init(&p->f_attr); 314 nfs_fattr_init(&p->dir_attr); 315 } 316 317 static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path, 318 struct nfs4_state_owner *sp, fmode_t fmode, int flags, 319 const struct iattr *attrs) 320 { 321 struct dentry *parent = dget_parent(path->dentry); 322 struct inode *dir = parent->d_inode; 323 struct nfs_server *server = NFS_SERVER(dir); 324 struct nfs4_opendata *p; 325 326 p = kzalloc(sizeof(*p), GFP_KERNEL); 327 if (p == NULL) 328 goto err; 329 p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid); 330 if (p->o_arg.seqid == NULL) 331 goto err_free; 332 p->path.mnt = mntget(path->mnt); 333 p->path.dentry = dget(path->dentry); 334 p->dir = parent; 335 p->owner = sp; 336 atomic_inc(&sp->so_count); 337 p->o_arg.fh = NFS_FH(dir); 338 p->o_arg.open_flags = flags; 339 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); 340 p->o_arg.clientid = server->nfs_client->cl_clientid; 341 p->o_arg.id = sp->so_owner_id.id; 342 p->o_arg.name = &p->path.dentry->d_name; 343 p->o_arg.server = server; 344 p->o_arg.bitmask = server->attr_bitmask; 345 p->o_arg.claim = NFS4_OPEN_CLAIM_NULL; 346 if (flags & O_EXCL) { 347 u32 *s = (u32 *) p->o_arg.u.verifier.data; 348 s[0] = jiffies; 349 s[1] = current->pid; 350 } else if (flags & O_CREAT) { 351 p->o_arg.u.attrs = &p->attrs; 352 memcpy(&p->attrs, attrs, sizeof(p->attrs)); 353 } 354 p->c_arg.fh = &p->o_res.fh; 355 p->c_arg.stateid = &p->o_res.stateid; 356 p->c_arg.seqid = p->o_arg.seqid; 357 nfs4_init_opendata_res(p); 358 kref_init(&p->kref); 359 return p; 360 err_free: 361 kfree(p); 362 err: 363 dput(parent); 364 return NULL; 365 } 366 367 static void nfs4_opendata_free(struct kref *kref) 368 { 369 struct nfs4_opendata *p = container_of(kref, 370 struct nfs4_opendata, kref); 371 372 nfs_free_seqid(p->o_arg.seqid); 373 if (p->state != NULL) 374 nfs4_put_open_state(p->state); 375 nfs4_put_state_owner(p->owner); 376 dput(p->dir); 377 path_put(&p->path); 378 kfree(p); 379 } 380 381 static void nfs4_opendata_put(struct nfs4_opendata *p) 382 { 383 if (p != NULL) 384 kref_put(&p->kref, nfs4_opendata_free); 385 } 386 387 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task) 388 { 389 int ret; 390 391 ret = rpc_wait_for_completion_task(task); 392 return ret; 393 } 394 395 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode) 396 { 397 int ret = 0; 398 399 if (open_mode & O_EXCL) 400 goto out; 401 switch (mode & (FMODE_READ|FMODE_WRITE)) { 402 case FMODE_READ: 403 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0; 404 break; 405 case FMODE_WRITE: 406 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0; 407 break; 408 case FMODE_READ|FMODE_WRITE: 409 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0; 410 } 411 out: 412 return ret; 413 } 414 415 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode) 416 { 417 if ((delegation->type & fmode) != fmode) 418 return 0; 419 if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) 420 return 0; 421 nfs_mark_delegation_referenced(delegation); 422 return 1; 423 } 424 425 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode) 426 { 427 switch (fmode) { 428 case FMODE_WRITE: 429 state->n_wronly++; 430 break; 431 case FMODE_READ: 432 state->n_rdonly++; 433 break; 434 case FMODE_READ|FMODE_WRITE: 435 state->n_rdwr++; 436 } 437 nfs4_state_set_mode_locked(state, state->state | fmode); 438 } 439 440 static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 441 { 442 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 443 memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data)); 444 memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data)); 445 switch (fmode) { 446 case FMODE_READ: 447 set_bit(NFS_O_RDONLY_STATE, &state->flags); 448 break; 449 case FMODE_WRITE: 450 set_bit(NFS_O_WRONLY_STATE, &state->flags); 451 break; 452 case FMODE_READ|FMODE_WRITE: 453 set_bit(NFS_O_RDWR_STATE, &state->flags); 454 } 455 } 456 457 static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode) 458 { 459 write_seqlock(&state->seqlock); 460 nfs_set_open_stateid_locked(state, stateid, fmode); 461 write_sequnlock(&state->seqlock); 462 } 463 464 static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode) 465 { 466 /* 467 * Protect the call to nfs4_state_set_mode_locked and 468 * serialise the stateid update 469 */ 470 write_seqlock(&state->seqlock); 471 if (deleg_stateid != NULL) { 472 memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data)); 473 set_bit(NFS_DELEGATED_STATE, &state->flags); 474 } 475 if (open_stateid != NULL) 476 nfs_set_open_stateid_locked(state, open_stateid, fmode); 477 write_sequnlock(&state->seqlock); 478 spin_lock(&state->owner->so_lock); 479 update_open_stateflags(state, fmode); 480 spin_unlock(&state->owner->so_lock); 481 } 482 483 static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode) 484 { 485 struct nfs_inode *nfsi = NFS_I(state->inode); 486 struct nfs_delegation *deleg_cur; 487 int ret = 0; 488 489 fmode &= (FMODE_READ|FMODE_WRITE); 490 491 rcu_read_lock(); 492 deleg_cur = rcu_dereference(nfsi->delegation); 493 if (deleg_cur == NULL) 494 goto no_delegation; 495 496 spin_lock(&deleg_cur->lock); 497 if (nfsi->delegation != deleg_cur || 498 (deleg_cur->type & fmode) != fmode) 499 goto no_delegation_unlock; 500 501 if (delegation == NULL) 502 delegation = &deleg_cur->stateid; 503 else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0) 504 goto no_delegation_unlock; 505 506 nfs_mark_delegation_referenced(deleg_cur); 507 __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode); 508 ret = 1; 509 no_delegation_unlock: 510 spin_unlock(&deleg_cur->lock); 511 no_delegation: 512 rcu_read_unlock(); 513 514 if (!ret && open_stateid != NULL) { 515 __update_open_stateid(state, open_stateid, NULL, fmode); 516 ret = 1; 517 } 518 519 return ret; 520 } 521 522 523 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode) 524 { 525 struct nfs_delegation *delegation; 526 527 rcu_read_lock(); 528 delegation = rcu_dereference(NFS_I(inode)->delegation); 529 if (delegation == NULL || (delegation->type & fmode) == fmode) { 530 rcu_read_unlock(); 531 return; 532 } 533 rcu_read_unlock(); 534 nfs_inode_return_delegation(inode); 535 } 536 537 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata) 538 { 539 struct nfs4_state *state = opendata->state; 540 struct nfs_inode *nfsi = NFS_I(state->inode); 541 struct nfs_delegation *delegation; 542 int open_mode = opendata->o_arg.open_flags & O_EXCL; 543 fmode_t fmode = opendata->o_arg.fmode; 544 nfs4_stateid stateid; 545 int ret = -EAGAIN; 546 547 for (;;) { 548 if (can_open_cached(state, fmode, open_mode)) { 549 spin_lock(&state->owner->so_lock); 550 if (can_open_cached(state, fmode, open_mode)) { 551 update_open_stateflags(state, fmode); 552 spin_unlock(&state->owner->so_lock); 553 goto out_return_state; 554 } 555 spin_unlock(&state->owner->so_lock); 556 } 557 rcu_read_lock(); 558 delegation = rcu_dereference(nfsi->delegation); 559 if (delegation == NULL || 560 !can_open_delegated(delegation, fmode)) { 561 rcu_read_unlock(); 562 break; 563 } 564 /* Save the delegation */ 565 memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data)); 566 rcu_read_unlock(); 567 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); 568 if (ret != 0) 569 goto out; 570 ret = -EAGAIN; 571 572 /* Try to update the stateid using the delegation */ 573 if (update_open_stateid(state, NULL, &stateid, fmode)) 574 goto out_return_state; 575 } 576 out: 577 return ERR_PTR(ret); 578 out_return_state: 579 atomic_inc(&state->count); 580 return state; 581 } 582 583 static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data) 584 { 585 struct inode *inode; 586 struct nfs4_state *state = NULL; 587 struct nfs_delegation *delegation; 588 int ret; 589 590 if (!data->rpc_done) { 591 state = nfs4_try_open_cached(data); 592 goto out; 593 } 594 595 ret = -EAGAIN; 596 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) 597 goto err; 598 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr); 599 ret = PTR_ERR(inode); 600 if (IS_ERR(inode)) 601 goto err; 602 ret = -ENOMEM; 603 state = nfs4_get_open_state(inode, data->owner); 604 if (state == NULL) 605 goto err_put_inode; 606 if (data->o_res.delegation_type != 0) { 607 int delegation_flags = 0; 608 609 rcu_read_lock(); 610 delegation = rcu_dereference(NFS_I(inode)->delegation); 611 if (delegation) 612 delegation_flags = delegation->flags; 613 rcu_read_unlock(); 614 if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0) 615 nfs_inode_set_delegation(state->inode, 616 data->owner->so_cred, 617 &data->o_res); 618 else 619 nfs_inode_reclaim_delegation(state->inode, 620 data->owner->so_cred, 621 &data->o_res); 622 } 623 624 update_open_stateid(state, &data->o_res.stateid, NULL, 625 data->o_arg.fmode); 626 iput(inode); 627 out: 628 return state; 629 err_put_inode: 630 iput(inode); 631 err: 632 return ERR_PTR(ret); 633 } 634 635 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state) 636 { 637 struct nfs_inode *nfsi = NFS_I(state->inode); 638 struct nfs_open_context *ctx; 639 640 spin_lock(&state->inode->i_lock); 641 list_for_each_entry(ctx, &nfsi->open_files, list) { 642 if (ctx->state != state) 643 continue; 644 get_nfs_open_context(ctx); 645 spin_unlock(&state->inode->i_lock); 646 return ctx; 647 } 648 spin_unlock(&state->inode->i_lock); 649 return ERR_PTR(-ENOENT); 650 } 651 652 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state) 653 { 654 struct nfs4_opendata *opendata; 655 656 opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL); 657 if (opendata == NULL) 658 return ERR_PTR(-ENOMEM); 659 opendata->state = state; 660 atomic_inc(&state->count); 661 return opendata; 662 } 663 664 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res) 665 { 666 struct nfs4_state *newstate; 667 int ret; 668 669 opendata->o_arg.open_flags = 0; 670 opendata->o_arg.fmode = fmode; 671 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); 672 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); 673 nfs4_init_opendata_res(opendata); 674 ret = _nfs4_proc_open(opendata); 675 if (ret != 0) 676 return ret; 677 newstate = nfs4_opendata_to_nfs4_state(opendata); 678 if (IS_ERR(newstate)) 679 return PTR_ERR(newstate); 680 nfs4_close_state(&opendata->path, newstate, fmode); 681 *res = newstate; 682 return 0; 683 } 684 685 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state) 686 { 687 struct nfs4_state *newstate; 688 int ret; 689 690 /* memory barrier prior to reading state->n_* */ 691 clear_bit(NFS_DELEGATED_STATE, &state->flags); 692 smp_rmb(); 693 if (state->n_rdwr != 0) { 694 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate); 695 if (ret != 0) 696 return ret; 697 if (newstate != state) 698 return -ESTALE; 699 } 700 if (state->n_wronly != 0) { 701 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate); 702 if (ret != 0) 703 return ret; 704 if (newstate != state) 705 return -ESTALE; 706 } 707 if (state->n_rdonly != 0) { 708 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate); 709 if (ret != 0) 710 return ret; 711 if (newstate != state) 712 return -ESTALE; 713 } 714 /* 715 * We may have performed cached opens for all three recoveries. 716 * Check if we need to update the current stateid. 717 */ 718 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && 719 memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) { 720 write_seqlock(&state->seqlock); 721 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) 722 memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)); 723 write_sequnlock(&state->seqlock); 724 } 725 return 0; 726 } 727 728 /* 729 * OPEN_RECLAIM: 730 * reclaim state on the server after a reboot. 731 */ 732 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 733 { 734 struct nfs_delegation *delegation; 735 struct nfs4_opendata *opendata; 736 fmode_t delegation_type = 0; 737 int status; 738 739 opendata = nfs4_open_recoverdata_alloc(ctx, state); 740 if (IS_ERR(opendata)) 741 return PTR_ERR(opendata); 742 opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS; 743 opendata->o_arg.fh = NFS_FH(state->inode); 744 rcu_read_lock(); 745 delegation = rcu_dereference(NFS_I(state->inode)->delegation); 746 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) 747 delegation_type = delegation->type; 748 rcu_read_unlock(); 749 opendata->o_arg.u.delegation_type = delegation_type; 750 status = nfs4_open_recover(opendata, state); 751 nfs4_opendata_put(opendata); 752 return status; 753 } 754 755 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state) 756 { 757 struct nfs_server *server = NFS_SERVER(state->inode); 758 struct nfs4_exception exception = { }; 759 int err; 760 do { 761 err = _nfs4_do_open_reclaim(ctx, state); 762 if (err != -NFS4ERR_DELAY) 763 break; 764 nfs4_handle_exception(server, err, &exception); 765 } while (exception.retry); 766 return err; 767 } 768 769 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state) 770 { 771 struct nfs_open_context *ctx; 772 int ret; 773 774 ctx = nfs4_state_find_open_context(state); 775 if (IS_ERR(ctx)) 776 return PTR_ERR(ctx); 777 ret = nfs4_do_open_reclaim(ctx, state); 778 put_nfs_open_context(ctx); 779 return ret; 780 } 781 782 static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 783 { 784 struct nfs4_opendata *opendata; 785 int ret; 786 787 opendata = nfs4_open_recoverdata_alloc(ctx, state); 788 if (IS_ERR(opendata)) 789 return PTR_ERR(opendata); 790 opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR; 791 memcpy(opendata->o_arg.u.delegation.data, stateid->data, 792 sizeof(opendata->o_arg.u.delegation.data)); 793 ret = nfs4_open_recover(opendata, state); 794 nfs4_opendata_put(opendata); 795 return ret; 796 } 797 798 int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) 799 { 800 struct nfs4_exception exception = { }; 801 struct nfs_server *server = NFS_SERVER(state->inode); 802 int err; 803 do { 804 err = _nfs4_open_delegation_recall(ctx, state, stateid); 805 switch (err) { 806 case 0: 807 return err; 808 case -NFS4ERR_STALE_CLIENTID: 809 case -NFS4ERR_STALE_STATEID: 810 case -NFS4ERR_EXPIRED: 811 /* Don't recall a delegation if it was lost */ 812 nfs4_schedule_state_recovery(server->nfs_client); 813 return err; 814 } 815 err = nfs4_handle_exception(server, err, &exception); 816 } while (exception.retry); 817 return err; 818 } 819 820 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) 821 { 822 struct nfs4_opendata *data = calldata; 823 824 data->rpc_status = task->tk_status; 825 if (RPC_ASSASSINATED(task)) 826 return; 827 if (data->rpc_status == 0) { 828 memcpy(data->o_res.stateid.data, data->c_res.stateid.data, 829 sizeof(data->o_res.stateid.data)); 830 nfs_confirm_seqid(&data->owner->so_seqid, 0); 831 renew_lease(data->o_res.server, data->timestamp); 832 data->rpc_done = 1; 833 } 834 } 835 836 static void nfs4_open_confirm_release(void *calldata) 837 { 838 struct nfs4_opendata *data = calldata; 839 struct nfs4_state *state = NULL; 840 841 /* If this request hasn't been cancelled, do nothing */ 842 if (data->cancelled == 0) 843 goto out_free; 844 /* In case of error, no cleanup! */ 845 if (!data->rpc_done) 846 goto out_free; 847 state = nfs4_opendata_to_nfs4_state(data); 848 if (!IS_ERR(state)) 849 nfs4_close_state(&data->path, state, data->o_arg.fmode); 850 out_free: 851 nfs4_opendata_put(data); 852 } 853 854 static const struct rpc_call_ops nfs4_open_confirm_ops = { 855 .rpc_call_done = nfs4_open_confirm_done, 856 .rpc_release = nfs4_open_confirm_release, 857 }; 858 859 /* 860 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata 861 */ 862 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 863 { 864 struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 865 struct rpc_task *task; 866 struct rpc_message msg = { 867 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM], 868 .rpc_argp = &data->c_arg, 869 .rpc_resp = &data->c_res, 870 .rpc_cred = data->owner->so_cred, 871 }; 872 struct rpc_task_setup task_setup_data = { 873 .rpc_client = server->client, 874 .rpc_message = &msg, 875 .callback_ops = &nfs4_open_confirm_ops, 876 .callback_data = data, 877 .workqueue = nfsiod_workqueue, 878 .flags = RPC_TASK_ASYNC, 879 }; 880 int status; 881 882 kref_get(&data->kref); 883 data->rpc_done = 0; 884 data->rpc_status = 0; 885 data->timestamp = jiffies; 886 task = rpc_run_task(&task_setup_data); 887 if (IS_ERR(task)) 888 return PTR_ERR(task); 889 status = nfs4_wait_for_completion_rpc_task(task); 890 if (status != 0) { 891 data->cancelled = 1; 892 smp_wmb(); 893 } else 894 status = data->rpc_status; 895 rpc_put_task(task); 896 return status; 897 } 898 899 static void nfs4_open_prepare(struct rpc_task *task, void *calldata) 900 { 901 struct nfs4_opendata *data = calldata; 902 struct nfs4_state_owner *sp = data->owner; 903 904 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) 905 return; 906 /* 907 * Check if we still need to send an OPEN call, or if we can use 908 * a delegation instead. 909 */ 910 if (data->state != NULL) { 911 struct nfs_delegation *delegation; 912 913 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags)) 914 goto out_no_action; 915 rcu_read_lock(); 916 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); 917 if (delegation != NULL && 918 test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) { 919 rcu_read_unlock(); 920 goto out_no_action; 921 } 922 rcu_read_unlock(); 923 } 924 /* Update sequence id. */ 925 data->o_arg.id = sp->so_owner_id.id; 926 data->o_arg.clientid = sp->so_client->cl_clientid; 927 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) { 928 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; 929 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); 930 } 931 data->timestamp = jiffies; 932 rpc_call_start(task); 933 return; 934 out_no_action: 935 task->tk_action = NULL; 936 937 } 938 939 static void nfs4_open_done(struct rpc_task *task, void *calldata) 940 { 941 struct nfs4_opendata *data = calldata; 942 943 data->rpc_status = task->tk_status; 944 if (RPC_ASSASSINATED(task)) 945 return; 946 if (task->tk_status == 0) { 947 switch (data->o_res.f_attr->mode & S_IFMT) { 948 case S_IFREG: 949 break; 950 case S_IFLNK: 951 data->rpc_status = -ELOOP; 952 break; 953 case S_IFDIR: 954 data->rpc_status = -EISDIR; 955 break; 956 default: 957 data->rpc_status = -ENOTDIR; 958 } 959 renew_lease(data->o_res.server, data->timestamp); 960 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) 961 nfs_confirm_seqid(&data->owner->so_seqid, 0); 962 } 963 data->rpc_done = 1; 964 } 965 966 static void nfs4_open_release(void *calldata) 967 { 968 struct nfs4_opendata *data = calldata; 969 struct nfs4_state *state = NULL; 970 971 /* If this request hasn't been cancelled, do nothing */ 972 if (data->cancelled == 0) 973 goto out_free; 974 /* In case of error, no cleanup! */ 975 if (data->rpc_status != 0 || !data->rpc_done) 976 goto out_free; 977 /* In case we need an open_confirm, no cleanup! */ 978 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) 979 goto out_free; 980 state = nfs4_opendata_to_nfs4_state(data); 981 if (!IS_ERR(state)) 982 nfs4_close_state(&data->path, state, data->o_arg.fmode); 983 out_free: 984 nfs4_opendata_put(data); 985 } 986 987 static const struct rpc_call_ops nfs4_open_ops = { 988 .rpc_call_prepare = nfs4_open_prepare, 989 .rpc_call_done = nfs4_open_done, 990 .rpc_release = nfs4_open_release, 991 }; 992 993 /* 994 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata 995 */ 996 static int _nfs4_proc_open(struct nfs4_opendata *data) 997 { 998 struct inode *dir = data->dir->d_inode; 999 struct nfs_server *server = NFS_SERVER(dir); 1000 struct nfs_openargs *o_arg = &data->o_arg; 1001 struct nfs_openres *o_res = &data->o_res; 1002 struct rpc_task *task; 1003 struct rpc_message msg = { 1004 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN], 1005 .rpc_argp = o_arg, 1006 .rpc_resp = o_res, 1007 .rpc_cred = data->owner->so_cred, 1008 }; 1009 struct rpc_task_setup task_setup_data = { 1010 .rpc_client = server->client, 1011 .rpc_message = &msg, 1012 .callback_ops = &nfs4_open_ops, 1013 .callback_data = data, 1014 .workqueue = nfsiod_workqueue, 1015 .flags = RPC_TASK_ASYNC, 1016 }; 1017 int status; 1018 1019 kref_get(&data->kref); 1020 data->rpc_done = 0; 1021 data->rpc_status = 0; 1022 data->cancelled = 0; 1023 task = rpc_run_task(&task_setup_data); 1024 if (IS_ERR(task)) 1025 return PTR_ERR(task); 1026 status = nfs4_wait_for_completion_rpc_task(task); 1027 if (status != 0) { 1028 data->cancelled = 1; 1029 smp_wmb(); 1030 } else 1031 status = data->rpc_status; 1032 rpc_put_task(task); 1033 if (status != 0 || !data->rpc_done) 1034 return status; 1035 1036 if (o_res->fh.size == 0) 1037 _nfs4_proc_lookup(dir, o_arg->name, &o_res->fh, o_res->f_attr); 1038 1039 if (o_arg->open_flags & O_CREAT) { 1040 update_changeattr(dir, &o_res->cinfo); 1041 nfs_post_op_update_inode(dir, o_res->dir_attr); 1042 } else 1043 nfs_refresh_inode(dir, o_res->dir_attr); 1044 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { 1045 status = _nfs4_proc_open_confirm(data); 1046 if (status != 0) 1047 return status; 1048 } 1049 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) 1050 _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr); 1051 return 0; 1052 } 1053 1054 static int nfs4_recover_expired_lease(struct nfs_server *server) 1055 { 1056 struct nfs_client *clp = server->nfs_client; 1057 int ret; 1058 1059 for (;;) { 1060 ret = nfs4_wait_clnt_recover(clp); 1061 if (ret != 0) 1062 return ret; 1063 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && 1064 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) 1065 break; 1066 nfs4_schedule_state_recovery(clp); 1067 } 1068 return 0; 1069 } 1070 1071 /* 1072 * OPEN_EXPIRED: 1073 * reclaim state on the server after a network partition. 1074 * Assumes caller holds the appropriate lock 1075 */ 1076 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 1077 { 1078 struct nfs4_opendata *opendata; 1079 int ret; 1080 1081 opendata = nfs4_open_recoverdata_alloc(ctx, state); 1082 if (IS_ERR(opendata)) 1083 return PTR_ERR(opendata); 1084 ret = nfs4_open_recover(opendata, state); 1085 if (ret == -ESTALE) 1086 d_drop(ctx->path.dentry); 1087 nfs4_opendata_put(opendata); 1088 return ret; 1089 } 1090 1091 static inline int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state) 1092 { 1093 struct nfs_server *server = NFS_SERVER(state->inode); 1094 struct nfs4_exception exception = { }; 1095 int err; 1096 1097 do { 1098 err = _nfs4_open_expired(ctx, state); 1099 if (err != -NFS4ERR_DELAY) 1100 break; 1101 nfs4_handle_exception(server, err, &exception); 1102 } while (exception.retry); 1103 return err; 1104 } 1105 1106 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state) 1107 { 1108 struct nfs_open_context *ctx; 1109 int ret; 1110 1111 ctx = nfs4_state_find_open_context(state); 1112 if (IS_ERR(ctx)) 1113 return PTR_ERR(ctx); 1114 ret = nfs4_do_open_expired(ctx, state); 1115 put_nfs_open_context(ctx); 1116 return ret; 1117 } 1118 1119 /* 1120 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-* 1121 * fields corresponding to attributes that were used to store the verifier. 1122 * Make sure we clobber those fields in the later setattr call 1123 */ 1124 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr) 1125 { 1126 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) && 1127 !(sattr->ia_valid & ATTR_ATIME_SET)) 1128 sattr->ia_valid |= ATTR_ATIME; 1129 1130 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) && 1131 !(sattr->ia_valid & ATTR_MTIME_SET)) 1132 sattr->ia_valid |= ATTR_MTIME; 1133 } 1134 1135 /* 1136 * Returns a referenced nfs4_state 1137 */ 1138 static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res) 1139 { 1140 struct nfs4_state_owner *sp; 1141 struct nfs4_state *state = NULL; 1142 struct nfs_server *server = NFS_SERVER(dir); 1143 struct nfs4_opendata *opendata; 1144 int status; 1145 1146 /* Protect against reboot recovery conflicts */ 1147 status = -ENOMEM; 1148 if (!(sp = nfs4_get_state_owner(server, cred))) { 1149 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n"); 1150 goto out_err; 1151 } 1152 status = nfs4_recover_expired_lease(server); 1153 if (status != 0) 1154 goto err_put_state_owner; 1155 if (path->dentry->d_inode != NULL) 1156 nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode); 1157 status = -ENOMEM; 1158 opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr); 1159 if (opendata == NULL) 1160 goto err_put_state_owner; 1161 1162 if (path->dentry->d_inode != NULL) 1163 opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp); 1164 1165 status = _nfs4_proc_open(opendata); 1166 if (status != 0) 1167 goto err_opendata_put; 1168 1169 if (opendata->o_arg.open_flags & O_EXCL) 1170 nfs4_exclusive_attrset(opendata, sattr); 1171 1172 state = nfs4_opendata_to_nfs4_state(opendata); 1173 status = PTR_ERR(state); 1174 if (IS_ERR(state)) 1175 goto err_opendata_put; 1176 nfs4_opendata_put(opendata); 1177 nfs4_put_state_owner(sp); 1178 *res = state; 1179 return 0; 1180 err_opendata_put: 1181 nfs4_opendata_put(opendata); 1182 err_put_state_owner: 1183 nfs4_put_state_owner(sp); 1184 out_err: 1185 *res = NULL; 1186 return status; 1187 } 1188 1189 1190 static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred) 1191 { 1192 struct nfs4_exception exception = { }; 1193 struct nfs4_state *res; 1194 int status; 1195 1196 do { 1197 status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res); 1198 if (status == 0) 1199 break; 1200 /* NOTE: BAD_SEQID means the server and client disagree about the 1201 * book-keeping w.r.t. state-changing operations 1202 * (OPEN/CLOSE/LOCK/LOCKU...) 1203 * It is actually a sign of a bug on the client or on the server. 1204 * 1205 * If we receive a BAD_SEQID error in the particular case of 1206 * doing an OPEN, we assume that nfs_increment_open_seqid() will 1207 * have unhashed the old state_owner for us, and that we can 1208 * therefore safely retry using a new one. We should still warn 1209 * the user though... 1210 */ 1211 if (status == -NFS4ERR_BAD_SEQID) { 1212 printk(KERN_WARNING "NFS: v4 server %s " 1213 " returned a bad sequence-id error!\n", 1214 NFS_SERVER(dir)->nfs_client->cl_hostname); 1215 exception.retry = 1; 1216 continue; 1217 } 1218 /* 1219 * BAD_STATEID on OPEN means that the server cancelled our 1220 * state before it received the OPEN_CONFIRM. 1221 * Recover by retrying the request as per the discussion 1222 * on Page 181 of RFC3530. 1223 */ 1224 if (status == -NFS4ERR_BAD_STATEID) { 1225 exception.retry = 1; 1226 continue; 1227 } 1228 if (status == -EAGAIN) { 1229 /* We must have found a delegation */ 1230 exception.retry = 1; 1231 continue; 1232 } 1233 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir), 1234 status, &exception)); 1235 } while (exception.retry); 1236 return res; 1237 } 1238 1239 static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 1240 struct nfs_fattr *fattr, struct iattr *sattr, 1241 struct nfs4_state *state) 1242 { 1243 struct nfs_server *server = NFS_SERVER(inode); 1244 struct nfs_setattrargs arg = { 1245 .fh = NFS_FH(inode), 1246 .iap = sattr, 1247 .server = server, 1248 .bitmask = server->attr_bitmask, 1249 }; 1250 struct nfs_setattrres res = { 1251 .fattr = fattr, 1252 .server = server, 1253 }; 1254 struct rpc_message msg = { 1255 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 1256 .rpc_argp = &arg, 1257 .rpc_resp = &res, 1258 .rpc_cred = cred, 1259 }; 1260 unsigned long timestamp = jiffies; 1261 int status; 1262 1263 nfs_fattr_init(fattr); 1264 1265 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) { 1266 /* Use that stateid */ 1267 } else if (state != NULL) { 1268 nfs4_copy_stateid(&arg.stateid, state, current->files); 1269 } else 1270 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid)); 1271 1272 status = rpc_call_sync(server->client, &msg, 0); 1273 if (status == 0 && state != NULL) 1274 renew_lease(server, timestamp); 1275 return status; 1276 } 1277 1278 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred, 1279 struct nfs_fattr *fattr, struct iattr *sattr, 1280 struct nfs4_state *state) 1281 { 1282 struct nfs_server *server = NFS_SERVER(inode); 1283 struct nfs4_exception exception = { }; 1284 int err; 1285 do { 1286 err = nfs4_handle_exception(server, 1287 _nfs4_do_setattr(inode, cred, fattr, sattr, state), 1288 &exception); 1289 } while (exception.retry); 1290 return err; 1291 } 1292 1293 struct nfs4_closedata { 1294 struct path path; 1295 struct inode *inode; 1296 struct nfs4_state *state; 1297 struct nfs_closeargs arg; 1298 struct nfs_closeres res; 1299 struct nfs_fattr fattr; 1300 unsigned long timestamp; 1301 }; 1302 1303 static void nfs4_free_closedata(void *data) 1304 { 1305 struct nfs4_closedata *calldata = data; 1306 struct nfs4_state_owner *sp = calldata->state->owner; 1307 1308 nfs4_put_open_state(calldata->state); 1309 nfs_free_seqid(calldata->arg.seqid); 1310 nfs4_put_state_owner(sp); 1311 path_put(&calldata->path); 1312 kfree(calldata); 1313 } 1314 1315 static void nfs4_close_done(struct rpc_task *task, void *data) 1316 { 1317 struct nfs4_closedata *calldata = data; 1318 struct nfs4_state *state = calldata->state; 1319 struct nfs_server *server = NFS_SERVER(calldata->inode); 1320 1321 if (RPC_ASSASSINATED(task)) 1322 return; 1323 /* hmm. we are done with the inode, and in the process of freeing 1324 * the state_owner. we keep this around to process errors 1325 */ 1326 switch (task->tk_status) { 1327 case 0: 1328 nfs_set_open_stateid(state, &calldata->res.stateid, 0); 1329 renew_lease(server, calldata->timestamp); 1330 break; 1331 case -NFS4ERR_STALE_STATEID: 1332 case -NFS4ERR_OLD_STATEID: 1333 case -NFS4ERR_BAD_STATEID: 1334 case -NFS4ERR_EXPIRED: 1335 if (calldata->arg.fmode == 0) 1336 break; 1337 default: 1338 if (nfs4_async_handle_error(task, server, state) == -EAGAIN) { 1339 rpc_restart_call(task); 1340 return; 1341 } 1342 } 1343 nfs_refresh_inode(calldata->inode, calldata->res.fattr); 1344 } 1345 1346 static void nfs4_close_prepare(struct rpc_task *task, void *data) 1347 { 1348 struct nfs4_closedata *calldata = data; 1349 struct nfs4_state *state = calldata->state; 1350 int clear_rd, clear_wr, clear_rdwr; 1351 1352 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 1353 return; 1354 1355 clear_rd = clear_wr = clear_rdwr = 0; 1356 spin_lock(&state->owner->so_lock); 1357 /* Calculate the change in open mode */ 1358 if (state->n_rdwr == 0) { 1359 if (state->n_rdonly == 0) { 1360 clear_rd |= test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags); 1361 clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags); 1362 } 1363 if (state->n_wronly == 0) { 1364 clear_wr |= test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags); 1365 clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags); 1366 } 1367 } 1368 spin_unlock(&state->owner->so_lock); 1369 if (!clear_rd && !clear_wr && !clear_rdwr) { 1370 /* Note: exit _without_ calling nfs4_close_done */ 1371 task->tk_action = NULL; 1372 return; 1373 } 1374 nfs_fattr_init(calldata->res.fattr); 1375 if (test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0) { 1376 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 1377 calldata->arg.fmode = FMODE_READ; 1378 } else if (test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0) { 1379 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 1380 calldata->arg.fmode = FMODE_WRITE; 1381 } 1382 calldata->timestamp = jiffies; 1383 rpc_call_start(task); 1384 } 1385 1386 static const struct rpc_call_ops nfs4_close_ops = { 1387 .rpc_call_prepare = nfs4_close_prepare, 1388 .rpc_call_done = nfs4_close_done, 1389 .rpc_release = nfs4_free_closedata, 1390 }; 1391 1392 /* 1393 * It is possible for data to be read/written from a mem-mapped file 1394 * after the sys_close call (which hits the vfs layer as a flush). 1395 * This means that we can't safely call nfsv4 close on a file until 1396 * the inode is cleared. This in turn means that we are not good 1397 * NFSv4 citizens - we do not indicate to the server to update the file's 1398 * share state even when we are done with one of the three share 1399 * stateid's in the inode. 1400 * 1401 * NOTE: Caller must be holding the sp->so_owner semaphore! 1402 */ 1403 int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait) 1404 { 1405 struct nfs_server *server = NFS_SERVER(state->inode); 1406 struct nfs4_closedata *calldata; 1407 struct nfs4_state_owner *sp = state->owner; 1408 struct rpc_task *task; 1409 struct rpc_message msg = { 1410 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE], 1411 .rpc_cred = state->owner->so_cred, 1412 }; 1413 struct rpc_task_setup task_setup_data = { 1414 .rpc_client = server->client, 1415 .rpc_message = &msg, 1416 .callback_ops = &nfs4_close_ops, 1417 .workqueue = nfsiod_workqueue, 1418 .flags = RPC_TASK_ASYNC, 1419 }; 1420 int status = -ENOMEM; 1421 1422 calldata = kmalloc(sizeof(*calldata), GFP_KERNEL); 1423 if (calldata == NULL) 1424 goto out; 1425 calldata->inode = state->inode; 1426 calldata->state = state; 1427 calldata->arg.fh = NFS_FH(state->inode); 1428 calldata->arg.stateid = &state->open_stateid; 1429 /* Serialization for the sequence id */ 1430 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); 1431 if (calldata->arg.seqid == NULL) 1432 goto out_free_calldata; 1433 calldata->arg.fmode = 0; 1434 calldata->arg.bitmask = server->cache_consistency_bitmask; 1435 calldata->res.fattr = &calldata->fattr; 1436 calldata->res.seqid = calldata->arg.seqid; 1437 calldata->res.server = server; 1438 calldata->path.mnt = mntget(path->mnt); 1439 calldata->path.dentry = dget(path->dentry); 1440 1441 msg.rpc_argp = &calldata->arg, 1442 msg.rpc_resp = &calldata->res, 1443 task_setup_data.callback_data = calldata; 1444 task = rpc_run_task(&task_setup_data); 1445 if (IS_ERR(task)) 1446 return PTR_ERR(task); 1447 status = 0; 1448 if (wait) 1449 status = rpc_wait_for_completion_task(task); 1450 rpc_put_task(task); 1451 return status; 1452 out_free_calldata: 1453 kfree(calldata); 1454 out: 1455 nfs4_put_open_state(state); 1456 nfs4_put_state_owner(sp); 1457 return status; 1458 } 1459 1460 static int nfs4_intent_set_file(struct nameidata *nd, struct path *path, struct nfs4_state *state, fmode_t fmode) 1461 { 1462 struct file *filp; 1463 int ret; 1464 1465 /* If the open_intent is for execute, we have an extra check to make */ 1466 if (fmode & FMODE_EXEC) { 1467 ret = nfs_may_open(state->inode, 1468 state->owner->so_cred, 1469 nd->intent.open.flags); 1470 if (ret < 0) 1471 goto out_close; 1472 } 1473 filp = lookup_instantiate_filp(nd, path->dentry, NULL); 1474 if (!IS_ERR(filp)) { 1475 struct nfs_open_context *ctx; 1476 ctx = nfs_file_open_context(filp); 1477 ctx->state = state; 1478 return 0; 1479 } 1480 ret = PTR_ERR(filp); 1481 out_close: 1482 nfs4_close_sync(path, state, fmode & (FMODE_READ|FMODE_WRITE)); 1483 return ret; 1484 } 1485 1486 struct dentry * 1487 nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 1488 { 1489 struct path path = { 1490 .mnt = nd->path.mnt, 1491 .dentry = dentry, 1492 }; 1493 struct dentry *parent; 1494 struct iattr attr; 1495 struct rpc_cred *cred; 1496 struct nfs4_state *state; 1497 struct dentry *res; 1498 fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 1499 1500 if (nd->flags & LOOKUP_CREATE) { 1501 attr.ia_mode = nd->intent.open.create_mode; 1502 attr.ia_valid = ATTR_MODE; 1503 if (!IS_POSIXACL(dir)) 1504 attr.ia_mode &= ~current_umask(); 1505 } else { 1506 attr.ia_valid = 0; 1507 BUG_ON(nd->intent.open.flags & O_CREAT); 1508 } 1509 1510 cred = rpc_lookup_cred(); 1511 if (IS_ERR(cred)) 1512 return (struct dentry *)cred; 1513 parent = dentry->d_parent; 1514 /* Protect against concurrent sillydeletes */ 1515 nfs_block_sillyrename(parent); 1516 state = nfs4_do_open(dir, &path, fmode, nd->intent.open.flags, &attr, cred); 1517 put_rpccred(cred); 1518 if (IS_ERR(state)) { 1519 if (PTR_ERR(state) == -ENOENT) { 1520 d_add(dentry, NULL); 1521 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1522 } 1523 nfs_unblock_sillyrename(parent); 1524 return (struct dentry *)state; 1525 } 1526 res = d_add_unique(dentry, igrab(state->inode)); 1527 if (res != NULL) 1528 path.dentry = res; 1529 nfs_set_verifier(path.dentry, nfs_save_change_attribute(dir)); 1530 nfs_unblock_sillyrename(parent); 1531 nfs4_intent_set_file(nd, &path, state, fmode); 1532 return res; 1533 } 1534 1535 int 1536 nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd) 1537 { 1538 struct path path = { 1539 .mnt = nd->path.mnt, 1540 .dentry = dentry, 1541 }; 1542 struct rpc_cred *cred; 1543 struct nfs4_state *state; 1544 fmode_t fmode = openflags & (FMODE_READ | FMODE_WRITE); 1545 1546 cred = rpc_lookup_cred(); 1547 if (IS_ERR(cred)) 1548 return PTR_ERR(cred); 1549 state = nfs4_do_open(dir, &path, fmode, openflags, NULL, cred); 1550 put_rpccred(cred); 1551 if (IS_ERR(state)) { 1552 switch (PTR_ERR(state)) { 1553 case -EPERM: 1554 case -EACCES: 1555 case -EDQUOT: 1556 case -ENOSPC: 1557 case -EROFS: 1558 lookup_instantiate_filp(nd, (struct dentry *)state, NULL); 1559 return 1; 1560 default: 1561 goto out_drop; 1562 } 1563 } 1564 if (state->inode == dentry->d_inode) { 1565 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1566 nfs4_intent_set_file(nd, &path, state, fmode); 1567 return 1; 1568 } 1569 nfs4_close_sync(&path, state, fmode); 1570 out_drop: 1571 d_drop(dentry); 1572 return 0; 1573 } 1574 1575 void nfs4_close_context(struct nfs_open_context *ctx, int is_sync) 1576 { 1577 if (ctx->state == NULL) 1578 return; 1579 if (is_sync) 1580 nfs4_close_sync(&ctx->path, ctx->state, ctx->mode); 1581 else 1582 nfs4_close_state(&ctx->path, ctx->state, ctx->mode); 1583 } 1584 1585 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 1586 { 1587 struct nfs4_server_caps_res res = {}; 1588 struct rpc_message msg = { 1589 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS], 1590 .rpc_argp = fhandle, 1591 .rpc_resp = &res, 1592 }; 1593 int status; 1594 1595 status = rpc_call_sync(server->client, &msg, 0); 1596 if (status == 0) { 1597 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); 1598 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL) 1599 server->caps |= NFS_CAP_ACLS; 1600 if (res.has_links != 0) 1601 server->caps |= NFS_CAP_HARDLINKS; 1602 if (res.has_symlinks != 0) 1603 server->caps |= NFS_CAP_SYMLINKS; 1604 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask)); 1605 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; 1606 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; 1607 server->acl_bitmask = res.acl_bitmask; 1608 } 1609 return status; 1610 } 1611 1612 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 1613 { 1614 struct nfs4_exception exception = { }; 1615 int err; 1616 do { 1617 err = nfs4_handle_exception(server, 1618 _nfs4_server_capabilities(server, fhandle), 1619 &exception); 1620 } while (exception.retry); 1621 return err; 1622 } 1623 1624 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 1625 struct nfs_fsinfo *info) 1626 { 1627 struct nfs4_lookup_root_arg args = { 1628 .bitmask = nfs4_fattr_bitmap, 1629 }; 1630 struct nfs4_lookup_res res = { 1631 .server = server, 1632 .fattr = info->fattr, 1633 .fh = fhandle, 1634 }; 1635 struct rpc_message msg = { 1636 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT], 1637 .rpc_argp = &args, 1638 .rpc_resp = &res, 1639 }; 1640 nfs_fattr_init(info->fattr); 1641 return rpc_call_sync(server->client, &msg, 0); 1642 } 1643 1644 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 1645 struct nfs_fsinfo *info) 1646 { 1647 struct nfs4_exception exception = { }; 1648 int err; 1649 do { 1650 err = nfs4_handle_exception(server, 1651 _nfs4_lookup_root(server, fhandle, info), 1652 &exception); 1653 } while (exception.retry); 1654 return err; 1655 } 1656 1657 /* 1658 * get the file handle for the "/" directory on the server 1659 */ 1660 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 1661 struct nfs_fsinfo *info) 1662 { 1663 int status; 1664 1665 status = nfs4_lookup_root(server, fhandle, info); 1666 if (status == 0) 1667 status = nfs4_server_capabilities(server, fhandle); 1668 if (status == 0) 1669 status = nfs4_do_fsinfo(server, fhandle, info); 1670 return nfs4_map_errors(status); 1671 } 1672 1673 /* 1674 * Get locations and (maybe) other attributes of a referral. 1675 * Note that we'll actually follow the referral later when 1676 * we detect fsid mismatch in inode revalidation 1677 */ 1678 static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle) 1679 { 1680 int status = -ENOMEM; 1681 struct page *page = NULL; 1682 struct nfs4_fs_locations *locations = NULL; 1683 1684 page = alloc_page(GFP_KERNEL); 1685 if (page == NULL) 1686 goto out; 1687 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 1688 if (locations == NULL) 1689 goto out; 1690 1691 status = nfs4_proc_fs_locations(dir, name, locations, page); 1692 if (status != 0) 1693 goto out; 1694 /* Make sure server returned a different fsid for the referral */ 1695 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 1696 dprintk("%s: server did not return a different fsid for a referral at %s\n", __func__, name->name); 1697 status = -EIO; 1698 goto out; 1699 } 1700 1701 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr)); 1702 fattr->valid |= NFS_ATTR_FATTR_V4_REFERRAL; 1703 if (!fattr->mode) 1704 fattr->mode = S_IFDIR; 1705 memset(fhandle, 0, sizeof(struct nfs_fh)); 1706 out: 1707 if (page) 1708 __free_page(page); 1709 if (locations) 1710 kfree(locations); 1711 return status; 1712 } 1713 1714 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1715 { 1716 struct nfs4_getattr_arg args = { 1717 .fh = fhandle, 1718 .bitmask = server->attr_bitmask, 1719 }; 1720 struct nfs4_getattr_res res = { 1721 .fattr = fattr, 1722 .server = server, 1723 }; 1724 struct rpc_message msg = { 1725 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 1726 .rpc_argp = &args, 1727 .rpc_resp = &res, 1728 }; 1729 1730 nfs_fattr_init(fattr); 1731 return rpc_call_sync(server->client, &msg, 0); 1732 } 1733 1734 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1735 { 1736 struct nfs4_exception exception = { }; 1737 int err; 1738 do { 1739 err = nfs4_handle_exception(server, 1740 _nfs4_proc_getattr(server, fhandle, fattr), 1741 &exception); 1742 } while (exception.retry); 1743 return err; 1744 } 1745 1746 /* 1747 * The file is not closed if it is opened due to the a request to change 1748 * the size of the file. The open call will not be needed once the 1749 * VFS layer lookup-intents are implemented. 1750 * 1751 * Close is called when the inode is destroyed. 1752 * If we haven't opened the file for O_WRONLY, we 1753 * need to in the size_change case to obtain a stateid. 1754 * 1755 * Got race? 1756 * Because OPEN is always done by name in nfsv4, it is 1757 * possible that we opened a different file by the same 1758 * name. We can recognize this race condition, but we 1759 * can't do anything about it besides returning an error. 1760 * 1761 * This will be fixed with VFS changes (lookup-intent). 1762 */ 1763 static int 1764 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 1765 struct iattr *sattr) 1766 { 1767 struct inode *inode = dentry->d_inode; 1768 struct rpc_cred *cred = NULL; 1769 struct nfs4_state *state = NULL; 1770 int status; 1771 1772 nfs_fattr_init(fattr); 1773 1774 /* Search for an existing open(O_WRITE) file */ 1775 if (sattr->ia_valid & ATTR_FILE) { 1776 struct nfs_open_context *ctx; 1777 1778 ctx = nfs_file_open_context(sattr->ia_file); 1779 if (ctx) { 1780 cred = ctx->cred; 1781 state = ctx->state; 1782 } 1783 } 1784 1785 status = nfs4_do_setattr(inode, cred, fattr, sattr, state); 1786 if (status == 0) 1787 nfs_setattr_update_inode(inode, sattr); 1788 return status; 1789 } 1790 1791 static int _nfs4_proc_lookupfh(struct nfs_server *server, const struct nfs_fh *dirfh, 1792 const struct qstr *name, struct nfs_fh *fhandle, 1793 struct nfs_fattr *fattr) 1794 { 1795 int status; 1796 struct nfs4_lookup_arg args = { 1797 .bitmask = server->attr_bitmask, 1798 .dir_fh = dirfh, 1799 .name = name, 1800 }; 1801 struct nfs4_lookup_res res = { 1802 .server = server, 1803 .fattr = fattr, 1804 .fh = fhandle, 1805 }; 1806 struct rpc_message msg = { 1807 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 1808 .rpc_argp = &args, 1809 .rpc_resp = &res, 1810 }; 1811 1812 nfs_fattr_init(fattr); 1813 1814 dprintk("NFS call lookupfh %s\n", name->name); 1815 status = rpc_call_sync(server->client, &msg, 0); 1816 dprintk("NFS reply lookupfh: %d\n", status); 1817 return status; 1818 } 1819 1820 static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh, 1821 struct qstr *name, struct nfs_fh *fhandle, 1822 struct nfs_fattr *fattr) 1823 { 1824 struct nfs4_exception exception = { }; 1825 int err; 1826 do { 1827 err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr); 1828 /* FIXME: !!!! */ 1829 if (err == -NFS4ERR_MOVED) { 1830 err = -EREMOTE; 1831 break; 1832 } 1833 err = nfs4_handle_exception(server, err, &exception); 1834 } while (exception.retry); 1835 return err; 1836 } 1837 1838 static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name, 1839 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1840 { 1841 int status; 1842 1843 dprintk("NFS call lookup %s\n", name->name); 1844 status = _nfs4_proc_lookupfh(NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr); 1845 if (status == -NFS4ERR_MOVED) 1846 status = nfs4_get_referral(dir, name, fattr, fhandle); 1847 dprintk("NFS reply lookup: %d\n", status); 1848 return status; 1849 } 1850 1851 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1852 { 1853 struct nfs4_exception exception = { }; 1854 int err; 1855 do { 1856 err = nfs4_handle_exception(NFS_SERVER(dir), 1857 _nfs4_proc_lookup(dir, name, fhandle, fattr), 1858 &exception); 1859 } while (exception.retry); 1860 return err; 1861 } 1862 1863 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 1864 { 1865 struct nfs_server *server = NFS_SERVER(inode); 1866 struct nfs_fattr fattr; 1867 struct nfs4_accessargs args = { 1868 .fh = NFS_FH(inode), 1869 .bitmask = server->attr_bitmask, 1870 }; 1871 struct nfs4_accessres res = { 1872 .server = server, 1873 .fattr = &fattr, 1874 }; 1875 struct rpc_message msg = { 1876 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], 1877 .rpc_argp = &args, 1878 .rpc_resp = &res, 1879 .rpc_cred = entry->cred, 1880 }; 1881 int mode = entry->mask; 1882 int status; 1883 1884 /* 1885 * Determine which access bits we want to ask for... 1886 */ 1887 if (mode & MAY_READ) 1888 args.access |= NFS4_ACCESS_READ; 1889 if (S_ISDIR(inode->i_mode)) { 1890 if (mode & MAY_WRITE) 1891 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE; 1892 if (mode & MAY_EXEC) 1893 args.access |= NFS4_ACCESS_LOOKUP; 1894 } else { 1895 if (mode & MAY_WRITE) 1896 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND; 1897 if (mode & MAY_EXEC) 1898 args.access |= NFS4_ACCESS_EXECUTE; 1899 } 1900 nfs_fattr_init(&fattr); 1901 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 1902 if (!status) { 1903 entry->mask = 0; 1904 if (res.access & NFS4_ACCESS_READ) 1905 entry->mask |= MAY_READ; 1906 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE)) 1907 entry->mask |= MAY_WRITE; 1908 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE)) 1909 entry->mask |= MAY_EXEC; 1910 nfs_refresh_inode(inode, &fattr); 1911 } 1912 return status; 1913 } 1914 1915 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 1916 { 1917 struct nfs4_exception exception = { }; 1918 int err; 1919 do { 1920 err = nfs4_handle_exception(NFS_SERVER(inode), 1921 _nfs4_proc_access(inode, entry), 1922 &exception); 1923 } while (exception.retry); 1924 return err; 1925 } 1926 1927 /* 1928 * TODO: For the time being, we don't try to get any attributes 1929 * along with any of the zero-copy operations READ, READDIR, 1930 * READLINK, WRITE. 1931 * 1932 * In the case of the first three, we want to put the GETATTR 1933 * after the read-type operation -- this is because it is hard 1934 * to predict the length of a GETATTR response in v4, and thus 1935 * align the READ data correctly. This means that the GETATTR 1936 * may end up partially falling into the page cache, and we should 1937 * shift it into the 'tail' of the xdr_buf before processing. 1938 * To do this efficiently, we need to know the total length 1939 * of data received, which doesn't seem to be available outside 1940 * of the RPC layer. 1941 * 1942 * In the case of WRITE, we also want to put the GETATTR after 1943 * the operation -- in this case because we want to make sure 1944 * we get the post-operation mtime and size. This means that 1945 * we can't use xdr_encode_pages() as written: we need a variant 1946 * of it which would leave room in the 'tail' iovec. 1947 * 1948 * Both of these changes to the XDR layer would in fact be quite 1949 * minor, but I decided to leave them for a subsequent patch. 1950 */ 1951 static int _nfs4_proc_readlink(struct inode *inode, struct page *page, 1952 unsigned int pgbase, unsigned int pglen) 1953 { 1954 struct nfs4_readlink args = { 1955 .fh = NFS_FH(inode), 1956 .pgbase = pgbase, 1957 .pglen = pglen, 1958 .pages = &page, 1959 }; 1960 struct rpc_message msg = { 1961 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK], 1962 .rpc_argp = &args, 1963 .rpc_resp = NULL, 1964 }; 1965 1966 return rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 1967 } 1968 1969 static int nfs4_proc_readlink(struct inode *inode, struct page *page, 1970 unsigned int pgbase, unsigned int pglen) 1971 { 1972 struct nfs4_exception exception = { }; 1973 int err; 1974 do { 1975 err = nfs4_handle_exception(NFS_SERVER(inode), 1976 _nfs4_proc_readlink(inode, page, pgbase, pglen), 1977 &exception); 1978 } while (exception.retry); 1979 return err; 1980 } 1981 1982 /* 1983 * Got race? 1984 * We will need to arrange for the VFS layer to provide an atomic open. 1985 * Until then, this create/open method is prone to inefficiency and race 1986 * conditions due to the lookup, create, and open VFS calls from sys_open() 1987 * placed on the wire. 1988 * 1989 * Given the above sorry state of affairs, I'm simply sending an OPEN. 1990 * The file will be opened again in the subsequent VFS open call 1991 * (nfs4_proc_file_open). 1992 * 1993 * The open for read will just hang around to be used by any process that 1994 * opens the file O_RDONLY. This will all be resolved with the VFS changes. 1995 */ 1996 1997 static int 1998 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 1999 int flags, struct nameidata *nd) 2000 { 2001 struct path path = { 2002 .mnt = nd->path.mnt, 2003 .dentry = dentry, 2004 }; 2005 struct nfs4_state *state; 2006 struct rpc_cred *cred; 2007 fmode_t fmode = flags & (FMODE_READ | FMODE_WRITE); 2008 int status = 0; 2009 2010 cred = rpc_lookup_cred(); 2011 if (IS_ERR(cred)) { 2012 status = PTR_ERR(cred); 2013 goto out; 2014 } 2015 state = nfs4_do_open(dir, &path, fmode, flags, sattr, cred); 2016 d_drop(dentry); 2017 if (IS_ERR(state)) { 2018 status = PTR_ERR(state); 2019 goto out_putcred; 2020 } 2021 d_add(dentry, igrab(state->inode)); 2022 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2023 if (flags & O_EXCL) { 2024 struct nfs_fattr fattr; 2025 status = nfs4_do_setattr(state->inode, cred, &fattr, sattr, state); 2026 if (status == 0) 2027 nfs_setattr_update_inode(state->inode, sattr); 2028 nfs_post_op_update_inode(state->inode, &fattr); 2029 } 2030 if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0) 2031 status = nfs4_intent_set_file(nd, &path, state, fmode); 2032 else 2033 nfs4_close_sync(&path, state, fmode); 2034 out_putcred: 2035 put_rpccred(cred); 2036 out: 2037 return status; 2038 } 2039 2040 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name) 2041 { 2042 struct nfs_server *server = NFS_SERVER(dir); 2043 struct nfs_removeargs args = { 2044 .fh = NFS_FH(dir), 2045 .name.len = name->len, 2046 .name.name = name->name, 2047 .bitmask = server->attr_bitmask, 2048 }; 2049 struct nfs_removeres res = { 2050 .server = server, 2051 }; 2052 struct rpc_message msg = { 2053 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE], 2054 .rpc_argp = &args, 2055 .rpc_resp = &res, 2056 }; 2057 int status; 2058 2059 nfs_fattr_init(&res.dir_attr); 2060 status = rpc_call_sync(server->client, &msg, 0); 2061 if (status == 0) { 2062 update_changeattr(dir, &res.cinfo); 2063 nfs_post_op_update_inode(dir, &res.dir_attr); 2064 } 2065 return status; 2066 } 2067 2068 static int nfs4_proc_remove(struct inode *dir, struct qstr *name) 2069 { 2070 struct nfs4_exception exception = { }; 2071 int err; 2072 do { 2073 err = nfs4_handle_exception(NFS_SERVER(dir), 2074 _nfs4_proc_remove(dir, name), 2075 &exception); 2076 } while (exception.retry); 2077 return err; 2078 } 2079 2080 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 2081 { 2082 struct nfs_server *server = NFS_SERVER(dir); 2083 struct nfs_removeargs *args = msg->rpc_argp; 2084 struct nfs_removeres *res = msg->rpc_resp; 2085 2086 args->bitmask = server->cache_consistency_bitmask; 2087 res->server = server; 2088 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; 2089 } 2090 2091 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir) 2092 { 2093 struct nfs_removeres *res = task->tk_msg.rpc_resp; 2094 2095 if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN) 2096 return 0; 2097 update_changeattr(dir, &res->cinfo); 2098 nfs_post_op_update_inode(dir, &res->dir_attr); 2099 return 1; 2100 } 2101 2102 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 2103 struct inode *new_dir, struct qstr *new_name) 2104 { 2105 struct nfs_server *server = NFS_SERVER(old_dir); 2106 struct nfs4_rename_arg arg = { 2107 .old_dir = NFS_FH(old_dir), 2108 .new_dir = NFS_FH(new_dir), 2109 .old_name = old_name, 2110 .new_name = new_name, 2111 .bitmask = server->attr_bitmask, 2112 }; 2113 struct nfs_fattr old_fattr, new_fattr; 2114 struct nfs4_rename_res res = { 2115 .server = server, 2116 .old_fattr = &old_fattr, 2117 .new_fattr = &new_fattr, 2118 }; 2119 struct rpc_message msg = { 2120 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME], 2121 .rpc_argp = &arg, 2122 .rpc_resp = &res, 2123 }; 2124 int status; 2125 2126 nfs_fattr_init(res.old_fattr); 2127 nfs_fattr_init(res.new_fattr); 2128 status = rpc_call_sync(server->client, &msg, 0); 2129 2130 if (!status) { 2131 update_changeattr(old_dir, &res.old_cinfo); 2132 nfs_post_op_update_inode(old_dir, res.old_fattr); 2133 update_changeattr(new_dir, &res.new_cinfo); 2134 nfs_post_op_update_inode(new_dir, res.new_fattr); 2135 } 2136 return status; 2137 } 2138 2139 static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 2140 struct inode *new_dir, struct qstr *new_name) 2141 { 2142 struct nfs4_exception exception = { }; 2143 int err; 2144 do { 2145 err = nfs4_handle_exception(NFS_SERVER(old_dir), 2146 _nfs4_proc_rename(old_dir, old_name, 2147 new_dir, new_name), 2148 &exception); 2149 } while (exception.retry); 2150 return err; 2151 } 2152 2153 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 2154 { 2155 struct nfs_server *server = NFS_SERVER(inode); 2156 struct nfs4_link_arg arg = { 2157 .fh = NFS_FH(inode), 2158 .dir_fh = NFS_FH(dir), 2159 .name = name, 2160 .bitmask = server->attr_bitmask, 2161 }; 2162 struct nfs_fattr fattr, dir_attr; 2163 struct nfs4_link_res res = { 2164 .server = server, 2165 .fattr = &fattr, 2166 .dir_attr = &dir_attr, 2167 }; 2168 struct rpc_message msg = { 2169 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK], 2170 .rpc_argp = &arg, 2171 .rpc_resp = &res, 2172 }; 2173 int status; 2174 2175 nfs_fattr_init(res.fattr); 2176 nfs_fattr_init(res.dir_attr); 2177 status = rpc_call_sync(server->client, &msg, 0); 2178 if (!status) { 2179 update_changeattr(dir, &res.cinfo); 2180 nfs_post_op_update_inode(dir, res.dir_attr); 2181 nfs_post_op_update_inode(inode, res.fattr); 2182 } 2183 2184 return status; 2185 } 2186 2187 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 2188 { 2189 struct nfs4_exception exception = { }; 2190 int err; 2191 do { 2192 err = nfs4_handle_exception(NFS_SERVER(inode), 2193 _nfs4_proc_link(inode, dir, name), 2194 &exception); 2195 } while (exception.retry); 2196 return err; 2197 } 2198 2199 struct nfs4_createdata { 2200 struct rpc_message msg; 2201 struct nfs4_create_arg arg; 2202 struct nfs4_create_res res; 2203 struct nfs_fh fh; 2204 struct nfs_fattr fattr; 2205 struct nfs_fattr dir_fattr; 2206 }; 2207 2208 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir, 2209 struct qstr *name, struct iattr *sattr, u32 ftype) 2210 { 2211 struct nfs4_createdata *data; 2212 2213 data = kzalloc(sizeof(*data), GFP_KERNEL); 2214 if (data != NULL) { 2215 struct nfs_server *server = NFS_SERVER(dir); 2216 2217 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; 2218 data->msg.rpc_argp = &data->arg; 2219 data->msg.rpc_resp = &data->res; 2220 data->arg.dir_fh = NFS_FH(dir); 2221 data->arg.server = server; 2222 data->arg.name = name; 2223 data->arg.attrs = sattr; 2224 data->arg.ftype = ftype; 2225 data->arg.bitmask = server->attr_bitmask; 2226 data->res.server = server; 2227 data->res.fh = &data->fh; 2228 data->res.fattr = &data->fattr; 2229 data->res.dir_fattr = &data->dir_fattr; 2230 nfs_fattr_init(data->res.fattr); 2231 nfs_fattr_init(data->res.dir_fattr); 2232 } 2233 return data; 2234 } 2235 2236 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data) 2237 { 2238 int status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0); 2239 if (status == 0) { 2240 update_changeattr(dir, &data->res.dir_cinfo); 2241 nfs_post_op_update_inode(dir, data->res.dir_fattr); 2242 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); 2243 } 2244 return status; 2245 } 2246 2247 static void nfs4_free_createdata(struct nfs4_createdata *data) 2248 { 2249 kfree(data); 2250 } 2251 2252 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2253 struct page *page, unsigned int len, struct iattr *sattr) 2254 { 2255 struct nfs4_createdata *data; 2256 int status = -ENAMETOOLONG; 2257 2258 if (len > NFS4_MAXPATHLEN) 2259 goto out; 2260 2261 status = -ENOMEM; 2262 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); 2263 if (data == NULL) 2264 goto out; 2265 2266 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; 2267 data->arg.u.symlink.pages = &page; 2268 data->arg.u.symlink.len = len; 2269 2270 status = nfs4_do_create(dir, dentry, data); 2271 2272 nfs4_free_createdata(data); 2273 out: 2274 return status; 2275 } 2276 2277 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2278 struct page *page, unsigned int len, struct iattr *sattr) 2279 { 2280 struct nfs4_exception exception = { }; 2281 int err; 2282 do { 2283 err = nfs4_handle_exception(NFS_SERVER(dir), 2284 _nfs4_proc_symlink(dir, dentry, page, 2285 len, sattr), 2286 &exception); 2287 } while (exception.retry); 2288 return err; 2289 } 2290 2291 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2292 struct iattr *sattr) 2293 { 2294 struct nfs4_createdata *data; 2295 int status = -ENOMEM; 2296 2297 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); 2298 if (data == NULL) 2299 goto out; 2300 2301 status = nfs4_do_create(dir, dentry, data); 2302 2303 nfs4_free_createdata(data); 2304 out: 2305 return status; 2306 } 2307 2308 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2309 struct iattr *sattr) 2310 { 2311 struct nfs4_exception exception = { }; 2312 int err; 2313 do { 2314 err = nfs4_handle_exception(NFS_SERVER(dir), 2315 _nfs4_proc_mkdir(dir, dentry, sattr), 2316 &exception); 2317 } while (exception.retry); 2318 return err; 2319 } 2320 2321 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2322 u64 cookie, struct page *page, unsigned int count, int plus) 2323 { 2324 struct inode *dir = dentry->d_inode; 2325 struct nfs4_readdir_arg args = { 2326 .fh = NFS_FH(dir), 2327 .pages = &page, 2328 .pgbase = 0, 2329 .count = count, 2330 .bitmask = NFS_SERVER(dentry->d_inode)->cache_consistency_bitmask, 2331 }; 2332 struct nfs4_readdir_res res; 2333 struct rpc_message msg = { 2334 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], 2335 .rpc_argp = &args, 2336 .rpc_resp = &res, 2337 .rpc_cred = cred, 2338 }; 2339 int status; 2340 2341 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__, 2342 dentry->d_parent->d_name.name, 2343 dentry->d_name.name, 2344 (unsigned long long)cookie); 2345 nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args); 2346 res.pgbase = args.pgbase; 2347 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2348 if (status == 0) 2349 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE); 2350 2351 nfs_invalidate_atime(dir); 2352 2353 dprintk("%s: returns %d\n", __func__, status); 2354 return status; 2355 } 2356 2357 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2358 u64 cookie, struct page *page, unsigned int count, int plus) 2359 { 2360 struct nfs4_exception exception = { }; 2361 int err; 2362 do { 2363 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), 2364 _nfs4_proc_readdir(dentry, cred, cookie, 2365 page, count, plus), 2366 &exception); 2367 } while (exception.retry); 2368 return err; 2369 } 2370 2371 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2372 struct iattr *sattr, dev_t rdev) 2373 { 2374 struct nfs4_createdata *data; 2375 int mode = sattr->ia_mode; 2376 int status = -ENOMEM; 2377 2378 BUG_ON(!(sattr->ia_valid & ATTR_MODE)); 2379 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode)); 2380 2381 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); 2382 if (data == NULL) 2383 goto out; 2384 2385 if (S_ISFIFO(mode)) 2386 data->arg.ftype = NF4FIFO; 2387 else if (S_ISBLK(mode)) { 2388 data->arg.ftype = NF4BLK; 2389 data->arg.u.device.specdata1 = MAJOR(rdev); 2390 data->arg.u.device.specdata2 = MINOR(rdev); 2391 } 2392 else if (S_ISCHR(mode)) { 2393 data->arg.ftype = NF4CHR; 2394 data->arg.u.device.specdata1 = MAJOR(rdev); 2395 data->arg.u.device.specdata2 = MINOR(rdev); 2396 } 2397 2398 status = nfs4_do_create(dir, dentry, data); 2399 2400 nfs4_free_createdata(data); 2401 out: 2402 return status; 2403 } 2404 2405 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2406 struct iattr *sattr, dev_t rdev) 2407 { 2408 struct nfs4_exception exception = { }; 2409 int err; 2410 do { 2411 err = nfs4_handle_exception(NFS_SERVER(dir), 2412 _nfs4_proc_mknod(dir, dentry, sattr, rdev), 2413 &exception); 2414 } while (exception.retry); 2415 return err; 2416 } 2417 2418 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 2419 struct nfs_fsstat *fsstat) 2420 { 2421 struct nfs4_statfs_arg args = { 2422 .fh = fhandle, 2423 .bitmask = server->attr_bitmask, 2424 }; 2425 struct rpc_message msg = { 2426 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS], 2427 .rpc_argp = &args, 2428 .rpc_resp = fsstat, 2429 }; 2430 2431 nfs_fattr_init(fsstat->fattr); 2432 return rpc_call_sync(server->client, &msg, 0); 2433 } 2434 2435 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat) 2436 { 2437 struct nfs4_exception exception = { }; 2438 int err; 2439 do { 2440 err = nfs4_handle_exception(server, 2441 _nfs4_proc_statfs(server, fhandle, fsstat), 2442 &exception); 2443 } while (exception.retry); 2444 return err; 2445 } 2446 2447 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 2448 struct nfs_fsinfo *fsinfo) 2449 { 2450 struct nfs4_fsinfo_arg args = { 2451 .fh = fhandle, 2452 .bitmask = server->attr_bitmask, 2453 }; 2454 struct rpc_message msg = { 2455 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO], 2456 .rpc_argp = &args, 2457 .rpc_resp = fsinfo, 2458 }; 2459 2460 return rpc_call_sync(server->client, &msg, 0); 2461 } 2462 2463 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 2464 { 2465 struct nfs4_exception exception = { }; 2466 int err; 2467 2468 do { 2469 err = nfs4_handle_exception(server, 2470 _nfs4_do_fsinfo(server, fhandle, fsinfo), 2471 &exception); 2472 } while (exception.retry); 2473 return err; 2474 } 2475 2476 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 2477 { 2478 nfs_fattr_init(fsinfo->fattr); 2479 return nfs4_do_fsinfo(server, fhandle, fsinfo); 2480 } 2481 2482 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 2483 struct nfs_pathconf *pathconf) 2484 { 2485 struct nfs4_pathconf_arg args = { 2486 .fh = fhandle, 2487 .bitmask = server->attr_bitmask, 2488 }; 2489 struct rpc_message msg = { 2490 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF], 2491 .rpc_argp = &args, 2492 .rpc_resp = pathconf, 2493 }; 2494 2495 /* None of the pathconf attributes are mandatory to implement */ 2496 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) { 2497 memset(pathconf, 0, sizeof(*pathconf)); 2498 return 0; 2499 } 2500 2501 nfs_fattr_init(pathconf->fattr); 2502 return rpc_call_sync(server->client, &msg, 0); 2503 } 2504 2505 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 2506 struct nfs_pathconf *pathconf) 2507 { 2508 struct nfs4_exception exception = { }; 2509 int err; 2510 2511 do { 2512 err = nfs4_handle_exception(server, 2513 _nfs4_proc_pathconf(server, fhandle, pathconf), 2514 &exception); 2515 } while (exception.retry); 2516 return err; 2517 } 2518 2519 static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data) 2520 { 2521 struct nfs_server *server = NFS_SERVER(data->inode); 2522 2523 if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) { 2524 rpc_restart_call(task); 2525 return -EAGAIN; 2526 } 2527 2528 nfs_invalidate_atime(data->inode); 2529 if (task->tk_status > 0) 2530 renew_lease(server, data->timestamp); 2531 return 0; 2532 } 2533 2534 static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 2535 { 2536 data->timestamp = jiffies; 2537 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; 2538 } 2539 2540 static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data) 2541 { 2542 struct inode *inode = data->inode; 2543 2544 if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) { 2545 rpc_restart_call(task); 2546 return -EAGAIN; 2547 } 2548 if (task->tk_status >= 0) { 2549 renew_lease(NFS_SERVER(inode), data->timestamp); 2550 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr); 2551 } 2552 return 0; 2553 } 2554 2555 static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 2556 { 2557 struct nfs_server *server = NFS_SERVER(data->inode); 2558 2559 data->args.bitmask = server->cache_consistency_bitmask; 2560 data->res.server = server; 2561 data->timestamp = jiffies; 2562 2563 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; 2564 } 2565 2566 static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data) 2567 { 2568 struct inode *inode = data->inode; 2569 2570 if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) { 2571 rpc_restart_call(task); 2572 return -EAGAIN; 2573 } 2574 nfs_refresh_inode(inode, data->res.fattr); 2575 return 0; 2576 } 2577 2578 static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) 2579 { 2580 struct nfs_server *server = NFS_SERVER(data->inode); 2581 2582 data->args.bitmask = server->cache_consistency_bitmask; 2583 data->res.server = server; 2584 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; 2585 } 2586 2587 /* 2588 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special 2589 * standalone procedure for queueing an asynchronous RENEW. 2590 */ 2591 static void nfs4_renew_done(struct rpc_task *task, void *data) 2592 { 2593 struct nfs_client *clp = (struct nfs_client *)task->tk_msg.rpc_argp; 2594 unsigned long timestamp = (unsigned long)data; 2595 2596 if (task->tk_status < 0) { 2597 switch (task->tk_status) { 2598 case -NFS4ERR_STALE_CLIENTID: 2599 case -NFS4ERR_EXPIRED: 2600 case -NFS4ERR_CB_PATH_DOWN: 2601 nfs4_schedule_state_recovery(clp); 2602 } 2603 return; 2604 } 2605 spin_lock(&clp->cl_lock); 2606 if (time_before(clp->cl_last_renewal,timestamp)) 2607 clp->cl_last_renewal = timestamp; 2608 spin_unlock(&clp->cl_lock); 2609 } 2610 2611 static const struct rpc_call_ops nfs4_renew_ops = { 2612 .rpc_call_done = nfs4_renew_done, 2613 }; 2614 2615 int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred) 2616 { 2617 struct rpc_message msg = { 2618 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 2619 .rpc_argp = clp, 2620 .rpc_cred = cred, 2621 }; 2622 2623 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT, 2624 &nfs4_renew_ops, (void *)jiffies); 2625 } 2626 2627 int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) 2628 { 2629 struct rpc_message msg = { 2630 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 2631 .rpc_argp = clp, 2632 .rpc_cred = cred, 2633 }; 2634 unsigned long now = jiffies; 2635 int status; 2636 2637 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 2638 if (status < 0) 2639 return status; 2640 spin_lock(&clp->cl_lock); 2641 if (time_before(clp->cl_last_renewal,now)) 2642 clp->cl_last_renewal = now; 2643 spin_unlock(&clp->cl_lock); 2644 return 0; 2645 } 2646 2647 static inline int nfs4_server_supports_acls(struct nfs_server *server) 2648 { 2649 return (server->caps & NFS_CAP_ACLS) 2650 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL) 2651 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL); 2652 } 2653 2654 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that 2655 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on 2656 * the stack. 2657 */ 2658 #define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT) 2659 2660 static void buf_to_pages(const void *buf, size_t buflen, 2661 struct page **pages, unsigned int *pgbase) 2662 { 2663 const void *p = buf; 2664 2665 *pgbase = offset_in_page(buf); 2666 p -= *pgbase; 2667 while (p < buf + buflen) { 2668 *(pages++) = virt_to_page(p); 2669 p += PAGE_CACHE_SIZE; 2670 } 2671 } 2672 2673 struct nfs4_cached_acl { 2674 int cached; 2675 size_t len; 2676 char data[0]; 2677 }; 2678 2679 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) 2680 { 2681 struct nfs_inode *nfsi = NFS_I(inode); 2682 2683 spin_lock(&inode->i_lock); 2684 kfree(nfsi->nfs4_acl); 2685 nfsi->nfs4_acl = acl; 2686 spin_unlock(&inode->i_lock); 2687 } 2688 2689 static void nfs4_zap_acl_attr(struct inode *inode) 2690 { 2691 nfs4_set_cached_acl(inode, NULL); 2692 } 2693 2694 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen) 2695 { 2696 struct nfs_inode *nfsi = NFS_I(inode); 2697 struct nfs4_cached_acl *acl; 2698 int ret = -ENOENT; 2699 2700 spin_lock(&inode->i_lock); 2701 acl = nfsi->nfs4_acl; 2702 if (acl == NULL) 2703 goto out; 2704 if (buf == NULL) /* user is just asking for length */ 2705 goto out_len; 2706 if (acl->cached == 0) 2707 goto out; 2708 ret = -ERANGE; /* see getxattr(2) man page */ 2709 if (acl->len > buflen) 2710 goto out; 2711 memcpy(buf, acl->data, acl->len); 2712 out_len: 2713 ret = acl->len; 2714 out: 2715 spin_unlock(&inode->i_lock); 2716 return ret; 2717 } 2718 2719 static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len) 2720 { 2721 struct nfs4_cached_acl *acl; 2722 2723 if (buf && acl_len <= PAGE_SIZE) { 2724 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL); 2725 if (acl == NULL) 2726 goto out; 2727 acl->cached = 1; 2728 memcpy(acl->data, buf, acl_len); 2729 } else { 2730 acl = kmalloc(sizeof(*acl), GFP_KERNEL); 2731 if (acl == NULL) 2732 goto out; 2733 acl->cached = 0; 2734 } 2735 acl->len = acl_len; 2736 out: 2737 nfs4_set_cached_acl(inode, acl); 2738 } 2739 2740 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 2741 { 2742 struct page *pages[NFS4ACL_MAXPAGES]; 2743 struct nfs_getaclargs args = { 2744 .fh = NFS_FH(inode), 2745 .acl_pages = pages, 2746 .acl_len = buflen, 2747 }; 2748 size_t resp_len = buflen; 2749 void *resp_buf; 2750 struct rpc_message msg = { 2751 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL], 2752 .rpc_argp = &args, 2753 .rpc_resp = &resp_len, 2754 }; 2755 struct page *localpage = NULL; 2756 int ret; 2757 2758 if (buflen < PAGE_SIZE) { 2759 /* As long as we're doing a round trip to the server anyway, 2760 * let's be prepared for a page of acl data. */ 2761 localpage = alloc_page(GFP_KERNEL); 2762 resp_buf = page_address(localpage); 2763 if (localpage == NULL) 2764 return -ENOMEM; 2765 args.acl_pages[0] = localpage; 2766 args.acl_pgbase = 0; 2767 resp_len = args.acl_len = PAGE_SIZE; 2768 } else { 2769 resp_buf = buf; 2770 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase); 2771 } 2772 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 2773 if (ret) 2774 goto out_free; 2775 if (resp_len > args.acl_len) 2776 nfs4_write_cached_acl(inode, NULL, resp_len); 2777 else 2778 nfs4_write_cached_acl(inode, resp_buf, resp_len); 2779 if (buf) { 2780 ret = -ERANGE; 2781 if (resp_len > buflen) 2782 goto out_free; 2783 if (localpage) 2784 memcpy(buf, resp_buf, resp_len); 2785 } 2786 ret = resp_len; 2787 out_free: 2788 if (localpage) 2789 __free_page(localpage); 2790 return ret; 2791 } 2792 2793 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 2794 { 2795 struct nfs4_exception exception = { }; 2796 ssize_t ret; 2797 do { 2798 ret = __nfs4_get_acl_uncached(inode, buf, buflen); 2799 if (ret >= 0) 2800 break; 2801 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception); 2802 } while (exception.retry); 2803 return ret; 2804 } 2805 2806 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen) 2807 { 2808 struct nfs_server *server = NFS_SERVER(inode); 2809 int ret; 2810 2811 if (!nfs4_server_supports_acls(server)) 2812 return -EOPNOTSUPP; 2813 ret = nfs_revalidate_inode(server, inode); 2814 if (ret < 0) 2815 return ret; 2816 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) 2817 nfs_zap_acl_cache(inode); 2818 ret = nfs4_read_cached_acl(inode, buf, buflen); 2819 if (ret != -ENOENT) 2820 return ret; 2821 return nfs4_get_acl_uncached(inode, buf, buflen); 2822 } 2823 2824 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 2825 { 2826 struct nfs_server *server = NFS_SERVER(inode); 2827 struct page *pages[NFS4ACL_MAXPAGES]; 2828 struct nfs_setaclargs arg = { 2829 .fh = NFS_FH(inode), 2830 .acl_pages = pages, 2831 .acl_len = buflen, 2832 }; 2833 struct rpc_message msg = { 2834 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL], 2835 .rpc_argp = &arg, 2836 .rpc_resp = NULL, 2837 }; 2838 int ret; 2839 2840 if (!nfs4_server_supports_acls(server)) 2841 return -EOPNOTSUPP; 2842 nfs_inode_return_delegation(inode); 2843 buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 2844 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 2845 nfs_access_zap_cache(inode); 2846 nfs_zap_acl_cache(inode); 2847 return ret; 2848 } 2849 2850 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 2851 { 2852 struct nfs4_exception exception = { }; 2853 int err; 2854 do { 2855 err = nfs4_handle_exception(NFS_SERVER(inode), 2856 __nfs4_proc_set_acl(inode, buf, buflen), 2857 &exception); 2858 } while (exception.retry); 2859 return err; 2860 } 2861 2862 static int 2863 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state) 2864 { 2865 struct nfs_client *clp = server->nfs_client; 2866 2867 if (!clp || task->tk_status >= 0) 2868 return 0; 2869 switch(task->tk_status) { 2870 case -NFS4ERR_ADMIN_REVOKED: 2871 case -NFS4ERR_BAD_STATEID: 2872 case -NFS4ERR_OPENMODE: 2873 if (state == NULL) 2874 break; 2875 nfs4_state_mark_reclaim_nograce(clp, state); 2876 case -NFS4ERR_STALE_CLIENTID: 2877 case -NFS4ERR_STALE_STATEID: 2878 case -NFS4ERR_EXPIRED: 2879 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); 2880 nfs4_schedule_state_recovery(clp); 2881 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) 2882 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); 2883 task->tk_status = 0; 2884 return -EAGAIN; 2885 case -NFS4ERR_DELAY: 2886 nfs_inc_server_stats(server, NFSIOS_DELAY); 2887 case -NFS4ERR_GRACE: 2888 rpc_delay(task, NFS4_POLL_RETRY_MAX); 2889 task->tk_status = 0; 2890 return -EAGAIN; 2891 case -NFS4ERR_OLD_STATEID: 2892 task->tk_status = 0; 2893 return -EAGAIN; 2894 } 2895 task->tk_status = nfs4_map_errors(task->tk_status); 2896 return 0; 2897 } 2898 2899 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, unsigned short port, struct rpc_cred *cred) 2900 { 2901 nfs4_verifier sc_verifier; 2902 struct nfs4_setclientid setclientid = { 2903 .sc_verifier = &sc_verifier, 2904 .sc_prog = program, 2905 }; 2906 struct rpc_message msg = { 2907 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], 2908 .rpc_argp = &setclientid, 2909 .rpc_resp = clp, 2910 .rpc_cred = cred, 2911 }; 2912 __be32 *p; 2913 int loop = 0; 2914 int status; 2915 2916 p = (__be32*)sc_verifier.data; 2917 *p++ = htonl((u32)clp->cl_boot_time.tv_sec); 2918 *p = htonl((u32)clp->cl_boot_time.tv_nsec); 2919 2920 for(;;) { 2921 setclientid.sc_name_len = scnprintf(setclientid.sc_name, 2922 sizeof(setclientid.sc_name), "%s/%s %s %s %u", 2923 clp->cl_ipaddr, 2924 rpc_peeraddr2str(clp->cl_rpcclient, 2925 RPC_DISPLAY_ADDR), 2926 rpc_peeraddr2str(clp->cl_rpcclient, 2927 RPC_DISPLAY_PROTO), 2928 clp->cl_rpcclient->cl_auth->au_ops->au_name, 2929 clp->cl_id_uniquifier); 2930 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid, 2931 sizeof(setclientid.sc_netid), 2932 rpc_peeraddr2str(clp->cl_rpcclient, 2933 RPC_DISPLAY_NETID)); 2934 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, 2935 sizeof(setclientid.sc_uaddr), "%s.%u.%u", 2936 clp->cl_ipaddr, port >> 8, port & 255); 2937 2938 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 2939 if (status != -NFS4ERR_CLID_INUSE) 2940 break; 2941 if (signalled()) 2942 break; 2943 if (loop++ & 1) 2944 ssleep(clp->cl_lease_time + 1); 2945 else 2946 if (++clp->cl_id_uniquifier == 0) 2947 break; 2948 } 2949 return status; 2950 } 2951 2952 static int _nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred) 2953 { 2954 struct nfs_fsinfo fsinfo; 2955 struct rpc_message msg = { 2956 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], 2957 .rpc_argp = clp, 2958 .rpc_resp = &fsinfo, 2959 .rpc_cred = cred, 2960 }; 2961 unsigned long now; 2962 int status; 2963 2964 now = jiffies; 2965 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 2966 if (status == 0) { 2967 spin_lock(&clp->cl_lock); 2968 clp->cl_lease_time = fsinfo.lease_time * HZ; 2969 clp->cl_last_renewal = now; 2970 spin_unlock(&clp->cl_lock); 2971 } 2972 return status; 2973 } 2974 2975 int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred) 2976 { 2977 long timeout = 0; 2978 int err; 2979 do { 2980 err = _nfs4_proc_setclientid_confirm(clp, cred); 2981 switch (err) { 2982 case 0: 2983 return err; 2984 case -NFS4ERR_RESOURCE: 2985 /* The IBM lawyers misread another document! */ 2986 case -NFS4ERR_DELAY: 2987 err = nfs4_delay(clp->cl_rpcclient, &timeout); 2988 } 2989 } while (err == 0); 2990 return err; 2991 } 2992 2993 struct nfs4_delegreturndata { 2994 struct nfs4_delegreturnargs args; 2995 struct nfs4_delegreturnres res; 2996 struct nfs_fh fh; 2997 nfs4_stateid stateid; 2998 unsigned long timestamp; 2999 struct nfs_fattr fattr; 3000 int rpc_status; 3001 }; 3002 3003 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) 3004 { 3005 struct nfs4_delegreturndata *data = calldata; 3006 data->rpc_status = task->tk_status; 3007 if (data->rpc_status == 0) 3008 renew_lease(data->res.server, data->timestamp); 3009 } 3010 3011 static void nfs4_delegreturn_release(void *calldata) 3012 { 3013 kfree(calldata); 3014 } 3015 3016 static const struct rpc_call_ops nfs4_delegreturn_ops = { 3017 .rpc_call_done = nfs4_delegreturn_done, 3018 .rpc_release = nfs4_delegreturn_release, 3019 }; 3020 3021 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 3022 { 3023 struct nfs4_delegreturndata *data; 3024 struct nfs_server *server = NFS_SERVER(inode); 3025 struct rpc_task *task; 3026 struct rpc_message msg = { 3027 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN], 3028 .rpc_cred = cred, 3029 }; 3030 struct rpc_task_setup task_setup_data = { 3031 .rpc_client = server->client, 3032 .rpc_message = &msg, 3033 .callback_ops = &nfs4_delegreturn_ops, 3034 .flags = RPC_TASK_ASYNC, 3035 }; 3036 int status = 0; 3037 3038 data = kmalloc(sizeof(*data), GFP_KERNEL); 3039 if (data == NULL) 3040 return -ENOMEM; 3041 data->args.fhandle = &data->fh; 3042 data->args.stateid = &data->stateid; 3043 data->args.bitmask = server->attr_bitmask; 3044 nfs_copy_fh(&data->fh, NFS_FH(inode)); 3045 memcpy(&data->stateid, stateid, sizeof(data->stateid)); 3046 data->res.fattr = &data->fattr; 3047 data->res.server = server; 3048 nfs_fattr_init(data->res.fattr); 3049 data->timestamp = jiffies; 3050 data->rpc_status = 0; 3051 3052 task_setup_data.callback_data = data; 3053 msg.rpc_argp = &data->args, 3054 msg.rpc_resp = &data->res, 3055 task = rpc_run_task(&task_setup_data); 3056 if (IS_ERR(task)) 3057 return PTR_ERR(task); 3058 if (!issync) 3059 goto out; 3060 status = nfs4_wait_for_completion_rpc_task(task); 3061 if (status != 0) 3062 goto out; 3063 status = data->rpc_status; 3064 if (status != 0) 3065 goto out; 3066 nfs_refresh_inode(inode, &data->fattr); 3067 out: 3068 rpc_put_task(task); 3069 return status; 3070 } 3071 3072 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync) 3073 { 3074 struct nfs_server *server = NFS_SERVER(inode); 3075 struct nfs4_exception exception = { }; 3076 int err; 3077 do { 3078 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync); 3079 switch (err) { 3080 case -NFS4ERR_STALE_STATEID: 3081 case -NFS4ERR_EXPIRED: 3082 case 0: 3083 return 0; 3084 } 3085 err = nfs4_handle_exception(server, err, &exception); 3086 } while (exception.retry); 3087 return err; 3088 } 3089 3090 #define NFS4_LOCK_MINTIMEOUT (1 * HZ) 3091 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ) 3092 3093 /* 3094 * sleep, with exponential backoff, and retry the LOCK operation. 3095 */ 3096 static unsigned long 3097 nfs4_set_lock_task_retry(unsigned long timeout) 3098 { 3099 schedule_timeout_killable(timeout); 3100 timeout <<= 1; 3101 if (timeout > NFS4_LOCK_MAXTIMEOUT) 3102 return NFS4_LOCK_MAXTIMEOUT; 3103 return timeout; 3104 } 3105 3106 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3107 { 3108 struct inode *inode = state->inode; 3109 struct nfs_server *server = NFS_SERVER(inode); 3110 struct nfs_client *clp = server->nfs_client; 3111 struct nfs_lockt_args arg = { 3112 .fh = NFS_FH(inode), 3113 .fl = request, 3114 }; 3115 struct nfs_lockt_res res = { 3116 .denied = request, 3117 }; 3118 struct rpc_message msg = { 3119 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT], 3120 .rpc_argp = &arg, 3121 .rpc_resp = &res, 3122 .rpc_cred = state->owner->so_cred, 3123 }; 3124 struct nfs4_lock_state *lsp; 3125 int status; 3126 3127 arg.lock_owner.clientid = clp->cl_clientid; 3128 status = nfs4_set_lock_state(state, request); 3129 if (status != 0) 3130 goto out; 3131 lsp = request->fl_u.nfs4_fl.owner; 3132 arg.lock_owner.id = lsp->ls_id.id; 3133 status = rpc_call_sync(server->client, &msg, 0); 3134 switch (status) { 3135 case 0: 3136 request->fl_type = F_UNLCK; 3137 break; 3138 case -NFS4ERR_DENIED: 3139 status = 0; 3140 } 3141 request->fl_ops->fl_release_private(request); 3142 out: 3143 return status; 3144 } 3145 3146 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3147 { 3148 struct nfs4_exception exception = { }; 3149 int err; 3150 3151 do { 3152 err = nfs4_handle_exception(NFS_SERVER(state->inode), 3153 _nfs4_proc_getlk(state, cmd, request), 3154 &exception); 3155 } while (exception.retry); 3156 return err; 3157 } 3158 3159 static int do_vfs_lock(struct file *file, struct file_lock *fl) 3160 { 3161 int res = 0; 3162 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 3163 case FL_POSIX: 3164 res = posix_lock_file_wait(file, fl); 3165 break; 3166 case FL_FLOCK: 3167 res = flock_lock_file_wait(file, fl); 3168 break; 3169 default: 3170 BUG(); 3171 } 3172 return res; 3173 } 3174 3175 struct nfs4_unlockdata { 3176 struct nfs_locku_args arg; 3177 struct nfs_locku_res res; 3178 struct nfs4_lock_state *lsp; 3179 struct nfs_open_context *ctx; 3180 struct file_lock fl; 3181 const struct nfs_server *server; 3182 unsigned long timestamp; 3183 }; 3184 3185 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, 3186 struct nfs_open_context *ctx, 3187 struct nfs4_lock_state *lsp, 3188 struct nfs_seqid *seqid) 3189 { 3190 struct nfs4_unlockdata *p; 3191 struct inode *inode = lsp->ls_state->inode; 3192 3193 p = kmalloc(sizeof(*p), GFP_KERNEL); 3194 if (p == NULL) 3195 return NULL; 3196 p->arg.fh = NFS_FH(inode); 3197 p->arg.fl = &p->fl; 3198 p->arg.seqid = seqid; 3199 p->res.seqid = seqid; 3200 p->arg.stateid = &lsp->ls_stateid; 3201 p->lsp = lsp; 3202 atomic_inc(&lsp->ls_count); 3203 /* Ensure we don't close file until we're done freeing locks! */ 3204 p->ctx = get_nfs_open_context(ctx); 3205 memcpy(&p->fl, fl, sizeof(p->fl)); 3206 p->server = NFS_SERVER(inode); 3207 return p; 3208 } 3209 3210 static void nfs4_locku_release_calldata(void *data) 3211 { 3212 struct nfs4_unlockdata *calldata = data; 3213 nfs_free_seqid(calldata->arg.seqid); 3214 nfs4_put_lock_state(calldata->lsp); 3215 put_nfs_open_context(calldata->ctx); 3216 kfree(calldata); 3217 } 3218 3219 static void nfs4_locku_done(struct rpc_task *task, void *data) 3220 { 3221 struct nfs4_unlockdata *calldata = data; 3222 3223 if (RPC_ASSASSINATED(task)) 3224 return; 3225 switch (task->tk_status) { 3226 case 0: 3227 memcpy(calldata->lsp->ls_stateid.data, 3228 calldata->res.stateid.data, 3229 sizeof(calldata->lsp->ls_stateid.data)); 3230 renew_lease(calldata->server, calldata->timestamp); 3231 break; 3232 case -NFS4ERR_BAD_STATEID: 3233 case -NFS4ERR_OLD_STATEID: 3234 case -NFS4ERR_STALE_STATEID: 3235 case -NFS4ERR_EXPIRED: 3236 break; 3237 default: 3238 if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN) 3239 rpc_restart_call(task); 3240 } 3241 } 3242 3243 static void nfs4_locku_prepare(struct rpc_task *task, void *data) 3244 { 3245 struct nfs4_unlockdata *calldata = data; 3246 3247 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 3248 return; 3249 if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) { 3250 /* Note: exit _without_ running nfs4_locku_done */ 3251 task->tk_action = NULL; 3252 return; 3253 } 3254 calldata->timestamp = jiffies; 3255 rpc_call_start(task); 3256 } 3257 3258 static const struct rpc_call_ops nfs4_locku_ops = { 3259 .rpc_call_prepare = nfs4_locku_prepare, 3260 .rpc_call_done = nfs4_locku_done, 3261 .rpc_release = nfs4_locku_release_calldata, 3262 }; 3263 3264 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 3265 struct nfs_open_context *ctx, 3266 struct nfs4_lock_state *lsp, 3267 struct nfs_seqid *seqid) 3268 { 3269 struct nfs4_unlockdata *data; 3270 struct rpc_message msg = { 3271 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU], 3272 .rpc_cred = ctx->cred, 3273 }; 3274 struct rpc_task_setup task_setup_data = { 3275 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), 3276 .rpc_message = &msg, 3277 .callback_ops = &nfs4_locku_ops, 3278 .workqueue = nfsiod_workqueue, 3279 .flags = RPC_TASK_ASYNC, 3280 }; 3281 3282 /* Ensure this is an unlock - when canceling a lock, the 3283 * canceled lock is passed in, and it won't be an unlock. 3284 */ 3285 fl->fl_type = F_UNLCK; 3286 3287 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); 3288 if (data == NULL) { 3289 nfs_free_seqid(seqid); 3290 return ERR_PTR(-ENOMEM); 3291 } 3292 3293 msg.rpc_argp = &data->arg, 3294 msg.rpc_resp = &data->res, 3295 task_setup_data.callback_data = data; 3296 return rpc_run_task(&task_setup_data); 3297 } 3298 3299 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request) 3300 { 3301 struct nfs_inode *nfsi = NFS_I(state->inode); 3302 struct nfs_seqid *seqid; 3303 struct nfs4_lock_state *lsp; 3304 struct rpc_task *task; 3305 int status = 0; 3306 unsigned char fl_flags = request->fl_flags; 3307 3308 status = nfs4_set_lock_state(state, request); 3309 /* Unlock _before_ we do the RPC call */ 3310 request->fl_flags |= FL_EXISTS; 3311 down_read(&nfsi->rwsem); 3312 if (do_vfs_lock(request->fl_file, request) == -ENOENT) { 3313 up_read(&nfsi->rwsem); 3314 goto out; 3315 } 3316 up_read(&nfsi->rwsem); 3317 if (status != 0) 3318 goto out; 3319 /* Is this a delegated lock? */ 3320 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) 3321 goto out; 3322 lsp = request->fl_u.nfs4_fl.owner; 3323 seqid = nfs_alloc_seqid(&lsp->ls_seqid); 3324 status = -ENOMEM; 3325 if (seqid == NULL) 3326 goto out; 3327 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid); 3328 status = PTR_ERR(task); 3329 if (IS_ERR(task)) 3330 goto out; 3331 status = nfs4_wait_for_completion_rpc_task(task); 3332 rpc_put_task(task); 3333 out: 3334 request->fl_flags = fl_flags; 3335 return status; 3336 } 3337 3338 struct nfs4_lockdata { 3339 struct nfs_lock_args arg; 3340 struct nfs_lock_res res; 3341 struct nfs4_lock_state *lsp; 3342 struct nfs_open_context *ctx; 3343 struct file_lock fl; 3344 unsigned long timestamp; 3345 int rpc_status; 3346 int cancelled; 3347 }; 3348 3349 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, 3350 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp) 3351 { 3352 struct nfs4_lockdata *p; 3353 struct inode *inode = lsp->ls_state->inode; 3354 struct nfs_server *server = NFS_SERVER(inode); 3355 3356 p = kzalloc(sizeof(*p), GFP_KERNEL); 3357 if (p == NULL) 3358 return NULL; 3359 3360 p->arg.fh = NFS_FH(inode); 3361 p->arg.fl = &p->fl; 3362 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid); 3363 if (p->arg.open_seqid == NULL) 3364 goto out_free; 3365 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid); 3366 if (p->arg.lock_seqid == NULL) 3367 goto out_free_seqid; 3368 p->arg.lock_stateid = &lsp->ls_stateid; 3369 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; 3370 p->arg.lock_owner.id = lsp->ls_id.id; 3371 p->res.lock_seqid = p->arg.lock_seqid; 3372 p->lsp = lsp; 3373 atomic_inc(&lsp->ls_count); 3374 p->ctx = get_nfs_open_context(ctx); 3375 memcpy(&p->fl, fl, sizeof(p->fl)); 3376 return p; 3377 out_free_seqid: 3378 nfs_free_seqid(p->arg.open_seqid); 3379 out_free: 3380 kfree(p); 3381 return NULL; 3382 } 3383 3384 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) 3385 { 3386 struct nfs4_lockdata *data = calldata; 3387 struct nfs4_state *state = data->lsp->ls_state; 3388 3389 dprintk("%s: begin!\n", __func__); 3390 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 3391 return; 3392 /* Do we need to do an open_to_lock_owner? */ 3393 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) { 3394 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) 3395 return; 3396 data->arg.open_stateid = &state->stateid; 3397 data->arg.new_lock_owner = 1; 3398 data->res.open_seqid = data->arg.open_seqid; 3399 } else 3400 data->arg.new_lock_owner = 0; 3401 data->timestamp = jiffies; 3402 rpc_call_start(task); 3403 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status); 3404 } 3405 3406 static void nfs4_lock_done(struct rpc_task *task, void *calldata) 3407 { 3408 struct nfs4_lockdata *data = calldata; 3409 3410 dprintk("%s: begin!\n", __func__); 3411 3412 data->rpc_status = task->tk_status; 3413 if (RPC_ASSASSINATED(task)) 3414 goto out; 3415 if (data->arg.new_lock_owner != 0) { 3416 if (data->rpc_status == 0) 3417 nfs_confirm_seqid(&data->lsp->ls_seqid, 0); 3418 else 3419 goto out; 3420 } 3421 if (data->rpc_status == 0) { 3422 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data, 3423 sizeof(data->lsp->ls_stateid.data)); 3424 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED; 3425 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp); 3426 } 3427 out: 3428 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status); 3429 } 3430 3431 static void nfs4_lock_release(void *calldata) 3432 { 3433 struct nfs4_lockdata *data = calldata; 3434 3435 dprintk("%s: begin!\n", __func__); 3436 nfs_free_seqid(data->arg.open_seqid); 3437 if (data->cancelled != 0) { 3438 struct rpc_task *task; 3439 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, 3440 data->arg.lock_seqid); 3441 if (!IS_ERR(task)) 3442 rpc_put_task(task); 3443 dprintk("%s: cancelling lock!\n", __func__); 3444 } else 3445 nfs_free_seqid(data->arg.lock_seqid); 3446 nfs4_put_lock_state(data->lsp); 3447 put_nfs_open_context(data->ctx); 3448 kfree(data); 3449 dprintk("%s: done!\n", __func__); 3450 } 3451 3452 static const struct rpc_call_ops nfs4_lock_ops = { 3453 .rpc_call_prepare = nfs4_lock_prepare, 3454 .rpc_call_done = nfs4_lock_done, 3455 .rpc_release = nfs4_lock_release, 3456 }; 3457 3458 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int reclaim) 3459 { 3460 struct nfs4_lockdata *data; 3461 struct rpc_task *task; 3462 struct rpc_message msg = { 3463 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK], 3464 .rpc_cred = state->owner->so_cred, 3465 }; 3466 struct rpc_task_setup task_setup_data = { 3467 .rpc_client = NFS_CLIENT(state->inode), 3468 .rpc_message = &msg, 3469 .callback_ops = &nfs4_lock_ops, 3470 .workqueue = nfsiod_workqueue, 3471 .flags = RPC_TASK_ASYNC, 3472 }; 3473 int ret; 3474 3475 dprintk("%s: begin!\n", __func__); 3476 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), 3477 fl->fl_u.nfs4_fl.owner); 3478 if (data == NULL) 3479 return -ENOMEM; 3480 if (IS_SETLKW(cmd)) 3481 data->arg.block = 1; 3482 if (reclaim != 0) 3483 data->arg.reclaim = 1; 3484 msg.rpc_argp = &data->arg, 3485 msg.rpc_resp = &data->res, 3486 task_setup_data.callback_data = data; 3487 task = rpc_run_task(&task_setup_data); 3488 if (IS_ERR(task)) 3489 return PTR_ERR(task); 3490 ret = nfs4_wait_for_completion_rpc_task(task); 3491 if (ret == 0) { 3492 ret = data->rpc_status; 3493 if (ret == -NFS4ERR_DENIED) 3494 ret = -EAGAIN; 3495 } else 3496 data->cancelled = 1; 3497 rpc_put_task(task); 3498 dprintk("%s: done, ret = %d!\n", __func__, ret); 3499 return ret; 3500 } 3501 3502 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request) 3503 { 3504 struct nfs_server *server = NFS_SERVER(state->inode); 3505 struct nfs4_exception exception = { }; 3506 int err; 3507 3508 do { 3509 /* Cache the lock if possible... */ 3510 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 3511 return 0; 3512 err = _nfs4_do_setlk(state, F_SETLK, request, 1); 3513 if (err != -NFS4ERR_DELAY) 3514 break; 3515 nfs4_handle_exception(server, err, &exception); 3516 } while (exception.retry); 3517 return err; 3518 } 3519 3520 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request) 3521 { 3522 struct nfs_server *server = NFS_SERVER(state->inode); 3523 struct nfs4_exception exception = { }; 3524 int err; 3525 3526 err = nfs4_set_lock_state(state, request); 3527 if (err != 0) 3528 return err; 3529 do { 3530 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 3531 return 0; 3532 err = _nfs4_do_setlk(state, F_SETLK, request, 0); 3533 if (err != -NFS4ERR_DELAY) 3534 break; 3535 nfs4_handle_exception(server, err, &exception); 3536 } while (exception.retry); 3537 return err; 3538 } 3539 3540 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3541 { 3542 struct nfs_inode *nfsi = NFS_I(state->inode); 3543 unsigned char fl_flags = request->fl_flags; 3544 int status; 3545 3546 /* Is this a delegated open? */ 3547 status = nfs4_set_lock_state(state, request); 3548 if (status != 0) 3549 goto out; 3550 request->fl_flags |= FL_ACCESS; 3551 status = do_vfs_lock(request->fl_file, request); 3552 if (status < 0) 3553 goto out; 3554 down_read(&nfsi->rwsem); 3555 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 3556 /* Yes: cache locks! */ 3557 /* ...but avoid races with delegation recall... */ 3558 request->fl_flags = fl_flags & ~FL_SLEEP; 3559 status = do_vfs_lock(request->fl_file, request); 3560 goto out_unlock; 3561 } 3562 status = _nfs4_do_setlk(state, cmd, request, 0); 3563 if (status != 0) 3564 goto out_unlock; 3565 /* Note: we always want to sleep here! */ 3566 request->fl_flags = fl_flags | FL_SLEEP; 3567 if (do_vfs_lock(request->fl_file, request) < 0) 3568 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__); 3569 out_unlock: 3570 up_read(&nfsi->rwsem); 3571 out: 3572 request->fl_flags = fl_flags; 3573 return status; 3574 } 3575 3576 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3577 { 3578 struct nfs4_exception exception = { }; 3579 int err; 3580 3581 do { 3582 err = nfs4_handle_exception(NFS_SERVER(state->inode), 3583 _nfs4_proc_setlk(state, cmd, request), 3584 &exception); 3585 } while (exception.retry); 3586 return err; 3587 } 3588 3589 static int 3590 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) 3591 { 3592 struct nfs_open_context *ctx; 3593 struct nfs4_state *state; 3594 unsigned long timeout = NFS4_LOCK_MINTIMEOUT; 3595 int status; 3596 3597 /* verify open state */ 3598 ctx = nfs_file_open_context(filp); 3599 state = ctx->state; 3600 3601 if (request->fl_start < 0 || request->fl_end < 0) 3602 return -EINVAL; 3603 3604 if (IS_GETLK(cmd)) 3605 return nfs4_proc_getlk(state, F_GETLK, request); 3606 3607 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) 3608 return -EINVAL; 3609 3610 if (request->fl_type == F_UNLCK) 3611 return nfs4_proc_unlck(state, cmd, request); 3612 3613 do { 3614 status = nfs4_proc_setlk(state, cmd, request); 3615 if ((status != -EAGAIN) || IS_SETLK(cmd)) 3616 break; 3617 timeout = nfs4_set_lock_task_retry(timeout); 3618 status = -ERESTARTSYS; 3619 if (signalled()) 3620 break; 3621 } while(status < 0); 3622 return status; 3623 } 3624 3625 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl) 3626 { 3627 struct nfs_server *server = NFS_SERVER(state->inode); 3628 struct nfs4_exception exception = { }; 3629 int err; 3630 3631 err = nfs4_set_lock_state(state, fl); 3632 if (err != 0) 3633 goto out; 3634 do { 3635 err = _nfs4_do_setlk(state, F_SETLK, fl, 0); 3636 if (err != -NFS4ERR_DELAY) 3637 break; 3638 err = nfs4_handle_exception(server, err, &exception); 3639 } while (exception.retry); 3640 out: 3641 return err; 3642 } 3643 3644 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl" 3645 3646 int nfs4_setxattr(struct dentry *dentry, const char *key, const void *buf, 3647 size_t buflen, int flags) 3648 { 3649 struct inode *inode = dentry->d_inode; 3650 3651 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0) 3652 return -EOPNOTSUPP; 3653 3654 return nfs4_proc_set_acl(inode, buf, buflen); 3655 } 3656 3657 /* The getxattr man page suggests returning -ENODATA for unknown attributes, 3658 * and that's what we'll do for e.g. user attributes that haven't been set. 3659 * But we'll follow ext2/ext3's lead by returning -EOPNOTSUPP for unsupported 3660 * attributes in kernel-managed attribute namespaces. */ 3661 ssize_t nfs4_getxattr(struct dentry *dentry, const char *key, void *buf, 3662 size_t buflen) 3663 { 3664 struct inode *inode = dentry->d_inode; 3665 3666 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0) 3667 return -EOPNOTSUPP; 3668 3669 return nfs4_proc_get_acl(inode, buf, buflen); 3670 } 3671 3672 ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen) 3673 { 3674 size_t len = strlen(XATTR_NAME_NFSV4_ACL) + 1; 3675 3676 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 3677 return 0; 3678 if (buf && buflen < len) 3679 return -ERANGE; 3680 if (buf) 3681 memcpy(buf, XATTR_NAME_NFSV4_ACL, len); 3682 return len; 3683 } 3684 3685 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr) 3686 { 3687 if (!((fattr->valid & NFS_ATTR_FATTR_FILEID) && 3688 (fattr->valid & NFS_ATTR_FATTR_FSID) && 3689 (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL))) 3690 return; 3691 3692 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | 3693 NFS_ATTR_FATTR_NLINK; 3694 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; 3695 fattr->nlink = 2; 3696 } 3697 3698 int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name, 3699 struct nfs4_fs_locations *fs_locations, struct page *page) 3700 { 3701 struct nfs_server *server = NFS_SERVER(dir); 3702 u32 bitmask[2] = { 3703 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 3704 [1] = FATTR4_WORD1_MOUNTED_ON_FILEID, 3705 }; 3706 struct nfs4_fs_locations_arg args = { 3707 .dir_fh = NFS_FH(dir), 3708 .name = name, 3709 .page = page, 3710 .bitmask = bitmask, 3711 }; 3712 struct rpc_message msg = { 3713 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 3714 .rpc_argp = &args, 3715 .rpc_resp = fs_locations, 3716 }; 3717 int status; 3718 3719 dprintk("%s: start\n", __func__); 3720 nfs_fattr_init(&fs_locations->fattr); 3721 fs_locations->server = server; 3722 fs_locations->nlocations = 0; 3723 status = rpc_call_sync(server->client, &msg, 0); 3724 nfs_fixup_referral_attributes(&fs_locations->fattr); 3725 dprintk("%s: returned status = %d\n", __func__, status); 3726 return status; 3727 } 3728 3729 struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = { 3730 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT, 3731 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT, 3732 .recover_open = nfs4_open_reclaim, 3733 .recover_lock = nfs4_lock_reclaim, 3734 }; 3735 3736 struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops = { 3737 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE, 3738 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE, 3739 .recover_open = nfs4_open_expired, 3740 .recover_lock = nfs4_lock_expired, 3741 }; 3742 3743 static const struct inode_operations nfs4_file_inode_operations = { 3744 .permission = nfs_permission, 3745 .getattr = nfs_getattr, 3746 .setattr = nfs_setattr, 3747 .getxattr = nfs4_getxattr, 3748 .setxattr = nfs4_setxattr, 3749 .listxattr = nfs4_listxattr, 3750 }; 3751 3752 const struct nfs_rpc_ops nfs_v4_clientops = { 3753 .version = 4, /* protocol version */ 3754 .dentry_ops = &nfs4_dentry_operations, 3755 .dir_inode_ops = &nfs4_dir_inode_operations, 3756 .file_inode_ops = &nfs4_file_inode_operations, 3757 .getroot = nfs4_proc_get_root, 3758 .getattr = nfs4_proc_getattr, 3759 .setattr = nfs4_proc_setattr, 3760 .lookupfh = nfs4_proc_lookupfh, 3761 .lookup = nfs4_proc_lookup, 3762 .access = nfs4_proc_access, 3763 .readlink = nfs4_proc_readlink, 3764 .create = nfs4_proc_create, 3765 .remove = nfs4_proc_remove, 3766 .unlink_setup = nfs4_proc_unlink_setup, 3767 .unlink_done = nfs4_proc_unlink_done, 3768 .rename = nfs4_proc_rename, 3769 .link = nfs4_proc_link, 3770 .symlink = nfs4_proc_symlink, 3771 .mkdir = nfs4_proc_mkdir, 3772 .rmdir = nfs4_proc_remove, 3773 .readdir = nfs4_proc_readdir, 3774 .mknod = nfs4_proc_mknod, 3775 .statfs = nfs4_proc_statfs, 3776 .fsinfo = nfs4_proc_fsinfo, 3777 .pathconf = nfs4_proc_pathconf, 3778 .set_capabilities = nfs4_server_capabilities, 3779 .decode_dirent = nfs4_decode_dirent, 3780 .read_setup = nfs4_proc_read_setup, 3781 .read_done = nfs4_read_done, 3782 .write_setup = nfs4_proc_write_setup, 3783 .write_done = nfs4_write_done, 3784 .commit_setup = nfs4_proc_commit_setup, 3785 .commit_done = nfs4_commit_done, 3786 .lock = nfs4_proc_lock, 3787 .clear_acl_cache = nfs4_zap_acl_attr, 3788 .close_context = nfs4_close_context, 3789 }; 3790 3791 /* 3792 * Local variables: 3793 * c-basic-offset: 8 3794 * End: 3795 */ 3796