1 /* 2 * Copyright (c) 2014 Christoph Hellwig. 3 */ 4 #include <linux/kmod.h> 5 #include <linux/file.h> 6 #include <linux/jhash.h> 7 #include <linux/sched.h> 8 #include <linux/sunrpc/addr.h> 9 10 #include "pnfs.h" 11 #include "netns.h" 12 #include "trace.h" 13 14 #define NFSDDBG_FACILITY NFSDDBG_PNFS 15 16 struct nfs4_layout { 17 struct list_head lo_perstate; 18 struct nfs4_layout_stateid *lo_state; 19 struct nfsd4_layout_seg lo_seg; 20 }; 21 22 static struct kmem_cache *nfs4_layout_cache; 23 static struct kmem_cache *nfs4_layout_stateid_cache; 24 25 static const struct nfsd4_callback_ops nfsd4_cb_layout_ops; 26 static const struct lock_manager_operations nfsd4_layouts_lm_ops; 27 28 const struct nfsd4_layout_ops *nfsd4_layout_ops[LAYOUT_TYPE_MAX] = { 29 [LAYOUT_BLOCK_VOLUME] = &bl_layout_ops, 30 }; 31 32 /* pNFS device ID to export fsid mapping */ 33 #define DEVID_HASH_BITS 8 34 #define DEVID_HASH_SIZE (1 << DEVID_HASH_BITS) 35 #define DEVID_HASH_MASK (DEVID_HASH_SIZE - 1) 36 static u64 nfsd_devid_seq = 1; 37 static struct list_head nfsd_devid_hash[DEVID_HASH_SIZE]; 38 static DEFINE_SPINLOCK(nfsd_devid_lock); 39 40 static inline u32 devid_hashfn(u64 idx) 41 { 42 return jhash_2words(idx, idx >> 32, 0) & DEVID_HASH_MASK; 43 } 44 45 static void 46 nfsd4_alloc_devid_map(const struct svc_fh *fhp) 47 { 48 const struct knfsd_fh *fh = &fhp->fh_handle; 49 size_t fsid_len = key_len(fh->fh_fsid_type); 50 struct nfsd4_deviceid_map *map, *old; 51 int i; 52 53 map = kzalloc(sizeof(*map) + fsid_len, GFP_KERNEL); 54 if (!map) 55 return; 56 57 map->fsid_type = fh->fh_fsid_type; 58 memcpy(&map->fsid, fh->fh_fsid, fsid_len); 59 60 spin_lock(&nfsd_devid_lock); 61 if (fhp->fh_export->ex_devid_map) 62 goto out_unlock; 63 64 for (i = 0; i < DEVID_HASH_SIZE; i++) { 65 list_for_each_entry(old, &nfsd_devid_hash[i], hash) { 66 if (old->fsid_type != fh->fh_fsid_type) 67 continue; 68 if (memcmp(old->fsid, fh->fh_fsid, 69 key_len(old->fsid_type))) 70 continue; 71 72 fhp->fh_export->ex_devid_map = old; 73 goto out_unlock; 74 } 75 } 76 77 map->idx = nfsd_devid_seq++; 78 list_add_tail_rcu(&map->hash, &nfsd_devid_hash[devid_hashfn(map->idx)]); 79 fhp->fh_export->ex_devid_map = map; 80 map = NULL; 81 82 out_unlock: 83 spin_unlock(&nfsd_devid_lock); 84 kfree(map); 85 } 86 87 struct nfsd4_deviceid_map * 88 nfsd4_find_devid_map(int idx) 89 { 90 struct nfsd4_deviceid_map *map, *ret = NULL; 91 92 rcu_read_lock(); 93 list_for_each_entry_rcu(map, &nfsd_devid_hash[devid_hashfn(idx)], hash) 94 if (map->idx == idx) 95 ret = map; 96 rcu_read_unlock(); 97 98 return ret; 99 } 100 101 int 102 nfsd4_set_deviceid(struct nfsd4_deviceid *id, const struct svc_fh *fhp, 103 u32 device_generation) 104 { 105 if (!fhp->fh_export->ex_devid_map) { 106 nfsd4_alloc_devid_map(fhp); 107 if (!fhp->fh_export->ex_devid_map) 108 return -ENOMEM; 109 } 110 111 id->fsid_idx = fhp->fh_export->ex_devid_map->idx; 112 id->generation = device_generation; 113 id->pad = 0; 114 return 0; 115 } 116 117 void nfsd4_setup_layout_type(struct svc_export *exp) 118 { 119 struct super_block *sb = exp->ex_path.mnt->mnt_sb; 120 121 if (!(exp->ex_flags & NFSEXP_PNFS)) 122 return; 123 124 if (sb->s_export_op->get_uuid && 125 sb->s_export_op->map_blocks && 126 sb->s_export_op->commit_blocks) 127 exp->ex_layout_type = LAYOUT_BLOCK_VOLUME; 128 } 129 130 static void 131 nfsd4_free_layout_stateid(struct nfs4_stid *stid) 132 { 133 struct nfs4_layout_stateid *ls = layoutstateid(stid); 134 struct nfs4_client *clp = ls->ls_stid.sc_client; 135 struct nfs4_file *fp = ls->ls_stid.sc_file; 136 137 trace_layoutstate_free(&ls->ls_stid.sc_stateid); 138 139 spin_lock(&clp->cl_lock); 140 list_del_init(&ls->ls_perclnt); 141 spin_unlock(&clp->cl_lock); 142 143 spin_lock(&fp->fi_lock); 144 list_del_init(&ls->ls_perfile); 145 spin_unlock(&fp->fi_lock); 146 147 vfs_setlease(ls->ls_file, F_UNLCK, NULL, (void **)&ls); 148 fput(ls->ls_file); 149 150 if (ls->ls_recalled) 151 atomic_dec(&ls->ls_stid.sc_file->fi_lo_recalls); 152 153 kmem_cache_free(nfs4_layout_stateid_cache, ls); 154 } 155 156 static int 157 nfsd4_layout_setlease(struct nfs4_layout_stateid *ls) 158 { 159 struct file_lock *fl; 160 int status; 161 162 fl = locks_alloc_lock(); 163 if (!fl) 164 return -ENOMEM; 165 locks_init_lock(fl); 166 fl->fl_lmops = &nfsd4_layouts_lm_ops; 167 fl->fl_flags = FL_LAYOUT; 168 fl->fl_type = F_RDLCK; 169 fl->fl_end = OFFSET_MAX; 170 fl->fl_owner = ls; 171 fl->fl_pid = current->tgid; 172 fl->fl_file = ls->ls_file; 173 174 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl, NULL); 175 if (status) { 176 locks_free_lock(fl); 177 return status; 178 } 179 BUG_ON(fl != NULL); 180 return 0; 181 } 182 183 static struct nfs4_layout_stateid * 184 nfsd4_alloc_layout_stateid(struct nfsd4_compound_state *cstate, 185 struct nfs4_stid *parent, u32 layout_type) 186 { 187 struct nfs4_client *clp = cstate->clp; 188 struct nfs4_file *fp = parent->sc_file; 189 struct nfs4_layout_stateid *ls; 190 struct nfs4_stid *stp; 191 192 stp = nfs4_alloc_stid(cstate->clp, nfs4_layout_stateid_cache); 193 if (!stp) 194 return NULL; 195 stp->sc_free = nfsd4_free_layout_stateid; 196 get_nfs4_file(fp); 197 stp->sc_file = fp; 198 199 ls = layoutstateid(stp); 200 INIT_LIST_HEAD(&ls->ls_perclnt); 201 INIT_LIST_HEAD(&ls->ls_perfile); 202 spin_lock_init(&ls->ls_lock); 203 INIT_LIST_HEAD(&ls->ls_layouts); 204 mutex_init(&ls->ls_mutex); 205 ls->ls_layout_type = layout_type; 206 nfsd4_init_cb(&ls->ls_recall, clp, &nfsd4_cb_layout_ops, 207 NFSPROC4_CLNT_CB_LAYOUT); 208 209 if (parent->sc_type == NFS4_DELEG_STID) 210 ls->ls_file = get_file(fp->fi_deleg_file); 211 else 212 ls->ls_file = find_any_file(fp); 213 BUG_ON(!ls->ls_file); 214 215 if (nfsd4_layout_setlease(ls)) { 216 fput(ls->ls_file); 217 put_nfs4_file(fp); 218 kmem_cache_free(nfs4_layout_stateid_cache, ls); 219 return NULL; 220 } 221 222 spin_lock(&clp->cl_lock); 223 stp->sc_type = NFS4_LAYOUT_STID; 224 list_add(&ls->ls_perclnt, &clp->cl_lo_states); 225 spin_unlock(&clp->cl_lock); 226 227 spin_lock(&fp->fi_lock); 228 list_add(&ls->ls_perfile, &fp->fi_lo_states); 229 spin_unlock(&fp->fi_lock); 230 231 trace_layoutstate_alloc(&ls->ls_stid.sc_stateid); 232 return ls; 233 } 234 235 __be32 236 nfsd4_preprocess_layout_stateid(struct svc_rqst *rqstp, 237 struct nfsd4_compound_state *cstate, stateid_t *stateid, 238 bool create, u32 layout_type, struct nfs4_layout_stateid **lsp) 239 { 240 struct nfs4_layout_stateid *ls; 241 struct nfs4_stid *stid; 242 unsigned char typemask = NFS4_LAYOUT_STID; 243 __be32 status; 244 245 if (create) 246 typemask |= (NFS4_OPEN_STID | NFS4_LOCK_STID | NFS4_DELEG_STID); 247 248 status = nfsd4_lookup_stateid(cstate, stateid, typemask, &stid, 249 net_generic(SVC_NET(rqstp), nfsd_net_id)); 250 if (status) 251 goto out; 252 253 if (!fh_match(&cstate->current_fh.fh_handle, 254 &stid->sc_file->fi_fhandle)) { 255 status = nfserr_bad_stateid; 256 goto out_put_stid; 257 } 258 259 if (stid->sc_type != NFS4_LAYOUT_STID) { 260 ls = nfsd4_alloc_layout_stateid(cstate, stid, layout_type); 261 nfs4_put_stid(stid); 262 263 status = nfserr_jukebox; 264 if (!ls) 265 goto out; 266 mutex_lock(&ls->ls_mutex); 267 } else { 268 ls = container_of(stid, struct nfs4_layout_stateid, ls_stid); 269 270 status = nfserr_bad_stateid; 271 mutex_lock(&ls->ls_mutex); 272 if (stateid->si_generation > stid->sc_stateid.si_generation) 273 goto out_unlock_stid; 274 if (layout_type != ls->ls_layout_type) 275 goto out_unlock_stid; 276 } 277 278 *lsp = ls; 279 return 0; 280 281 out_unlock_stid: 282 mutex_unlock(&ls->ls_mutex); 283 out_put_stid: 284 nfs4_put_stid(stid); 285 out: 286 return status; 287 } 288 289 static void 290 nfsd4_recall_file_layout(struct nfs4_layout_stateid *ls) 291 { 292 spin_lock(&ls->ls_lock); 293 if (ls->ls_recalled) 294 goto out_unlock; 295 296 ls->ls_recalled = true; 297 atomic_inc(&ls->ls_stid.sc_file->fi_lo_recalls); 298 if (list_empty(&ls->ls_layouts)) 299 goto out_unlock; 300 301 trace_layout_recall(&ls->ls_stid.sc_stateid); 302 303 atomic_inc(&ls->ls_stid.sc_count); 304 nfsd4_run_cb(&ls->ls_recall); 305 306 out_unlock: 307 spin_unlock(&ls->ls_lock); 308 } 309 310 static inline u64 311 layout_end(struct nfsd4_layout_seg *seg) 312 { 313 u64 end = seg->offset + seg->length; 314 return end >= seg->offset ? end : NFS4_MAX_UINT64; 315 } 316 317 static void 318 layout_update_len(struct nfsd4_layout_seg *lo, u64 end) 319 { 320 if (end == NFS4_MAX_UINT64) 321 lo->length = NFS4_MAX_UINT64; 322 else 323 lo->length = end - lo->offset; 324 } 325 326 static bool 327 layouts_overlapping(struct nfs4_layout *lo, struct nfsd4_layout_seg *s) 328 { 329 if (s->iomode != IOMODE_ANY && s->iomode != lo->lo_seg.iomode) 330 return false; 331 if (layout_end(&lo->lo_seg) <= s->offset) 332 return false; 333 if (layout_end(s) <= lo->lo_seg.offset) 334 return false; 335 return true; 336 } 337 338 static bool 339 layouts_try_merge(struct nfsd4_layout_seg *lo, struct nfsd4_layout_seg *new) 340 { 341 if (lo->iomode != new->iomode) 342 return false; 343 if (layout_end(new) < lo->offset) 344 return false; 345 if (layout_end(lo) < new->offset) 346 return false; 347 348 lo->offset = min(lo->offset, new->offset); 349 layout_update_len(lo, max(layout_end(lo), layout_end(new))); 350 return true; 351 } 352 353 static __be32 354 nfsd4_recall_conflict(struct nfs4_layout_stateid *ls) 355 { 356 struct nfs4_file *fp = ls->ls_stid.sc_file; 357 struct nfs4_layout_stateid *l, *n; 358 __be32 nfserr = nfs_ok; 359 360 assert_spin_locked(&fp->fi_lock); 361 362 list_for_each_entry_safe(l, n, &fp->fi_lo_states, ls_perfile) { 363 if (l != ls) { 364 nfsd4_recall_file_layout(l); 365 nfserr = nfserr_recallconflict; 366 } 367 } 368 369 return nfserr; 370 } 371 372 __be32 373 nfsd4_insert_layout(struct nfsd4_layoutget *lgp, struct nfs4_layout_stateid *ls) 374 { 375 struct nfsd4_layout_seg *seg = &lgp->lg_seg; 376 struct nfs4_file *fp = ls->ls_stid.sc_file; 377 struct nfs4_layout *lp, *new = NULL; 378 __be32 nfserr; 379 380 spin_lock(&fp->fi_lock); 381 nfserr = nfsd4_recall_conflict(ls); 382 if (nfserr) 383 goto out; 384 spin_lock(&ls->ls_lock); 385 list_for_each_entry(lp, &ls->ls_layouts, lo_perstate) { 386 if (layouts_try_merge(&lp->lo_seg, seg)) 387 goto done; 388 } 389 spin_unlock(&ls->ls_lock); 390 spin_unlock(&fp->fi_lock); 391 392 new = kmem_cache_alloc(nfs4_layout_cache, GFP_KERNEL); 393 if (!new) 394 return nfserr_jukebox; 395 memcpy(&new->lo_seg, seg, sizeof(lp->lo_seg)); 396 new->lo_state = ls; 397 398 spin_lock(&fp->fi_lock); 399 nfserr = nfsd4_recall_conflict(ls); 400 if (nfserr) 401 goto out; 402 spin_lock(&ls->ls_lock); 403 list_for_each_entry(lp, &ls->ls_layouts, lo_perstate) { 404 if (layouts_try_merge(&lp->lo_seg, seg)) 405 goto done; 406 } 407 408 atomic_inc(&ls->ls_stid.sc_count); 409 list_add_tail(&new->lo_perstate, &ls->ls_layouts); 410 new = NULL; 411 done: 412 nfs4_inc_and_copy_stateid(&lgp->lg_sid, &ls->ls_stid); 413 spin_unlock(&ls->ls_lock); 414 out: 415 spin_unlock(&fp->fi_lock); 416 if (new) 417 kmem_cache_free(nfs4_layout_cache, new); 418 return nfserr; 419 } 420 421 static void 422 nfsd4_free_layouts(struct list_head *reaplist) 423 { 424 while (!list_empty(reaplist)) { 425 struct nfs4_layout *lp = list_first_entry(reaplist, 426 struct nfs4_layout, lo_perstate); 427 428 list_del(&lp->lo_perstate); 429 nfs4_put_stid(&lp->lo_state->ls_stid); 430 kmem_cache_free(nfs4_layout_cache, lp); 431 } 432 } 433 434 static void 435 nfsd4_return_file_layout(struct nfs4_layout *lp, struct nfsd4_layout_seg *seg, 436 struct list_head *reaplist) 437 { 438 struct nfsd4_layout_seg *lo = &lp->lo_seg; 439 u64 end = layout_end(lo); 440 441 if (seg->offset <= lo->offset) { 442 if (layout_end(seg) >= end) { 443 list_move_tail(&lp->lo_perstate, reaplist); 444 return; 445 } 446 lo->offset = layout_end(seg); 447 } else { 448 /* retain the whole layout segment on a split. */ 449 if (layout_end(seg) < end) { 450 dprintk("%s: split not supported\n", __func__); 451 return; 452 } 453 end = seg->offset; 454 } 455 456 layout_update_len(lo, end); 457 } 458 459 __be32 460 nfsd4_return_file_layouts(struct svc_rqst *rqstp, 461 struct nfsd4_compound_state *cstate, 462 struct nfsd4_layoutreturn *lrp) 463 { 464 struct nfs4_layout_stateid *ls; 465 struct nfs4_layout *lp, *n; 466 LIST_HEAD(reaplist); 467 __be32 nfserr; 468 int found = 0; 469 470 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lrp->lr_sid, 471 false, lrp->lr_layout_type, 472 &ls); 473 if (nfserr) { 474 trace_layout_return_lookup_fail(&lrp->lr_sid); 475 return nfserr; 476 } 477 478 spin_lock(&ls->ls_lock); 479 list_for_each_entry_safe(lp, n, &ls->ls_layouts, lo_perstate) { 480 if (layouts_overlapping(lp, &lrp->lr_seg)) { 481 nfsd4_return_file_layout(lp, &lrp->lr_seg, &reaplist); 482 found++; 483 } 484 } 485 if (!list_empty(&ls->ls_layouts)) { 486 if (found) 487 nfs4_inc_and_copy_stateid(&lrp->lr_sid, &ls->ls_stid); 488 lrp->lrs_present = 1; 489 } else { 490 trace_layoutstate_unhash(&ls->ls_stid.sc_stateid); 491 nfs4_unhash_stid(&ls->ls_stid); 492 lrp->lrs_present = 0; 493 } 494 spin_unlock(&ls->ls_lock); 495 496 mutex_unlock(&ls->ls_mutex); 497 nfs4_put_stid(&ls->ls_stid); 498 nfsd4_free_layouts(&reaplist); 499 return nfs_ok; 500 } 501 502 __be32 503 nfsd4_return_client_layouts(struct svc_rqst *rqstp, 504 struct nfsd4_compound_state *cstate, 505 struct nfsd4_layoutreturn *lrp) 506 { 507 struct nfs4_layout_stateid *ls, *n; 508 struct nfs4_client *clp = cstate->clp; 509 struct nfs4_layout *lp, *t; 510 LIST_HEAD(reaplist); 511 512 lrp->lrs_present = 0; 513 514 spin_lock(&clp->cl_lock); 515 list_for_each_entry_safe(ls, n, &clp->cl_lo_states, ls_perclnt) { 516 if (ls->ls_layout_type != lrp->lr_layout_type) 517 continue; 518 519 if (lrp->lr_return_type == RETURN_FSID && 520 !fh_fsid_match(&ls->ls_stid.sc_file->fi_fhandle, 521 &cstate->current_fh.fh_handle)) 522 continue; 523 524 spin_lock(&ls->ls_lock); 525 list_for_each_entry_safe(lp, t, &ls->ls_layouts, lo_perstate) { 526 if (lrp->lr_seg.iomode == IOMODE_ANY || 527 lrp->lr_seg.iomode == lp->lo_seg.iomode) 528 list_move_tail(&lp->lo_perstate, &reaplist); 529 } 530 spin_unlock(&ls->ls_lock); 531 } 532 spin_unlock(&clp->cl_lock); 533 534 nfsd4_free_layouts(&reaplist); 535 return 0; 536 } 537 538 static void 539 nfsd4_return_all_layouts(struct nfs4_layout_stateid *ls, 540 struct list_head *reaplist) 541 { 542 spin_lock(&ls->ls_lock); 543 list_splice_init(&ls->ls_layouts, reaplist); 544 spin_unlock(&ls->ls_lock); 545 } 546 547 void 548 nfsd4_return_all_client_layouts(struct nfs4_client *clp) 549 { 550 struct nfs4_layout_stateid *ls, *n; 551 LIST_HEAD(reaplist); 552 553 spin_lock(&clp->cl_lock); 554 list_for_each_entry_safe(ls, n, &clp->cl_lo_states, ls_perclnt) 555 nfsd4_return_all_layouts(ls, &reaplist); 556 spin_unlock(&clp->cl_lock); 557 558 nfsd4_free_layouts(&reaplist); 559 } 560 561 void 562 nfsd4_return_all_file_layouts(struct nfs4_client *clp, struct nfs4_file *fp) 563 { 564 struct nfs4_layout_stateid *ls, *n; 565 LIST_HEAD(reaplist); 566 567 spin_lock(&fp->fi_lock); 568 list_for_each_entry_safe(ls, n, &fp->fi_lo_states, ls_perfile) { 569 if (ls->ls_stid.sc_client == clp) 570 nfsd4_return_all_layouts(ls, &reaplist); 571 } 572 spin_unlock(&fp->fi_lock); 573 574 nfsd4_free_layouts(&reaplist); 575 } 576 577 static void 578 nfsd4_cb_layout_fail(struct nfs4_layout_stateid *ls) 579 { 580 struct nfs4_client *clp = ls->ls_stid.sc_client; 581 char addr_str[INET6_ADDRSTRLEN]; 582 static char *envp[] = { 583 "HOME=/", 584 "TERM=linux", 585 "PATH=/sbin:/usr/sbin:/bin:/usr/bin", 586 NULL 587 }; 588 char *argv[8]; 589 int error; 590 591 rpc_ntop((struct sockaddr *)&clp->cl_addr, addr_str, sizeof(addr_str)); 592 593 trace_layout_recall_fail(&ls->ls_stid.sc_stateid); 594 595 printk(KERN_WARNING 596 "nfsd: client %s failed to respond to layout recall. " 597 " Fencing..\n", addr_str); 598 599 argv[0] = "/sbin/nfsd-recall-failed"; 600 argv[1] = addr_str; 601 argv[2] = ls->ls_file->f_path.mnt->mnt_sb->s_id; 602 argv[3] = NULL; 603 604 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 605 if (error) { 606 printk(KERN_ERR "nfsd: fence failed for client %s: %d!\n", 607 addr_str, error); 608 } 609 } 610 611 static void 612 nfsd4_cb_layout_prepare(struct nfsd4_callback *cb) 613 { 614 struct nfs4_layout_stateid *ls = 615 container_of(cb, struct nfs4_layout_stateid, ls_recall); 616 617 mutex_lock(&ls->ls_mutex); 618 nfs4_inc_and_copy_stateid(&ls->ls_recall_sid, &ls->ls_stid); 619 mutex_unlock(&ls->ls_mutex); 620 } 621 622 static int 623 nfsd4_cb_layout_done(struct nfsd4_callback *cb, struct rpc_task *task) 624 { 625 struct nfs4_layout_stateid *ls = 626 container_of(cb, struct nfs4_layout_stateid, ls_recall); 627 struct nfsd_net *nn; 628 ktime_t now, cutoff; 629 LIST_HEAD(reaplist); 630 631 632 switch (task->tk_status) { 633 case 0: 634 case -NFS4ERR_DELAY: 635 /* 636 * Anything left? If not, then call it done. Note that we don't 637 * take the spinlock since this is an optimization and nothing 638 * should get added until the cb counter goes to zero. 639 */ 640 if (list_empty(&ls->ls_layouts)) 641 return 1; 642 643 /* Poll the client until it's done with the layout */ 644 now = ktime_get(); 645 nn = net_generic(ls->ls_stid.sc_client->net, nfsd_net_id); 646 647 /* Client gets 2 lease periods to return it */ 648 cutoff = ktime_add_ns(task->tk_start, 649 nn->nfsd4_lease * NSEC_PER_SEC * 2); 650 651 if (ktime_before(now, cutoff)) { 652 rpc_delay(task, HZ/100); /* 10 mili-seconds */ 653 return 0; 654 } 655 /* Fallthrough */ 656 case -NFS4ERR_NOMATCHING_LAYOUT: 657 trace_layout_recall_done(&ls->ls_stid.sc_stateid); 658 task->tk_status = 0; 659 return 1; 660 default: 661 /* 662 * Unknown error or non-responding client, we'll need to fence. 663 */ 664 nfsd4_cb_layout_fail(ls); 665 return -1; 666 } 667 } 668 669 static void 670 nfsd4_cb_layout_release(struct nfsd4_callback *cb) 671 { 672 struct nfs4_layout_stateid *ls = 673 container_of(cb, struct nfs4_layout_stateid, ls_recall); 674 LIST_HEAD(reaplist); 675 676 trace_layout_recall_release(&ls->ls_stid.sc_stateid); 677 678 nfsd4_return_all_layouts(ls, &reaplist); 679 nfsd4_free_layouts(&reaplist); 680 nfs4_put_stid(&ls->ls_stid); 681 } 682 683 static const struct nfsd4_callback_ops nfsd4_cb_layout_ops = { 684 .prepare = nfsd4_cb_layout_prepare, 685 .done = nfsd4_cb_layout_done, 686 .release = nfsd4_cb_layout_release, 687 }; 688 689 static bool 690 nfsd4_layout_lm_break(struct file_lock *fl) 691 { 692 /* 693 * We don't want the locks code to timeout the lease for us; 694 * we'll remove it ourself if a layout isn't returned 695 * in time: 696 */ 697 fl->fl_break_time = 0; 698 nfsd4_recall_file_layout(fl->fl_owner); 699 return false; 700 } 701 702 static int 703 nfsd4_layout_lm_change(struct file_lock *onlist, int arg, 704 struct list_head *dispose) 705 { 706 BUG_ON(!(arg & F_UNLCK)); 707 return lease_modify(onlist, arg, dispose); 708 } 709 710 static const struct lock_manager_operations nfsd4_layouts_lm_ops = { 711 .lm_break = nfsd4_layout_lm_break, 712 .lm_change = nfsd4_layout_lm_change, 713 }; 714 715 int 716 nfsd4_init_pnfs(void) 717 { 718 int i; 719 720 for (i = 0; i < DEVID_HASH_SIZE; i++) 721 INIT_LIST_HEAD(&nfsd_devid_hash[i]); 722 723 nfs4_layout_cache = kmem_cache_create("nfs4_layout", 724 sizeof(struct nfs4_layout), 0, 0, NULL); 725 if (!nfs4_layout_cache) 726 return -ENOMEM; 727 728 nfs4_layout_stateid_cache = kmem_cache_create("nfs4_layout_stateid", 729 sizeof(struct nfs4_layout_stateid), 0, 0, NULL); 730 if (!nfs4_layout_stateid_cache) { 731 kmem_cache_destroy(nfs4_layout_cache); 732 return -ENOMEM; 733 } 734 return 0; 735 } 736 737 void 738 nfsd4_exit_pnfs(void) 739 { 740 int i; 741 742 kmem_cache_destroy(nfs4_layout_cache); 743 kmem_cache_destroy(nfs4_layout_stateid_cache); 744 745 for (i = 0; i < DEVID_HASH_SIZE; i++) { 746 struct nfsd4_deviceid_map *map, *n; 747 748 list_for_each_entry_safe(map, n, &nfsd_devid_hash[i], hash) 749 kfree(map); 750 } 751 } 752