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