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
devid_hashfn(u64 idx)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
nfsd4_alloc_devid_map(const struct svc_fh * fhp)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 *
nfsd4_find_devid_map(int idx)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
nfsd4_set_deviceid(struct nfsd4_deviceid * id,const struct svc_fh * fhp,u32 device_generation)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
nfsd4_setup_layout_type(struct svc_export * exp)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
nfsd4_free_layout_stateid(struct nfs4_stid * stid)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
nfsd4_layout_setlease(struct nfs4_layout_stateid * ls)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 *
nfsd4_alloc_layout_stateid(struct nfsd4_compound_state * cstate,struct nfs4_stid * parent,u32 layout_type)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 nfsd4_free_layout_stateid);
228 if (!stp)
229 return NULL;
230
231 get_nfs4_file(fp);
232 stp->sc_file = fp;
233
234 ls = layoutstateid(stp);
235 INIT_LIST_HEAD(&ls->ls_perclnt);
236 INIT_LIST_HEAD(&ls->ls_perfile);
237 spin_lock_init(&ls->ls_lock);
238 INIT_LIST_HEAD(&ls->ls_layouts);
239 mutex_init(&ls->ls_mutex);
240 ls->ls_layout_type = layout_type;
241 nfsd4_init_cb(&ls->ls_recall, clp, &nfsd4_cb_layout_ops,
242 NFSPROC4_CLNT_CB_LAYOUT);
243
244 if (parent->sc_type == NFS4_DELEG_STID)
245 ls->ls_file = get_file(fp->fi_deleg_file);
246 else
247 ls->ls_file = find_any_file(fp);
248 BUG_ON(!ls->ls_file);
249
250 if (nfsd4_layout_setlease(ls)) {
251 fput(ls->ls_file);
252 put_nfs4_file(fp);
253 kmem_cache_free(nfs4_layout_stateid_cache, ls);
254 return NULL;
255 }
256
257 spin_lock(&clp->cl_lock);
258 stp->sc_type = NFS4_LAYOUT_STID;
259 list_add(&ls->ls_perclnt, &clp->cl_lo_states);
260 spin_unlock(&clp->cl_lock);
261
262 spin_lock(&fp->fi_lock);
263 list_add(&ls->ls_perfile, &fp->fi_lo_states);
264 spin_unlock(&fp->fi_lock);
265
266 trace_layoutstate_alloc(&ls->ls_stid.sc_stateid);
267 return ls;
268 }
269
270 __be32
nfsd4_preprocess_layout_stateid(struct svc_rqst * rqstp,struct nfsd4_compound_state * cstate,stateid_t * stateid,bool create,u32 layout_type,struct nfs4_layout_stateid ** lsp)271 nfsd4_preprocess_layout_stateid(struct svc_rqst *rqstp,
272 struct nfsd4_compound_state *cstate, stateid_t *stateid,
273 bool create, u32 layout_type, struct nfs4_layout_stateid **lsp)
274 {
275 struct nfs4_layout_stateid *ls;
276 struct nfs4_stid *stid;
277 unsigned char typemask = NFS4_LAYOUT_STID;
278 __be32 status;
279
280 if (create)
281 typemask |= (NFS4_OPEN_STID | NFS4_LOCK_STID | NFS4_DELEG_STID);
282
283 status = nfsd4_lookup_stateid(cstate, stateid, typemask, &stid,
284 net_generic(SVC_NET(rqstp), nfsd_net_id));
285 if (status)
286 goto out;
287
288 if (!fh_match(&cstate->current_fh.fh_handle,
289 &stid->sc_file->fi_fhandle)) {
290 status = nfserr_bad_stateid;
291 goto out_put_stid;
292 }
293
294 if (stid->sc_type != NFS4_LAYOUT_STID) {
295 ls = nfsd4_alloc_layout_stateid(cstate, stid, layout_type);
296 nfs4_put_stid(stid);
297
298 status = nfserr_jukebox;
299 if (!ls)
300 goto out;
301 mutex_lock(&ls->ls_mutex);
302 } else {
303 ls = container_of(stid, struct nfs4_layout_stateid, ls_stid);
304
305 status = nfserr_bad_stateid;
306 mutex_lock(&ls->ls_mutex);
307 if (nfsd4_stateid_generation_after(stateid, &stid->sc_stateid))
308 goto out_unlock_stid;
309 if (layout_type != ls->ls_layout_type)
310 goto out_unlock_stid;
311 }
312
313 *lsp = ls;
314 return 0;
315
316 out_unlock_stid:
317 mutex_unlock(&ls->ls_mutex);
318 out_put_stid:
319 nfs4_put_stid(stid);
320 out:
321 return status;
322 }
323
324 static void
nfsd4_recall_file_layout(struct nfs4_layout_stateid * ls)325 nfsd4_recall_file_layout(struct nfs4_layout_stateid *ls)
326 {
327 spin_lock(&ls->ls_lock);
328 if (ls->ls_recalled)
329 goto out_unlock;
330
331 ls->ls_recalled = true;
332 atomic_inc(&ls->ls_stid.sc_file->fi_lo_recalls);
333 if (list_empty(&ls->ls_layouts))
334 goto out_unlock;
335
336 trace_layout_recall(&ls->ls_stid.sc_stateid);
337
338 atomic_inc(&ls->ls_stid.sc_count);
339 nfsd4_run_cb(&ls->ls_recall);
340
341 out_unlock:
342 spin_unlock(&ls->ls_lock);
343 }
344
345 static inline u64
layout_end(struct nfsd4_layout_seg * seg)346 layout_end(struct nfsd4_layout_seg *seg)
347 {
348 u64 end = seg->offset + seg->length;
349 return end >= seg->offset ? end : NFS4_MAX_UINT64;
350 }
351
352 static void
layout_update_len(struct nfsd4_layout_seg * lo,u64 end)353 layout_update_len(struct nfsd4_layout_seg *lo, u64 end)
354 {
355 if (end == NFS4_MAX_UINT64)
356 lo->length = NFS4_MAX_UINT64;
357 else
358 lo->length = end - lo->offset;
359 }
360
361 static bool
layouts_overlapping(struct nfs4_layout * lo,struct nfsd4_layout_seg * s)362 layouts_overlapping(struct nfs4_layout *lo, struct nfsd4_layout_seg *s)
363 {
364 if (s->iomode != IOMODE_ANY && s->iomode != lo->lo_seg.iomode)
365 return false;
366 if (layout_end(&lo->lo_seg) <= s->offset)
367 return false;
368 if (layout_end(s) <= lo->lo_seg.offset)
369 return false;
370 return true;
371 }
372
373 static bool
layouts_try_merge(struct nfsd4_layout_seg * lo,struct nfsd4_layout_seg * new)374 layouts_try_merge(struct nfsd4_layout_seg *lo, struct nfsd4_layout_seg *new)
375 {
376 if (lo->iomode != new->iomode)
377 return false;
378 if (layout_end(new) < lo->offset)
379 return false;
380 if (layout_end(lo) < new->offset)
381 return false;
382
383 lo->offset = min(lo->offset, new->offset);
384 layout_update_len(lo, max(layout_end(lo), layout_end(new)));
385 return true;
386 }
387
388 static __be32
nfsd4_recall_conflict(struct nfs4_layout_stateid * ls)389 nfsd4_recall_conflict(struct nfs4_layout_stateid *ls)
390 {
391 struct nfs4_file *fp = ls->ls_stid.sc_file;
392 struct nfs4_layout_stateid *l, *n;
393 __be32 nfserr = nfs_ok;
394
395 assert_spin_locked(&fp->fi_lock);
396
397 list_for_each_entry_safe(l, n, &fp->fi_lo_states, ls_perfile) {
398 if (l != ls) {
399 nfsd4_recall_file_layout(l);
400 nfserr = nfserr_recallconflict;
401 }
402 }
403
404 return nfserr;
405 }
406
407 __be32
nfsd4_insert_layout(struct nfsd4_layoutget * lgp,struct nfs4_layout_stateid * ls)408 nfsd4_insert_layout(struct nfsd4_layoutget *lgp, struct nfs4_layout_stateid *ls)
409 {
410 struct nfsd4_layout_seg *seg = &lgp->lg_seg;
411 struct nfs4_file *fp = ls->ls_stid.sc_file;
412 struct nfs4_layout *lp, *new = NULL;
413 __be32 nfserr;
414
415 spin_lock(&fp->fi_lock);
416 nfserr = nfsd4_recall_conflict(ls);
417 if (nfserr)
418 goto out;
419 spin_lock(&ls->ls_lock);
420 list_for_each_entry(lp, &ls->ls_layouts, lo_perstate) {
421 if (layouts_try_merge(&lp->lo_seg, seg))
422 goto done;
423 }
424 spin_unlock(&ls->ls_lock);
425 spin_unlock(&fp->fi_lock);
426
427 new = kmem_cache_alloc(nfs4_layout_cache, GFP_KERNEL);
428 if (!new)
429 return nfserr_jukebox;
430 memcpy(&new->lo_seg, seg, sizeof(lp->lo_seg));
431 new->lo_state = ls;
432
433 spin_lock(&fp->fi_lock);
434 nfserr = nfsd4_recall_conflict(ls);
435 if (nfserr)
436 goto out;
437 spin_lock(&ls->ls_lock);
438 list_for_each_entry(lp, &ls->ls_layouts, lo_perstate) {
439 if (layouts_try_merge(&lp->lo_seg, seg))
440 goto done;
441 }
442
443 atomic_inc(&ls->ls_stid.sc_count);
444 list_add_tail(&new->lo_perstate, &ls->ls_layouts);
445 new = NULL;
446 done:
447 nfs4_inc_and_copy_stateid(&lgp->lg_sid, &ls->ls_stid);
448 spin_unlock(&ls->ls_lock);
449 out:
450 spin_unlock(&fp->fi_lock);
451 if (new)
452 kmem_cache_free(nfs4_layout_cache, new);
453 return nfserr;
454 }
455
456 static void
nfsd4_free_layouts(struct list_head * reaplist)457 nfsd4_free_layouts(struct list_head *reaplist)
458 {
459 while (!list_empty(reaplist)) {
460 struct nfs4_layout *lp = list_first_entry(reaplist,
461 struct nfs4_layout, lo_perstate);
462
463 list_del(&lp->lo_perstate);
464 nfs4_put_stid(&lp->lo_state->ls_stid);
465 kmem_cache_free(nfs4_layout_cache, lp);
466 }
467 }
468
469 static void
nfsd4_return_file_layout(struct nfs4_layout * lp,struct nfsd4_layout_seg * seg,struct list_head * reaplist)470 nfsd4_return_file_layout(struct nfs4_layout *lp, struct nfsd4_layout_seg *seg,
471 struct list_head *reaplist)
472 {
473 struct nfsd4_layout_seg *lo = &lp->lo_seg;
474 u64 end = layout_end(lo);
475
476 if (seg->offset <= lo->offset) {
477 if (layout_end(seg) >= end) {
478 list_move_tail(&lp->lo_perstate, reaplist);
479 return;
480 }
481 lo->offset = layout_end(seg);
482 } else {
483 /* retain the whole layout segment on a split. */
484 if (layout_end(seg) < end) {
485 dprintk("%s: split not supported\n", __func__);
486 return;
487 }
488 end = seg->offset;
489 }
490
491 layout_update_len(lo, end);
492 }
493
494 __be32
nfsd4_return_file_layouts(struct svc_rqst * rqstp,struct nfsd4_compound_state * cstate,struct nfsd4_layoutreturn * lrp)495 nfsd4_return_file_layouts(struct svc_rqst *rqstp,
496 struct nfsd4_compound_state *cstate,
497 struct nfsd4_layoutreturn *lrp)
498 {
499 struct nfs4_layout_stateid *ls;
500 struct nfs4_layout *lp, *n;
501 LIST_HEAD(reaplist);
502 __be32 nfserr;
503 int found = 0;
504
505 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lrp->lr_sid,
506 false, lrp->lr_layout_type,
507 &ls);
508 if (nfserr) {
509 trace_layout_return_lookup_fail(&lrp->lr_sid);
510 return nfserr;
511 }
512
513 spin_lock(&ls->ls_lock);
514 list_for_each_entry_safe(lp, n, &ls->ls_layouts, lo_perstate) {
515 if (layouts_overlapping(lp, &lrp->lr_seg)) {
516 nfsd4_return_file_layout(lp, &lrp->lr_seg, &reaplist);
517 found++;
518 }
519 }
520 if (!list_empty(&ls->ls_layouts)) {
521 if (found)
522 nfs4_inc_and_copy_stateid(&lrp->lr_sid, &ls->ls_stid);
523 lrp->lrs_present = 1;
524 } else {
525 trace_layoutstate_unhash(&ls->ls_stid.sc_stateid);
526 nfs4_unhash_stid(&ls->ls_stid);
527 lrp->lrs_present = 0;
528 }
529 spin_unlock(&ls->ls_lock);
530
531 mutex_unlock(&ls->ls_mutex);
532 nfs4_put_stid(&ls->ls_stid);
533 nfsd4_free_layouts(&reaplist);
534 return nfs_ok;
535 }
536
537 __be32
nfsd4_return_client_layouts(struct svc_rqst * rqstp,struct nfsd4_compound_state * cstate,struct nfsd4_layoutreturn * lrp)538 nfsd4_return_client_layouts(struct svc_rqst *rqstp,
539 struct nfsd4_compound_state *cstate,
540 struct nfsd4_layoutreturn *lrp)
541 {
542 struct nfs4_layout_stateid *ls, *n;
543 struct nfs4_client *clp = cstate->clp;
544 struct nfs4_layout *lp, *t;
545 LIST_HEAD(reaplist);
546
547 lrp->lrs_present = 0;
548
549 spin_lock(&clp->cl_lock);
550 list_for_each_entry_safe(ls, n, &clp->cl_lo_states, ls_perclnt) {
551 if (ls->ls_layout_type != lrp->lr_layout_type)
552 continue;
553
554 if (lrp->lr_return_type == RETURN_FSID &&
555 !fh_fsid_match(&ls->ls_stid.sc_file->fi_fhandle,
556 &cstate->current_fh.fh_handle))
557 continue;
558
559 spin_lock(&ls->ls_lock);
560 list_for_each_entry_safe(lp, t, &ls->ls_layouts, lo_perstate) {
561 if (lrp->lr_seg.iomode == IOMODE_ANY ||
562 lrp->lr_seg.iomode == lp->lo_seg.iomode)
563 list_move_tail(&lp->lo_perstate, &reaplist);
564 }
565 spin_unlock(&ls->ls_lock);
566 }
567 spin_unlock(&clp->cl_lock);
568
569 nfsd4_free_layouts(&reaplist);
570 return 0;
571 }
572
573 static void
nfsd4_return_all_layouts(struct nfs4_layout_stateid * ls,struct list_head * reaplist)574 nfsd4_return_all_layouts(struct nfs4_layout_stateid *ls,
575 struct list_head *reaplist)
576 {
577 spin_lock(&ls->ls_lock);
578 list_splice_init(&ls->ls_layouts, reaplist);
579 spin_unlock(&ls->ls_lock);
580 }
581
582 void
nfsd4_return_all_client_layouts(struct nfs4_client * clp)583 nfsd4_return_all_client_layouts(struct nfs4_client *clp)
584 {
585 struct nfs4_layout_stateid *ls, *n;
586 LIST_HEAD(reaplist);
587
588 spin_lock(&clp->cl_lock);
589 list_for_each_entry_safe(ls, n, &clp->cl_lo_states, ls_perclnt)
590 nfsd4_return_all_layouts(ls, &reaplist);
591 spin_unlock(&clp->cl_lock);
592
593 nfsd4_free_layouts(&reaplist);
594 }
595
596 void
nfsd4_return_all_file_layouts(struct nfs4_client * clp,struct nfs4_file * fp)597 nfsd4_return_all_file_layouts(struct nfs4_client *clp, struct nfs4_file *fp)
598 {
599 struct nfs4_layout_stateid *ls, *n;
600 LIST_HEAD(reaplist);
601
602 spin_lock(&fp->fi_lock);
603 list_for_each_entry_safe(ls, n, &fp->fi_lo_states, ls_perfile) {
604 if (ls->ls_stid.sc_client == clp)
605 nfsd4_return_all_layouts(ls, &reaplist);
606 }
607 spin_unlock(&fp->fi_lock);
608
609 nfsd4_free_layouts(&reaplist);
610 }
611
612 static void
nfsd4_cb_layout_fail(struct nfs4_layout_stateid * ls)613 nfsd4_cb_layout_fail(struct nfs4_layout_stateid *ls)
614 {
615 struct nfs4_client *clp = ls->ls_stid.sc_client;
616 char addr_str[INET6_ADDRSTRLEN];
617 static char *envp[] = {
618 "HOME=/",
619 "TERM=linux",
620 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
621 NULL
622 };
623 char *argv[8];
624 int error;
625
626 rpc_ntop((struct sockaddr *)&clp->cl_addr, addr_str, sizeof(addr_str));
627
628 printk(KERN_WARNING
629 "nfsd: client %s failed to respond to layout recall. "
630 " Fencing..\n", addr_str);
631
632 argv[0] = "/sbin/nfsd-recall-failed";
633 argv[1] = addr_str;
634 argv[2] = ls->ls_file->f_path.mnt->mnt_sb->s_id;
635 argv[3] = NULL;
636
637 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
638 if (error) {
639 printk(KERN_ERR "nfsd: fence failed for client %s: %d!\n",
640 addr_str, error);
641 }
642 }
643
644 static void
nfsd4_cb_layout_prepare(struct nfsd4_callback * cb)645 nfsd4_cb_layout_prepare(struct nfsd4_callback *cb)
646 {
647 struct nfs4_layout_stateid *ls =
648 container_of(cb, struct nfs4_layout_stateid, ls_recall);
649
650 mutex_lock(&ls->ls_mutex);
651 nfs4_inc_and_copy_stateid(&ls->ls_recall_sid, &ls->ls_stid);
652 mutex_unlock(&ls->ls_mutex);
653 }
654
655 static int
nfsd4_cb_layout_done(struct nfsd4_callback * cb,struct rpc_task * task)656 nfsd4_cb_layout_done(struct nfsd4_callback *cb, struct rpc_task *task)
657 {
658 struct nfs4_layout_stateid *ls =
659 container_of(cb, struct nfs4_layout_stateid, ls_recall);
660 struct nfsd_net *nn;
661 ktime_t now, cutoff;
662 const struct nfsd4_layout_ops *ops;
663 LIST_HEAD(reaplist);
664
665
666 switch (task->tk_status) {
667 case 0:
668 case -NFS4ERR_DELAY:
669 /*
670 * Anything left? If not, then call it done. Note that we don't
671 * take the spinlock since this is an optimization and nothing
672 * should get added until the cb counter goes to zero.
673 */
674 if (list_empty(&ls->ls_layouts))
675 return 1;
676
677 /* Poll the client until it's done with the layout */
678 now = ktime_get();
679 nn = net_generic(ls->ls_stid.sc_client->net, nfsd_net_id);
680
681 /* Client gets 2 lease periods to return it */
682 cutoff = ktime_add_ns(task->tk_start,
683 nn->nfsd4_lease * NSEC_PER_SEC * 2);
684
685 if (ktime_before(now, cutoff)) {
686 rpc_delay(task, HZ/100); /* 10 mili-seconds */
687 return 0;
688 }
689 /* Fallthrough */
690 case -NFS4ERR_NOMATCHING_LAYOUT:
691 trace_layout_recall_done(&ls->ls_stid.sc_stateid);
692 task->tk_status = 0;
693 return 1;
694 default:
695 /*
696 * Unknown error or non-responding client, we'll need to fence.
697 */
698 trace_layout_recall_fail(&ls->ls_stid.sc_stateid);
699
700 ops = nfsd4_layout_ops[ls->ls_layout_type];
701 if (ops->fence_client)
702 ops->fence_client(ls);
703 else
704 nfsd4_cb_layout_fail(ls);
705 return -1;
706 }
707 }
708
709 static void
nfsd4_cb_layout_release(struct nfsd4_callback * cb)710 nfsd4_cb_layout_release(struct nfsd4_callback *cb)
711 {
712 struct nfs4_layout_stateid *ls =
713 container_of(cb, struct nfs4_layout_stateid, ls_recall);
714 LIST_HEAD(reaplist);
715
716 trace_layout_recall_release(&ls->ls_stid.sc_stateid);
717
718 nfsd4_return_all_layouts(ls, &reaplist);
719 nfsd4_free_layouts(&reaplist);
720 nfs4_put_stid(&ls->ls_stid);
721 }
722
723 static const struct nfsd4_callback_ops nfsd4_cb_layout_ops = {
724 .prepare = nfsd4_cb_layout_prepare,
725 .done = nfsd4_cb_layout_done,
726 .release = nfsd4_cb_layout_release,
727 };
728
729 static bool
nfsd4_layout_lm_break(struct file_lock * fl)730 nfsd4_layout_lm_break(struct file_lock *fl)
731 {
732 /*
733 * We don't want the locks code to timeout the lease for us;
734 * we'll remove it ourself if a layout isn't returned
735 * in time:
736 */
737 fl->fl_break_time = 0;
738 nfsd4_recall_file_layout(fl->fl_owner);
739 return false;
740 }
741
742 static int
nfsd4_layout_lm_change(struct file_lock * onlist,int arg,struct list_head * dispose)743 nfsd4_layout_lm_change(struct file_lock *onlist, int arg,
744 struct list_head *dispose)
745 {
746 BUG_ON(!(arg & F_UNLCK));
747 return lease_modify(onlist, arg, dispose);
748 }
749
750 static const struct lock_manager_operations nfsd4_layouts_lm_ops = {
751 .lm_break = nfsd4_layout_lm_break,
752 .lm_change = nfsd4_layout_lm_change,
753 };
754
755 int
nfsd4_init_pnfs(void)756 nfsd4_init_pnfs(void)
757 {
758 int i;
759
760 for (i = 0; i < DEVID_HASH_SIZE; i++)
761 INIT_LIST_HEAD(&nfsd_devid_hash[i]);
762
763 nfs4_layout_cache = kmem_cache_create("nfs4_layout",
764 sizeof(struct nfs4_layout), 0, 0, NULL);
765 if (!nfs4_layout_cache)
766 return -ENOMEM;
767
768 nfs4_layout_stateid_cache = kmem_cache_create("nfs4_layout_stateid",
769 sizeof(struct nfs4_layout_stateid), 0, 0, NULL);
770 if (!nfs4_layout_stateid_cache) {
771 kmem_cache_destroy(nfs4_layout_cache);
772 return -ENOMEM;
773 }
774 return 0;
775 }
776
777 void
nfsd4_exit_pnfs(void)778 nfsd4_exit_pnfs(void)
779 {
780 int i;
781
782 kmem_cache_destroy(nfs4_layout_cache);
783 kmem_cache_destroy(nfs4_layout_stateid_cache);
784
785 for (i = 0; i < DEVID_HASH_SIZE; i++) {
786 struct nfsd4_deviceid_map *map, *n;
787
788 list_for_each_entry_safe(map, n, &nfsd_devid_hash[i], hash)
789 kfree(map);
790 }
791 }
792