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