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, __be32 *verifier, struct dentry *dentry, 142 struct nfs4_readdir_arg *readdir) 143 { 144 __be32 *start, *p; 145 146 BUG_ON(readdir->count < 80); 147 if (cookie > 2) { 148 readdir->cookie = cookie; 149 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); 150 return; 151 } 152 153 readdir->cookie = 0; 154 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); 155 if (cookie == 2) 156 return; 157 158 /* 159 * NFSv4 servers do not return entries for '.' and '..' 160 * Therefore, we fake these entries here. We let '.' 161 * have cookie 0 and '..' have cookie 1. Note that 162 * when talking to the server, we always send cookie 0 163 * instead of 1 or 2. 164 */ 165 start = p = kmap_atomic(*readdir->pages, KM_USER0); 166 167 if (cookie == 0) { 168 *p++ = xdr_one; /* next */ 169 *p++ = xdr_zero; /* cookie, first word */ 170 *p++ = xdr_one; /* cookie, second word */ 171 *p++ = xdr_one; /* entry len */ 172 memcpy(p, ".\0\0\0", 4); /* entry */ 173 p++; 174 *p++ = xdr_one; /* bitmap length */ 175 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 176 *p++ = htonl(8); /* attribute buffer length */ 177 p = xdr_encode_hyper(p, 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_put_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_put_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 break; 1144 default: 1145 if (nfs4_async_handle_error(task, server) == -EAGAIN) { 1146 rpc_restart_call(task); 1147 return; 1148 } 1149 } 1150 nfs_refresh_inode(calldata->inode, calldata->res.fattr); 1151 } 1152 1153 static void nfs4_close_prepare(struct rpc_task *task, void *data) 1154 { 1155 struct nfs4_closedata *calldata = data; 1156 struct nfs4_state *state = calldata->state; 1157 struct rpc_message msg = { 1158 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE], 1159 .rpc_argp = &calldata->arg, 1160 .rpc_resp = &calldata->res, 1161 .rpc_cred = state->owner->so_cred, 1162 }; 1163 int mode = 0, old_mode; 1164 1165 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 1166 return; 1167 /* Recalculate the new open mode in case someone reopened the file 1168 * while we were waiting in line to be scheduled. 1169 */ 1170 spin_lock(&state->owner->so_lock); 1171 spin_lock(&calldata->inode->i_lock); 1172 mode = old_mode = state->state; 1173 if (state->n_rdwr == 0) { 1174 if (state->n_rdonly == 0) 1175 mode &= ~FMODE_READ; 1176 if (state->n_wronly == 0) 1177 mode &= ~FMODE_WRITE; 1178 } 1179 nfs4_state_set_mode_locked(state, mode); 1180 spin_unlock(&calldata->inode->i_lock); 1181 spin_unlock(&state->owner->so_lock); 1182 if (mode == old_mode || test_bit(NFS_DELEGATED_STATE, &state->flags)) { 1183 /* Note: exit _without_ calling nfs4_close_done */ 1184 task->tk_action = NULL; 1185 return; 1186 } 1187 nfs_fattr_init(calldata->res.fattr); 1188 if (mode != 0) 1189 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; 1190 calldata->arg.open_flags = mode; 1191 calldata->timestamp = jiffies; 1192 rpc_call_setup(task, &msg, 0); 1193 } 1194 1195 static const struct rpc_call_ops nfs4_close_ops = { 1196 .rpc_call_prepare = nfs4_close_prepare, 1197 .rpc_call_done = nfs4_close_done, 1198 .rpc_release = nfs4_free_closedata, 1199 }; 1200 1201 /* 1202 * It is possible for data to be read/written from a mem-mapped file 1203 * after the sys_close call (which hits the vfs layer as a flush). 1204 * This means that we can't safely call nfsv4 close on a file until 1205 * the inode is cleared. This in turn means that we are not good 1206 * NFSv4 citizens - we do not indicate to the server to update the file's 1207 * share state even when we are done with one of the three share 1208 * stateid's in the inode. 1209 * 1210 * NOTE: Caller must be holding the sp->so_owner semaphore! 1211 */ 1212 int nfs4_do_close(struct inode *inode, struct nfs4_state *state) 1213 { 1214 struct nfs_server *server = NFS_SERVER(inode); 1215 struct nfs4_closedata *calldata; 1216 int status = -ENOMEM; 1217 1218 calldata = kmalloc(sizeof(*calldata), GFP_KERNEL); 1219 if (calldata == NULL) 1220 goto out; 1221 calldata->inode = inode; 1222 calldata->state = state; 1223 calldata->arg.fh = NFS_FH(inode); 1224 calldata->arg.stateid = &state->stateid; 1225 /* Serialization for the sequence id */ 1226 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid); 1227 if (calldata->arg.seqid == NULL) 1228 goto out_free_calldata; 1229 calldata->arg.bitmask = server->attr_bitmask; 1230 calldata->res.fattr = &calldata->fattr; 1231 calldata->res.server = server; 1232 1233 status = nfs4_call_async(server->client, &nfs4_close_ops, calldata); 1234 if (status == 0) 1235 goto out; 1236 1237 nfs_free_seqid(calldata->arg.seqid); 1238 out_free_calldata: 1239 kfree(calldata); 1240 out: 1241 return status; 1242 } 1243 1244 static int nfs4_intent_set_file(struct nameidata *nd, struct dentry *dentry, struct nfs4_state *state) 1245 { 1246 struct file *filp; 1247 1248 filp = lookup_instantiate_filp(nd, dentry, NULL); 1249 if (!IS_ERR(filp)) { 1250 struct nfs_open_context *ctx; 1251 ctx = (struct nfs_open_context *)filp->private_data; 1252 ctx->state = state; 1253 return 0; 1254 } 1255 nfs4_close_state(state, nd->intent.open.flags); 1256 return PTR_ERR(filp); 1257 } 1258 1259 struct dentry * 1260 nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 1261 { 1262 struct iattr attr; 1263 struct rpc_cred *cred; 1264 struct nfs4_state *state; 1265 struct dentry *res; 1266 1267 if (nd->flags & LOOKUP_CREATE) { 1268 attr.ia_mode = nd->intent.open.create_mode; 1269 attr.ia_valid = ATTR_MODE; 1270 if (!IS_POSIXACL(dir)) 1271 attr.ia_mode &= ~current->fs->umask; 1272 } else { 1273 attr.ia_valid = 0; 1274 BUG_ON(nd->intent.open.flags & O_CREAT); 1275 } 1276 1277 cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0); 1278 if (IS_ERR(cred)) 1279 return (struct dentry *)cred; 1280 state = nfs4_do_open(dir, dentry, nd->intent.open.flags, &attr, cred); 1281 put_rpccred(cred); 1282 if (IS_ERR(state)) { 1283 if (PTR_ERR(state) == -ENOENT) 1284 d_add(dentry, NULL); 1285 return (struct dentry *)state; 1286 } 1287 res = d_add_unique(dentry, igrab(state->inode)); 1288 if (res != NULL) 1289 dentry = res; 1290 nfs4_intent_set_file(nd, dentry, state); 1291 return res; 1292 } 1293 1294 int 1295 nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd) 1296 { 1297 struct rpc_cred *cred; 1298 struct nfs4_state *state; 1299 1300 cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0); 1301 if (IS_ERR(cred)) 1302 return PTR_ERR(cred); 1303 state = nfs4_open_delegated(dentry->d_inode, openflags, cred); 1304 if (IS_ERR(state)) 1305 state = nfs4_do_open(dir, dentry, openflags, NULL, cred); 1306 put_rpccred(cred); 1307 if (IS_ERR(state)) { 1308 switch (PTR_ERR(state)) { 1309 case -EPERM: 1310 case -EACCES: 1311 case -EDQUOT: 1312 case -ENOSPC: 1313 case -EROFS: 1314 lookup_instantiate_filp(nd, (struct dentry *)state, NULL); 1315 return 1; 1316 default: 1317 goto out_drop; 1318 } 1319 } 1320 if (state->inode == dentry->d_inode) { 1321 nfs4_intent_set_file(nd, dentry, state); 1322 return 1; 1323 } 1324 nfs4_close_state(state, openflags); 1325 out_drop: 1326 d_drop(dentry); 1327 return 0; 1328 } 1329 1330 1331 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 1332 { 1333 struct nfs4_server_caps_res res = {}; 1334 struct rpc_message msg = { 1335 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS], 1336 .rpc_argp = fhandle, 1337 .rpc_resp = &res, 1338 }; 1339 int status; 1340 1341 status = rpc_call_sync(server->client, &msg, 0); 1342 if (status == 0) { 1343 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); 1344 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL) 1345 server->caps |= NFS_CAP_ACLS; 1346 if (res.has_links != 0) 1347 server->caps |= NFS_CAP_HARDLINKS; 1348 if (res.has_symlinks != 0) 1349 server->caps |= NFS_CAP_SYMLINKS; 1350 server->acl_bitmask = res.acl_bitmask; 1351 } 1352 return status; 1353 } 1354 1355 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle) 1356 { 1357 struct nfs4_exception exception = { }; 1358 int err; 1359 do { 1360 err = nfs4_handle_exception(server, 1361 _nfs4_server_capabilities(server, fhandle), 1362 &exception); 1363 } while (exception.retry); 1364 return err; 1365 } 1366 1367 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 1368 struct nfs_fsinfo *info) 1369 { 1370 struct nfs4_lookup_root_arg args = { 1371 .bitmask = nfs4_fattr_bitmap, 1372 }; 1373 struct nfs4_lookup_res res = { 1374 .server = server, 1375 .fattr = info->fattr, 1376 .fh = fhandle, 1377 }; 1378 struct rpc_message msg = { 1379 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT], 1380 .rpc_argp = &args, 1381 .rpc_resp = &res, 1382 }; 1383 nfs_fattr_init(info->fattr); 1384 return rpc_call_sync(server->client, &msg, 0); 1385 } 1386 1387 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, 1388 struct nfs_fsinfo *info) 1389 { 1390 struct nfs4_exception exception = { }; 1391 int err; 1392 do { 1393 err = nfs4_handle_exception(server, 1394 _nfs4_lookup_root(server, fhandle, info), 1395 &exception); 1396 } while (exception.retry); 1397 return err; 1398 } 1399 1400 /* 1401 * get the file handle for the "/" directory on the server 1402 */ 1403 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 1404 struct nfs_fsinfo *info) 1405 { 1406 int status; 1407 1408 status = nfs4_lookup_root(server, fhandle, info); 1409 if (status == 0) 1410 status = nfs4_server_capabilities(server, fhandle); 1411 if (status == 0) 1412 status = nfs4_do_fsinfo(server, fhandle, info); 1413 return nfs4_map_errors(status); 1414 } 1415 1416 /* 1417 * Get locations and (maybe) other attributes of a referral. 1418 * Note that we'll actually follow the referral later when 1419 * we detect fsid mismatch in inode revalidation 1420 */ 1421 static int nfs4_get_referral(struct inode *dir, struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle) 1422 { 1423 int status = -ENOMEM; 1424 struct page *page = NULL; 1425 struct nfs4_fs_locations *locations = NULL; 1426 1427 page = alloc_page(GFP_KERNEL); 1428 if (page == NULL) 1429 goto out; 1430 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); 1431 if (locations == NULL) 1432 goto out; 1433 1434 status = nfs4_proc_fs_locations(dir, name, locations, page); 1435 if (status != 0) 1436 goto out; 1437 /* Make sure server returned a different fsid for the referral */ 1438 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 1439 dprintk("%s: server did not return a different fsid for a referral at %s\n", __FUNCTION__, name->name); 1440 status = -EIO; 1441 goto out; 1442 } 1443 1444 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr)); 1445 fattr->valid |= NFS_ATTR_FATTR_V4_REFERRAL; 1446 if (!fattr->mode) 1447 fattr->mode = S_IFDIR; 1448 memset(fhandle, 0, sizeof(struct nfs_fh)); 1449 out: 1450 if (page) 1451 __free_page(page); 1452 if (locations) 1453 kfree(locations); 1454 return status; 1455 } 1456 1457 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1458 { 1459 struct nfs4_getattr_arg args = { 1460 .fh = fhandle, 1461 .bitmask = server->attr_bitmask, 1462 }; 1463 struct nfs4_getattr_res res = { 1464 .fattr = fattr, 1465 .server = server, 1466 }; 1467 struct rpc_message msg = { 1468 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR], 1469 .rpc_argp = &args, 1470 .rpc_resp = &res, 1471 }; 1472 1473 nfs_fattr_init(fattr); 1474 return rpc_call_sync(server->client, &msg, 0); 1475 } 1476 1477 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1478 { 1479 struct nfs4_exception exception = { }; 1480 int err; 1481 do { 1482 err = nfs4_handle_exception(server, 1483 _nfs4_proc_getattr(server, fhandle, fattr), 1484 &exception); 1485 } while (exception.retry); 1486 return err; 1487 } 1488 1489 /* 1490 * The file is not closed if it is opened due to the a request to change 1491 * the size of the file. The open call will not be needed once the 1492 * VFS layer lookup-intents are implemented. 1493 * 1494 * Close is called when the inode is destroyed. 1495 * If we haven't opened the file for O_WRONLY, we 1496 * need to in the size_change case to obtain a stateid. 1497 * 1498 * Got race? 1499 * Because OPEN is always done by name in nfsv4, it is 1500 * possible that we opened a different file by the same 1501 * name. We can recognize this race condition, but we 1502 * can't do anything about it besides returning an error. 1503 * 1504 * This will be fixed with VFS changes (lookup-intent). 1505 */ 1506 static int 1507 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 1508 struct iattr *sattr) 1509 { 1510 struct rpc_cred *cred; 1511 struct inode *inode = dentry->d_inode; 1512 struct nfs_open_context *ctx; 1513 struct nfs4_state *state = NULL; 1514 int status; 1515 1516 nfs_fattr_init(fattr); 1517 1518 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0); 1519 if (IS_ERR(cred)) 1520 return PTR_ERR(cred); 1521 1522 /* Search for an existing open(O_WRITE) file */ 1523 ctx = nfs_find_open_context(inode, cred, FMODE_WRITE); 1524 if (ctx != NULL) 1525 state = ctx->state; 1526 1527 status = nfs4_do_setattr(inode, fattr, sattr, state); 1528 if (status == 0) 1529 nfs_setattr_update_inode(inode, sattr); 1530 if (ctx != NULL) 1531 put_nfs_open_context(ctx); 1532 put_rpccred(cred); 1533 return status; 1534 } 1535 1536 static int _nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh, 1537 struct qstr *name, struct nfs_fh *fhandle, 1538 struct nfs_fattr *fattr) 1539 { 1540 int status; 1541 struct nfs4_lookup_arg args = { 1542 .bitmask = server->attr_bitmask, 1543 .dir_fh = dirfh, 1544 .name = name, 1545 }; 1546 struct nfs4_lookup_res res = { 1547 .server = server, 1548 .fattr = fattr, 1549 .fh = fhandle, 1550 }; 1551 struct rpc_message msg = { 1552 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 1553 .rpc_argp = &args, 1554 .rpc_resp = &res, 1555 }; 1556 1557 nfs_fattr_init(fattr); 1558 1559 dprintk("NFS call lookupfh %s\n", name->name); 1560 status = rpc_call_sync(server->client, &msg, 0); 1561 dprintk("NFS reply lookupfh: %d\n", status); 1562 if (status == -NFS4ERR_MOVED) 1563 status = -EREMOTE; 1564 return status; 1565 } 1566 1567 static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh, 1568 struct qstr *name, struct nfs_fh *fhandle, 1569 struct nfs_fattr *fattr) 1570 { 1571 struct nfs4_exception exception = { }; 1572 int err; 1573 do { 1574 err = nfs4_handle_exception(server, 1575 _nfs4_proc_lookupfh(server, dirfh, name, 1576 fhandle, fattr), 1577 &exception); 1578 } while (exception.retry); 1579 return err; 1580 } 1581 1582 static int _nfs4_proc_lookup(struct inode *dir, struct qstr *name, 1583 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1584 { 1585 int status; 1586 struct nfs_server *server = NFS_SERVER(dir); 1587 struct nfs4_lookup_arg args = { 1588 .bitmask = server->attr_bitmask, 1589 .dir_fh = NFS_FH(dir), 1590 .name = name, 1591 }; 1592 struct nfs4_lookup_res res = { 1593 .server = server, 1594 .fattr = fattr, 1595 .fh = fhandle, 1596 }; 1597 struct rpc_message msg = { 1598 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP], 1599 .rpc_argp = &args, 1600 .rpc_resp = &res, 1601 }; 1602 1603 nfs_fattr_init(fattr); 1604 1605 dprintk("NFS call lookup %s\n", name->name); 1606 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 1607 if (status == -NFS4ERR_MOVED) 1608 status = nfs4_get_referral(dir, name, fattr, fhandle); 1609 dprintk("NFS reply lookup: %d\n", status); 1610 return status; 1611 } 1612 1613 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr) 1614 { 1615 struct nfs4_exception exception = { }; 1616 int err; 1617 do { 1618 err = nfs4_handle_exception(NFS_SERVER(dir), 1619 _nfs4_proc_lookup(dir, name, fhandle, fattr), 1620 &exception); 1621 } while (exception.retry); 1622 return err; 1623 } 1624 1625 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 1626 { 1627 struct nfs4_accessargs args = { 1628 .fh = NFS_FH(inode), 1629 }; 1630 struct nfs4_accessres res = { 0 }; 1631 struct rpc_message msg = { 1632 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS], 1633 .rpc_argp = &args, 1634 .rpc_resp = &res, 1635 .rpc_cred = entry->cred, 1636 }; 1637 int mode = entry->mask; 1638 int status; 1639 1640 /* 1641 * Determine which access bits we want to ask for... 1642 */ 1643 if (mode & MAY_READ) 1644 args.access |= NFS4_ACCESS_READ; 1645 if (S_ISDIR(inode->i_mode)) { 1646 if (mode & MAY_WRITE) 1647 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE; 1648 if (mode & MAY_EXEC) 1649 args.access |= NFS4_ACCESS_LOOKUP; 1650 } else { 1651 if (mode & MAY_WRITE) 1652 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND; 1653 if (mode & MAY_EXEC) 1654 args.access |= NFS4_ACCESS_EXECUTE; 1655 } 1656 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 1657 if (!status) { 1658 entry->mask = 0; 1659 if (res.access & NFS4_ACCESS_READ) 1660 entry->mask |= MAY_READ; 1661 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE)) 1662 entry->mask |= MAY_WRITE; 1663 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE)) 1664 entry->mask |= MAY_EXEC; 1665 } 1666 return status; 1667 } 1668 1669 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry) 1670 { 1671 struct nfs4_exception exception = { }; 1672 int err; 1673 do { 1674 err = nfs4_handle_exception(NFS_SERVER(inode), 1675 _nfs4_proc_access(inode, entry), 1676 &exception); 1677 } while (exception.retry); 1678 return err; 1679 } 1680 1681 /* 1682 * TODO: For the time being, we don't try to get any attributes 1683 * along with any of the zero-copy operations READ, READDIR, 1684 * READLINK, WRITE. 1685 * 1686 * In the case of the first three, we want to put the GETATTR 1687 * after the read-type operation -- this is because it is hard 1688 * to predict the length of a GETATTR response in v4, and thus 1689 * align the READ data correctly. This means that the GETATTR 1690 * may end up partially falling into the page cache, and we should 1691 * shift it into the 'tail' of the xdr_buf before processing. 1692 * To do this efficiently, we need to know the total length 1693 * of data received, which doesn't seem to be available outside 1694 * of the RPC layer. 1695 * 1696 * In the case of WRITE, we also want to put the GETATTR after 1697 * the operation -- in this case because we want to make sure 1698 * we get the post-operation mtime and size. This means that 1699 * we can't use xdr_encode_pages() as written: we need a variant 1700 * of it which would leave room in the 'tail' iovec. 1701 * 1702 * Both of these changes to the XDR layer would in fact be quite 1703 * minor, but I decided to leave them for a subsequent patch. 1704 */ 1705 static int _nfs4_proc_readlink(struct inode *inode, struct page *page, 1706 unsigned int pgbase, unsigned int pglen) 1707 { 1708 struct nfs4_readlink args = { 1709 .fh = NFS_FH(inode), 1710 .pgbase = pgbase, 1711 .pglen = pglen, 1712 .pages = &page, 1713 }; 1714 struct rpc_message msg = { 1715 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK], 1716 .rpc_argp = &args, 1717 .rpc_resp = NULL, 1718 }; 1719 1720 return rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 1721 } 1722 1723 static int nfs4_proc_readlink(struct inode *inode, struct page *page, 1724 unsigned int pgbase, unsigned int pglen) 1725 { 1726 struct nfs4_exception exception = { }; 1727 int err; 1728 do { 1729 err = nfs4_handle_exception(NFS_SERVER(inode), 1730 _nfs4_proc_readlink(inode, page, pgbase, pglen), 1731 &exception); 1732 } while (exception.retry); 1733 return err; 1734 } 1735 1736 /* 1737 * Got race? 1738 * We will need to arrange for the VFS layer to provide an atomic open. 1739 * Until then, this create/open method is prone to inefficiency and race 1740 * conditions due to the lookup, create, and open VFS calls from sys_open() 1741 * placed on the wire. 1742 * 1743 * Given the above sorry state of affairs, I'm simply sending an OPEN. 1744 * The file will be opened again in the subsequent VFS open call 1745 * (nfs4_proc_file_open). 1746 * 1747 * The open for read will just hang around to be used by any process that 1748 * opens the file O_RDONLY. This will all be resolved with the VFS changes. 1749 */ 1750 1751 static int 1752 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 1753 int flags, struct nameidata *nd) 1754 { 1755 struct nfs4_state *state; 1756 struct rpc_cred *cred; 1757 int status = 0; 1758 1759 cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0); 1760 if (IS_ERR(cred)) { 1761 status = PTR_ERR(cred); 1762 goto out; 1763 } 1764 state = nfs4_do_open(dir, dentry, flags, sattr, cred); 1765 put_rpccred(cred); 1766 if (IS_ERR(state)) { 1767 status = PTR_ERR(state); 1768 goto out; 1769 } 1770 d_instantiate(dentry, igrab(state->inode)); 1771 if (flags & O_EXCL) { 1772 struct nfs_fattr fattr; 1773 status = nfs4_do_setattr(state->inode, &fattr, sattr, state); 1774 if (status == 0) 1775 nfs_setattr_update_inode(state->inode, sattr); 1776 } 1777 if (status == 0 && nd != NULL && (nd->flags & LOOKUP_OPEN)) 1778 status = nfs4_intent_set_file(nd, dentry, state); 1779 else 1780 nfs4_close_state(state, flags); 1781 out: 1782 return status; 1783 } 1784 1785 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name) 1786 { 1787 struct nfs_server *server = NFS_SERVER(dir); 1788 struct nfs4_remove_arg args = { 1789 .fh = NFS_FH(dir), 1790 .name = name, 1791 .bitmask = server->attr_bitmask, 1792 }; 1793 struct nfs_fattr dir_attr; 1794 struct nfs4_remove_res res = { 1795 .server = server, 1796 .dir_attr = &dir_attr, 1797 }; 1798 struct rpc_message msg = { 1799 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE], 1800 .rpc_argp = &args, 1801 .rpc_resp = &res, 1802 }; 1803 int status; 1804 1805 nfs_fattr_init(res.dir_attr); 1806 status = rpc_call_sync(server->client, &msg, 0); 1807 if (status == 0) { 1808 update_changeattr(dir, &res.cinfo); 1809 nfs_post_op_update_inode(dir, res.dir_attr); 1810 } 1811 return status; 1812 } 1813 1814 static int nfs4_proc_remove(struct inode *dir, struct qstr *name) 1815 { 1816 struct nfs4_exception exception = { }; 1817 int err; 1818 do { 1819 err = nfs4_handle_exception(NFS_SERVER(dir), 1820 _nfs4_proc_remove(dir, name), 1821 &exception); 1822 } while (exception.retry); 1823 return err; 1824 } 1825 1826 struct unlink_desc { 1827 struct nfs4_remove_arg args; 1828 struct nfs4_remove_res res; 1829 struct nfs_fattr dir_attr; 1830 }; 1831 1832 static int nfs4_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, 1833 struct qstr *name) 1834 { 1835 struct nfs_server *server = NFS_SERVER(dir->d_inode); 1836 struct unlink_desc *up; 1837 1838 up = kmalloc(sizeof(*up), GFP_KERNEL); 1839 if (!up) 1840 return -ENOMEM; 1841 1842 up->args.fh = NFS_FH(dir->d_inode); 1843 up->args.name = name; 1844 up->args.bitmask = server->attr_bitmask; 1845 up->res.server = server; 1846 up->res.dir_attr = &up->dir_attr; 1847 1848 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; 1849 msg->rpc_argp = &up->args; 1850 msg->rpc_resp = &up->res; 1851 return 0; 1852 } 1853 1854 static int nfs4_proc_unlink_done(struct dentry *dir, struct rpc_task *task) 1855 { 1856 struct rpc_message *msg = &task->tk_msg; 1857 struct unlink_desc *up; 1858 1859 if (msg->rpc_resp != NULL) { 1860 up = container_of(msg->rpc_resp, struct unlink_desc, res); 1861 update_changeattr(dir->d_inode, &up->res.cinfo); 1862 nfs_post_op_update_inode(dir->d_inode, up->res.dir_attr); 1863 kfree(up); 1864 msg->rpc_resp = NULL; 1865 msg->rpc_argp = NULL; 1866 } 1867 return 0; 1868 } 1869 1870 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 1871 struct inode *new_dir, struct qstr *new_name) 1872 { 1873 struct nfs_server *server = NFS_SERVER(old_dir); 1874 struct nfs4_rename_arg arg = { 1875 .old_dir = NFS_FH(old_dir), 1876 .new_dir = NFS_FH(new_dir), 1877 .old_name = old_name, 1878 .new_name = new_name, 1879 .bitmask = server->attr_bitmask, 1880 }; 1881 struct nfs_fattr old_fattr, new_fattr; 1882 struct nfs4_rename_res res = { 1883 .server = server, 1884 .old_fattr = &old_fattr, 1885 .new_fattr = &new_fattr, 1886 }; 1887 struct rpc_message msg = { 1888 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME], 1889 .rpc_argp = &arg, 1890 .rpc_resp = &res, 1891 }; 1892 int status; 1893 1894 nfs_fattr_init(res.old_fattr); 1895 nfs_fattr_init(res.new_fattr); 1896 status = rpc_call_sync(server->client, &msg, 0); 1897 1898 if (!status) { 1899 update_changeattr(old_dir, &res.old_cinfo); 1900 nfs_post_op_update_inode(old_dir, res.old_fattr); 1901 update_changeattr(new_dir, &res.new_cinfo); 1902 nfs_post_op_update_inode(new_dir, res.new_fattr); 1903 } 1904 return status; 1905 } 1906 1907 static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name, 1908 struct inode *new_dir, struct qstr *new_name) 1909 { 1910 struct nfs4_exception exception = { }; 1911 int err; 1912 do { 1913 err = nfs4_handle_exception(NFS_SERVER(old_dir), 1914 _nfs4_proc_rename(old_dir, old_name, 1915 new_dir, new_name), 1916 &exception); 1917 } while (exception.retry); 1918 return err; 1919 } 1920 1921 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 1922 { 1923 struct nfs_server *server = NFS_SERVER(inode); 1924 struct nfs4_link_arg arg = { 1925 .fh = NFS_FH(inode), 1926 .dir_fh = NFS_FH(dir), 1927 .name = name, 1928 .bitmask = server->attr_bitmask, 1929 }; 1930 struct nfs_fattr fattr, dir_attr; 1931 struct nfs4_link_res res = { 1932 .server = server, 1933 .fattr = &fattr, 1934 .dir_attr = &dir_attr, 1935 }; 1936 struct rpc_message msg = { 1937 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK], 1938 .rpc_argp = &arg, 1939 .rpc_resp = &res, 1940 }; 1941 int status; 1942 1943 nfs_fattr_init(res.fattr); 1944 nfs_fattr_init(res.dir_attr); 1945 status = rpc_call_sync(server->client, &msg, 0); 1946 if (!status) { 1947 update_changeattr(dir, &res.cinfo); 1948 nfs_post_op_update_inode(dir, res.dir_attr); 1949 nfs_post_op_update_inode(inode, res.fattr); 1950 } 1951 1952 return status; 1953 } 1954 1955 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 1956 { 1957 struct nfs4_exception exception = { }; 1958 int err; 1959 do { 1960 err = nfs4_handle_exception(NFS_SERVER(inode), 1961 _nfs4_proc_link(inode, dir, name), 1962 &exception); 1963 } while (exception.retry); 1964 return err; 1965 } 1966 1967 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 1968 struct page *page, unsigned int len, struct iattr *sattr) 1969 { 1970 struct nfs_server *server = NFS_SERVER(dir); 1971 struct nfs_fh fhandle; 1972 struct nfs_fattr fattr, dir_fattr; 1973 struct nfs4_create_arg arg = { 1974 .dir_fh = NFS_FH(dir), 1975 .server = server, 1976 .name = &dentry->d_name, 1977 .attrs = sattr, 1978 .ftype = NF4LNK, 1979 .bitmask = server->attr_bitmask, 1980 }; 1981 struct nfs4_create_res res = { 1982 .server = server, 1983 .fh = &fhandle, 1984 .fattr = &fattr, 1985 .dir_fattr = &dir_fattr, 1986 }; 1987 struct rpc_message msg = { 1988 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK], 1989 .rpc_argp = &arg, 1990 .rpc_resp = &res, 1991 }; 1992 int status; 1993 1994 if (len > NFS4_MAXPATHLEN) 1995 return -ENAMETOOLONG; 1996 1997 arg.u.symlink.pages = &page; 1998 arg.u.symlink.len = len; 1999 nfs_fattr_init(&fattr); 2000 nfs_fattr_init(&dir_fattr); 2001 2002 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2003 if (!status) { 2004 update_changeattr(dir, &res.dir_cinfo); 2005 nfs_post_op_update_inode(dir, res.dir_fattr); 2006 status = nfs_instantiate(dentry, &fhandle, &fattr); 2007 } 2008 return status; 2009 } 2010 2011 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2012 struct page *page, unsigned int len, struct iattr *sattr) 2013 { 2014 struct nfs4_exception exception = { }; 2015 int err; 2016 do { 2017 err = nfs4_handle_exception(NFS_SERVER(dir), 2018 _nfs4_proc_symlink(dir, dentry, page, 2019 len, sattr), 2020 &exception); 2021 } while (exception.retry); 2022 return err; 2023 } 2024 2025 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2026 struct iattr *sattr) 2027 { 2028 struct nfs_server *server = NFS_SERVER(dir); 2029 struct nfs_fh fhandle; 2030 struct nfs_fattr fattr, dir_fattr; 2031 struct nfs4_create_arg arg = { 2032 .dir_fh = NFS_FH(dir), 2033 .server = server, 2034 .name = &dentry->d_name, 2035 .attrs = sattr, 2036 .ftype = NF4DIR, 2037 .bitmask = server->attr_bitmask, 2038 }; 2039 struct nfs4_create_res res = { 2040 .server = server, 2041 .fh = &fhandle, 2042 .fattr = &fattr, 2043 .dir_fattr = &dir_fattr, 2044 }; 2045 struct rpc_message msg = { 2046 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE], 2047 .rpc_argp = &arg, 2048 .rpc_resp = &res, 2049 }; 2050 int status; 2051 2052 nfs_fattr_init(&fattr); 2053 nfs_fattr_init(&dir_fattr); 2054 2055 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2056 if (!status) { 2057 update_changeattr(dir, &res.dir_cinfo); 2058 nfs_post_op_update_inode(dir, res.dir_fattr); 2059 status = nfs_instantiate(dentry, &fhandle, &fattr); 2060 } 2061 return status; 2062 } 2063 2064 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2065 struct iattr *sattr) 2066 { 2067 struct nfs4_exception exception = { }; 2068 int err; 2069 do { 2070 err = nfs4_handle_exception(NFS_SERVER(dir), 2071 _nfs4_proc_mkdir(dir, dentry, sattr), 2072 &exception); 2073 } while (exception.retry); 2074 return err; 2075 } 2076 2077 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2078 u64 cookie, struct page *page, unsigned int count, int plus) 2079 { 2080 struct inode *dir = dentry->d_inode; 2081 struct nfs4_readdir_arg args = { 2082 .fh = NFS_FH(dir), 2083 .pages = &page, 2084 .pgbase = 0, 2085 .count = count, 2086 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask, 2087 }; 2088 struct nfs4_readdir_res res; 2089 struct rpc_message msg = { 2090 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR], 2091 .rpc_argp = &args, 2092 .rpc_resp = &res, 2093 .rpc_cred = cred, 2094 }; 2095 int status; 2096 2097 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __FUNCTION__, 2098 dentry->d_parent->d_name.name, 2099 dentry->d_name.name, 2100 (unsigned long long)cookie); 2101 nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args); 2102 res.pgbase = args.pgbase; 2103 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2104 if (status == 0) 2105 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE); 2106 dprintk("%s: returns %d\n", __FUNCTION__, status); 2107 return status; 2108 } 2109 2110 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 2111 u64 cookie, struct page *page, unsigned int count, int plus) 2112 { 2113 struct nfs4_exception exception = { }; 2114 int err; 2115 do { 2116 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), 2117 _nfs4_proc_readdir(dentry, cred, cookie, 2118 page, count, plus), 2119 &exception); 2120 } while (exception.retry); 2121 return err; 2122 } 2123 2124 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2125 struct iattr *sattr, dev_t rdev) 2126 { 2127 struct nfs_server *server = NFS_SERVER(dir); 2128 struct nfs_fh fh; 2129 struct nfs_fattr fattr, dir_fattr; 2130 struct nfs4_create_arg arg = { 2131 .dir_fh = NFS_FH(dir), 2132 .server = server, 2133 .name = &dentry->d_name, 2134 .attrs = sattr, 2135 .bitmask = server->attr_bitmask, 2136 }; 2137 struct nfs4_create_res res = { 2138 .server = server, 2139 .fh = &fh, 2140 .fattr = &fattr, 2141 .dir_fattr = &dir_fattr, 2142 }; 2143 struct rpc_message msg = { 2144 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE], 2145 .rpc_argp = &arg, 2146 .rpc_resp = &res, 2147 }; 2148 int status; 2149 int mode = sattr->ia_mode; 2150 2151 nfs_fattr_init(&fattr); 2152 nfs_fattr_init(&dir_fattr); 2153 2154 BUG_ON(!(sattr->ia_valid & ATTR_MODE)); 2155 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode)); 2156 if (S_ISFIFO(mode)) 2157 arg.ftype = NF4FIFO; 2158 else if (S_ISBLK(mode)) { 2159 arg.ftype = NF4BLK; 2160 arg.u.device.specdata1 = MAJOR(rdev); 2161 arg.u.device.specdata2 = MINOR(rdev); 2162 } 2163 else if (S_ISCHR(mode)) { 2164 arg.ftype = NF4CHR; 2165 arg.u.device.specdata1 = MAJOR(rdev); 2166 arg.u.device.specdata2 = MINOR(rdev); 2167 } 2168 else 2169 arg.ftype = NF4SOCK; 2170 2171 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2172 if (status == 0) { 2173 update_changeattr(dir, &res.dir_cinfo); 2174 nfs_post_op_update_inode(dir, res.dir_fattr); 2175 status = nfs_instantiate(dentry, &fh, &fattr); 2176 } 2177 return status; 2178 } 2179 2180 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2181 struct iattr *sattr, dev_t rdev) 2182 { 2183 struct nfs4_exception exception = { }; 2184 int err; 2185 do { 2186 err = nfs4_handle_exception(NFS_SERVER(dir), 2187 _nfs4_proc_mknod(dir, dentry, sattr, rdev), 2188 &exception); 2189 } while (exception.retry); 2190 return err; 2191 } 2192 2193 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 2194 struct nfs_fsstat *fsstat) 2195 { 2196 struct nfs4_statfs_arg args = { 2197 .fh = fhandle, 2198 .bitmask = server->attr_bitmask, 2199 }; 2200 struct rpc_message msg = { 2201 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS], 2202 .rpc_argp = &args, 2203 .rpc_resp = fsstat, 2204 }; 2205 2206 nfs_fattr_init(fsstat->fattr); 2207 return rpc_call_sync(server->client, &msg, 0); 2208 } 2209 2210 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat) 2211 { 2212 struct nfs4_exception exception = { }; 2213 int err; 2214 do { 2215 err = nfs4_handle_exception(server, 2216 _nfs4_proc_statfs(server, fhandle, fsstat), 2217 &exception); 2218 } while (exception.retry); 2219 return err; 2220 } 2221 2222 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 2223 struct nfs_fsinfo *fsinfo) 2224 { 2225 struct nfs4_fsinfo_arg args = { 2226 .fh = fhandle, 2227 .bitmask = server->attr_bitmask, 2228 }; 2229 struct rpc_message msg = { 2230 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO], 2231 .rpc_argp = &args, 2232 .rpc_resp = fsinfo, 2233 }; 2234 2235 return rpc_call_sync(server->client, &msg, 0); 2236 } 2237 2238 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 2239 { 2240 struct nfs4_exception exception = { }; 2241 int err; 2242 2243 do { 2244 err = nfs4_handle_exception(server, 2245 _nfs4_do_fsinfo(server, fhandle, fsinfo), 2246 &exception); 2247 } while (exception.retry); 2248 return err; 2249 } 2250 2251 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo) 2252 { 2253 nfs_fattr_init(fsinfo->fattr); 2254 return nfs4_do_fsinfo(server, fhandle, fsinfo); 2255 } 2256 2257 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 2258 struct nfs_pathconf *pathconf) 2259 { 2260 struct nfs4_pathconf_arg args = { 2261 .fh = fhandle, 2262 .bitmask = server->attr_bitmask, 2263 }; 2264 struct rpc_message msg = { 2265 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF], 2266 .rpc_argp = &args, 2267 .rpc_resp = pathconf, 2268 }; 2269 2270 /* None of the pathconf attributes are mandatory to implement */ 2271 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) { 2272 memset(pathconf, 0, sizeof(*pathconf)); 2273 return 0; 2274 } 2275 2276 nfs_fattr_init(pathconf->fattr); 2277 return rpc_call_sync(server->client, &msg, 0); 2278 } 2279 2280 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 2281 struct nfs_pathconf *pathconf) 2282 { 2283 struct nfs4_exception exception = { }; 2284 int err; 2285 2286 do { 2287 err = nfs4_handle_exception(server, 2288 _nfs4_proc_pathconf(server, fhandle, pathconf), 2289 &exception); 2290 } while (exception.retry); 2291 return err; 2292 } 2293 2294 static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data) 2295 { 2296 struct nfs_server *server = NFS_SERVER(data->inode); 2297 2298 if (nfs4_async_handle_error(task, server) == -EAGAIN) { 2299 rpc_restart_call(task); 2300 return -EAGAIN; 2301 } 2302 if (task->tk_status > 0) 2303 renew_lease(server, data->timestamp); 2304 return 0; 2305 } 2306 2307 static void nfs4_proc_read_setup(struct nfs_read_data *data) 2308 { 2309 struct rpc_message msg = { 2310 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ], 2311 .rpc_argp = &data->args, 2312 .rpc_resp = &data->res, 2313 .rpc_cred = data->cred, 2314 }; 2315 2316 data->timestamp = jiffies; 2317 2318 rpc_call_setup(&data->task, &msg, 0); 2319 } 2320 2321 static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data) 2322 { 2323 struct inode *inode = data->inode; 2324 2325 if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) { 2326 rpc_restart_call(task); 2327 return -EAGAIN; 2328 } 2329 if (task->tk_status >= 0) { 2330 renew_lease(NFS_SERVER(inode), data->timestamp); 2331 nfs_post_op_update_inode(inode, data->res.fattr); 2332 } 2333 return 0; 2334 } 2335 2336 static void nfs4_proc_write_setup(struct nfs_write_data *data, int how) 2337 { 2338 struct rpc_message msg = { 2339 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE], 2340 .rpc_argp = &data->args, 2341 .rpc_resp = &data->res, 2342 .rpc_cred = data->cred, 2343 }; 2344 struct inode *inode = data->inode; 2345 struct nfs_server *server = NFS_SERVER(inode); 2346 int stable; 2347 2348 if (how & FLUSH_STABLE) { 2349 if (!NFS_I(inode)->ncommit) 2350 stable = NFS_FILE_SYNC; 2351 else 2352 stable = NFS_DATA_SYNC; 2353 } else 2354 stable = NFS_UNSTABLE; 2355 data->args.stable = stable; 2356 data->args.bitmask = server->attr_bitmask; 2357 data->res.server = server; 2358 2359 data->timestamp = jiffies; 2360 2361 /* Finalize the task. */ 2362 rpc_call_setup(&data->task, &msg, 0); 2363 } 2364 2365 static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data) 2366 { 2367 struct inode *inode = data->inode; 2368 2369 if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) { 2370 rpc_restart_call(task); 2371 return -EAGAIN; 2372 } 2373 if (task->tk_status >= 0) 2374 nfs_post_op_update_inode(inode, data->res.fattr); 2375 return 0; 2376 } 2377 2378 static void nfs4_proc_commit_setup(struct nfs_write_data *data, int how) 2379 { 2380 struct rpc_message msg = { 2381 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT], 2382 .rpc_argp = &data->args, 2383 .rpc_resp = &data->res, 2384 .rpc_cred = data->cred, 2385 }; 2386 struct nfs_server *server = NFS_SERVER(data->inode); 2387 2388 data->args.bitmask = server->attr_bitmask; 2389 data->res.server = server; 2390 2391 rpc_call_setup(&data->task, &msg, 0); 2392 } 2393 2394 /* 2395 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special 2396 * standalone procedure for queueing an asynchronous RENEW. 2397 */ 2398 static void nfs4_renew_done(struct rpc_task *task, void *data) 2399 { 2400 struct nfs_client *clp = (struct nfs_client *)task->tk_msg.rpc_argp; 2401 unsigned long timestamp = (unsigned long)data; 2402 2403 if (task->tk_status < 0) { 2404 switch (task->tk_status) { 2405 case -NFS4ERR_STALE_CLIENTID: 2406 case -NFS4ERR_EXPIRED: 2407 case -NFS4ERR_CB_PATH_DOWN: 2408 nfs4_schedule_state_recovery(clp); 2409 } 2410 return; 2411 } 2412 spin_lock(&clp->cl_lock); 2413 if (time_before(clp->cl_last_renewal,timestamp)) 2414 clp->cl_last_renewal = timestamp; 2415 spin_unlock(&clp->cl_lock); 2416 } 2417 2418 static const struct rpc_call_ops nfs4_renew_ops = { 2419 .rpc_call_done = nfs4_renew_done, 2420 }; 2421 2422 int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred) 2423 { 2424 struct rpc_message msg = { 2425 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 2426 .rpc_argp = clp, 2427 .rpc_cred = cred, 2428 }; 2429 2430 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT, 2431 &nfs4_renew_ops, (void *)jiffies); 2432 } 2433 2434 int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) 2435 { 2436 struct rpc_message msg = { 2437 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW], 2438 .rpc_argp = clp, 2439 .rpc_cred = cred, 2440 }; 2441 unsigned long now = jiffies; 2442 int status; 2443 2444 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 2445 if (status < 0) 2446 return status; 2447 spin_lock(&clp->cl_lock); 2448 if (time_before(clp->cl_last_renewal,now)) 2449 clp->cl_last_renewal = now; 2450 spin_unlock(&clp->cl_lock); 2451 return 0; 2452 } 2453 2454 static inline int nfs4_server_supports_acls(struct nfs_server *server) 2455 { 2456 return (server->caps & NFS_CAP_ACLS) 2457 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL) 2458 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL); 2459 } 2460 2461 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that 2462 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on 2463 * the stack. 2464 */ 2465 #define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT) 2466 2467 static void buf_to_pages(const void *buf, size_t buflen, 2468 struct page **pages, unsigned int *pgbase) 2469 { 2470 const void *p = buf; 2471 2472 *pgbase = offset_in_page(buf); 2473 p -= *pgbase; 2474 while (p < buf + buflen) { 2475 *(pages++) = virt_to_page(p); 2476 p += PAGE_CACHE_SIZE; 2477 } 2478 } 2479 2480 struct nfs4_cached_acl { 2481 int cached; 2482 size_t len; 2483 char data[0]; 2484 }; 2485 2486 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) 2487 { 2488 struct nfs_inode *nfsi = NFS_I(inode); 2489 2490 spin_lock(&inode->i_lock); 2491 kfree(nfsi->nfs4_acl); 2492 nfsi->nfs4_acl = acl; 2493 spin_unlock(&inode->i_lock); 2494 } 2495 2496 static void nfs4_zap_acl_attr(struct inode *inode) 2497 { 2498 nfs4_set_cached_acl(inode, NULL); 2499 } 2500 2501 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen) 2502 { 2503 struct nfs_inode *nfsi = NFS_I(inode); 2504 struct nfs4_cached_acl *acl; 2505 int ret = -ENOENT; 2506 2507 spin_lock(&inode->i_lock); 2508 acl = nfsi->nfs4_acl; 2509 if (acl == NULL) 2510 goto out; 2511 if (buf == NULL) /* user is just asking for length */ 2512 goto out_len; 2513 if (acl->cached == 0) 2514 goto out; 2515 ret = -ERANGE; /* see getxattr(2) man page */ 2516 if (acl->len > buflen) 2517 goto out; 2518 memcpy(buf, acl->data, acl->len); 2519 out_len: 2520 ret = acl->len; 2521 out: 2522 spin_unlock(&inode->i_lock); 2523 return ret; 2524 } 2525 2526 static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len) 2527 { 2528 struct nfs4_cached_acl *acl; 2529 2530 if (buf && acl_len <= PAGE_SIZE) { 2531 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL); 2532 if (acl == NULL) 2533 goto out; 2534 acl->cached = 1; 2535 memcpy(acl->data, buf, acl_len); 2536 } else { 2537 acl = kmalloc(sizeof(*acl), GFP_KERNEL); 2538 if (acl == NULL) 2539 goto out; 2540 acl->cached = 0; 2541 } 2542 acl->len = acl_len; 2543 out: 2544 nfs4_set_cached_acl(inode, acl); 2545 } 2546 2547 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 2548 { 2549 struct page *pages[NFS4ACL_MAXPAGES]; 2550 struct nfs_getaclargs args = { 2551 .fh = NFS_FH(inode), 2552 .acl_pages = pages, 2553 .acl_len = buflen, 2554 }; 2555 size_t resp_len = buflen; 2556 void *resp_buf; 2557 struct rpc_message msg = { 2558 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL], 2559 .rpc_argp = &args, 2560 .rpc_resp = &resp_len, 2561 }; 2562 struct page *localpage = NULL; 2563 int ret; 2564 2565 if (buflen < PAGE_SIZE) { 2566 /* As long as we're doing a round trip to the server anyway, 2567 * let's be prepared for a page of acl data. */ 2568 localpage = alloc_page(GFP_KERNEL); 2569 resp_buf = page_address(localpage); 2570 if (localpage == NULL) 2571 return -ENOMEM; 2572 args.acl_pages[0] = localpage; 2573 args.acl_pgbase = 0; 2574 resp_len = args.acl_len = PAGE_SIZE; 2575 } else { 2576 resp_buf = buf; 2577 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase); 2578 } 2579 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 2580 if (ret) 2581 goto out_free; 2582 if (resp_len > args.acl_len) 2583 nfs4_write_cached_acl(inode, NULL, resp_len); 2584 else 2585 nfs4_write_cached_acl(inode, resp_buf, resp_len); 2586 if (buf) { 2587 ret = -ERANGE; 2588 if (resp_len > buflen) 2589 goto out_free; 2590 if (localpage) 2591 memcpy(buf, resp_buf, resp_len); 2592 } 2593 ret = resp_len; 2594 out_free: 2595 if (localpage) 2596 __free_page(localpage); 2597 return ret; 2598 } 2599 2600 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen) 2601 { 2602 struct nfs4_exception exception = { }; 2603 ssize_t ret; 2604 do { 2605 ret = __nfs4_get_acl_uncached(inode, buf, buflen); 2606 if (ret >= 0) 2607 break; 2608 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception); 2609 } while (exception.retry); 2610 return ret; 2611 } 2612 2613 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen) 2614 { 2615 struct nfs_server *server = NFS_SERVER(inode); 2616 int ret; 2617 2618 if (!nfs4_server_supports_acls(server)) 2619 return -EOPNOTSUPP; 2620 ret = nfs_revalidate_inode(server, inode); 2621 if (ret < 0) 2622 return ret; 2623 ret = nfs4_read_cached_acl(inode, buf, buflen); 2624 if (ret != -ENOENT) 2625 return ret; 2626 return nfs4_get_acl_uncached(inode, buf, buflen); 2627 } 2628 2629 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 2630 { 2631 struct nfs_server *server = NFS_SERVER(inode); 2632 struct page *pages[NFS4ACL_MAXPAGES]; 2633 struct nfs_setaclargs arg = { 2634 .fh = NFS_FH(inode), 2635 .acl_pages = pages, 2636 .acl_len = buflen, 2637 }; 2638 struct rpc_message msg = { 2639 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL], 2640 .rpc_argp = &arg, 2641 .rpc_resp = NULL, 2642 }; 2643 int ret; 2644 2645 if (!nfs4_server_supports_acls(server)) 2646 return -EOPNOTSUPP; 2647 nfs_inode_return_delegation(inode); 2648 buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 2649 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 2650 nfs_zap_caches(inode); 2651 return ret; 2652 } 2653 2654 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen) 2655 { 2656 struct nfs4_exception exception = { }; 2657 int err; 2658 do { 2659 err = nfs4_handle_exception(NFS_SERVER(inode), 2660 __nfs4_proc_set_acl(inode, buf, buflen), 2661 &exception); 2662 } while (exception.retry); 2663 return err; 2664 } 2665 2666 static int 2667 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server) 2668 { 2669 struct nfs_client *clp = server->nfs_client; 2670 2671 if (!clp || task->tk_status >= 0) 2672 return 0; 2673 switch(task->tk_status) { 2674 case -NFS4ERR_STALE_CLIENTID: 2675 case -NFS4ERR_STALE_STATEID: 2676 case -NFS4ERR_EXPIRED: 2677 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL, NULL); 2678 nfs4_schedule_state_recovery(clp); 2679 if (test_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) == 0) 2680 rpc_wake_up_task(task); 2681 task->tk_status = 0; 2682 return -EAGAIN; 2683 case -NFS4ERR_DELAY: 2684 nfs_inc_server_stats((struct nfs_server *) server, 2685 NFSIOS_DELAY); 2686 case -NFS4ERR_GRACE: 2687 rpc_delay(task, NFS4_POLL_RETRY_MAX); 2688 task->tk_status = 0; 2689 return -EAGAIN; 2690 case -NFS4ERR_OLD_STATEID: 2691 task->tk_status = 0; 2692 return -EAGAIN; 2693 } 2694 task->tk_status = nfs4_map_errors(task->tk_status); 2695 return 0; 2696 } 2697 2698 static int nfs4_wait_bit_interruptible(void *word) 2699 { 2700 if (signal_pending(current)) 2701 return -ERESTARTSYS; 2702 schedule(); 2703 return 0; 2704 } 2705 2706 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp) 2707 { 2708 sigset_t oldset; 2709 int res; 2710 2711 might_sleep(); 2712 2713 rwsem_acquire(&clp->cl_sem.dep_map, 0, 0, _RET_IP_); 2714 2715 rpc_clnt_sigmask(clnt, &oldset); 2716 res = wait_on_bit(&clp->cl_state, NFS4CLNT_STATE_RECOVER, 2717 nfs4_wait_bit_interruptible, 2718 TASK_INTERRUPTIBLE); 2719 rpc_clnt_sigunmask(clnt, &oldset); 2720 2721 rwsem_release(&clp->cl_sem.dep_map, 1, _RET_IP_); 2722 return res; 2723 } 2724 2725 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout) 2726 { 2727 sigset_t oldset; 2728 int res = 0; 2729 2730 might_sleep(); 2731 2732 if (*timeout <= 0) 2733 *timeout = NFS4_POLL_RETRY_MIN; 2734 if (*timeout > NFS4_POLL_RETRY_MAX) 2735 *timeout = NFS4_POLL_RETRY_MAX; 2736 rpc_clnt_sigmask(clnt, &oldset); 2737 if (clnt->cl_intr) { 2738 schedule_timeout_interruptible(*timeout); 2739 if (signalled()) 2740 res = -ERESTARTSYS; 2741 } else 2742 schedule_timeout_uninterruptible(*timeout); 2743 rpc_clnt_sigunmask(clnt, &oldset); 2744 *timeout <<= 1; 2745 return res; 2746 } 2747 2748 /* This is the error handling routine for processes that are allowed 2749 * to sleep. 2750 */ 2751 int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception) 2752 { 2753 struct nfs_client *clp = server->nfs_client; 2754 int ret = errorcode; 2755 2756 exception->retry = 0; 2757 switch(errorcode) { 2758 case 0: 2759 return 0; 2760 case -NFS4ERR_STALE_CLIENTID: 2761 case -NFS4ERR_STALE_STATEID: 2762 case -NFS4ERR_EXPIRED: 2763 nfs4_schedule_state_recovery(clp); 2764 ret = nfs4_wait_clnt_recover(server->client, clp); 2765 if (ret == 0) 2766 exception->retry = 1; 2767 break; 2768 case -NFS4ERR_FILE_OPEN: 2769 case -NFS4ERR_GRACE: 2770 case -NFS4ERR_DELAY: 2771 ret = nfs4_delay(server->client, &exception->timeout); 2772 if (ret != 0) 2773 break; 2774 case -NFS4ERR_OLD_STATEID: 2775 exception->retry = 1; 2776 } 2777 /* We failed to handle the error */ 2778 return nfs4_map_errors(ret); 2779 } 2780 2781 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, unsigned short port, struct rpc_cred *cred) 2782 { 2783 nfs4_verifier sc_verifier; 2784 struct nfs4_setclientid setclientid = { 2785 .sc_verifier = &sc_verifier, 2786 .sc_prog = program, 2787 }; 2788 struct rpc_message msg = { 2789 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID], 2790 .rpc_argp = &setclientid, 2791 .rpc_resp = clp, 2792 .rpc_cred = cred, 2793 }; 2794 __be32 *p; 2795 int loop = 0; 2796 int status; 2797 2798 p = (__be32*)sc_verifier.data; 2799 *p++ = htonl((u32)clp->cl_boot_time.tv_sec); 2800 *p = htonl((u32)clp->cl_boot_time.tv_nsec); 2801 2802 for(;;) { 2803 setclientid.sc_name_len = scnprintf(setclientid.sc_name, 2804 sizeof(setclientid.sc_name), "%s/%u.%u.%u.%u %s %u", 2805 clp->cl_ipaddr, NIPQUAD(clp->cl_addr.sin_addr), 2806 cred->cr_ops->cr_name, 2807 clp->cl_id_uniquifier); 2808 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid, 2809 sizeof(setclientid.sc_netid), "tcp"); 2810 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr, 2811 sizeof(setclientid.sc_uaddr), "%s.%d.%d", 2812 clp->cl_ipaddr, port >> 8, port & 255); 2813 2814 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 2815 if (status != -NFS4ERR_CLID_INUSE) 2816 break; 2817 if (signalled()) 2818 break; 2819 if (loop++ & 1) 2820 ssleep(clp->cl_lease_time + 1); 2821 else 2822 if (++clp->cl_id_uniquifier == 0) 2823 break; 2824 } 2825 return status; 2826 } 2827 2828 static int _nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred) 2829 { 2830 struct nfs_fsinfo fsinfo; 2831 struct rpc_message msg = { 2832 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM], 2833 .rpc_argp = clp, 2834 .rpc_resp = &fsinfo, 2835 .rpc_cred = cred, 2836 }; 2837 unsigned long now; 2838 int status; 2839 2840 now = jiffies; 2841 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); 2842 if (status == 0) { 2843 spin_lock(&clp->cl_lock); 2844 clp->cl_lease_time = fsinfo.lease_time * HZ; 2845 clp->cl_last_renewal = now; 2846 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); 2847 spin_unlock(&clp->cl_lock); 2848 } 2849 return status; 2850 } 2851 2852 int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred) 2853 { 2854 long timeout; 2855 int err; 2856 do { 2857 err = _nfs4_proc_setclientid_confirm(clp, cred); 2858 switch (err) { 2859 case 0: 2860 return err; 2861 case -NFS4ERR_RESOURCE: 2862 /* The IBM lawyers misread another document! */ 2863 case -NFS4ERR_DELAY: 2864 err = nfs4_delay(clp->cl_rpcclient, &timeout); 2865 } 2866 } while (err == 0); 2867 return err; 2868 } 2869 2870 struct nfs4_delegreturndata { 2871 struct nfs4_delegreturnargs args; 2872 struct nfs4_delegreturnres res; 2873 struct nfs_fh fh; 2874 nfs4_stateid stateid; 2875 struct rpc_cred *cred; 2876 unsigned long timestamp; 2877 struct nfs_fattr fattr; 2878 int rpc_status; 2879 }; 2880 2881 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *calldata) 2882 { 2883 struct nfs4_delegreturndata *data = calldata; 2884 struct rpc_message msg = { 2885 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN], 2886 .rpc_argp = &data->args, 2887 .rpc_resp = &data->res, 2888 .rpc_cred = data->cred, 2889 }; 2890 nfs_fattr_init(data->res.fattr); 2891 rpc_call_setup(task, &msg, 0); 2892 } 2893 2894 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata) 2895 { 2896 struct nfs4_delegreturndata *data = calldata; 2897 data->rpc_status = task->tk_status; 2898 if (data->rpc_status == 0) 2899 renew_lease(data->res.server, data->timestamp); 2900 } 2901 2902 static void nfs4_delegreturn_release(void *calldata) 2903 { 2904 struct nfs4_delegreturndata *data = calldata; 2905 2906 put_rpccred(data->cred); 2907 kfree(calldata); 2908 } 2909 2910 static const struct rpc_call_ops nfs4_delegreturn_ops = { 2911 .rpc_call_prepare = nfs4_delegreturn_prepare, 2912 .rpc_call_done = nfs4_delegreturn_done, 2913 .rpc_release = nfs4_delegreturn_release, 2914 }; 2915 2916 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid) 2917 { 2918 struct nfs4_delegreturndata *data; 2919 struct nfs_server *server = NFS_SERVER(inode); 2920 struct rpc_task *task; 2921 int status; 2922 2923 data = kmalloc(sizeof(*data), GFP_KERNEL); 2924 if (data == NULL) 2925 return -ENOMEM; 2926 data->args.fhandle = &data->fh; 2927 data->args.stateid = &data->stateid; 2928 data->args.bitmask = server->attr_bitmask; 2929 nfs_copy_fh(&data->fh, NFS_FH(inode)); 2930 memcpy(&data->stateid, stateid, sizeof(data->stateid)); 2931 data->res.fattr = &data->fattr; 2932 data->res.server = server; 2933 data->cred = get_rpccred(cred); 2934 data->timestamp = jiffies; 2935 data->rpc_status = 0; 2936 2937 task = rpc_run_task(NFS_CLIENT(inode), RPC_TASK_ASYNC, &nfs4_delegreturn_ops, data); 2938 if (IS_ERR(task)) 2939 return PTR_ERR(task); 2940 status = nfs4_wait_for_completion_rpc_task(task); 2941 if (status == 0) { 2942 status = data->rpc_status; 2943 if (status == 0) 2944 nfs_post_op_update_inode(inode, &data->fattr); 2945 } 2946 rpc_put_task(task); 2947 return status; 2948 } 2949 2950 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid) 2951 { 2952 struct nfs_server *server = NFS_SERVER(inode); 2953 struct nfs4_exception exception = { }; 2954 int err; 2955 do { 2956 err = _nfs4_proc_delegreturn(inode, cred, stateid); 2957 switch (err) { 2958 case -NFS4ERR_STALE_STATEID: 2959 case -NFS4ERR_EXPIRED: 2960 case 0: 2961 return 0; 2962 } 2963 err = nfs4_handle_exception(server, err, &exception); 2964 } while (exception.retry); 2965 return err; 2966 } 2967 2968 #define NFS4_LOCK_MINTIMEOUT (1 * HZ) 2969 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ) 2970 2971 /* 2972 * sleep, with exponential backoff, and retry the LOCK operation. 2973 */ 2974 static unsigned long 2975 nfs4_set_lock_task_retry(unsigned long timeout) 2976 { 2977 schedule_timeout_interruptible(timeout); 2978 timeout <<= 1; 2979 if (timeout > NFS4_LOCK_MAXTIMEOUT) 2980 return NFS4_LOCK_MAXTIMEOUT; 2981 return timeout; 2982 } 2983 2984 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 2985 { 2986 struct inode *inode = state->inode; 2987 struct nfs_server *server = NFS_SERVER(inode); 2988 struct nfs_client *clp = server->nfs_client; 2989 struct nfs_lockt_args arg = { 2990 .fh = NFS_FH(inode), 2991 .fl = request, 2992 }; 2993 struct nfs_lockt_res res = { 2994 .denied = request, 2995 }; 2996 struct rpc_message msg = { 2997 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT], 2998 .rpc_argp = &arg, 2999 .rpc_resp = &res, 3000 .rpc_cred = state->owner->so_cred, 3001 }; 3002 struct nfs4_lock_state *lsp; 3003 int status; 3004 3005 down_read(&clp->cl_sem); 3006 arg.lock_owner.clientid = clp->cl_clientid; 3007 status = nfs4_set_lock_state(state, request); 3008 if (status != 0) 3009 goto out; 3010 lsp = request->fl_u.nfs4_fl.owner; 3011 arg.lock_owner.id = lsp->ls_id; 3012 status = rpc_call_sync(server->client, &msg, 0); 3013 switch (status) { 3014 case 0: 3015 request->fl_type = F_UNLCK; 3016 break; 3017 case -NFS4ERR_DENIED: 3018 status = 0; 3019 } 3020 request->fl_ops->fl_release_private(request); 3021 out: 3022 up_read(&clp->cl_sem); 3023 return status; 3024 } 3025 3026 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3027 { 3028 struct nfs4_exception exception = { }; 3029 int err; 3030 3031 do { 3032 err = nfs4_handle_exception(NFS_SERVER(state->inode), 3033 _nfs4_proc_getlk(state, cmd, request), 3034 &exception); 3035 } while (exception.retry); 3036 return err; 3037 } 3038 3039 static int do_vfs_lock(struct file *file, struct file_lock *fl) 3040 { 3041 int res = 0; 3042 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 3043 case FL_POSIX: 3044 res = posix_lock_file_wait(file, fl); 3045 break; 3046 case FL_FLOCK: 3047 res = flock_lock_file_wait(file, fl); 3048 break; 3049 default: 3050 BUG(); 3051 } 3052 return res; 3053 } 3054 3055 struct nfs4_unlockdata { 3056 struct nfs_locku_args arg; 3057 struct nfs_locku_res res; 3058 struct nfs4_lock_state *lsp; 3059 struct nfs_open_context *ctx; 3060 struct file_lock fl; 3061 const struct nfs_server *server; 3062 unsigned long timestamp; 3063 }; 3064 3065 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, 3066 struct nfs_open_context *ctx, 3067 struct nfs4_lock_state *lsp, 3068 struct nfs_seqid *seqid) 3069 { 3070 struct nfs4_unlockdata *p; 3071 struct inode *inode = lsp->ls_state->inode; 3072 3073 p = kmalloc(sizeof(*p), GFP_KERNEL); 3074 if (p == NULL) 3075 return NULL; 3076 p->arg.fh = NFS_FH(inode); 3077 p->arg.fl = &p->fl; 3078 p->arg.seqid = seqid; 3079 p->arg.stateid = &lsp->ls_stateid; 3080 p->lsp = lsp; 3081 atomic_inc(&lsp->ls_count); 3082 /* Ensure we don't close file until we're done freeing locks! */ 3083 p->ctx = get_nfs_open_context(ctx); 3084 memcpy(&p->fl, fl, sizeof(p->fl)); 3085 p->server = NFS_SERVER(inode); 3086 return p; 3087 } 3088 3089 static void nfs4_locku_release_calldata(void *data) 3090 { 3091 struct nfs4_unlockdata *calldata = data; 3092 nfs_free_seqid(calldata->arg.seqid); 3093 nfs4_put_lock_state(calldata->lsp); 3094 put_nfs_open_context(calldata->ctx); 3095 kfree(calldata); 3096 } 3097 3098 static void nfs4_locku_done(struct rpc_task *task, void *data) 3099 { 3100 struct nfs4_unlockdata *calldata = data; 3101 3102 if (RPC_ASSASSINATED(task)) 3103 return; 3104 nfs_increment_lock_seqid(task->tk_status, calldata->arg.seqid); 3105 switch (task->tk_status) { 3106 case 0: 3107 memcpy(calldata->lsp->ls_stateid.data, 3108 calldata->res.stateid.data, 3109 sizeof(calldata->lsp->ls_stateid.data)); 3110 renew_lease(calldata->server, calldata->timestamp); 3111 break; 3112 case -NFS4ERR_STALE_STATEID: 3113 case -NFS4ERR_EXPIRED: 3114 break; 3115 default: 3116 if (nfs4_async_handle_error(task, calldata->server) == -EAGAIN) 3117 rpc_restart_call(task); 3118 } 3119 } 3120 3121 static void nfs4_locku_prepare(struct rpc_task *task, void *data) 3122 { 3123 struct nfs4_unlockdata *calldata = data; 3124 struct rpc_message msg = { 3125 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU], 3126 .rpc_argp = &calldata->arg, 3127 .rpc_resp = &calldata->res, 3128 .rpc_cred = calldata->lsp->ls_state->owner->so_cred, 3129 }; 3130 3131 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) 3132 return; 3133 if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) { 3134 /* Note: exit _without_ running nfs4_locku_done */ 3135 task->tk_action = NULL; 3136 return; 3137 } 3138 calldata->timestamp = jiffies; 3139 rpc_call_setup(task, &msg, 0); 3140 } 3141 3142 static const struct rpc_call_ops nfs4_locku_ops = { 3143 .rpc_call_prepare = nfs4_locku_prepare, 3144 .rpc_call_done = nfs4_locku_done, 3145 .rpc_release = nfs4_locku_release_calldata, 3146 }; 3147 3148 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl, 3149 struct nfs_open_context *ctx, 3150 struct nfs4_lock_state *lsp, 3151 struct nfs_seqid *seqid) 3152 { 3153 struct nfs4_unlockdata *data; 3154 3155 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid); 3156 if (data == NULL) { 3157 nfs_free_seqid(seqid); 3158 return ERR_PTR(-ENOMEM); 3159 } 3160 3161 return rpc_run_task(NFS_CLIENT(lsp->ls_state->inode), RPC_TASK_ASYNC, &nfs4_locku_ops, data); 3162 } 3163 3164 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request) 3165 { 3166 struct nfs_seqid *seqid; 3167 struct nfs4_lock_state *lsp; 3168 struct rpc_task *task; 3169 int status = 0; 3170 3171 status = nfs4_set_lock_state(state, request); 3172 /* Unlock _before_ we do the RPC call */ 3173 request->fl_flags |= FL_EXISTS; 3174 if (do_vfs_lock(request->fl_file, request) == -ENOENT) 3175 goto out; 3176 if (status != 0) 3177 goto out; 3178 /* Is this a delegated lock? */ 3179 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) 3180 goto out; 3181 lsp = request->fl_u.nfs4_fl.owner; 3182 seqid = nfs_alloc_seqid(&lsp->ls_seqid); 3183 status = -ENOMEM; 3184 if (seqid == NULL) 3185 goto out; 3186 task = nfs4_do_unlck(request, request->fl_file->private_data, lsp, seqid); 3187 status = PTR_ERR(task); 3188 if (IS_ERR(task)) 3189 goto out; 3190 status = nfs4_wait_for_completion_rpc_task(task); 3191 rpc_put_task(task); 3192 out: 3193 return status; 3194 } 3195 3196 struct nfs4_lockdata { 3197 struct nfs_lock_args arg; 3198 struct nfs_lock_res res; 3199 struct nfs4_lock_state *lsp; 3200 struct nfs_open_context *ctx; 3201 struct file_lock fl; 3202 unsigned long timestamp; 3203 int rpc_status; 3204 int cancelled; 3205 }; 3206 3207 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, 3208 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp) 3209 { 3210 struct nfs4_lockdata *p; 3211 struct inode *inode = lsp->ls_state->inode; 3212 struct nfs_server *server = NFS_SERVER(inode); 3213 3214 p = kzalloc(sizeof(*p), GFP_KERNEL); 3215 if (p == NULL) 3216 return NULL; 3217 3218 p->arg.fh = NFS_FH(inode); 3219 p->arg.fl = &p->fl; 3220 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid); 3221 if (p->arg.lock_seqid == NULL) 3222 goto out_free; 3223 p->arg.lock_stateid = &lsp->ls_stateid; 3224 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; 3225 p->arg.lock_owner.id = lsp->ls_id; 3226 p->lsp = lsp; 3227 atomic_inc(&lsp->ls_count); 3228 p->ctx = get_nfs_open_context(ctx); 3229 memcpy(&p->fl, fl, sizeof(p->fl)); 3230 return p; 3231 out_free: 3232 kfree(p); 3233 return NULL; 3234 } 3235 3236 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) 3237 { 3238 struct nfs4_lockdata *data = calldata; 3239 struct nfs4_state *state = data->lsp->ls_state; 3240 struct nfs4_state_owner *sp = state->owner; 3241 struct rpc_message msg = { 3242 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK], 3243 .rpc_argp = &data->arg, 3244 .rpc_resp = &data->res, 3245 .rpc_cred = sp->so_cred, 3246 }; 3247 3248 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 3249 return; 3250 dprintk("%s: begin!\n", __FUNCTION__); 3251 /* Do we need to do an open_to_lock_owner? */ 3252 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) { 3253 data->arg.open_seqid = nfs_alloc_seqid(&sp->so_seqid); 3254 if (data->arg.open_seqid == NULL) { 3255 data->rpc_status = -ENOMEM; 3256 task->tk_action = NULL; 3257 goto out; 3258 } 3259 data->arg.open_stateid = &state->stateid; 3260 data->arg.new_lock_owner = 1; 3261 } 3262 data->timestamp = jiffies; 3263 rpc_call_setup(task, &msg, 0); 3264 out: 3265 dprintk("%s: done!, ret = %d\n", __FUNCTION__, data->rpc_status); 3266 } 3267 3268 static void nfs4_lock_done(struct rpc_task *task, void *calldata) 3269 { 3270 struct nfs4_lockdata *data = calldata; 3271 3272 dprintk("%s: begin!\n", __FUNCTION__); 3273 3274 data->rpc_status = task->tk_status; 3275 if (RPC_ASSASSINATED(task)) 3276 goto out; 3277 if (data->arg.new_lock_owner != 0) { 3278 nfs_increment_open_seqid(data->rpc_status, data->arg.open_seqid); 3279 if (data->rpc_status == 0) 3280 nfs_confirm_seqid(&data->lsp->ls_seqid, 0); 3281 else 3282 goto out; 3283 } 3284 if (data->rpc_status == 0) { 3285 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data, 3286 sizeof(data->lsp->ls_stateid.data)); 3287 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED; 3288 renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp); 3289 } 3290 nfs_increment_lock_seqid(data->rpc_status, data->arg.lock_seqid); 3291 out: 3292 dprintk("%s: done, ret = %d!\n", __FUNCTION__, data->rpc_status); 3293 } 3294 3295 static void nfs4_lock_release(void *calldata) 3296 { 3297 struct nfs4_lockdata *data = calldata; 3298 3299 dprintk("%s: begin!\n", __FUNCTION__); 3300 if (data->arg.open_seqid != NULL) 3301 nfs_free_seqid(data->arg.open_seqid); 3302 if (data->cancelled != 0) { 3303 struct rpc_task *task; 3304 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, 3305 data->arg.lock_seqid); 3306 if (!IS_ERR(task)) 3307 rpc_put_task(task); 3308 dprintk("%s: cancelling lock!\n", __FUNCTION__); 3309 } else 3310 nfs_free_seqid(data->arg.lock_seqid); 3311 nfs4_put_lock_state(data->lsp); 3312 put_nfs_open_context(data->ctx); 3313 kfree(data); 3314 dprintk("%s: done!\n", __FUNCTION__); 3315 } 3316 3317 static const struct rpc_call_ops nfs4_lock_ops = { 3318 .rpc_call_prepare = nfs4_lock_prepare, 3319 .rpc_call_done = nfs4_lock_done, 3320 .rpc_release = nfs4_lock_release, 3321 }; 3322 3323 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int reclaim) 3324 { 3325 struct nfs4_lockdata *data; 3326 struct rpc_task *task; 3327 int ret; 3328 3329 dprintk("%s: begin!\n", __FUNCTION__); 3330 data = nfs4_alloc_lockdata(fl, fl->fl_file->private_data, 3331 fl->fl_u.nfs4_fl.owner); 3332 if (data == NULL) 3333 return -ENOMEM; 3334 if (IS_SETLKW(cmd)) 3335 data->arg.block = 1; 3336 if (reclaim != 0) 3337 data->arg.reclaim = 1; 3338 task = rpc_run_task(NFS_CLIENT(state->inode), RPC_TASK_ASYNC, 3339 &nfs4_lock_ops, data); 3340 if (IS_ERR(task)) 3341 return PTR_ERR(task); 3342 ret = nfs4_wait_for_completion_rpc_task(task); 3343 if (ret == 0) { 3344 ret = data->rpc_status; 3345 if (ret == -NFS4ERR_DENIED) 3346 ret = -EAGAIN; 3347 } else 3348 data->cancelled = 1; 3349 rpc_put_task(task); 3350 dprintk("%s: done, ret = %d!\n", __FUNCTION__, ret); 3351 return ret; 3352 } 3353 3354 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request) 3355 { 3356 struct nfs_server *server = NFS_SERVER(state->inode); 3357 struct nfs4_exception exception = { }; 3358 int err; 3359 3360 do { 3361 /* Cache the lock if possible... */ 3362 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 3363 return 0; 3364 err = _nfs4_do_setlk(state, F_SETLK, request, 1); 3365 if (err != -NFS4ERR_DELAY) 3366 break; 3367 nfs4_handle_exception(server, err, &exception); 3368 } while (exception.retry); 3369 return err; 3370 } 3371 3372 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request) 3373 { 3374 struct nfs_server *server = NFS_SERVER(state->inode); 3375 struct nfs4_exception exception = { }; 3376 int err; 3377 3378 err = nfs4_set_lock_state(state, request); 3379 if (err != 0) 3380 return err; 3381 do { 3382 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) 3383 return 0; 3384 err = _nfs4_do_setlk(state, F_SETLK, request, 0); 3385 if (err != -NFS4ERR_DELAY) 3386 break; 3387 nfs4_handle_exception(server, err, &exception); 3388 } while (exception.retry); 3389 return err; 3390 } 3391 3392 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3393 { 3394 struct nfs_client *clp = state->owner->so_client; 3395 unsigned char fl_flags = request->fl_flags; 3396 int status; 3397 3398 /* Is this a delegated open? */ 3399 status = nfs4_set_lock_state(state, request); 3400 if (status != 0) 3401 goto out; 3402 request->fl_flags |= FL_ACCESS; 3403 status = do_vfs_lock(request->fl_file, request); 3404 if (status < 0) 3405 goto out; 3406 down_read(&clp->cl_sem); 3407 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 3408 struct nfs_inode *nfsi = NFS_I(state->inode); 3409 /* Yes: cache locks! */ 3410 down_read(&nfsi->rwsem); 3411 /* ...but avoid races with delegation recall... */ 3412 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { 3413 request->fl_flags = fl_flags & ~FL_SLEEP; 3414 status = do_vfs_lock(request->fl_file, request); 3415 up_read(&nfsi->rwsem); 3416 goto out_unlock; 3417 } 3418 up_read(&nfsi->rwsem); 3419 } 3420 status = _nfs4_do_setlk(state, cmd, request, 0); 3421 if (status != 0) 3422 goto out_unlock; 3423 /* Note: we always want to sleep here! */ 3424 request->fl_flags = fl_flags | FL_SLEEP; 3425 if (do_vfs_lock(request->fl_file, request) < 0) 3426 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __FUNCTION__); 3427 out_unlock: 3428 up_read(&clp->cl_sem); 3429 out: 3430 request->fl_flags = fl_flags; 3431 return status; 3432 } 3433 3434 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request) 3435 { 3436 struct nfs4_exception exception = { }; 3437 int err; 3438 3439 do { 3440 err = nfs4_handle_exception(NFS_SERVER(state->inode), 3441 _nfs4_proc_setlk(state, cmd, request), 3442 &exception); 3443 } while (exception.retry); 3444 return err; 3445 } 3446 3447 static int 3448 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) 3449 { 3450 struct nfs_open_context *ctx; 3451 struct nfs4_state *state; 3452 unsigned long timeout = NFS4_LOCK_MINTIMEOUT; 3453 int status; 3454 3455 /* verify open state */ 3456 ctx = (struct nfs_open_context *)filp->private_data; 3457 state = ctx->state; 3458 3459 if (request->fl_start < 0 || request->fl_end < 0) 3460 return -EINVAL; 3461 3462 if (IS_GETLK(cmd)) 3463 return nfs4_proc_getlk(state, F_GETLK, request); 3464 3465 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd))) 3466 return -EINVAL; 3467 3468 if (request->fl_type == F_UNLCK) 3469 return nfs4_proc_unlck(state, cmd, request); 3470 3471 do { 3472 status = nfs4_proc_setlk(state, cmd, request); 3473 if ((status != -EAGAIN) || IS_SETLK(cmd)) 3474 break; 3475 timeout = nfs4_set_lock_task_retry(timeout); 3476 status = -ERESTARTSYS; 3477 if (signalled()) 3478 break; 3479 } while(status < 0); 3480 return status; 3481 } 3482 3483 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl) 3484 { 3485 struct nfs_server *server = NFS_SERVER(state->inode); 3486 struct nfs4_exception exception = { }; 3487 int err; 3488 3489 err = nfs4_set_lock_state(state, fl); 3490 if (err != 0) 3491 goto out; 3492 do { 3493 err = _nfs4_do_setlk(state, F_SETLK, fl, 0); 3494 if (err != -NFS4ERR_DELAY) 3495 break; 3496 err = nfs4_handle_exception(server, err, &exception); 3497 } while (exception.retry); 3498 out: 3499 return err; 3500 } 3501 3502 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl" 3503 3504 int nfs4_setxattr(struct dentry *dentry, const char *key, const void *buf, 3505 size_t buflen, int flags) 3506 { 3507 struct inode *inode = dentry->d_inode; 3508 3509 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0) 3510 return -EOPNOTSUPP; 3511 3512 if (!S_ISREG(inode->i_mode) && 3513 (!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX)) 3514 return -EPERM; 3515 3516 return nfs4_proc_set_acl(inode, buf, buflen); 3517 } 3518 3519 /* The getxattr man page suggests returning -ENODATA for unknown attributes, 3520 * and that's what we'll do for e.g. user attributes that haven't been set. 3521 * But we'll follow ext2/ext3's lead by returning -EOPNOTSUPP for unsupported 3522 * attributes in kernel-managed attribute namespaces. */ 3523 ssize_t nfs4_getxattr(struct dentry *dentry, const char *key, void *buf, 3524 size_t buflen) 3525 { 3526 struct inode *inode = dentry->d_inode; 3527 3528 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0) 3529 return -EOPNOTSUPP; 3530 3531 return nfs4_proc_get_acl(inode, buf, buflen); 3532 } 3533 3534 ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen) 3535 { 3536 size_t len = strlen(XATTR_NAME_NFSV4_ACL) + 1; 3537 3538 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 3539 return 0; 3540 if (buf && buflen < len) 3541 return -ERANGE; 3542 if (buf) 3543 memcpy(buf, XATTR_NAME_NFSV4_ACL, len); 3544 return len; 3545 } 3546 3547 int nfs4_proc_fs_locations(struct inode *dir, struct qstr *name, 3548 struct nfs4_fs_locations *fs_locations, struct page *page) 3549 { 3550 struct nfs_server *server = NFS_SERVER(dir); 3551 u32 bitmask[2] = { 3552 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS, 3553 [1] = FATTR4_WORD1_MOUNTED_ON_FILEID, 3554 }; 3555 struct nfs4_fs_locations_arg args = { 3556 .dir_fh = NFS_FH(dir), 3557 .name = name, 3558 .page = page, 3559 .bitmask = bitmask, 3560 }; 3561 struct rpc_message msg = { 3562 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS], 3563 .rpc_argp = &args, 3564 .rpc_resp = fs_locations, 3565 }; 3566 int status; 3567 3568 dprintk("%s: start\n", __FUNCTION__); 3569 nfs_fattr_init(&fs_locations->fattr); 3570 fs_locations->server = server; 3571 fs_locations->nlocations = 0; 3572 status = rpc_call_sync(server->client, &msg, 0); 3573 dprintk("%s: returned status = %d\n", __FUNCTION__, status); 3574 return status; 3575 } 3576 3577 struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = { 3578 .recover_open = nfs4_open_reclaim, 3579 .recover_lock = nfs4_lock_reclaim, 3580 }; 3581 3582 struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops = { 3583 .recover_open = nfs4_open_expired, 3584 .recover_lock = nfs4_lock_expired, 3585 }; 3586 3587 static const struct inode_operations nfs4_file_inode_operations = { 3588 .permission = nfs_permission, 3589 .getattr = nfs_getattr, 3590 .setattr = nfs_setattr, 3591 .getxattr = nfs4_getxattr, 3592 .setxattr = nfs4_setxattr, 3593 .listxattr = nfs4_listxattr, 3594 }; 3595 3596 const struct nfs_rpc_ops nfs_v4_clientops = { 3597 .version = 4, /* protocol version */ 3598 .dentry_ops = &nfs4_dentry_operations, 3599 .dir_inode_ops = &nfs4_dir_inode_operations, 3600 .file_inode_ops = &nfs4_file_inode_operations, 3601 .getroot = nfs4_proc_get_root, 3602 .getattr = nfs4_proc_getattr, 3603 .setattr = nfs4_proc_setattr, 3604 .lookupfh = nfs4_proc_lookupfh, 3605 .lookup = nfs4_proc_lookup, 3606 .access = nfs4_proc_access, 3607 .readlink = nfs4_proc_readlink, 3608 .create = nfs4_proc_create, 3609 .remove = nfs4_proc_remove, 3610 .unlink_setup = nfs4_proc_unlink_setup, 3611 .unlink_done = nfs4_proc_unlink_done, 3612 .rename = nfs4_proc_rename, 3613 .link = nfs4_proc_link, 3614 .symlink = nfs4_proc_symlink, 3615 .mkdir = nfs4_proc_mkdir, 3616 .rmdir = nfs4_proc_remove, 3617 .readdir = nfs4_proc_readdir, 3618 .mknod = nfs4_proc_mknod, 3619 .statfs = nfs4_proc_statfs, 3620 .fsinfo = nfs4_proc_fsinfo, 3621 .pathconf = nfs4_proc_pathconf, 3622 .set_capabilities = nfs4_server_capabilities, 3623 .decode_dirent = nfs4_decode_dirent, 3624 .read_setup = nfs4_proc_read_setup, 3625 .read_done = nfs4_read_done, 3626 .write_setup = nfs4_proc_write_setup, 3627 .write_done = nfs4_write_done, 3628 .commit_setup = nfs4_proc_commit_setup, 3629 .commit_done = nfs4_commit_done, 3630 .file_open = nfs_open, 3631 .file_release = nfs_release, 3632 .lock = nfs4_proc_lock, 3633 .clear_acl_cache = nfs4_zap_acl_attr, 3634 }; 3635 3636 /* 3637 * Local variables: 3638 * c-basic-offset: 8 3639 * End: 3640 */ 3641