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