1 /* 2 * Copyright (c) 2001 The Regents of the University of Michigan. 3 * All rights reserved. 4 * 5 * Kendrick Smith <kmsmith@umich.edu> 6 * Andy Adamson <kandros@umich.edu> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 28 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 */ 34 35 #include <linux/file.h> 36 #include <linux/fs.h> 37 #include <linux/slab.h> 38 #include <linux/namei.h> 39 #include <linux/swap.h> 40 #include <linux/pagemap.h> 41 #include <linux/ratelimit.h> 42 #include <linux/sunrpc/svcauth_gss.h> 43 #include <linux/sunrpc/addr.h> 44 #include <linux/jhash.h> 45 #include "xdr4.h" 46 #include "xdr4cb.h" 47 #include "vfs.h" 48 #include "current_stateid.h" 49 50 #include "netns.h" 51 #include "pnfs.h" 52 53 #define NFSDDBG_FACILITY NFSDDBG_PROC 54 55 #define all_ones {{~0,~0},~0} 56 static const stateid_t one_stateid = { 57 .si_generation = ~0, 58 .si_opaque = all_ones, 59 }; 60 static const stateid_t zero_stateid = { 61 /* all fields zero */ 62 }; 63 static const stateid_t currentstateid = { 64 .si_generation = 1, 65 }; 66 67 static u64 current_sessionid = 1; 68 69 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t))) 70 #define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t))) 71 #define CURRENT_STATEID(stateid) (!memcmp((stateid), ¤tstateid, sizeof(stateid_t))) 72 73 /* forward declarations */ 74 static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner); 75 static void nfs4_free_ol_stateid(struct nfs4_stid *stid); 76 77 /* Locking: */ 78 79 /* 80 * Currently used for the del_recall_lru and file hash table. In an 81 * effort to decrease the scope of the client_mutex, this spinlock may 82 * eventually cover more: 83 */ 84 static DEFINE_SPINLOCK(state_lock); 85 86 /* 87 * A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for 88 * the refcount on the open stateid to drop. 89 */ 90 static DECLARE_WAIT_QUEUE_HEAD(close_wq); 91 92 static struct kmem_cache *openowner_slab; 93 static struct kmem_cache *lockowner_slab; 94 static struct kmem_cache *file_slab; 95 static struct kmem_cache *stateid_slab; 96 static struct kmem_cache *deleg_slab; 97 static struct kmem_cache *odstate_slab; 98 99 static void free_session(struct nfsd4_session *); 100 101 static const struct nfsd4_callback_ops nfsd4_cb_recall_ops; 102 static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops; 103 104 static bool is_session_dead(struct nfsd4_session *ses) 105 { 106 return ses->se_flags & NFS4_SESSION_DEAD; 107 } 108 109 static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me) 110 { 111 if (atomic_read(&ses->se_ref) > ref_held_by_me) 112 return nfserr_jukebox; 113 ses->se_flags |= NFS4_SESSION_DEAD; 114 return nfs_ok; 115 } 116 117 static bool is_client_expired(struct nfs4_client *clp) 118 { 119 return clp->cl_time == 0; 120 } 121 122 static __be32 get_client_locked(struct nfs4_client *clp) 123 { 124 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 125 126 lockdep_assert_held(&nn->client_lock); 127 128 if (is_client_expired(clp)) 129 return nfserr_expired; 130 atomic_inc(&clp->cl_refcount); 131 return nfs_ok; 132 } 133 134 /* must be called under the client_lock */ 135 static inline void 136 renew_client_locked(struct nfs4_client *clp) 137 { 138 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 139 140 if (is_client_expired(clp)) { 141 WARN_ON(1); 142 printk("%s: client (clientid %08x/%08x) already expired\n", 143 __func__, 144 clp->cl_clientid.cl_boot, 145 clp->cl_clientid.cl_id); 146 return; 147 } 148 149 dprintk("renewing client (clientid %08x/%08x)\n", 150 clp->cl_clientid.cl_boot, 151 clp->cl_clientid.cl_id); 152 list_move_tail(&clp->cl_lru, &nn->client_lru); 153 clp->cl_time = get_seconds(); 154 } 155 156 static void put_client_renew_locked(struct nfs4_client *clp) 157 { 158 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 159 160 lockdep_assert_held(&nn->client_lock); 161 162 if (!atomic_dec_and_test(&clp->cl_refcount)) 163 return; 164 if (!is_client_expired(clp)) 165 renew_client_locked(clp); 166 } 167 168 static void put_client_renew(struct nfs4_client *clp) 169 { 170 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 171 172 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock)) 173 return; 174 if (!is_client_expired(clp)) 175 renew_client_locked(clp); 176 spin_unlock(&nn->client_lock); 177 } 178 179 static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses) 180 { 181 __be32 status; 182 183 if (is_session_dead(ses)) 184 return nfserr_badsession; 185 status = get_client_locked(ses->se_client); 186 if (status) 187 return status; 188 atomic_inc(&ses->se_ref); 189 return nfs_ok; 190 } 191 192 static void nfsd4_put_session_locked(struct nfsd4_session *ses) 193 { 194 struct nfs4_client *clp = ses->se_client; 195 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 196 197 lockdep_assert_held(&nn->client_lock); 198 199 if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses)) 200 free_session(ses); 201 put_client_renew_locked(clp); 202 } 203 204 static void nfsd4_put_session(struct nfsd4_session *ses) 205 { 206 struct nfs4_client *clp = ses->se_client; 207 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 208 209 spin_lock(&nn->client_lock); 210 nfsd4_put_session_locked(ses); 211 spin_unlock(&nn->client_lock); 212 } 213 214 static struct nfsd4_blocked_lock * 215 find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh, 216 struct nfsd_net *nn) 217 { 218 struct nfsd4_blocked_lock *cur, *found = NULL; 219 220 spin_lock(&nn->blocked_locks_lock); 221 list_for_each_entry(cur, &lo->lo_blocked, nbl_list) { 222 if (fh_match(fh, &cur->nbl_fh)) { 223 list_del_init(&cur->nbl_list); 224 list_del_init(&cur->nbl_lru); 225 found = cur; 226 break; 227 } 228 } 229 spin_unlock(&nn->blocked_locks_lock); 230 if (found) 231 posix_unblock_lock(&found->nbl_lock); 232 return found; 233 } 234 235 static struct nfsd4_blocked_lock * 236 find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh, 237 struct nfsd_net *nn) 238 { 239 struct nfsd4_blocked_lock *nbl; 240 241 nbl = find_blocked_lock(lo, fh, nn); 242 if (!nbl) { 243 nbl= kmalloc(sizeof(*nbl), GFP_KERNEL); 244 if (nbl) { 245 fh_copy_shallow(&nbl->nbl_fh, fh); 246 locks_init_lock(&nbl->nbl_lock); 247 nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client, 248 &nfsd4_cb_notify_lock_ops, 249 NFSPROC4_CLNT_CB_NOTIFY_LOCK); 250 } 251 } 252 return nbl; 253 } 254 255 static void 256 free_blocked_lock(struct nfsd4_blocked_lock *nbl) 257 { 258 locks_release_private(&nbl->nbl_lock); 259 kfree(nbl); 260 } 261 262 static int 263 nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task) 264 { 265 /* 266 * Since this is just an optimization, we don't try very hard if it 267 * turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and 268 * just quit trying on anything else. 269 */ 270 switch (task->tk_status) { 271 case -NFS4ERR_DELAY: 272 rpc_delay(task, 1 * HZ); 273 return 0; 274 default: 275 return 1; 276 } 277 } 278 279 static void 280 nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb) 281 { 282 struct nfsd4_blocked_lock *nbl = container_of(cb, 283 struct nfsd4_blocked_lock, nbl_cb); 284 285 free_blocked_lock(nbl); 286 } 287 288 static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = { 289 .done = nfsd4_cb_notify_lock_done, 290 .release = nfsd4_cb_notify_lock_release, 291 }; 292 293 static inline struct nfs4_stateowner * 294 nfs4_get_stateowner(struct nfs4_stateowner *sop) 295 { 296 atomic_inc(&sop->so_count); 297 return sop; 298 } 299 300 static int 301 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner) 302 { 303 return (sop->so_owner.len == owner->len) && 304 0 == memcmp(sop->so_owner.data, owner->data, owner->len); 305 } 306 307 static struct nfs4_openowner * 308 find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open, 309 struct nfs4_client *clp) 310 { 311 struct nfs4_stateowner *so; 312 313 lockdep_assert_held(&clp->cl_lock); 314 315 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval], 316 so_strhash) { 317 if (!so->so_is_open_owner) 318 continue; 319 if (same_owner_str(so, &open->op_owner)) 320 return openowner(nfs4_get_stateowner(so)); 321 } 322 return NULL; 323 } 324 325 static struct nfs4_openowner * 326 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open, 327 struct nfs4_client *clp) 328 { 329 struct nfs4_openowner *oo; 330 331 spin_lock(&clp->cl_lock); 332 oo = find_openstateowner_str_locked(hashval, open, clp); 333 spin_unlock(&clp->cl_lock); 334 return oo; 335 } 336 337 static inline u32 338 opaque_hashval(const void *ptr, int nbytes) 339 { 340 unsigned char *cptr = (unsigned char *) ptr; 341 342 u32 x = 0; 343 while (nbytes--) { 344 x *= 37; 345 x += *cptr++; 346 } 347 return x; 348 } 349 350 static void nfsd4_free_file_rcu(struct rcu_head *rcu) 351 { 352 struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu); 353 354 kmem_cache_free(file_slab, fp); 355 } 356 357 void 358 put_nfs4_file(struct nfs4_file *fi) 359 { 360 might_lock(&state_lock); 361 362 if (atomic_dec_and_lock(&fi->fi_ref, &state_lock)) { 363 hlist_del_rcu(&fi->fi_hash); 364 spin_unlock(&state_lock); 365 WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate)); 366 WARN_ON_ONCE(!list_empty(&fi->fi_delegations)); 367 call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu); 368 } 369 } 370 371 static struct file * 372 __nfs4_get_fd(struct nfs4_file *f, int oflag) 373 { 374 if (f->fi_fds[oflag]) 375 return get_file(f->fi_fds[oflag]); 376 return NULL; 377 } 378 379 static struct file * 380 find_writeable_file_locked(struct nfs4_file *f) 381 { 382 struct file *ret; 383 384 lockdep_assert_held(&f->fi_lock); 385 386 ret = __nfs4_get_fd(f, O_WRONLY); 387 if (!ret) 388 ret = __nfs4_get_fd(f, O_RDWR); 389 return ret; 390 } 391 392 static struct file * 393 find_writeable_file(struct nfs4_file *f) 394 { 395 struct file *ret; 396 397 spin_lock(&f->fi_lock); 398 ret = find_writeable_file_locked(f); 399 spin_unlock(&f->fi_lock); 400 401 return ret; 402 } 403 404 static struct file *find_readable_file_locked(struct nfs4_file *f) 405 { 406 struct file *ret; 407 408 lockdep_assert_held(&f->fi_lock); 409 410 ret = __nfs4_get_fd(f, O_RDONLY); 411 if (!ret) 412 ret = __nfs4_get_fd(f, O_RDWR); 413 return ret; 414 } 415 416 static struct file * 417 find_readable_file(struct nfs4_file *f) 418 { 419 struct file *ret; 420 421 spin_lock(&f->fi_lock); 422 ret = find_readable_file_locked(f); 423 spin_unlock(&f->fi_lock); 424 425 return ret; 426 } 427 428 struct file * 429 find_any_file(struct nfs4_file *f) 430 { 431 struct file *ret; 432 433 spin_lock(&f->fi_lock); 434 ret = __nfs4_get_fd(f, O_RDWR); 435 if (!ret) { 436 ret = __nfs4_get_fd(f, O_WRONLY); 437 if (!ret) 438 ret = __nfs4_get_fd(f, O_RDONLY); 439 } 440 spin_unlock(&f->fi_lock); 441 return ret; 442 } 443 444 static atomic_long_t num_delegations; 445 unsigned long max_delegations; 446 447 /* 448 * Open owner state (share locks) 449 */ 450 451 /* hash tables for lock and open owners */ 452 #define OWNER_HASH_BITS 8 453 #define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS) 454 #define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1) 455 456 static unsigned int ownerstr_hashval(struct xdr_netobj *ownername) 457 { 458 unsigned int ret; 459 460 ret = opaque_hashval(ownername->data, ownername->len); 461 return ret & OWNER_HASH_MASK; 462 } 463 464 /* hash table for nfs4_file */ 465 #define FILE_HASH_BITS 8 466 #define FILE_HASH_SIZE (1 << FILE_HASH_BITS) 467 468 static unsigned int nfsd_fh_hashval(struct knfsd_fh *fh) 469 { 470 return jhash2(fh->fh_base.fh_pad, XDR_QUADLEN(fh->fh_size), 0); 471 } 472 473 static unsigned int file_hashval(struct knfsd_fh *fh) 474 { 475 return nfsd_fh_hashval(fh) & (FILE_HASH_SIZE - 1); 476 } 477 478 static struct hlist_head file_hashtbl[FILE_HASH_SIZE]; 479 480 static void 481 __nfs4_file_get_access(struct nfs4_file *fp, u32 access) 482 { 483 lockdep_assert_held(&fp->fi_lock); 484 485 if (access & NFS4_SHARE_ACCESS_WRITE) 486 atomic_inc(&fp->fi_access[O_WRONLY]); 487 if (access & NFS4_SHARE_ACCESS_READ) 488 atomic_inc(&fp->fi_access[O_RDONLY]); 489 } 490 491 static __be32 492 nfs4_file_get_access(struct nfs4_file *fp, u32 access) 493 { 494 lockdep_assert_held(&fp->fi_lock); 495 496 /* Does this access mode make sense? */ 497 if (access & ~NFS4_SHARE_ACCESS_BOTH) 498 return nfserr_inval; 499 500 /* Does it conflict with a deny mode already set? */ 501 if ((access & fp->fi_share_deny) != 0) 502 return nfserr_share_denied; 503 504 __nfs4_file_get_access(fp, access); 505 return nfs_ok; 506 } 507 508 static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny) 509 { 510 /* Common case is that there is no deny mode. */ 511 if (deny) { 512 /* Does this deny mode make sense? */ 513 if (deny & ~NFS4_SHARE_DENY_BOTH) 514 return nfserr_inval; 515 516 if ((deny & NFS4_SHARE_DENY_READ) && 517 atomic_read(&fp->fi_access[O_RDONLY])) 518 return nfserr_share_denied; 519 520 if ((deny & NFS4_SHARE_DENY_WRITE) && 521 atomic_read(&fp->fi_access[O_WRONLY])) 522 return nfserr_share_denied; 523 } 524 return nfs_ok; 525 } 526 527 static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag) 528 { 529 might_lock(&fp->fi_lock); 530 531 if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) { 532 struct file *f1 = NULL; 533 struct file *f2 = NULL; 534 535 swap(f1, fp->fi_fds[oflag]); 536 if (atomic_read(&fp->fi_access[1 - oflag]) == 0) 537 swap(f2, fp->fi_fds[O_RDWR]); 538 spin_unlock(&fp->fi_lock); 539 if (f1) 540 fput(f1); 541 if (f2) 542 fput(f2); 543 } 544 } 545 546 static void nfs4_file_put_access(struct nfs4_file *fp, u32 access) 547 { 548 WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH); 549 550 if (access & NFS4_SHARE_ACCESS_WRITE) 551 __nfs4_file_put_access(fp, O_WRONLY); 552 if (access & NFS4_SHARE_ACCESS_READ) 553 __nfs4_file_put_access(fp, O_RDONLY); 554 } 555 556 /* 557 * Allocate a new open/delegation state counter. This is needed for 558 * pNFS for proper return on close semantics. 559 * 560 * Note that we only allocate it for pNFS-enabled exports, otherwise 561 * all pointers to struct nfs4_clnt_odstate are always NULL. 562 */ 563 static struct nfs4_clnt_odstate * 564 alloc_clnt_odstate(struct nfs4_client *clp) 565 { 566 struct nfs4_clnt_odstate *co; 567 568 co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL); 569 if (co) { 570 co->co_client = clp; 571 atomic_set(&co->co_odcount, 1); 572 } 573 return co; 574 } 575 576 static void 577 hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co) 578 { 579 struct nfs4_file *fp = co->co_file; 580 581 lockdep_assert_held(&fp->fi_lock); 582 list_add(&co->co_perfile, &fp->fi_clnt_odstate); 583 } 584 585 static inline void 586 get_clnt_odstate(struct nfs4_clnt_odstate *co) 587 { 588 if (co) 589 atomic_inc(&co->co_odcount); 590 } 591 592 static void 593 put_clnt_odstate(struct nfs4_clnt_odstate *co) 594 { 595 struct nfs4_file *fp; 596 597 if (!co) 598 return; 599 600 fp = co->co_file; 601 if (atomic_dec_and_lock(&co->co_odcount, &fp->fi_lock)) { 602 list_del(&co->co_perfile); 603 spin_unlock(&fp->fi_lock); 604 605 nfsd4_return_all_file_layouts(co->co_client, fp); 606 kmem_cache_free(odstate_slab, co); 607 } 608 } 609 610 static struct nfs4_clnt_odstate * 611 find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new) 612 { 613 struct nfs4_clnt_odstate *co; 614 struct nfs4_client *cl; 615 616 if (!new) 617 return NULL; 618 619 cl = new->co_client; 620 621 spin_lock(&fp->fi_lock); 622 list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) { 623 if (co->co_client == cl) { 624 get_clnt_odstate(co); 625 goto out; 626 } 627 } 628 co = new; 629 co->co_file = fp; 630 hash_clnt_odstate_locked(new); 631 out: 632 spin_unlock(&fp->fi_lock); 633 return co; 634 } 635 636 struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, 637 struct kmem_cache *slab) 638 { 639 struct nfs4_stid *stid; 640 int new_id; 641 642 stid = kmem_cache_zalloc(slab, GFP_KERNEL); 643 if (!stid) 644 return NULL; 645 646 idr_preload(GFP_KERNEL); 647 spin_lock(&cl->cl_lock); 648 new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 0, 0, GFP_NOWAIT); 649 spin_unlock(&cl->cl_lock); 650 idr_preload_end(); 651 if (new_id < 0) 652 goto out_free; 653 stid->sc_client = cl; 654 stid->sc_stateid.si_opaque.so_id = new_id; 655 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid; 656 /* Will be incremented before return to client: */ 657 atomic_set(&stid->sc_count, 1); 658 spin_lock_init(&stid->sc_lock); 659 660 /* 661 * It shouldn't be a problem to reuse an opaque stateid value. 662 * I don't think it is for 4.1. But with 4.0 I worry that, for 663 * example, a stray write retransmission could be accepted by 664 * the server when it should have been rejected. Therefore, 665 * adopt a trick from the sctp code to attempt to maximize the 666 * amount of time until an id is reused, by ensuring they always 667 * "increase" (mod INT_MAX): 668 */ 669 return stid; 670 out_free: 671 kmem_cache_free(slab, stid); 672 return NULL; 673 } 674 675 static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp) 676 { 677 struct nfs4_stid *stid; 678 struct nfs4_ol_stateid *stp; 679 680 stid = nfs4_alloc_stid(clp, stateid_slab); 681 if (!stid) 682 return NULL; 683 684 stp = openlockstateid(stid); 685 stp->st_stid.sc_free = nfs4_free_ol_stateid; 686 return stp; 687 } 688 689 static void nfs4_free_deleg(struct nfs4_stid *stid) 690 { 691 kmem_cache_free(deleg_slab, stid); 692 atomic_long_dec(&num_delegations); 693 } 694 695 /* 696 * When we recall a delegation, we should be careful not to hand it 697 * out again straight away. 698 * To ensure this we keep a pair of bloom filters ('new' and 'old') 699 * in which the filehandles of recalled delegations are "stored". 700 * If a filehandle appear in either filter, a delegation is blocked. 701 * When a delegation is recalled, the filehandle is stored in the "new" 702 * filter. 703 * Every 30 seconds we swap the filters and clear the "new" one, 704 * unless both are empty of course. 705 * 706 * Each filter is 256 bits. We hash the filehandle to 32bit and use the 707 * low 3 bytes as hash-table indices. 708 * 709 * 'blocked_delegations_lock', which is always taken in block_delegations(), 710 * is used to manage concurrent access. Testing does not need the lock 711 * except when swapping the two filters. 712 */ 713 static DEFINE_SPINLOCK(blocked_delegations_lock); 714 static struct bloom_pair { 715 int entries, old_entries; 716 time_t swap_time; 717 int new; /* index into 'set' */ 718 DECLARE_BITMAP(set[2], 256); 719 } blocked_delegations; 720 721 static int delegation_blocked(struct knfsd_fh *fh) 722 { 723 u32 hash; 724 struct bloom_pair *bd = &blocked_delegations; 725 726 if (bd->entries == 0) 727 return 0; 728 if (seconds_since_boot() - bd->swap_time > 30) { 729 spin_lock(&blocked_delegations_lock); 730 if (seconds_since_boot() - bd->swap_time > 30) { 731 bd->entries -= bd->old_entries; 732 bd->old_entries = bd->entries; 733 memset(bd->set[bd->new], 0, 734 sizeof(bd->set[0])); 735 bd->new = 1-bd->new; 736 bd->swap_time = seconds_since_boot(); 737 } 738 spin_unlock(&blocked_delegations_lock); 739 } 740 hash = jhash(&fh->fh_base, fh->fh_size, 0); 741 if (test_bit(hash&255, bd->set[0]) && 742 test_bit((hash>>8)&255, bd->set[0]) && 743 test_bit((hash>>16)&255, bd->set[0])) 744 return 1; 745 746 if (test_bit(hash&255, bd->set[1]) && 747 test_bit((hash>>8)&255, bd->set[1]) && 748 test_bit((hash>>16)&255, bd->set[1])) 749 return 1; 750 751 return 0; 752 } 753 754 static void block_delegations(struct knfsd_fh *fh) 755 { 756 u32 hash; 757 struct bloom_pair *bd = &blocked_delegations; 758 759 hash = jhash(&fh->fh_base, fh->fh_size, 0); 760 761 spin_lock(&blocked_delegations_lock); 762 __set_bit(hash&255, bd->set[bd->new]); 763 __set_bit((hash>>8)&255, bd->set[bd->new]); 764 __set_bit((hash>>16)&255, bd->set[bd->new]); 765 if (bd->entries == 0) 766 bd->swap_time = seconds_since_boot(); 767 bd->entries += 1; 768 spin_unlock(&blocked_delegations_lock); 769 } 770 771 static struct nfs4_delegation * 772 alloc_init_deleg(struct nfs4_client *clp, struct svc_fh *current_fh, 773 struct nfs4_clnt_odstate *odstate) 774 { 775 struct nfs4_delegation *dp; 776 long n; 777 778 dprintk("NFSD alloc_init_deleg\n"); 779 n = atomic_long_inc_return(&num_delegations); 780 if (n < 0 || n > max_delegations) 781 goto out_dec; 782 if (delegation_blocked(¤t_fh->fh_handle)) 783 goto out_dec; 784 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab)); 785 if (dp == NULL) 786 goto out_dec; 787 788 dp->dl_stid.sc_free = nfs4_free_deleg; 789 /* 790 * delegation seqid's are never incremented. The 4.1 special 791 * meaning of seqid 0 isn't meaningful, really, but let's avoid 792 * 0 anyway just for consistency and use 1: 793 */ 794 dp->dl_stid.sc_stateid.si_generation = 1; 795 INIT_LIST_HEAD(&dp->dl_perfile); 796 INIT_LIST_HEAD(&dp->dl_perclnt); 797 INIT_LIST_HEAD(&dp->dl_recall_lru); 798 dp->dl_clnt_odstate = odstate; 799 get_clnt_odstate(odstate); 800 dp->dl_type = NFS4_OPEN_DELEGATE_READ; 801 dp->dl_retries = 1; 802 nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client, 803 &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL); 804 return dp; 805 out_dec: 806 atomic_long_dec(&num_delegations); 807 return NULL; 808 } 809 810 void 811 nfs4_put_stid(struct nfs4_stid *s) 812 { 813 struct nfs4_file *fp = s->sc_file; 814 struct nfs4_client *clp = s->sc_client; 815 816 might_lock(&clp->cl_lock); 817 818 if (!atomic_dec_and_lock(&s->sc_count, &clp->cl_lock)) { 819 wake_up_all(&close_wq); 820 return; 821 } 822 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id); 823 spin_unlock(&clp->cl_lock); 824 s->sc_free(s); 825 if (fp) 826 put_nfs4_file(fp); 827 } 828 829 void 830 nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid) 831 { 832 stateid_t *src = &stid->sc_stateid; 833 834 spin_lock(&stid->sc_lock); 835 if (unlikely(++src->si_generation == 0)) 836 src->si_generation = 1; 837 memcpy(dst, src, sizeof(*dst)); 838 spin_unlock(&stid->sc_lock); 839 } 840 841 static void nfs4_put_deleg_lease(struct nfs4_file *fp) 842 { 843 struct file *filp = NULL; 844 845 spin_lock(&fp->fi_lock); 846 if (fp->fi_deleg_file && --fp->fi_delegees == 0) 847 swap(filp, fp->fi_deleg_file); 848 spin_unlock(&fp->fi_lock); 849 850 if (filp) { 851 vfs_setlease(filp, F_UNLCK, NULL, (void **)&fp); 852 fput(filp); 853 } 854 } 855 856 void nfs4_unhash_stid(struct nfs4_stid *s) 857 { 858 s->sc_type = 0; 859 } 860 861 /** 862 * nfs4_get_existing_delegation - Discover if this delegation already exists 863 * @clp: a pointer to the nfs4_client we're granting a delegation to 864 * @fp: a pointer to the nfs4_file we're granting a delegation on 865 * 866 * Return: 867 * On success: NULL if an existing delegation was not found. 868 * 869 * On error: -EAGAIN if one was previously granted to this nfs4_client 870 * for this nfs4_file. 871 * 872 */ 873 874 static int 875 nfs4_get_existing_delegation(struct nfs4_client *clp, struct nfs4_file *fp) 876 { 877 struct nfs4_delegation *searchdp = NULL; 878 struct nfs4_client *searchclp = NULL; 879 880 lockdep_assert_held(&state_lock); 881 lockdep_assert_held(&fp->fi_lock); 882 883 list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) { 884 searchclp = searchdp->dl_stid.sc_client; 885 if (clp == searchclp) { 886 return -EAGAIN; 887 } 888 } 889 return 0; 890 } 891 892 /** 893 * hash_delegation_locked - Add a delegation to the appropriate lists 894 * @dp: a pointer to the nfs4_delegation we are adding. 895 * @fp: a pointer to the nfs4_file we're granting a delegation on 896 * 897 * Return: 898 * On success: NULL if the delegation was successfully hashed. 899 * 900 * On error: -EAGAIN if one was previously granted to this 901 * nfs4_client for this nfs4_file. Delegation is not hashed. 902 * 903 */ 904 905 static int 906 hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp) 907 { 908 int status; 909 struct nfs4_client *clp = dp->dl_stid.sc_client; 910 911 lockdep_assert_held(&state_lock); 912 lockdep_assert_held(&fp->fi_lock); 913 914 status = nfs4_get_existing_delegation(clp, fp); 915 if (status) 916 return status; 917 ++fp->fi_delegees; 918 atomic_inc(&dp->dl_stid.sc_count); 919 dp->dl_stid.sc_type = NFS4_DELEG_STID; 920 list_add(&dp->dl_perfile, &fp->fi_delegations); 921 list_add(&dp->dl_perclnt, &clp->cl_delegations); 922 return 0; 923 } 924 925 static bool 926 unhash_delegation_locked(struct nfs4_delegation *dp) 927 { 928 struct nfs4_file *fp = dp->dl_stid.sc_file; 929 930 lockdep_assert_held(&state_lock); 931 932 if (list_empty(&dp->dl_perfile)) 933 return false; 934 935 dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID; 936 /* Ensure that deleg break won't try to requeue it */ 937 ++dp->dl_time; 938 spin_lock(&fp->fi_lock); 939 list_del_init(&dp->dl_perclnt); 940 list_del_init(&dp->dl_recall_lru); 941 list_del_init(&dp->dl_perfile); 942 spin_unlock(&fp->fi_lock); 943 return true; 944 } 945 946 static void destroy_delegation(struct nfs4_delegation *dp) 947 { 948 bool unhashed; 949 950 spin_lock(&state_lock); 951 unhashed = unhash_delegation_locked(dp); 952 spin_unlock(&state_lock); 953 if (unhashed) { 954 put_clnt_odstate(dp->dl_clnt_odstate); 955 nfs4_put_deleg_lease(dp->dl_stid.sc_file); 956 nfs4_put_stid(&dp->dl_stid); 957 } 958 } 959 960 static void revoke_delegation(struct nfs4_delegation *dp) 961 { 962 struct nfs4_client *clp = dp->dl_stid.sc_client; 963 964 WARN_ON(!list_empty(&dp->dl_recall_lru)); 965 966 put_clnt_odstate(dp->dl_clnt_odstate); 967 nfs4_put_deleg_lease(dp->dl_stid.sc_file); 968 969 if (clp->cl_minorversion == 0) 970 nfs4_put_stid(&dp->dl_stid); 971 else { 972 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID; 973 spin_lock(&clp->cl_lock); 974 list_add(&dp->dl_recall_lru, &clp->cl_revoked); 975 spin_unlock(&clp->cl_lock); 976 } 977 } 978 979 /* 980 * SETCLIENTID state 981 */ 982 983 static unsigned int clientid_hashval(u32 id) 984 { 985 return id & CLIENT_HASH_MASK; 986 } 987 988 static unsigned int clientstr_hashval(const char *name) 989 { 990 return opaque_hashval(name, 8) & CLIENT_HASH_MASK; 991 } 992 993 /* 994 * We store the NONE, READ, WRITE, and BOTH bits separately in the 995 * st_{access,deny}_bmap field of the stateid, in order to track not 996 * only what share bits are currently in force, but also what 997 * combinations of share bits previous opens have used. This allows us 998 * to enforce the recommendation of rfc 3530 14.2.19 that the server 999 * return an error if the client attempt to downgrade to a combination 1000 * of share bits not explicable by closing some of its previous opens. 1001 * 1002 * XXX: This enforcement is actually incomplete, since we don't keep 1003 * track of access/deny bit combinations; so, e.g., we allow: 1004 * 1005 * OPEN allow read, deny write 1006 * OPEN allow both, deny none 1007 * DOWNGRADE allow read, deny none 1008 * 1009 * which we should reject. 1010 */ 1011 static unsigned int 1012 bmap_to_share_mode(unsigned long bmap) { 1013 int i; 1014 unsigned int access = 0; 1015 1016 for (i = 1; i < 4; i++) { 1017 if (test_bit(i, &bmap)) 1018 access |= i; 1019 } 1020 return access; 1021 } 1022 1023 /* set share access for a given stateid */ 1024 static inline void 1025 set_access(u32 access, struct nfs4_ol_stateid *stp) 1026 { 1027 unsigned char mask = 1 << access; 1028 1029 WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH); 1030 stp->st_access_bmap |= mask; 1031 } 1032 1033 /* clear share access for a given stateid */ 1034 static inline void 1035 clear_access(u32 access, struct nfs4_ol_stateid *stp) 1036 { 1037 unsigned char mask = 1 << access; 1038 1039 WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH); 1040 stp->st_access_bmap &= ~mask; 1041 } 1042 1043 /* test whether a given stateid has access */ 1044 static inline bool 1045 test_access(u32 access, struct nfs4_ol_stateid *stp) 1046 { 1047 unsigned char mask = 1 << access; 1048 1049 return (bool)(stp->st_access_bmap & mask); 1050 } 1051 1052 /* set share deny for a given stateid */ 1053 static inline void 1054 set_deny(u32 deny, struct nfs4_ol_stateid *stp) 1055 { 1056 unsigned char mask = 1 << deny; 1057 1058 WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH); 1059 stp->st_deny_bmap |= mask; 1060 } 1061 1062 /* clear share deny for a given stateid */ 1063 static inline void 1064 clear_deny(u32 deny, struct nfs4_ol_stateid *stp) 1065 { 1066 unsigned char mask = 1 << deny; 1067 1068 WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH); 1069 stp->st_deny_bmap &= ~mask; 1070 } 1071 1072 /* test whether a given stateid is denying specific access */ 1073 static inline bool 1074 test_deny(u32 deny, struct nfs4_ol_stateid *stp) 1075 { 1076 unsigned char mask = 1 << deny; 1077 1078 return (bool)(stp->st_deny_bmap & mask); 1079 } 1080 1081 static int nfs4_access_to_omode(u32 access) 1082 { 1083 switch (access & NFS4_SHARE_ACCESS_BOTH) { 1084 case NFS4_SHARE_ACCESS_READ: 1085 return O_RDONLY; 1086 case NFS4_SHARE_ACCESS_WRITE: 1087 return O_WRONLY; 1088 case NFS4_SHARE_ACCESS_BOTH: 1089 return O_RDWR; 1090 } 1091 WARN_ON_ONCE(1); 1092 return O_RDONLY; 1093 } 1094 1095 /* 1096 * A stateid that had a deny mode associated with it is being released 1097 * or downgraded. Recalculate the deny mode on the file. 1098 */ 1099 static void 1100 recalculate_deny_mode(struct nfs4_file *fp) 1101 { 1102 struct nfs4_ol_stateid *stp; 1103 1104 spin_lock(&fp->fi_lock); 1105 fp->fi_share_deny = 0; 1106 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) 1107 fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap); 1108 spin_unlock(&fp->fi_lock); 1109 } 1110 1111 static void 1112 reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp) 1113 { 1114 int i; 1115 bool change = false; 1116 1117 for (i = 1; i < 4; i++) { 1118 if ((i & deny) != i) { 1119 change = true; 1120 clear_deny(i, stp); 1121 } 1122 } 1123 1124 /* Recalculate per-file deny mode if there was a change */ 1125 if (change) 1126 recalculate_deny_mode(stp->st_stid.sc_file); 1127 } 1128 1129 /* release all access and file references for a given stateid */ 1130 static void 1131 release_all_access(struct nfs4_ol_stateid *stp) 1132 { 1133 int i; 1134 struct nfs4_file *fp = stp->st_stid.sc_file; 1135 1136 if (fp && stp->st_deny_bmap != 0) 1137 recalculate_deny_mode(fp); 1138 1139 for (i = 1; i < 4; i++) { 1140 if (test_access(i, stp)) 1141 nfs4_file_put_access(stp->st_stid.sc_file, i); 1142 clear_access(i, stp); 1143 } 1144 } 1145 1146 static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop) 1147 { 1148 kfree(sop->so_owner.data); 1149 sop->so_ops->so_free(sop); 1150 } 1151 1152 static void nfs4_put_stateowner(struct nfs4_stateowner *sop) 1153 { 1154 struct nfs4_client *clp = sop->so_client; 1155 1156 might_lock(&clp->cl_lock); 1157 1158 if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock)) 1159 return; 1160 sop->so_ops->so_unhash(sop); 1161 spin_unlock(&clp->cl_lock); 1162 nfs4_free_stateowner(sop); 1163 } 1164 1165 static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp) 1166 { 1167 struct nfs4_file *fp = stp->st_stid.sc_file; 1168 1169 lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock); 1170 1171 if (list_empty(&stp->st_perfile)) 1172 return false; 1173 1174 spin_lock(&fp->fi_lock); 1175 list_del_init(&stp->st_perfile); 1176 spin_unlock(&fp->fi_lock); 1177 list_del(&stp->st_perstateowner); 1178 return true; 1179 } 1180 1181 static void nfs4_free_ol_stateid(struct nfs4_stid *stid) 1182 { 1183 struct nfs4_ol_stateid *stp = openlockstateid(stid); 1184 1185 put_clnt_odstate(stp->st_clnt_odstate); 1186 release_all_access(stp); 1187 if (stp->st_stateowner) 1188 nfs4_put_stateowner(stp->st_stateowner); 1189 kmem_cache_free(stateid_slab, stid); 1190 } 1191 1192 static void nfs4_free_lock_stateid(struct nfs4_stid *stid) 1193 { 1194 struct nfs4_ol_stateid *stp = openlockstateid(stid); 1195 struct nfs4_lockowner *lo = lockowner(stp->st_stateowner); 1196 struct file *file; 1197 1198 file = find_any_file(stp->st_stid.sc_file); 1199 if (file) 1200 filp_close(file, (fl_owner_t)lo); 1201 nfs4_free_ol_stateid(stid); 1202 } 1203 1204 /* 1205 * Put the persistent reference to an already unhashed generic stateid, while 1206 * holding the cl_lock. If it's the last reference, then put it onto the 1207 * reaplist for later destruction. 1208 */ 1209 static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp, 1210 struct list_head *reaplist) 1211 { 1212 struct nfs4_stid *s = &stp->st_stid; 1213 struct nfs4_client *clp = s->sc_client; 1214 1215 lockdep_assert_held(&clp->cl_lock); 1216 1217 WARN_ON_ONCE(!list_empty(&stp->st_locks)); 1218 1219 if (!atomic_dec_and_test(&s->sc_count)) { 1220 wake_up_all(&close_wq); 1221 return; 1222 } 1223 1224 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id); 1225 list_add(&stp->st_locks, reaplist); 1226 } 1227 1228 static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp) 1229 { 1230 lockdep_assert_held(&stp->st_stid.sc_client->cl_lock); 1231 1232 list_del_init(&stp->st_locks); 1233 nfs4_unhash_stid(&stp->st_stid); 1234 return unhash_ol_stateid(stp); 1235 } 1236 1237 static void release_lock_stateid(struct nfs4_ol_stateid *stp) 1238 { 1239 struct nfs4_client *clp = stp->st_stid.sc_client; 1240 bool unhashed; 1241 1242 spin_lock(&clp->cl_lock); 1243 unhashed = unhash_lock_stateid(stp); 1244 spin_unlock(&clp->cl_lock); 1245 if (unhashed) 1246 nfs4_put_stid(&stp->st_stid); 1247 } 1248 1249 static void unhash_lockowner_locked(struct nfs4_lockowner *lo) 1250 { 1251 struct nfs4_client *clp = lo->lo_owner.so_client; 1252 1253 lockdep_assert_held(&clp->cl_lock); 1254 1255 list_del_init(&lo->lo_owner.so_strhash); 1256 } 1257 1258 /* 1259 * Free a list of generic stateids that were collected earlier after being 1260 * fully unhashed. 1261 */ 1262 static void 1263 free_ol_stateid_reaplist(struct list_head *reaplist) 1264 { 1265 struct nfs4_ol_stateid *stp; 1266 struct nfs4_file *fp; 1267 1268 might_sleep(); 1269 1270 while (!list_empty(reaplist)) { 1271 stp = list_first_entry(reaplist, struct nfs4_ol_stateid, 1272 st_locks); 1273 list_del(&stp->st_locks); 1274 fp = stp->st_stid.sc_file; 1275 stp->st_stid.sc_free(&stp->st_stid); 1276 if (fp) 1277 put_nfs4_file(fp); 1278 } 1279 } 1280 1281 static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp, 1282 struct list_head *reaplist) 1283 { 1284 struct nfs4_ol_stateid *stp; 1285 1286 lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock); 1287 1288 while (!list_empty(&open_stp->st_locks)) { 1289 stp = list_entry(open_stp->st_locks.next, 1290 struct nfs4_ol_stateid, st_locks); 1291 WARN_ON(!unhash_lock_stateid(stp)); 1292 put_ol_stateid_locked(stp, reaplist); 1293 } 1294 } 1295 1296 static bool unhash_open_stateid(struct nfs4_ol_stateid *stp, 1297 struct list_head *reaplist) 1298 { 1299 bool unhashed; 1300 1301 lockdep_assert_held(&stp->st_stid.sc_client->cl_lock); 1302 1303 unhashed = unhash_ol_stateid(stp); 1304 release_open_stateid_locks(stp, reaplist); 1305 return unhashed; 1306 } 1307 1308 static void release_open_stateid(struct nfs4_ol_stateid *stp) 1309 { 1310 LIST_HEAD(reaplist); 1311 1312 spin_lock(&stp->st_stid.sc_client->cl_lock); 1313 if (unhash_open_stateid(stp, &reaplist)) 1314 put_ol_stateid_locked(stp, &reaplist); 1315 spin_unlock(&stp->st_stid.sc_client->cl_lock); 1316 free_ol_stateid_reaplist(&reaplist); 1317 } 1318 1319 static void unhash_openowner_locked(struct nfs4_openowner *oo) 1320 { 1321 struct nfs4_client *clp = oo->oo_owner.so_client; 1322 1323 lockdep_assert_held(&clp->cl_lock); 1324 1325 list_del_init(&oo->oo_owner.so_strhash); 1326 list_del_init(&oo->oo_perclient); 1327 } 1328 1329 static void release_last_closed_stateid(struct nfs4_openowner *oo) 1330 { 1331 struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net, 1332 nfsd_net_id); 1333 struct nfs4_ol_stateid *s; 1334 1335 spin_lock(&nn->client_lock); 1336 s = oo->oo_last_closed_stid; 1337 if (s) { 1338 list_del_init(&oo->oo_close_lru); 1339 oo->oo_last_closed_stid = NULL; 1340 } 1341 spin_unlock(&nn->client_lock); 1342 if (s) 1343 nfs4_put_stid(&s->st_stid); 1344 } 1345 1346 static void release_openowner(struct nfs4_openowner *oo) 1347 { 1348 struct nfs4_ol_stateid *stp; 1349 struct nfs4_client *clp = oo->oo_owner.so_client; 1350 struct list_head reaplist; 1351 1352 INIT_LIST_HEAD(&reaplist); 1353 1354 spin_lock(&clp->cl_lock); 1355 unhash_openowner_locked(oo); 1356 while (!list_empty(&oo->oo_owner.so_stateids)) { 1357 stp = list_first_entry(&oo->oo_owner.so_stateids, 1358 struct nfs4_ol_stateid, st_perstateowner); 1359 if (unhash_open_stateid(stp, &reaplist)) 1360 put_ol_stateid_locked(stp, &reaplist); 1361 } 1362 spin_unlock(&clp->cl_lock); 1363 free_ol_stateid_reaplist(&reaplist); 1364 release_last_closed_stateid(oo); 1365 nfs4_put_stateowner(&oo->oo_owner); 1366 } 1367 1368 static inline int 1369 hash_sessionid(struct nfs4_sessionid *sessionid) 1370 { 1371 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid; 1372 1373 return sid->sequence % SESSION_HASH_SIZE; 1374 } 1375 1376 #ifdef CONFIG_SUNRPC_DEBUG 1377 static inline void 1378 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid) 1379 { 1380 u32 *ptr = (u32 *)(&sessionid->data[0]); 1381 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]); 1382 } 1383 #else 1384 static inline void 1385 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid) 1386 { 1387 } 1388 #endif 1389 1390 /* 1391 * Bump the seqid on cstate->replay_owner, and clear replay_owner if it 1392 * won't be used for replay. 1393 */ 1394 void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr) 1395 { 1396 struct nfs4_stateowner *so = cstate->replay_owner; 1397 1398 if (nfserr == nfserr_replay_me) 1399 return; 1400 1401 if (!seqid_mutating_err(ntohl(nfserr))) { 1402 nfsd4_cstate_clear_replay(cstate); 1403 return; 1404 } 1405 if (!so) 1406 return; 1407 if (so->so_is_open_owner) 1408 release_last_closed_stateid(openowner(so)); 1409 so->so_seqid++; 1410 return; 1411 } 1412 1413 static void 1414 gen_sessionid(struct nfsd4_session *ses) 1415 { 1416 struct nfs4_client *clp = ses->se_client; 1417 struct nfsd4_sessionid *sid; 1418 1419 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data; 1420 sid->clientid = clp->cl_clientid; 1421 sid->sequence = current_sessionid++; 1422 sid->reserved = 0; 1423 } 1424 1425 /* 1426 * The protocol defines ca_maxresponssize_cached to include the size of 1427 * the rpc header, but all we need to cache is the data starting after 1428 * the end of the initial SEQUENCE operation--the rest we regenerate 1429 * each time. Therefore we can advertise a ca_maxresponssize_cached 1430 * value that is the number of bytes in our cache plus a few additional 1431 * bytes. In order to stay on the safe side, and not promise more than 1432 * we can cache, those additional bytes must be the minimum possible: 24 1433 * bytes of rpc header (xid through accept state, with AUTH_NULL 1434 * verifier), 12 for the compound header (with zero-length tag), and 44 1435 * for the SEQUENCE op response: 1436 */ 1437 #define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44) 1438 1439 static void 1440 free_session_slots(struct nfsd4_session *ses) 1441 { 1442 int i; 1443 1444 for (i = 0; i < ses->se_fchannel.maxreqs; i++) 1445 kfree(ses->se_slots[i]); 1446 } 1447 1448 /* 1449 * We don't actually need to cache the rpc and session headers, so we 1450 * can allocate a little less for each slot: 1451 */ 1452 static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca) 1453 { 1454 u32 size; 1455 1456 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ) 1457 size = 0; 1458 else 1459 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ; 1460 return size + sizeof(struct nfsd4_slot); 1461 } 1462 1463 /* 1464 * XXX: If we run out of reserved DRC memory we could (up to a point) 1465 * re-negotiate active sessions and reduce their slot usage to make 1466 * room for new connections. For now we just fail the create session. 1467 */ 1468 static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca) 1469 { 1470 u32 slotsize = slot_bytes(ca); 1471 u32 num = ca->maxreqs; 1472 int avail; 1473 1474 spin_lock(&nfsd_drc_lock); 1475 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION, 1476 nfsd_drc_max_mem - nfsd_drc_mem_used); 1477 num = min_t(int, num, avail / slotsize); 1478 nfsd_drc_mem_used += num * slotsize; 1479 spin_unlock(&nfsd_drc_lock); 1480 1481 return num; 1482 } 1483 1484 static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca) 1485 { 1486 int slotsize = slot_bytes(ca); 1487 1488 spin_lock(&nfsd_drc_lock); 1489 nfsd_drc_mem_used -= slotsize * ca->maxreqs; 1490 spin_unlock(&nfsd_drc_lock); 1491 } 1492 1493 static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs, 1494 struct nfsd4_channel_attrs *battrs) 1495 { 1496 int numslots = fattrs->maxreqs; 1497 int slotsize = slot_bytes(fattrs); 1498 struct nfsd4_session *new; 1499 int mem, i; 1500 1501 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *) 1502 + sizeof(struct nfsd4_session) > PAGE_SIZE); 1503 mem = numslots * sizeof(struct nfsd4_slot *); 1504 1505 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL); 1506 if (!new) 1507 return NULL; 1508 /* allocate each struct nfsd4_slot and data cache in one piece */ 1509 for (i = 0; i < numslots; i++) { 1510 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL); 1511 if (!new->se_slots[i]) 1512 goto out_free; 1513 } 1514 1515 memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs)); 1516 memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs)); 1517 1518 return new; 1519 out_free: 1520 while (i--) 1521 kfree(new->se_slots[i]); 1522 kfree(new); 1523 return NULL; 1524 } 1525 1526 static void free_conn(struct nfsd4_conn *c) 1527 { 1528 svc_xprt_put(c->cn_xprt); 1529 kfree(c); 1530 } 1531 1532 static void nfsd4_conn_lost(struct svc_xpt_user *u) 1533 { 1534 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user); 1535 struct nfs4_client *clp = c->cn_session->se_client; 1536 1537 spin_lock(&clp->cl_lock); 1538 if (!list_empty(&c->cn_persession)) { 1539 list_del(&c->cn_persession); 1540 free_conn(c); 1541 } 1542 nfsd4_probe_callback(clp); 1543 spin_unlock(&clp->cl_lock); 1544 } 1545 1546 static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags) 1547 { 1548 struct nfsd4_conn *conn; 1549 1550 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL); 1551 if (!conn) 1552 return NULL; 1553 svc_xprt_get(rqstp->rq_xprt); 1554 conn->cn_xprt = rqstp->rq_xprt; 1555 conn->cn_flags = flags; 1556 INIT_LIST_HEAD(&conn->cn_xpt_user.list); 1557 return conn; 1558 } 1559 1560 static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses) 1561 { 1562 conn->cn_session = ses; 1563 list_add(&conn->cn_persession, &ses->se_conns); 1564 } 1565 1566 static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses) 1567 { 1568 struct nfs4_client *clp = ses->se_client; 1569 1570 spin_lock(&clp->cl_lock); 1571 __nfsd4_hash_conn(conn, ses); 1572 spin_unlock(&clp->cl_lock); 1573 } 1574 1575 static int nfsd4_register_conn(struct nfsd4_conn *conn) 1576 { 1577 conn->cn_xpt_user.callback = nfsd4_conn_lost; 1578 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user); 1579 } 1580 1581 static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses) 1582 { 1583 int ret; 1584 1585 nfsd4_hash_conn(conn, ses); 1586 ret = nfsd4_register_conn(conn); 1587 if (ret) 1588 /* oops; xprt is already down: */ 1589 nfsd4_conn_lost(&conn->cn_xpt_user); 1590 /* We may have gained or lost a callback channel: */ 1591 nfsd4_probe_callback_sync(ses->se_client); 1592 } 1593 1594 static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses) 1595 { 1596 u32 dir = NFS4_CDFC4_FORE; 1597 1598 if (cses->flags & SESSION4_BACK_CHAN) 1599 dir |= NFS4_CDFC4_BACK; 1600 return alloc_conn(rqstp, dir); 1601 } 1602 1603 /* must be called under client_lock */ 1604 static void nfsd4_del_conns(struct nfsd4_session *s) 1605 { 1606 struct nfs4_client *clp = s->se_client; 1607 struct nfsd4_conn *c; 1608 1609 spin_lock(&clp->cl_lock); 1610 while (!list_empty(&s->se_conns)) { 1611 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession); 1612 list_del_init(&c->cn_persession); 1613 spin_unlock(&clp->cl_lock); 1614 1615 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user); 1616 free_conn(c); 1617 1618 spin_lock(&clp->cl_lock); 1619 } 1620 spin_unlock(&clp->cl_lock); 1621 } 1622 1623 static void __free_session(struct nfsd4_session *ses) 1624 { 1625 free_session_slots(ses); 1626 kfree(ses); 1627 } 1628 1629 static void free_session(struct nfsd4_session *ses) 1630 { 1631 nfsd4_del_conns(ses); 1632 nfsd4_put_drc_mem(&ses->se_fchannel); 1633 __free_session(ses); 1634 } 1635 1636 static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses) 1637 { 1638 int idx; 1639 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1640 1641 new->se_client = clp; 1642 gen_sessionid(new); 1643 1644 INIT_LIST_HEAD(&new->se_conns); 1645 1646 new->se_cb_seq_nr = 1; 1647 new->se_flags = cses->flags; 1648 new->se_cb_prog = cses->callback_prog; 1649 new->se_cb_sec = cses->cb_sec; 1650 atomic_set(&new->se_ref, 0); 1651 idx = hash_sessionid(&new->se_sessionid); 1652 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]); 1653 spin_lock(&clp->cl_lock); 1654 list_add(&new->se_perclnt, &clp->cl_sessions); 1655 spin_unlock(&clp->cl_lock); 1656 1657 { 1658 struct sockaddr *sa = svc_addr(rqstp); 1659 /* 1660 * This is a little silly; with sessions there's no real 1661 * use for the callback address. Use the peer address 1662 * as a reasonable default for now, but consider fixing 1663 * the rpc client not to require an address in the 1664 * future: 1665 */ 1666 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa); 1667 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa); 1668 } 1669 } 1670 1671 /* caller must hold client_lock */ 1672 static struct nfsd4_session * 1673 __find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net) 1674 { 1675 struct nfsd4_session *elem; 1676 int idx; 1677 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1678 1679 lockdep_assert_held(&nn->client_lock); 1680 1681 dump_sessionid(__func__, sessionid); 1682 idx = hash_sessionid(sessionid); 1683 /* Search in the appropriate list */ 1684 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) { 1685 if (!memcmp(elem->se_sessionid.data, sessionid->data, 1686 NFS4_MAX_SESSIONID_LEN)) { 1687 return elem; 1688 } 1689 } 1690 1691 dprintk("%s: session not found\n", __func__); 1692 return NULL; 1693 } 1694 1695 static struct nfsd4_session * 1696 find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net, 1697 __be32 *ret) 1698 { 1699 struct nfsd4_session *session; 1700 __be32 status = nfserr_badsession; 1701 1702 session = __find_in_sessionid_hashtbl(sessionid, net); 1703 if (!session) 1704 goto out; 1705 status = nfsd4_get_session_locked(session); 1706 if (status) 1707 session = NULL; 1708 out: 1709 *ret = status; 1710 return session; 1711 } 1712 1713 /* caller must hold client_lock */ 1714 static void 1715 unhash_session(struct nfsd4_session *ses) 1716 { 1717 struct nfs4_client *clp = ses->se_client; 1718 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1719 1720 lockdep_assert_held(&nn->client_lock); 1721 1722 list_del(&ses->se_hash); 1723 spin_lock(&ses->se_client->cl_lock); 1724 list_del(&ses->se_perclnt); 1725 spin_unlock(&ses->se_client->cl_lock); 1726 } 1727 1728 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */ 1729 static int 1730 STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn) 1731 { 1732 /* 1733 * We're assuming the clid was not given out from a boot 1734 * precisely 2^32 (about 136 years) before this one. That seems 1735 * a safe assumption: 1736 */ 1737 if (clid->cl_boot == (u32)nn->boot_time) 1738 return 0; 1739 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n", 1740 clid->cl_boot, clid->cl_id, nn->boot_time); 1741 return 1; 1742 } 1743 1744 /* 1745 * XXX Should we use a slab cache ? 1746 * This type of memory management is somewhat inefficient, but we use it 1747 * anyway since SETCLIENTID is not a common operation. 1748 */ 1749 static struct nfs4_client *alloc_client(struct xdr_netobj name) 1750 { 1751 struct nfs4_client *clp; 1752 int i; 1753 1754 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL); 1755 if (clp == NULL) 1756 return NULL; 1757 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL); 1758 if (clp->cl_name.data == NULL) 1759 goto err_no_name; 1760 clp->cl_ownerstr_hashtbl = kmalloc(sizeof(struct list_head) * 1761 OWNER_HASH_SIZE, GFP_KERNEL); 1762 if (!clp->cl_ownerstr_hashtbl) 1763 goto err_no_hashtbl; 1764 for (i = 0; i < OWNER_HASH_SIZE; i++) 1765 INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]); 1766 clp->cl_name.len = name.len; 1767 INIT_LIST_HEAD(&clp->cl_sessions); 1768 idr_init(&clp->cl_stateids); 1769 atomic_set(&clp->cl_refcount, 0); 1770 clp->cl_cb_state = NFSD4_CB_UNKNOWN; 1771 INIT_LIST_HEAD(&clp->cl_idhash); 1772 INIT_LIST_HEAD(&clp->cl_openowners); 1773 INIT_LIST_HEAD(&clp->cl_delegations); 1774 INIT_LIST_HEAD(&clp->cl_lru); 1775 INIT_LIST_HEAD(&clp->cl_revoked); 1776 #ifdef CONFIG_NFSD_PNFS 1777 INIT_LIST_HEAD(&clp->cl_lo_states); 1778 #endif 1779 spin_lock_init(&clp->cl_lock); 1780 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table"); 1781 return clp; 1782 err_no_hashtbl: 1783 kfree(clp->cl_name.data); 1784 err_no_name: 1785 kfree(clp); 1786 return NULL; 1787 } 1788 1789 static void 1790 free_client(struct nfs4_client *clp) 1791 { 1792 while (!list_empty(&clp->cl_sessions)) { 1793 struct nfsd4_session *ses; 1794 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session, 1795 se_perclnt); 1796 list_del(&ses->se_perclnt); 1797 WARN_ON_ONCE(atomic_read(&ses->se_ref)); 1798 free_session(ses); 1799 } 1800 rpc_destroy_wait_queue(&clp->cl_cb_waitq); 1801 free_svc_cred(&clp->cl_cred); 1802 kfree(clp->cl_ownerstr_hashtbl); 1803 kfree(clp->cl_name.data); 1804 idr_destroy(&clp->cl_stateids); 1805 kfree(clp); 1806 } 1807 1808 /* must be called under the client_lock */ 1809 static void 1810 unhash_client_locked(struct nfs4_client *clp) 1811 { 1812 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1813 struct nfsd4_session *ses; 1814 1815 lockdep_assert_held(&nn->client_lock); 1816 1817 /* Mark the client as expired! */ 1818 clp->cl_time = 0; 1819 /* Make it invisible */ 1820 if (!list_empty(&clp->cl_idhash)) { 1821 list_del_init(&clp->cl_idhash); 1822 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags)) 1823 rb_erase(&clp->cl_namenode, &nn->conf_name_tree); 1824 else 1825 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); 1826 } 1827 list_del_init(&clp->cl_lru); 1828 spin_lock(&clp->cl_lock); 1829 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt) 1830 list_del_init(&ses->se_hash); 1831 spin_unlock(&clp->cl_lock); 1832 } 1833 1834 static void 1835 unhash_client(struct nfs4_client *clp) 1836 { 1837 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1838 1839 spin_lock(&nn->client_lock); 1840 unhash_client_locked(clp); 1841 spin_unlock(&nn->client_lock); 1842 } 1843 1844 static __be32 mark_client_expired_locked(struct nfs4_client *clp) 1845 { 1846 if (atomic_read(&clp->cl_refcount)) 1847 return nfserr_jukebox; 1848 unhash_client_locked(clp); 1849 return nfs_ok; 1850 } 1851 1852 static void 1853 __destroy_client(struct nfs4_client *clp) 1854 { 1855 struct nfs4_openowner *oo; 1856 struct nfs4_delegation *dp; 1857 struct list_head reaplist; 1858 1859 INIT_LIST_HEAD(&reaplist); 1860 spin_lock(&state_lock); 1861 while (!list_empty(&clp->cl_delegations)) { 1862 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt); 1863 WARN_ON(!unhash_delegation_locked(dp)); 1864 list_add(&dp->dl_recall_lru, &reaplist); 1865 } 1866 spin_unlock(&state_lock); 1867 while (!list_empty(&reaplist)) { 1868 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru); 1869 list_del_init(&dp->dl_recall_lru); 1870 put_clnt_odstate(dp->dl_clnt_odstate); 1871 nfs4_put_deleg_lease(dp->dl_stid.sc_file); 1872 nfs4_put_stid(&dp->dl_stid); 1873 } 1874 while (!list_empty(&clp->cl_revoked)) { 1875 dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru); 1876 list_del_init(&dp->dl_recall_lru); 1877 nfs4_put_stid(&dp->dl_stid); 1878 } 1879 while (!list_empty(&clp->cl_openowners)) { 1880 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient); 1881 nfs4_get_stateowner(&oo->oo_owner); 1882 release_openowner(oo); 1883 } 1884 nfsd4_return_all_client_layouts(clp); 1885 nfsd4_shutdown_callback(clp); 1886 if (clp->cl_cb_conn.cb_xprt) 1887 svc_xprt_put(clp->cl_cb_conn.cb_xprt); 1888 free_client(clp); 1889 } 1890 1891 static void 1892 destroy_client(struct nfs4_client *clp) 1893 { 1894 unhash_client(clp); 1895 __destroy_client(clp); 1896 } 1897 1898 static void expire_client(struct nfs4_client *clp) 1899 { 1900 unhash_client(clp); 1901 nfsd4_client_record_remove(clp); 1902 __destroy_client(clp); 1903 } 1904 1905 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source) 1906 { 1907 memcpy(target->cl_verifier.data, source->data, 1908 sizeof(target->cl_verifier.data)); 1909 } 1910 1911 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source) 1912 { 1913 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 1914 target->cl_clientid.cl_id = source->cl_clientid.cl_id; 1915 } 1916 1917 int strdup_if_nonnull(char **target, char *source) 1918 { 1919 if (source) { 1920 *target = kstrdup(source, GFP_KERNEL); 1921 if (!*target) 1922 return -ENOMEM; 1923 } else 1924 *target = NULL; 1925 return 0; 1926 } 1927 1928 static int copy_cred(struct svc_cred *target, struct svc_cred *source) 1929 { 1930 int ret; 1931 1932 ret = strdup_if_nonnull(&target->cr_principal, source->cr_principal); 1933 if (ret) 1934 return ret; 1935 ret = strdup_if_nonnull(&target->cr_raw_principal, 1936 source->cr_raw_principal); 1937 if (ret) 1938 return ret; 1939 target->cr_flavor = source->cr_flavor; 1940 target->cr_uid = source->cr_uid; 1941 target->cr_gid = source->cr_gid; 1942 target->cr_group_info = source->cr_group_info; 1943 get_group_info(target->cr_group_info); 1944 target->cr_gss_mech = source->cr_gss_mech; 1945 if (source->cr_gss_mech) 1946 gss_mech_get(source->cr_gss_mech); 1947 return 0; 1948 } 1949 1950 static int 1951 compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2) 1952 { 1953 if (o1->len < o2->len) 1954 return -1; 1955 if (o1->len > o2->len) 1956 return 1; 1957 return memcmp(o1->data, o2->data, o1->len); 1958 } 1959 1960 static int same_name(const char *n1, const char *n2) 1961 { 1962 return 0 == memcmp(n1, n2, HEXDIR_LEN); 1963 } 1964 1965 static int 1966 same_verf(nfs4_verifier *v1, nfs4_verifier *v2) 1967 { 1968 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data)); 1969 } 1970 1971 static int 1972 same_clid(clientid_t *cl1, clientid_t *cl2) 1973 { 1974 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id); 1975 } 1976 1977 static bool groups_equal(struct group_info *g1, struct group_info *g2) 1978 { 1979 int i; 1980 1981 if (g1->ngroups != g2->ngroups) 1982 return false; 1983 for (i=0; i<g1->ngroups; i++) 1984 if (!gid_eq(g1->gid[i], g2->gid[i])) 1985 return false; 1986 return true; 1987 } 1988 1989 /* 1990 * RFC 3530 language requires clid_inuse be returned when the 1991 * "principal" associated with a requests differs from that previously 1992 * used. We use uid, gid's, and gss principal string as our best 1993 * approximation. We also don't want to allow non-gss use of a client 1994 * established using gss: in theory cr_principal should catch that 1995 * change, but in practice cr_principal can be null even in the gss case 1996 * since gssd doesn't always pass down a principal string. 1997 */ 1998 static bool is_gss_cred(struct svc_cred *cr) 1999 { 2000 /* Is cr_flavor one of the gss "pseudoflavors"?: */ 2001 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR); 2002 } 2003 2004 2005 static bool 2006 same_creds(struct svc_cred *cr1, struct svc_cred *cr2) 2007 { 2008 if ((is_gss_cred(cr1) != is_gss_cred(cr2)) 2009 || (!uid_eq(cr1->cr_uid, cr2->cr_uid)) 2010 || (!gid_eq(cr1->cr_gid, cr2->cr_gid)) 2011 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info)) 2012 return false; 2013 if (cr1->cr_principal == cr2->cr_principal) 2014 return true; 2015 if (!cr1->cr_principal || !cr2->cr_principal) 2016 return false; 2017 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal); 2018 } 2019 2020 static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp) 2021 { 2022 struct svc_cred *cr = &rqstp->rq_cred; 2023 u32 service; 2024 2025 if (!cr->cr_gss_mech) 2026 return false; 2027 service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor); 2028 return service == RPC_GSS_SVC_INTEGRITY || 2029 service == RPC_GSS_SVC_PRIVACY; 2030 } 2031 2032 bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp) 2033 { 2034 struct svc_cred *cr = &rqstp->rq_cred; 2035 2036 if (!cl->cl_mach_cred) 2037 return true; 2038 if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech) 2039 return false; 2040 if (!svc_rqst_integrity_protected(rqstp)) 2041 return false; 2042 if (cl->cl_cred.cr_raw_principal) 2043 return 0 == strcmp(cl->cl_cred.cr_raw_principal, 2044 cr->cr_raw_principal); 2045 if (!cr->cr_principal) 2046 return false; 2047 return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal); 2048 } 2049 2050 static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn) 2051 { 2052 __be32 verf[2]; 2053 2054 /* 2055 * This is opaque to client, so no need to byte-swap. Use 2056 * __force to keep sparse happy 2057 */ 2058 verf[0] = (__force __be32)get_seconds(); 2059 verf[1] = (__force __be32)nn->clverifier_counter++; 2060 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data)); 2061 } 2062 2063 static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn) 2064 { 2065 clp->cl_clientid.cl_boot = nn->boot_time; 2066 clp->cl_clientid.cl_id = nn->clientid_counter++; 2067 gen_confirm(clp, nn); 2068 } 2069 2070 static struct nfs4_stid * 2071 find_stateid_locked(struct nfs4_client *cl, stateid_t *t) 2072 { 2073 struct nfs4_stid *ret; 2074 2075 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id); 2076 if (!ret || !ret->sc_type) 2077 return NULL; 2078 return ret; 2079 } 2080 2081 static struct nfs4_stid * 2082 find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask) 2083 { 2084 struct nfs4_stid *s; 2085 2086 spin_lock(&cl->cl_lock); 2087 s = find_stateid_locked(cl, t); 2088 if (s != NULL) { 2089 if (typemask & s->sc_type) 2090 atomic_inc(&s->sc_count); 2091 else 2092 s = NULL; 2093 } 2094 spin_unlock(&cl->cl_lock); 2095 return s; 2096 } 2097 2098 static struct nfs4_client *create_client(struct xdr_netobj name, 2099 struct svc_rqst *rqstp, nfs4_verifier *verf) 2100 { 2101 struct nfs4_client *clp; 2102 struct sockaddr *sa = svc_addr(rqstp); 2103 int ret; 2104 struct net *net = SVC_NET(rqstp); 2105 2106 clp = alloc_client(name); 2107 if (clp == NULL) 2108 return NULL; 2109 2110 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred); 2111 if (ret) { 2112 free_client(clp); 2113 return NULL; 2114 } 2115 nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL); 2116 clp->cl_time = get_seconds(); 2117 clear_bit(0, &clp->cl_cb_slot_busy); 2118 copy_verf(clp, verf); 2119 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa); 2120 clp->cl_cb_session = NULL; 2121 clp->net = net; 2122 return clp; 2123 } 2124 2125 static void 2126 add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root) 2127 { 2128 struct rb_node **new = &(root->rb_node), *parent = NULL; 2129 struct nfs4_client *clp; 2130 2131 while (*new) { 2132 clp = rb_entry(*new, struct nfs4_client, cl_namenode); 2133 parent = *new; 2134 2135 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0) 2136 new = &((*new)->rb_left); 2137 else 2138 new = &((*new)->rb_right); 2139 } 2140 2141 rb_link_node(&new_clp->cl_namenode, parent, new); 2142 rb_insert_color(&new_clp->cl_namenode, root); 2143 } 2144 2145 static struct nfs4_client * 2146 find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root) 2147 { 2148 int cmp; 2149 struct rb_node *node = root->rb_node; 2150 struct nfs4_client *clp; 2151 2152 while (node) { 2153 clp = rb_entry(node, struct nfs4_client, cl_namenode); 2154 cmp = compare_blob(&clp->cl_name, name); 2155 if (cmp > 0) 2156 node = node->rb_left; 2157 else if (cmp < 0) 2158 node = node->rb_right; 2159 else 2160 return clp; 2161 } 2162 return NULL; 2163 } 2164 2165 static void 2166 add_to_unconfirmed(struct nfs4_client *clp) 2167 { 2168 unsigned int idhashval; 2169 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 2170 2171 lockdep_assert_held(&nn->client_lock); 2172 2173 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags); 2174 add_clp_to_name_tree(clp, &nn->unconf_name_tree); 2175 idhashval = clientid_hashval(clp->cl_clientid.cl_id); 2176 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]); 2177 renew_client_locked(clp); 2178 } 2179 2180 static void 2181 move_to_confirmed(struct nfs4_client *clp) 2182 { 2183 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id); 2184 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 2185 2186 lockdep_assert_held(&nn->client_lock); 2187 2188 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp); 2189 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]); 2190 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); 2191 add_clp_to_name_tree(clp, &nn->conf_name_tree); 2192 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags); 2193 renew_client_locked(clp); 2194 } 2195 2196 static struct nfs4_client * 2197 find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions) 2198 { 2199 struct nfs4_client *clp; 2200 unsigned int idhashval = clientid_hashval(clid->cl_id); 2201 2202 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) { 2203 if (same_clid(&clp->cl_clientid, clid)) { 2204 if ((bool)clp->cl_minorversion != sessions) 2205 return NULL; 2206 renew_client_locked(clp); 2207 return clp; 2208 } 2209 } 2210 return NULL; 2211 } 2212 2213 static struct nfs4_client * 2214 find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn) 2215 { 2216 struct list_head *tbl = nn->conf_id_hashtbl; 2217 2218 lockdep_assert_held(&nn->client_lock); 2219 return find_client_in_id_table(tbl, clid, sessions); 2220 } 2221 2222 static struct nfs4_client * 2223 find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn) 2224 { 2225 struct list_head *tbl = nn->unconf_id_hashtbl; 2226 2227 lockdep_assert_held(&nn->client_lock); 2228 return find_client_in_id_table(tbl, clid, sessions); 2229 } 2230 2231 static bool clp_used_exchangeid(struct nfs4_client *clp) 2232 { 2233 return clp->cl_exchange_flags != 0; 2234 } 2235 2236 static struct nfs4_client * 2237 find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn) 2238 { 2239 lockdep_assert_held(&nn->client_lock); 2240 return find_clp_in_name_tree(name, &nn->conf_name_tree); 2241 } 2242 2243 static struct nfs4_client * 2244 find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn) 2245 { 2246 lockdep_assert_held(&nn->client_lock); 2247 return find_clp_in_name_tree(name, &nn->unconf_name_tree); 2248 } 2249 2250 static void 2251 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp) 2252 { 2253 struct nfs4_cb_conn *conn = &clp->cl_cb_conn; 2254 struct sockaddr *sa = svc_addr(rqstp); 2255 u32 scopeid = rpc_get_scope_id(sa); 2256 unsigned short expected_family; 2257 2258 /* Currently, we only support tcp and tcp6 for the callback channel */ 2259 if (se->se_callback_netid_len == 3 && 2260 !memcmp(se->se_callback_netid_val, "tcp", 3)) 2261 expected_family = AF_INET; 2262 else if (se->se_callback_netid_len == 4 && 2263 !memcmp(se->se_callback_netid_val, "tcp6", 4)) 2264 expected_family = AF_INET6; 2265 else 2266 goto out_err; 2267 2268 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val, 2269 se->se_callback_addr_len, 2270 (struct sockaddr *)&conn->cb_addr, 2271 sizeof(conn->cb_addr)); 2272 2273 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family) 2274 goto out_err; 2275 2276 if (conn->cb_addr.ss_family == AF_INET6) 2277 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid; 2278 2279 conn->cb_prog = se->se_callback_prog; 2280 conn->cb_ident = se->se_callback_ident; 2281 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen); 2282 return; 2283 out_err: 2284 conn->cb_addr.ss_family = AF_UNSPEC; 2285 conn->cb_addrlen = 0; 2286 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) " 2287 "will not receive delegations\n", 2288 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id); 2289 2290 return; 2291 } 2292 2293 /* 2294 * Cache a reply. nfsd4_check_resp_size() has bounded the cache size. 2295 */ 2296 static void 2297 nfsd4_store_cache_entry(struct nfsd4_compoundres *resp) 2298 { 2299 struct xdr_buf *buf = resp->xdr.buf; 2300 struct nfsd4_slot *slot = resp->cstate.slot; 2301 unsigned int base; 2302 2303 dprintk("--> %s slot %p\n", __func__, slot); 2304 2305 slot->sl_opcnt = resp->opcnt; 2306 slot->sl_status = resp->cstate.status; 2307 2308 slot->sl_flags |= NFSD4_SLOT_INITIALIZED; 2309 if (nfsd4_not_cached(resp)) { 2310 slot->sl_datalen = 0; 2311 return; 2312 } 2313 base = resp->cstate.data_offset; 2314 slot->sl_datalen = buf->len - base; 2315 if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen)) 2316 WARN(1, "%s: sessions DRC could not cache compound\n", 2317 __func__); 2318 return; 2319 } 2320 2321 /* 2322 * Encode the replay sequence operation from the slot values. 2323 * If cachethis is FALSE encode the uncached rep error on the next 2324 * operation which sets resp->p and increments resp->opcnt for 2325 * nfs4svc_encode_compoundres. 2326 * 2327 */ 2328 static __be32 2329 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args, 2330 struct nfsd4_compoundres *resp) 2331 { 2332 struct nfsd4_op *op; 2333 struct nfsd4_slot *slot = resp->cstate.slot; 2334 2335 /* Encode the replayed sequence operation */ 2336 op = &args->ops[resp->opcnt - 1]; 2337 nfsd4_encode_operation(resp, op); 2338 2339 /* Return nfserr_retry_uncached_rep in next operation. */ 2340 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) { 2341 op = &args->ops[resp->opcnt++]; 2342 op->status = nfserr_retry_uncached_rep; 2343 nfsd4_encode_operation(resp, op); 2344 } 2345 return op->status; 2346 } 2347 2348 /* 2349 * The sequence operation is not cached because we can use the slot and 2350 * session values. 2351 */ 2352 static __be32 2353 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp, 2354 struct nfsd4_sequence *seq) 2355 { 2356 struct nfsd4_slot *slot = resp->cstate.slot; 2357 struct xdr_stream *xdr = &resp->xdr; 2358 __be32 *p; 2359 __be32 status; 2360 2361 dprintk("--> %s slot %p\n", __func__, slot); 2362 2363 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp); 2364 if (status) 2365 return status; 2366 2367 p = xdr_reserve_space(xdr, slot->sl_datalen); 2368 if (!p) { 2369 WARN_ON_ONCE(1); 2370 return nfserr_serverfault; 2371 } 2372 xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen); 2373 xdr_commit_encode(xdr); 2374 2375 resp->opcnt = slot->sl_opcnt; 2376 return slot->sl_status; 2377 } 2378 2379 /* 2380 * Set the exchange_id flags returned by the server. 2381 */ 2382 static void 2383 nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid) 2384 { 2385 #ifdef CONFIG_NFSD_PNFS 2386 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS; 2387 #else 2388 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS; 2389 #endif 2390 2391 /* Referrals are supported, Migration is not. */ 2392 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER; 2393 2394 /* set the wire flags to return to client. */ 2395 clid->flags = new->cl_exchange_flags; 2396 } 2397 2398 static bool client_has_openowners(struct nfs4_client *clp) 2399 { 2400 struct nfs4_openowner *oo; 2401 2402 list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) { 2403 if (!list_empty(&oo->oo_owner.so_stateids)) 2404 return true; 2405 } 2406 return false; 2407 } 2408 2409 static bool client_has_state(struct nfs4_client *clp) 2410 { 2411 return client_has_openowners(clp) 2412 #ifdef CONFIG_NFSD_PNFS 2413 || !list_empty(&clp->cl_lo_states) 2414 #endif 2415 || !list_empty(&clp->cl_delegations) 2416 || !list_empty(&clp->cl_sessions); 2417 } 2418 2419 __be32 2420 nfsd4_exchange_id(struct svc_rqst *rqstp, 2421 struct nfsd4_compound_state *cstate, 2422 struct nfsd4_exchange_id *exid) 2423 { 2424 struct nfs4_client *conf, *new; 2425 struct nfs4_client *unconf = NULL; 2426 __be32 status; 2427 char addr_str[INET6_ADDRSTRLEN]; 2428 nfs4_verifier verf = exid->verifier; 2429 struct sockaddr *sa = svc_addr(rqstp); 2430 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A; 2431 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 2432 2433 rpc_ntop(sa, addr_str, sizeof(addr_str)); 2434 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p " 2435 "ip_addr=%s flags %x, spa_how %d\n", 2436 __func__, rqstp, exid, exid->clname.len, exid->clname.data, 2437 addr_str, exid->flags, exid->spa_how); 2438 2439 if (exid->flags & ~EXCHGID4_FLAG_MASK_A) 2440 return nfserr_inval; 2441 2442 new = create_client(exid->clname, rqstp, &verf); 2443 if (new == NULL) 2444 return nfserr_jukebox; 2445 2446 switch (exid->spa_how) { 2447 case SP4_MACH_CRED: 2448 exid->spo_must_enforce[0] = 0; 2449 exid->spo_must_enforce[1] = ( 2450 1 << (OP_BIND_CONN_TO_SESSION - 32) | 2451 1 << (OP_EXCHANGE_ID - 32) | 2452 1 << (OP_CREATE_SESSION - 32) | 2453 1 << (OP_DESTROY_SESSION - 32) | 2454 1 << (OP_DESTROY_CLIENTID - 32)); 2455 2456 exid->spo_must_allow[0] &= (1 << (OP_CLOSE) | 2457 1 << (OP_OPEN_DOWNGRADE) | 2458 1 << (OP_LOCKU) | 2459 1 << (OP_DELEGRETURN)); 2460 2461 exid->spo_must_allow[1] &= ( 2462 1 << (OP_TEST_STATEID - 32) | 2463 1 << (OP_FREE_STATEID - 32)); 2464 if (!svc_rqst_integrity_protected(rqstp)) { 2465 status = nfserr_inval; 2466 goto out_nolock; 2467 } 2468 /* 2469 * Sometimes userspace doesn't give us a principal. 2470 * Which is a bug, really. Anyway, we can't enforce 2471 * MACH_CRED in that case, better to give up now: 2472 */ 2473 if (!new->cl_cred.cr_principal && 2474 !new->cl_cred.cr_raw_principal) { 2475 status = nfserr_serverfault; 2476 goto out_nolock; 2477 } 2478 new->cl_mach_cred = true; 2479 case SP4_NONE: 2480 break; 2481 default: /* checked by xdr code */ 2482 WARN_ON_ONCE(1); 2483 case SP4_SSV: 2484 status = nfserr_encr_alg_unsupp; 2485 goto out_nolock; 2486 } 2487 2488 /* Cases below refer to rfc 5661 section 18.35.4: */ 2489 spin_lock(&nn->client_lock); 2490 conf = find_confirmed_client_by_name(&exid->clname, nn); 2491 if (conf) { 2492 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred); 2493 bool verfs_match = same_verf(&verf, &conf->cl_verifier); 2494 2495 if (update) { 2496 if (!clp_used_exchangeid(conf)) { /* buggy client */ 2497 status = nfserr_inval; 2498 goto out; 2499 } 2500 if (!nfsd4_mach_creds_match(conf, rqstp)) { 2501 status = nfserr_wrong_cred; 2502 goto out; 2503 } 2504 if (!creds_match) { /* case 9 */ 2505 status = nfserr_perm; 2506 goto out; 2507 } 2508 if (!verfs_match) { /* case 8 */ 2509 status = nfserr_not_same; 2510 goto out; 2511 } 2512 /* case 6 */ 2513 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R; 2514 goto out_copy; 2515 } 2516 if (!creds_match) { /* case 3 */ 2517 if (client_has_state(conf)) { 2518 status = nfserr_clid_inuse; 2519 goto out; 2520 } 2521 goto out_new; 2522 } 2523 if (verfs_match) { /* case 2 */ 2524 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R; 2525 goto out_copy; 2526 } 2527 /* case 5, client reboot */ 2528 conf = NULL; 2529 goto out_new; 2530 } 2531 2532 if (update) { /* case 7 */ 2533 status = nfserr_noent; 2534 goto out; 2535 } 2536 2537 unconf = find_unconfirmed_client_by_name(&exid->clname, nn); 2538 if (unconf) /* case 4, possible retry or client restart */ 2539 unhash_client_locked(unconf); 2540 2541 /* case 1 (normal case) */ 2542 out_new: 2543 if (conf) { 2544 status = mark_client_expired_locked(conf); 2545 if (status) 2546 goto out; 2547 } 2548 new->cl_minorversion = cstate->minorversion; 2549 new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0]; 2550 new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1]; 2551 2552 gen_clid(new, nn); 2553 add_to_unconfirmed(new); 2554 swap(new, conf); 2555 out_copy: 2556 exid->clientid.cl_boot = conf->cl_clientid.cl_boot; 2557 exid->clientid.cl_id = conf->cl_clientid.cl_id; 2558 2559 exid->seqid = conf->cl_cs_slot.sl_seqid + 1; 2560 nfsd4_set_ex_flags(conf, exid); 2561 2562 dprintk("nfsd4_exchange_id seqid %d flags %x\n", 2563 conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags); 2564 status = nfs_ok; 2565 2566 out: 2567 spin_unlock(&nn->client_lock); 2568 out_nolock: 2569 if (new) 2570 expire_client(new); 2571 if (unconf) 2572 expire_client(unconf); 2573 return status; 2574 } 2575 2576 static __be32 2577 check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse) 2578 { 2579 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid, 2580 slot_seqid); 2581 2582 /* The slot is in use, and no response has been sent. */ 2583 if (slot_inuse) { 2584 if (seqid == slot_seqid) 2585 return nfserr_jukebox; 2586 else 2587 return nfserr_seq_misordered; 2588 } 2589 /* Note unsigned 32-bit arithmetic handles wraparound: */ 2590 if (likely(seqid == slot_seqid + 1)) 2591 return nfs_ok; 2592 if (seqid == slot_seqid) 2593 return nfserr_replay_cache; 2594 return nfserr_seq_misordered; 2595 } 2596 2597 /* 2598 * Cache the create session result into the create session single DRC 2599 * slot cache by saving the xdr structure. sl_seqid has been set. 2600 * Do this for solo or embedded create session operations. 2601 */ 2602 static void 2603 nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses, 2604 struct nfsd4_clid_slot *slot, __be32 nfserr) 2605 { 2606 slot->sl_status = nfserr; 2607 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses)); 2608 } 2609 2610 static __be32 2611 nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses, 2612 struct nfsd4_clid_slot *slot) 2613 { 2614 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses)); 2615 return slot->sl_status; 2616 } 2617 2618 #define NFSD_MIN_REQ_HDR_SEQ_SZ ((\ 2619 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \ 2620 1 + /* MIN tag is length with zero, only length */ \ 2621 3 + /* version, opcount, opcode */ \ 2622 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \ 2623 /* seqid, slotID, slotID, cache */ \ 2624 4 ) * sizeof(__be32)) 2625 2626 #define NFSD_MIN_RESP_HDR_SEQ_SZ ((\ 2627 2 + /* verifier: AUTH_NULL, length 0 */\ 2628 1 + /* status */ \ 2629 1 + /* MIN tag is length with zero, only length */ \ 2630 3 + /* opcount, opcode, opstatus*/ \ 2631 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \ 2632 /* seqid, slotID, slotID, slotID, status */ \ 2633 5 ) * sizeof(__be32)) 2634 2635 static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn) 2636 { 2637 u32 maxrpc = nn->nfsd_serv->sv_max_mesg; 2638 2639 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ) 2640 return nfserr_toosmall; 2641 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ) 2642 return nfserr_toosmall; 2643 ca->headerpadsz = 0; 2644 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc); 2645 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc); 2646 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND); 2647 ca->maxresp_cached = min_t(u32, ca->maxresp_cached, 2648 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ); 2649 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION); 2650 /* 2651 * Note decreasing slot size below client's request may make it 2652 * difficult for client to function correctly, whereas 2653 * decreasing the number of slots will (just?) affect 2654 * performance. When short on memory we therefore prefer to 2655 * decrease number of slots instead of their size. Clients that 2656 * request larger slots than they need will get poor results: 2657 */ 2658 ca->maxreqs = nfsd4_get_drc_mem(ca); 2659 if (!ca->maxreqs) 2660 return nfserr_jukebox; 2661 2662 return nfs_ok; 2663 } 2664 2665 /* 2666 * Server's NFSv4.1 backchannel support is AUTH_SYS-only for now. 2667 * These are based on similar macros in linux/sunrpc/msg_prot.h . 2668 */ 2669 #define RPC_MAX_HEADER_WITH_AUTH_SYS \ 2670 (RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK)) 2671 2672 #define RPC_MAX_REPHEADER_WITH_AUTH_SYS \ 2673 (RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK)) 2674 2675 #define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \ 2676 RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32)) 2677 #define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \ 2678 RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \ 2679 sizeof(__be32)) 2680 2681 static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca) 2682 { 2683 ca->headerpadsz = 0; 2684 2685 if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ) 2686 return nfserr_toosmall; 2687 if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ) 2688 return nfserr_toosmall; 2689 ca->maxresp_cached = 0; 2690 if (ca->maxops < 2) 2691 return nfserr_toosmall; 2692 2693 return nfs_ok; 2694 } 2695 2696 static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs) 2697 { 2698 switch (cbs->flavor) { 2699 case RPC_AUTH_NULL: 2700 case RPC_AUTH_UNIX: 2701 return nfs_ok; 2702 default: 2703 /* 2704 * GSS case: the spec doesn't allow us to return this 2705 * error. But it also doesn't allow us not to support 2706 * GSS. 2707 * I'd rather this fail hard than return some error the 2708 * client might think it can already handle: 2709 */ 2710 return nfserr_encr_alg_unsupp; 2711 } 2712 } 2713 2714 __be32 2715 nfsd4_create_session(struct svc_rqst *rqstp, 2716 struct nfsd4_compound_state *cstate, 2717 struct nfsd4_create_session *cr_ses) 2718 { 2719 struct sockaddr *sa = svc_addr(rqstp); 2720 struct nfs4_client *conf, *unconf; 2721 struct nfs4_client *old = NULL; 2722 struct nfsd4_session *new; 2723 struct nfsd4_conn *conn; 2724 struct nfsd4_clid_slot *cs_slot = NULL; 2725 __be32 status = 0; 2726 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 2727 2728 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A) 2729 return nfserr_inval; 2730 status = nfsd4_check_cb_sec(&cr_ses->cb_sec); 2731 if (status) 2732 return status; 2733 status = check_forechannel_attrs(&cr_ses->fore_channel, nn); 2734 if (status) 2735 return status; 2736 status = check_backchannel_attrs(&cr_ses->back_channel); 2737 if (status) 2738 goto out_release_drc_mem; 2739 status = nfserr_jukebox; 2740 new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel); 2741 if (!new) 2742 goto out_release_drc_mem; 2743 conn = alloc_conn_from_crses(rqstp, cr_ses); 2744 if (!conn) 2745 goto out_free_session; 2746 2747 spin_lock(&nn->client_lock); 2748 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn); 2749 conf = find_confirmed_client(&cr_ses->clientid, true, nn); 2750 WARN_ON_ONCE(conf && unconf); 2751 2752 if (conf) { 2753 status = nfserr_wrong_cred; 2754 if (!nfsd4_mach_creds_match(conf, rqstp)) 2755 goto out_free_conn; 2756 cs_slot = &conf->cl_cs_slot; 2757 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0); 2758 if (status) { 2759 if (status == nfserr_replay_cache) 2760 status = nfsd4_replay_create_session(cr_ses, cs_slot); 2761 goto out_free_conn; 2762 } 2763 } else if (unconf) { 2764 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) || 2765 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) { 2766 status = nfserr_clid_inuse; 2767 goto out_free_conn; 2768 } 2769 status = nfserr_wrong_cred; 2770 if (!nfsd4_mach_creds_match(unconf, rqstp)) 2771 goto out_free_conn; 2772 cs_slot = &unconf->cl_cs_slot; 2773 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0); 2774 if (status) { 2775 /* an unconfirmed replay returns misordered */ 2776 status = nfserr_seq_misordered; 2777 goto out_free_conn; 2778 } 2779 old = find_confirmed_client_by_name(&unconf->cl_name, nn); 2780 if (old) { 2781 status = mark_client_expired_locked(old); 2782 if (status) { 2783 old = NULL; 2784 goto out_free_conn; 2785 } 2786 } 2787 move_to_confirmed(unconf); 2788 conf = unconf; 2789 } else { 2790 status = nfserr_stale_clientid; 2791 goto out_free_conn; 2792 } 2793 status = nfs_ok; 2794 /* Persistent sessions are not supported */ 2795 cr_ses->flags &= ~SESSION4_PERSIST; 2796 /* Upshifting from TCP to RDMA is not supported */ 2797 cr_ses->flags &= ~SESSION4_RDMA; 2798 2799 init_session(rqstp, new, conf, cr_ses); 2800 nfsd4_get_session_locked(new); 2801 2802 memcpy(cr_ses->sessionid.data, new->se_sessionid.data, 2803 NFS4_MAX_SESSIONID_LEN); 2804 cs_slot->sl_seqid++; 2805 cr_ses->seqid = cs_slot->sl_seqid; 2806 2807 /* cache solo and embedded create sessions under the client_lock */ 2808 nfsd4_cache_create_session(cr_ses, cs_slot, status); 2809 spin_unlock(&nn->client_lock); 2810 /* init connection and backchannel */ 2811 nfsd4_init_conn(rqstp, conn, new); 2812 nfsd4_put_session(new); 2813 if (old) 2814 expire_client(old); 2815 return status; 2816 out_free_conn: 2817 spin_unlock(&nn->client_lock); 2818 free_conn(conn); 2819 if (old) 2820 expire_client(old); 2821 out_free_session: 2822 __free_session(new); 2823 out_release_drc_mem: 2824 nfsd4_put_drc_mem(&cr_ses->fore_channel); 2825 return status; 2826 } 2827 2828 static __be32 nfsd4_map_bcts_dir(u32 *dir) 2829 { 2830 switch (*dir) { 2831 case NFS4_CDFC4_FORE: 2832 case NFS4_CDFC4_BACK: 2833 return nfs_ok; 2834 case NFS4_CDFC4_FORE_OR_BOTH: 2835 case NFS4_CDFC4_BACK_OR_BOTH: 2836 *dir = NFS4_CDFC4_BOTH; 2837 return nfs_ok; 2838 }; 2839 return nfserr_inval; 2840 } 2841 2842 __be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc) 2843 { 2844 struct nfsd4_session *session = cstate->session; 2845 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 2846 __be32 status; 2847 2848 status = nfsd4_check_cb_sec(&bc->bc_cb_sec); 2849 if (status) 2850 return status; 2851 spin_lock(&nn->client_lock); 2852 session->se_cb_prog = bc->bc_cb_program; 2853 session->se_cb_sec = bc->bc_cb_sec; 2854 spin_unlock(&nn->client_lock); 2855 2856 nfsd4_probe_callback(session->se_client); 2857 2858 return nfs_ok; 2859 } 2860 2861 __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp, 2862 struct nfsd4_compound_state *cstate, 2863 struct nfsd4_bind_conn_to_session *bcts) 2864 { 2865 __be32 status; 2866 struct nfsd4_conn *conn; 2867 struct nfsd4_session *session; 2868 struct net *net = SVC_NET(rqstp); 2869 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2870 2871 if (!nfsd4_last_compound_op(rqstp)) 2872 return nfserr_not_only_op; 2873 spin_lock(&nn->client_lock); 2874 session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status); 2875 spin_unlock(&nn->client_lock); 2876 if (!session) 2877 goto out_no_session; 2878 status = nfserr_wrong_cred; 2879 if (!nfsd4_mach_creds_match(session->se_client, rqstp)) 2880 goto out; 2881 status = nfsd4_map_bcts_dir(&bcts->dir); 2882 if (status) 2883 goto out; 2884 conn = alloc_conn(rqstp, bcts->dir); 2885 status = nfserr_jukebox; 2886 if (!conn) 2887 goto out; 2888 nfsd4_init_conn(rqstp, conn, session); 2889 status = nfs_ok; 2890 out: 2891 nfsd4_put_session(session); 2892 out_no_session: 2893 return status; 2894 } 2895 2896 static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid) 2897 { 2898 if (!session) 2899 return 0; 2900 return !memcmp(sid, &session->se_sessionid, sizeof(*sid)); 2901 } 2902 2903 __be32 2904 nfsd4_destroy_session(struct svc_rqst *r, 2905 struct nfsd4_compound_state *cstate, 2906 struct nfsd4_destroy_session *sessionid) 2907 { 2908 struct nfsd4_session *ses; 2909 __be32 status; 2910 int ref_held_by_me = 0; 2911 struct net *net = SVC_NET(r); 2912 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2913 2914 status = nfserr_not_only_op; 2915 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) { 2916 if (!nfsd4_last_compound_op(r)) 2917 goto out; 2918 ref_held_by_me++; 2919 } 2920 dump_sessionid(__func__, &sessionid->sessionid); 2921 spin_lock(&nn->client_lock); 2922 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, net, &status); 2923 if (!ses) 2924 goto out_client_lock; 2925 status = nfserr_wrong_cred; 2926 if (!nfsd4_mach_creds_match(ses->se_client, r)) 2927 goto out_put_session; 2928 status = mark_session_dead_locked(ses, 1 + ref_held_by_me); 2929 if (status) 2930 goto out_put_session; 2931 unhash_session(ses); 2932 spin_unlock(&nn->client_lock); 2933 2934 nfsd4_probe_callback_sync(ses->se_client); 2935 2936 spin_lock(&nn->client_lock); 2937 status = nfs_ok; 2938 out_put_session: 2939 nfsd4_put_session_locked(ses); 2940 out_client_lock: 2941 spin_unlock(&nn->client_lock); 2942 out: 2943 return status; 2944 } 2945 2946 static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s) 2947 { 2948 struct nfsd4_conn *c; 2949 2950 list_for_each_entry(c, &s->se_conns, cn_persession) { 2951 if (c->cn_xprt == xpt) { 2952 return c; 2953 } 2954 } 2955 return NULL; 2956 } 2957 2958 static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses) 2959 { 2960 struct nfs4_client *clp = ses->se_client; 2961 struct nfsd4_conn *c; 2962 __be32 status = nfs_ok; 2963 int ret; 2964 2965 spin_lock(&clp->cl_lock); 2966 c = __nfsd4_find_conn(new->cn_xprt, ses); 2967 if (c) 2968 goto out_free; 2969 status = nfserr_conn_not_bound_to_session; 2970 if (clp->cl_mach_cred) 2971 goto out_free; 2972 __nfsd4_hash_conn(new, ses); 2973 spin_unlock(&clp->cl_lock); 2974 ret = nfsd4_register_conn(new); 2975 if (ret) 2976 /* oops; xprt is already down: */ 2977 nfsd4_conn_lost(&new->cn_xpt_user); 2978 return nfs_ok; 2979 out_free: 2980 spin_unlock(&clp->cl_lock); 2981 free_conn(new); 2982 return status; 2983 } 2984 2985 static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session) 2986 { 2987 struct nfsd4_compoundargs *args = rqstp->rq_argp; 2988 2989 return args->opcnt > session->se_fchannel.maxops; 2990 } 2991 2992 static bool nfsd4_request_too_big(struct svc_rqst *rqstp, 2993 struct nfsd4_session *session) 2994 { 2995 struct xdr_buf *xb = &rqstp->rq_arg; 2996 2997 return xb->len > session->se_fchannel.maxreq_sz; 2998 } 2999 3000 __be32 3001 nfsd4_sequence(struct svc_rqst *rqstp, 3002 struct nfsd4_compound_state *cstate, 3003 struct nfsd4_sequence *seq) 3004 { 3005 struct nfsd4_compoundres *resp = rqstp->rq_resp; 3006 struct xdr_stream *xdr = &resp->xdr; 3007 struct nfsd4_session *session; 3008 struct nfs4_client *clp; 3009 struct nfsd4_slot *slot; 3010 struct nfsd4_conn *conn; 3011 __be32 status; 3012 int buflen; 3013 struct net *net = SVC_NET(rqstp); 3014 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 3015 3016 if (resp->opcnt != 1) 3017 return nfserr_sequence_pos; 3018 3019 /* 3020 * Will be either used or freed by nfsd4_sequence_check_conn 3021 * below. 3022 */ 3023 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE); 3024 if (!conn) 3025 return nfserr_jukebox; 3026 3027 spin_lock(&nn->client_lock); 3028 session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status); 3029 if (!session) 3030 goto out_no_session; 3031 clp = session->se_client; 3032 3033 status = nfserr_too_many_ops; 3034 if (nfsd4_session_too_many_ops(rqstp, session)) 3035 goto out_put_session; 3036 3037 status = nfserr_req_too_big; 3038 if (nfsd4_request_too_big(rqstp, session)) 3039 goto out_put_session; 3040 3041 status = nfserr_badslot; 3042 if (seq->slotid >= session->se_fchannel.maxreqs) 3043 goto out_put_session; 3044 3045 slot = session->se_slots[seq->slotid]; 3046 dprintk("%s: slotid %d\n", __func__, seq->slotid); 3047 3048 /* We do not negotiate the number of slots yet, so set the 3049 * maxslots to the session maxreqs which is used to encode 3050 * sr_highest_slotid and the sr_target_slot id to maxslots */ 3051 seq->maxslots = session->se_fchannel.maxreqs; 3052 3053 status = check_slot_seqid(seq->seqid, slot->sl_seqid, 3054 slot->sl_flags & NFSD4_SLOT_INUSE); 3055 if (status == nfserr_replay_cache) { 3056 status = nfserr_seq_misordered; 3057 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED)) 3058 goto out_put_session; 3059 cstate->slot = slot; 3060 cstate->session = session; 3061 cstate->clp = clp; 3062 /* Return the cached reply status and set cstate->status 3063 * for nfsd4_proc_compound processing */ 3064 status = nfsd4_replay_cache_entry(resp, seq); 3065 cstate->status = nfserr_replay_cache; 3066 goto out; 3067 } 3068 if (status) 3069 goto out_put_session; 3070 3071 status = nfsd4_sequence_check_conn(conn, session); 3072 conn = NULL; 3073 if (status) 3074 goto out_put_session; 3075 3076 buflen = (seq->cachethis) ? 3077 session->se_fchannel.maxresp_cached : 3078 session->se_fchannel.maxresp_sz; 3079 status = (seq->cachethis) ? nfserr_rep_too_big_to_cache : 3080 nfserr_rep_too_big; 3081 if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack)) 3082 goto out_put_session; 3083 svc_reserve(rqstp, buflen); 3084 3085 status = nfs_ok; 3086 /* Success! bump slot seqid */ 3087 slot->sl_seqid = seq->seqid; 3088 slot->sl_flags |= NFSD4_SLOT_INUSE; 3089 if (seq->cachethis) 3090 slot->sl_flags |= NFSD4_SLOT_CACHETHIS; 3091 else 3092 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS; 3093 3094 cstate->slot = slot; 3095 cstate->session = session; 3096 cstate->clp = clp; 3097 3098 out: 3099 switch (clp->cl_cb_state) { 3100 case NFSD4_CB_DOWN: 3101 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN; 3102 break; 3103 case NFSD4_CB_FAULT: 3104 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT; 3105 break; 3106 default: 3107 seq->status_flags = 0; 3108 } 3109 if (!list_empty(&clp->cl_revoked)) 3110 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED; 3111 out_no_session: 3112 if (conn) 3113 free_conn(conn); 3114 spin_unlock(&nn->client_lock); 3115 return status; 3116 out_put_session: 3117 nfsd4_put_session_locked(session); 3118 goto out_no_session; 3119 } 3120 3121 void 3122 nfsd4_sequence_done(struct nfsd4_compoundres *resp) 3123 { 3124 struct nfsd4_compound_state *cs = &resp->cstate; 3125 3126 if (nfsd4_has_session(cs)) { 3127 if (cs->status != nfserr_replay_cache) { 3128 nfsd4_store_cache_entry(resp); 3129 cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE; 3130 } 3131 /* Drop session reference that was taken in nfsd4_sequence() */ 3132 nfsd4_put_session(cs->session); 3133 } else if (cs->clp) 3134 put_client_renew(cs->clp); 3135 } 3136 3137 __be32 3138 nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc) 3139 { 3140 struct nfs4_client *conf, *unconf; 3141 struct nfs4_client *clp = NULL; 3142 __be32 status = 0; 3143 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 3144 3145 spin_lock(&nn->client_lock); 3146 unconf = find_unconfirmed_client(&dc->clientid, true, nn); 3147 conf = find_confirmed_client(&dc->clientid, true, nn); 3148 WARN_ON_ONCE(conf && unconf); 3149 3150 if (conf) { 3151 if (client_has_state(conf)) { 3152 status = nfserr_clientid_busy; 3153 goto out; 3154 } 3155 status = mark_client_expired_locked(conf); 3156 if (status) 3157 goto out; 3158 clp = conf; 3159 } else if (unconf) 3160 clp = unconf; 3161 else { 3162 status = nfserr_stale_clientid; 3163 goto out; 3164 } 3165 if (!nfsd4_mach_creds_match(clp, rqstp)) { 3166 clp = NULL; 3167 status = nfserr_wrong_cred; 3168 goto out; 3169 } 3170 unhash_client_locked(clp); 3171 out: 3172 spin_unlock(&nn->client_lock); 3173 if (clp) 3174 expire_client(clp); 3175 return status; 3176 } 3177 3178 __be32 3179 nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc) 3180 { 3181 __be32 status = 0; 3182 3183 if (rc->rca_one_fs) { 3184 if (!cstate->current_fh.fh_dentry) 3185 return nfserr_nofilehandle; 3186 /* 3187 * We don't take advantage of the rca_one_fs case. 3188 * That's OK, it's optional, we can safely ignore it. 3189 */ 3190 return nfs_ok; 3191 } 3192 3193 status = nfserr_complete_already; 3194 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, 3195 &cstate->session->se_client->cl_flags)) 3196 goto out; 3197 3198 status = nfserr_stale_clientid; 3199 if (is_client_expired(cstate->session->se_client)) 3200 /* 3201 * The following error isn't really legal. 3202 * But we only get here if the client just explicitly 3203 * destroyed the client. Surely it no longer cares what 3204 * error it gets back on an operation for the dead 3205 * client. 3206 */ 3207 goto out; 3208 3209 status = nfs_ok; 3210 nfsd4_client_record_create(cstate->session->se_client); 3211 out: 3212 return status; 3213 } 3214 3215 __be32 3216 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 3217 struct nfsd4_setclientid *setclid) 3218 { 3219 struct xdr_netobj clname = setclid->se_name; 3220 nfs4_verifier clverifier = setclid->se_verf; 3221 struct nfs4_client *conf, *new; 3222 struct nfs4_client *unconf = NULL; 3223 __be32 status; 3224 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 3225 3226 new = create_client(clname, rqstp, &clverifier); 3227 if (new == NULL) 3228 return nfserr_jukebox; 3229 /* Cases below refer to rfc 3530 section 14.2.33: */ 3230 spin_lock(&nn->client_lock); 3231 conf = find_confirmed_client_by_name(&clname, nn); 3232 if (conf && client_has_state(conf)) { 3233 /* case 0: */ 3234 status = nfserr_clid_inuse; 3235 if (clp_used_exchangeid(conf)) 3236 goto out; 3237 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) { 3238 char addr_str[INET6_ADDRSTRLEN]; 3239 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str, 3240 sizeof(addr_str)); 3241 dprintk("NFSD: setclientid: string in use by client " 3242 "at %s\n", addr_str); 3243 goto out; 3244 } 3245 } 3246 unconf = find_unconfirmed_client_by_name(&clname, nn); 3247 if (unconf) 3248 unhash_client_locked(unconf); 3249 if (conf && same_verf(&conf->cl_verifier, &clverifier)) { 3250 /* case 1: probable callback update */ 3251 copy_clid(new, conf); 3252 gen_confirm(new, nn); 3253 } else /* case 4 (new client) or cases 2, 3 (client reboot): */ 3254 gen_clid(new, nn); 3255 new->cl_minorversion = 0; 3256 gen_callback(new, setclid, rqstp); 3257 add_to_unconfirmed(new); 3258 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot; 3259 setclid->se_clientid.cl_id = new->cl_clientid.cl_id; 3260 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data)); 3261 new = NULL; 3262 status = nfs_ok; 3263 out: 3264 spin_unlock(&nn->client_lock); 3265 if (new) 3266 free_client(new); 3267 if (unconf) 3268 expire_client(unconf); 3269 return status; 3270 } 3271 3272 3273 __be32 3274 nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 3275 struct nfsd4_compound_state *cstate, 3276 struct nfsd4_setclientid_confirm *setclientid_confirm) 3277 { 3278 struct nfs4_client *conf, *unconf; 3279 struct nfs4_client *old = NULL; 3280 nfs4_verifier confirm = setclientid_confirm->sc_confirm; 3281 clientid_t * clid = &setclientid_confirm->sc_clientid; 3282 __be32 status; 3283 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 3284 3285 if (STALE_CLIENTID(clid, nn)) 3286 return nfserr_stale_clientid; 3287 3288 spin_lock(&nn->client_lock); 3289 conf = find_confirmed_client(clid, false, nn); 3290 unconf = find_unconfirmed_client(clid, false, nn); 3291 /* 3292 * We try hard to give out unique clientid's, so if we get an 3293 * attempt to confirm the same clientid with a different cred, 3294 * the client may be buggy; this should never happen. 3295 * 3296 * Nevertheless, RFC 7530 recommends INUSE for this case: 3297 */ 3298 status = nfserr_clid_inuse; 3299 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred)) 3300 goto out; 3301 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred)) 3302 goto out; 3303 /* cases below refer to rfc 3530 section 14.2.34: */ 3304 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) { 3305 if (conf && same_verf(&confirm, &conf->cl_confirm)) { 3306 /* case 2: probable retransmit */ 3307 status = nfs_ok; 3308 } else /* case 4: client hasn't noticed we rebooted yet? */ 3309 status = nfserr_stale_clientid; 3310 goto out; 3311 } 3312 status = nfs_ok; 3313 if (conf) { /* case 1: callback update */ 3314 old = unconf; 3315 unhash_client_locked(old); 3316 nfsd4_change_callback(conf, &unconf->cl_cb_conn); 3317 } else { /* case 3: normal case; new or rebooted client */ 3318 old = find_confirmed_client_by_name(&unconf->cl_name, nn); 3319 if (old) { 3320 status = nfserr_clid_inuse; 3321 if (client_has_state(old) 3322 && !same_creds(&unconf->cl_cred, 3323 &old->cl_cred)) 3324 goto out; 3325 status = mark_client_expired_locked(old); 3326 if (status) { 3327 old = NULL; 3328 goto out; 3329 } 3330 } 3331 move_to_confirmed(unconf); 3332 conf = unconf; 3333 } 3334 get_client_locked(conf); 3335 spin_unlock(&nn->client_lock); 3336 nfsd4_probe_callback(conf); 3337 spin_lock(&nn->client_lock); 3338 put_client_renew_locked(conf); 3339 out: 3340 spin_unlock(&nn->client_lock); 3341 if (old) 3342 expire_client(old); 3343 return status; 3344 } 3345 3346 static struct nfs4_file *nfsd4_alloc_file(void) 3347 { 3348 return kmem_cache_alloc(file_slab, GFP_KERNEL); 3349 } 3350 3351 /* OPEN Share state helper functions */ 3352 static void nfsd4_init_file(struct knfsd_fh *fh, unsigned int hashval, 3353 struct nfs4_file *fp) 3354 { 3355 lockdep_assert_held(&state_lock); 3356 3357 atomic_set(&fp->fi_ref, 1); 3358 spin_lock_init(&fp->fi_lock); 3359 INIT_LIST_HEAD(&fp->fi_stateids); 3360 INIT_LIST_HEAD(&fp->fi_delegations); 3361 INIT_LIST_HEAD(&fp->fi_clnt_odstate); 3362 fh_copy_shallow(&fp->fi_fhandle, fh); 3363 fp->fi_deleg_file = NULL; 3364 fp->fi_had_conflict = false; 3365 fp->fi_share_deny = 0; 3366 memset(fp->fi_fds, 0, sizeof(fp->fi_fds)); 3367 memset(fp->fi_access, 0, sizeof(fp->fi_access)); 3368 #ifdef CONFIG_NFSD_PNFS 3369 INIT_LIST_HEAD(&fp->fi_lo_states); 3370 atomic_set(&fp->fi_lo_recalls, 0); 3371 #endif 3372 hlist_add_head_rcu(&fp->fi_hash, &file_hashtbl[hashval]); 3373 } 3374 3375 void 3376 nfsd4_free_slabs(void) 3377 { 3378 kmem_cache_destroy(odstate_slab); 3379 kmem_cache_destroy(openowner_slab); 3380 kmem_cache_destroy(lockowner_slab); 3381 kmem_cache_destroy(file_slab); 3382 kmem_cache_destroy(stateid_slab); 3383 kmem_cache_destroy(deleg_slab); 3384 } 3385 3386 int 3387 nfsd4_init_slabs(void) 3388 { 3389 openowner_slab = kmem_cache_create("nfsd4_openowners", 3390 sizeof(struct nfs4_openowner), 0, 0, NULL); 3391 if (openowner_slab == NULL) 3392 goto out; 3393 lockowner_slab = kmem_cache_create("nfsd4_lockowners", 3394 sizeof(struct nfs4_lockowner), 0, 0, NULL); 3395 if (lockowner_slab == NULL) 3396 goto out_free_openowner_slab; 3397 file_slab = kmem_cache_create("nfsd4_files", 3398 sizeof(struct nfs4_file), 0, 0, NULL); 3399 if (file_slab == NULL) 3400 goto out_free_lockowner_slab; 3401 stateid_slab = kmem_cache_create("nfsd4_stateids", 3402 sizeof(struct nfs4_ol_stateid), 0, 0, NULL); 3403 if (stateid_slab == NULL) 3404 goto out_free_file_slab; 3405 deleg_slab = kmem_cache_create("nfsd4_delegations", 3406 sizeof(struct nfs4_delegation), 0, 0, NULL); 3407 if (deleg_slab == NULL) 3408 goto out_free_stateid_slab; 3409 odstate_slab = kmem_cache_create("nfsd4_odstate", 3410 sizeof(struct nfs4_clnt_odstate), 0, 0, NULL); 3411 if (odstate_slab == NULL) 3412 goto out_free_deleg_slab; 3413 return 0; 3414 3415 out_free_deleg_slab: 3416 kmem_cache_destroy(deleg_slab); 3417 out_free_stateid_slab: 3418 kmem_cache_destroy(stateid_slab); 3419 out_free_file_slab: 3420 kmem_cache_destroy(file_slab); 3421 out_free_lockowner_slab: 3422 kmem_cache_destroy(lockowner_slab); 3423 out_free_openowner_slab: 3424 kmem_cache_destroy(openowner_slab); 3425 out: 3426 dprintk("nfsd4: out of memory while initializing nfsv4\n"); 3427 return -ENOMEM; 3428 } 3429 3430 static void init_nfs4_replay(struct nfs4_replay *rp) 3431 { 3432 rp->rp_status = nfserr_serverfault; 3433 rp->rp_buflen = 0; 3434 rp->rp_buf = rp->rp_ibuf; 3435 mutex_init(&rp->rp_mutex); 3436 } 3437 3438 static void nfsd4_cstate_assign_replay(struct nfsd4_compound_state *cstate, 3439 struct nfs4_stateowner *so) 3440 { 3441 if (!nfsd4_has_session(cstate)) { 3442 mutex_lock(&so->so_replay.rp_mutex); 3443 cstate->replay_owner = nfs4_get_stateowner(so); 3444 } 3445 } 3446 3447 void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate) 3448 { 3449 struct nfs4_stateowner *so = cstate->replay_owner; 3450 3451 if (so != NULL) { 3452 cstate->replay_owner = NULL; 3453 mutex_unlock(&so->so_replay.rp_mutex); 3454 nfs4_put_stateowner(so); 3455 } 3456 } 3457 3458 static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp) 3459 { 3460 struct nfs4_stateowner *sop; 3461 3462 sop = kmem_cache_alloc(slab, GFP_KERNEL); 3463 if (!sop) 3464 return NULL; 3465 3466 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL); 3467 if (!sop->so_owner.data) { 3468 kmem_cache_free(slab, sop); 3469 return NULL; 3470 } 3471 sop->so_owner.len = owner->len; 3472 3473 INIT_LIST_HEAD(&sop->so_stateids); 3474 sop->so_client = clp; 3475 init_nfs4_replay(&sop->so_replay); 3476 atomic_set(&sop->so_count, 1); 3477 return sop; 3478 } 3479 3480 static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval) 3481 { 3482 lockdep_assert_held(&clp->cl_lock); 3483 3484 list_add(&oo->oo_owner.so_strhash, 3485 &clp->cl_ownerstr_hashtbl[strhashval]); 3486 list_add(&oo->oo_perclient, &clp->cl_openowners); 3487 } 3488 3489 static void nfs4_unhash_openowner(struct nfs4_stateowner *so) 3490 { 3491 unhash_openowner_locked(openowner(so)); 3492 } 3493 3494 static void nfs4_free_openowner(struct nfs4_stateowner *so) 3495 { 3496 struct nfs4_openowner *oo = openowner(so); 3497 3498 kmem_cache_free(openowner_slab, oo); 3499 } 3500 3501 static const struct nfs4_stateowner_operations openowner_ops = { 3502 .so_unhash = nfs4_unhash_openowner, 3503 .so_free = nfs4_free_openowner, 3504 }; 3505 3506 static struct nfs4_ol_stateid * 3507 nfsd4_find_existing_open(struct nfs4_file *fp, struct nfsd4_open *open) 3508 { 3509 struct nfs4_ol_stateid *local, *ret = NULL; 3510 struct nfs4_openowner *oo = open->op_openowner; 3511 3512 lockdep_assert_held(&fp->fi_lock); 3513 3514 list_for_each_entry(local, &fp->fi_stateids, st_perfile) { 3515 /* ignore lock owners */ 3516 if (local->st_stateowner->so_is_open_owner == 0) 3517 continue; 3518 if (local->st_stateowner == &oo->oo_owner) { 3519 ret = local; 3520 atomic_inc(&ret->st_stid.sc_count); 3521 break; 3522 } 3523 } 3524 return ret; 3525 } 3526 3527 static struct nfs4_openowner * 3528 alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open, 3529 struct nfsd4_compound_state *cstate) 3530 { 3531 struct nfs4_client *clp = cstate->clp; 3532 struct nfs4_openowner *oo, *ret; 3533 3534 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp); 3535 if (!oo) 3536 return NULL; 3537 oo->oo_owner.so_ops = &openowner_ops; 3538 oo->oo_owner.so_is_open_owner = 1; 3539 oo->oo_owner.so_seqid = open->op_seqid; 3540 oo->oo_flags = 0; 3541 if (nfsd4_has_session(cstate)) 3542 oo->oo_flags |= NFS4_OO_CONFIRMED; 3543 oo->oo_time = 0; 3544 oo->oo_last_closed_stid = NULL; 3545 INIT_LIST_HEAD(&oo->oo_close_lru); 3546 spin_lock(&clp->cl_lock); 3547 ret = find_openstateowner_str_locked(strhashval, open, clp); 3548 if (ret == NULL) { 3549 hash_openowner(oo, clp, strhashval); 3550 ret = oo; 3551 } else 3552 nfs4_free_stateowner(&oo->oo_owner); 3553 3554 spin_unlock(&clp->cl_lock); 3555 return ret; 3556 } 3557 3558 static struct nfs4_ol_stateid * 3559 init_open_stateid(struct nfs4_file *fp, struct nfsd4_open *open) 3560 { 3561 3562 struct nfs4_openowner *oo = open->op_openowner; 3563 struct nfs4_ol_stateid *retstp = NULL; 3564 struct nfs4_ol_stateid *stp; 3565 3566 stp = open->op_stp; 3567 /* We are moving these outside of the spinlocks to avoid the warnings */ 3568 mutex_init(&stp->st_mutex); 3569 mutex_lock(&stp->st_mutex); 3570 3571 spin_lock(&oo->oo_owner.so_client->cl_lock); 3572 spin_lock(&fp->fi_lock); 3573 3574 retstp = nfsd4_find_existing_open(fp, open); 3575 if (retstp) 3576 goto out_unlock; 3577 3578 open->op_stp = NULL; 3579 atomic_inc(&stp->st_stid.sc_count); 3580 stp->st_stid.sc_type = NFS4_OPEN_STID; 3581 INIT_LIST_HEAD(&stp->st_locks); 3582 stp->st_stateowner = nfs4_get_stateowner(&oo->oo_owner); 3583 get_nfs4_file(fp); 3584 stp->st_stid.sc_file = fp; 3585 stp->st_access_bmap = 0; 3586 stp->st_deny_bmap = 0; 3587 stp->st_openstp = NULL; 3588 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids); 3589 list_add(&stp->st_perfile, &fp->fi_stateids); 3590 3591 out_unlock: 3592 spin_unlock(&fp->fi_lock); 3593 spin_unlock(&oo->oo_owner.so_client->cl_lock); 3594 if (retstp) { 3595 mutex_lock(&retstp->st_mutex); 3596 /* To keep mutex tracking happy */ 3597 mutex_unlock(&stp->st_mutex); 3598 stp = retstp; 3599 } 3600 return stp; 3601 } 3602 3603 /* 3604 * In the 4.0 case we need to keep the owners around a little while to handle 3605 * CLOSE replay. We still do need to release any file access that is held by 3606 * them before returning however. 3607 */ 3608 static void 3609 move_to_close_lru(struct nfs4_ol_stateid *s, struct net *net) 3610 { 3611 struct nfs4_ol_stateid *last; 3612 struct nfs4_openowner *oo = openowner(s->st_stateowner); 3613 struct nfsd_net *nn = net_generic(s->st_stid.sc_client->net, 3614 nfsd_net_id); 3615 3616 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo); 3617 3618 /* 3619 * We know that we hold one reference via nfsd4_close, and another 3620 * "persistent" reference for the client. If the refcount is higher 3621 * than 2, then there are still calls in progress that are using this 3622 * stateid. We can't put the sc_file reference until they are finished. 3623 * Wait for the refcount to drop to 2. Since it has been unhashed, 3624 * there should be no danger of the refcount going back up again at 3625 * this point. 3626 */ 3627 wait_event(close_wq, atomic_read(&s->st_stid.sc_count) == 2); 3628 3629 release_all_access(s); 3630 if (s->st_stid.sc_file) { 3631 put_nfs4_file(s->st_stid.sc_file); 3632 s->st_stid.sc_file = NULL; 3633 } 3634 3635 spin_lock(&nn->client_lock); 3636 last = oo->oo_last_closed_stid; 3637 oo->oo_last_closed_stid = s; 3638 list_move_tail(&oo->oo_close_lru, &nn->close_lru); 3639 oo->oo_time = get_seconds(); 3640 spin_unlock(&nn->client_lock); 3641 if (last) 3642 nfs4_put_stid(&last->st_stid); 3643 } 3644 3645 /* search file_hashtbl[] for file */ 3646 static struct nfs4_file * 3647 find_file_locked(struct knfsd_fh *fh, unsigned int hashval) 3648 { 3649 struct nfs4_file *fp; 3650 3651 hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash) { 3652 if (fh_match(&fp->fi_fhandle, fh)) { 3653 if (atomic_inc_not_zero(&fp->fi_ref)) 3654 return fp; 3655 } 3656 } 3657 return NULL; 3658 } 3659 3660 struct nfs4_file * 3661 find_file(struct knfsd_fh *fh) 3662 { 3663 struct nfs4_file *fp; 3664 unsigned int hashval = file_hashval(fh); 3665 3666 rcu_read_lock(); 3667 fp = find_file_locked(fh, hashval); 3668 rcu_read_unlock(); 3669 return fp; 3670 } 3671 3672 static struct nfs4_file * 3673 find_or_add_file(struct nfs4_file *new, struct knfsd_fh *fh) 3674 { 3675 struct nfs4_file *fp; 3676 unsigned int hashval = file_hashval(fh); 3677 3678 rcu_read_lock(); 3679 fp = find_file_locked(fh, hashval); 3680 rcu_read_unlock(); 3681 if (fp) 3682 return fp; 3683 3684 spin_lock(&state_lock); 3685 fp = find_file_locked(fh, hashval); 3686 if (likely(fp == NULL)) { 3687 nfsd4_init_file(fh, hashval, new); 3688 fp = new; 3689 } 3690 spin_unlock(&state_lock); 3691 3692 return fp; 3693 } 3694 3695 /* 3696 * Called to check deny when READ with all zero stateid or 3697 * WRITE with all zero or all one stateid 3698 */ 3699 static __be32 3700 nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type) 3701 { 3702 struct nfs4_file *fp; 3703 __be32 ret = nfs_ok; 3704 3705 fp = find_file(¤t_fh->fh_handle); 3706 if (!fp) 3707 return ret; 3708 /* Check for conflicting share reservations */ 3709 spin_lock(&fp->fi_lock); 3710 if (fp->fi_share_deny & deny_type) 3711 ret = nfserr_locked; 3712 spin_unlock(&fp->fi_lock); 3713 put_nfs4_file(fp); 3714 return ret; 3715 } 3716 3717 static void nfsd4_cb_recall_prepare(struct nfsd4_callback *cb) 3718 { 3719 struct nfs4_delegation *dp = cb_to_delegation(cb); 3720 struct nfsd_net *nn = net_generic(dp->dl_stid.sc_client->net, 3721 nfsd_net_id); 3722 3723 block_delegations(&dp->dl_stid.sc_file->fi_fhandle); 3724 3725 /* 3726 * We can't do this in nfsd_break_deleg_cb because it is 3727 * already holding inode->i_lock. 3728 * 3729 * If the dl_time != 0, then we know that it has already been 3730 * queued for a lease break. Don't queue it again. 3731 */ 3732 spin_lock(&state_lock); 3733 if (dp->dl_time == 0) { 3734 dp->dl_time = get_seconds(); 3735 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru); 3736 } 3737 spin_unlock(&state_lock); 3738 } 3739 3740 static int nfsd4_cb_recall_done(struct nfsd4_callback *cb, 3741 struct rpc_task *task) 3742 { 3743 struct nfs4_delegation *dp = cb_to_delegation(cb); 3744 3745 if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID) 3746 return 1; 3747 3748 switch (task->tk_status) { 3749 case 0: 3750 return 1; 3751 case -EBADHANDLE: 3752 case -NFS4ERR_BAD_STATEID: 3753 /* 3754 * Race: client probably got cb_recall before open reply 3755 * granting delegation. 3756 */ 3757 if (dp->dl_retries--) { 3758 rpc_delay(task, 2 * HZ); 3759 return 0; 3760 } 3761 /*FALLTHRU*/ 3762 default: 3763 return -1; 3764 } 3765 } 3766 3767 static void nfsd4_cb_recall_release(struct nfsd4_callback *cb) 3768 { 3769 struct nfs4_delegation *dp = cb_to_delegation(cb); 3770 3771 nfs4_put_stid(&dp->dl_stid); 3772 } 3773 3774 static const struct nfsd4_callback_ops nfsd4_cb_recall_ops = { 3775 .prepare = nfsd4_cb_recall_prepare, 3776 .done = nfsd4_cb_recall_done, 3777 .release = nfsd4_cb_recall_release, 3778 }; 3779 3780 static void nfsd_break_one_deleg(struct nfs4_delegation *dp) 3781 { 3782 /* 3783 * We're assuming the state code never drops its reference 3784 * without first removing the lease. Since we're in this lease 3785 * callback (and since the lease code is serialized by the kernel 3786 * lock) we know the server hasn't removed the lease yet, we know 3787 * it's safe to take a reference. 3788 */ 3789 atomic_inc(&dp->dl_stid.sc_count); 3790 nfsd4_run_cb(&dp->dl_recall); 3791 } 3792 3793 /* Called from break_lease() with i_lock held. */ 3794 static bool 3795 nfsd_break_deleg_cb(struct file_lock *fl) 3796 { 3797 bool ret = false; 3798 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner; 3799 struct nfs4_delegation *dp; 3800 3801 if (!fp) { 3802 WARN(1, "(%p)->fl_owner NULL\n", fl); 3803 return ret; 3804 } 3805 if (fp->fi_had_conflict) { 3806 WARN(1, "duplicate break on %p\n", fp); 3807 return ret; 3808 } 3809 /* 3810 * We don't want the locks code to timeout the lease for us; 3811 * we'll remove it ourself if a delegation isn't returned 3812 * in time: 3813 */ 3814 fl->fl_break_time = 0; 3815 3816 spin_lock(&fp->fi_lock); 3817 fp->fi_had_conflict = true; 3818 /* 3819 * If there are no delegations on the list, then return true 3820 * so that the lease code will go ahead and delete it. 3821 */ 3822 if (list_empty(&fp->fi_delegations)) 3823 ret = true; 3824 else 3825 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) 3826 nfsd_break_one_deleg(dp); 3827 spin_unlock(&fp->fi_lock); 3828 return ret; 3829 } 3830 3831 static int 3832 nfsd_change_deleg_cb(struct file_lock *onlist, int arg, 3833 struct list_head *dispose) 3834 { 3835 if (arg & F_UNLCK) 3836 return lease_modify(onlist, arg, dispose); 3837 else 3838 return -EAGAIN; 3839 } 3840 3841 static const struct lock_manager_operations nfsd_lease_mng_ops = { 3842 .lm_break = nfsd_break_deleg_cb, 3843 .lm_change = nfsd_change_deleg_cb, 3844 }; 3845 3846 static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid) 3847 { 3848 if (nfsd4_has_session(cstate)) 3849 return nfs_ok; 3850 if (seqid == so->so_seqid - 1) 3851 return nfserr_replay_me; 3852 if (seqid == so->so_seqid) 3853 return nfs_ok; 3854 return nfserr_bad_seqid; 3855 } 3856 3857 static __be32 lookup_clientid(clientid_t *clid, 3858 struct nfsd4_compound_state *cstate, 3859 struct nfsd_net *nn) 3860 { 3861 struct nfs4_client *found; 3862 3863 if (cstate->clp) { 3864 found = cstate->clp; 3865 if (!same_clid(&found->cl_clientid, clid)) 3866 return nfserr_stale_clientid; 3867 return nfs_ok; 3868 } 3869 3870 if (STALE_CLIENTID(clid, nn)) 3871 return nfserr_stale_clientid; 3872 3873 /* 3874 * For v4.1+ we get the client in the SEQUENCE op. If we don't have one 3875 * cached already then we know this is for is for v4.0 and "sessions" 3876 * will be false. 3877 */ 3878 WARN_ON_ONCE(cstate->session); 3879 spin_lock(&nn->client_lock); 3880 found = find_confirmed_client(clid, false, nn); 3881 if (!found) { 3882 spin_unlock(&nn->client_lock); 3883 return nfserr_expired; 3884 } 3885 atomic_inc(&found->cl_refcount); 3886 spin_unlock(&nn->client_lock); 3887 3888 /* Cache the nfs4_client in cstate! */ 3889 cstate->clp = found; 3890 return nfs_ok; 3891 } 3892 3893 __be32 3894 nfsd4_process_open1(struct nfsd4_compound_state *cstate, 3895 struct nfsd4_open *open, struct nfsd_net *nn) 3896 { 3897 clientid_t *clientid = &open->op_clientid; 3898 struct nfs4_client *clp = NULL; 3899 unsigned int strhashval; 3900 struct nfs4_openowner *oo = NULL; 3901 __be32 status; 3902 3903 if (STALE_CLIENTID(&open->op_clientid, nn)) 3904 return nfserr_stale_clientid; 3905 /* 3906 * In case we need it later, after we've already created the 3907 * file and don't want to risk a further failure: 3908 */ 3909 open->op_file = nfsd4_alloc_file(); 3910 if (open->op_file == NULL) 3911 return nfserr_jukebox; 3912 3913 status = lookup_clientid(clientid, cstate, nn); 3914 if (status) 3915 return status; 3916 clp = cstate->clp; 3917 3918 strhashval = ownerstr_hashval(&open->op_owner); 3919 oo = find_openstateowner_str(strhashval, open, clp); 3920 open->op_openowner = oo; 3921 if (!oo) { 3922 goto new_owner; 3923 } 3924 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) { 3925 /* Replace unconfirmed owners without checking for replay. */ 3926 release_openowner(oo); 3927 open->op_openowner = NULL; 3928 goto new_owner; 3929 } 3930 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid); 3931 if (status) 3932 return status; 3933 goto alloc_stateid; 3934 new_owner: 3935 oo = alloc_init_open_stateowner(strhashval, open, cstate); 3936 if (oo == NULL) 3937 return nfserr_jukebox; 3938 open->op_openowner = oo; 3939 alloc_stateid: 3940 open->op_stp = nfs4_alloc_open_stateid(clp); 3941 if (!open->op_stp) 3942 return nfserr_jukebox; 3943 3944 if (nfsd4_has_session(cstate) && 3945 (cstate->current_fh.fh_export->ex_flags & NFSEXP_PNFS)) { 3946 open->op_odstate = alloc_clnt_odstate(clp); 3947 if (!open->op_odstate) 3948 return nfserr_jukebox; 3949 } 3950 3951 return nfs_ok; 3952 } 3953 3954 static inline __be32 3955 nfs4_check_delegmode(struct nfs4_delegation *dp, int flags) 3956 { 3957 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ)) 3958 return nfserr_openmode; 3959 else 3960 return nfs_ok; 3961 } 3962 3963 static int share_access_to_flags(u32 share_access) 3964 { 3965 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE; 3966 } 3967 3968 static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s) 3969 { 3970 struct nfs4_stid *ret; 3971 3972 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID); 3973 if (!ret) 3974 return NULL; 3975 return delegstateid(ret); 3976 } 3977 3978 static bool nfsd4_is_deleg_cur(struct nfsd4_open *open) 3979 { 3980 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR || 3981 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH; 3982 } 3983 3984 static __be32 3985 nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open, 3986 struct nfs4_delegation **dp) 3987 { 3988 int flags; 3989 __be32 status = nfserr_bad_stateid; 3990 struct nfs4_delegation *deleg; 3991 3992 deleg = find_deleg_stateid(cl, &open->op_delegate_stateid); 3993 if (deleg == NULL) 3994 goto out; 3995 flags = share_access_to_flags(open->op_share_access); 3996 status = nfs4_check_delegmode(deleg, flags); 3997 if (status) { 3998 nfs4_put_stid(&deleg->dl_stid); 3999 goto out; 4000 } 4001 *dp = deleg; 4002 out: 4003 if (!nfsd4_is_deleg_cur(open)) 4004 return nfs_ok; 4005 if (status) 4006 return status; 4007 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; 4008 return nfs_ok; 4009 } 4010 4011 static inline int nfs4_access_to_access(u32 nfs4_access) 4012 { 4013 int flags = 0; 4014 4015 if (nfs4_access & NFS4_SHARE_ACCESS_READ) 4016 flags |= NFSD_MAY_READ; 4017 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE) 4018 flags |= NFSD_MAY_WRITE; 4019 return flags; 4020 } 4021 4022 static inline __be32 4023 nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh, 4024 struct nfsd4_open *open) 4025 { 4026 struct iattr iattr = { 4027 .ia_valid = ATTR_SIZE, 4028 .ia_size = 0, 4029 }; 4030 if (!open->op_truncate) 4031 return 0; 4032 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 4033 return nfserr_inval; 4034 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0); 4035 } 4036 4037 static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp, 4038 struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, 4039 struct nfsd4_open *open) 4040 { 4041 struct file *filp = NULL; 4042 __be32 status; 4043 int oflag = nfs4_access_to_omode(open->op_share_access); 4044 int access = nfs4_access_to_access(open->op_share_access); 4045 unsigned char old_access_bmap, old_deny_bmap; 4046 4047 spin_lock(&fp->fi_lock); 4048 4049 /* 4050 * Are we trying to set a deny mode that would conflict with 4051 * current access? 4052 */ 4053 status = nfs4_file_check_deny(fp, open->op_share_deny); 4054 if (status != nfs_ok) { 4055 spin_unlock(&fp->fi_lock); 4056 goto out; 4057 } 4058 4059 /* set access to the file */ 4060 status = nfs4_file_get_access(fp, open->op_share_access); 4061 if (status != nfs_ok) { 4062 spin_unlock(&fp->fi_lock); 4063 goto out; 4064 } 4065 4066 /* Set access bits in stateid */ 4067 old_access_bmap = stp->st_access_bmap; 4068 set_access(open->op_share_access, stp); 4069 4070 /* Set new deny mask */ 4071 old_deny_bmap = stp->st_deny_bmap; 4072 set_deny(open->op_share_deny, stp); 4073 fp->fi_share_deny |= (open->op_share_deny & NFS4_SHARE_DENY_BOTH); 4074 4075 if (!fp->fi_fds[oflag]) { 4076 spin_unlock(&fp->fi_lock); 4077 status = nfsd_open(rqstp, cur_fh, S_IFREG, access, &filp); 4078 if (status) 4079 goto out_put_access; 4080 spin_lock(&fp->fi_lock); 4081 if (!fp->fi_fds[oflag]) { 4082 fp->fi_fds[oflag] = filp; 4083 filp = NULL; 4084 } 4085 } 4086 spin_unlock(&fp->fi_lock); 4087 if (filp) 4088 fput(filp); 4089 4090 status = nfsd4_truncate(rqstp, cur_fh, open); 4091 if (status) 4092 goto out_put_access; 4093 out: 4094 return status; 4095 out_put_access: 4096 stp->st_access_bmap = old_access_bmap; 4097 nfs4_file_put_access(fp, open->op_share_access); 4098 reset_union_bmap_deny(bmap_to_share_mode(old_deny_bmap), stp); 4099 goto out; 4100 } 4101 4102 static __be32 4103 nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open) 4104 { 4105 __be32 status; 4106 unsigned char old_deny_bmap = stp->st_deny_bmap; 4107 4108 if (!test_access(open->op_share_access, stp)) 4109 return nfs4_get_vfs_file(rqstp, fp, cur_fh, stp, open); 4110 4111 /* test and set deny mode */ 4112 spin_lock(&fp->fi_lock); 4113 status = nfs4_file_check_deny(fp, open->op_share_deny); 4114 if (status == nfs_ok) { 4115 set_deny(open->op_share_deny, stp); 4116 fp->fi_share_deny |= 4117 (open->op_share_deny & NFS4_SHARE_DENY_BOTH); 4118 } 4119 spin_unlock(&fp->fi_lock); 4120 4121 if (status != nfs_ok) 4122 return status; 4123 4124 status = nfsd4_truncate(rqstp, cur_fh, open); 4125 if (status != nfs_ok) 4126 reset_union_bmap_deny(old_deny_bmap, stp); 4127 return status; 4128 } 4129 4130 /* Should we give out recallable state?: */ 4131 static bool nfsd4_cb_channel_good(struct nfs4_client *clp) 4132 { 4133 if (clp->cl_cb_state == NFSD4_CB_UP) 4134 return true; 4135 /* 4136 * In the sessions case, since we don't have to establish a 4137 * separate connection for callbacks, we assume it's OK 4138 * until we hear otherwise: 4139 */ 4140 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN; 4141 } 4142 4143 static struct file_lock *nfs4_alloc_init_lease(struct nfs4_file *fp, int flag) 4144 { 4145 struct file_lock *fl; 4146 4147 fl = locks_alloc_lock(); 4148 if (!fl) 4149 return NULL; 4150 fl->fl_lmops = &nfsd_lease_mng_ops; 4151 fl->fl_flags = FL_DELEG; 4152 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; 4153 fl->fl_end = OFFSET_MAX; 4154 fl->fl_owner = (fl_owner_t)fp; 4155 fl->fl_pid = current->tgid; 4156 return fl; 4157 } 4158 4159 /** 4160 * nfs4_setlease - Obtain a delegation by requesting lease from vfs layer 4161 * @dp: a pointer to the nfs4_delegation we're adding. 4162 * 4163 * Return: 4164 * On success: Return code will be 0 on success. 4165 * 4166 * On error: -EAGAIN if there was an existing delegation. 4167 * nonzero if there is an error in other cases. 4168 * 4169 */ 4170 4171 static int nfs4_setlease(struct nfs4_delegation *dp) 4172 { 4173 struct nfs4_file *fp = dp->dl_stid.sc_file; 4174 struct file_lock *fl; 4175 struct file *filp; 4176 int status = 0; 4177 4178 fl = nfs4_alloc_init_lease(fp, NFS4_OPEN_DELEGATE_READ); 4179 if (!fl) 4180 return -ENOMEM; 4181 filp = find_readable_file(fp); 4182 if (!filp) { 4183 /* We should always have a readable file here */ 4184 WARN_ON_ONCE(1); 4185 locks_free_lock(fl); 4186 return -EBADF; 4187 } 4188 fl->fl_file = filp; 4189 status = vfs_setlease(filp, fl->fl_type, &fl, NULL); 4190 if (fl) 4191 locks_free_lock(fl); 4192 if (status) 4193 goto out_fput; 4194 spin_lock(&state_lock); 4195 spin_lock(&fp->fi_lock); 4196 /* Did the lease get broken before we took the lock? */ 4197 status = -EAGAIN; 4198 if (fp->fi_had_conflict) 4199 goto out_unlock; 4200 /* Race breaker */ 4201 if (fp->fi_deleg_file) { 4202 status = hash_delegation_locked(dp, fp); 4203 goto out_unlock; 4204 } 4205 fp->fi_deleg_file = filp; 4206 fp->fi_delegees = 0; 4207 status = hash_delegation_locked(dp, fp); 4208 spin_unlock(&fp->fi_lock); 4209 spin_unlock(&state_lock); 4210 if (status) { 4211 /* Should never happen, this is a new fi_deleg_file */ 4212 WARN_ON_ONCE(1); 4213 goto out_fput; 4214 } 4215 return 0; 4216 out_unlock: 4217 spin_unlock(&fp->fi_lock); 4218 spin_unlock(&state_lock); 4219 out_fput: 4220 fput(filp); 4221 return status; 4222 } 4223 4224 static struct nfs4_delegation * 4225 nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh, 4226 struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate) 4227 { 4228 int status; 4229 struct nfs4_delegation *dp; 4230 4231 if (fp->fi_had_conflict) 4232 return ERR_PTR(-EAGAIN); 4233 4234 spin_lock(&state_lock); 4235 spin_lock(&fp->fi_lock); 4236 status = nfs4_get_existing_delegation(clp, fp); 4237 spin_unlock(&fp->fi_lock); 4238 spin_unlock(&state_lock); 4239 4240 if (status) 4241 return ERR_PTR(status); 4242 4243 dp = alloc_init_deleg(clp, fh, odstate); 4244 if (!dp) 4245 return ERR_PTR(-ENOMEM); 4246 4247 get_nfs4_file(fp); 4248 spin_lock(&state_lock); 4249 spin_lock(&fp->fi_lock); 4250 dp->dl_stid.sc_file = fp; 4251 if (!fp->fi_deleg_file) { 4252 spin_unlock(&fp->fi_lock); 4253 spin_unlock(&state_lock); 4254 status = nfs4_setlease(dp); 4255 goto out; 4256 } 4257 if (fp->fi_had_conflict) { 4258 status = -EAGAIN; 4259 goto out_unlock; 4260 } 4261 status = hash_delegation_locked(dp, fp); 4262 out_unlock: 4263 spin_unlock(&fp->fi_lock); 4264 spin_unlock(&state_lock); 4265 out: 4266 if (status) { 4267 put_clnt_odstate(dp->dl_clnt_odstate); 4268 nfs4_put_stid(&dp->dl_stid); 4269 return ERR_PTR(status); 4270 } 4271 return dp; 4272 } 4273 4274 static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status) 4275 { 4276 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT; 4277 if (status == -EAGAIN) 4278 open->op_why_no_deleg = WND4_CONTENTION; 4279 else { 4280 open->op_why_no_deleg = WND4_RESOURCE; 4281 switch (open->op_deleg_want) { 4282 case NFS4_SHARE_WANT_READ_DELEG: 4283 case NFS4_SHARE_WANT_WRITE_DELEG: 4284 case NFS4_SHARE_WANT_ANY_DELEG: 4285 break; 4286 case NFS4_SHARE_WANT_CANCEL: 4287 open->op_why_no_deleg = WND4_CANCELLED; 4288 break; 4289 case NFS4_SHARE_WANT_NO_DELEG: 4290 WARN_ON_ONCE(1); 4291 } 4292 } 4293 } 4294 4295 /* 4296 * Attempt to hand out a delegation. 4297 * 4298 * Note we don't support write delegations, and won't until the vfs has 4299 * proper support for them. 4300 */ 4301 static void 4302 nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, 4303 struct nfs4_ol_stateid *stp) 4304 { 4305 struct nfs4_delegation *dp; 4306 struct nfs4_openowner *oo = openowner(stp->st_stateowner); 4307 struct nfs4_client *clp = stp->st_stid.sc_client; 4308 int cb_up; 4309 int status = 0; 4310 4311 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client); 4312 open->op_recall = 0; 4313 switch (open->op_claim_type) { 4314 case NFS4_OPEN_CLAIM_PREVIOUS: 4315 if (!cb_up) 4316 open->op_recall = 1; 4317 if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ) 4318 goto out_no_deleg; 4319 break; 4320 case NFS4_OPEN_CLAIM_NULL: 4321 case NFS4_OPEN_CLAIM_FH: 4322 /* 4323 * Let's not give out any delegations till everyone's 4324 * had the chance to reclaim theirs, *and* until 4325 * NLM locks have all been reclaimed: 4326 */ 4327 if (locks_in_grace(clp->net)) 4328 goto out_no_deleg; 4329 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED)) 4330 goto out_no_deleg; 4331 /* 4332 * Also, if the file was opened for write or 4333 * create, there's a good chance the client's 4334 * about to write to it, resulting in an 4335 * immediate recall (since we don't support 4336 * write delegations): 4337 */ 4338 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 4339 goto out_no_deleg; 4340 if (open->op_create == NFS4_OPEN_CREATE) 4341 goto out_no_deleg; 4342 break; 4343 default: 4344 goto out_no_deleg; 4345 } 4346 dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate); 4347 if (IS_ERR(dp)) 4348 goto out_no_deleg; 4349 4350 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid)); 4351 4352 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n", 4353 STATEID_VAL(&dp->dl_stid.sc_stateid)); 4354 open->op_delegate_type = NFS4_OPEN_DELEGATE_READ; 4355 nfs4_put_stid(&dp->dl_stid); 4356 return; 4357 out_no_deleg: 4358 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE; 4359 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS && 4360 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) { 4361 dprintk("NFSD: WARNING: refusing delegation reclaim\n"); 4362 open->op_recall = 1; 4363 } 4364 4365 /* 4.1 client asking for a delegation? */ 4366 if (open->op_deleg_want) 4367 nfsd4_open_deleg_none_ext(open, status); 4368 return; 4369 } 4370 4371 static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open, 4372 struct nfs4_delegation *dp) 4373 { 4374 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG && 4375 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) { 4376 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT; 4377 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE; 4378 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG && 4379 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) { 4380 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT; 4381 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE; 4382 } 4383 /* Otherwise the client must be confused wanting a delegation 4384 * it already has, therefore we don't return 4385 * NFS4_OPEN_DELEGATE_NONE_EXT and reason. 4386 */ 4387 } 4388 4389 __be32 4390 nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 4391 { 4392 struct nfsd4_compoundres *resp = rqstp->rq_resp; 4393 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client; 4394 struct nfs4_file *fp = NULL; 4395 struct nfs4_ol_stateid *stp = NULL; 4396 struct nfs4_delegation *dp = NULL; 4397 __be32 status; 4398 4399 /* 4400 * Lookup file; if found, lookup stateid and check open request, 4401 * and check for delegations in the process of being recalled. 4402 * If not found, create the nfs4_file struct 4403 */ 4404 fp = find_or_add_file(open->op_file, ¤t_fh->fh_handle); 4405 if (fp != open->op_file) { 4406 status = nfs4_check_deleg(cl, open, &dp); 4407 if (status) 4408 goto out; 4409 spin_lock(&fp->fi_lock); 4410 stp = nfsd4_find_existing_open(fp, open); 4411 spin_unlock(&fp->fi_lock); 4412 } else { 4413 open->op_file = NULL; 4414 status = nfserr_bad_stateid; 4415 if (nfsd4_is_deleg_cur(open)) 4416 goto out; 4417 } 4418 4419 /* 4420 * OPEN the file, or upgrade an existing OPEN. 4421 * If truncate fails, the OPEN fails. 4422 */ 4423 if (stp) { 4424 /* Stateid was found, this is an OPEN upgrade */ 4425 mutex_lock(&stp->st_mutex); 4426 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open); 4427 if (status) { 4428 mutex_unlock(&stp->st_mutex); 4429 goto out; 4430 } 4431 } else { 4432 /* stp is returned locked. */ 4433 stp = init_open_stateid(fp, open); 4434 /* See if we lost the race to some other thread */ 4435 if (stp->st_access_bmap != 0) { 4436 status = nfs4_upgrade_open(rqstp, fp, current_fh, 4437 stp, open); 4438 if (status) { 4439 mutex_unlock(&stp->st_mutex); 4440 goto out; 4441 } 4442 goto upgrade_out; 4443 } 4444 status = nfs4_get_vfs_file(rqstp, fp, current_fh, stp, open); 4445 if (status) { 4446 mutex_unlock(&stp->st_mutex); 4447 release_open_stateid(stp); 4448 goto out; 4449 } 4450 4451 stp->st_clnt_odstate = find_or_hash_clnt_odstate(fp, 4452 open->op_odstate); 4453 if (stp->st_clnt_odstate == open->op_odstate) 4454 open->op_odstate = NULL; 4455 } 4456 upgrade_out: 4457 nfs4_inc_and_copy_stateid(&open->op_stateid, &stp->st_stid); 4458 mutex_unlock(&stp->st_mutex); 4459 4460 if (nfsd4_has_session(&resp->cstate)) { 4461 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) { 4462 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT; 4463 open->op_why_no_deleg = WND4_NOT_WANTED; 4464 goto nodeleg; 4465 } 4466 } 4467 4468 /* 4469 * Attempt to hand out a delegation. No error return, because the 4470 * OPEN succeeds even if we fail. 4471 */ 4472 nfs4_open_delegation(current_fh, open, stp); 4473 nodeleg: 4474 status = nfs_ok; 4475 4476 dprintk("%s: stateid=" STATEID_FMT "\n", __func__, 4477 STATEID_VAL(&stp->st_stid.sc_stateid)); 4478 out: 4479 /* 4.1 client trying to upgrade/downgrade delegation? */ 4480 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp && 4481 open->op_deleg_want) 4482 nfsd4_deleg_xgrade_none_ext(open, dp); 4483 4484 if (fp) 4485 put_nfs4_file(fp); 4486 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 4487 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; 4488 /* 4489 * To finish the open response, we just need to set the rflags. 4490 */ 4491 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX; 4492 if (nfsd4_has_session(&resp->cstate)) 4493 open->op_rflags |= NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK; 4494 else if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED)) 4495 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM; 4496 4497 if (dp) 4498 nfs4_put_stid(&dp->dl_stid); 4499 if (stp) 4500 nfs4_put_stid(&stp->st_stid); 4501 4502 return status; 4503 } 4504 4505 void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate, 4506 struct nfsd4_open *open) 4507 { 4508 if (open->op_openowner) { 4509 struct nfs4_stateowner *so = &open->op_openowner->oo_owner; 4510 4511 nfsd4_cstate_assign_replay(cstate, so); 4512 nfs4_put_stateowner(so); 4513 } 4514 if (open->op_file) 4515 kmem_cache_free(file_slab, open->op_file); 4516 if (open->op_stp) 4517 nfs4_put_stid(&open->op_stp->st_stid); 4518 if (open->op_odstate) 4519 kmem_cache_free(odstate_slab, open->op_odstate); 4520 } 4521 4522 __be32 4523 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 4524 clientid_t *clid) 4525 { 4526 struct nfs4_client *clp; 4527 __be32 status; 4528 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 4529 4530 dprintk("process_renew(%08x/%08x): starting\n", 4531 clid->cl_boot, clid->cl_id); 4532 status = lookup_clientid(clid, cstate, nn); 4533 if (status) 4534 goto out; 4535 clp = cstate->clp; 4536 status = nfserr_cb_path_down; 4537 if (!list_empty(&clp->cl_delegations) 4538 && clp->cl_cb_state != NFSD4_CB_UP) 4539 goto out; 4540 status = nfs_ok; 4541 out: 4542 return status; 4543 } 4544 4545 void 4546 nfsd4_end_grace(struct nfsd_net *nn) 4547 { 4548 /* do nothing if grace period already ended */ 4549 if (nn->grace_ended) 4550 return; 4551 4552 dprintk("NFSD: end of grace period\n"); 4553 nn->grace_ended = true; 4554 /* 4555 * If the server goes down again right now, an NFSv4 4556 * client will still be allowed to reclaim after it comes back up, 4557 * even if it hasn't yet had a chance to reclaim state this time. 4558 * 4559 */ 4560 nfsd4_record_grace_done(nn); 4561 /* 4562 * At this point, NFSv4 clients can still reclaim. But if the 4563 * server crashes, any that have not yet reclaimed will be out 4564 * of luck on the next boot. 4565 * 4566 * (NFSv4.1+ clients are considered to have reclaimed once they 4567 * call RECLAIM_COMPLETE. NFSv4.0 clients are considered to 4568 * have reclaimed after their first OPEN.) 4569 */ 4570 locks_end_grace(&nn->nfsd4_manager); 4571 /* 4572 * At this point, and once lockd and/or any other containers 4573 * exit their grace period, further reclaims will fail and 4574 * regular locking can resume. 4575 */ 4576 } 4577 4578 static time_t 4579 nfs4_laundromat(struct nfsd_net *nn) 4580 { 4581 struct nfs4_client *clp; 4582 struct nfs4_openowner *oo; 4583 struct nfs4_delegation *dp; 4584 struct nfs4_ol_stateid *stp; 4585 struct nfsd4_blocked_lock *nbl; 4586 struct list_head *pos, *next, reaplist; 4587 time_t cutoff = get_seconds() - nn->nfsd4_lease; 4588 time_t t, new_timeo = nn->nfsd4_lease; 4589 4590 dprintk("NFSD: laundromat service - starting\n"); 4591 nfsd4_end_grace(nn); 4592 INIT_LIST_HEAD(&reaplist); 4593 spin_lock(&nn->client_lock); 4594 list_for_each_safe(pos, next, &nn->client_lru) { 4595 clp = list_entry(pos, struct nfs4_client, cl_lru); 4596 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) { 4597 t = clp->cl_time - cutoff; 4598 new_timeo = min(new_timeo, t); 4599 break; 4600 } 4601 if (mark_client_expired_locked(clp)) { 4602 dprintk("NFSD: client in use (clientid %08x)\n", 4603 clp->cl_clientid.cl_id); 4604 continue; 4605 } 4606 list_add(&clp->cl_lru, &reaplist); 4607 } 4608 spin_unlock(&nn->client_lock); 4609 list_for_each_safe(pos, next, &reaplist) { 4610 clp = list_entry(pos, struct nfs4_client, cl_lru); 4611 dprintk("NFSD: purging unused client (clientid %08x)\n", 4612 clp->cl_clientid.cl_id); 4613 list_del_init(&clp->cl_lru); 4614 expire_client(clp); 4615 } 4616 spin_lock(&state_lock); 4617 list_for_each_safe(pos, next, &nn->del_recall_lru) { 4618 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 4619 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) { 4620 t = dp->dl_time - cutoff; 4621 new_timeo = min(new_timeo, t); 4622 break; 4623 } 4624 WARN_ON(!unhash_delegation_locked(dp)); 4625 list_add(&dp->dl_recall_lru, &reaplist); 4626 } 4627 spin_unlock(&state_lock); 4628 while (!list_empty(&reaplist)) { 4629 dp = list_first_entry(&reaplist, struct nfs4_delegation, 4630 dl_recall_lru); 4631 list_del_init(&dp->dl_recall_lru); 4632 revoke_delegation(dp); 4633 } 4634 4635 spin_lock(&nn->client_lock); 4636 while (!list_empty(&nn->close_lru)) { 4637 oo = list_first_entry(&nn->close_lru, struct nfs4_openowner, 4638 oo_close_lru); 4639 if (time_after((unsigned long)oo->oo_time, 4640 (unsigned long)cutoff)) { 4641 t = oo->oo_time - cutoff; 4642 new_timeo = min(new_timeo, t); 4643 break; 4644 } 4645 list_del_init(&oo->oo_close_lru); 4646 stp = oo->oo_last_closed_stid; 4647 oo->oo_last_closed_stid = NULL; 4648 spin_unlock(&nn->client_lock); 4649 nfs4_put_stid(&stp->st_stid); 4650 spin_lock(&nn->client_lock); 4651 } 4652 spin_unlock(&nn->client_lock); 4653 4654 /* 4655 * It's possible for a client to try and acquire an already held lock 4656 * that is being held for a long time, and then lose interest in it. 4657 * So, we clean out any un-revisited request after a lease period 4658 * under the assumption that the client is no longer interested. 4659 * 4660 * RFC5661, sec. 9.6 states that the client must not rely on getting 4661 * notifications and must continue to poll for locks, even when the 4662 * server supports them. Thus this shouldn't lead to clients blocking 4663 * indefinitely once the lock does become free. 4664 */ 4665 BUG_ON(!list_empty(&reaplist)); 4666 spin_lock(&nn->blocked_locks_lock); 4667 while (!list_empty(&nn->blocked_locks_lru)) { 4668 nbl = list_first_entry(&nn->blocked_locks_lru, 4669 struct nfsd4_blocked_lock, nbl_lru); 4670 if (time_after((unsigned long)nbl->nbl_time, 4671 (unsigned long)cutoff)) { 4672 t = nbl->nbl_time - cutoff; 4673 new_timeo = min(new_timeo, t); 4674 break; 4675 } 4676 list_move(&nbl->nbl_lru, &reaplist); 4677 list_del_init(&nbl->nbl_list); 4678 } 4679 spin_unlock(&nn->blocked_locks_lock); 4680 4681 while (!list_empty(&reaplist)) { 4682 nbl = list_first_entry(&nn->blocked_locks_lru, 4683 struct nfsd4_blocked_lock, nbl_lru); 4684 list_del_init(&nbl->nbl_lru); 4685 posix_unblock_lock(&nbl->nbl_lock); 4686 free_blocked_lock(nbl); 4687 } 4688 4689 new_timeo = max_t(time_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT); 4690 return new_timeo; 4691 } 4692 4693 static struct workqueue_struct *laundry_wq; 4694 static void laundromat_main(struct work_struct *); 4695 4696 static void 4697 laundromat_main(struct work_struct *laundry) 4698 { 4699 time_t t; 4700 struct delayed_work *dwork = to_delayed_work(laundry); 4701 struct nfsd_net *nn = container_of(dwork, struct nfsd_net, 4702 laundromat_work); 4703 4704 t = nfs4_laundromat(nn); 4705 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t); 4706 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ); 4707 } 4708 4709 static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stid *stp) 4710 { 4711 if (!fh_match(&fhp->fh_handle, &stp->sc_file->fi_fhandle)) 4712 return nfserr_bad_stateid; 4713 return nfs_ok; 4714 } 4715 4716 static inline int 4717 access_permit_read(struct nfs4_ol_stateid *stp) 4718 { 4719 return test_access(NFS4_SHARE_ACCESS_READ, stp) || 4720 test_access(NFS4_SHARE_ACCESS_BOTH, stp) || 4721 test_access(NFS4_SHARE_ACCESS_WRITE, stp); 4722 } 4723 4724 static inline int 4725 access_permit_write(struct nfs4_ol_stateid *stp) 4726 { 4727 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) || 4728 test_access(NFS4_SHARE_ACCESS_BOTH, stp); 4729 } 4730 4731 static 4732 __be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags) 4733 { 4734 __be32 status = nfserr_openmode; 4735 4736 /* For lock stateid's, we test the parent open, not the lock: */ 4737 if (stp->st_openstp) 4738 stp = stp->st_openstp; 4739 if ((flags & WR_STATE) && !access_permit_write(stp)) 4740 goto out; 4741 if ((flags & RD_STATE) && !access_permit_read(stp)) 4742 goto out; 4743 status = nfs_ok; 4744 out: 4745 return status; 4746 } 4747 4748 static inline __be32 4749 check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags) 4750 { 4751 if (ONE_STATEID(stateid) && (flags & RD_STATE)) 4752 return nfs_ok; 4753 else if (opens_in_grace(net)) { 4754 /* Answer in remaining cases depends on existence of 4755 * conflicting state; so we must wait out the grace period. */ 4756 return nfserr_grace; 4757 } else if (flags & WR_STATE) 4758 return nfs4_share_conflict(current_fh, 4759 NFS4_SHARE_DENY_WRITE); 4760 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */ 4761 return nfs4_share_conflict(current_fh, 4762 NFS4_SHARE_DENY_READ); 4763 } 4764 4765 /* 4766 * Allow READ/WRITE during grace period on recovered state only for files 4767 * that are not able to provide mandatory locking. 4768 */ 4769 static inline int 4770 grace_disallows_io(struct net *net, struct inode *inode) 4771 { 4772 return opens_in_grace(net) && mandatory_lock(inode); 4773 } 4774 4775 static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session) 4776 { 4777 /* 4778 * When sessions are used the stateid generation number is ignored 4779 * when it is zero. 4780 */ 4781 if (has_session && in->si_generation == 0) 4782 return nfs_ok; 4783 4784 if (in->si_generation == ref->si_generation) 4785 return nfs_ok; 4786 4787 /* If the client sends us a stateid from the future, it's buggy: */ 4788 if (nfsd4_stateid_generation_after(in, ref)) 4789 return nfserr_bad_stateid; 4790 /* 4791 * However, we could see a stateid from the past, even from a 4792 * non-buggy client. For example, if the client sends a lock 4793 * while some IO is outstanding, the lock may bump si_generation 4794 * while the IO is still in flight. The client could avoid that 4795 * situation by waiting for responses on all the IO requests, 4796 * but better performance may result in retrying IO that 4797 * receives an old_stateid error if requests are rarely 4798 * reordered in flight: 4799 */ 4800 return nfserr_old_stateid; 4801 } 4802 4803 static __be32 nfsd4_check_openowner_confirmed(struct nfs4_ol_stateid *ols) 4804 { 4805 if (ols->st_stateowner->so_is_open_owner && 4806 !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED)) 4807 return nfserr_bad_stateid; 4808 return nfs_ok; 4809 } 4810 4811 static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid) 4812 { 4813 struct nfs4_stid *s; 4814 __be32 status = nfserr_bad_stateid; 4815 4816 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) 4817 return status; 4818 /* Client debugging aid. */ 4819 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) { 4820 char addr_str[INET6_ADDRSTRLEN]; 4821 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str, 4822 sizeof(addr_str)); 4823 pr_warn_ratelimited("NFSD: client %s testing state ID " 4824 "with incorrect client ID\n", addr_str); 4825 return status; 4826 } 4827 spin_lock(&cl->cl_lock); 4828 s = find_stateid_locked(cl, stateid); 4829 if (!s) 4830 goto out_unlock; 4831 status = check_stateid_generation(stateid, &s->sc_stateid, 1); 4832 if (status) 4833 goto out_unlock; 4834 switch (s->sc_type) { 4835 case NFS4_DELEG_STID: 4836 status = nfs_ok; 4837 break; 4838 case NFS4_REVOKED_DELEG_STID: 4839 status = nfserr_deleg_revoked; 4840 break; 4841 case NFS4_OPEN_STID: 4842 case NFS4_LOCK_STID: 4843 status = nfsd4_check_openowner_confirmed(openlockstateid(s)); 4844 break; 4845 default: 4846 printk("unknown stateid type %x\n", s->sc_type); 4847 /* Fallthrough */ 4848 case NFS4_CLOSED_STID: 4849 case NFS4_CLOSED_DELEG_STID: 4850 status = nfserr_bad_stateid; 4851 } 4852 out_unlock: 4853 spin_unlock(&cl->cl_lock); 4854 return status; 4855 } 4856 4857 __be32 4858 nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate, 4859 stateid_t *stateid, unsigned char typemask, 4860 struct nfs4_stid **s, struct nfsd_net *nn) 4861 { 4862 __be32 status; 4863 4864 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) 4865 return nfserr_bad_stateid; 4866 status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn); 4867 if (status == nfserr_stale_clientid) { 4868 if (cstate->session) 4869 return nfserr_bad_stateid; 4870 return nfserr_stale_stateid; 4871 } 4872 if (status) 4873 return status; 4874 *s = find_stateid_by_type(cstate->clp, stateid, typemask); 4875 if (!*s) 4876 return nfserr_bad_stateid; 4877 return nfs_ok; 4878 } 4879 4880 static struct file * 4881 nfs4_find_file(struct nfs4_stid *s, int flags) 4882 { 4883 if (!s) 4884 return NULL; 4885 4886 switch (s->sc_type) { 4887 case NFS4_DELEG_STID: 4888 if (WARN_ON_ONCE(!s->sc_file->fi_deleg_file)) 4889 return NULL; 4890 return get_file(s->sc_file->fi_deleg_file); 4891 case NFS4_OPEN_STID: 4892 case NFS4_LOCK_STID: 4893 if (flags & RD_STATE) 4894 return find_readable_file(s->sc_file); 4895 else 4896 return find_writeable_file(s->sc_file); 4897 break; 4898 } 4899 4900 return NULL; 4901 } 4902 4903 static __be32 4904 nfs4_check_olstateid(struct svc_fh *fhp, struct nfs4_ol_stateid *ols, int flags) 4905 { 4906 __be32 status; 4907 4908 status = nfsd4_check_openowner_confirmed(ols); 4909 if (status) 4910 return status; 4911 return nfs4_check_openmode(ols, flags); 4912 } 4913 4914 static __be32 4915 nfs4_check_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_stid *s, 4916 struct file **filpp, bool *tmp_file, int flags) 4917 { 4918 int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE; 4919 struct file *file; 4920 __be32 status; 4921 4922 file = nfs4_find_file(s, flags); 4923 if (file) { 4924 status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, 4925 acc | NFSD_MAY_OWNER_OVERRIDE); 4926 if (status) { 4927 fput(file); 4928 return status; 4929 } 4930 4931 *filpp = file; 4932 } else { 4933 status = nfsd_open(rqstp, fhp, S_IFREG, acc, filpp); 4934 if (status) 4935 return status; 4936 4937 if (tmp_file) 4938 *tmp_file = true; 4939 } 4940 4941 return 0; 4942 } 4943 4944 /* 4945 * Checks for stateid operations 4946 */ 4947 __be32 4948 nfs4_preprocess_stateid_op(struct svc_rqst *rqstp, 4949 struct nfsd4_compound_state *cstate, struct svc_fh *fhp, 4950 stateid_t *stateid, int flags, struct file **filpp, bool *tmp_file) 4951 { 4952 struct inode *ino = d_inode(fhp->fh_dentry); 4953 struct net *net = SVC_NET(rqstp); 4954 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 4955 struct nfs4_stid *s = NULL; 4956 __be32 status; 4957 4958 if (filpp) 4959 *filpp = NULL; 4960 if (tmp_file) 4961 *tmp_file = false; 4962 4963 if (grace_disallows_io(net, ino)) 4964 return nfserr_grace; 4965 4966 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) { 4967 status = check_special_stateids(net, fhp, stateid, flags); 4968 goto done; 4969 } 4970 4971 status = nfsd4_lookup_stateid(cstate, stateid, 4972 NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID, 4973 &s, nn); 4974 if (status) 4975 return status; 4976 status = check_stateid_generation(stateid, &s->sc_stateid, 4977 nfsd4_has_session(cstate)); 4978 if (status) 4979 goto out; 4980 4981 switch (s->sc_type) { 4982 case NFS4_DELEG_STID: 4983 status = nfs4_check_delegmode(delegstateid(s), flags); 4984 break; 4985 case NFS4_OPEN_STID: 4986 case NFS4_LOCK_STID: 4987 status = nfs4_check_olstateid(fhp, openlockstateid(s), flags); 4988 break; 4989 default: 4990 status = nfserr_bad_stateid; 4991 break; 4992 } 4993 if (status) 4994 goto out; 4995 status = nfs4_check_fh(fhp, s); 4996 4997 done: 4998 if (!status && filpp) 4999 status = nfs4_check_file(rqstp, fhp, s, filpp, tmp_file, flags); 5000 out: 5001 if (s) 5002 nfs4_put_stid(s); 5003 return status; 5004 } 5005 5006 /* 5007 * Test if the stateid is valid 5008 */ 5009 __be32 5010 nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5011 struct nfsd4_test_stateid *test_stateid) 5012 { 5013 struct nfsd4_test_stateid_id *stateid; 5014 struct nfs4_client *cl = cstate->session->se_client; 5015 5016 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list) 5017 stateid->ts_id_status = 5018 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid); 5019 5020 return nfs_ok; 5021 } 5022 5023 static __be32 5024 nfsd4_free_lock_stateid(stateid_t *stateid, struct nfs4_stid *s) 5025 { 5026 struct nfs4_ol_stateid *stp = openlockstateid(s); 5027 __be32 ret; 5028 5029 mutex_lock(&stp->st_mutex); 5030 5031 ret = check_stateid_generation(stateid, &s->sc_stateid, 1); 5032 if (ret) 5033 goto out; 5034 5035 ret = nfserr_locks_held; 5036 if (check_for_locks(stp->st_stid.sc_file, 5037 lockowner(stp->st_stateowner))) 5038 goto out; 5039 5040 release_lock_stateid(stp); 5041 ret = nfs_ok; 5042 5043 out: 5044 mutex_unlock(&stp->st_mutex); 5045 nfs4_put_stid(s); 5046 return ret; 5047 } 5048 5049 __be32 5050 nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5051 struct nfsd4_free_stateid *free_stateid) 5052 { 5053 stateid_t *stateid = &free_stateid->fr_stateid; 5054 struct nfs4_stid *s; 5055 struct nfs4_delegation *dp; 5056 struct nfs4_client *cl = cstate->session->se_client; 5057 __be32 ret = nfserr_bad_stateid; 5058 5059 spin_lock(&cl->cl_lock); 5060 s = find_stateid_locked(cl, stateid); 5061 if (!s) 5062 goto out_unlock; 5063 switch (s->sc_type) { 5064 case NFS4_DELEG_STID: 5065 ret = nfserr_locks_held; 5066 break; 5067 case NFS4_OPEN_STID: 5068 ret = check_stateid_generation(stateid, &s->sc_stateid, 1); 5069 if (ret) 5070 break; 5071 ret = nfserr_locks_held; 5072 break; 5073 case NFS4_LOCK_STID: 5074 atomic_inc(&s->sc_count); 5075 spin_unlock(&cl->cl_lock); 5076 ret = nfsd4_free_lock_stateid(stateid, s); 5077 goto out; 5078 case NFS4_REVOKED_DELEG_STID: 5079 dp = delegstateid(s); 5080 list_del_init(&dp->dl_recall_lru); 5081 spin_unlock(&cl->cl_lock); 5082 nfs4_put_stid(s); 5083 ret = nfs_ok; 5084 goto out; 5085 /* Default falls through and returns nfserr_bad_stateid */ 5086 } 5087 out_unlock: 5088 spin_unlock(&cl->cl_lock); 5089 out: 5090 return ret; 5091 } 5092 5093 static inline int 5094 setlkflg (int type) 5095 { 5096 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ? 5097 RD_STATE : WR_STATE; 5098 } 5099 5100 static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp) 5101 { 5102 struct svc_fh *current_fh = &cstate->current_fh; 5103 struct nfs4_stateowner *sop = stp->st_stateowner; 5104 __be32 status; 5105 5106 status = nfsd4_check_seqid(cstate, sop, seqid); 5107 if (status) 5108 return status; 5109 if (stp->st_stid.sc_type == NFS4_CLOSED_STID 5110 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID) 5111 /* 5112 * "Closed" stateid's exist *only* to return 5113 * nfserr_replay_me from the previous step, and 5114 * revoked delegations are kept only for free_stateid. 5115 */ 5116 return nfserr_bad_stateid; 5117 mutex_lock(&stp->st_mutex); 5118 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate)); 5119 if (status == nfs_ok) 5120 status = nfs4_check_fh(current_fh, &stp->st_stid); 5121 if (status != nfs_ok) 5122 mutex_unlock(&stp->st_mutex); 5123 return status; 5124 } 5125 5126 /* 5127 * Checks for sequence id mutating operations. 5128 */ 5129 static __be32 5130 nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, 5131 stateid_t *stateid, char typemask, 5132 struct nfs4_ol_stateid **stpp, 5133 struct nfsd_net *nn) 5134 { 5135 __be32 status; 5136 struct nfs4_stid *s; 5137 struct nfs4_ol_stateid *stp = NULL; 5138 5139 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__, 5140 seqid, STATEID_VAL(stateid)); 5141 5142 *stpp = NULL; 5143 status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn); 5144 if (status) 5145 return status; 5146 stp = openlockstateid(s); 5147 nfsd4_cstate_assign_replay(cstate, stp->st_stateowner); 5148 5149 status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp); 5150 if (!status) 5151 *stpp = stp; 5152 else 5153 nfs4_put_stid(&stp->st_stid); 5154 return status; 5155 } 5156 5157 static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, 5158 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn) 5159 { 5160 __be32 status; 5161 struct nfs4_openowner *oo; 5162 struct nfs4_ol_stateid *stp; 5163 5164 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid, 5165 NFS4_OPEN_STID, &stp, nn); 5166 if (status) 5167 return status; 5168 oo = openowner(stp->st_stateowner); 5169 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) { 5170 mutex_unlock(&stp->st_mutex); 5171 nfs4_put_stid(&stp->st_stid); 5172 return nfserr_bad_stateid; 5173 } 5174 *stpp = stp; 5175 return nfs_ok; 5176 } 5177 5178 __be32 5179 nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5180 struct nfsd4_open_confirm *oc) 5181 { 5182 __be32 status; 5183 struct nfs4_openowner *oo; 5184 struct nfs4_ol_stateid *stp; 5185 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 5186 5187 dprintk("NFSD: nfsd4_open_confirm on file %pd\n", 5188 cstate->current_fh.fh_dentry); 5189 5190 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0); 5191 if (status) 5192 return status; 5193 5194 status = nfs4_preprocess_seqid_op(cstate, 5195 oc->oc_seqid, &oc->oc_req_stateid, 5196 NFS4_OPEN_STID, &stp, nn); 5197 if (status) 5198 goto out; 5199 oo = openowner(stp->st_stateowner); 5200 status = nfserr_bad_stateid; 5201 if (oo->oo_flags & NFS4_OO_CONFIRMED) { 5202 mutex_unlock(&stp->st_mutex); 5203 goto put_stateid; 5204 } 5205 oo->oo_flags |= NFS4_OO_CONFIRMED; 5206 nfs4_inc_and_copy_stateid(&oc->oc_resp_stateid, &stp->st_stid); 5207 mutex_unlock(&stp->st_mutex); 5208 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n", 5209 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid)); 5210 5211 nfsd4_client_record_create(oo->oo_owner.so_client); 5212 status = nfs_ok; 5213 put_stateid: 5214 nfs4_put_stid(&stp->st_stid); 5215 out: 5216 nfsd4_bump_seqid(cstate, status); 5217 return status; 5218 } 5219 5220 static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access) 5221 { 5222 if (!test_access(access, stp)) 5223 return; 5224 nfs4_file_put_access(stp->st_stid.sc_file, access); 5225 clear_access(access, stp); 5226 } 5227 5228 static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access) 5229 { 5230 switch (to_access) { 5231 case NFS4_SHARE_ACCESS_READ: 5232 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE); 5233 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH); 5234 break; 5235 case NFS4_SHARE_ACCESS_WRITE: 5236 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ); 5237 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH); 5238 break; 5239 case NFS4_SHARE_ACCESS_BOTH: 5240 break; 5241 default: 5242 WARN_ON_ONCE(1); 5243 } 5244 } 5245 5246 __be32 5247 nfsd4_open_downgrade(struct svc_rqst *rqstp, 5248 struct nfsd4_compound_state *cstate, 5249 struct nfsd4_open_downgrade *od) 5250 { 5251 __be32 status; 5252 struct nfs4_ol_stateid *stp; 5253 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 5254 5255 dprintk("NFSD: nfsd4_open_downgrade on file %pd\n", 5256 cstate->current_fh.fh_dentry); 5257 5258 /* We don't yet support WANT bits: */ 5259 if (od->od_deleg_want) 5260 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__, 5261 od->od_deleg_want); 5262 5263 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid, 5264 &od->od_stateid, &stp, nn); 5265 if (status) 5266 goto out; 5267 status = nfserr_inval; 5268 if (!test_access(od->od_share_access, stp)) { 5269 dprintk("NFSD: access not a subset of current bitmap: 0x%hhx, input access=%08x\n", 5270 stp->st_access_bmap, od->od_share_access); 5271 goto put_stateid; 5272 } 5273 if (!test_deny(od->od_share_deny, stp)) { 5274 dprintk("NFSD: deny not a subset of current bitmap: 0x%hhx, input deny=%08x\n", 5275 stp->st_deny_bmap, od->od_share_deny); 5276 goto put_stateid; 5277 } 5278 nfs4_stateid_downgrade(stp, od->od_share_access); 5279 reset_union_bmap_deny(od->od_share_deny, stp); 5280 nfs4_inc_and_copy_stateid(&od->od_stateid, &stp->st_stid); 5281 status = nfs_ok; 5282 put_stateid: 5283 mutex_unlock(&stp->st_mutex); 5284 nfs4_put_stid(&stp->st_stid); 5285 out: 5286 nfsd4_bump_seqid(cstate, status); 5287 return status; 5288 } 5289 5290 static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s) 5291 { 5292 struct nfs4_client *clp = s->st_stid.sc_client; 5293 bool unhashed; 5294 LIST_HEAD(reaplist); 5295 5296 s->st_stid.sc_type = NFS4_CLOSED_STID; 5297 spin_lock(&clp->cl_lock); 5298 unhashed = unhash_open_stateid(s, &reaplist); 5299 5300 if (clp->cl_minorversion) { 5301 if (unhashed) 5302 put_ol_stateid_locked(s, &reaplist); 5303 spin_unlock(&clp->cl_lock); 5304 free_ol_stateid_reaplist(&reaplist); 5305 } else { 5306 spin_unlock(&clp->cl_lock); 5307 free_ol_stateid_reaplist(&reaplist); 5308 if (unhashed) 5309 move_to_close_lru(s, clp->net); 5310 } 5311 } 5312 5313 /* 5314 * nfs4_unlock_state() called after encode 5315 */ 5316 __be32 5317 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5318 struct nfsd4_close *close) 5319 { 5320 __be32 status; 5321 struct nfs4_ol_stateid *stp; 5322 struct net *net = SVC_NET(rqstp); 5323 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 5324 5325 dprintk("NFSD: nfsd4_close on file %pd\n", 5326 cstate->current_fh.fh_dentry); 5327 5328 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid, 5329 &close->cl_stateid, 5330 NFS4_OPEN_STID|NFS4_CLOSED_STID, 5331 &stp, nn); 5332 nfsd4_bump_seqid(cstate, status); 5333 if (status) 5334 goto out; 5335 nfs4_inc_and_copy_stateid(&close->cl_stateid, &stp->st_stid); 5336 mutex_unlock(&stp->st_mutex); 5337 5338 nfsd4_close_open_stateid(stp); 5339 5340 /* put reference from nfs4_preprocess_seqid_op */ 5341 nfs4_put_stid(&stp->st_stid); 5342 out: 5343 return status; 5344 } 5345 5346 __be32 5347 nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5348 struct nfsd4_delegreturn *dr) 5349 { 5350 struct nfs4_delegation *dp; 5351 stateid_t *stateid = &dr->dr_stateid; 5352 struct nfs4_stid *s; 5353 __be32 status; 5354 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 5355 5356 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) 5357 return status; 5358 5359 status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn); 5360 if (status) 5361 goto out; 5362 dp = delegstateid(s); 5363 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate)); 5364 if (status) 5365 goto put_stateid; 5366 5367 destroy_delegation(dp); 5368 put_stateid: 5369 nfs4_put_stid(&dp->dl_stid); 5370 out: 5371 return status; 5372 } 5373 5374 static inline u64 5375 end_offset(u64 start, u64 len) 5376 { 5377 u64 end; 5378 5379 end = start + len; 5380 return end >= start ? end: NFS4_MAX_UINT64; 5381 } 5382 5383 /* last octet in a range */ 5384 static inline u64 5385 last_byte_offset(u64 start, u64 len) 5386 { 5387 u64 end; 5388 5389 WARN_ON_ONCE(!len); 5390 end = start + len; 5391 return end > start ? end - 1: NFS4_MAX_UINT64; 5392 } 5393 5394 /* 5395 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that 5396 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th 5397 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit 5398 * locking, this prevents us from being completely protocol-compliant. The 5399 * real solution to this problem is to start using unsigned file offsets in 5400 * the VFS, but this is a very deep change! 5401 */ 5402 static inline void 5403 nfs4_transform_lock_offset(struct file_lock *lock) 5404 { 5405 if (lock->fl_start < 0) 5406 lock->fl_start = OFFSET_MAX; 5407 if (lock->fl_end < 0) 5408 lock->fl_end = OFFSET_MAX; 5409 } 5410 5411 static fl_owner_t 5412 nfsd4_fl_get_owner(fl_owner_t owner) 5413 { 5414 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner; 5415 5416 nfs4_get_stateowner(&lo->lo_owner); 5417 return owner; 5418 } 5419 5420 static void 5421 nfsd4_fl_put_owner(fl_owner_t owner) 5422 { 5423 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner; 5424 5425 if (lo) 5426 nfs4_put_stateowner(&lo->lo_owner); 5427 } 5428 5429 static void 5430 nfsd4_lm_notify(struct file_lock *fl) 5431 { 5432 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)fl->fl_owner; 5433 struct net *net = lo->lo_owner.so_client->net; 5434 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 5435 struct nfsd4_blocked_lock *nbl = container_of(fl, 5436 struct nfsd4_blocked_lock, nbl_lock); 5437 bool queue = false; 5438 5439 /* An empty list means that something else is going to be using it */ 5440 spin_lock(&nn->blocked_locks_lock); 5441 if (!list_empty(&nbl->nbl_list)) { 5442 list_del_init(&nbl->nbl_list); 5443 list_del_init(&nbl->nbl_lru); 5444 queue = true; 5445 } 5446 spin_unlock(&nn->blocked_locks_lock); 5447 5448 if (queue) 5449 nfsd4_run_cb(&nbl->nbl_cb); 5450 } 5451 5452 static const struct lock_manager_operations nfsd_posix_mng_ops = { 5453 .lm_notify = nfsd4_lm_notify, 5454 .lm_get_owner = nfsd4_fl_get_owner, 5455 .lm_put_owner = nfsd4_fl_put_owner, 5456 }; 5457 5458 static inline void 5459 nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) 5460 { 5461 struct nfs4_lockowner *lo; 5462 5463 if (fl->fl_lmops == &nfsd_posix_mng_ops) { 5464 lo = (struct nfs4_lockowner *) fl->fl_owner; 5465 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data, 5466 lo->lo_owner.so_owner.len, GFP_KERNEL); 5467 if (!deny->ld_owner.data) 5468 /* We just don't care that much */ 5469 goto nevermind; 5470 deny->ld_owner.len = lo->lo_owner.so_owner.len; 5471 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid; 5472 } else { 5473 nevermind: 5474 deny->ld_owner.len = 0; 5475 deny->ld_owner.data = NULL; 5476 deny->ld_clientid.cl_boot = 0; 5477 deny->ld_clientid.cl_id = 0; 5478 } 5479 deny->ld_start = fl->fl_start; 5480 deny->ld_length = NFS4_MAX_UINT64; 5481 if (fl->fl_end != NFS4_MAX_UINT64) 5482 deny->ld_length = fl->fl_end - fl->fl_start + 1; 5483 deny->ld_type = NFS4_READ_LT; 5484 if (fl->fl_type != F_RDLCK) 5485 deny->ld_type = NFS4_WRITE_LT; 5486 } 5487 5488 static struct nfs4_lockowner * 5489 find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner) 5490 { 5491 unsigned int strhashval = ownerstr_hashval(owner); 5492 struct nfs4_stateowner *so; 5493 5494 lockdep_assert_held(&clp->cl_lock); 5495 5496 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval], 5497 so_strhash) { 5498 if (so->so_is_open_owner) 5499 continue; 5500 if (same_owner_str(so, owner)) 5501 return lockowner(nfs4_get_stateowner(so)); 5502 } 5503 return NULL; 5504 } 5505 5506 static struct nfs4_lockowner * 5507 find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner) 5508 { 5509 struct nfs4_lockowner *lo; 5510 5511 spin_lock(&clp->cl_lock); 5512 lo = find_lockowner_str_locked(clp, owner); 5513 spin_unlock(&clp->cl_lock); 5514 return lo; 5515 } 5516 5517 static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop) 5518 { 5519 unhash_lockowner_locked(lockowner(sop)); 5520 } 5521 5522 static void nfs4_free_lockowner(struct nfs4_stateowner *sop) 5523 { 5524 struct nfs4_lockowner *lo = lockowner(sop); 5525 5526 kmem_cache_free(lockowner_slab, lo); 5527 } 5528 5529 static const struct nfs4_stateowner_operations lockowner_ops = { 5530 .so_unhash = nfs4_unhash_lockowner, 5531 .so_free = nfs4_free_lockowner, 5532 }; 5533 5534 /* 5535 * Alloc a lock owner structure. 5536 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 5537 * occurred. 5538 * 5539 * strhashval = ownerstr_hashval 5540 */ 5541 static struct nfs4_lockowner * 5542 alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, 5543 struct nfs4_ol_stateid *open_stp, 5544 struct nfsd4_lock *lock) 5545 { 5546 struct nfs4_lockowner *lo, *ret; 5547 5548 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp); 5549 if (!lo) 5550 return NULL; 5551 INIT_LIST_HEAD(&lo->lo_blocked); 5552 INIT_LIST_HEAD(&lo->lo_owner.so_stateids); 5553 lo->lo_owner.so_is_open_owner = 0; 5554 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid; 5555 lo->lo_owner.so_ops = &lockowner_ops; 5556 spin_lock(&clp->cl_lock); 5557 ret = find_lockowner_str_locked(clp, &lock->lk_new_owner); 5558 if (ret == NULL) { 5559 list_add(&lo->lo_owner.so_strhash, 5560 &clp->cl_ownerstr_hashtbl[strhashval]); 5561 ret = lo; 5562 } else 5563 nfs4_free_stateowner(&lo->lo_owner); 5564 5565 spin_unlock(&clp->cl_lock); 5566 return ret; 5567 } 5568 5569 static void 5570 init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo, 5571 struct nfs4_file *fp, struct inode *inode, 5572 struct nfs4_ol_stateid *open_stp) 5573 { 5574 struct nfs4_client *clp = lo->lo_owner.so_client; 5575 5576 lockdep_assert_held(&clp->cl_lock); 5577 5578 atomic_inc(&stp->st_stid.sc_count); 5579 stp->st_stid.sc_type = NFS4_LOCK_STID; 5580 stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner); 5581 get_nfs4_file(fp); 5582 stp->st_stid.sc_file = fp; 5583 stp->st_stid.sc_free = nfs4_free_lock_stateid; 5584 stp->st_access_bmap = 0; 5585 stp->st_deny_bmap = open_stp->st_deny_bmap; 5586 stp->st_openstp = open_stp; 5587 mutex_init(&stp->st_mutex); 5588 list_add(&stp->st_locks, &open_stp->st_locks); 5589 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids); 5590 spin_lock(&fp->fi_lock); 5591 list_add(&stp->st_perfile, &fp->fi_stateids); 5592 spin_unlock(&fp->fi_lock); 5593 } 5594 5595 static struct nfs4_ol_stateid * 5596 find_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp) 5597 { 5598 struct nfs4_ol_stateid *lst; 5599 struct nfs4_client *clp = lo->lo_owner.so_client; 5600 5601 lockdep_assert_held(&clp->cl_lock); 5602 5603 list_for_each_entry(lst, &lo->lo_owner.so_stateids, st_perstateowner) { 5604 if (lst->st_stid.sc_file == fp) { 5605 atomic_inc(&lst->st_stid.sc_count); 5606 return lst; 5607 } 5608 } 5609 return NULL; 5610 } 5611 5612 static struct nfs4_ol_stateid * 5613 find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi, 5614 struct inode *inode, struct nfs4_ol_stateid *ost, 5615 bool *new) 5616 { 5617 struct nfs4_stid *ns = NULL; 5618 struct nfs4_ol_stateid *lst; 5619 struct nfs4_openowner *oo = openowner(ost->st_stateowner); 5620 struct nfs4_client *clp = oo->oo_owner.so_client; 5621 5622 spin_lock(&clp->cl_lock); 5623 lst = find_lock_stateid(lo, fi); 5624 if (lst == NULL) { 5625 spin_unlock(&clp->cl_lock); 5626 ns = nfs4_alloc_stid(clp, stateid_slab); 5627 if (ns == NULL) 5628 return NULL; 5629 5630 spin_lock(&clp->cl_lock); 5631 lst = find_lock_stateid(lo, fi); 5632 if (likely(!lst)) { 5633 lst = openlockstateid(ns); 5634 init_lock_stateid(lst, lo, fi, inode, ost); 5635 ns = NULL; 5636 *new = true; 5637 } 5638 } 5639 spin_unlock(&clp->cl_lock); 5640 if (ns) 5641 nfs4_put_stid(ns); 5642 return lst; 5643 } 5644 5645 static int 5646 check_lock_length(u64 offset, u64 length) 5647 { 5648 return ((length == 0) || ((length != NFS4_MAX_UINT64) && 5649 (length > ~offset))); 5650 } 5651 5652 static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access) 5653 { 5654 struct nfs4_file *fp = lock_stp->st_stid.sc_file; 5655 5656 lockdep_assert_held(&fp->fi_lock); 5657 5658 if (test_access(access, lock_stp)) 5659 return; 5660 __nfs4_file_get_access(fp, access); 5661 set_access(access, lock_stp); 5662 } 5663 5664 static __be32 5665 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, 5666 struct nfs4_ol_stateid *ost, 5667 struct nfsd4_lock *lock, 5668 struct nfs4_ol_stateid **plst, bool *new) 5669 { 5670 __be32 status; 5671 struct nfs4_file *fi = ost->st_stid.sc_file; 5672 struct nfs4_openowner *oo = openowner(ost->st_stateowner); 5673 struct nfs4_client *cl = oo->oo_owner.so_client; 5674 struct inode *inode = d_inode(cstate->current_fh.fh_dentry); 5675 struct nfs4_lockowner *lo; 5676 struct nfs4_ol_stateid *lst; 5677 unsigned int strhashval; 5678 bool hashed; 5679 5680 lo = find_lockowner_str(cl, &lock->lk_new_owner); 5681 if (!lo) { 5682 strhashval = ownerstr_hashval(&lock->lk_new_owner); 5683 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock); 5684 if (lo == NULL) 5685 return nfserr_jukebox; 5686 } else { 5687 /* with an existing lockowner, seqids must be the same */ 5688 status = nfserr_bad_seqid; 5689 if (!cstate->minorversion && 5690 lock->lk_new_lock_seqid != lo->lo_owner.so_seqid) 5691 goto out; 5692 } 5693 5694 retry: 5695 lst = find_or_create_lock_stateid(lo, fi, inode, ost, new); 5696 if (lst == NULL) { 5697 status = nfserr_jukebox; 5698 goto out; 5699 } 5700 5701 mutex_lock(&lst->st_mutex); 5702 5703 /* See if it's still hashed to avoid race with FREE_STATEID */ 5704 spin_lock(&cl->cl_lock); 5705 hashed = !list_empty(&lst->st_perfile); 5706 spin_unlock(&cl->cl_lock); 5707 5708 if (!hashed) { 5709 mutex_unlock(&lst->st_mutex); 5710 nfs4_put_stid(&lst->st_stid); 5711 goto retry; 5712 } 5713 status = nfs_ok; 5714 *plst = lst; 5715 out: 5716 nfs4_put_stateowner(&lo->lo_owner); 5717 return status; 5718 } 5719 5720 /* 5721 * LOCK operation 5722 */ 5723 __be32 5724 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5725 struct nfsd4_lock *lock) 5726 { 5727 struct nfs4_openowner *open_sop = NULL; 5728 struct nfs4_lockowner *lock_sop = NULL; 5729 struct nfs4_ol_stateid *lock_stp = NULL; 5730 struct nfs4_ol_stateid *open_stp = NULL; 5731 struct nfs4_file *fp; 5732 struct file *filp = NULL; 5733 struct nfsd4_blocked_lock *nbl = NULL; 5734 struct file_lock *file_lock = NULL; 5735 struct file_lock *conflock = NULL; 5736 __be32 status = 0; 5737 int lkflg; 5738 int err; 5739 bool new = false; 5740 unsigned char fl_type; 5741 unsigned int fl_flags = FL_POSIX; 5742 struct net *net = SVC_NET(rqstp); 5743 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 5744 5745 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n", 5746 (long long) lock->lk_offset, 5747 (long long) lock->lk_length); 5748 5749 if (check_lock_length(lock->lk_offset, lock->lk_length)) 5750 return nfserr_inval; 5751 5752 if ((status = fh_verify(rqstp, &cstate->current_fh, 5753 S_IFREG, NFSD_MAY_LOCK))) { 5754 dprintk("NFSD: nfsd4_lock: permission denied!\n"); 5755 return status; 5756 } 5757 5758 if (lock->lk_is_new) { 5759 if (nfsd4_has_session(cstate)) 5760 /* See rfc 5661 18.10.3: given clientid is ignored: */ 5761 memcpy(&lock->lk_new_clientid, 5762 &cstate->session->se_client->cl_clientid, 5763 sizeof(clientid_t)); 5764 5765 status = nfserr_stale_clientid; 5766 if (STALE_CLIENTID(&lock->lk_new_clientid, nn)) 5767 goto out; 5768 5769 /* validate and update open stateid and open seqid */ 5770 status = nfs4_preprocess_confirmed_seqid_op(cstate, 5771 lock->lk_new_open_seqid, 5772 &lock->lk_new_open_stateid, 5773 &open_stp, nn); 5774 if (status) 5775 goto out; 5776 mutex_unlock(&open_stp->st_mutex); 5777 open_sop = openowner(open_stp->st_stateowner); 5778 status = nfserr_bad_stateid; 5779 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid, 5780 &lock->lk_new_clientid)) 5781 goto out; 5782 status = lookup_or_create_lock_state(cstate, open_stp, lock, 5783 &lock_stp, &new); 5784 } else { 5785 status = nfs4_preprocess_seqid_op(cstate, 5786 lock->lk_old_lock_seqid, 5787 &lock->lk_old_lock_stateid, 5788 NFS4_LOCK_STID, &lock_stp, nn); 5789 } 5790 if (status) 5791 goto out; 5792 lock_sop = lockowner(lock_stp->st_stateowner); 5793 5794 lkflg = setlkflg(lock->lk_type); 5795 status = nfs4_check_openmode(lock_stp, lkflg); 5796 if (status) 5797 goto out; 5798 5799 status = nfserr_grace; 5800 if (locks_in_grace(net) && !lock->lk_reclaim) 5801 goto out; 5802 status = nfserr_no_grace; 5803 if (!locks_in_grace(net) && lock->lk_reclaim) 5804 goto out; 5805 5806 fp = lock_stp->st_stid.sc_file; 5807 switch (lock->lk_type) { 5808 case NFS4_READW_LT: 5809 if (nfsd4_has_session(cstate)) 5810 fl_flags |= FL_SLEEP; 5811 /* Fallthrough */ 5812 case NFS4_READ_LT: 5813 spin_lock(&fp->fi_lock); 5814 filp = find_readable_file_locked(fp); 5815 if (filp) 5816 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ); 5817 spin_unlock(&fp->fi_lock); 5818 fl_type = F_RDLCK; 5819 break; 5820 case NFS4_WRITEW_LT: 5821 if (nfsd4_has_session(cstate)) 5822 fl_flags |= FL_SLEEP; 5823 /* Fallthrough */ 5824 case NFS4_WRITE_LT: 5825 spin_lock(&fp->fi_lock); 5826 filp = find_writeable_file_locked(fp); 5827 if (filp) 5828 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE); 5829 spin_unlock(&fp->fi_lock); 5830 fl_type = F_WRLCK; 5831 break; 5832 default: 5833 status = nfserr_inval; 5834 goto out; 5835 } 5836 5837 if (!filp) { 5838 status = nfserr_openmode; 5839 goto out; 5840 } 5841 5842 nbl = find_or_allocate_block(lock_sop, &fp->fi_fhandle, nn); 5843 if (!nbl) { 5844 dprintk("NFSD: %s: unable to allocate block!\n", __func__); 5845 status = nfserr_jukebox; 5846 goto out; 5847 } 5848 5849 file_lock = &nbl->nbl_lock; 5850 file_lock->fl_type = fl_type; 5851 file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner)); 5852 file_lock->fl_pid = current->tgid; 5853 file_lock->fl_file = filp; 5854 file_lock->fl_flags = fl_flags; 5855 file_lock->fl_lmops = &nfsd_posix_mng_ops; 5856 file_lock->fl_start = lock->lk_offset; 5857 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length); 5858 nfs4_transform_lock_offset(file_lock); 5859 5860 conflock = locks_alloc_lock(); 5861 if (!conflock) { 5862 dprintk("NFSD: %s: unable to allocate lock!\n", __func__); 5863 status = nfserr_jukebox; 5864 goto out; 5865 } 5866 5867 if (fl_flags & FL_SLEEP) { 5868 nbl->nbl_time = jiffies; 5869 spin_lock(&nn->blocked_locks_lock); 5870 list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked); 5871 list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru); 5872 spin_unlock(&nn->blocked_locks_lock); 5873 } 5874 5875 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock); 5876 switch (err) { 5877 case 0: /* success! */ 5878 nfs4_inc_and_copy_stateid(&lock->lk_resp_stateid, &lock_stp->st_stid); 5879 status = 0; 5880 break; 5881 case FILE_LOCK_DEFERRED: 5882 nbl = NULL; 5883 /* Fallthrough */ 5884 case -EAGAIN: /* conflock holds conflicting lock */ 5885 status = nfserr_denied; 5886 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n"); 5887 nfs4_set_lock_denied(conflock, &lock->lk_denied); 5888 break; 5889 case -EDEADLK: 5890 status = nfserr_deadlock; 5891 break; 5892 default: 5893 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err); 5894 status = nfserrno(err); 5895 break; 5896 } 5897 out: 5898 if (nbl) { 5899 /* dequeue it if we queued it before */ 5900 if (fl_flags & FL_SLEEP) { 5901 spin_lock(&nn->blocked_locks_lock); 5902 list_del_init(&nbl->nbl_list); 5903 list_del_init(&nbl->nbl_lru); 5904 spin_unlock(&nn->blocked_locks_lock); 5905 } 5906 free_blocked_lock(nbl); 5907 } 5908 if (filp) 5909 fput(filp); 5910 if (lock_stp) { 5911 /* Bump seqid manually if the 4.0 replay owner is openowner */ 5912 if (cstate->replay_owner && 5913 cstate->replay_owner != &lock_sop->lo_owner && 5914 seqid_mutating_err(ntohl(status))) 5915 lock_sop->lo_owner.so_seqid++; 5916 5917 mutex_unlock(&lock_stp->st_mutex); 5918 5919 /* 5920 * If this is a new, never-before-used stateid, and we are 5921 * returning an error, then just go ahead and release it. 5922 */ 5923 if (status && new) 5924 release_lock_stateid(lock_stp); 5925 5926 nfs4_put_stid(&lock_stp->st_stid); 5927 } 5928 if (open_stp) 5929 nfs4_put_stid(&open_stp->st_stid); 5930 nfsd4_bump_seqid(cstate, status); 5931 if (conflock) 5932 locks_free_lock(conflock); 5933 return status; 5934 } 5935 5936 /* 5937 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN, 5938 * so we do a temporary open here just to get an open file to pass to 5939 * vfs_test_lock. (Arguably perhaps test_lock should be done with an 5940 * inode operation.) 5941 */ 5942 static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock) 5943 { 5944 struct file *file; 5945 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file); 5946 if (!err) { 5947 err = nfserrno(vfs_test_lock(file, lock)); 5948 fput(file); 5949 } 5950 return err; 5951 } 5952 5953 /* 5954 * LOCKT operation 5955 */ 5956 __be32 5957 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 5958 struct nfsd4_lockt *lockt) 5959 { 5960 struct file_lock *file_lock = NULL; 5961 struct nfs4_lockowner *lo = NULL; 5962 __be32 status; 5963 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 5964 5965 if (locks_in_grace(SVC_NET(rqstp))) 5966 return nfserr_grace; 5967 5968 if (check_lock_length(lockt->lt_offset, lockt->lt_length)) 5969 return nfserr_inval; 5970 5971 if (!nfsd4_has_session(cstate)) { 5972 status = lookup_clientid(&lockt->lt_clientid, cstate, nn); 5973 if (status) 5974 goto out; 5975 } 5976 5977 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) 5978 goto out; 5979 5980 file_lock = locks_alloc_lock(); 5981 if (!file_lock) { 5982 dprintk("NFSD: %s: unable to allocate lock!\n", __func__); 5983 status = nfserr_jukebox; 5984 goto out; 5985 } 5986 5987 switch (lockt->lt_type) { 5988 case NFS4_READ_LT: 5989 case NFS4_READW_LT: 5990 file_lock->fl_type = F_RDLCK; 5991 break; 5992 case NFS4_WRITE_LT: 5993 case NFS4_WRITEW_LT: 5994 file_lock->fl_type = F_WRLCK; 5995 break; 5996 default: 5997 dprintk("NFSD: nfs4_lockt: bad lock type!\n"); 5998 status = nfserr_inval; 5999 goto out; 6000 } 6001 6002 lo = find_lockowner_str(cstate->clp, &lockt->lt_owner); 6003 if (lo) 6004 file_lock->fl_owner = (fl_owner_t)lo; 6005 file_lock->fl_pid = current->tgid; 6006 file_lock->fl_flags = FL_POSIX; 6007 6008 file_lock->fl_start = lockt->lt_offset; 6009 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length); 6010 6011 nfs4_transform_lock_offset(file_lock); 6012 6013 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock); 6014 if (status) 6015 goto out; 6016 6017 if (file_lock->fl_type != F_UNLCK) { 6018 status = nfserr_denied; 6019 nfs4_set_lock_denied(file_lock, &lockt->lt_denied); 6020 } 6021 out: 6022 if (lo) 6023 nfs4_put_stateowner(&lo->lo_owner); 6024 if (file_lock) 6025 locks_free_lock(file_lock); 6026 return status; 6027 } 6028 6029 __be32 6030 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 6031 struct nfsd4_locku *locku) 6032 { 6033 struct nfs4_ol_stateid *stp; 6034 struct file *filp = NULL; 6035 struct file_lock *file_lock = NULL; 6036 __be32 status; 6037 int err; 6038 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 6039 6040 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n", 6041 (long long) locku->lu_offset, 6042 (long long) locku->lu_length); 6043 6044 if (check_lock_length(locku->lu_offset, locku->lu_length)) 6045 return nfserr_inval; 6046 6047 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid, 6048 &locku->lu_stateid, NFS4_LOCK_STID, 6049 &stp, nn); 6050 if (status) 6051 goto out; 6052 filp = find_any_file(stp->st_stid.sc_file); 6053 if (!filp) { 6054 status = nfserr_lock_range; 6055 goto put_stateid; 6056 } 6057 file_lock = locks_alloc_lock(); 6058 if (!file_lock) { 6059 dprintk("NFSD: %s: unable to allocate lock!\n", __func__); 6060 status = nfserr_jukebox; 6061 goto fput; 6062 } 6063 6064 file_lock->fl_type = F_UNLCK; 6065 file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner)); 6066 file_lock->fl_pid = current->tgid; 6067 file_lock->fl_file = filp; 6068 file_lock->fl_flags = FL_POSIX; 6069 file_lock->fl_lmops = &nfsd_posix_mng_ops; 6070 file_lock->fl_start = locku->lu_offset; 6071 6072 file_lock->fl_end = last_byte_offset(locku->lu_offset, 6073 locku->lu_length); 6074 nfs4_transform_lock_offset(file_lock); 6075 6076 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL); 6077 if (err) { 6078 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n"); 6079 goto out_nfserr; 6080 } 6081 nfs4_inc_and_copy_stateid(&locku->lu_stateid, &stp->st_stid); 6082 fput: 6083 fput(filp); 6084 put_stateid: 6085 mutex_unlock(&stp->st_mutex); 6086 nfs4_put_stid(&stp->st_stid); 6087 out: 6088 nfsd4_bump_seqid(cstate, status); 6089 if (file_lock) 6090 locks_free_lock(file_lock); 6091 return status; 6092 6093 out_nfserr: 6094 status = nfserrno(err); 6095 goto fput; 6096 } 6097 6098 /* 6099 * returns 6100 * true: locks held by lockowner 6101 * false: no locks held by lockowner 6102 */ 6103 static bool 6104 check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner) 6105 { 6106 struct file_lock *fl; 6107 int status = false; 6108 struct file *filp = find_any_file(fp); 6109 struct inode *inode; 6110 struct file_lock_context *flctx; 6111 6112 if (!filp) { 6113 /* Any valid lock stateid should have some sort of access */ 6114 WARN_ON_ONCE(1); 6115 return status; 6116 } 6117 6118 inode = file_inode(filp); 6119 flctx = inode->i_flctx; 6120 6121 if (flctx && !list_empty_careful(&flctx->flc_posix)) { 6122 spin_lock(&flctx->flc_lock); 6123 list_for_each_entry(fl, &flctx->flc_posix, fl_list) { 6124 if (fl->fl_owner == (fl_owner_t)lowner) { 6125 status = true; 6126 break; 6127 } 6128 } 6129 spin_unlock(&flctx->flc_lock); 6130 } 6131 fput(filp); 6132 return status; 6133 } 6134 6135 __be32 6136 nfsd4_release_lockowner(struct svc_rqst *rqstp, 6137 struct nfsd4_compound_state *cstate, 6138 struct nfsd4_release_lockowner *rlockowner) 6139 { 6140 clientid_t *clid = &rlockowner->rl_clientid; 6141 struct nfs4_stateowner *sop; 6142 struct nfs4_lockowner *lo = NULL; 6143 struct nfs4_ol_stateid *stp; 6144 struct xdr_netobj *owner = &rlockowner->rl_owner; 6145 unsigned int hashval = ownerstr_hashval(owner); 6146 __be32 status; 6147 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 6148 struct nfs4_client *clp; 6149 LIST_HEAD (reaplist); 6150 6151 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n", 6152 clid->cl_boot, clid->cl_id); 6153 6154 status = lookup_clientid(clid, cstate, nn); 6155 if (status) 6156 return status; 6157 6158 clp = cstate->clp; 6159 /* Find the matching lock stateowner */ 6160 spin_lock(&clp->cl_lock); 6161 list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval], 6162 so_strhash) { 6163 6164 if (sop->so_is_open_owner || !same_owner_str(sop, owner)) 6165 continue; 6166 6167 /* see if there are still any locks associated with it */ 6168 lo = lockowner(sop); 6169 list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) { 6170 if (check_for_locks(stp->st_stid.sc_file, lo)) { 6171 status = nfserr_locks_held; 6172 spin_unlock(&clp->cl_lock); 6173 return status; 6174 } 6175 } 6176 6177 nfs4_get_stateowner(sop); 6178 break; 6179 } 6180 if (!lo) { 6181 spin_unlock(&clp->cl_lock); 6182 return status; 6183 } 6184 6185 unhash_lockowner_locked(lo); 6186 while (!list_empty(&lo->lo_owner.so_stateids)) { 6187 stp = list_first_entry(&lo->lo_owner.so_stateids, 6188 struct nfs4_ol_stateid, 6189 st_perstateowner); 6190 WARN_ON(!unhash_lock_stateid(stp)); 6191 put_ol_stateid_locked(stp, &reaplist); 6192 } 6193 spin_unlock(&clp->cl_lock); 6194 free_ol_stateid_reaplist(&reaplist); 6195 nfs4_put_stateowner(&lo->lo_owner); 6196 6197 return status; 6198 } 6199 6200 static inline struct nfs4_client_reclaim * 6201 alloc_reclaim(void) 6202 { 6203 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL); 6204 } 6205 6206 bool 6207 nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn) 6208 { 6209 struct nfs4_client_reclaim *crp; 6210 6211 crp = nfsd4_find_reclaim_client(name, nn); 6212 return (crp && crp->cr_clp); 6213 } 6214 6215 /* 6216 * failure => all reset bets are off, nfserr_no_grace... 6217 */ 6218 struct nfs4_client_reclaim * 6219 nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn) 6220 { 6221 unsigned int strhashval; 6222 struct nfs4_client_reclaim *crp; 6223 6224 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name); 6225 crp = alloc_reclaim(); 6226 if (crp) { 6227 strhashval = clientstr_hashval(name); 6228 INIT_LIST_HEAD(&crp->cr_strhash); 6229 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]); 6230 memcpy(crp->cr_recdir, name, HEXDIR_LEN); 6231 crp->cr_clp = NULL; 6232 nn->reclaim_str_hashtbl_size++; 6233 } 6234 return crp; 6235 } 6236 6237 void 6238 nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn) 6239 { 6240 list_del(&crp->cr_strhash); 6241 kfree(crp); 6242 nn->reclaim_str_hashtbl_size--; 6243 } 6244 6245 void 6246 nfs4_release_reclaim(struct nfsd_net *nn) 6247 { 6248 struct nfs4_client_reclaim *crp = NULL; 6249 int i; 6250 6251 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 6252 while (!list_empty(&nn->reclaim_str_hashtbl[i])) { 6253 crp = list_entry(nn->reclaim_str_hashtbl[i].next, 6254 struct nfs4_client_reclaim, cr_strhash); 6255 nfs4_remove_reclaim_record(crp, nn); 6256 } 6257 } 6258 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size); 6259 } 6260 6261 /* 6262 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */ 6263 struct nfs4_client_reclaim * 6264 nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn) 6265 { 6266 unsigned int strhashval; 6267 struct nfs4_client_reclaim *crp = NULL; 6268 6269 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir); 6270 6271 strhashval = clientstr_hashval(recdir); 6272 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) { 6273 if (same_name(crp->cr_recdir, recdir)) { 6274 return crp; 6275 } 6276 } 6277 return NULL; 6278 } 6279 6280 /* 6281 * Called from OPEN. Look for clientid in reclaim list. 6282 */ 6283 __be32 6284 nfs4_check_open_reclaim(clientid_t *clid, 6285 struct nfsd4_compound_state *cstate, 6286 struct nfsd_net *nn) 6287 { 6288 __be32 status; 6289 6290 /* find clientid in conf_id_hashtbl */ 6291 status = lookup_clientid(clid, cstate, nn); 6292 if (status) 6293 return nfserr_reclaim_bad; 6294 6295 if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags)) 6296 return nfserr_no_grace; 6297 6298 if (nfsd4_client_record_check(cstate->clp)) 6299 return nfserr_reclaim_bad; 6300 6301 return nfs_ok; 6302 } 6303 6304 #ifdef CONFIG_NFSD_FAULT_INJECTION 6305 static inline void 6306 put_client(struct nfs4_client *clp) 6307 { 6308 atomic_dec(&clp->cl_refcount); 6309 } 6310 6311 static struct nfs4_client * 6312 nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size) 6313 { 6314 struct nfs4_client *clp; 6315 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6316 nfsd_net_id); 6317 6318 if (!nfsd_netns_ready(nn)) 6319 return NULL; 6320 6321 list_for_each_entry(clp, &nn->client_lru, cl_lru) { 6322 if (memcmp(&clp->cl_addr, addr, addr_size) == 0) 6323 return clp; 6324 } 6325 return NULL; 6326 } 6327 6328 u64 6329 nfsd_inject_print_clients(void) 6330 { 6331 struct nfs4_client *clp; 6332 u64 count = 0; 6333 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6334 nfsd_net_id); 6335 char buf[INET6_ADDRSTRLEN]; 6336 6337 if (!nfsd_netns_ready(nn)) 6338 return 0; 6339 6340 spin_lock(&nn->client_lock); 6341 list_for_each_entry(clp, &nn->client_lru, cl_lru) { 6342 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf)); 6343 pr_info("NFS Client: %s\n", buf); 6344 ++count; 6345 } 6346 spin_unlock(&nn->client_lock); 6347 6348 return count; 6349 } 6350 6351 u64 6352 nfsd_inject_forget_client(struct sockaddr_storage *addr, size_t addr_size) 6353 { 6354 u64 count = 0; 6355 struct nfs4_client *clp; 6356 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6357 nfsd_net_id); 6358 6359 if (!nfsd_netns_ready(nn)) 6360 return count; 6361 6362 spin_lock(&nn->client_lock); 6363 clp = nfsd_find_client(addr, addr_size); 6364 if (clp) { 6365 if (mark_client_expired_locked(clp) == nfs_ok) 6366 ++count; 6367 else 6368 clp = NULL; 6369 } 6370 spin_unlock(&nn->client_lock); 6371 6372 if (clp) 6373 expire_client(clp); 6374 6375 return count; 6376 } 6377 6378 u64 6379 nfsd_inject_forget_clients(u64 max) 6380 { 6381 u64 count = 0; 6382 struct nfs4_client *clp, *next; 6383 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6384 nfsd_net_id); 6385 LIST_HEAD(reaplist); 6386 6387 if (!nfsd_netns_ready(nn)) 6388 return count; 6389 6390 spin_lock(&nn->client_lock); 6391 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) { 6392 if (mark_client_expired_locked(clp) == nfs_ok) { 6393 list_add(&clp->cl_lru, &reaplist); 6394 if (max != 0 && ++count >= max) 6395 break; 6396 } 6397 } 6398 spin_unlock(&nn->client_lock); 6399 6400 list_for_each_entry_safe(clp, next, &reaplist, cl_lru) 6401 expire_client(clp); 6402 6403 return count; 6404 } 6405 6406 static void nfsd_print_count(struct nfs4_client *clp, unsigned int count, 6407 const char *type) 6408 { 6409 char buf[INET6_ADDRSTRLEN]; 6410 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf)); 6411 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type); 6412 } 6413 6414 static void 6415 nfsd_inject_add_lock_to_list(struct nfs4_ol_stateid *lst, 6416 struct list_head *collect) 6417 { 6418 struct nfs4_client *clp = lst->st_stid.sc_client; 6419 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6420 nfsd_net_id); 6421 6422 if (!collect) 6423 return; 6424 6425 lockdep_assert_held(&nn->client_lock); 6426 atomic_inc(&clp->cl_refcount); 6427 list_add(&lst->st_locks, collect); 6428 } 6429 6430 static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, 6431 struct list_head *collect, 6432 bool (*func)(struct nfs4_ol_stateid *)) 6433 { 6434 struct nfs4_openowner *oop; 6435 struct nfs4_ol_stateid *stp, *st_next; 6436 struct nfs4_ol_stateid *lst, *lst_next; 6437 u64 count = 0; 6438 6439 spin_lock(&clp->cl_lock); 6440 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) { 6441 list_for_each_entry_safe(stp, st_next, 6442 &oop->oo_owner.so_stateids, st_perstateowner) { 6443 list_for_each_entry_safe(lst, lst_next, 6444 &stp->st_locks, st_locks) { 6445 if (func) { 6446 if (func(lst)) 6447 nfsd_inject_add_lock_to_list(lst, 6448 collect); 6449 } 6450 ++count; 6451 /* 6452 * Despite the fact that these functions deal 6453 * with 64-bit integers for "count", we must 6454 * ensure that it doesn't blow up the 6455 * clp->cl_refcount. Throw a warning if we 6456 * start to approach INT_MAX here. 6457 */ 6458 WARN_ON_ONCE(count == (INT_MAX / 2)); 6459 if (count == max) 6460 goto out; 6461 } 6462 } 6463 } 6464 out: 6465 spin_unlock(&clp->cl_lock); 6466 6467 return count; 6468 } 6469 6470 static u64 6471 nfsd_collect_client_locks(struct nfs4_client *clp, struct list_head *collect, 6472 u64 max) 6473 { 6474 return nfsd_foreach_client_lock(clp, max, collect, unhash_lock_stateid); 6475 } 6476 6477 static u64 6478 nfsd_print_client_locks(struct nfs4_client *clp) 6479 { 6480 u64 count = nfsd_foreach_client_lock(clp, 0, NULL, NULL); 6481 nfsd_print_count(clp, count, "locked files"); 6482 return count; 6483 } 6484 6485 u64 6486 nfsd_inject_print_locks(void) 6487 { 6488 struct nfs4_client *clp; 6489 u64 count = 0; 6490 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6491 nfsd_net_id); 6492 6493 if (!nfsd_netns_ready(nn)) 6494 return 0; 6495 6496 spin_lock(&nn->client_lock); 6497 list_for_each_entry(clp, &nn->client_lru, cl_lru) 6498 count += nfsd_print_client_locks(clp); 6499 spin_unlock(&nn->client_lock); 6500 6501 return count; 6502 } 6503 6504 static void 6505 nfsd_reap_locks(struct list_head *reaplist) 6506 { 6507 struct nfs4_client *clp; 6508 struct nfs4_ol_stateid *stp, *next; 6509 6510 list_for_each_entry_safe(stp, next, reaplist, st_locks) { 6511 list_del_init(&stp->st_locks); 6512 clp = stp->st_stid.sc_client; 6513 nfs4_put_stid(&stp->st_stid); 6514 put_client(clp); 6515 } 6516 } 6517 6518 u64 6519 nfsd_inject_forget_client_locks(struct sockaddr_storage *addr, size_t addr_size) 6520 { 6521 unsigned int count = 0; 6522 struct nfs4_client *clp; 6523 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6524 nfsd_net_id); 6525 LIST_HEAD(reaplist); 6526 6527 if (!nfsd_netns_ready(nn)) 6528 return count; 6529 6530 spin_lock(&nn->client_lock); 6531 clp = nfsd_find_client(addr, addr_size); 6532 if (clp) 6533 count = nfsd_collect_client_locks(clp, &reaplist, 0); 6534 spin_unlock(&nn->client_lock); 6535 nfsd_reap_locks(&reaplist); 6536 return count; 6537 } 6538 6539 u64 6540 nfsd_inject_forget_locks(u64 max) 6541 { 6542 u64 count = 0; 6543 struct nfs4_client *clp; 6544 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6545 nfsd_net_id); 6546 LIST_HEAD(reaplist); 6547 6548 if (!nfsd_netns_ready(nn)) 6549 return count; 6550 6551 spin_lock(&nn->client_lock); 6552 list_for_each_entry(clp, &nn->client_lru, cl_lru) { 6553 count += nfsd_collect_client_locks(clp, &reaplist, max - count); 6554 if (max != 0 && count >= max) 6555 break; 6556 } 6557 spin_unlock(&nn->client_lock); 6558 nfsd_reap_locks(&reaplist); 6559 return count; 6560 } 6561 6562 static u64 6563 nfsd_foreach_client_openowner(struct nfs4_client *clp, u64 max, 6564 struct list_head *collect, 6565 void (*func)(struct nfs4_openowner *)) 6566 { 6567 struct nfs4_openowner *oop, *next; 6568 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6569 nfsd_net_id); 6570 u64 count = 0; 6571 6572 lockdep_assert_held(&nn->client_lock); 6573 6574 spin_lock(&clp->cl_lock); 6575 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) { 6576 if (func) { 6577 func(oop); 6578 if (collect) { 6579 atomic_inc(&clp->cl_refcount); 6580 list_add(&oop->oo_perclient, collect); 6581 } 6582 } 6583 ++count; 6584 /* 6585 * Despite the fact that these functions deal with 6586 * 64-bit integers for "count", we must ensure that 6587 * it doesn't blow up the clp->cl_refcount. Throw a 6588 * warning if we start to approach INT_MAX here. 6589 */ 6590 WARN_ON_ONCE(count == (INT_MAX / 2)); 6591 if (count == max) 6592 break; 6593 } 6594 spin_unlock(&clp->cl_lock); 6595 6596 return count; 6597 } 6598 6599 static u64 6600 nfsd_print_client_openowners(struct nfs4_client *clp) 6601 { 6602 u64 count = nfsd_foreach_client_openowner(clp, 0, NULL, NULL); 6603 6604 nfsd_print_count(clp, count, "openowners"); 6605 return count; 6606 } 6607 6608 static u64 6609 nfsd_collect_client_openowners(struct nfs4_client *clp, 6610 struct list_head *collect, u64 max) 6611 { 6612 return nfsd_foreach_client_openowner(clp, max, collect, 6613 unhash_openowner_locked); 6614 } 6615 6616 u64 6617 nfsd_inject_print_openowners(void) 6618 { 6619 struct nfs4_client *clp; 6620 u64 count = 0; 6621 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6622 nfsd_net_id); 6623 6624 if (!nfsd_netns_ready(nn)) 6625 return 0; 6626 6627 spin_lock(&nn->client_lock); 6628 list_for_each_entry(clp, &nn->client_lru, cl_lru) 6629 count += nfsd_print_client_openowners(clp); 6630 spin_unlock(&nn->client_lock); 6631 6632 return count; 6633 } 6634 6635 static void 6636 nfsd_reap_openowners(struct list_head *reaplist) 6637 { 6638 struct nfs4_client *clp; 6639 struct nfs4_openowner *oop, *next; 6640 6641 list_for_each_entry_safe(oop, next, reaplist, oo_perclient) { 6642 list_del_init(&oop->oo_perclient); 6643 clp = oop->oo_owner.so_client; 6644 release_openowner(oop); 6645 put_client(clp); 6646 } 6647 } 6648 6649 u64 6650 nfsd_inject_forget_client_openowners(struct sockaddr_storage *addr, 6651 size_t addr_size) 6652 { 6653 unsigned int count = 0; 6654 struct nfs4_client *clp; 6655 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6656 nfsd_net_id); 6657 LIST_HEAD(reaplist); 6658 6659 if (!nfsd_netns_ready(nn)) 6660 return count; 6661 6662 spin_lock(&nn->client_lock); 6663 clp = nfsd_find_client(addr, addr_size); 6664 if (clp) 6665 count = nfsd_collect_client_openowners(clp, &reaplist, 0); 6666 spin_unlock(&nn->client_lock); 6667 nfsd_reap_openowners(&reaplist); 6668 return count; 6669 } 6670 6671 u64 6672 nfsd_inject_forget_openowners(u64 max) 6673 { 6674 u64 count = 0; 6675 struct nfs4_client *clp; 6676 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6677 nfsd_net_id); 6678 LIST_HEAD(reaplist); 6679 6680 if (!nfsd_netns_ready(nn)) 6681 return count; 6682 6683 spin_lock(&nn->client_lock); 6684 list_for_each_entry(clp, &nn->client_lru, cl_lru) { 6685 count += nfsd_collect_client_openowners(clp, &reaplist, 6686 max - count); 6687 if (max != 0 && count >= max) 6688 break; 6689 } 6690 spin_unlock(&nn->client_lock); 6691 nfsd_reap_openowners(&reaplist); 6692 return count; 6693 } 6694 6695 static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max, 6696 struct list_head *victims) 6697 { 6698 struct nfs4_delegation *dp, *next; 6699 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6700 nfsd_net_id); 6701 u64 count = 0; 6702 6703 lockdep_assert_held(&nn->client_lock); 6704 6705 spin_lock(&state_lock); 6706 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) { 6707 if (victims) { 6708 /* 6709 * It's not safe to mess with delegations that have a 6710 * non-zero dl_time. They might have already been broken 6711 * and could be processed by the laundromat outside of 6712 * the state_lock. Just leave them be. 6713 */ 6714 if (dp->dl_time != 0) 6715 continue; 6716 6717 atomic_inc(&clp->cl_refcount); 6718 WARN_ON(!unhash_delegation_locked(dp)); 6719 list_add(&dp->dl_recall_lru, victims); 6720 } 6721 ++count; 6722 /* 6723 * Despite the fact that these functions deal with 6724 * 64-bit integers for "count", we must ensure that 6725 * it doesn't blow up the clp->cl_refcount. Throw a 6726 * warning if we start to approach INT_MAX here. 6727 */ 6728 WARN_ON_ONCE(count == (INT_MAX / 2)); 6729 if (count == max) 6730 break; 6731 } 6732 spin_unlock(&state_lock); 6733 return count; 6734 } 6735 6736 static u64 6737 nfsd_print_client_delegations(struct nfs4_client *clp) 6738 { 6739 u64 count = nfsd_find_all_delegations(clp, 0, NULL); 6740 6741 nfsd_print_count(clp, count, "delegations"); 6742 return count; 6743 } 6744 6745 u64 6746 nfsd_inject_print_delegations(void) 6747 { 6748 struct nfs4_client *clp; 6749 u64 count = 0; 6750 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6751 nfsd_net_id); 6752 6753 if (!nfsd_netns_ready(nn)) 6754 return 0; 6755 6756 spin_lock(&nn->client_lock); 6757 list_for_each_entry(clp, &nn->client_lru, cl_lru) 6758 count += nfsd_print_client_delegations(clp); 6759 spin_unlock(&nn->client_lock); 6760 6761 return count; 6762 } 6763 6764 static void 6765 nfsd_forget_delegations(struct list_head *reaplist) 6766 { 6767 struct nfs4_client *clp; 6768 struct nfs4_delegation *dp, *next; 6769 6770 list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) { 6771 list_del_init(&dp->dl_recall_lru); 6772 clp = dp->dl_stid.sc_client; 6773 revoke_delegation(dp); 6774 put_client(clp); 6775 } 6776 } 6777 6778 u64 6779 nfsd_inject_forget_client_delegations(struct sockaddr_storage *addr, 6780 size_t addr_size) 6781 { 6782 u64 count = 0; 6783 struct nfs4_client *clp; 6784 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6785 nfsd_net_id); 6786 LIST_HEAD(reaplist); 6787 6788 if (!nfsd_netns_ready(nn)) 6789 return count; 6790 6791 spin_lock(&nn->client_lock); 6792 clp = nfsd_find_client(addr, addr_size); 6793 if (clp) 6794 count = nfsd_find_all_delegations(clp, 0, &reaplist); 6795 spin_unlock(&nn->client_lock); 6796 6797 nfsd_forget_delegations(&reaplist); 6798 return count; 6799 } 6800 6801 u64 6802 nfsd_inject_forget_delegations(u64 max) 6803 { 6804 u64 count = 0; 6805 struct nfs4_client *clp; 6806 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6807 nfsd_net_id); 6808 LIST_HEAD(reaplist); 6809 6810 if (!nfsd_netns_ready(nn)) 6811 return count; 6812 6813 spin_lock(&nn->client_lock); 6814 list_for_each_entry(clp, &nn->client_lru, cl_lru) { 6815 count += nfsd_find_all_delegations(clp, max - count, &reaplist); 6816 if (max != 0 && count >= max) 6817 break; 6818 } 6819 spin_unlock(&nn->client_lock); 6820 nfsd_forget_delegations(&reaplist); 6821 return count; 6822 } 6823 6824 static void 6825 nfsd_recall_delegations(struct list_head *reaplist) 6826 { 6827 struct nfs4_client *clp; 6828 struct nfs4_delegation *dp, *next; 6829 6830 list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) { 6831 list_del_init(&dp->dl_recall_lru); 6832 clp = dp->dl_stid.sc_client; 6833 /* 6834 * We skipped all entries that had a zero dl_time before, 6835 * so we can now reset the dl_time back to 0. If a delegation 6836 * break comes in now, then it won't make any difference since 6837 * we're recalling it either way. 6838 */ 6839 spin_lock(&state_lock); 6840 dp->dl_time = 0; 6841 spin_unlock(&state_lock); 6842 nfsd_break_one_deleg(dp); 6843 put_client(clp); 6844 } 6845 } 6846 6847 u64 6848 nfsd_inject_recall_client_delegations(struct sockaddr_storage *addr, 6849 size_t addr_size) 6850 { 6851 u64 count = 0; 6852 struct nfs4_client *clp; 6853 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6854 nfsd_net_id); 6855 LIST_HEAD(reaplist); 6856 6857 if (!nfsd_netns_ready(nn)) 6858 return count; 6859 6860 spin_lock(&nn->client_lock); 6861 clp = nfsd_find_client(addr, addr_size); 6862 if (clp) 6863 count = nfsd_find_all_delegations(clp, 0, &reaplist); 6864 spin_unlock(&nn->client_lock); 6865 6866 nfsd_recall_delegations(&reaplist); 6867 return count; 6868 } 6869 6870 u64 6871 nfsd_inject_recall_delegations(u64 max) 6872 { 6873 u64 count = 0; 6874 struct nfs4_client *clp, *next; 6875 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 6876 nfsd_net_id); 6877 LIST_HEAD(reaplist); 6878 6879 if (!nfsd_netns_ready(nn)) 6880 return count; 6881 6882 spin_lock(&nn->client_lock); 6883 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) { 6884 count += nfsd_find_all_delegations(clp, max - count, &reaplist); 6885 if (max != 0 && ++count >= max) 6886 break; 6887 } 6888 spin_unlock(&nn->client_lock); 6889 nfsd_recall_delegations(&reaplist); 6890 return count; 6891 } 6892 #endif /* CONFIG_NFSD_FAULT_INJECTION */ 6893 6894 /* 6895 * Since the lifetime of a delegation isn't limited to that of an open, a 6896 * client may quite reasonably hang on to a delegation as long as it has 6897 * the inode cached. This becomes an obvious problem the first time a 6898 * client's inode cache approaches the size of the server's total memory. 6899 * 6900 * For now we avoid this problem by imposing a hard limit on the number 6901 * of delegations, which varies according to the server's memory size. 6902 */ 6903 static void 6904 set_max_delegations(void) 6905 { 6906 /* 6907 * Allow at most 4 delegations per megabyte of RAM. Quick 6908 * estimates suggest that in the worst case (where every delegation 6909 * is for a different inode), a delegation could take about 1.5K, 6910 * giving a worst case usage of about 6% of memory. 6911 */ 6912 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT); 6913 } 6914 6915 static int nfs4_state_create_net(struct net *net) 6916 { 6917 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 6918 int i; 6919 6920 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) * 6921 CLIENT_HASH_SIZE, GFP_KERNEL); 6922 if (!nn->conf_id_hashtbl) 6923 goto err; 6924 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) * 6925 CLIENT_HASH_SIZE, GFP_KERNEL); 6926 if (!nn->unconf_id_hashtbl) 6927 goto err_unconf_id; 6928 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) * 6929 SESSION_HASH_SIZE, GFP_KERNEL); 6930 if (!nn->sessionid_hashtbl) 6931 goto err_sessionid; 6932 6933 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 6934 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]); 6935 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]); 6936 } 6937 for (i = 0; i < SESSION_HASH_SIZE; i++) 6938 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]); 6939 nn->conf_name_tree = RB_ROOT; 6940 nn->unconf_name_tree = RB_ROOT; 6941 INIT_LIST_HEAD(&nn->client_lru); 6942 INIT_LIST_HEAD(&nn->close_lru); 6943 INIT_LIST_HEAD(&nn->del_recall_lru); 6944 spin_lock_init(&nn->client_lock); 6945 6946 spin_lock_init(&nn->blocked_locks_lock); 6947 INIT_LIST_HEAD(&nn->blocked_locks_lru); 6948 6949 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main); 6950 get_net(net); 6951 6952 return 0; 6953 6954 err_sessionid: 6955 kfree(nn->unconf_id_hashtbl); 6956 err_unconf_id: 6957 kfree(nn->conf_id_hashtbl); 6958 err: 6959 return -ENOMEM; 6960 } 6961 6962 static void 6963 nfs4_state_destroy_net(struct net *net) 6964 { 6965 int i; 6966 struct nfs4_client *clp = NULL; 6967 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 6968 6969 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 6970 while (!list_empty(&nn->conf_id_hashtbl[i])) { 6971 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); 6972 destroy_client(clp); 6973 } 6974 } 6975 6976 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 6977 while (!list_empty(&nn->unconf_id_hashtbl[i])) { 6978 clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); 6979 destroy_client(clp); 6980 } 6981 } 6982 6983 kfree(nn->sessionid_hashtbl); 6984 kfree(nn->unconf_id_hashtbl); 6985 kfree(nn->conf_id_hashtbl); 6986 put_net(net); 6987 } 6988 6989 int 6990 nfs4_state_start_net(struct net *net) 6991 { 6992 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 6993 int ret; 6994 6995 ret = nfs4_state_create_net(net); 6996 if (ret) 6997 return ret; 6998 nn->boot_time = get_seconds(); 6999 nn->grace_ended = false; 7000 nn->nfsd4_manager.block_opens = true; 7001 locks_start_grace(net, &nn->nfsd4_manager); 7002 nfsd4_client_tracking_init(net); 7003 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n", 7004 nn->nfsd4_grace, net); 7005 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ); 7006 return 0; 7007 } 7008 7009 /* initialization to perform when the nfsd service is started: */ 7010 7011 int 7012 nfs4_state_start(void) 7013 { 7014 int ret; 7015 7016 ret = set_callback_cred(); 7017 if (ret) 7018 return -ENOMEM; 7019 laundry_wq = alloc_workqueue("%s", WQ_UNBOUND, 0, "nfsd4"); 7020 if (laundry_wq == NULL) { 7021 ret = -ENOMEM; 7022 goto out_recovery; 7023 } 7024 ret = nfsd4_create_callback_queue(); 7025 if (ret) 7026 goto out_free_laundry; 7027 7028 set_max_delegations(); 7029 7030 return 0; 7031 7032 out_free_laundry: 7033 destroy_workqueue(laundry_wq); 7034 out_recovery: 7035 return ret; 7036 } 7037 7038 void 7039 nfs4_state_shutdown_net(struct net *net) 7040 { 7041 struct nfs4_delegation *dp = NULL; 7042 struct list_head *pos, *next, reaplist; 7043 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 7044 struct nfsd4_blocked_lock *nbl; 7045 7046 cancel_delayed_work_sync(&nn->laundromat_work); 7047 locks_end_grace(&nn->nfsd4_manager); 7048 7049 INIT_LIST_HEAD(&reaplist); 7050 spin_lock(&state_lock); 7051 list_for_each_safe(pos, next, &nn->del_recall_lru) { 7052 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 7053 WARN_ON(!unhash_delegation_locked(dp)); 7054 list_add(&dp->dl_recall_lru, &reaplist); 7055 } 7056 spin_unlock(&state_lock); 7057 list_for_each_safe(pos, next, &reaplist) { 7058 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 7059 list_del_init(&dp->dl_recall_lru); 7060 put_clnt_odstate(dp->dl_clnt_odstate); 7061 nfs4_put_deleg_lease(dp->dl_stid.sc_file); 7062 nfs4_put_stid(&dp->dl_stid); 7063 } 7064 7065 BUG_ON(!list_empty(&reaplist)); 7066 spin_lock(&nn->blocked_locks_lock); 7067 while (!list_empty(&nn->blocked_locks_lru)) { 7068 nbl = list_first_entry(&nn->blocked_locks_lru, 7069 struct nfsd4_blocked_lock, nbl_lru); 7070 list_move(&nbl->nbl_lru, &reaplist); 7071 list_del_init(&nbl->nbl_list); 7072 } 7073 spin_unlock(&nn->blocked_locks_lock); 7074 7075 while (!list_empty(&reaplist)) { 7076 nbl = list_first_entry(&nn->blocked_locks_lru, 7077 struct nfsd4_blocked_lock, nbl_lru); 7078 list_del_init(&nbl->nbl_lru); 7079 posix_unblock_lock(&nbl->nbl_lock); 7080 free_blocked_lock(nbl); 7081 } 7082 7083 nfsd4_client_tracking_exit(net); 7084 nfs4_state_destroy_net(net); 7085 } 7086 7087 void 7088 nfs4_state_shutdown(void) 7089 { 7090 destroy_workqueue(laundry_wq); 7091 nfsd4_destroy_callback_queue(); 7092 } 7093 7094 static void 7095 get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid) 7096 { 7097 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid)) 7098 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t)); 7099 } 7100 7101 static void 7102 put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid) 7103 { 7104 if (cstate->minorversion) { 7105 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t)); 7106 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG); 7107 } 7108 } 7109 7110 void 7111 clear_current_stateid(struct nfsd4_compound_state *cstate) 7112 { 7113 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG); 7114 } 7115 7116 /* 7117 * functions to set current state id 7118 */ 7119 void 7120 nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp) 7121 { 7122 put_stateid(cstate, &odp->od_stateid); 7123 } 7124 7125 void 7126 nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 7127 { 7128 put_stateid(cstate, &open->op_stateid); 7129 } 7130 7131 void 7132 nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close) 7133 { 7134 put_stateid(cstate, &close->cl_stateid); 7135 } 7136 7137 void 7138 nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock) 7139 { 7140 put_stateid(cstate, &lock->lk_resp_stateid); 7141 } 7142 7143 /* 7144 * functions to consume current state id 7145 */ 7146 7147 void 7148 nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp) 7149 { 7150 get_stateid(cstate, &odp->od_stateid); 7151 } 7152 7153 void 7154 nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp) 7155 { 7156 get_stateid(cstate, &drp->dr_stateid); 7157 } 7158 7159 void 7160 nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp) 7161 { 7162 get_stateid(cstate, &fsp->fr_stateid); 7163 } 7164 7165 void 7166 nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr) 7167 { 7168 get_stateid(cstate, &setattr->sa_stateid); 7169 } 7170 7171 void 7172 nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close) 7173 { 7174 get_stateid(cstate, &close->cl_stateid); 7175 } 7176 7177 void 7178 nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku) 7179 { 7180 get_stateid(cstate, &locku->lu_stateid); 7181 } 7182 7183 void 7184 nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read) 7185 { 7186 get_stateid(cstate, &read->rd_stateid); 7187 } 7188 7189 void 7190 nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write) 7191 { 7192 get_stateid(cstate, &write->wr_stateid); 7193 } 7194