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