2 * Module for the pnfs nfs4 file layout driver.
3 * Defines all I/O and Policy interface operations, plus code
4 * to register itself with the pNFS client.
7 * The Regents of the University of Michigan
10 * Dean Hildebrand <dhildebz@umich.edu>
12 * Permission is granted to use, copy, create derivative works, and
13 * redistribute this software and such derivative works for any purpose,
14 * so long as the name of the University of Michigan is not used in
15 * any advertising or publicity pertaining to the use or distribution
16 * of this software without specific, written prior authorization. If
17 * the above copyright notice or any other identification of the
18 * University of Michigan is included in any copy of any portion of
19 * this software, then the disclaimer below must also be included.
21 * This software is provided as is, without representation or warranty
22 * of any kind either express or implied, including without limitation
23 * the implied warranties of merchantability, fitness for a particular
24 * purpose, or noninfringement. The Regents of the University of
25 * Michigan shall not be liable for any damages, including special,
26 * indirect, incidental, or consequential damages, with respect to any
27 * claim arising out of or in connection with the use of the software,
28 * even if it has been or is hereafter advised of the possibility of
32 #include <linux/nfs_fs.h>
33 #include <linux/nfs_page.h>
34 #include <linux/module.h>
35 #include <linux/backing-dev.h>
37 #include <linux/sunrpc/metrics.h>
39 #include "../nfs4session.h"
40 #include "../internal.h"
41 #include "../delegation.h"
42 #include "filelayout.h"
43 #include "../nfs4trace.h"
45 #define NFSDBG_FACILITY NFSDBG_PNFS_LD
47 MODULE_LICENSE("GPL");
48 MODULE_AUTHOR("Dean Hildebrand <dhildebz@umich.edu>");
49 MODULE_DESCRIPTION("The NFSv4 file layout driver");
51 #define FILELAYOUT_POLL_RETRY_MAX (15*HZ)
54 filelayout_get_dense_offset(struct nfs4_filelayout_segment
*flseg
,
57 u32 stripe_width
= flseg
->stripe_unit
* flseg
->dsaddr
->stripe_count
;
61 offset
-= flseg
->pattern_offset
;
62 stripe_no
= div_u64(offset
, stripe_width
);
63 div_u64_rem(offset
, flseg
->stripe_unit
, &rem
);
65 return stripe_no
* flseg
->stripe_unit
+ rem
;
68 /* This function is used by the layout driver to calculate the
69 * offset of the file on the dserver based on whether the
70 * layout type is STRIPE_DENSE or STRIPE_SPARSE
73 filelayout_get_dserver_offset(struct pnfs_layout_segment
*lseg
, loff_t offset
)
75 struct nfs4_filelayout_segment
*flseg
= FILELAYOUT_LSEG(lseg
);
77 switch (flseg
->stripe_type
) {
82 return filelayout_get_dense_offset(flseg
, offset
);
88 static void filelayout_reset_write(struct nfs_pgio_header
*hdr
)
90 struct rpc_task
*task
= &hdr
->task
;
92 if (!test_and_set_bit(NFS_IOHDR_REDO
, &hdr
->flags
)) {
93 dprintk("%s Reset task %5u for i/o through MDS "
94 "(req %s/%llu, %u bytes @ offset %llu)\n", __func__
,
96 hdr
->inode
->i_sb
->s_id
,
97 (unsigned long long)NFS_FILEID(hdr
->inode
),
99 (unsigned long long)hdr
->args
.offset
);
101 task
->tk_status
= pnfs_write_done_resend_to_mds(hdr
);
105 static void filelayout_reset_read(struct nfs_pgio_header
*hdr
)
107 struct rpc_task
*task
= &hdr
->task
;
109 if (!test_and_set_bit(NFS_IOHDR_REDO
, &hdr
->flags
)) {
110 dprintk("%s Reset task %5u for i/o through MDS "
111 "(req %s/%llu, %u bytes @ offset %llu)\n", __func__
,
113 hdr
->inode
->i_sb
->s_id
,
114 (unsigned long long)NFS_FILEID(hdr
->inode
),
116 (unsigned long long)hdr
->args
.offset
);
118 task
->tk_status
= pnfs_read_done_resend_to_mds(hdr
);
122 static int filelayout_async_handle_error(struct rpc_task
*task
,
123 struct nfs4_state
*state
,
124 struct nfs_client
*clp
,
125 struct pnfs_layout_segment
*lseg
)
127 struct pnfs_layout_hdr
*lo
= lseg
->pls_layout
;
128 struct inode
*inode
= lo
->plh_inode
;
129 struct nfs_server
*mds_server
= NFS_SERVER(inode
);
130 struct nfs4_deviceid_node
*devid
= FILELAYOUT_DEVID_NODE(lseg
);
131 struct nfs_client
*mds_client
= mds_server
->nfs_client
;
132 struct nfs4_slot_table
*tbl
= &clp
->cl_session
->fc_slot_table
;
134 if (task
->tk_status
>= 0)
137 switch (task
->tk_status
) {
138 /* MDS state errors */
139 case -NFS4ERR_DELEG_REVOKED
:
140 case -NFS4ERR_ADMIN_REVOKED
:
141 case -NFS4ERR_BAD_STATEID
:
142 case -NFS4ERR_OPENMODE
:
145 if (nfs4_schedule_stateid_recovery(mds_server
, state
) < 0)
146 goto out_bad_stateid
;
147 goto wait_on_recovery
;
148 case -NFS4ERR_EXPIRED
:
150 if (nfs4_schedule_stateid_recovery(mds_server
, state
) < 0)
151 goto out_bad_stateid
;
153 nfs4_schedule_lease_recovery(mds_client
);
154 goto wait_on_recovery
;
155 /* DS session errors */
156 case -NFS4ERR_BADSESSION
:
157 case -NFS4ERR_BADSLOT
:
158 case -NFS4ERR_BAD_HIGH_SLOT
:
159 case -NFS4ERR_DEADSESSION
:
160 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION
:
161 case -NFS4ERR_SEQ_FALSE_RETRY
:
162 case -NFS4ERR_SEQ_MISORDERED
:
163 dprintk("%s ERROR %d, Reset session. Exchangeid "
164 "flags 0x%x\n", __func__
, task
->tk_status
,
165 clp
->cl_exchange_flags
);
166 nfs4_schedule_session_recovery(clp
->cl_session
, task
->tk_status
);
170 rpc_delay(task
, FILELAYOUT_POLL_RETRY_MAX
);
172 case -NFS4ERR_RETRY_UNCACHED_REP
:
174 /* Invalidate Layout errors */
175 case -NFS4ERR_PNFS_NO_LAYOUT
:
176 case -ESTALE
: /* mapped NFS4ERR_STALE */
177 case -EBADHANDLE
: /* mapped NFS4ERR_BADHANDLE */
178 case -EISDIR
: /* mapped NFS4ERR_ISDIR */
179 case -NFS4ERR_FHEXPIRED
:
180 case -NFS4ERR_WRONG_TYPE
:
181 dprintk("%s Invalid layout error %d\n", __func__
,
184 * Destroy layout so new i/o will get a new layout.
185 * Layout will not be destroyed until all current lseg
186 * references are put. Mark layout as invalid to resend failed
187 * i/o and all i/o waiting on the slot table to the MDS until
188 * layout is destroyed and a new valid layout is obtained.
190 pnfs_destroy_layout(NFS_I(inode
));
191 rpc_wake_up(&tbl
->slot_tbl_waitq
);
193 /* RPC connection errors */
201 dprintk("%s DS connection error %d\n", __func__
,
203 nfs4_mark_deviceid_unavailable(devid
);
204 pnfs_error_mark_layout_for_return(inode
, lseg
);
205 rpc_wake_up(&tbl
->slot_tbl_waitq
);
208 pnfs_set_lo_fail(lseg
);
210 dprintk("%s Retry through MDS. Error %d\n", __func__
,
212 return -NFS4ERR_RESET_TO_MDS
;
218 task
->tk_status
= -EIO
;
221 rpc_sleep_on(&mds_client
->cl_rpcwaitq
, task
, NULL
);
222 if (test_bit(NFS4CLNT_MANAGER_RUNNING
, &mds_client
->cl_state
) == 0)
223 rpc_wake_up_queued_task(&mds_client
->cl_rpcwaitq
, task
);
227 /* NFS_PROTO call done callback routines */
229 static int filelayout_read_done_cb(struct rpc_task
*task
,
230 struct nfs_pgio_header
*hdr
)
234 trace_nfs4_pnfs_read(hdr
, task
->tk_status
);
235 err
= filelayout_async_handle_error(task
, hdr
->args
.context
->state
,
236 hdr
->ds_clp
, hdr
->lseg
);
239 case -NFS4ERR_RESET_TO_MDS
:
240 filelayout_reset_read(hdr
);
241 return task
->tk_status
;
243 rpc_restart_call_prepare(task
);
251 * We reference the rpc_cred of the first WRITE that triggers the need for
252 * a LAYOUTCOMMIT, and use it to send the layoutcommit compound.
253 * rfc5661 is not clear about which credential should be used.
256 filelayout_set_layoutcommit(struct nfs_pgio_header
*hdr
)
260 if (FILELAYOUT_LSEG(hdr
->lseg
)->commit_through_mds
||
261 hdr
->res
.verf
->committed
== NFS_FILE_SYNC
)
263 if (hdr
->res
.verf
->committed
== NFS_DATA_SYNC
)
264 end_offs
= hdr
->mds_offset
+ (loff_t
)hdr
->res
.count
;
266 /* Note: if the write is unstable, don't set end_offs until commit */
267 pnfs_set_layoutcommit(hdr
->inode
, hdr
->lseg
, end_offs
);
268 dprintk("%s inode %lu pls_end_pos %lu\n", __func__
, hdr
->inode
->i_ino
,
269 (unsigned long) NFS_I(hdr
->inode
)->layout
->plh_lwb
);
273 filelayout_test_devid_unavailable(struct nfs4_deviceid_node
*node
)
275 return filelayout_test_devid_invalid(node
) ||
276 nfs4_test_deviceid_unavailable(node
);
280 filelayout_reset_to_mds(struct pnfs_layout_segment
*lseg
)
282 struct nfs4_deviceid_node
*node
= FILELAYOUT_DEVID_NODE(lseg
);
284 return filelayout_test_devid_unavailable(node
);
288 * Call ops for the async read/write cases
289 * In the case of dense layouts, the offset needs to be reset to its
292 static void filelayout_read_prepare(struct rpc_task
*task
, void *data
)
294 struct nfs_pgio_header
*hdr
= data
;
296 if (unlikely(test_bit(NFS_CONTEXT_BAD
, &hdr
->args
.context
->flags
))) {
297 rpc_exit(task
, -EIO
);
300 if (filelayout_reset_to_mds(hdr
->lseg
)) {
301 dprintk("%s task %u reset io to MDS\n", __func__
, task
->tk_pid
);
302 filelayout_reset_read(hdr
);
306 hdr
->pgio_done_cb
= filelayout_read_done_cb
;
308 if (nfs4_setup_sequence(hdr
->ds_clp
,
313 if (nfs4_set_rw_stateid(&hdr
->args
.stateid
, hdr
->args
.context
,
314 hdr
->args
.lock_context
, FMODE_READ
) == -EIO
)
315 rpc_exit(task
, -EIO
); /* lost lock, terminate I/O */
318 static void filelayout_read_call_done(struct rpc_task
*task
, void *data
)
320 struct nfs_pgio_header
*hdr
= data
;
322 dprintk("--> %s task->tk_status %d\n", __func__
, task
->tk_status
);
324 if (test_bit(NFS_IOHDR_REDO
, &hdr
->flags
) &&
325 task
->tk_status
== 0) {
326 nfs41_sequence_done(task
, &hdr
->res
.seq_res
);
330 /* Note this may cause RPC to be resent */
331 hdr
->mds_ops
->rpc_call_done(task
, data
);
334 static void filelayout_read_count_stats(struct rpc_task
*task
, void *data
)
336 struct nfs_pgio_header
*hdr
= data
;
338 rpc_count_iostats(task
, NFS_SERVER(hdr
->inode
)->client
->cl_metrics
);
341 static int filelayout_write_done_cb(struct rpc_task
*task
,
342 struct nfs_pgio_header
*hdr
)
346 trace_nfs4_pnfs_write(hdr
, task
->tk_status
);
347 err
= filelayout_async_handle_error(task
, hdr
->args
.context
->state
,
348 hdr
->ds_clp
, hdr
->lseg
);
351 case -NFS4ERR_RESET_TO_MDS
:
352 filelayout_reset_write(hdr
);
353 return task
->tk_status
;
355 rpc_restart_call_prepare(task
);
359 filelayout_set_layoutcommit(hdr
);
361 /* zero out the fattr */
362 hdr
->fattr
.valid
= 0;
363 if (task
->tk_status
>= 0)
364 nfs_writeback_update_inode(hdr
);
369 static int filelayout_commit_done_cb(struct rpc_task
*task
,
370 struct nfs_commit_data
*data
)
374 trace_nfs4_pnfs_commit_ds(data
, task
->tk_status
);
375 err
= filelayout_async_handle_error(task
, NULL
, data
->ds_clp
,
379 case -NFS4ERR_RESET_TO_MDS
:
380 pnfs_generic_prepare_to_resend_writes(data
);
383 rpc_restart_call_prepare(task
);
387 pnfs_set_layoutcommit(data
->inode
, data
->lseg
, data
->lwb
);
392 static void filelayout_write_prepare(struct rpc_task
*task
, void *data
)
394 struct nfs_pgio_header
*hdr
= data
;
396 if (unlikely(test_bit(NFS_CONTEXT_BAD
, &hdr
->args
.context
->flags
))) {
397 rpc_exit(task
, -EIO
);
400 if (filelayout_reset_to_mds(hdr
->lseg
)) {
401 dprintk("%s task %u reset io to MDS\n", __func__
, task
->tk_pid
);
402 filelayout_reset_write(hdr
);
406 if (nfs4_setup_sequence(hdr
->ds_clp
,
411 if (nfs4_set_rw_stateid(&hdr
->args
.stateid
, hdr
->args
.context
,
412 hdr
->args
.lock_context
, FMODE_WRITE
) == -EIO
)
413 rpc_exit(task
, -EIO
); /* lost lock, terminate I/O */
416 static void filelayout_write_call_done(struct rpc_task
*task
, void *data
)
418 struct nfs_pgio_header
*hdr
= data
;
420 if (test_bit(NFS_IOHDR_REDO
, &hdr
->flags
) &&
421 task
->tk_status
== 0) {
422 nfs41_sequence_done(task
, &hdr
->res
.seq_res
);
426 /* Note this may cause RPC to be resent */
427 hdr
->mds_ops
->rpc_call_done(task
, data
);
430 static void filelayout_write_count_stats(struct rpc_task
*task
, void *data
)
432 struct nfs_pgio_header
*hdr
= data
;
434 rpc_count_iostats(task
, NFS_SERVER(hdr
->inode
)->client
->cl_metrics
);
437 static void filelayout_commit_prepare(struct rpc_task
*task
, void *data
)
439 struct nfs_commit_data
*wdata
= data
;
441 nfs4_setup_sequence(wdata
->ds_clp
,
442 &wdata
->args
.seq_args
,
447 static void filelayout_commit_count_stats(struct rpc_task
*task
, void *data
)
449 struct nfs_commit_data
*cdata
= data
;
451 rpc_count_iostats(task
, NFS_SERVER(cdata
->inode
)->client
->cl_metrics
);
454 static const struct rpc_call_ops filelayout_read_call_ops
= {
455 .rpc_call_prepare
= filelayout_read_prepare
,
456 .rpc_call_done
= filelayout_read_call_done
,
457 .rpc_count_stats
= filelayout_read_count_stats
,
458 .rpc_release
= pnfs_generic_rw_release
,
461 static const struct rpc_call_ops filelayout_write_call_ops
= {
462 .rpc_call_prepare
= filelayout_write_prepare
,
463 .rpc_call_done
= filelayout_write_call_done
,
464 .rpc_count_stats
= filelayout_write_count_stats
,
465 .rpc_release
= pnfs_generic_rw_release
,
468 static const struct rpc_call_ops filelayout_commit_call_ops
= {
469 .rpc_call_prepare
= filelayout_commit_prepare
,
470 .rpc_call_done
= pnfs_generic_write_commit_done
,
471 .rpc_count_stats
= filelayout_commit_count_stats
,
472 .rpc_release
= pnfs_generic_commit_release
,
475 static enum pnfs_try_status
476 filelayout_read_pagelist(struct nfs_pgio_header
*hdr
)
478 struct pnfs_layout_segment
*lseg
= hdr
->lseg
;
479 struct nfs4_pnfs_ds
*ds
;
480 struct rpc_clnt
*ds_clnt
;
481 loff_t offset
= hdr
->args
.offset
;
485 dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n",
486 __func__
, hdr
->inode
->i_ino
,
487 hdr
->args
.pgbase
, (size_t)hdr
->args
.count
, offset
);
489 /* Retrieve the correct rpc_client for the byte range */
490 j
= nfs4_fl_calc_j_index(lseg
, offset
);
491 idx
= nfs4_fl_calc_ds_index(lseg
, j
);
492 ds
= nfs4_fl_prepare_ds(lseg
, idx
);
494 return PNFS_NOT_ATTEMPTED
;
496 ds_clnt
= nfs4_find_or_create_ds_client(ds
->ds_clp
, hdr
->inode
);
498 return PNFS_NOT_ATTEMPTED
;
500 dprintk("%s USE DS: %s cl_count %d\n", __func__
,
501 ds
->ds_remotestr
, atomic_read(&ds
->ds_clp
->cl_count
));
503 /* No multipath support. Use first DS */
504 atomic_inc(&ds
->ds_clp
->cl_count
);
505 hdr
->ds_clp
= ds
->ds_clp
;
506 hdr
->ds_commit_idx
= idx
;
507 fh
= nfs4_fl_select_ds_fh(lseg
, j
);
511 hdr
->args
.offset
= filelayout_get_dserver_offset(lseg
, offset
);
512 hdr
->mds_offset
= offset
;
514 /* Perform an asynchronous read to ds */
515 nfs_initiate_pgio(ds_clnt
, hdr
, hdr
->cred
,
516 NFS_PROTO(hdr
->inode
), &filelayout_read_call_ops
,
517 0, RPC_TASK_SOFTCONN
);
518 return PNFS_ATTEMPTED
;
521 /* Perform async writes. */
522 static enum pnfs_try_status
523 filelayout_write_pagelist(struct nfs_pgio_header
*hdr
, int sync
)
525 struct pnfs_layout_segment
*lseg
= hdr
->lseg
;
526 struct nfs4_pnfs_ds
*ds
;
527 struct rpc_clnt
*ds_clnt
;
528 loff_t offset
= hdr
->args
.offset
;
532 /* Retrieve the correct rpc_client for the byte range */
533 j
= nfs4_fl_calc_j_index(lseg
, offset
);
534 idx
= nfs4_fl_calc_ds_index(lseg
, j
);
535 ds
= nfs4_fl_prepare_ds(lseg
, idx
);
537 return PNFS_NOT_ATTEMPTED
;
539 ds_clnt
= nfs4_find_or_create_ds_client(ds
->ds_clp
, hdr
->inode
);
541 return PNFS_NOT_ATTEMPTED
;
543 dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d\n",
544 __func__
, hdr
->inode
->i_ino
, sync
, (size_t) hdr
->args
.count
,
545 offset
, ds
->ds_remotestr
, atomic_read(&ds
->ds_clp
->cl_count
));
547 hdr
->pgio_done_cb
= filelayout_write_done_cb
;
548 atomic_inc(&ds
->ds_clp
->cl_count
);
549 hdr
->ds_clp
= ds
->ds_clp
;
550 hdr
->ds_commit_idx
= idx
;
551 fh
= nfs4_fl_select_ds_fh(lseg
, j
);
554 hdr
->args
.offset
= filelayout_get_dserver_offset(lseg
, offset
);
556 /* Perform an asynchronous write */
557 nfs_initiate_pgio(ds_clnt
, hdr
, hdr
->cred
,
558 NFS_PROTO(hdr
->inode
), &filelayout_write_call_ops
,
559 sync
, RPC_TASK_SOFTCONN
);
560 return PNFS_ATTEMPTED
;
564 filelayout_check_deviceid(struct pnfs_layout_hdr
*lo
,
565 struct nfs4_filelayout_segment
*fl
,
568 struct nfs4_deviceid_node
*d
;
569 struct nfs4_file_layout_dsaddr
*dsaddr
;
570 int status
= -EINVAL
;
572 /* find and reference the deviceid */
573 d
= nfs4_find_get_deviceid(NFS_SERVER(lo
->plh_inode
), &fl
->deviceid
,
574 lo
->plh_lc_cred
, gfp_flags
);
578 dsaddr
= container_of(d
, struct nfs4_file_layout_dsaddr
, id_node
);
579 /* Found deviceid is unavailable */
580 if (filelayout_test_devid_unavailable(&dsaddr
->id_node
))
585 if (fl
->first_stripe_index
>= dsaddr
->stripe_count
) {
586 dprintk("%s Bad first_stripe_index %u\n",
587 __func__
, fl
->first_stripe_index
);
591 if ((fl
->stripe_type
== STRIPE_SPARSE
&&
592 fl
->num_fh
> 1 && fl
->num_fh
!= dsaddr
->ds_num
) ||
593 (fl
->stripe_type
== STRIPE_DENSE
&&
594 fl
->num_fh
!= dsaddr
->stripe_count
)) {
595 dprintk("%s num_fh %u not valid for given packing\n",
596 __func__
, fl
->num_fh
);
603 nfs4_fl_put_deviceid(dsaddr
);
608 * filelayout_check_layout()
610 * Make sure layout segment parameters are sane WRT the device.
611 * At this point no generic layer initialization of the lseg has occurred,
612 * and nothing has been added to the layout_hdr cache.
616 filelayout_check_layout(struct pnfs_layout_hdr
*lo
,
617 struct nfs4_filelayout_segment
*fl
,
618 struct nfs4_layoutget_res
*lgr
,
621 int status
= -EINVAL
;
623 dprintk("--> %s\n", __func__
);
625 /* FIXME: remove this check when layout segment support is added */
626 if (lgr
->range
.offset
!= 0 ||
627 lgr
->range
.length
!= NFS4_MAX_UINT64
) {
628 dprintk("%s Only whole file layouts supported. Use MDS i/o\n",
633 if (fl
->pattern_offset
> lgr
->range
.offset
) {
634 dprintk("%s pattern_offset %lld too large\n",
635 __func__
, fl
->pattern_offset
);
639 if (!fl
->stripe_unit
) {
640 dprintk("%s Invalid stripe unit (%u)\n",
641 __func__
, fl
->stripe_unit
);
647 dprintk("--> %s returns %d\n", __func__
, status
);
651 static void _filelayout_free_lseg(struct nfs4_filelayout_segment
*fl
)
656 for (i
= 0; i
< fl
->num_fh
; i
++) {
657 if (!fl
->fh_array
[i
])
659 kfree(fl
->fh_array
[i
]);
667 filelayout_decode_layout(struct pnfs_layout_hdr
*flo
,
668 struct nfs4_filelayout_segment
*fl
,
669 struct nfs4_layoutget_res
*lgr
,
672 struct xdr_stream stream
;
674 struct page
*scratch
;
679 dprintk("%s: set_layout_map Begin\n", __func__
);
681 scratch
= alloc_page(gfp_flags
);
685 xdr_init_decode_pages(&stream
, &buf
, lgr
->layoutp
->pages
, lgr
->layoutp
->len
);
686 xdr_set_scratch_buffer(&stream
, page_address(scratch
), PAGE_SIZE
);
688 /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8),
690 p
= xdr_inline_decode(&stream
, NFS4_DEVICEID4_SIZE
+ 20);
694 memcpy(&fl
->deviceid
, p
, sizeof(fl
->deviceid
));
695 p
+= XDR_QUADLEN(NFS4_DEVICEID4_SIZE
);
696 nfs4_print_deviceid(&fl
->deviceid
);
698 nfl_util
= be32_to_cpup(p
++);
699 if (nfl_util
& NFL4_UFLG_COMMIT_THRU_MDS
)
700 fl
->commit_through_mds
= 1;
701 if (nfl_util
& NFL4_UFLG_DENSE
)
702 fl
->stripe_type
= STRIPE_DENSE
;
704 fl
->stripe_type
= STRIPE_SPARSE
;
705 fl
->stripe_unit
= nfl_util
& ~NFL4_UFLG_MASK
;
707 fl
->first_stripe_index
= be32_to_cpup(p
++);
708 p
= xdr_decode_hyper(p
, &fl
->pattern_offset
);
709 fl
->num_fh
= be32_to_cpup(p
++);
711 dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n",
712 __func__
, nfl_util
, fl
->num_fh
, fl
->first_stripe_index
,
715 /* Note that a zero value for num_fh is legal for STRIPE_SPARSE.
716 * Futher checking is done in filelayout_check_layout */
718 max(NFS4_PNFS_MAX_STRIPE_CNT
, NFS4_PNFS_MAX_MULTI_CNT
))
721 if (fl
->num_fh
> 0) {
722 fl
->fh_array
= kcalloc(fl
->num_fh
, sizeof(fl
->fh_array
[0]),
728 for (i
= 0; i
< fl
->num_fh
; i
++) {
729 /* Do we want to use a mempool here? */
730 fl
->fh_array
[i
] = kmalloc(sizeof(struct nfs_fh
), gfp_flags
);
731 if (!fl
->fh_array
[i
])
734 p
= xdr_inline_decode(&stream
, 4);
737 fl
->fh_array
[i
]->size
= be32_to_cpup(p
++);
738 if (sizeof(struct nfs_fh
) < fl
->fh_array
[i
]->size
) {
739 printk(KERN_ERR
"NFS: Too big fh %d received %d\n",
740 i
, fl
->fh_array
[i
]->size
);
744 p
= xdr_inline_decode(&stream
, fl
->fh_array
[i
]->size
);
747 memcpy(fl
->fh_array
[i
]->data
, p
, fl
->fh_array
[i
]->size
);
748 dprintk("DEBUG: %s: fh len %d\n", __func__
,
749 fl
->fh_array
[i
]->size
);
752 __free_page(scratch
);
756 __free_page(scratch
);
761 filelayout_free_lseg(struct pnfs_layout_segment
*lseg
)
763 struct nfs4_filelayout_segment
*fl
= FILELAYOUT_LSEG(lseg
);
765 dprintk("--> %s\n", __func__
);
766 nfs4_fl_put_deviceid(fl
->dsaddr
);
767 /* This assumes a single RW lseg */
768 if (lseg
->pls_range
.iomode
== IOMODE_RW
) {
769 struct nfs4_filelayout
*flo
;
771 flo
= FILELAYOUT_FROM_HDR(lseg
->pls_layout
);
772 flo
->commit_info
.nbuckets
= 0;
773 kfree(flo
->commit_info
.buckets
);
774 flo
->commit_info
.buckets
= NULL
;
776 _filelayout_free_lseg(fl
);
780 filelayout_alloc_commit_info(struct pnfs_layout_segment
*lseg
,
781 struct nfs_commit_info
*cinfo
,
784 struct nfs4_filelayout_segment
*fl
= FILELAYOUT_LSEG(lseg
);
785 struct pnfs_commit_bucket
*buckets
;
788 if (fl
->commit_through_mds
)
791 size
= (fl
->stripe_type
== STRIPE_SPARSE
) ?
792 fl
->dsaddr
->ds_num
: fl
->dsaddr
->stripe_count
;
794 if (cinfo
->ds
->nbuckets
>= size
) {
795 /* This assumes there is only one IOMODE_RW lseg. What
796 * we really want to do is have a layout_hdr level
797 * dictionary of <multipath_list4, fh> keys, each
798 * associated with a struct list_head, populated by calls
799 * to filelayout_write_pagelist().
804 buckets
= kcalloc(size
, sizeof(struct pnfs_commit_bucket
),
808 for (i
= 0; i
< size
; i
++) {
809 INIT_LIST_HEAD(&buckets
[i
].written
);
810 INIT_LIST_HEAD(&buckets
[i
].committing
);
811 /* mark direct verifier as unset */
812 buckets
[i
].direct_verf
.committed
= NFS_INVALID_STABLE_HOW
;
815 spin_lock(&cinfo
->inode
->i_lock
);
816 if (cinfo
->ds
->nbuckets
>= size
)
818 for (i
= 0; i
< cinfo
->ds
->nbuckets
; i
++) {
819 list_splice(&cinfo
->ds
->buckets
[i
].written
,
820 &buckets
[i
].written
);
821 list_splice(&cinfo
->ds
->buckets
[i
].committing
,
822 &buckets
[i
].committing
);
823 buckets
[i
].direct_verf
.committed
=
824 cinfo
->ds
->buckets
[i
].direct_verf
.committed
;
825 buckets
[i
].wlseg
= cinfo
->ds
->buckets
[i
].wlseg
;
826 buckets
[i
].clseg
= cinfo
->ds
->buckets
[i
].clseg
;
828 swap(cinfo
->ds
->buckets
, buckets
);
829 cinfo
->ds
->nbuckets
= size
;
831 spin_unlock(&cinfo
->inode
->i_lock
);
836 static struct pnfs_layout_segment
*
837 filelayout_alloc_lseg(struct pnfs_layout_hdr
*layoutid
,
838 struct nfs4_layoutget_res
*lgr
,
841 struct nfs4_filelayout_segment
*fl
;
844 dprintk("--> %s\n", __func__
);
845 fl
= kzalloc(sizeof(*fl
), gfp_flags
);
849 rc
= filelayout_decode_layout(layoutid
, fl
, lgr
, gfp_flags
);
850 if (rc
!= 0 || filelayout_check_layout(layoutid
, fl
, lgr
, gfp_flags
)) {
851 _filelayout_free_lseg(fl
);
854 return &fl
->generic_hdr
;
858 * filelayout_pg_test(). Called by nfs_can_coalesce_requests()
860 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number
861 * of bytes (maximum @req->wb_bytes) that can be coalesced.
864 filelayout_pg_test(struct nfs_pageio_descriptor
*pgio
, struct nfs_page
*prev
,
865 struct nfs_page
*req
)
868 u64 p_stripe
, r_stripe
;
870 u64 segment_offset
= pgio
->pg_lseg
->pls_range
.offset
;
871 u32 stripe_unit
= FILELAYOUT_LSEG(pgio
->pg_lseg
)->stripe_unit
;
873 /* calls nfs_generic_pg_test */
874 size
= pnfs_generic_pg_test(pgio
, prev
, req
);
878 /* see if req and prev are in the same stripe */
880 p_stripe
= (u64
)req_offset(prev
) - segment_offset
;
881 r_stripe
= (u64
)req_offset(req
) - segment_offset
;
882 do_div(p_stripe
, stripe_unit
);
883 do_div(r_stripe
, stripe_unit
);
885 if (p_stripe
!= r_stripe
)
889 /* calculate remaining bytes in the current stripe */
890 div_u64_rem((u64
)req_offset(req
) - segment_offset
,
893 WARN_ON_ONCE(stripe_offset
> stripe_unit
);
894 if (stripe_offset
>= stripe_unit
)
896 return min(stripe_unit
- (unsigned int)stripe_offset
, size
);
899 static struct pnfs_layout_segment
*
900 fl_pnfs_update_layout(struct inode
*ino
,
901 struct nfs_open_context
*ctx
,
904 enum pnfs_iomode iomode
,
908 struct pnfs_layout_segment
*lseg
= NULL
;
909 struct pnfs_layout_hdr
*lo
;
910 struct nfs4_filelayout_segment
*fl
;
913 lseg
= pnfs_update_layout(ino
, ctx
, pos
, count
, iomode
, strict_iomode
,
916 lseg
= ERR_PTR(-ENOMEM
);
920 lo
= NFS_I(ino
)->layout
;
921 fl
= FILELAYOUT_LSEG(lseg
);
923 status
= filelayout_check_deviceid(lo
, fl
, gfp_flags
);
925 lseg
= ERR_PTR(status
);
933 filelayout_pg_init_read(struct nfs_pageio_descriptor
*pgio
,
934 struct nfs_page
*req
)
936 if (!pgio
->pg_lseg
) {
937 pgio
->pg_lseg
= fl_pnfs_update_layout(pgio
->pg_inode
,
944 if (IS_ERR(pgio
->pg_lseg
)) {
945 pgio
->pg_error
= PTR_ERR(pgio
->pg_lseg
);
946 pgio
->pg_lseg
= NULL
;
950 /* If no lseg, fall back to read through mds */
951 if (pgio
->pg_lseg
== NULL
)
952 nfs_pageio_reset_read_mds(pgio
);
956 filelayout_pg_init_write(struct nfs_pageio_descriptor
*pgio
,
957 struct nfs_page
*req
)
959 struct nfs_commit_info cinfo
;
962 if (!pgio
->pg_lseg
) {
963 pgio
->pg_lseg
= fl_pnfs_update_layout(pgio
->pg_inode
,
970 if (IS_ERR(pgio
->pg_lseg
)) {
971 pgio
->pg_error
= PTR_ERR(pgio
->pg_lseg
);
972 pgio
->pg_lseg
= NULL
;
977 /* If no lseg, fall back to write through mds */
978 if (pgio
->pg_lseg
== NULL
)
980 nfs_init_cinfo(&cinfo
, pgio
->pg_inode
, pgio
->pg_dreq
);
981 status
= filelayout_alloc_commit_info(pgio
->pg_lseg
, &cinfo
, GFP_NOFS
);
983 pnfs_put_lseg(pgio
->pg_lseg
);
984 pgio
->pg_lseg
= NULL
;
989 nfs_pageio_reset_write_mds(pgio
);
992 static const struct nfs_pageio_ops filelayout_pg_read_ops
= {
993 .pg_init
= filelayout_pg_init_read
,
994 .pg_test
= filelayout_pg_test
,
995 .pg_doio
= pnfs_generic_pg_readpages
,
996 .pg_cleanup
= pnfs_generic_pg_cleanup
,
999 static const struct nfs_pageio_ops filelayout_pg_write_ops
= {
1000 .pg_init
= filelayout_pg_init_write
,
1001 .pg_test
= filelayout_pg_test
,
1002 .pg_doio
= pnfs_generic_pg_writepages
,
1003 .pg_cleanup
= pnfs_generic_pg_cleanup
,
1006 static u32
select_bucket_index(struct nfs4_filelayout_segment
*fl
, u32 j
)
1008 if (fl
->stripe_type
== STRIPE_SPARSE
)
1009 return nfs4_fl_calc_ds_index(&fl
->generic_hdr
, j
);
1015 filelayout_mark_request_commit(struct nfs_page
*req
,
1016 struct pnfs_layout_segment
*lseg
,
1017 struct nfs_commit_info
*cinfo
,
1021 struct nfs4_filelayout_segment
*fl
= FILELAYOUT_LSEG(lseg
);
1024 if (fl
->commit_through_mds
) {
1025 nfs_request_add_commit_list(req
, cinfo
);
1027 /* Note that we are calling nfs4_fl_calc_j_index on each page
1028 * that ends up being committed to a data server. An attractive
1029 * alternative is to add a field to nfs_write_data and nfs_page
1030 * to store the value calculated in filelayout_write_pagelist
1031 * and just use that here.
1033 j
= nfs4_fl_calc_j_index(lseg
, req_offset(req
));
1034 i
= select_bucket_index(fl
, j
);
1035 pnfs_layout_mark_request_commit(req
, lseg
, cinfo
, i
);
1039 static u32
calc_ds_index_from_commit(struct pnfs_layout_segment
*lseg
, u32 i
)
1041 struct nfs4_filelayout_segment
*flseg
= FILELAYOUT_LSEG(lseg
);
1043 if (flseg
->stripe_type
== STRIPE_SPARSE
)
1046 return nfs4_fl_calc_ds_index(lseg
, i
);
1049 static struct nfs_fh
*
1050 select_ds_fh_from_commit(struct pnfs_layout_segment
*lseg
, u32 i
)
1052 struct nfs4_filelayout_segment
*flseg
= FILELAYOUT_LSEG(lseg
);
1054 if (flseg
->stripe_type
== STRIPE_SPARSE
) {
1055 if (flseg
->num_fh
== 1)
1057 else if (flseg
->num_fh
== 0)
1058 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
1061 return flseg
->fh_array
[i
];
1064 static int filelayout_initiate_commit(struct nfs_commit_data
*data
, int how
)
1066 struct pnfs_layout_segment
*lseg
= data
->lseg
;
1067 struct nfs4_pnfs_ds
*ds
;
1068 struct rpc_clnt
*ds_clnt
;
1072 idx
= calc_ds_index_from_commit(lseg
, data
->ds_commit_index
);
1073 ds
= nfs4_fl_prepare_ds(lseg
, idx
);
1077 ds_clnt
= nfs4_find_or_create_ds_client(ds
->ds_clp
, data
->inode
);
1078 if (IS_ERR(ds_clnt
))
1081 dprintk("%s ino %lu, how %d cl_count %d\n", __func__
,
1082 data
->inode
->i_ino
, how
, atomic_read(&ds
->ds_clp
->cl_count
));
1083 data
->commit_done_cb
= filelayout_commit_done_cb
;
1084 atomic_inc(&ds
->ds_clp
->cl_count
);
1085 data
->ds_clp
= ds
->ds_clp
;
1086 fh
= select_ds_fh_from_commit(lseg
, data
->ds_commit_index
);
1089 return nfs_initiate_commit(ds_clnt
, data
, NFS_PROTO(data
->inode
),
1090 &filelayout_commit_call_ops
, how
,
1093 pnfs_generic_prepare_to_resend_writes(data
);
1094 pnfs_generic_commit_release(data
);
1098 /* filelayout_search_commit_reqs - Search lists in @cinfo for the head reqest
1100 * @cinfo - commit info for current inode
1101 * @page - page to search for matching head request
1103 * Returns a the head request if one is found, otherwise returns NULL.
1105 static struct nfs_page
*
1106 filelayout_search_commit_reqs(struct nfs_commit_info
*cinfo
, struct page
*page
)
1108 struct nfs_page
*freq
, *t
;
1109 struct pnfs_commit_bucket
*b
;
1112 /* Linearly search the commit lists for each bucket until a matching
1113 * request is found */
1114 for (i
= 0, b
= cinfo
->ds
->buckets
; i
< cinfo
->ds
->nbuckets
; i
++, b
++) {
1115 list_for_each_entry_safe(freq
, t
, &b
->written
, wb_list
) {
1116 if (freq
->wb_page
== page
)
1117 return freq
->wb_head
;
1119 list_for_each_entry_safe(freq
, t
, &b
->committing
, wb_list
) {
1120 if (freq
->wb_page
== page
)
1121 return freq
->wb_head
;
1129 filelayout_commit_pagelist(struct inode
*inode
, struct list_head
*mds_pages
,
1130 int how
, struct nfs_commit_info
*cinfo
)
1132 return pnfs_generic_commit_pagelist(inode
, mds_pages
, how
, cinfo
,
1133 filelayout_initiate_commit
);
1136 static struct nfs4_deviceid_node
*
1137 filelayout_alloc_deviceid_node(struct nfs_server
*server
,
1138 struct pnfs_device
*pdev
, gfp_t gfp_flags
)
1140 struct nfs4_file_layout_dsaddr
*dsaddr
;
1142 dsaddr
= nfs4_fl_alloc_deviceid_node(server
, pdev
, gfp_flags
);
1145 return &dsaddr
->id_node
;
1149 filelayout_free_deviceid_node(struct nfs4_deviceid_node
*d
)
1151 nfs4_fl_free_deviceid(container_of(d
, struct nfs4_file_layout_dsaddr
, id_node
));
1154 static struct pnfs_layout_hdr
*
1155 filelayout_alloc_layout_hdr(struct inode
*inode
, gfp_t gfp_flags
)
1157 struct nfs4_filelayout
*flo
;
1159 flo
= kzalloc(sizeof(*flo
), gfp_flags
);
1160 return flo
!= NULL
? &flo
->generic_hdr
: NULL
;
1164 filelayout_free_layout_hdr(struct pnfs_layout_hdr
*lo
)
1166 kfree(FILELAYOUT_FROM_HDR(lo
));
1169 static struct pnfs_ds_commit_info
*
1170 filelayout_get_ds_info(struct inode
*inode
)
1172 struct pnfs_layout_hdr
*layout
= NFS_I(inode
)->layout
;
1177 return &FILELAYOUT_FROM_HDR(layout
)->commit_info
;
1180 static struct pnfs_layoutdriver_type filelayout_type
= {
1181 .id
= LAYOUT_NFSV4_1_FILES
,
1182 .name
= "LAYOUT_NFSV4_1_FILES",
1183 .owner
= THIS_MODULE
,
1184 .alloc_layout_hdr
= filelayout_alloc_layout_hdr
,
1185 .free_layout_hdr
= filelayout_free_layout_hdr
,
1186 .alloc_lseg
= filelayout_alloc_lseg
,
1187 .free_lseg
= filelayout_free_lseg
,
1188 .pg_read_ops
= &filelayout_pg_read_ops
,
1189 .pg_write_ops
= &filelayout_pg_write_ops
,
1190 .get_ds_info
= &filelayout_get_ds_info
,
1191 .mark_request_commit
= filelayout_mark_request_commit
,
1192 .clear_request_commit
= pnfs_generic_clear_request_commit
,
1193 .scan_commit_lists
= pnfs_generic_scan_commit_lists
,
1194 .recover_commit_reqs
= pnfs_generic_recover_commit_reqs
,
1195 .search_commit_reqs
= filelayout_search_commit_reqs
,
1196 .commit_pagelist
= filelayout_commit_pagelist
,
1197 .read_pagelist
= filelayout_read_pagelist
,
1198 .write_pagelist
= filelayout_write_pagelist
,
1199 .alloc_deviceid_node
= filelayout_alloc_deviceid_node
,
1200 .free_deviceid_node
= filelayout_free_deviceid_node
,
1201 .sync
= pnfs_nfs_generic_sync
,
1204 static int __init
nfs4filelayout_init(void)
1206 printk(KERN_INFO
"%s: NFSv4 File Layout Driver Registering...\n",
1208 return pnfs_register_layoutdriver(&filelayout_type
);
1211 static void __exit
nfs4filelayout_exit(void)
1213 printk(KERN_INFO
"%s: NFSv4 File Layout Driver Unregistering...\n",
1215 pnfs_unregister_layoutdriver(&filelayout_type
);
1218 MODULE_ALIAS("nfs-layouttype4-1");
1220 module_init(nfs4filelayout_init
);
1221 module_exit(nfs4filelayout_exit
);