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