2 * Device operations for the pnfs nfs4 file layout driver.
4 * Copyright (c) 2014, Primary Data, Inc. All rights reserved.
6 * Tao Peng <bergwolf@primarydata.com>
9 #include <linux/nfs_fs.h>
10 #include <linux/vmalloc.h>
11 #include <linux/module.h>
12 #include <linux/sunrpc/addr.h>
14 #include "../internal.h"
15 #include "../nfs4session.h"
16 #include "flexfilelayout.h"
18 #define NFSDBG_FACILITY NFSDBG_PNFS_LD
20 static unsigned int dataserver_timeo
= NFS4_DEF_DS_TIMEO
;
21 static unsigned int dataserver_retrans
= NFS4_DEF_DS_RETRANS
;
23 void nfs4_ff_layout_put_deviceid(struct nfs4_ff_layout_ds
*mirror_ds
)
26 nfs4_put_deviceid_node(&mirror_ds
->id_node
);
29 void nfs4_ff_layout_free_deviceid(struct nfs4_ff_layout_ds
*mirror_ds
)
31 nfs4_print_deviceid(&mirror_ds
->id_node
.deviceid
);
32 nfs4_pnfs_ds_put(mirror_ds
->ds
);
33 kfree_rcu(mirror_ds
, id_node
.rcu
);
36 /* Decode opaque device data and construct new_ds using it */
37 struct nfs4_ff_layout_ds
*
38 nfs4_ff_alloc_deviceid_node(struct nfs_server
*server
, struct pnfs_device
*pdev
,
41 struct xdr_stream stream
;
44 struct list_head dsaddrs
;
45 struct nfs4_pnfs_ds_addr
*da
;
46 struct nfs4_ff_layout_ds
*new_ds
= NULL
;
47 struct nfs4_ff_ds_version
*ds_versions
= NULL
;
53 /* set up xdr stream */
54 scratch
= alloc_page(gfp_flags
);
58 new_ds
= kzalloc(sizeof(struct nfs4_ff_layout_ds
), gfp_flags
);
62 nfs4_init_deviceid_node(&new_ds
->id_node
,
65 INIT_LIST_HEAD(&dsaddrs
);
67 xdr_init_decode_pages(&stream
, &buf
, pdev
->pages
, pdev
->pglen
);
68 xdr_set_scratch_buffer(&stream
, page_address(scratch
), PAGE_SIZE
);
71 p
= xdr_inline_decode(&stream
, 4);
73 goto out_err_drain_dsaddrs
;
74 mp_count
= be32_to_cpup(p
);
75 dprintk("%s: multipath ds count %d\n", __func__
, mp_count
);
77 for (i
= 0; i
< mp_count
; i
++) {
79 da
= nfs4_decode_mp_ds_addr(server
->nfs_client
->cl_net
,
82 list_add_tail(&da
->da_node
, &dsaddrs
);
84 if (list_empty(&dsaddrs
)) {
85 dprintk("%s: no suitable DS addresses found\n",
88 goto out_err_drain_dsaddrs
;
92 p
= xdr_inline_decode(&stream
, 4);
94 goto out_err_drain_dsaddrs
;
95 version_count
= be32_to_cpup(p
);
96 dprintk("%s: version count %d\n", __func__
, version_count
);
98 ds_versions
= kzalloc(version_count
* sizeof(struct nfs4_ff_ds_version
),
103 for (i
= 0; i
< version_count
; i
++) {
104 /* 20 = version(4) + minor_version(4) + rsize(4) + wsize(4) +
105 * tightly_coupled(4) */
106 p
= xdr_inline_decode(&stream
, 20);
108 goto out_err_drain_dsaddrs
;
109 ds_versions
[i
].version
= be32_to_cpup(p
++);
110 ds_versions
[i
].minor_version
= be32_to_cpup(p
++);
111 ds_versions
[i
].rsize
= nfs_block_size(be32_to_cpup(p
++), NULL
);
112 ds_versions
[i
].wsize
= nfs_block_size(be32_to_cpup(p
++), NULL
);
113 ds_versions
[i
].tightly_coupled
= be32_to_cpup(p
);
115 if (ds_versions
[i
].rsize
> NFS_MAX_FILE_IO_SIZE
)
116 ds_versions
[i
].rsize
= NFS_MAX_FILE_IO_SIZE
;
117 if (ds_versions
[i
].wsize
> NFS_MAX_FILE_IO_SIZE
)
118 ds_versions
[i
].wsize
= NFS_MAX_FILE_IO_SIZE
;
120 if (ds_versions
[i
].version
!= 3 || ds_versions
[i
].minor_version
!= 0) {
121 dprintk("%s: [%d] unsupported ds version %d-%d\n", __func__
,
122 i
, ds_versions
[i
].version
,
123 ds_versions
[i
].minor_version
);
124 ret
= -EPROTONOSUPPORT
;
125 goto out_err_drain_dsaddrs
;
128 dprintk("%s: [%d] vers %u minor_ver %u rsize %u wsize %u coupled %d\n",
129 __func__
, i
, ds_versions
[i
].version
,
130 ds_versions
[i
].minor_version
,
131 ds_versions
[i
].rsize
,
132 ds_versions
[i
].wsize
,
133 ds_versions
[i
].tightly_coupled
);
136 new_ds
->ds_versions
= ds_versions
;
137 new_ds
->ds_versions_cnt
= version_count
;
139 new_ds
->ds
= nfs4_pnfs_ds_add(&dsaddrs
, gfp_flags
);
141 goto out_err_drain_dsaddrs
;
143 /* If DS was already in cache, free ds addrs */
144 while (!list_empty(&dsaddrs
)) {
145 da
= list_first_entry(&dsaddrs
,
146 struct nfs4_pnfs_ds_addr
,
148 list_del_init(&da
->da_node
);
149 kfree(da
->da_remotestr
);
153 __free_page(scratch
);
156 out_err_drain_dsaddrs
:
157 while (!list_empty(&dsaddrs
)) {
158 da
= list_first_entry(&dsaddrs
, struct nfs4_pnfs_ds_addr
,
160 list_del_init(&da
->da_node
);
161 kfree(da
->da_remotestr
);
167 __free_page(scratch
);
171 dprintk("%s ERROR: returning %d\n", __func__
, ret
);
175 static void ff_layout_mark_devid_invalid(struct pnfs_layout_segment
*lseg
,
176 struct nfs4_deviceid_node
*devid
)
178 nfs4_mark_deviceid_unavailable(devid
);
179 if (!ff_layout_has_available_ds(lseg
))
180 pnfs_error_mark_layout_for_return(lseg
->pls_layout
->plh_inode
,
184 static bool ff_layout_mirror_valid(struct pnfs_layout_segment
*lseg
,
185 struct nfs4_ff_layout_mirror
*mirror
)
187 if (mirror
== NULL
|| mirror
->mirror_ds
== NULL
) {
188 pnfs_error_mark_layout_for_return(lseg
->pls_layout
->plh_inode
,
192 if (mirror
->mirror_ds
->ds
== NULL
) {
193 struct nfs4_deviceid_node
*devid
;
194 devid
= &mirror
->mirror_ds
->id_node
;
195 ff_layout_mark_devid_invalid(lseg
, devid
);
202 end_offset(u64 start
, u64 len
)
207 return end
>= start
? end
: NFS4_MAX_UINT64
;
210 static void extend_ds_error(struct nfs4_ff_layout_ds_err
*err
,
211 u64 offset
, u64 length
)
215 end
= max_t(u64
, end_offset(err
->offset
, err
->length
),
216 end_offset(offset
, length
));
217 err
->offset
= min_t(u64
, err
->offset
, offset
);
218 err
->length
= end
- err
->offset
;
222 ff_ds_error_match(const struct nfs4_ff_layout_ds_err
*e1
,
223 const struct nfs4_ff_layout_ds_err
*e2
)
227 if (e1
->opnum
!= e2
->opnum
)
228 return e1
->opnum
< e2
->opnum
? -1 : 1;
229 if (e1
->status
!= e2
->status
)
230 return e1
->status
< e2
->status
? -1 : 1;
231 ret
= memcmp(&e1
->stateid
, &e2
->stateid
, sizeof(e1
->stateid
));
234 ret
= memcmp(&e1
->deviceid
, &e2
->deviceid
, sizeof(e1
->deviceid
));
237 if (end_offset(e1
->offset
, e1
->length
) < e2
->offset
)
239 if (e1
->offset
> end_offset(e2
->offset
, e2
->length
))
241 /* If ranges overlap or are contiguous, they are the same */
246 ff_layout_add_ds_error_locked(struct nfs4_flexfile_layout
*flo
,
247 struct nfs4_ff_layout_ds_err
*dserr
)
249 struct nfs4_ff_layout_ds_err
*err
, *tmp
;
250 struct list_head
*head
= &flo
->error_list
;
253 /* Do insertion sort w/ merges */
254 list_for_each_entry_safe(err
, tmp
, &flo
->error_list
, list
) {
255 match
= ff_ds_error_match(err
, dserr
);
259 /* Add entry "dserr" _before_ entry "err" */
263 /* Entries match, so merge "err" into "dserr" */
264 extend_ds_error(dserr
, err
->offset
, err
->length
);
265 list_del(&err
->list
);
269 list_add_tail(&dserr
->list
, head
);
272 int ff_layout_track_ds_error(struct nfs4_flexfile_layout
*flo
,
273 struct nfs4_ff_layout_mirror
*mirror
, u64 offset
,
274 u64 length
, int status
, enum nfs_opnum4 opnum
,
277 struct nfs4_ff_layout_ds_err
*dserr
;
282 if (mirror
->mirror_ds
== NULL
)
285 dserr
= kmalloc(sizeof(*dserr
), gfp_flags
);
289 INIT_LIST_HEAD(&dserr
->list
);
290 dserr
->offset
= offset
;
291 dserr
->length
= length
;
292 dserr
->status
= status
;
293 dserr
->opnum
= opnum
;
294 nfs4_stateid_copy(&dserr
->stateid
, &mirror
->stateid
);
295 memcpy(&dserr
->deviceid
, &mirror
->mirror_ds
->id_node
.deviceid
,
296 NFS4_DEVICEID4_SIZE
);
298 spin_lock(&flo
->generic_hdr
.plh_inode
->i_lock
);
299 ff_layout_add_ds_error_locked(flo
, dserr
);
300 spin_unlock(&flo
->generic_hdr
.plh_inode
->i_lock
);
305 /* currently we only support AUTH_NONE and AUTH_SYS */
306 static rpc_authflavor_t
307 nfs4_ff_layout_choose_authflavor(struct nfs4_ff_layout_mirror
*mirror
)
309 if (mirror
->uid
== (u32
)-1)
310 return RPC_AUTH_NULL
;
311 return RPC_AUTH_UNIX
;
314 /* fetch cred for NFSv3 DS */
315 static int ff_layout_update_mirror_cred(struct nfs4_ff_layout_mirror
*mirror
,
316 struct nfs4_pnfs_ds
*ds
)
318 if (ds
->ds_clp
&& !mirror
->cred
&&
319 mirror
->mirror_ds
->ds_versions
[0].version
== 3) {
320 struct rpc_auth
*auth
= ds
->ds_clp
->cl_rpcclient
->cl_auth
;
321 struct rpc_cred
*cred
;
322 struct auth_cred acred
= {
323 .uid
= make_kuid(&init_user_ns
, mirror
->uid
),
324 .gid
= make_kgid(&init_user_ns
, mirror
->gid
),
327 /* AUTH_NULL ignores acred */
328 cred
= auth
->au_ops
->lookup_cred(auth
, &acred
, 0);
330 dprintk("%s: lookup_cred failed with %ld\n",
331 __func__
, PTR_ERR(cred
));
332 return PTR_ERR(cred
);
334 if (cmpxchg(&mirror
->cred
, NULL
, cred
))
342 nfs4_ff_layout_select_ds_fh(struct pnfs_layout_segment
*lseg
, u32 mirror_idx
)
344 struct nfs4_ff_layout_mirror
*mirror
= FF_LAYOUT_COMP(lseg
, mirror_idx
);
345 struct nfs_fh
*fh
= NULL
;
347 if (!ff_layout_mirror_valid(lseg
, mirror
)) {
348 pr_err_ratelimited("NFS: %s: No data server for mirror offset index %d\n",
349 __func__
, mirror_idx
);
353 /* FIXME: For now assume there is only 1 version available for the DS */
354 fh
= &mirror
->fh_versions
[0];
359 /* Upon return, either ds is connected, or ds is NULL */
360 struct nfs4_pnfs_ds
*
361 nfs4_ff_layout_prepare_ds(struct pnfs_layout_segment
*lseg
, u32 ds_idx
,
364 struct nfs4_ff_layout_mirror
*mirror
= FF_LAYOUT_COMP(lseg
, ds_idx
);
365 struct nfs4_pnfs_ds
*ds
= NULL
;
366 struct nfs4_deviceid_node
*devid
;
367 struct inode
*ino
= lseg
->pls_layout
->plh_inode
;
368 struct nfs_server
*s
= NFS_SERVER(ino
);
369 unsigned int max_payload
;
370 rpc_authflavor_t flavor
;
372 if (!ff_layout_mirror_valid(lseg
, mirror
)) {
373 pr_err_ratelimited("NFS: %s: No data server for offset index %d\n",
378 devid
= &mirror
->mirror_ds
->id_node
;
379 if (ff_layout_test_devid_unavailable(devid
))
382 ds
= mirror
->mirror_ds
->ds
;
383 /* matching smp_wmb() in _nfs4_pnfs_v3/4_ds_connect */
386 goto out_update_creds
;
388 flavor
= nfs4_ff_layout_choose_authflavor(mirror
);
390 /* FIXME: For now we assume the server sent only one version of NFS
393 nfs4_pnfs_ds_connect(s
, ds
, devid
, dataserver_timeo
,
395 mirror
->mirror_ds
->ds_versions
[0].version
,
396 mirror
->mirror_ds
->ds_versions
[0].minor_version
,
399 /* connect success, check rsize/wsize limit */
402 nfs_block_size(rpc_max_payload(ds
->ds_clp
->cl_rpcclient
),
404 if (mirror
->mirror_ds
->ds_versions
[0].rsize
> max_payload
)
405 mirror
->mirror_ds
->ds_versions
[0].rsize
= max_payload
;
406 if (mirror
->mirror_ds
->ds_versions
[0].wsize
> max_payload
)
407 mirror
->mirror_ds
->ds_versions
[0].wsize
= max_payload
;
409 ff_layout_track_ds_error(FF_LAYOUT_FROM_HDR(lseg
->pls_layout
),
410 mirror
, lseg
->pls_range
.offset
,
411 lseg
->pls_range
.length
, NFS4ERR_NXIO
,
412 OP_ILLEGAL
, GFP_NOIO
);
414 if (ff_layout_has_available_ds(lseg
))
415 set_bit(NFS_LAYOUT_RETURN_REQUESTED
,
416 &lseg
->pls_layout
->plh_flags
);
418 pnfs_error_mark_layout_for_return(ino
, lseg
);
420 pnfs_error_mark_layout_for_return(ino
, lseg
);
425 if (ff_layout_update_mirror_cred(mirror
, ds
))
432 ff_layout_get_ds_cred(struct pnfs_layout_segment
*lseg
, u32 ds_idx
,
433 struct rpc_cred
*mdscred
)
435 struct nfs4_ff_layout_mirror
*mirror
= FF_LAYOUT_COMP(lseg
, ds_idx
);
436 struct rpc_cred
*cred
= ERR_PTR(-EINVAL
);
438 if (!nfs4_ff_layout_prepare_ds(lseg
, ds_idx
, true))
441 if (mirror
&& mirror
->cred
)
450 * Find or create a DS rpc client with th MDS server rpc client auth flavor
451 * in the nfs_client cl_ds_clients list.
454 nfs4_ff_find_or_create_ds_client(struct pnfs_layout_segment
*lseg
, u32 ds_idx
,
455 struct nfs_client
*ds_clp
, struct inode
*inode
)
457 struct nfs4_ff_layout_mirror
*mirror
= FF_LAYOUT_COMP(lseg
, ds_idx
);
459 switch (mirror
->mirror_ds
->ds_versions
[0].version
) {
461 /* For NFSv3 DS, flavor is set when creating DS connections */
462 return ds_clp
->cl_rpcclient
;
464 return nfs4_find_or_create_ds_client(ds_clp
, inode
);
470 static bool is_range_intersecting(u64 offset1
, u64 length1
,
471 u64 offset2
, u64 length2
)
473 u64 end1
= end_offset(offset1
, length1
);
474 u64 end2
= end_offset(offset2
, length2
);
476 return (end1
== NFS4_MAX_UINT64
|| end1
> offset2
) &&
477 (end2
== NFS4_MAX_UINT64
|| end2
> offset1
);
480 /* called with inode i_lock held */
481 int ff_layout_encode_ds_ioerr(struct nfs4_flexfile_layout
*flo
,
482 struct xdr_stream
*xdr
, int *count
,
483 const struct pnfs_layout_range
*range
)
485 struct nfs4_ff_layout_ds_err
*err
, *n
;
488 list_for_each_entry_safe(err
, n
, &flo
->error_list
, list
) {
489 if (!is_range_intersecting(err
->offset
, err
->length
,
490 range
->offset
, range
->length
))
492 /* offset(8) + length(8) + stateid(NFS4_STATEID_SIZE)
493 * + array length + deviceid(NFS4_DEVICEID4_SIZE)
494 * + status(4) + opnum(4)
496 p
= xdr_reserve_space(xdr
,
497 28 + NFS4_STATEID_SIZE
+ NFS4_DEVICEID4_SIZE
);
500 p
= xdr_encode_hyper(p
, err
->offset
);
501 p
= xdr_encode_hyper(p
, err
->length
);
502 p
= xdr_encode_opaque_fixed(p
, &err
->stateid
,
505 *p
++ = cpu_to_be32(1);
506 p
= xdr_encode_opaque_fixed(p
, &err
->deviceid
,
507 NFS4_DEVICEID4_SIZE
);
508 *p
++ = cpu_to_be32(err
->status
);
509 *p
++ = cpu_to_be32(err
->opnum
);
511 list_del(&err
->list
);
512 dprintk("%s: offset %llu length %llu status %d op %d count %d\n",
513 __func__
, err
->offset
, err
->length
, err
->status
,
521 static bool ff_read_layout_has_available_ds(struct pnfs_layout_segment
*lseg
)
523 struct nfs4_ff_layout_mirror
*mirror
;
524 struct nfs4_deviceid_node
*devid
;
527 for (idx
= 0; idx
< FF_LAYOUT_MIRROR_COUNT(lseg
); idx
++) {
528 mirror
= FF_LAYOUT_COMP(lseg
, idx
);
529 if (mirror
&& mirror
->mirror_ds
) {
530 devid
= &mirror
->mirror_ds
->id_node
;
531 if (!ff_layout_test_devid_unavailable(devid
))
539 static bool ff_rw_layout_has_available_ds(struct pnfs_layout_segment
*lseg
)
541 struct nfs4_ff_layout_mirror
*mirror
;
542 struct nfs4_deviceid_node
*devid
;
545 for (idx
= 0; idx
< FF_LAYOUT_MIRROR_COUNT(lseg
); idx
++) {
546 mirror
= FF_LAYOUT_COMP(lseg
, idx
);
547 if (!mirror
|| !mirror
->mirror_ds
)
549 devid
= &mirror
->mirror_ds
->id_node
;
550 if (ff_layout_test_devid_unavailable(devid
))
554 return FF_LAYOUT_MIRROR_COUNT(lseg
) != 0;
557 bool ff_layout_has_available_ds(struct pnfs_layout_segment
*lseg
)
559 if (lseg
->pls_range
.iomode
== IOMODE_READ
)
560 return ff_read_layout_has_available_ds(lseg
);
561 /* Note: RW layout needs all mirrors available */
562 return ff_rw_layout_has_available_ds(lseg
);
565 module_param(dataserver_retrans
, uint
, 0644);
566 MODULE_PARM_DESC(dataserver_retrans
, "The number of times the NFSv4.1 client "
567 "retries a request before it attempts further "
568 " recovery action.");
569 module_param(dataserver_timeo
, uint
, 0644);
570 MODULE_PARM_DESC(dataserver_timeo
, "The time (in tenths of a second) the "
571 "NFSv4.1 client waits for a response from a "
572 " data server before it retries an NFS request.");