~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfsd/nfs4layouts.c

Version: ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 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                                         nfsd4_free_layout_stateid);
194         if (!stp)
195                 return NULL;
196 
197         get_nfs4_file(fp);
198         stp->sc_file = fp;
199 
200         ls = layoutstateid(stp);
201         INIT_LIST_HEAD(&ls->ls_perclnt);
202         INIT_LIST_HEAD(&ls->ls_perfile);
203         spin_lock_init(&ls->ls_lock);
204         INIT_LIST_HEAD(&ls->ls_layouts);
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                 put_nfs4_file(fp);
217                 kmem_cache_free(nfs4_layout_stateid_cache, ls);
218                 return NULL;
219         }
220 
221         spin_lock(&clp->cl_lock);
222         stp->sc_type = NFS4_LAYOUT_STID;
223         list_add(&ls->ls_perclnt, &clp->cl_lo_states);
224         spin_unlock(&clp->cl_lock);
225 
226         spin_lock(&fp->fi_lock);
227         list_add(&ls->ls_perfile, &fp->fi_lo_states);
228         spin_unlock(&fp->fi_lock);
229 
230         trace_layoutstate_alloc(&ls->ls_stid.sc_stateid);
231         return ls;
232 }
233 
234 __be32
235 nfsd4_preprocess_layout_stateid(struct svc_rqst *rqstp,
236                 struct nfsd4_compound_state *cstate, stateid_t *stateid,
237                 bool create, u32 layout_type, struct nfs4_layout_stateid **lsp)
238 {
239         struct nfs4_layout_stateid *ls;
240         struct nfs4_stid *stid;
241         unsigned char typemask = NFS4_LAYOUT_STID;
242         __be32 status;
243 
244         if (create)
245                 typemask |= (NFS4_OPEN_STID | NFS4_LOCK_STID | NFS4_DELEG_STID);
246 
247         status = nfsd4_lookup_stateid(cstate, stateid, typemask, &stid,
248                         net_generic(SVC_NET(rqstp), nfsd_net_id));
249         if (status)
250                 goto out;
251 
252         if (!fh_match(&cstate->current_fh.fh_handle,
253                       &stid->sc_file->fi_fhandle)) {
254                 status = nfserr_bad_stateid;
255                 goto out_put_stid;
256         }
257 
258         if (stid->sc_type != NFS4_LAYOUT_STID) {
259                 ls = nfsd4_alloc_layout_stateid(cstate, stid, layout_type);
260                 nfs4_put_stid(stid);
261 
262                 status = nfserr_jukebox;
263                 if (!ls)
264                         goto out;
265         } else {
266                 ls = container_of(stid, struct nfs4_layout_stateid, ls_stid);
267 
268                 status = nfserr_bad_stateid;
269                 if (stateid->si_generation > stid->sc_stateid.si_generation)
270                         goto out_put_stid;
271                 if (layout_type != ls->ls_layout_type)
272                         goto out_put_stid;
273         }
274 
275         *lsp = ls;
276         return 0;
277 
278 out_put_stid:
279         nfs4_put_stid(stid);
280 out:
281         return status;
282 }
283 
284 static void
285 nfsd4_recall_file_layout(struct nfs4_layout_stateid *ls)
286 {
287         spin_lock(&ls->ls_lock);
288         if (ls->ls_recalled)
289                 goto out_unlock;
290 
291         ls->ls_recalled = true;
292         atomic_inc(&ls->ls_stid.sc_file->fi_lo_recalls);
293         if (list_empty(&ls->ls_layouts))
294                 goto out_unlock;
295 
296         trace_layout_recall(&ls->ls_stid.sc_stateid);
297 
298         atomic_inc(&ls->ls_stid.sc_count);
299         update_stateid(&ls->ls_stid.sc_stateid);
300         memcpy(&ls->ls_recall_sid, &ls->ls_stid.sc_stateid, sizeof(stateid_t));
301         nfsd4_run_cb(&ls->ls_recall);
302 
303 out_unlock:
304         spin_unlock(&ls->ls_lock);
305 }
306 
307 static inline u64
308 layout_end(struct nfsd4_layout_seg *seg)
309 {
310         u64 end = seg->offset + seg->length;
311         return end >= seg->offset ? end : NFS4_MAX_UINT64;
312 }
313 
314 static void
315 layout_update_len(struct nfsd4_layout_seg *lo, u64 end)
316 {
317         if (end == NFS4_MAX_UINT64)
318                 lo->length = NFS4_MAX_UINT64;
319         else
320                 lo->length = end - lo->offset;
321 }
322 
323 static bool
324 layouts_overlapping(struct nfs4_layout *lo, struct nfsd4_layout_seg *s)
325 {
326         if (s->iomode != IOMODE_ANY && s->iomode != lo->lo_seg.iomode)
327                 return false;
328         if (layout_end(&lo->lo_seg) <= s->offset)
329                 return false;
330         if (layout_end(s) <= lo->lo_seg.offset)
331                 return false;
332         return true;
333 }
334 
335 static bool
336 layouts_try_merge(struct nfsd4_layout_seg *lo, struct nfsd4_layout_seg *new)
337 {
338         if (lo->iomode != new->iomode)
339                 return false;
340         if (layout_end(new) < lo->offset)
341                 return false;
342         if (layout_end(lo) < new->offset)
343                 return false;
344 
345         lo->offset = min(lo->offset, new->offset);
346         layout_update_len(lo, max(layout_end(lo), layout_end(new)));
347         return true;
348 }
349 
350 static __be32
351 nfsd4_recall_conflict(struct nfs4_layout_stateid *ls)
352 {
353         struct nfs4_file *fp = ls->ls_stid.sc_file;
354         struct nfs4_layout_stateid *l, *n;
355         __be32 nfserr = nfs_ok;
356 
357         assert_spin_locked(&fp->fi_lock);
358 
359         list_for_each_entry_safe(l, n, &fp->fi_lo_states, ls_perfile) {
360                 if (l != ls) {
361                         nfsd4_recall_file_layout(l);
362                         nfserr = nfserr_recallconflict;
363                 }
364         }
365 
366         return nfserr;
367 }
368 
369 __be32
370 nfsd4_insert_layout(struct nfsd4_layoutget *lgp, struct nfs4_layout_stateid *ls)
371 {
372         struct nfsd4_layout_seg *seg = &lgp->lg_seg;
373         struct nfs4_file *fp = ls->ls_stid.sc_file;
374         struct nfs4_layout *lp, *new = NULL;
375         __be32 nfserr;
376 
377         spin_lock(&fp->fi_lock);
378         nfserr = nfsd4_recall_conflict(ls);
379         if (nfserr)
380                 goto out;
381         spin_lock(&ls->ls_lock);
382         list_for_each_entry(lp, &ls->ls_layouts, lo_perstate) {
383                 if (layouts_try_merge(&lp->lo_seg, seg))
384                         goto done;
385         }
386         spin_unlock(&ls->ls_lock);
387         spin_unlock(&fp->fi_lock);
388 
389         new = kmem_cache_alloc(nfs4_layout_cache, GFP_KERNEL);
390         if (!new)
391                 return nfserr_jukebox;
392         memcpy(&new->lo_seg, seg, sizeof(lp->lo_seg));
393         new->lo_state = ls;
394 
395         spin_lock(&fp->fi_lock);
396         nfserr = nfsd4_recall_conflict(ls);
397         if (nfserr)
398                 goto out;
399         spin_lock(&ls->ls_lock);
400         list_for_each_entry(lp, &ls->ls_layouts, lo_perstate) {
401                 if (layouts_try_merge(&lp->lo_seg, seg))
402                         goto done;
403         }
404 
405         atomic_inc(&ls->ls_stid.sc_count);
406         list_add_tail(&new->lo_perstate, &ls->ls_layouts);
407         new = NULL;
408 done:
409         update_stateid(&ls->ls_stid.sc_stateid);
410         memcpy(&lgp->lg_sid, &ls->ls_stid.sc_stateid, sizeof(stateid_t));
411         spin_unlock(&ls->ls_lock);
412 out:
413         spin_unlock(&fp->fi_lock);
414         if (new)
415                 kmem_cache_free(nfs4_layout_cache, new);
416         return nfserr;
417 }
418 
419 static void
420 nfsd4_free_layouts(struct list_head *reaplist)
421 {
422         while (!list_empty(reaplist)) {
423                 struct nfs4_layout *lp = list_first_entry(reaplist,
424                                 struct nfs4_layout, lo_perstate);
425 
426                 list_del(&lp->lo_perstate);
427                 nfs4_put_stid(&lp->lo_state->ls_stid);
428                 kmem_cache_free(nfs4_layout_cache, lp);
429         }
430 }
431 
432 static void
433 nfsd4_return_file_layout(struct nfs4_layout *lp, struct nfsd4_layout_seg *seg,
434                 struct list_head *reaplist)
435 {
436         struct nfsd4_layout_seg *lo = &lp->lo_seg;
437         u64 end = layout_end(lo);
438 
439         if (seg->offset <= lo->offset) {
440                 if (layout_end(seg) >= end) {
441                         list_move_tail(&lp->lo_perstate, reaplist);
442                         return;
443                 }
444                 lo->offset = layout_end(seg);
445         } else {
446                 /* retain the whole layout segment on a split. */
447                 if (layout_end(seg) < end) {
448                         dprintk("%s: split not supported\n", __func__);
449                         return;
450                 }
451                 end = seg->offset;
452         }
453 
454         layout_update_len(lo, end);
455 }
456 
457 __be32
458 nfsd4_return_file_layouts(struct svc_rqst *rqstp,
459                 struct nfsd4_compound_state *cstate,
460                 struct nfsd4_layoutreturn *lrp)
461 {
462         struct nfs4_layout_stateid *ls;
463         struct nfs4_layout *lp, *n;
464         LIST_HEAD(reaplist);
465         __be32 nfserr;
466         int found = 0;
467 
468         nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lrp->lr_sid,
469                                                 false, lrp->lr_layout_type,
470                                                 &ls);
471         if (nfserr) {
472                 trace_layout_return_lookup_fail(&lrp->lr_sid);
473                 return nfserr;
474         }
475 
476         spin_lock(&ls->ls_lock);
477         list_for_each_entry_safe(lp, n, &ls->ls_layouts, lo_perstate) {
478                 if (layouts_overlapping(lp, &lrp->lr_seg)) {
479                         nfsd4_return_file_layout(lp, &lrp->lr_seg, &reaplist);
480                         found++;
481                 }
482         }
483         if (!list_empty(&ls->ls_layouts)) {
484                 if (found) {
485                         update_stateid(&ls->ls_stid.sc_stateid);
486                         memcpy(&lrp->lr_sid, &ls->ls_stid.sc_stateid,
487                                 sizeof(stateid_t));
488                 }
489                 lrp->lrs_present = 1;
490         } else {
491                 trace_layoutstate_unhash(&ls->ls_stid.sc_stateid);
492                 nfs4_unhash_stid(&ls->ls_stid);
493                 lrp->lrs_present = 0;
494         }
495         spin_unlock(&ls->ls_lock);
496 
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 int
612 nfsd4_cb_layout_done(struct nfsd4_callback *cb, struct rpc_task *task)
613 {
614         struct nfs4_layout_stateid *ls =
615                 container_of(cb, struct nfs4_layout_stateid, ls_recall);
616         LIST_HEAD(reaplist);
617 
618         switch (task->tk_status) {
619         case 0:
620                 return 1;
621         case -NFS4ERR_NOMATCHING_LAYOUT:
622                 trace_layout_recall_done(&ls->ls_stid.sc_stateid);
623                 task->tk_status = 0;
624                 return 1;
625         case -NFS4ERR_DELAY:
626                 /* Poll the client until it's done with the layout */
627                 /* FIXME: cap number of retries.
628                  * The pnfs standard states that we need to only expire
629                  * the client after at-least "lease time" .eg lease-time * 2
630                  * when failing to communicate a recall
631                  */
632                 rpc_delay(task, HZ/100); /* 10 mili-seconds */
633                 return 0;
634         default:
635                 /*
636                  * Unknown error or non-responding client, we'll need to fence.
637                  */
638                 nfsd4_cb_layout_fail(ls);
639                 return -1;
640         }
641 }
642 
643 static void
644 nfsd4_cb_layout_release(struct nfsd4_callback *cb)
645 {
646         struct nfs4_layout_stateid *ls =
647                 container_of(cb, struct nfs4_layout_stateid, ls_recall);
648         LIST_HEAD(reaplist);
649 
650         trace_layout_recall_release(&ls->ls_stid.sc_stateid);
651 
652         nfsd4_return_all_layouts(ls, &reaplist);
653         nfsd4_free_layouts(&reaplist);
654         nfs4_put_stid(&ls->ls_stid);
655 }
656 
657 static struct nfsd4_callback_ops nfsd4_cb_layout_ops = {
658         .done           = nfsd4_cb_layout_done,
659         .release        = nfsd4_cb_layout_release,
660 };
661 
662 static bool
663 nfsd4_layout_lm_break(struct file_lock *fl)
664 {
665         /*
666          * We don't want the locks code to timeout the lease for us;
667          * we'll remove it ourself if a layout isn't returned
668          * in time:
669          */
670         fl->fl_break_time = 0;
671         nfsd4_recall_file_layout(fl->fl_owner);
672         return false;
673 }
674 
675 static int
676 nfsd4_layout_lm_change(struct file_lock *onlist, int arg,
677                 struct list_head *dispose)
678 {
679         BUG_ON(!(arg & F_UNLCK));
680         return lease_modify(onlist, arg, dispose);
681 }
682 
683 static const struct lock_manager_operations nfsd4_layouts_lm_ops = {
684         .lm_break       = nfsd4_layout_lm_break,
685         .lm_change      = nfsd4_layout_lm_change,
686 };
687 
688 int
689 nfsd4_init_pnfs(void)
690 {
691         int i;
692 
693         for (i = 0; i < DEVID_HASH_SIZE; i++)
694                 INIT_LIST_HEAD(&nfsd_devid_hash[i]);
695 
696         nfs4_layout_cache = kmem_cache_create("nfs4_layout",
697                         sizeof(struct nfs4_layout), 0, 0, NULL);
698         if (!nfs4_layout_cache)
699                 return -ENOMEM;
700 
701         nfs4_layout_stateid_cache = kmem_cache_create("nfs4_layout_stateid",
702                         sizeof(struct nfs4_layout_stateid), 0, 0, NULL);
703         if (!nfs4_layout_stateid_cache) {
704                 kmem_cache_destroy(nfs4_layout_cache);
705                 return -ENOMEM;
706         }
707         return 0;
708 }
709 
710 void
711 nfsd4_exit_pnfs(void)
712 {
713         int i;
714 
715         kmem_cache_destroy(nfs4_layout_cache);
716         kmem_cache_destroy(nfs4_layout_stateid_cache);
717 
718         for (i = 0; i < DEVID_HASH_SIZE; i++) {
719                 struct nfsd4_deviceid_map *map, *n;
720 
721                 list_for_each_entry_safe(map, n, &nfsd_devid_hash[i], hash)
722                         kfree(map);
723         }
724 }
725 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp