1 /* 2 * linux/fs/nfsd/nfs4state.c 3 * 4 * Copyright (c) 2001 The Regents of the University of Michigan. 5 * All rights reserved. 6 * 7 * Kendrick Smith <kmsmith@umich.edu> 8 * Andy Adamson <kandros@umich.edu> 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of the University nor the names of its 20 * contributors may be used to endorse or promote products derived 21 * from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 * 35 */ 36 37 #include <linux/param.h> 38 #include <linux/major.h> 39 #include <linux/slab.h> 40 41 #include <linux/sunrpc/svc.h> 42 #include <linux/nfsd/nfsd.h> 43 #include <linux/nfsd/cache.h> 44 #include <linux/file.h> 45 #include <linux/mount.h> 46 #include <linux/workqueue.h> 47 #include <linux/smp_lock.h> 48 #include <linux/kthread.h> 49 #include <linux/nfs4.h> 50 #include <linux/nfsd/state.h> 51 #include <linux/nfsd/xdr4.h> 52 #include <linux/namei.h> 53 #include <linux/swap.h> 54 #include <linux/mutex.h> 55 #include <linux/lockd/bind.h> 56 #include <linux/module.h> 57 58 #define NFSDDBG_FACILITY NFSDDBG_PROC 59 60 /* Globals */ 61 static time_t lease_time = 90; /* default lease time */ 62 static time_t user_lease_time = 90; 63 static time_t boot_time; 64 static u32 current_ownerid = 1; 65 static u32 current_fileid = 1; 66 static u32 current_delegid = 1; 67 static u32 nfs4_init; 68 static stateid_t zerostateid; /* bits all 0 */ 69 static stateid_t onestateid; /* bits all 1 */ 70 71 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t))) 72 #define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t))) 73 74 /* forward declarations */ 75 static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags); 76 static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid); 77 static void release_stateid_lockowners(struct nfs4_stateid *open_stp); 78 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery"; 79 static void nfs4_set_recdir(char *recdir); 80 81 /* Locking: 82 * 83 * client_mutex: 84 * protects clientid_hashtbl[], clientstr_hashtbl[], 85 * unconfstr_hashtbl[], uncofid_hashtbl[]. 86 */ 87 static DEFINE_MUTEX(client_mutex); 88 89 static struct kmem_cache *stateowner_slab = NULL; 90 static struct kmem_cache *file_slab = NULL; 91 static struct kmem_cache *stateid_slab = NULL; 92 static struct kmem_cache *deleg_slab = NULL; 93 94 void 95 nfs4_lock_state(void) 96 { 97 mutex_lock(&client_mutex); 98 } 99 100 void 101 nfs4_unlock_state(void) 102 { 103 mutex_unlock(&client_mutex); 104 } 105 106 static inline u32 107 opaque_hashval(const void *ptr, int nbytes) 108 { 109 unsigned char *cptr = (unsigned char *) ptr; 110 111 u32 x = 0; 112 while (nbytes--) { 113 x *= 37; 114 x += *cptr++; 115 } 116 return x; 117 } 118 119 /* forward declarations */ 120 static void release_stateowner(struct nfs4_stateowner *sop); 121 static void release_stateid(struct nfs4_stateid *stp, int flags); 122 123 /* 124 * Delegation state 125 */ 126 127 /* recall_lock protects the del_recall_lru */ 128 static DEFINE_SPINLOCK(recall_lock); 129 static struct list_head del_recall_lru; 130 131 static void 132 free_nfs4_file(struct kref *kref) 133 { 134 struct nfs4_file *fp = container_of(kref, struct nfs4_file, fi_ref); 135 list_del(&fp->fi_hash); 136 iput(fp->fi_inode); 137 kmem_cache_free(file_slab, fp); 138 } 139 140 static inline void 141 put_nfs4_file(struct nfs4_file *fi) 142 { 143 kref_put(&fi->fi_ref, free_nfs4_file); 144 } 145 146 static inline void 147 get_nfs4_file(struct nfs4_file *fi) 148 { 149 kref_get(&fi->fi_ref); 150 } 151 152 static int num_delegations; 153 unsigned int max_delegations; 154 155 /* 156 * Open owner state (share locks) 157 */ 158 159 /* hash tables for nfs4_stateowner */ 160 #define OWNER_HASH_BITS 8 161 #define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS) 162 #define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1) 163 164 #define ownerid_hashval(id) \ 165 ((id) & OWNER_HASH_MASK) 166 #define ownerstr_hashval(clientid, ownername) \ 167 (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK) 168 169 static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE]; 170 static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE]; 171 172 /* hash table for nfs4_file */ 173 #define FILE_HASH_BITS 8 174 #define FILE_HASH_SIZE (1 << FILE_HASH_BITS) 175 #define FILE_HASH_MASK (FILE_HASH_SIZE - 1) 176 /* hash table for (open)nfs4_stateid */ 177 #define STATEID_HASH_BITS 10 178 #define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS) 179 #define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1) 180 181 #define file_hashval(x) \ 182 hash_ptr(x, FILE_HASH_BITS) 183 #define stateid_hashval(owner_id, file_id) \ 184 (((owner_id) + (file_id)) & STATEID_HASH_MASK) 185 186 static struct list_head file_hashtbl[FILE_HASH_SIZE]; 187 static struct list_head stateid_hashtbl[STATEID_HASH_SIZE]; 188 189 static struct nfs4_delegation * 190 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type) 191 { 192 struct nfs4_delegation *dp; 193 struct nfs4_file *fp = stp->st_file; 194 struct nfs4_callback *cb = &stp->st_stateowner->so_client->cl_callback; 195 196 dprintk("NFSD alloc_init_deleg\n"); 197 if (fp->fi_had_conflict) 198 return NULL; 199 if (num_delegations > max_delegations) 200 return NULL; 201 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL); 202 if (dp == NULL) 203 return dp; 204 num_delegations++; 205 INIT_LIST_HEAD(&dp->dl_perfile); 206 INIT_LIST_HEAD(&dp->dl_perclnt); 207 INIT_LIST_HEAD(&dp->dl_recall_lru); 208 dp->dl_client = clp; 209 get_nfs4_file(fp); 210 dp->dl_file = fp; 211 dp->dl_flock = NULL; 212 get_file(stp->st_vfs_file); 213 dp->dl_vfs_file = stp->st_vfs_file; 214 dp->dl_type = type; 215 dp->dl_recall.cbr_dp = NULL; 216 dp->dl_recall.cbr_ident = cb->cb_ident; 217 dp->dl_recall.cbr_trunc = 0; 218 dp->dl_stateid.si_boot = boot_time; 219 dp->dl_stateid.si_stateownerid = current_delegid++; 220 dp->dl_stateid.si_fileid = 0; 221 dp->dl_stateid.si_generation = 0; 222 dp->dl_fhlen = current_fh->fh_handle.fh_size; 223 memcpy(dp->dl_fhval, ¤t_fh->fh_handle.fh_base, 224 current_fh->fh_handle.fh_size); 225 dp->dl_time = 0; 226 atomic_set(&dp->dl_count, 1); 227 list_add(&dp->dl_perfile, &fp->fi_delegations); 228 list_add(&dp->dl_perclnt, &clp->cl_delegations); 229 return dp; 230 } 231 232 void 233 nfs4_put_delegation(struct nfs4_delegation *dp) 234 { 235 if (atomic_dec_and_test(&dp->dl_count)) { 236 dprintk("NFSD: freeing dp %p\n",dp); 237 put_nfs4_file(dp->dl_file); 238 kmem_cache_free(deleg_slab, dp); 239 num_delegations--; 240 } 241 } 242 243 /* Remove the associated file_lock first, then remove the delegation. 244 * lease_modify() is called to remove the FS_LEASE file_lock from 245 * the i_flock list, eventually calling nfsd's lock_manager 246 * fl_release_callback. 247 */ 248 static void 249 nfs4_close_delegation(struct nfs4_delegation *dp) 250 { 251 struct file *filp = dp->dl_vfs_file; 252 253 dprintk("NFSD: close_delegation dp %p\n",dp); 254 dp->dl_vfs_file = NULL; 255 /* The following nfsd_close may not actually close the file, 256 * but we want to remove the lease in any case. */ 257 if (dp->dl_flock) 258 vfs_setlease(filp, F_UNLCK, &dp->dl_flock); 259 nfsd_close(filp); 260 } 261 262 /* Called under the state lock. */ 263 static void 264 unhash_delegation(struct nfs4_delegation *dp) 265 { 266 list_del_init(&dp->dl_perfile); 267 list_del_init(&dp->dl_perclnt); 268 spin_lock(&recall_lock); 269 list_del_init(&dp->dl_recall_lru); 270 spin_unlock(&recall_lock); 271 nfs4_close_delegation(dp); 272 nfs4_put_delegation(dp); 273 } 274 275 /* 276 * SETCLIENTID state 277 */ 278 279 /* Hash tables for nfs4_clientid state */ 280 #define CLIENT_HASH_BITS 4 281 #define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS) 282 #define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1) 283 284 #define clientid_hashval(id) \ 285 ((id) & CLIENT_HASH_MASK) 286 #define clientstr_hashval(name) \ 287 (opaque_hashval((name), 8) & CLIENT_HASH_MASK) 288 /* 289 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot 290 * used in reboot/reset lease grace period processing 291 * 292 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed 293 * setclientid_confirmed info. 294 * 295 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed 296 * setclientid info. 297 * 298 * client_lru holds client queue ordered by nfs4_client.cl_time 299 * for lease renewal. 300 * 301 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time 302 * for last close replay. 303 */ 304 static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE]; 305 static int reclaim_str_hashtbl_size = 0; 306 static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE]; 307 static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE]; 308 static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE]; 309 static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE]; 310 static struct list_head client_lru; 311 static struct list_head close_lru; 312 313 static inline void 314 renew_client(struct nfs4_client *clp) 315 { 316 /* 317 * Move client to the end to the LRU list. 318 */ 319 dprintk("renewing client (clientid %08x/%08x)\n", 320 clp->cl_clientid.cl_boot, 321 clp->cl_clientid.cl_id); 322 list_move_tail(&clp->cl_lru, &client_lru); 323 clp->cl_time = get_seconds(); 324 } 325 326 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */ 327 static int 328 STALE_CLIENTID(clientid_t *clid) 329 { 330 if (clid->cl_boot == boot_time) 331 return 0; 332 dprintk("NFSD stale clientid (%08x/%08x)\n", 333 clid->cl_boot, clid->cl_id); 334 return 1; 335 } 336 337 /* 338 * XXX Should we use a slab cache ? 339 * This type of memory management is somewhat inefficient, but we use it 340 * anyway since SETCLIENTID is not a common operation. 341 */ 342 static struct nfs4_client *alloc_client(struct xdr_netobj name) 343 { 344 struct nfs4_client *clp; 345 346 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL); 347 if (clp == NULL) 348 return NULL; 349 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL); 350 if (clp->cl_name.data == NULL) { 351 kfree(clp); 352 return NULL; 353 } 354 memcpy(clp->cl_name.data, name.data, name.len); 355 clp->cl_name.len = name.len; 356 return clp; 357 } 358 359 static void 360 shutdown_callback_client(struct nfs4_client *clp) 361 { 362 struct rpc_clnt *clnt = clp->cl_callback.cb_client; 363 364 if (clnt) { 365 /* 366 * Callback threads take a reference on the client, so there 367 * should be no outstanding callbacks at this point. 368 */ 369 clp->cl_callback.cb_client = NULL; 370 rpc_shutdown_client(clnt); 371 } 372 } 373 374 static inline void 375 free_client(struct nfs4_client *clp) 376 { 377 shutdown_callback_client(clp); 378 if (clp->cl_cred.cr_group_info) 379 put_group_info(clp->cl_cred.cr_group_info); 380 kfree(clp->cl_name.data); 381 kfree(clp); 382 } 383 384 void 385 put_nfs4_client(struct nfs4_client *clp) 386 { 387 if (atomic_dec_and_test(&clp->cl_count)) 388 free_client(clp); 389 } 390 391 static void 392 expire_client(struct nfs4_client *clp) 393 { 394 struct nfs4_stateowner *sop; 395 struct nfs4_delegation *dp; 396 struct list_head reaplist; 397 398 dprintk("NFSD: expire_client cl_count %d\n", 399 atomic_read(&clp->cl_count)); 400 401 INIT_LIST_HEAD(&reaplist); 402 spin_lock(&recall_lock); 403 while (!list_empty(&clp->cl_delegations)) { 404 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt); 405 dprintk("NFSD: expire client. dp %p, fp %p\n", dp, 406 dp->dl_flock); 407 list_del_init(&dp->dl_perclnt); 408 list_move(&dp->dl_recall_lru, &reaplist); 409 } 410 spin_unlock(&recall_lock); 411 while (!list_empty(&reaplist)) { 412 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru); 413 list_del_init(&dp->dl_recall_lru); 414 unhash_delegation(dp); 415 } 416 list_del(&clp->cl_idhash); 417 list_del(&clp->cl_strhash); 418 list_del(&clp->cl_lru); 419 while (!list_empty(&clp->cl_openowners)) { 420 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient); 421 release_stateowner(sop); 422 } 423 put_nfs4_client(clp); 424 } 425 426 static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir) 427 { 428 struct nfs4_client *clp; 429 430 clp = alloc_client(name); 431 if (clp == NULL) 432 return NULL; 433 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN); 434 atomic_set(&clp->cl_count, 1); 435 atomic_set(&clp->cl_callback.cb_set, 0); 436 INIT_LIST_HEAD(&clp->cl_idhash); 437 INIT_LIST_HEAD(&clp->cl_strhash); 438 INIT_LIST_HEAD(&clp->cl_openowners); 439 INIT_LIST_HEAD(&clp->cl_delegations); 440 INIT_LIST_HEAD(&clp->cl_lru); 441 return clp; 442 } 443 444 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source) 445 { 446 memcpy(target->cl_verifier.data, source->data, 447 sizeof(target->cl_verifier.data)); 448 } 449 450 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source) 451 { 452 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 453 target->cl_clientid.cl_id = source->cl_clientid.cl_id; 454 } 455 456 static void copy_cred(struct svc_cred *target, struct svc_cred *source) 457 { 458 target->cr_uid = source->cr_uid; 459 target->cr_gid = source->cr_gid; 460 target->cr_group_info = source->cr_group_info; 461 get_group_info(target->cr_group_info); 462 } 463 464 static int same_name(const char *n1, const char *n2) 465 { 466 return 0 == memcmp(n1, n2, HEXDIR_LEN); 467 } 468 469 static int 470 same_verf(nfs4_verifier *v1, nfs4_verifier *v2) 471 { 472 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data)); 473 } 474 475 static int 476 same_clid(clientid_t *cl1, clientid_t *cl2) 477 { 478 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id); 479 } 480 481 /* XXX what about NGROUP */ 482 static int 483 same_creds(struct svc_cred *cr1, struct svc_cred *cr2) 484 { 485 return cr1->cr_uid == cr2->cr_uid; 486 } 487 488 static void gen_clid(struct nfs4_client *clp) 489 { 490 static u32 current_clientid = 1; 491 492 clp->cl_clientid.cl_boot = boot_time; 493 clp->cl_clientid.cl_id = current_clientid++; 494 } 495 496 static void gen_confirm(struct nfs4_client *clp) 497 { 498 static u32 i; 499 u32 *p; 500 501 p = (u32 *)clp->cl_confirm.data; 502 *p++ = get_seconds(); 503 *p++ = i++; 504 } 505 506 static int check_name(struct xdr_netobj name) 507 { 508 if (name.len == 0) 509 return 0; 510 if (name.len > NFS4_OPAQUE_LIMIT) { 511 dprintk("NFSD: check_name: name too long(%d)!\n", name.len); 512 return 0; 513 } 514 return 1; 515 } 516 517 static void 518 add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval) 519 { 520 unsigned int idhashval; 521 522 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]); 523 idhashval = clientid_hashval(clp->cl_clientid.cl_id); 524 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]); 525 list_add_tail(&clp->cl_lru, &client_lru); 526 clp->cl_time = get_seconds(); 527 } 528 529 static void 530 move_to_confirmed(struct nfs4_client *clp) 531 { 532 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id); 533 unsigned int strhashval; 534 535 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp); 536 list_del_init(&clp->cl_strhash); 537 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]); 538 strhashval = clientstr_hashval(clp->cl_recdir); 539 list_add(&clp->cl_strhash, &conf_str_hashtbl[strhashval]); 540 renew_client(clp); 541 } 542 543 static struct nfs4_client * 544 find_confirmed_client(clientid_t *clid) 545 { 546 struct nfs4_client *clp; 547 unsigned int idhashval = clientid_hashval(clid->cl_id); 548 549 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) { 550 if (same_clid(&clp->cl_clientid, clid)) 551 return clp; 552 } 553 return NULL; 554 } 555 556 static struct nfs4_client * 557 find_unconfirmed_client(clientid_t *clid) 558 { 559 struct nfs4_client *clp; 560 unsigned int idhashval = clientid_hashval(clid->cl_id); 561 562 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) { 563 if (same_clid(&clp->cl_clientid, clid)) 564 return clp; 565 } 566 return NULL; 567 } 568 569 static struct nfs4_client * 570 find_confirmed_client_by_str(const char *dname, unsigned int hashval) 571 { 572 struct nfs4_client *clp; 573 574 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) { 575 if (same_name(clp->cl_recdir, dname)) 576 return clp; 577 } 578 return NULL; 579 } 580 581 static struct nfs4_client * 582 find_unconfirmed_client_by_str(const char *dname, unsigned int hashval) 583 { 584 struct nfs4_client *clp; 585 586 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) { 587 if (same_name(clp->cl_recdir, dname)) 588 return clp; 589 } 590 return NULL; 591 } 592 593 /* a helper function for parse_callback */ 594 static int 595 parse_octet(unsigned int *lenp, char **addrp) 596 { 597 unsigned int len = *lenp; 598 char *p = *addrp; 599 int n = -1; 600 char c; 601 602 for (;;) { 603 if (!len) 604 break; 605 len--; 606 c = *p++; 607 if (c == '.') 608 break; 609 if ((c < '0') || (c > '9')) { 610 n = -1; 611 break; 612 } 613 if (n < 0) 614 n = 0; 615 n = (n * 10) + (c - '0'); 616 if (n > 255) { 617 n = -1; 618 break; 619 } 620 } 621 *lenp = len; 622 *addrp = p; 623 return n; 624 } 625 626 /* parse and set the setclientid ipv4 callback address */ 627 static int 628 parse_ipv4(unsigned int addr_len, char *addr_val, unsigned int *cbaddrp, unsigned short *cbportp) 629 { 630 int temp = 0; 631 u32 cbaddr = 0; 632 u16 cbport = 0; 633 u32 addrlen = addr_len; 634 char *addr = addr_val; 635 int i, shift; 636 637 /* ipaddress */ 638 shift = 24; 639 for(i = 4; i > 0 ; i--) { 640 if ((temp = parse_octet(&addrlen, &addr)) < 0) { 641 return 0; 642 } 643 cbaddr |= (temp << shift); 644 if (shift > 0) 645 shift -= 8; 646 } 647 *cbaddrp = cbaddr; 648 649 /* port */ 650 shift = 8; 651 for(i = 2; i > 0 ; i--) { 652 if ((temp = parse_octet(&addrlen, &addr)) < 0) { 653 return 0; 654 } 655 cbport |= (temp << shift); 656 if (shift > 0) 657 shift -= 8; 658 } 659 *cbportp = cbport; 660 return 1; 661 } 662 663 static void 664 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se) 665 { 666 struct nfs4_callback *cb = &clp->cl_callback; 667 668 /* Currently, we only support tcp for the callback channel */ 669 if ((se->se_callback_netid_len != 3) || memcmp((char *)se->se_callback_netid_val, "tcp", 3)) 670 goto out_err; 671 672 if ( !(parse_ipv4(se->se_callback_addr_len, se->se_callback_addr_val, 673 &cb->cb_addr, &cb->cb_port))) 674 goto out_err; 675 cb->cb_prog = se->se_callback_prog; 676 cb->cb_ident = se->se_callback_ident; 677 return; 678 out_err: 679 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) " 680 "will not receive delegations\n", 681 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id); 682 683 return; 684 } 685 686 __be32 687 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 688 struct nfsd4_setclientid *setclid) 689 { 690 struct sockaddr_in *sin = svc_addr_in(rqstp); 691 struct xdr_netobj clname = { 692 .len = setclid->se_namelen, 693 .data = setclid->se_name, 694 }; 695 nfs4_verifier clverifier = setclid->se_verf; 696 unsigned int strhashval; 697 struct nfs4_client *conf, *unconf, *new; 698 __be32 status; 699 char dname[HEXDIR_LEN]; 700 701 if (!check_name(clname)) 702 return nfserr_inval; 703 704 status = nfs4_make_rec_clidname(dname, &clname); 705 if (status) 706 return status; 707 708 /* 709 * XXX The Duplicate Request Cache (DRC) has been checked (??) 710 * We get here on a DRC miss. 711 */ 712 713 strhashval = clientstr_hashval(dname); 714 715 nfs4_lock_state(); 716 conf = find_confirmed_client_by_str(dname, strhashval); 717 if (conf) { 718 /* RFC 3530 14.2.33 CASE 0: */ 719 status = nfserr_clid_inuse; 720 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred) 721 || conf->cl_addr != sin->sin_addr.s_addr) { 722 dprintk("NFSD: setclientid: string in use by client" 723 "at %u.%u.%u.%u\n", NIPQUAD(conf->cl_addr)); 724 goto out; 725 } 726 } 727 /* 728 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION") 729 * has a description of SETCLIENTID request processing consisting 730 * of 5 bullet points, labeled as CASE0 - CASE4 below. 731 */ 732 unconf = find_unconfirmed_client_by_str(dname, strhashval); 733 status = nfserr_resource; 734 if (!conf) { 735 /* 736 * RFC 3530 14.2.33 CASE 4: 737 * placed first, because it is the normal case 738 */ 739 if (unconf) 740 expire_client(unconf); 741 new = create_client(clname, dname); 742 if (new == NULL) 743 goto out; 744 gen_clid(new); 745 } else if (same_verf(&conf->cl_verifier, &clverifier)) { 746 /* 747 * RFC 3530 14.2.33 CASE 1: 748 * probable callback update 749 */ 750 if (unconf) { 751 /* Note this is removing unconfirmed {*x***}, 752 * which is stronger than RFC recommended {vxc**}. 753 * This has the advantage that there is at most 754 * one {*x***} in either list at any time. 755 */ 756 expire_client(unconf); 757 } 758 new = create_client(clname, dname); 759 if (new == NULL) 760 goto out; 761 copy_clid(new, conf); 762 } else if (!unconf) { 763 /* 764 * RFC 3530 14.2.33 CASE 2: 765 * probable client reboot; state will be removed if 766 * confirmed. 767 */ 768 new = create_client(clname, dname); 769 if (new == NULL) 770 goto out; 771 gen_clid(new); 772 } else { 773 /* 774 * RFC 3530 14.2.33 CASE 3: 775 * probable client reboot; state will be removed if 776 * confirmed. 777 */ 778 expire_client(unconf); 779 new = create_client(clname, dname); 780 if (new == NULL) 781 goto out; 782 gen_clid(new); 783 } 784 copy_verf(new, &clverifier); 785 new->cl_addr = sin->sin_addr.s_addr; 786 copy_cred(&new->cl_cred, &rqstp->rq_cred); 787 gen_confirm(new); 788 gen_callback(new, setclid); 789 add_to_unconfirmed(new, strhashval); 790 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot; 791 setclid->se_clientid.cl_id = new->cl_clientid.cl_id; 792 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data)); 793 status = nfs_ok; 794 out: 795 nfs4_unlock_state(); 796 return status; 797 } 798 799 800 /* 801 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has 802 * a description of SETCLIENTID_CONFIRM request processing consisting of 4 803 * bullets, labeled as CASE1 - CASE4 below. 804 */ 805 __be32 806 nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 807 struct nfsd4_compound_state *cstate, 808 struct nfsd4_setclientid_confirm *setclientid_confirm) 809 { 810 struct sockaddr_in *sin = svc_addr_in(rqstp); 811 struct nfs4_client *conf, *unconf; 812 nfs4_verifier confirm = setclientid_confirm->sc_confirm; 813 clientid_t * clid = &setclientid_confirm->sc_clientid; 814 __be32 status; 815 816 if (STALE_CLIENTID(clid)) 817 return nfserr_stale_clientid; 818 /* 819 * XXX The Duplicate Request Cache (DRC) has been checked (??) 820 * We get here on a DRC miss. 821 */ 822 823 nfs4_lock_state(); 824 825 conf = find_confirmed_client(clid); 826 unconf = find_unconfirmed_client(clid); 827 828 status = nfserr_clid_inuse; 829 if (conf && conf->cl_addr != sin->sin_addr.s_addr) 830 goto out; 831 if (unconf && unconf->cl_addr != sin->sin_addr.s_addr) 832 goto out; 833 834 /* 835 * section 14.2.34 of RFC 3530 has a description of 836 * SETCLIENTID_CONFIRM request processing consisting 837 * of 4 bullet points, labeled as CASE1 - CASE4 below. 838 */ 839 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) { 840 /* 841 * RFC 3530 14.2.34 CASE 1: 842 * callback update 843 */ 844 if (!same_creds(&conf->cl_cred, &unconf->cl_cred)) 845 status = nfserr_clid_inuse; 846 else { 847 /* XXX: We just turn off callbacks until we can handle 848 * change request correctly. */ 849 atomic_set(&conf->cl_callback.cb_set, 0); 850 gen_confirm(conf); 851 nfsd4_remove_clid_dir(unconf); 852 expire_client(unconf); 853 status = nfs_ok; 854 855 } 856 } else if (conf && !unconf) { 857 /* 858 * RFC 3530 14.2.34 CASE 2: 859 * probable retransmitted request; play it safe and 860 * do nothing. 861 */ 862 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) 863 status = nfserr_clid_inuse; 864 else 865 status = nfs_ok; 866 } else if (!conf && unconf 867 && same_verf(&unconf->cl_confirm, &confirm)) { 868 /* 869 * RFC 3530 14.2.34 CASE 3: 870 * Normal case; new or rebooted client: 871 */ 872 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) { 873 status = nfserr_clid_inuse; 874 } else { 875 unsigned int hash = 876 clientstr_hashval(unconf->cl_recdir); 877 conf = find_confirmed_client_by_str(unconf->cl_recdir, 878 hash); 879 if (conf) { 880 nfsd4_remove_clid_dir(conf); 881 expire_client(conf); 882 } 883 move_to_confirmed(unconf); 884 conf = unconf; 885 nfsd4_probe_callback(conf); 886 status = nfs_ok; 887 } 888 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm))) 889 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm, 890 &confirm)))) { 891 /* 892 * RFC 3530 14.2.34 CASE 4: 893 * Client probably hasn't noticed that we rebooted yet. 894 */ 895 status = nfserr_stale_clientid; 896 } else { 897 /* check that we have hit one of the cases...*/ 898 status = nfserr_clid_inuse; 899 } 900 out: 901 nfs4_unlock_state(); 902 return status; 903 } 904 905 /* OPEN Share state helper functions */ 906 static inline struct nfs4_file * 907 alloc_init_file(struct inode *ino) 908 { 909 struct nfs4_file *fp; 910 unsigned int hashval = file_hashval(ino); 911 912 fp = kmem_cache_alloc(file_slab, GFP_KERNEL); 913 if (fp) { 914 kref_init(&fp->fi_ref); 915 INIT_LIST_HEAD(&fp->fi_hash); 916 INIT_LIST_HEAD(&fp->fi_stateids); 917 INIT_LIST_HEAD(&fp->fi_delegations); 918 list_add(&fp->fi_hash, &file_hashtbl[hashval]); 919 fp->fi_inode = igrab(ino); 920 fp->fi_id = current_fileid++; 921 fp->fi_had_conflict = false; 922 return fp; 923 } 924 return NULL; 925 } 926 927 static void 928 nfsd4_free_slab(struct kmem_cache **slab) 929 { 930 if (*slab == NULL) 931 return; 932 kmem_cache_destroy(*slab); 933 *slab = NULL; 934 } 935 936 void 937 nfsd4_free_slabs(void) 938 { 939 nfsd4_free_slab(&stateowner_slab); 940 nfsd4_free_slab(&file_slab); 941 nfsd4_free_slab(&stateid_slab); 942 nfsd4_free_slab(&deleg_slab); 943 } 944 945 static int 946 nfsd4_init_slabs(void) 947 { 948 stateowner_slab = kmem_cache_create("nfsd4_stateowners", 949 sizeof(struct nfs4_stateowner), 0, 0, NULL); 950 if (stateowner_slab == NULL) 951 goto out_nomem; 952 file_slab = kmem_cache_create("nfsd4_files", 953 sizeof(struct nfs4_file), 0, 0, NULL); 954 if (file_slab == NULL) 955 goto out_nomem; 956 stateid_slab = kmem_cache_create("nfsd4_stateids", 957 sizeof(struct nfs4_stateid), 0, 0, NULL); 958 if (stateid_slab == NULL) 959 goto out_nomem; 960 deleg_slab = kmem_cache_create("nfsd4_delegations", 961 sizeof(struct nfs4_delegation), 0, 0, NULL); 962 if (deleg_slab == NULL) 963 goto out_nomem; 964 return 0; 965 out_nomem: 966 nfsd4_free_slabs(); 967 dprintk("nfsd4: out of memory while initializing nfsv4\n"); 968 return -ENOMEM; 969 } 970 971 void 972 nfs4_free_stateowner(struct kref *kref) 973 { 974 struct nfs4_stateowner *sop = 975 container_of(kref, struct nfs4_stateowner, so_ref); 976 kfree(sop->so_owner.data); 977 kmem_cache_free(stateowner_slab, sop); 978 } 979 980 static inline struct nfs4_stateowner * 981 alloc_stateowner(struct xdr_netobj *owner) 982 { 983 struct nfs4_stateowner *sop; 984 985 if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) { 986 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) { 987 memcpy(sop->so_owner.data, owner->data, owner->len); 988 sop->so_owner.len = owner->len; 989 kref_init(&sop->so_ref); 990 return sop; 991 } 992 kmem_cache_free(stateowner_slab, sop); 993 } 994 return NULL; 995 } 996 997 static struct nfs4_stateowner * 998 alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) { 999 struct nfs4_stateowner *sop; 1000 struct nfs4_replay *rp; 1001 unsigned int idhashval; 1002 1003 if (!(sop = alloc_stateowner(&open->op_owner))) 1004 return NULL; 1005 idhashval = ownerid_hashval(current_ownerid); 1006 INIT_LIST_HEAD(&sop->so_idhash); 1007 INIT_LIST_HEAD(&sop->so_strhash); 1008 INIT_LIST_HEAD(&sop->so_perclient); 1009 INIT_LIST_HEAD(&sop->so_stateids); 1010 INIT_LIST_HEAD(&sop->so_perstateid); /* not used */ 1011 INIT_LIST_HEAD(&sop->so_close_lru); 1012 sop->so_time = 0; 1013 list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]); 1014 list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]); 1015 list_add(&sop->so_perclient, &clp->cl_openowners); 1016 sop->so_is_open_owner = 1; 1017 sop->so_id = current_ownerid++; 1018 sop->so_client = clp; 1019 sop->so_seqid = open->op_seqid; 1020 sop->so_confirmed = 0; 1021 rp = &sop->so_replay; 1022 rp->rp_status = nfserr_serverfault; 1023 rp->rp_buflen = 0; 1024 rp->rp_buf = rp->rp_ibuf; 1025 return sop; 1026 } 1027 1028 static void 1029 release_stateid_lockowners(struct nfs4_stateid *open_stp) 1030 { 1031 struct nfs4_stateowner *lock_sop; 1032 1033 while (!list_empty(&open_stp->st_lockowners)) { 1034 lock_sop = list_entry(open_stp->st_lockowners.next, 1035 struct nfs4_stateowner, so_perstateid); 1036 /* list_del(&open_stp->st_lockowners); */ 1037 BUG_ON(lock_sop->so_is_open_owner); 1038 release_stateowner(lock_sop); 1039 } 1040 } 1041 1042 static void 1043 unhash_stateowner(struct nfs4_stateowner *sop) 1044 { 1045 struct nfs4_stateid *stp; 1046 1047 list_del(&sop->so_idhash); 1048 list_del(&sop->so_strhash); 1049 if (sop->so_is_open_owner) 1050 list_del(&sop->so_perclient); 1051 list_del(&sop->so_perstateid); 1052 while (!list_empty(&sop->so_stateids)) { 1053 stp = list_entry(sop->so_stateids.next, 1054 struct nfs4_stateid, st_perstateowner); 1055 if (sop->so_is_open_owner) 1056 release_stateid(stp, OPEN_STATE); 1057 else 1058 release_stateid(stp, LOCK_STATE); 1059 } 1060 } 1061 1062 static void 1063 release_stateowner(struct nfs4_stateowner *sop) 1064 { 1065 unhash_stateowner(sop); 1066 list_del(&sop->so_close_lru); 1067 nfs4_put_stateowner(sop); 1068 } 1069 1070 static inline void 1071 init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) { 1072 struct nfs4_stateowner *sop = open->op_stateowner; 1073 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id); 1074 1075 INIT_LIST_HEAD(&stp->st_hash); 1076 INIT_LIST_HEAD(&stp->st_perstateowner); 1077 INIT_LIST_HEAD(&stp->st_lockowners); 1078 INIT_LIST_HEAD(&stp->st_perfile); 1079 list_add(&stp->st_hash, &stateid_hashtbl[hashval]); 1080 list_add(&stp->st_perstateowner, &sop->so_stateids); 1081 list_add(&stp->st_perfile, &fp->fi_stateids); 1082 stp->st_stateowner = sop; 1083 get_nfs4_file(fp); 1084 stp->st_file = fp; 1085 stp->st_stateid.si_boot = boot_time; 1086 stp->st_stateid.si_stateownerid = sop->so_id; 1087 stp->st_stateid.si_fileid = fp->fi_id; 1088 stp->st_stateid.si_generation = 0; 1089 stp->st_access_bmap = 0; 1090 stp->st_deny_bmap = 0; 1091 __set_bit(open->op_share_access, &stp->st_access_bmap); 1092 __set_bit(open->op_share_deny, &stp->st_deny_bmap); 1093 stp->st_openstp = NULL; 1094 } 1095 1096 static void 1097 release_stateid(struct nfs4_stateid *stp, int flags) 1098 { 1099 struct file *filp = stp->st_vfs_file; 1100 1101 list_del(&stp->st_hash); 1102 list_del(&stp->st_perfile); 1103 list_del(&stp->st_perstateowner); 1104 if (flags & OPEN_STATE) { 1105 release_stateid_lockowners(stp); 1106 stp->st_vfs_file = NULL; 1107 nfsd_close(filp); 1108 } else if (flags & LOCK_STATE) 1109 locks_remove_posix(filp, (fl_owner_t) stp->st_stateowner); 1110 put_nfs4_file(stp->st_file); 1111 kmem_cache_free(stateid_slab, stp); 1112 } 1113 1114 static void 1115 move_to_close_lru(struct nfs4_stateowner *sop) 1116 { 1117 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop); 1118 1119 list_move_tail(&sop->so_close_lru, &close_lru); 1120 sop->so_time = get_seconds(); 1121 } 1122 1123 static int 1124 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner, 1125 clientid_t *clid) 1126 { 1127 return (sop->so_owner.len == owner->len) && 1128 0 == memcmp(sop->so_owner.data, owner->data, owner->len) && 1129 (sop->so_client->cl_clientid.cl_id == clid->cl_id); 1130 } 1131 1132 static struct nfs4_stateowner * 1133 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open) 1134 { 1135 struct nfs4_stateowner *so = NULL; 1136 1137 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) { 1138 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) 1139 return so; 1140 } 1141 return NULL; 1142 } 1143 1144 /* search file_hashtbl[] for file */ 1145 static struct nfs4_file * 1146 find_file(struct inode *ino) 1147 { 1148 unsigned int hashval = file_hashval(ino); 1149 struct nfs4_file *fp; 1150 1151 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) { 1152 if (fp->fi_inode == ino) { 1153 get_nfs4_file(fp); 1154 return fp; 1155 } 1156 } 1157 return NULL; 1158 } 1159 1160 static inline int access_valid(u32 x) 1161 { 1162 if (x < NFS4_SHARE_ACCESS_READ) 1163 return 0; 1164 if (x > NFS4_SHARE_ACCESS_BOTH) 1165 return 0; 1166 return 1; 1167 } 1168 1169 static inline int deny_valid(u32 x) 1170 { 1171 /* Note: unlike access bits, deny bits may be zero. */ 1172 return x <= NFS4_SHARE_DENY_BOTH; 1173 } 1174 1175 /* 1176 * We store the NONE, READ, WRITE, and BOTH bits separately in the 1177 * st_{access,deny}_bmap field of the stateid, in order to track not 1178 * only what share bits are currently in force, but also what 1179 * combinations of share bits previous opens have used. This allows us 1180 * to enforce the recommendation of rfc 3530 14.2.19 that the server 1181 * return an error if the client attempt to downgrade to a combination 1182 * of share bits not explicable by closing some of its previous opens. 1183 * 1184 * XXX: This enforcement is actually incomplete, since we don't keep 1185 * track of access/deny bit combinations; so, e.g., we allow: 1186 * 1187 * OPEN allow read, deny write 1188 * OPEN allow both, deny none 1189 * DOWNGRADE allow read, deny none 1190 * 1191 * which we should reject. 1192 */ 1193 static void 1194 set_access(unsigned int *access, unsigned long bmap) { 1195 int i; 1196 1197 *access = 0; 1198 for (i = 1; i < 4; i++) { 1199 if (test_bit(i, &bmap)) 1200 *access |= i; 1201 } 1202 } 1203 1204 static void 1205 set_deny(unsigned int *deny, unsigned long bmap) { 1206 int i; 1207 1208 *deny = 0; 1209 for (i = 0; i < 4; i++) { 1210 if (test_bit(i, &bmap)) 1211 *deny |= i ; 1212 } 1213 } 1214 1215 static int 1216 test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) { 1217 unsigned int access, deny; 1218 1219 set_access(&access, stp->st_access_bmap); 1220 set_deny(&deny, stp->st_deny_bmap); 1221 if ((access & open->op_share_deny) || (deny & open->op_share_access)) 1222 return 0; 1223 return 1; 1224 } 1225 1226 /* 1227 * Called to check deny when READ with all zero stateid or 1228 * WRITE with all zero or all one stateid 1229 */ 1230 static __be32 1231 nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type) 1232 { 1233 struct inode *ino = current_fh->fh_dentry->d_inode; 1234 struct nfs4_file *fp; 1235 struct nfs4_stateid *stp; 1236 __be32 ret; 1237 1238 dprintk("NFSD: nfs4_share_conflict\n"); 1239 1240 fp = find_file(ino); 1241 if (!fp) 1242 return nfs_ok; 1243 ret = nfserr_locked; 1244 /* Search for conflicting share reservations */ 1245 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) { 1246 if (test_bit(deny_type, &stp->st_deny_bmap) || 1247 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap)) 1248 goto out; 1249 } 1250 ret = nfs_ok; 1251 out: 1252 put_nfs4_file(fp); 1253 return ret; 1254 } 1255 1256 static inline void 1257 nfs4_file_downgrade(struct file *filp, unsigned int share_access) 1258 { 1259 if (share_access & NFS4_SHARE_ACCESS_WRITE) { 1260 drop_file_write_access(filp); 1261 filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE; 1262 } 1263 } 1264 1265 /* 1266 * Recall a delegation 1267 */ 1268 static int 1269 do_recall(void *__dp) 1270 { 1271 struct nfs4_delegation *dp = __dp; 1272 1273 dp->dl_file->fi_had_conflict = true; 1274 nfsd4_cb_recall(dp); 1275 return 0; 1276 } 1277 1278 /* 1279 * Spawn a thread to perform a recall on the delegation represented 1280 * by the lease (file_lock) 1281 * 1282 * Called from break_lease() with lock_kernel() held. 1283 * Note: we assume break_lease will only call this *once* for any given 1284 * lease. 1285 */ 1286 static 1287 void nfsd_break_deleg_cb(struct file_lock *fl) 1288 { 1289 struct nfs4_delegation *dp= (struct nfs4_delegation *)fl->fl_owner; 1290 struct task_struct *t; 1291 1292 dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl); 1293 if (!dp) 1294 return; 1295 1296 /* We're assuming the state code never drops its reference 1297 * without first removing the lease. Since we're in this lease 1298 * callback (and since the lease code is serialized by the kernel 1299 * lock) we know the server hasn't removed the lease yet, we know 1300 * it's safe to take a reference: */ 1301 atomic_inc(&dp->dl_count); 1302 atomic_inc(&dp->dl_client->cl_count); 1303 1304 spin_lock(&recall_lock); 1305 list_add_tail(&dp->dl_recall_lru, &del_recall_lru); 1306 spin_unlock(&recall_lock); 1307 1308 /* only place dl_time is set. protected by lock_kernel*/ 1309 dp->dl_time = get_seconds(); 1310 1311 /* 1312 * We don't want the locks code to timeout the lease for us; 1313 * we'll remove it ourself if the delegation isn't returned 1314 * in time. 1315 */ 1316 fl->fl_break_time = 0; 1317 1318 t = kthread_run(do_recall, dp, "%s", "nfs4_cb_recall"); 1319 if (IS_ERR(t)) { 1320 struct nfs4_client *clp = dp->dl_client; 1321 1322 printk(KERN_INFO "NFSD: Callback thread failed for " 1323 "for client (clientid %08x/%08x)\n", 1324 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id); 1325 put_nfs4_client(dp->dl_client); 1326 nfs4_put_delegation(dp); 1327 } 1328 } 1329 1330 /* 1331 * The file_lock is being reapd. 1332 * 1333 * Called by locks_free_lock() with lock_kernel() held. 1334 */ 1335 static 1336 void nfsd_release_deleg_cb(struct file_lock *fl) 1337 { 1338 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner; 1339 1340 dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count)); 1341 1342 if (!(fl->fl_flags & FL_LEASE) || !dp) 1343 return; 1344 dp->dl_flock = NULL; 1345 } 1346 1347 /* 1348 * Set the delegation file_lock back pointer. 1349 * 1350 * Called from setlease() with lock_kernel() held. 1351 */ 1352 static 1353 void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl) 1354 { 1355 struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner; 1356 1357 dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp); 1358 if (!dp) 1359 return; 1360 dp->dl_flock = new; 1361 } 1362 1363 /* 1364 * Called from setlease() with lock_kernel() held 1365 */ 1366 static 1367 int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try) 1368 { 1369 struct nfs4_delegation *onlistd = 1370 (struct nfs4_delegation *)onlist->fl_owner; 1371 struct nfs4_delegation *tryd = 1372 (struct nfs4_delegation *)try->fl_owner; 1373 1374 if (onlist->fl_lmops != try->fl_lmops) 1375 return 0; 1376 1377 return onlistd->dl_client == tryd->dl_client; 1378 } 1379 1380 1381 static 1382 int nfsd_change_deleg_cb(struct file_lock **onlist, int arg) 1383 { 1384 if (arg & F_UNLCK) 1385 return lease_modify(onlist, arg); 1386 else 1387 return -EAGAIN; 1388 } 1389 1390 static struct lock_manager_operations nfsd_lease_mng_ops = { 1391 .fl_break = nfsd_break_deleg_cb, 1392 .fl_release_private = nfsd_release_deleg_cb, 1393 .fl_copy_lock = nfsd_copy_lock_deleg_cb, 1394 .fl_mylease = nfsd_same_client_deleg_cb, 1395 .fl_change = nfsd_change_deleg_cb, 1396 }; 1397 1398 1399 __be32 1400 nfsd4_process_open1(struct nfsd4_open *open) 1401 { 1402 clientid_t *clientid = &open->op_clientid; 1403 struct nfs4_client *clp = NULL; 1404 unsigned int strhashval; 1405 struct nfs4_stateowner *sop = NULL; 1406 1407 if (!check_name(open->op_owner)) 1408 return nfserr_inval; 1409 1410 if (STALE_CLIENTID(&open->op_clientid)) 1411 return nfserr_stale_clientid; 1412 1413 strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner); 1414 sop = find_openstateowner_str(strhashval, open); 1415 open->op_stateowner = sop; 1416 if (!sop) { 1417 /* Make sure the client's lease hasn't expired. */ 1418 clp = find_confirmed_client(clientid); 1419 if (clp == NULL) 1420 return nfserr_expired; 1421 goto renew; 1422 } 1423 if (!sop->so_confirmed) { 1424 /* Replace unconfirmed owners without checking for replay. */ 1425 clp = sop->so_client; 1426 release_stateowner(sop); 1427 open->op_stateowner = NULL; 1428 goto renew; 1429 } 1430 if (open->op_seqid == sop->so_seqid - 1) { 1431 if (sop->so_replay.rp_buflen) 1432 return nfserr_replay_me; 1433 /* The original OPEN failed so spectacularly 1434 * that we don't even have replay data saved! 1435 * Therefore, we have no choice but to continue 1436 * processing this OPEN; presumably, we'll 1437 * fail again for the same reason. 1438 */ 1439 dprintk("nfsd4_process_open1: replay with no replay cache\n"); 1440 goto renew; 1441 } 1442 if (open->op_seqid != sop->so_seqid) 1443 return nfserr_bad_seqid; 1444 renew: 1445 if (open->op_stateowner == NULL) { 1446 sop = alloc_init_open_stateowner(strhashval, clp, open); 1447 if (sop == NULL) 1448 return nfserr_resource; 1449 open->op_stateowner = sop; 1450 } 1451 list_del_init(&sop->so_close_lru); 1452 renew_client(sop->so_client); 1453 return nfs_ok; 1454 } 1455 1456 static inline __be32 1457 nfs4_check_delegmode(struct nfs4_delegation *dp, int flags) 1458 { 1459 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ)) 1460 return nfserr_openmode; 1461 else 1462 return nfs_ok; 1463 } 1464 1465 static struct nfs4_delegation * 1466 find_delegation_file(struct nfs4_file *fp, stateid_t *stid) 1467 { 1468 struct nfs4_delegation *dp; 1469 1470 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) { 1471 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) 1472 return dp; 1473 } 1474 return NULL; 1475 } 1476 1477 static __be32 1478 nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open, 1479 struct nfs4_delegation **dp) 1480 { 1481 int flags; 1482 __be32 status = nfserr_bad_stateid; 1483 1484 *dp = find_delegation_file(fp, &open->op_delegate_stateid); 1485 if (*dp == NULL) 1486 goto out; 1487 flags = open->op_share_access == NFS4_SHARE_ACCESS_READ ? 1488 RD_STATE : WR_STATE; 1489 status = nfs4_check_delegmode(*dp, flags); 1490 if (status) 1491 *dp = NULL; 1492 out: 1493 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR) 1494 return nfs_ok; 1495 if (status) 1496 return status; 1497 open->op_stateowner->so_confirmed = 1; 1498 return nfs_ok; 1499 } 1500 1501 static __be32 1502 nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp) 1503 { 1504 struct nfs4_stateid *local; 1505 __be32 status = nfserr_share_denied; 1506 struct nfs4_stateowner *sop = open->op_stateowner; 1507 1508 list_for_each_entry(local, &fp->fi_stateids, st_perfile) { 1509 /* ignore lock owners */ 1510 if (local->st_stateowner->so_is_open_owner == 0) 1511 continue; 1512 /* remember if we have seen this open owner */ 1513 if (local->st_stateowner == sop) 1514 *stpp = local; 1515 /* check for conflicting share reservations */ 1516 if (!test_share(local, open)) 1517 goto out; 1518 } 1519 status = 0; 1520 out: 1521 return status; 1522 } 1523 1524 static inline struct nfs4_stateid * 1525 nfs4_alloc_stateid(void) 1526 { 1527 return kmem_cache_alloc(stateid_slab, GFP_KERNEL); 1528 } 1529 1530 static __be32 1531 nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp, 1532 struct nfs4_delegation *dp, 1533 struct svc_fh *cur_fh, int flags) 1534 { 1535 struct nfs4_stateid *stp; 1536 1537 stp = nfs4_alloc_stateid(); 1538 if (stp == NULL) 1539 return nfserr_resource; 1540 1541 if (dp) { 1542 get_file(dp->dl_vfs_file); 1543 stp->st_vfs_file = dp->dl_vfs_file; 1544 } else { 1545 __be32 status; 1546 status = nfsd_open(rqstp, cur_fh, S_IFREG, flags, 1547 &stp->st_vfs_file); 1548 if (status) { 1549 if (status == nfserr_dropit) 1550 status = nfserr_jukebox; 1551 kmem_cache_free(stateid_slab, stp); 1552 return status; 1553 } 1554 } 1555 *stpp = stp; 1556 return 0; 1557 } 1558 1559 static inline __be32 1560 nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh, 1561 struct nfsd4_open *open) 1562 { 1563 struct iattr iattr = { 1564 .ia_valid = ATTR_SIZE, 1565 .ia_size = 0, 1566 }; 1567 if (!open->op_truncate) 1568 return 0; 1569 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 1570 return nfserr_inval; 1571 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0); 1572 } 1573 1574 static __be32 1575 nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open) 1576 { 1577 struct file *filp = stp->st_vfs_file; 1578 struct inode *inode = filp->f_path.dentry->d_inode; 1579 unsigned int share_access, new_writer; 1580 __be32 status; 1581 1582 set_access(&share_access, stp->st_access_bmap); 1583 new_writer = (~share_access) & open->op_share_access 1584 & NFS4_SHARE_ACCESS_WRITE; 1585 1586 if (new_writer) { 1587 int err = get_write_access(inode); 1588 if (err) 1589 return nfserrno(err); 1590 err = mnt_want_write(cur_fh->fh_export->ex_path.mnt); 1591 if (err) 1592 return nfserrno(err); 1593 file_take_write(filp); 1594 } 1595 status = nfsd4_truncate(rqstp, cur_fh, open); 1596 if (status) { 1597 if (new_writer) 1598 put_write_access(inode); 1599 return status; 1600 } 1601 /* remember the open */ 1602 filp->f_mode |= open->op_share_access; 1603 __set_bit(open->op_share_access, &stp->st_access_bmap); 1604 __set_bit(open->op_share_deny, &stp->st_deny_bmap); 1605 1606 return nfs_ok; 1607 } 1608 1609 1610 static void 1611 nfs4_set_claim_prev(struct nfsd4_open *open) 1612 { 1613 open->op_stateowner->so_confirmed = 1; 1614 open->op_stateowner->so_client->cl_firststate = 1; 1615 } 1616 1617 /* 1618 * Attempt to hand out a delegation. 1619 */ 1620 static void 1621 nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp) 1622 { 1623 struct nfs4_delegation *dp; 1624 struct nfs4_stateowner *sop = stp->st_stateowner; 1625 struct nfs4_callback *cb = &sop->so_client->cl_callback; 1626 struct file_lock fl, *flp = &fl; 1627 int status, flag = 0; 1628 1629 flag = NFS4_OPEN_DELEGATE_NONE; 1630 open->op_recall = 0; 1631 switch (open->op_claim_type) { 1632 case NFS4_OPEN_CLAIM_PREVIOUS: 1633 if (!atomic_read(&cb->cb_set)) 1634 open->op_recall = 1; 1635 flag = open->op_delegate_type; 1636 if (flag == NFS4_OPEN_DELEGATE_NONE) 1637 goto out; 1638 break; 1639 case NFS4_OPEN_CLAIM_NULL: 1640 /* Let's not give out any delegations till everyone's 1641 * had the chance to reclaim theirs.... */ 1642 if (locks_in_grace()) 1643 goto out; 1644 if (!atomic_read(&cb->cb_set) || !sop->so_confirmed) 1645 goto out; 1646 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 1647 flag = NFS4_OPEN_DELEGATE_WRITE; 1648 else 1649 flag = NFS4_OPEN_DELEGATE_READ; 1650 break; 1651 default: 1652 goto out; 1653 } 1654 1655 dp = alloc_init_deleg(sop->so_client, stp, fh, flag); 1656 if (dp == NULL) { 1657 flag = NFS4_OPEN_DELEGATE_NONE; 1658 goto out; 1659 } 1660 locks_init_lock(&fl); 1661 fl.fl_lmops = &nfsd_lease_mng_ops; 1662 fl.fl_flags = FL_LEASE; 1663 fl.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK; 1664 fl.fl_end = OFFSET_MAX; 1665 fl.fl_owner = (fl_owner_t)dp; 1666 fl.fl_file = stp->st_vfs_file; 1667 fl.fl_pid = current->tgid; 1668 1669 /* vfs_setlease checks to see if delegation should be handed out. 1670 * the lock_manager callbacks fl_mylease and fl_change are used 1671 */ 1672 if ((status = vfs_setlease(stp->st_vfs_file, fl.fl_type, &flp))) { 1673 dprintk("NFSD: setlease failed [%d], no delegation\n", status); 1674 unhash_delegation(dp); 1675 flag = NFS4_OPEN_DELEGATE_NONE; 1676 goto out; 1677 } 1678 1679 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid)); 1680 1681 dprintk("NFSD: delegation stateid=(%08x/%08x/%08x/%08x)\n\n", 1682 dp->dl_stateid.si_boot, 1683 dp->dl_stateid.si_stateownerid, 1684 dp->dl_stateid.si_fileid, 1685 dp->dl_stateid.si_generation); 1686 out: 1687 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS 1688 && flag == NFS4_OPEN_DELEGATE_NONE 1689 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) 1690 dprintk("NFSD: WARNING: refusing delegation reclaim\n"); 1691 open->op_delegate_type = flag; 1692 } 1693 1694 /* 1695 * called with nfs4_lock_state() held. 1696 */ 1697 __be32 1698 nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 1699 { 1700 struct nfs4_file *fp = NULL; 1701 struct inode *ino = current_fh->fh_dentry->d_inode; 1702 struct nfs4_stateid *stp = NULL; 1703 struct nfs4_delegation *dp = NULL; 1704 __be32 status; 1705 1706 status = nfserr_inval; 1707 if (!access_valid(open->op_share_access) 1708 || !deny_valid(open->op_share_deny)) 1709 goto out; 1710 /* 1711 * Lookup file; if found, lookup stateid and check open request, 1712 * and check for delegations in the process of being recalled. 1713 * If not found, create the nfs4_file struct 1714 */ 1715 fp = find_file(ino); 1716 if (fp) { 1717 if ((status = nfs4_check_open(fp, open, &stp))) 1718 goto out; 1719 status = nfs4_check_deleg(fp, open, &dp); 1720 if (status) 1721 goto out; 1722 } else { 1723 status = nfserr_bad_stateid; 1724 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) 1725 goto out; 1726 status = nfserr_resource; 1727 fp = alloc_init_file(ino); 1728 if (fp == NULL) 1729 goto out; 1730 } 1731 1732 /* 1733 * OPEN the file, or upgrade an existing OPEN. 1734 * If truncate fails, the OPEN fails. 1735 */ 1736 if (stp) { 1737 /* Stateid was found, this is an OPEN upgrade */ 1738 status = nfs4_upgrade_open(rqstp, current_fh, stp, open); 1739 if (status) 1740 goto out; 1741 update_stateid(&stp->st_stateid); 1742 } else { 1743 /* Stateid was not found, this is a new OPEN */ 1744 int flags = 0; 1745 if (open->op_share_access & NFS4_SHARE_ACCESS_READ) 1746 flags |= NFSD_MAY_READ; 1747 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 1748 flags |= NFSD_MAY_WRITE; 1749 status = nfs4_new_open(rqstp, &stp, dp, current_fh, flags); 1750 if (status) 1751 goto out; 1752 init_stateid(stp, fp, open); 1753 status = nfsd4_truncate(rqstp, current_fh, open); 1754 if (status) { 1755 release_stateid(stp, OPEN_STATE); 1756 goto out; 1757 } 1758 } 1759 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t)); 1760 1761 /* 1762 * Attempt to hand out a delegation. No error return, because the 1763 * OPEN succeeds even if we fail. 1764 */ 1765 nfs4_open_delegation(current_fh, open, stp); 1766 1767 status = nfs_ok; 1768 1769 dprintk("nfs4_process_open2: stateid=(%08x/%08x/%08x/%08x)\n", 1770 stp->st_stateid.si_boot, stp->st_stateid.si_stateownerid, 1771 stp->st_stateid.si_fileid, stp->st_stateid.si_generation); 1772 out: 1773 if (fp) 1774 put_nfs4_file(fp); 1775 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 1776 nfs4_set_claim_prev(open); 1777 /* 1778 * To finish the open response, we just need to set the rflags. 1779 */ 1780 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX; 1781 if (!open->op_stateowner->so_confirmed) 1782 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM; 1783 1784 return status; 1785 } 1786 1787 __be32 1788 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 1789 clientid_t *clid) 1790 { 1791 struct nfs4_client *clp; 1792 __be32 status; 1793 1794 nfs4_lock_state(); 1795 dprintk("process_renew(%08x/%08x): starting\n", 1796 clid->cl_boot, clid->cl_id); 1797 status = nfserr_stale_clientid; 1798 if (STALE_CLIENTID(clid)) 1799 goto out; 1800 clp = find_confirmed_client(clid); 1801 status = nfserr_expired; 1802 if (clp == NULL) { 1803 /* We assume the client took too long to RENEW. */ 1804 dprintk("nfsd4_renew: clientid not found!\n"); 1805 goto out; 1806 } 1807 renew_client(clp); 1808 status = nfserr_cb_path_down; 1809 if (!list_empty(&clp->cl_delegations) 1810 && !atomic_read(&clp->cl_callback.cb_set)) 1811 goto out; 1812 status = nfs_ok; 1813 out: 1814 nfs4_unlock_state(); 1815 return status; 1816 } 1817 1818 struct lock_manager nfsd4_manager = { 1819 }; 1820 1821 static void 1822 nfsd4_end_grace(void) 1823 { 1824 dprintk("NFSD: end of grace period\n"); 1825 nfsd4_recdir_purge_old(); 1826 locks_end_grace(&nfsd4_manager); 1827 } 1828 1829 static time_t 1830 nfs4_laundromat(void) 1831 { 1832 struct nfs4_client *clp; 1833 struct nfs4_stateowner *sop; 1834 struct nfs4_delegation *dp; 1835 struct list_head *pos, *next, reaplist; 1836 time_t cutoff = get_seconds() - NFSD_LEASE_TIME; 1837 time_t t, clientid_val = NFSD_LEASE_TIME; 1838 time_t u, test_val = NFSD_LEASE_TIME; 1839 1840 nfs4_lock_state(); 1841 1842 dprintk("NFSD: laundromat service - starting\n"); 1843 if (locks_in_grace()) 1844 nfsd4_end_grace(); 1845 list_for_each_safe(pos, next, &client_lru) { 1846 clp = list_entry(pos, struct nfs4_client, cl_lru); 1847 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) { 1848 t = clp->cl_time - cutoff; 1849 if (clientid_val > t) 1850 clientid_val = t; 1851 break; 1852 } 1853 dprintk("NFSD: purging unused client (clientid %08x)\n", 1854 clp->cl_clientid.cl_id); 1855 nfsd4_remove_clid_dir(clp); 1856 expire_client(clp); 1857 } 1858 INIT_LIST_HEAD(&reaplist); 1859 spin_lock(&recall_lock); 1860 list_for_each_safe(pos, next, &del_recall_lru) { 1861 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 1862 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) { 1863 u = dp->dl_time - cutoff; 1864 if (test_val > u) 1865 test_val = u; 1866 break; 1867 } 1868 dprintk("NFSD: purging unused delegation dp %p, fp %p\n", 1869 dp, dp->dl_flock); 1870 list_move(&dp->dl_recall_lru, &reaplist); 1871 } 1872 spin_unlock(&recall_lock); 1873 list_for_each_safe(pos, next, &reaplist) { 1874 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 1875 list_del_init(&dp->dl_recall_lru); 1876 unhash_delegation(dp); 1877 } 1878 test_val = NFSD_LEASE_TIME; 1879 list_for_each_safe(pos, next, &close_lru) { 1880 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru); 1881 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) { 1882 u = sop->so_time - cutoff; 1883 if (test_val > u) 1884 test_val = u; 1885 break; 1886 } 1887 dprintk("NFSD: purging unused open stateowner (so_id %d)\n", 1888 sop->so_id); 1889 release_stateowner(sop); 1890 } 1891 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT) 1892 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT; 1893 nfs4_unlock_state(); 1894 return clientid_val; 1895 } 1896 1897 static struct workqueue_struct *laundry_wq; 1898 static void laundromat_main(struct work_struct *); 1899 static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main); 1900 1901 static void 1902 laundromat_main(struct work_struct *not_used) 1903 { 1904 time_t t; 1905 1906 t = nfs4_laundromat(); 1907 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t); 1908 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ); 1909 } 1910 1911 static struct nfs4_stateowner * 1912 search_close_lru(u32 st_id, int flags) 1913 { 1914 struct nfs4_stateowner *local = NULL; 1915 1916 if (flags & CLOSE_STATE) { 1917 list_for_each_entry(local, &close_lru, so_close_lru) { 1918 if (local->so_id == st_id) 1919 return local; 1920 } 1921 } 1922 return NULL; 1923 } 1924 1925 static inline int 1926 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp) 1927 { 1928 return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_path.dentry->d_inode; 1929 } 1930 1931 static int 1932 STALE_STATEID(stateid_t *stateid) 1933 { 1934 if (stateid->si_boot == boot_time) 1935 return 0; 1936 dprintk("NFSD: stale stateid (%08x/%08x/%08x/%08x)!\n", 1937 stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid, 1938 stateid->si_generation); 1939 return 1; 1940 } 1941 1942 static inline int 1943 access_permit_read(unsigned long access_bmap) 1944 { 1945 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) || 1946 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) || 1947 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap); 1948 } 1949 1950 static inline int 1951 access_permit_write(unsigned long access_bmap) 1952 { 1953 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) || 1954 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap); 1955 } 1956 1957 static 1958 __be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags) 1959 { 1960 __be32 status = nfserr_openmode; 1961 1962 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap))) 1963 goto out; 1964 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap))) 1965 goto out; 1966 status = nfs_ok; 1967 out: 1968 return status; 1969 } 1970 1971 static inline __be32 1972 check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags) 1973 { 1974 /* Trying to call delegreturn with a special stateid? Yuch: */ 1975 if (!(flags & (RD_STATE | WR_STATE))) 1976 return nfserr_bad_stateid; 1977 else if (ONE_STATEID(stateid) && (flags & RD_STATE)) 1978 return nfs_ok; 1979 else if (locks_in_grace()) { 1980 /* Answer in remaining cases depends on existance of 1981 * conflicting state; so we must wait out the grace period. */ 1982 return nfserr_grace; 1983 } else if (flags & WR_STATE) 1984 return nfs4_share_conflict(current_fh, 1985 NFS4_SHARE_DENY_WRITE); 1986 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */ 1987 return nfs4_share_conflict(current_fh, 1988 NFS4_SHARE_DENY_READ); 1989 } 1990 1991 /* 1992 * Allow READ/WRITE during grace period on recovered state only for files 1993 * that are not able to provide mandatory locking. 1994 */ 1995 static inline int 1996 io_during_grace_disallowed(struct inode *inode, int flags) 1997 { 1998 return locks_in_grace() && (flags & (RD_STATE | WR_STATE)) 1999 && mandatory_lock(inode); 2000 } 2001 2002 static int check_stateid_generation(stateid_t *in, stateid_t *ref) 2003 { 2004 /* If the client sends us a stateid from the future, it's buggy: */ 2005 if (in->si_generation > ref->si_generation) 2006 return nfserr_bad_stateid; 2007 /* 2008 * The following, however, can happen. For example, if the 2009 * client sends an open and some IO at the same time, the open 2010 * may bump si_generation while the IO is still in flight. 2011 * Thanks to hard links and renames, the client never knows what 2012 * file an open will affect. So it could avoid that situation 2013 * only by serializing all opens and IO from the same open 2014 * owner. To recover from the old_stateid error, the client 2015 * will just have to retry the IO: 2016 */ 2017 if (in->si_generation < ref->si_generation) 2018 return nfserr_old_stateid; 2019 return nfs_ok; 2020 } 2021 2022 /* 2023 * Checks for stateid operations 2024 */ 2025 __be32 2026 nfs4_preprocess_stateid_op(struct svc_fh *current_fh, stateid_t *stateid, int flags, struct file **filpp) 2027 { 2028 struct nfs4_stateid *stp = NULL; 2029 struct nfs4_delegation *dp = NULL; 2030 stateid_t *stidp; 2031 struct inode *ino = current_fh->fh_dentry->d_inode; 2032 __be32 status; 2033 2034 dprintk("NFSD: preprocess_stateid_op: stateid = (%08x/%08x/%08x/%08x)\n", 2035 stateid->si_boot, stateid->si_stateownerid, 2036 stateid->si_fileid, stateid->si_generation); 2037 if (filpp) 2038 *filpp = NULL; 2039 2040 if (io_during_grace_disallowed(ino, flags)) 2041 return nfserr_grace; 2042 2043 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) 2044 return check_special_stateids(current_fh, stateid, flags); 2045 2046 /* STALE STATEID */ 2047 status = nfserr_stale_stateid; 2048 if (STALE_STATEID(stateid)) 2049 goto out; 2050 2051 /* BAD STATEID */ 2052 status = nfserr_bad_stateid; 2053 if (!stateid->si_fileid) { /* delegation stateid */ 2054 if(!(dp = find_delegation_stateid(ino, stateid))) { 2055 dprintk("NFSD: delegation stateid not found\n"); 2056 goto out; 2057 } 2058 stidp = &dp->dl_stateid; 2059 } else { /* open or lock stateid */ 2060 if (!(stp = find_stateid(stateid, flags))) { 2061 dprintk("NFSD: open or lock stateid not found\n"); 2062 goto out; 2063 } 2064 if ((flags & CHECK_FH) && nfs4_check_fh(current_fh, stp)) 2065 goto out; 2066 if (!stp->st_stateowner->so_confirmed) 2067 goto out; 2068 stidp = &stp->st_stateid; 2069 } 2070 status = check_stateid_generation(stateid, stidp); 2071 if (status) 2072 goto out; 2073 if (stp) { 2074 if ((status = nfs4_check_openmode(stp,flags))) 2075 goto out; 2076 renew_client(stp->st_stateowner->so_client); 2077 if (filpp) 2078 *filpp = stp->st_vfs_file; 2079 } else { 2080 if ((status = nfs4_check_delegmode(dp, flags))) 2081 goto out; 2082 renew_client(dp->dl_client); 2083 if (flags & DELEG_RET) 2084 unhash_delegation(dp); 2085 if (filpp) 2086 *filpp = dp->dl_vfs_file; 2087 } 2088 status = nfs_ok; 2089 out: 2090 return status; 2091 } 2092 2093 static inline int 2094 setlkflg (int type) 2095 { 2096 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ? 2097 RD_STATE : WR_STATE; 2098 } 2099 2100 /* 2101 * Checks for sequence id mutating operations. 2102 */ 2103 static __be32 2104 nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *stateid, int flags, struct nfs4_stateowner **sopp, struct nfs4_stateid **stpp, struct nfsd4_lock *lock) 2105 { 2106 struct nfs4_stateid *stp; 2107 struct nfs4_stateowner *sop; 2108 __be32 status; 2109 2110 dprintk("NFSD: preprocess_seqid_op: seqid=%d " 2111 "stateid = (%08x/%08x/%08x/%08x)\n", seqid, 2112 stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid, 2113 stateid->si_generation); 2114 2115 *stpp = NULL; 2116 *sopp = NULL; 2117 2118 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) { 2119 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n"); 2120 return nfserr_bad_stateid; 2121 } 2122 2123 if (STALE_STATEID(stateid)) 2124 return nfserr_stale_stateid; 2125 /* 2126 * We return BAD_STATEID if filehandle doesn't match stateid, 2127 * the confirmed flag is incorrecly set, or the generation 2128 * number is incorrect. 2129 */ 2130 stp = find_stateid(stateid, flags); 2131 if (stp == NULL) { 2132 /* 2133 * Also, we should make sure this isn't just the result of 2134 * a replayed close: 2135 */ 2136 sop = search_close_lru(stateid->si_stateownerid, flags); 2137 if (sop == NULL) 2138 return nfserr_bad_stateid; 2139 *sopp = sop; 2140 goto check_replay; 2141 } 2142 2143 *stpp = stp; 2144 *sopp = sop = stp->st_stateowner; 2145 2146 if (lock) { 2147 clientid_t *lockclid = &lock->v.new.clientid; 2148 struct nfs4_client *clp = sop->so_client; 2149 int lkflg = 0; 2150 __be32 status; 2151 2152 lkflg = setlkflg(lock->lk_type); 2153 2154 if (lock->lk_is_new) { 2155 if (!sop->so_is_open_owner) 2156 return nfserr_bad_stateid; 2157 if (!same_clid(&clp->cl_clientid, lockclid)) 2158 return nfserr_bad_stateid; 2159 /* stp is the open stateid */ 2160 status = nfs4_check_openmode(stp, lkflg); 2161 if (status) 2162 return status; 2163 } else { 2164 /* stp is the lock stateid */ 2165 status = nfs4_check_openmode(stp->st_openstp, lkflg); 2166 if (status) 2167 return status; 2168 } 2169 } 2170 2171 if (nfs4_check_fh(current_fh, stp)) { 2172 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n"); 2173 return nfserr_bad_stateid; 2174 } 2175 2176 /* 2177 * We now validate the seqid and stateid generation numbers. 2178 * For the moment, we ignore the possibility of 2179 * generation number wraparound. 2180 */ 2181 if (seqid != sop->so_seqid) 2182 goto check_replay; 2183 2184 if (sop->so_confirmed && flags & CONFIRM) { 2185 dprintk("NFSD: preprocess_seqid_op: expected" 2186 " unconfirmed stateowner!\n"); 2187 return nfserr_bad_stateid; 2188 } 2189 if (!sop->so_confirmed && !(flags & CONFIRM)) { 2190 dprintk("NFSD: preprocess_seqid_op: stateowner not" 2191 " confirmed yet!\n"); 2192 return nfserr_bad_stateid; 2193 } 2194 status = check_stateid_generation(stateid, &stp->st_stateid); 2195 if (status) 2196 return status; 2197 renew_client(sop->so_client); 2198 return nfs_ok; 2199 2200 check_replay: 2201 if (seqid == sop->so_seqid - 1) { 2202 dprintk("NFSD: preprocess_seqid_op: retransmission?\n"); 2203 /* indicate replay to calling function */ 2204 return nfserr_replay_me; 2205 } 2206 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n", 2207 sop->so_seqid, seqid); 2208 *sopp = NULL; 2209 return nfserr_bad_seqid; 2210 } 2211 2212 __be32 2213 nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2214 struct nfsd4_open_confirm *oc) 2215 { 2216 __be32 status; 2217 struct nfs4_stateowner *sop; 2218 struct nfs4_stateid *stp; 2219 2220 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n", 2221 (int)cstate->current_fh.fh_dentry->d_name.len, 2222 cstate->current_fh.fh_dentry->d_name.name); 2223 2224 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0); 2225 if (status) 2226 return status; 2227 2228 nfs4_lock_state(); 2229 2230 if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh, 2231 oc->oc_seqid, &oc->oc_req_stateid, 2232 CONFIRM | OPEN_STATE, 2233 &oc->oc_stateowner, &stp, NULL))) 2234 goto out; 2235 2236 sop = oc->oc_stateowner; 2237 sop->so_confirmed = 1; 2238 update_stateid(&stp->st_stateid); 2239 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t)); 2240 dprintk("NFSD: nfsd4_open_confirm: success, seqid=%d " 2241 "stateid=(%08x/%08x/%08x/%08x)\n", oc->oc_seqid, 2242 stp->st_stateid.si_boot, 2243 stp->st_stateid.si_stateownerid, 2244 stp->st_stateid.si_fileid, 2245 stp->st_stateid.si_generation); 2246 2247 nfsd4_create_clid_dir(sop->so_client); 2248 out: 2249 if (oc->oc_stateowner) { 2250 nfs4_get_stateowner(oc->oc_stateowner); 2251 cstate->replay_owner = oc->oc_stateowner; 2252 } 2253 nfs4_unlock_state(); 2254 return status; 2255 } 2256 2257 2258 /* 2259 * unset all bits in union bitmap (bmap) that 2260 * do not exist in share (from successful OPEN_DOWNGRADE) 2261 */ 2262 static void 2263 reset_union_bmap_access(unsigned long access, unsigned long *bmap) 2264 { 2265 int i; 2266 for (i = 1; i < 4; i++) { 2267 if ((i & access) != i) 2268 __clear_bit(i, bmap); 2269 } 2270 } 2271 2272 static void 2273 reset_union_bmap_deny(unsigned long deny, unsigned long *bmap) 2274 { 2275 int i; 2276 for (i = 0; i < 4; i++) { 2277 if ((i & deny) != i) 2278 __clear_bit(i, bmap); 2279 } 2280 } 2281 2282 __be32 2283 nfsd4_open_downgrade(struct svc_rqst *rqstp, 2284 struct nfsd4_compound_state *cstate, 2285 struct nfsd4_open_downgrade *od) 2286 { 2287 __be32 status; 2288 struct nfs4_stateid *stp; 2289 unsigned int share_access; 2290 2291 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n", 2292 (int)cstate->current_fh.fh_dentry->d_name.len, 2293 cstate->current_fh.fh_dentry->d_name.name); 2294 2295 if (!access_valid(od->od_share_access) 2296 || !deny_valid(od->od_share_deny)) 2297 return nfserr_inval; 2298 2299 nfs4_lock_state(); 2300 if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh, 2301 od->od_seqid, 2302 &od->od_stateid, 2303 OPEN_STATE, 2304 &od->od_stateowner, &stp, NULL))) 2305 goto out; 2306 2307 status = nfserr_inval; 2308 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) { 2309 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n", 2310 stp->st_access_bmap, od->od_share_access); 2311 goto out; 2312 } 2313 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) { 2314 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n", 2315 stp->st_deny_bmap, od->od_share_deny); 2316 goto out; 2317 } 2318 set_access(&share_access, stp->st_access_bmap); 2319 nfs4_file_downgrade(stp->st_vfs_file, 2320 share_access & ~od->od_share_access); 2321 2322 reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap); 2323 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap); 2324 2325 update_stateid(&stp->st_stateid); 2326 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t)); 2327 status = nfs_ok; 2328 out: 2329 if (od->od_stateowner) { 2330 nfs4_get_stateowner(od->od_stateowner); 2331 cstate->replay_owner = od->od_stateowner; 2332 } 2333 nfs4_unlock_state(); 2334 return status; 2335 } 2336 2337 /* 2338 * nfs4_unlock_state() called after encode 2339 */ 2340 __be32 2341 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2342 struct nfsd4_close *close) 2343 { 2344 __be32 status; 2345 struct nfs4_stateid *stp; 2346 2347 dprintk("NFSD: nfsd4_close on file %.*s\n", 2348 (int)cstate->current_fh.fh_dentry->d_name.len, 2349 cstate->current_fh.fh_dentry->d_name.name); 2350 2351 nfs4_lock_state(); 2352 /* check close_lru for replay */ 2353 if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh, 2354 close->cl_seqid, 2355 &close->cl_stateid, 2356 OPEN_STATE | CLOSE_STATE, 2357 &close->cl_stateowner, &stp, NULL))) 2358 goto out; 2359 status = nfs_ok; 2360 update_stateid(&stp->st_stateid); 2361 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t)); 2362 2363 /* release_stateid() calls nfsd_close() if needed */ 2364 release_stateid(stp, OPEN_STATE); 2365 2366 /* place unused nfs4_stateowners on so_close_lru list to be 2367 * released by the laundromat service after the lease period 2368 * to enable us to handle CLOSE replay 2369 */ 2370 if (list_empty(&close->cl_stateowner->so_stateids)) 2371 move_to_close_lru(close->cl_stateowner); 2372 out: 2373 if (close->cl_stateowner) { 2374 nfs4_get_stateowner(close->cl_stateowner); 2375 cstate->replay_owner = close->cl_stateowner; 2376 } 2377 nfs4_unlock_state(); 2378 return status; 2379 } 2380 2381 __be32 2382 nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2383 struct nfsd4_delegreturn *dr) 2384 { 2385 __be32 status; 2386 2387 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) 2388 goto out; 2389 2390 nfs4_lock_state(); 2391 status = nfs4_preprocess_stateid_op(&cstate->current_fh, 2392 &dr->dr_stateid, DELEG_RET, NULL); 2393 nfs4_unlock_state(); 2394 out: 2395 return status; 2396 } 2397 2398 2399 /* 2400 * Lock owner state (byte-range locks) 2401 */ 2402 #define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start)) 2403 #define LOCK_HASH_BITS 8 2404 #define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS) 2405 #define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1) 2406 2407 #define lockownerid_hashval(id) \ 2408 ((id) & LOCK_HASH_MASK) 2409 2410 static inline unsigned int 2411 lock_ownerstr_hashval(struct inode *inode, u32 cl_id, 2412 struct xdr_netobj *ownername) 2413 { 2414 return (file_hashval(inode) + cl_id 2415 + opaque_hashval(ownername->data, ownername->len)) 2416 & LOCK_HASH_MASK; 2417 } 2418 2419 static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE]; 2420 static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE]; 2421 static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE]; 2422 2423 static struct nfs4_stateid * 2424 find_stateid(stateid_t *stid, int flags) 2425 { 2426 struct nfs4_stateid *local = NULL; 2427 u32 st_id = stid->si_stateownerid; 2428 u32 f_id = stid->si_fileid; 2429 unsigned int hashval; 2430 2431 dprintk("NFSD: find_stateid flags 0x%x\n",flags); 2432 if ((flags & LOCK_STATE) || (flags & RD_STATE) || (flags & WR_STATE)) { 2433 hashval = stateid_hashval(st_id, f_id); 2434 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) { 2435 if ((local->st_stateid.si_stateownerid == st_id) && 2436 (local->st_stateid.si_fileid == f_id)) 2437 return local; 2438 } 2439 } 2440 if ((flags & OPEN_STATE) || (flags & RD_STATE) || (flags & WR_STATE)) { 2441 hashval = stateid_hashval(st_id, f_id); 2442 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) { 2443 if ((local->st_stateid.si_stateownerid == st_id) && 2444 (local->st_stateid.si_fileid == f_id)) 2445 return local; 2446 } 2447 } 2448 return NULL; 2449 } 2450 2451 static struct nfs4_delegation * 2452 find_delegation_stateid(struct inode *ino, stateid_t *stid) 2453 { 2454 struct nfs4_file *fp; 2455 struct nfs4_delegation *dl; 2456 2457 dprintk("NFSD:find_delegation_stateid stateid=(%08x/%08x/%08x/%08x)\n", 2458 stid->si_boot, stid->si_stateownerid, 2459 stid->si_fileid, stid->si_generation); 2460 2461 fp = find_file(ino); 2462 if (!fp) 2463 return NULL; 2464 dl = find_delegation_file(fp, stid); 2465 put_nfs4_file(fp); 2466 return dl; 2467 } 2468 2469 /* 2470 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that 2471 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th 2472 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit 2473 * locking, this prevents us from being completely protocol-compliant. The 2474 * real solution to this problem is to start using unsigned file offsets in 2475 * the VFS, but this is a very deep change! 2476 */ 2477 static inline void 2478 nfs4_transform_lock_offset(struct file_lock *lock) 2479 { 2480 if (lock->fl_start < 0) 2481 lock->fl_start = OFFSET_MAX; 2482 if (lock->fl_end < 0) 2483 lock->fl_end = OFFSET_MAX; 2484 } 2485 2486 /* Hack!: For now, we're defining this just so we can use a pointer to it 2487 * as a unique cookie to identify our (NFSv4's) posix locks. */ 2488 static struct lock_manager_operations nfsd_posix_mng_ops = { 2489 }; 2490 2491 static inline void 2492 nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny) 2493 { 2494 struct nfs4_stateowner *sop; 2495 unsigned int hval; 2496 2497 if (fl->fl_lmops == &nfsd_posix_mng_ops) { 2498 sop = (struct nfs4_stateowner *) fl->fl_owner; 2499 hval = lockownerid_hashval(sop->so_id); 2500 kref_get(&sop->so_ref); 2501 deny->ld_sop = sop; 2502 deny->ld_clientid = sop->so_client->cl_clientid; 2503 } else { 2504 deny->ld_sop = NULL; 2505 deny->ld_clientid.cl_boot = 0; 2506 deny->ld_clientid.cl_id = 0; 2507 } 2508 deny->ld_start = fl->fl_start; 2509 deny->ld_length = ~(u64)0; 2510 if (fl->fl_end != ~(u64)0) 2511 deny->ld_length = fl->fl_end - fl->fl_start + 1; 2512 deny->ld_type = NFS4_READ_LT; 2513 if (fl->fl_type != F_RDLCK) 2514 deny->ld_type = NFS4_WRITE_LT; 2515 } 2516 2517 static struct nfs4_stateowner * 2518 find_lockstateowner_str(struct inode *inode, clientid_t *clid, 2519 struct xdr_netobj *owner) 2520 { 2521 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner); 2522 struct nfs4_stateowner *op; 2523 2524 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) { 2525 if (same_owner_str(op, owner, clid)) 2526 return op; 2527 } 2528 return NULL; 2529 } 2530 2531 /* 2532 * Alloc a lock owner structure. 2533 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 2534 * occured. 2535 * 2536 * strhashval = lock_ownerstr_hashval 2537 */ 2538 2539 static struct nfs4_stateowner * 2540 alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) { 2541 struct nfs4_stateowner *sop; 2542 struct nfs4_replay *rp; 2543 unsigned int idhashval; 2544 2545 if (!(sop = alloc_stateowner(&lock->lk_new_owner))) 2546 return NULL; 2547 idhashval = lockownerid_hashval(current_ownerid); 2548 INIT_LIST_HEAD(&sop->so_idhash); 2549 INIT_LIST_HEAD(&sop->so_strhash); 2550 INIT_LIST_HEAD(&sop->so_perclient); 2551 INIT_LIST_HEAD(&sop->so_stateids); 2552 INIT_LIST_HEAD(&sop->so_perstateid); 2553 INIT_LIST_HEAD(&sop->so_close_lru); /* not used */ 2554 sop->so_time = 0; 2555 list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]); 2556 list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]); 2557 list_add(&sop->so_perstateid, &open_stp->st_lockowners); 2558 sop->so_is_open_owner = 0; 2559 sop->so_id = current_ownerid++; 2560 sop->so_client = clp; 2561 /* It is the openowner seqid that will be incremented in encode in the 2562 * case of new lockowners; so increment the lock seqid manually: */ 2563 sop->so_seqid = lock->lk_new_lock_seqid + 1; 2564 sop->so_confirmed = 1; 2565 rp = &sop->so_replay; 2566 rp->rp_status = nfserr_serverfault; 2567 rp->rp_buflen = 0; 2568 rp->rp_buf = rp->rp_ibuf; 2569 return sop; 2570 } 2571 2572 static struct nfs4_stateid * 2573 alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp) 2574 { 2575 struct nfs4_stateid *stp; 2576 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id); 2577 2578 stp = nfs4_alloc_stateid(); 2579 if (stp == NULL) 2580 goto out; 2581 INIT_LIST_HEAD(&stp->st_hash); 2582 INIT_LIST_HEAD(&stp->st_perfile); 2583 INIT_LIST_HEAD(&stp->st_perstateowner); 2584 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */ 2585 list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]); 2586 list_add(&stp->st_perfile, &fp->fi_stateids); 2587 list_add(&stp->st_perstateowner, &sop->so_stateids); 2588 stp->st_stateowner = sop; 2589 get_nfs4_file(fp); 2590 stp->st_file = fp; 2591 stp->st_stateid.si_boot = boot_time; 2592 stp->st_stateid.si_stateownerid = sop->so_id; 2593 stp->st_stateid.si_fileid = fp->fi_id; 2594 stp->st_stateid.si_generation = 0; 2595 stp->st_vfs_file = open_stp->st_vfs_file; /* FIXME refcount?? */ 2596 stp->st_access_bmap = open_stp->st_access_bmap; 2597 stp->st_deny_bmap = open_stp->st_deny_bmap; 2598 stp->st_openstp = open_stp; 2599 2600 out: 2601 return stp; 2602 } 2603 2604 static int 2605 check_lock_length(u64 offset, u64 length) 2606 { 2607 return ((length == 0) || ((length != ~(u64)0) && 2608 LOFF_OVERFLOW(offset, length))); 2609 } 2610 2611 /* 2612 * LOCK operation 2613 */ 2614 __be32 2615 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2616 struct nfsd4_lock *lock) 2617 { 2618 struct nfs4_stateowner *open_sop = NULL; 2619 struct nfs4_stateowner *lock_sop = NULL; 2620 struct nfs4_stateid *lock_stp; 2621 struct file *filp; 2622 struct file_lock file_lock; 2623 struct file_lock conflock; 2624 __be32 status = 0; 2625 unsigned int strhashval; 2626 unsigned int cmd; 2627 int err; 2628 2629 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n", 2630 (long long) lock->lk_offset, 2631 (long long) lock->lk_length); 2632 2633 if (check_lock_length(lock->lk_offset, lock->lk_length)) 2634 return nfserr_inval; 2635 2636 if ((status = fh_verify(rqstp, &cstate->current_fh, 2637 S_IFREG, NFSD_MAY_LOCK))) { 2638 dprintk("NFSD: nfsd4_lock: permission denied!\n"); 2639 return status; 2640 } 2641 2642 nfs4_lock_state(); 2643 2644 if (lock->lk_is_new) { 2645 /* 2646 * Client indicates that this is a new lockowner. 2647 * Use open owner and open stateid to create lock owner and 2648 * lock stateid. 2649 */ 2650 struct nfs4_stateid *open_stp = NULL; 2651 struct nfs4_file *fp; 2652 2653 status = nfserr_stale_clientid; 2654 if (STALE_CLIENTID(&lock->lk_new_clientid)) 2655 goto out; 2656 2657 /* validate and update open stateid and open seqid */ 2658 status = nfs4_preprocess_seqid_op(&cstate->current_fh, 2659 lock->lk_new_open_seqid, 2660 &lock->lk_new_open_stateid, 2661 OPEN_STATE, 2662 &lock->lk_replay_owner, &open_stp, 2663 lock); 2664 if (status) 2665 goto out; 2666 open_sop = lock->lk_replay_owner; 2667 /* create lockowner and lock stateid */ 2668 fp = open_stp->st_file; 2669 strhashval = lock_ownerstr_hashval(fp->fi_inode, 2670 open_sop->so_client->cl_clientid.cl_id, 2671 &lock->v.new.owner); 2672 /* XXX: Do we need to check for duplicate stateowners on 2673 * the same file, or should they just be allowed (and 2674 * create new stateids)? */ 2675 status = nfserr_resource; 2676 lock_sop = alloc_init_lock_stateowner(strhashval, 2677 open_sop->so_client, open_stp, lock); 2678 if (lock_sop == NULL) 2679 goto out; 2680 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp); 2681 if (lock_stp == NULL) 2682 goto out; 2683 } else { 2684 /* lock (lock owner + lock stateid) already exists */ 2685 status = nfs4_preprocess_seqid_op(&cstate->current_fh, 2686 lock->lk_old_lock_seqid, 2687 &lock->lk_old_lock_stateid, 2688 LOCK_STATE, 2689 &lock->lk_replay_owner, &lock_stp, lock); 2690 if (status) 2691 goto out; 2692 lock_sop = lock->lk_replay_owner; 2693 } 2694 /* lock->lk_replay_owner and lock_stp have been created or found */ 2695 filp = lock_stp->st_vfs_file; 2696 2697 status = nfserr_grace; 2698 if (locks_in_grace() && !lock->lk_reclaim) 2699 goto out; 2700 status = nfserr_no_grace; 2701 if (!locks_in_grace() && lock->lk_reclaim) 2702 goto out; 2703 2704 locks_init_lock(&file_lock); 2705 switch (lock->lk_type) { 2706 case NFS4_READ_LT: 2707 case NFS4_READW_LT: 2708 file_lock.fl_type = F_RDLCK; 2709 cmd = F_SETLK; 2710 break; 2711 case NFS4_WRITE_LT: 2712 case NFS4_WRITEW_LT: 2713 file_lock.fl_type = F_WRLCK; 2714 cmd = F_SETLK; 2715 break; 2716 default: 2717 status = nfserr_inval; 2718 goto out; 2719 } 2720 file_lock.fl_owner = (fl_owner_t)lock_sop; 2721 file_lock.fl_pid = current->tgid; 2722 file_lock.fl_file = filp; 2723 file_lock.fl_flags = FL_POSIX; 2724 file_lock.fl_lmops = &nfsd_posix_mng_ops; 2725 2726 file_lock.fl_start = lock->lk_offset; 2727 if ((lock->lk_length == ~(u64)0) || 2728 LOFF_OVERFLOW(lock->lk_offset, lock->lk_length)) 2729 file_lock.fl_end = ~(u64)0; 2730 else 2731 file_lock.fl_end = lock->lk_offset + lock->lk_length - 1; 2732 nfs4_transform_lock_offset(&file_lock); 2733 2734 /* 2735 * Try to lock the file in the VFS. 2736 * Note: locks.c uses the BKL to protect the inode's lock list. 2737 */ 2738 2739 err = vfs_lock_file(filp, cmd, &file_lock, &conflock); 2740 switch (-err) { 2741 case 0: /* success! */ 2742 update_stateid(&lock_stp->st_stateid); 2743 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid, 2744 sizeof(stateid_t)); 2745 status = 0; 2746 break; 2747 case (EAGAIN): /* conflock holds conflicting lock */ 2748 status = nfserr_denied; 2749 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n"); 2750 nfs4_set_lock_denied(&conflock, &lock->lk_denied); 2751 break; 2752 case (EDEADLK): 2753 status = nfserr_deadlock; 2754 break; 2755 default: 2756 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err); 2757 status = nfserr_resource; 2758 break; 2759 } 2760 out: 2761 if (status && lock->lk_is_new && lock_sop) 2762 release_stateowner(lock_sop); 2763 if (lock->lk_replay_owner) { 2764 nfs4_get_stateowner(lock->lk_replay_owner); 2765 cstate->replay_owner = lock->lk_replay_owner; 2766 } 2767 nfs4_unlock_state(); 2768 return status; 2769 } 2770 2771 /* 2772 * LOCKT operation 2773 */ 2774 __be32 2775 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2776 struct nfsd4_lockt *lockt) 2777 { 2778 struct inode *inode; 2779 struct file file; 2780 struct file_lock file_lock; 2781 int error; 2782 __be32 status; 2783 2784 if (locks_in_grace()) 2785 return nfserr_grace; 2786 2787 if (check_lock_length(lockt->lt_offset, lockt->lt_length)) 2788 return nfserr_inval; 2789 2790 lockt->lt_stateowner = NULL; 2791 nfs4_lock_state(); 2792 2793 status = nfserr_stale_clientid; 2794 if (STALE_CLIENTID(&lockt->lt_clientid)) 2795 goto out; 2796 2797 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) { 2798 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n"); 2799 if (status == nfserr_symlink) 2800 status = nfserr_inval; 2801 goto out; 2802 } 2803 2804 inode = cstate->current_fh.fh_dentry->d_inode; 2805 locks_init_lock(&file_lock); 2806 switch (lockt->lt_type) { 2807 case NFS4_READ_LT: 2808 case NFS4_READW_LT: 2809 file_lock.fl_type = F_RDLCK; 2810 break; 2811 case NFS4_WRITE_LT: 2812 case NFS4_WRITEW_LT: 2813 file_lock.fl_type = F_WRLCK; 2814 break; 2815 default: 2816 dprintk("NFSD: nfs4_lockt: bad lock type!\n"); 2817 status = nfserr_inval; 2818 goto out; 2819 } 2820 2821 lockt->lt_stateowner = find_lockstateowner_str(inode, 2822 &lockt->lt_clientid, &lockt->lt_owner); 2823 if (lockt->lt_stateowner) 2824 file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner; 2825 file_lock.fl_pid = current->tgid; 2826 file_lock.fl_flags = FL_POSIX; 2827 file_lock.fl_lmops = &nfsd_posix_mng_ops; 2828 2829 file_lock.fl_start = lockt->lt_offset; 2830 if ((lockt->lt_length == ~(u64)0) || LOFF_OVERFLOW(lockt->lt_offset, lockt->lt_length)) 2831 file_lock.fl_end = ~(u64)0; 2832 else 2833 file_lock.fl_end = lockt->lt_offset + lockt->lt_length - 1; 2834 2835 nfs4_transform_lock_offset(&file_lock); 2836 2837 /* vfs_test_lock uses the struct file _only_ to resolve the inode. 2838 * since LOCKT doesn't require an OPEN, and therefore a struct 2839 * file may not exist, pass vfs_test_lock a struct file with 2840 * only the dentry:inode set. 2841 */ 2842 memset(&file, 0, sizeof (struct file)); 2843 file.f_path.dentry = cstate->current_fh.fh_dentry; 2844 2845 status = nfs_ok; 2846 error = vfs_test_lock(&file, &file_lock); 2847 if (error) { 2848 status = nfserrno(error); 2849 goto out; 2850 } 2851 if (file_lock.fl_type != F_UNLCK) { 2852 status = nfserr_denied; 2853 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied); 2854 } 2855 out: 2856 nfs4_unlock_state(); 2857 return status; 2858 } 2859 2860 __be32 2861 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 2862 struct nfsd4_locku *locku) 2863 { 2864 struct nfs4_stateid *stp; 2865 struct file *filp = NULL; 2866 struct file_lock file_lock; 2867 __be32 status; 2868 int err; 2869 2870 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n", 2871 (long long) locku->lu_offset, 2872 (long long) locku->lu_length); 2873 2874 if (check_lock_length(locku->lu_offset, locku->lu_length)) 2875 return nfserr_inval; 2876 2877 nfs4_lock_state(); 2878 2879 if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh, 2880 locku->lu_seqid, 2881 &locku->lu_stateid, 2882 LOCK_STATE, 2883 &locku->lu_stateowner, &stp, NULL))) 2884 goto out; 2885 2886 filp = stp->st_vfs_file; 2887 BUG_ON(!filp); 2888 locks_init_lock(&file_lock); 2889 file_lock.fl_type = F_UNLCK; 2890 file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner; 2891 file_lock.fl_pid = current->tgid; 2892 file_lock.fl_file = filp; 2893 file_lock.fl_flags = FL_POSIX; 2894 file_lock.fl_lmops = &nfsd_posix_mng_ops; 2895 file_lock.fl_start = locku->lu_offset; 2896 2897 if ((locku->lu_length == ~(u64)0) || LOFF_OVERFLOW(locku->lu_offset, locku->lu_length)) 2898 file_lock.fl_end = ~(u64)0; 2899 else 2900 file_lock.fl_end = locku->lu_offset + locku->lu_length - 1; 2901 nfs4_transform_lock_offset(&file_lock); 2902 2903 /* 2904 * Try to unlock the file in the VFS. 2905 */ 2906 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL); 2907 if (err) { 2908 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n"); 2909 goto out_nfserr; 2910 } 2911 /* 2912 * OK, unlock succeeded; the only thing left to do is update the stateid. 2913 */ 2914 update_stateid(&stp->st_stateid); 2915 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t)); 2916 2917 out: 2918 if (locku->lu_stateowner) { 2919 nfs4_get_stateowner(locku->lu_stateowner); 2920 cstate->replay_owner = locku->lu_stateowner; 2921 } 2922 nfs4_unlock_state(); 2923 return status; 2924 2925 out_nfserr: 2926 status = nfserrno(err); 2927 goto out; 2928 } 2929 2930 /* 2931 * returns 2932 * 1: locks held by lockowner 2933 * 0: no locks held by lockowner 2934 */ 2935 static int 2936 check_for_locks(struct file *filp, struct nfs4_stateowner *lowner) 2937 { 2938 struct file_lock **flpp; 2939 struct inode *inode = filp->f_path.dentry->d_inode; 2940 int status = 0; 2941 2942 lock_kernel(); 2943 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) { 2944 if ((*flpp)->fl_owner == (fl_owner_t)lowner) { 2945 status = 1; 2946 goto out; 2947 } 2948 } 2949 out: 2950 unlock_kernel(); 2951 return status; 2952 } 2953 2954 __be32 2955 nfsd4_release_lockowner(struct svc_rqst *rqstp, 2956 struct nfsd4_compound_state *cstate, 2957 struct nfsd4_release_lockowner *rlockowner) 2958 { 2959 clientid_t *clid = &rlockowner->rl_clientid; 2960 struct nfs4_stateowner *sop; 2961 struct nfs4_stateid *stp; 2962 struct xdr_netobj *owner = &rlockowner->rl_owner; 2963 struct list_head matches; 2964 int i; 2965 __be32 status; 2966 2967 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n", 2968 clid->cl_boot, clid->cl_id); 2969 2970 /* XXX check for lease expiration */ 2971 2972 status = nfserr_stale_clientid; 2973 if (STALE_CLIENTID(clid)) 2974 return status; 2975 2976 nfs4_lock_state(); 2977 2978 status = nfserr_locks_held; 2979 /* XXX: we're doing a linear search through all the lockowners. 2980 * Yipes! For now we'll just hope clients aren't really using 2981 * release_lockowner much, but eventually we have to fix these 2982 * data structures. */ 2983 INIT_LIST_HEAD(&matches); 2984 for (i = 0; i < LOCK_HASH_SIZE; i++) { 2985 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) { 2986 if (!same_owner_str(sop, owner, clid)) 2987 continue; 2988 list_for_each_entry(stp, &sop->so_stateids, 2989 st_perstateowner) { 2990 if (check_for_locks(stp->st_vfs_file, sop)) 2991 goto out; 2992 /* Note: so_perclient unused for lockowners, 2993 * so it's OK to fool with here. */ 2994 list_add(&sop->so_perclient, &matches); 2995 } 2996 } 2997 } 2998 /* Clients probably won't expect us to return with some (but not all) 2999 * of the lockowner state released; so don't release any until all 3000 * have been checked. */ 3001 status = nfs_ok; 3002 while (!list_empty(&matches)) { 3003 sop = list_entry(matches.next, struct nfs4_stateowner, 3004 so_perclient); 3005 /* unhash_stateowner deletes so_perclient only 3006 * for openowners. */ 3007 list_del(&sop->so_perclient); 3008 release_stateowner(sop); 3009 } 3010 out: 3011 nfs4_unlock_state(); 3012 return status; 3013 } 3014 3015 static inline struct nfs4_client_reclaim * 3016 alloc_reclaim(void) 3017 { 3018 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL); 3019 } 3020 3021 int 3022 nfs4_has_reclaimed_state(const char *name) 3023 { 3024 unsigned int strhashval = clientstr_hashval(name); 3025 struct nfs4_client *clp; 3026 3027 clp = find_confirmed_client_by_str(name, strhashval); 3028 return clp ? 1 : 0; 3029 } 3030 3031 /* 3032 * failure => all reset bets are off, nfserr_no_grace... 3033 */ 3034 int 3035 nfs4_client_to_reclaim(const char *name) 3036 { 3037 unsigned int strhashval; 3038 struct nfs4_client_reclaim *crp = NULL; 3039 3040 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name); 3041 crp = alloc_reclaim(); 3042 if (!crp) 3043 return 0; 3044 strhashval = clientstr_hashval(name); 3045 INIT_LIST_HEAD(&crp->cr_strhash); 3046 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]); 3047 memcpy(crp->cr_recdir, name, HEXDIR_LEN); 3048 reclaim_str_hashtbl_size++; 3049 return 1; 3050 } 3051 3052 static void 3053 nfs4_release_reclaim(void) 3054 { 3055 struct nfs4_client_reclaim *crp = NULL; 3056 int i; 3057 3058 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 3059 while (!list_empty(&reclaim_str_hashtbl[i])) { 3060 crp = list_entry(reclaim_str_hashtbl[i].next, 3061 struct nfs4_client_reclaim, cr_strhash); 3062 list_del(&crp->cr_strhash); 3063 kfree(crp); 3064 reclaim_str_hashtbl_size--; 3065 } 3066 } 3067 BUG_ON(reclaim_str_hashtbl_size); 3068 } 3069 3070 /* 3071 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */ 3072 static struct nfs4_client_reclaim * 3073 nfs4_find_reclaim_client(clientid_t *clid) 3074 { 3075 unsigned int strhashval; 3076 struct nfs4_client *clp; 3077 struct nfs4_client_reclaim *crp = NULL; 3078 3079 3080 /* find clientid in conf_id_hashtbl */ 3081 clp = find_confirmed_client(clid); 3082 if (clp == NULL) 3083 return NULL; 3084 3085 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n", 3086 clp->cl_name.len, clp->cl_name.data, 3087 clp->cl_recdir); 3088 3089 /* find clp->cl_name in reclaim_str_hashtbl */ 3090 strhashval = clientstr_hashval(clp->cl_recdir); 3091 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) { 3092 if (same_name(crp->cr_recdir, clp->cl_recdir)) { 3093 return crp; 3094 } 3095 } 3096 return NULL; 3097 } 3098 3099 /* 3100 * Called from OPEN. Look for clientid in reclaim list. 3101 */ 3102 __be32 3103 nfs4_check_open_reclaim(clientid_t *clid) 3104 { 3105 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad; 3106 } 3107 3108 /* initialization to perform at module load time: */ 3109 3110 int 3111 nfs4_state_init(void) 3112 { 3113 int i, status; 3114 3115 status = nfsd4_init_slabs(); 3116 if (status) 3117 return status; 3118 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 3119 INIT_LIST_HEAD(&conf_id_hashtbl[i]); 3120 INIT_LIST_HEAD(&conf_str_hashtbl[i]); 3121 INIT_LIST_HEAD(&unconf_str_hashtbl[i]); 3122 INIT_LIST_HEAD(&unconf_id_hashtbl[i]); 3123 } 3124 for (i = 0; i < FILE_HASH_SIZE; i++) { 3125 INIT_LIST_HEAD(&file_hashtbl[i]); 3126 } 3127 for (i = 0; i < OWNER_HASH_SIZE; i++) { 3128 INIT_LIST_HEAD(&ownerstr_hashtbl[i]); 3129 INIT_LIST_HEAD(&ownerid_hashtbl[i]); 3130 } 3131 for (i = 0; i < STATEID_HASH_SIZE; i++) { 3132 INIT_LIST_HEAD(&stateid_hashtbl[i]); 3133 INIT_LIST_HEAD(&lockstateid_hashtbl[i]); 3134 } 3135 for (i = 0; i < LOCK_HASH_SIZE; i++) { 3136 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]); 3137 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]); 3138 } 3139 memset(&onestateid, ~0, sizeof(stateid_t)); 3140 INIT_LIST_HEAD(&close_lru); 3141 INIT_LIST_HEAD(&client_lru); 3142 INIT_LIST_HEAD(&del_recall_lru); 3143 for (i = 0; i < CLIENT_HASH_SIZE; i++) 3144 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]); 3145 reclaim_str_hashtbl_size = 0; 3146 return 0; 3147 } 3148 3149 static void 3150 nfsd4_load_reboot_recovery_data(void) 3151 { 3152 int status; 3153 3154 nfs4_lock_state(); 3155 nfsd4_init_recdir(user_recovery_dirname); 3156 status = nfsd4_recdir_load(); 3157 nfs4_unlock_state(); 3158 if (status) 3159 printk("NFSD: Failure reading reboot recovery data\n"); 3160 } 3161 3162 unsigned long 3163 get_nfs4_grace_period(void) 3164 { 3165 return max(user_lease_time, lease_time) * HZ; 3166 } 3167 3168 /* 3169 * Since the lifetime of a delegation isn't limited to that of an open, a 3170 * client may quite reasonably hang on to a delegation as long as it has 3171 * the inode cached. This becomes an obvious problem the first time a 3172 * client's inode cache approaches the size of the server's total memory. 3173 * 3174 * For now we avoid this problem by imposing a hard limit on the number 3175 * of delegations, which varies according to the server's memory size. 3176 */ 3177 static void 3178 set_max_delegations(void) 3179 { 3180 /* 3181 * Allow at most 4 delegations per megabyte of RAM. Quick 3182 * estimates suggest that in the worst case (where every delegation 3183 * is for a different inode), a delegation could take about 1.5K, 3184 * giving a worst case usage of about 6% of memory. 3185 */ 3186 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT); 3187 } 3188 3189 /* initialization to perform when the nfsd service is started: */ 3190 3191 static void 3192 __nfs4_state_start(void) 3193 { 3194 unsigned long grace_time; 3195 3196 boot_time = get_seconds(); 3197 grace_time = get_nfs4_grace_period(); 3198 lease_time = user_lease_time; 3199 locks_start_grace(&nfsd4_manager); 3200 printk(KERN_INFO "NFSD: starting %ld-second grace period\n", 3201 grace_time/HZ); 3202 laundry_wq = create_singlethread_workqueue("nfsd4"); 3203 queue_delayed_work(laundry_wq, &laundromat_work, grace_time); 3204 set_max_delegations(); 3205 } 3206 3207 void 3208 nfs4_state_start(void) 3209 { 3210 if (nfs4_init) 3211 return; 3212 nfsd4_load_reboot_recovery_data(); 3213 __nfs4_state_start(); 3214 nfs4_init = 1; 3215 return; 3216 } 3217 3218 time_t 3219 nfs4_lease_time(void) 3220 { 3221 return lease_time; 3222 } 3223 3224 static void 3225 __nfs4_state_shutdown(void) 3226 { 3227 int i; 3228 struct nfs4_client *clp = NULL; 3229 struct nfs4_delegation *dp = NULL; 3230 struct list_head *pos, *next, reaplist; 3231 3232 for (i = 0; i < CLIENT_HASH_SIZE; i++) { 3233 while (!list_empty(&conf_id_hashtbl[i])) { 3234 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); 3235 expire_client(clp); 3236 } 3237 while (!list_empty(&unconf_str_hashtbl[i])) { 3238 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash); 3239 expire_client(clp); 3240 } 3241 } 3242 INIT_LIST_HEAD(&reaplist); 3243 spin_lock(&recall_lock); 3244 list_for_each_safe(pos, next, &del_recall_lru) { 3245 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 3246 list_move(&dp->dl_recall_lru, &reaplist); 3247 } 3248 spin_unlock(&recall_lock); 3249 list_for_each_safe(pos, next, &reaplist) { 3250 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru); 3251 list_del_init(&dp->dl_recall_lru); 3252 unhash_delegation(dp); 3253 } 3254 3255 nfsd4_shutdown_recdir(); 3256 nfs4_init = 0; 3257 } 3258 3259 void 3260 nfs4_state_shutdown(void) 3261 { 3262 cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work); 3263 destroy_workqueue(laundry_wq); 3264 nfs4_lock_state(); 3265 nfs4_release_reclaim(); 3266 __nfs4_state_shutdown(); 3267 nfs4_unlock_state(); 3268 } 3269 3270 /* 3271 * user_recovery_dirname is protected by the nfsd_mutex since it's only 3272 * accessed when nfsd is starting. 3273 */ 3274 static void 3275 nfs4_set_recdir(char *recdir) 3276 { 3277 strcpy(user_recovery_dirname, recdir); 3278 } 3279 3280 /* 3281 * Change the NFSv4 recovery directory to recdir. 3282 */ 3283 int 3284 nfs4_reset_recoverydir(char *recdir) 3285 { 3286 int status; 3287 struct path path; 3288 3289 status = kern_path(recdir, LOOKUP_FOLLOW, &path); 3290 if (status) 3291 return status; 3292 status = -ENOTDIR; 3293 if (S_ISDIR(path.dentry->d_inode->i_mode)) { 3294 nfs4_set_recdir(recdir); 3295 status = 0; 3296 } 3297 path_put(&path); 3298 return status; 3299 } 3300 3301 char * 3302 nfs4_recoverydir(void) 3303 { 3304 return user_recovery_dirname; 3305 } 3306 3307 /* 3308 * Called when leasetime is changed. 3309 * 3310 * The only way the protocol gives us to handle on-the-fly lease changes is to 3311 * simulate a reboot. Instead of doing that, we just wait till the next time 3312 * we start to register any changes in lease time. If the administrator 3313 * really wants to change the lease time *now*, they can go ahead and bring 3314 * nfsd down and then back up again after changing the lease time. 3315 * 3316 * user_lease_time is protected by nfsd_mutex since it's only really accessed 3317 * when nfsd is starting 3318 */ 3319 void 3320 nfs4_reset_lease(time_t leasetime) 3321 { 3322 user_lease_time = leasetime; 3323 } 3324