1
2
3
4
5
6
7
8
9
10#include <linux/nfs_fs.h>
11#include <linux/vmalloc.h>
12#include <linux/module.h>
13#include <linux/sunrpc/addr.h>
14
15#include "../internal.h"
16#include "../nfs4session.h"
17#include "flexfilelayout.h"
18
19#define NFSDBG_FACILITY NFSDBG_PNFS_LD
20
21static unsigned int dataserver_timeo = NFS_DEF_TCP_RETRANS;
22static unsigned int dataserver_retrans;
23
24static bool ff_layout_has_available_ds(struct pnfs_layout_segment *lseg);
25
26void nfs4_ff_layout_put_deviceid(struct nfs4_ff_layout_ds *mirror_ds)
27{
28 if (!IS_ERR_OR_NULL(mirror_ds))
29 nfs4_put_deviceid_node(&mirror_ds->id_node);
30}
31
32void nfs4_ff_layout_free_deviceid(struct nfs4_ff_layout_ds *mirror_ds)
33{
34 nfs4_print_deviceid(&mirror_ds->id_node.deviceid);
35 nfs4_pnfs_ds_put(mirror_ds->ds);
36 kfree(mirror_ds->ds_versions);
37 kfree_rcu(mirror_ds, id_node.rcu);
38}
39
40
41struct nfs4_ff_layout_ds *
42nfs4_ff_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,
43 gfp_t gfp_flags)
44{
45 struct xdr_stream stream;
46 struct xdr_buf buf;
47 struct page *scratch;
48 struct list_head dsaddrs;
49 struct nfs4_pnfs_ds_addr *da;
50 struct nfs4_ff_layout_ds *new_ds = NULL;
51 struct nfs4_ff_ds_version *ds_versions = NULL;
52 u32 mp_count;
53 u32 version_count;
54 __be32 *p;
55 int i, ret = -ENOMEM;
56
57
58 scratch = alloc_page(gfp_flags);
59 if (!scratch)
60 goto out_err;
61
62 new_ds = kzalloc(sizeof(struct nfs4_ff_layout_ds), gfp_flags);
63 if (!new_ds)
64 goto out_scratch;
65
66 nfs4_init_deviceid_node(&new_ds->id_node,
67 server,
68 &pdev->dev_id);
69 INIT_LIST_HEAD(&dsaddrs);
70
71 xdr_init_decode_pages(&stream, &buf, pdev->pages, pdev->pglen);
72 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
73
74
75 p = xdr_inline_decode(&stream, 4);
76 if (unlikely(!p))
77 goto out_err_drain_dsaddrs;
78 mp_count = be32_to_cpup(p);
79 dprintk("%s: multipath ds count %d\n", __func__, mp_count);
80
81 for (i = 0; i < mp_count; i++) {
82
83 da = nfs4_decode_mp_ds_addr(server->nfs_client->cl_net,
84 &stream, gfp_flags);
85 if (da)
86 list_add_tail(&da->da_node, &dsaddrs);
87 }
88 if (list_empty(&dsaddrs)) {
89 dprintk("%s: no suitable DS addresses found\n",
90 __func__);
91 ret = -ENOMEDIUM;
92 goto out_err_drain_dsaddrs;
93 }
94
95
96 p = xdr_inline_decode(&stream, 4);
97 if (unlikely(!p))
98 goto out_err_drain_dsaddrs;
99 version_count = be32_to_cpup(p);
100 dprintk("%s: version count %d\n", __func__, version_count);
101
102 ds_versions = kcalloc(version_count,
103 sizeof(struct nfs4_ff_ds_version),
104 gfp_flags);
105 if (!ds_versions)
106 goto out_scratch;
107
108 for (i = 0; i < version_count; i++) {
109
110
111 p = xdr_inline_decode(&stream, 20);
112 if (unlikely(!p))
113 goto out_err_drain_dsaddrs;
114 ds_versions[i].version = be32_to_cpup(p++);
115 ds_versions[i].minor_version = be32_to_cpup(p++);
116 ds_versions[i].rsize = nfs_block_size(be32_to_cpup(p++), NULL);
117 ds_versions[i].wsize = nfs_block_size(be32_to_cpup(p++), NULL);
118 ds_versions[i].tightly_coupled = be32_to_cpup(p);
119
120 if (ds_versions[i].rsize > NFS_MAX_FILE_IO_SIZE)
121 ds_versions[i].rsize = NFS_MAX_FILE_IO_SIZE;
122 if (ds_versions[i].wsize > NFS_MAX_FILE_IO_SIZE)
123 ds_versions[i].wsize = NFS_MAX_FILE_IO_SIZE;
124
125
126
127
128
129
130 if (!((ds_versions[i].version == 3 && ds_versions[i].minor_version == 0) ||
131 (ds_versions[i].version == 4 && ds_versions[i].minor_version < 3))) {
132 dprintk("%s: [%d] unsupported ds version %d-%d\n", __func__,
133 i, ds_versions[i].version,
134 ds_versions[i].minor_version);
135 ret = -EPROTONOSUPPORT;
136 goto out_err_drain_dsaddrs;
137 }
138
139 dprintk("%s: [%d] vers %u minor_ver %u rsize %u wsize %u coupled %d\n",
140 __func__, i, ds_versions[i].version,
141 ds_versions[i].minor_version,
142 ds_versions[i].rsize,
143 ds_versions[i].wsize,
144 ds_versions[i].tightly_coupled);
145 }
146
147 new_ds->ds_versions = ds_versions;
148 new_ds->ds_versions_cnt = version_count;
149
150 new_ds->ds = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags);
151 if (!new_ds->ds)
152 goto out_err_drain_dsaddrs;
153
154
155 while (!list_empty(&dsaddrs)) {
156 da = list_first_entry(&dsaddrs,
157 struct nfs4_pnfs_ds_addr,
158 da_node);
159 list_del_init(&da->da_node);
160 kfree(da->da_remotestr);
161 kfree(da);
162 }
163
164 __free_page(scratch);
165 return new_ds;
166
167out_err_drain_dsaddrs:
168 while (!list_empty(&dsaddrs)) {
169 da = list_first_entry(&dsaddrs, struct nfs4_pnfs_ds_addr,
170 da_node);
171 list_del_init(&da->da_node);
172 kfree(da->da_remotestr);
173 kfree(da);
174 }
175
176 kfree(ds_versions);
177out_scratch:
178 __free_page(scratch);
179out_err:
180 kfree(new_ds);
181
182 dprintk("%s ERROR: returning %d\n", __func__, ret);
183 return NULL;
184}
185
186static void ff_layout_mark_devid_invalid(struct pnfs_layout_segment *lseg,
187 struct nfs4_deviceid_node *devid)
188{
189 nfs4_delete_deviceid(devid->ld, devid->nfs_client, &devid->deviceid);
190 if (!ff_layout_has_available_ds(lseg))
191 pnfs_error_mark_layout_for_return(lseg->pls_layout->plh_inode,
192 lseg);
193}
194
195static bool ff_layout_mirror_valid(struct pnfs_layout_segment *lseg,
196 struct nfs4_ff_layout_mirror *mirror,
197 bool create)
198{
199 if (mirror == NULL || IS_ERR(mirror->mirror_ds))
200 goto outerr;
201 if (mirror->mirror_ds == NULL) {
202 if (create) {
203 struct nfs4_deviceid_node *node;
204 struct pnfs_layout_hdr *lh = lseg->pls_layout;
205 struct nfs4_ff_layout_ds *mirror_ds = ERR_PTR(-ENODEV);
206
207 node = nfs4_find_get_deviceid(NFS_SERVER(lh->plh_inode),
208 &mirror->devid, lh->plh_lc_cred,
209 GFP_KERNEL);
210 if (node)
211 mirror_ds = FF_LAYOUT_MIRROR_DS(node);
212
213
214 if (cmpxchg(&mirror->mirror_ds, NULL, mirror_ds) &&
215 mirror_ds != ERR_PTR(-ENODEV))
216 nfs4_put_deviceid_node(node);
217 } else
218 goto outerr;
219 }
220
221 if (IS_ERR(mirror->mirror_ds))
222 goto outerr;
223
224 if (mirror->mirror_ds->ds == NULL) {
225 struct nfs4_deviceid_node *devid;
226 devid = &mirror->mirror_ds->id_node;
227 ff_layout_mark_devid_invalid(lseg, devid);
228 return false;
229 }
230 return true;
231outerr:
232 pnfs_error_mark_layout_for_return(lseg->pls_layout->plh_inode, lseg);
233 return false;
234}
235
236static void extend_ds_error(struct nfs4_ff_layout_ds_err *err,
237 u64 offset, u64 length)
238{
239 u64 end;
240
241 end = max_t(u64, pnfs_end_offset(err->offset, err->length),
242 pnfs_end_offset(offset, length));
243 err->offset = min_t(u64, err->offset, offset);
244 err->length = end - err->offset;
245}
246
247static int
248ff_ds_error_match(const struct nfs4_ff_layout_ds_err *e1,
249 const struct nfs4_ff_layout_ds_err *e2)
250{
251 int ret;
252
253 if (e1->opnum != e2->opnum)
254 return e1->opnum < e2->opnum ? -1 : 1;
255 if (e1->status != e2->status)
256 return e1->status < e2->status ? -1 : 1;
257 ret = memcmp(e1->stateid.data, e2->stateid.data,
258 sizeof(e1->stateid.data));
259 if (ret != 0)
260 return ret;
261 ret = memcmp(&e1->deviceid, &e2->deviceid, sizeof(e1->deviceid));
262 if (ret != 0)
263 return ret;
264 if (pnfs_end_offset(e1->offset, e1->length) < e2->offset)
265 return -1;
266 if (e1->offset > pnfs_end_offset(e2->offset, e2->length))
267 return 1;
268
269 return 0;
270}
271
272static void
273ff_layout_add_ds_error_locked(struct nfs4_flexfile_layout *flo,
274 struct nfs4_ff_layout_ds_err *dserr)
275{
276 struct nfs4_ff_layout_ds_err *err, *tmp;
277 struct list_head *head = &flo->error_list;
278 int match;
279
280
281 list_for_each_entry_safe(err, tmp, &flo->error_list, list) {
282 match = ff_ds_error_match(err, dserr);
283 if (match < 0)
284 continue;
285 if (match > 0) {
286
287 head = &err->list;
288 break;
289 }
290
291 extend_ds_error(dserr, err->offset, err->length);
292 list_replace(&err->list, &dserr->list);
293 kfree(err);
294 return;
295 }
296
297 list_add_tail(&dserr->list, head);
298}
299
300int ff_layout_track_ds_error(struct nfs4_flexfile_layout *flo,
301 struct nfs4_ff_layout_mirror *mirror, u64 offset,
302 u64 length, int status, enum nfs_opnum4 opnum,
303 gfp_t gfp_flags)
304{
305 struct nfs4_ff_layout_ds_err *dserr;
306
307 if (status == 0)
308 return 0;
309
310 if (mirror->mirror_ds == NULL)
311 return -EINVAL;
312
313 dserr = kmalloc(sizeof(*dserr), gfp_flags);
314 if (!dserr)
315 return -ENOMEM;
316
317 INIT_LIST_HEAD(&dserr->list);
318 dserr->offset = offset;
319 dserr->length = length;
320 dserr->status = status;
321 dserr->opnum = opnum;
322 nfs4_stateid_copy(&dserr->stateid, &mirror->stateid);
323 memcpy(&dserr->deviceid, &mirror->mirror_ds->id_node.deviceid,
324 NFS4_DEVICEID4_SIZE);
325
326 spin_lock(&flo->generic_hdr.plh_inode->i_lock);
327 ff_layout_add_ds_error_locked(flo, dserr);
328 spin_unlock(&flo->generic_hdr.plh_inode->i_lock);
329
330 return 0;
331}
332
333static struct rpc_cred *
334ff_layout_get_mirror_cred(struct nfs4_ff_layout_mirror *mirror, u32 iomode)
335{
336 struct rpc_cred *cred, __rcu **pcred;
337
338 if (iomode == IOMODE_READ)
339 pcred = &mirror->ro_cred;
340 else
341 pcred = &mirror->rw_cred;
342
343 rcu_read_lock();
344 do {
345 cred = rcu_dereference(*pcred);
346 if (!cred)
347 break;
348
349 cred = get_rpccred_rcu(cred);
350 } while(!cred);
351 rcu_read_unlock();
352 return cred;
353}
354
355struct nfs_fh *
356nfs4_ff_layout_select_ds_fh(struct pnfs_layout_segment *lseg, u32 mirror_idx)
357{
358 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, mirror_idx);
359 struct nfs_fh *fh = NULL;
360
361 if (!ff_layout_mirror_valid(lseg, mirror, false)) {
362 pr_err_ratelimited("NFS: %s: No data server for mirror offset index %d\n",
363 __func__, mirror_idx);
364 goto out;
365 }
366
367
368 fh = &mirror->fh_versions[0];
369out:
370 return fh;
371}
372
373int
374nfs4_ff_layout_select_ds_stateid(struct pnfs_layout_segment *lseg,
375 u32 mirror_idx,
376 nfs4_stateid *stateid)
377{
378 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, mirror_idx);
379
380 if (!ff_layout_mirror_valid(lseg, mirror, false)) {
381 pr_err_ratelimited("NFS: %s: No data server for mirror offset index %d\n",
382 __func__, mirror_idx);
383 goto out;
384 }
385
386 nfs4_stateid_copy(stateid, &mirror->stateid);
387 return 1;
388out:
389 return 0;
390}
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409struct nfs4_pnfs_ds *
410nfs4_ff_layout_prepare_ds(struct pnfs_layout_segment *lseg, u32 ds_idx,
411 bool fail_return)
412{
413 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
414 struct nfs4_pnfs_ds *ds = NULL;
415 struct nfs4_deviceid_node *devid;
416 struct inode *ino = lseg->pls_layout->plh_inode;
417 struct nfs_server *s = NFS_SERVER(ino);
418 unsigned int max_payload;
419 int status;
420
421 if (!ff_layout_mirror_valid(lseg, mirror, true)) {
422 pr_err_ratelimited("NFS: %s: No data server for offset index %d\n",
423 __func__, ds_idx);
424 goto out;
425 }
426
427 devid = &mirror->mirror_ds->id_node;
428 if (ff_layout_test_devid_unavailable(devid))
429 goto out_fail;
430
431 ds = mirror->mirror_ds->ds;
432
433 smp_rmb();
434 if (ds->ds_clp)
435 goto out;
436
437
438
439
440 status = nfs4_pnfs_ds_connect(s, ds, devid, dataserver_timeo,
441 dataserver_retrans,
442 mirror->mirror_ds->ds_versions[0].version,
443 mirror->mirror_ds->ds_versions[0].minor_version);
444
445
446 if (!status) {
447 max_payload =
448 nfs_block_size(rpc_max_payload(ds->ds_clp->cl_rpcclient),
449 NULL);
450 if (mirror->mirror_ds->ds_versions[0].rsize > max_payload)
451 mirror->mirror_ds->ds_versions[0].rsize = max_payload;
452 if (mirror->mirror_ds->ds_versions[0].wsize > max_payload)
453 mirror->mirror_ds->ds_versions[0].wsize = max_payload;
454 goto out;
455 }
456out_fail:
457 ff_layout_track_ds_error(FF_LAYOUT_FROM_HDR(lseg->pls_layout),
458 mirror, lseg->pls_range.offset,
459 lseg->pls_range.length, NFS4ERR_NXIO,
460 OP_ILLEGAL, GFP_NOIO);
461 if (fail_return || !ff_layout_has_available_ds(lseg))
462 pnfs_error_mark_layout_for_return(ino, lseg);
463 ds = NULL;
464out:
465 return ds;
466}
467
468struct rpc_cred *
469ff_layout_get_ds_cred(struct pnfs_layout_segment *lseg, u32 ds_idx,
470 struct rpc_cred *mdscred)
471{
472 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
473 struct rpc_cred *cred;
474
475 if (mirror && !mirror->mirror_ds->ds_versions[0].tightly_coupled) {
476 cred = ff_layout_get_mirror_cred(mirror, lseg->pls_range.iomode);
477 if (!cred)
478 cred = get_rpccred(mdscred);
479 } else {
480 cred = get_rpccred(mdscred);
481 }
482 return cred;
483}
484
485
486
487
488
489struct rpc_clnt *
490nfs4_ff_find_or_create_ds_client(struct pnfs_layout_segment *lseg, u32 ds_idx,
491 struct nfs_client *ds_clp, struct inode *inode)
492{
493 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
494
495 switch (mirror->mirror_ds->ds_versions[0].version) {
496 case 3:
497
498 return ds_clp->cl_rpcclient;
499 case 4:
500 return nfs4_find_or_create_ds_client(ds_clp, inode);
501 default:
502 BUG();
503 }
504}
505
506void ff_layout_free_ds_ioerr(struct list_head *head)
507{
508 struct nfs4_ff_layout_ds_err *err;
509
510 while (!list_empty(head)) {
511 err = list_first_entry(head,
512 struct nfs4_ff_layout_ds_err,
513 list);
514 list_del(&err->list);
515 kfree(err);
516 }
517}
518
519
520int ff_layout_encode_ds_ioerr(struct xdr_stream *xdr, const struct list_head *head)
521{
522 struct nfs4_ff_layout_ds_err *err;
523 __be32 *p;
524
525 list_for_each_entry(err, head, list) {
526
527
528
529
530 p = xdr_reserve_space(xdr,
531 28 + NFS4_STATEID_SIZE + NFS4_DEVICEID4_SIZE);
532 if (unlikely(!p))
533 return -ENOBUFS;
534 p = xdr_encode_hyper(p, err->offset);
535 p = xdr_encode_hyper(p, err->length);
536 p = xdr_encode_opaque_fixed(p, &err->stateid,
537 NFS4_STATEID_SIZE);
538
539 *p++ = cpu_to_be32(1);
540 p = xdr_encode_opaque_fixed(p, &err->deviceid,
541 NFS4_DEVICEID4_SIZE);
542 *p++ = cpu_to_be32(err->status);
543 *p++ = cpu_to_be32(err->opnum);
544 dprintk("%s: offset %llu length %llu status %d op %d\n",
545 __func__, err->offset, err->length, err->status,
546 err->opnum);
547 }
548
549 return 0;
550}
551
552static
553unsigned int do_layout_fetch_ds_ioerr(struct pnfs_layout_hdr *lo,
554 const struct pnfs_layout_range *range,
555 struct list_head *head,
556 unsigned int maxnum)
557{
558 struct nfs4_flexfile_layout *flo = FF_LAYOUT_FROM_HDR(lo);
559 struct inode *inode = lo->plh_inode;
560 struct nfs4_ff_layout_ds_err *err, *n;
561 unsigned int ret = 0;
562
563 spin_lock(&inode->i_lock);
564 list_for_each_entry_safe(err, n, &flo->error_list, list) {
565 if (!pnfs_is_range_intersecting(err->offset,
566 pnfs_end_offset(err->offset, err->length),
567 range->offset,
568 pnfs_end_offset(range->offset, range->length)))
569 continue;
570 if (!maxnum)
571 break;
572 list_move(&err->list, head);
573 maxnum--;
574 ret++;
575 }
576 spin_unlock(&inode->i_lock);
577 return ret;
578}
579
580unsigned int ff_layout_fetch_ds_ioerr(struct pnfs_layout_hdr *lo,
581 const struct pnfs_layout_range *range,
582 struct list_head *head,
583 unsigned int maxnum)
584{
585 unsigned int ret;
586
587 ret = do_layout_fetch_ds_ioerr(lo, range, head, maxnum);
588
589 if (ret == maxnum) {
590 LIST_HEAD(discard);
591 do_layout_fetch_ds_ioerr(lo, range, &discard, -1);
592 ff_layout_free_ds_ioerr(&discard);
593 }
594 return ret;
595}
596
597static bool ff_read_layout_has_available_ds(struct pnfs_layout_segment *lseg)
598{
599 struct nfs4_ff_layout_mirror *mirror;
600 struct nfs4_deviceid_node *devid;
601 u32 idx;
602
603 for (idx = 0; idx < FF_LAYOUT_MIRROR_COUNT(lseg); idx++) {
604 mirror = FF_LAYOUT_COMP(lseg, idx);
605 if (mirror) {
606 if (!mirror->mirror_ds)
607 return true;
608 if (IS_ERR(mirror->mirror_ds))
609 continue;
610 devid = &mirror->mirror_ds->id_node;
611 if (!ff_layout_test_devid_unavailable(devid))
612 return true;
613 }
614 }
615
616 return false;
617}
618
619static bool ff_rw_layout_has_available_ds(struct pnfs_layout_segment *lseg)
620{
621 struct nfs4_ff_layout_mirror *mirror;
622 struct nfs4_deviceid_node *devid;
623 u32 idx;
624
625 for (idx = 0; idx < FF_LAYOUT_MIRROR_COUNT(lseg); idx++) {
626 mirror = FF_LAYOUT_COMP(lseg, idx);
627 if (!mirror || IS_ERR(mirror->mirror_ds))
628 return false;
629 if (!mirror->mirror_ds)
630 continue;
631 devid = &mirror->mirror_ds->id_node;
632 if (ff_layout_test_devid_unavailable(devid))
633 return false;
634 }
635
636 return FF_LAYOUT_MIRROR_COUNT(lseg) != 0;
637}
638
639static bool ff_layout_has_available_ds(struct pnfs_layout_segment *lseg)
640{
641 if (lseg->pls_range.iomode == IOMODE_READ)
642 return ff_read_layout_has_available_ds(lseg);
643
644 return ff_rw_layout_has_available_ds(lseg);
645}
646
647bool ff_layout_avoid_mds_available_ds(struct pnfs_layout_segment *lseg)
648{
649 return ff_layout_no_fallback_to_mds(lseg) ||
650 ff_layout_has_available_ds(lseg);
651}
652
653bool ff_layout_avoid_read_on_rw(struct pnfs_layout_segment *lseg)
654{
655 return lseg->pls_range.iomode == IOMODE_RW &&
656 ff_layout_no_read_on_rw(lseg);
657}
658
659module_param(dataserver_retrans, uint, 0644);
660MODULE_PARM_DESC(dataserver_retrans, "The number of times the NFSv4.1 client "
661 "retries a request before it attempts further "
662 " recovery action.");
663module_param(dataserver_timeo, uint, 0644);
664MODULE_PARM_DESC(dataserver_timeo, "The time (in tenths of a second) the "
665 "NFSv4.1 client waits for a response from a "
666 " data server before it retries an NFS request.");
667
