Loading...
1/*
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.
5 *
6 * Copyright (c) 2002
7 * The Regents of the University of Michigan
8 * All Rights Reserved
9 *
10 * Dean Hildebrand <dhildebz@umich.edu>
11 *
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.
20 *
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
29 * such damages.
30 */
31
32#include <linux/nfs_fs.h>
33#include <linux/nfs_page.h>
34#include <linux/module.h>
35#include <linux/backing-dev.h>
36
37#include <linux/sunrpc/metrics.h>
38
39#include "../nfs4session.h"
40#include "../internal.h"
41#include "../delegation.h"
42#include "filelayout.h"
43#include "../nfs4trace.h"
44
45#define NFSDBG_FACILITY NFSDBG_PNFS_LD
46
47MODULE_LICENSE("GPL");
48MODULE_AUTHOR("Dean Hildebrand <dhildebz@umich.edu>");
49MODULE_DESCRIPTION("The NFSv4 file layout driver");
50
51#define FILELAYOUT_POLL_RETRY_MAX (15*HZ)
52
53static loff_t
54filelayout_get_dense_offset(struct nfs4_filelayout_segment *flseg,
55 loff_t offset)
56{
57 u32 stripe_width = flseg->stripe_unit * flseg->dsaddr->stripe_count;
58 u64 stripe_no;
59 u32 rem;
60
61 offset -= flseg->pattern_offset;
62 stripe_no = div_u64(offset, stripe_width);
63 div_u64_rem(offset, flseg->stripe_unit, &rem);
64
65 return stripe_no * flseg->stripe_unit + rem;
66}
67
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
71 */
72static loff_t
73filelayout_get_dserver_offset(struct pnfs_layout_segment *lseg, loff_t offset)
74{
75 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
76
77 switch (flseg->stripe_type) {
78 case STRIPE_SPARSE:
79 return offset;
80
81 case STRIPE_DENSE:
82 return filelayout_get_dense_offset(flseg, offset);
83 }
84
85 BUG();
86}
87
88static void filelayout_reset_write(struct nfs_pgio_header *hdr)
89{
90 struct rpc_task *task = &hdr->task;
91
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__,
95 hdr->task.tk_pid,
96 hdr->inode->i_sb->s_id,
97 (unsigned long long)NFS_FILEID(hdr->inode),
98 hdr->args.count,
99 (unsigned long long)hdr->args.offset);
100
101 task->tk_status = pnfs_write_done_resend_to_mds(hdr);
102 }
103}
104
105static void filelayout_reset_read(struct nfs_pgio_header *hdr)
106{
107 struct rpc_task *task = &hdr->task;
108
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__,
112 hdr->task.tk_pid,
113 hdr->inode->i_sb->s_id,
114 (unsigned long long)NFS_FILEID(hdr->inode),
115 hdr->args.count,
116 (unsigned long long)hdr->args.offset);
117
118 task->tk_status = pnfs_read_done_resend_to_mds(hdr);
119 }
120}
121
122static 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)
126{
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;
133
134 if (task->tk_status >= 0)
135 return 0;
136
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:
143 if (state == NULL)
144 break;
145 if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)
146 goto out_bad_stateid;
147 goto wait_on_recovery;
148 case -NFS4ERR_EXPIRED:
149 if (state != NULL) {
150 if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)
151 goto out_bad_stateid;
152 }
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);
167 break;
168 case -NFS4ERR_DELAY:
169 case -NFS4ERR_GRACE:
170 rpc_delay(task, FILELAYOUT_POLL_RETRY_MAX);
171 break;
172 case -NFS4ERR_RETRY_UNCACHED_REP:
173 break;
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__,
182 task->tk_status);
183 /*
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.
189 */
190 pnfs_destroy_layout(NFS_I(inode));
191 rpc_wake_up(&tbl->slot_tbl_waitq);
192 goto reset;
193 /* RPC connection errors */
194 case -ECONNREFUSED:
195 case -EHOSTDOWN:
196 case -EHOSTUNREACH:
197 case -ENETUNREACH:
198 case -EIO:
199 case -ETIMEDOUT:
200 case -EPIPE:
201 dprintk("%s DS connection error %d\n", __func__,
202 task->tk_status);
203 nfs4_mark_deviceid_unavailable(devid);
204 pnfs_error_mark_layout_for_return(inode, lseg);
205 pnfs_set_lo_fail(lseg);
206 rpc_wake_up(&tbl->slot_tbl_waitq);
207 /* fall through */
208 default:
209reset:
210 dprintk("%s Retry through MDS. Error %d\n", __func__,
211 task->tk_status);
212 return -NFS4ERR_RESET_TO_MDS;
213 }
214out:
215 task->tk_status = 0;
216 return -EAGAIN;
217out_bad_stateid:
218 task->tk_status = -EIO;
219 return 0;
220wait_on_recovery:
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);
224 goto out;
225}
226
227/* NFS_PROTO call done callback routines */
228
229static int filelayout_read_done_cb(struct rpc_task *task,
230 struct nfs_pgio_header *hdr)
231{
232 int err;
233
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);
237
238 switch (err) {
239 case -NFS4ERR_RESET_TO_MDS:
240 filelayout_reset_read(hdr);
241 return task->tk_status;
242 case -EAGAIN:
243 rpc_restart_call_prepare(task);
244 return -EAGAIN;
245 }
246
247 return 0;
248}
249
250/*
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.
254 */
255static void
256filelayout_set_layoutcommit(struct nfs_pgio_header *hdr)
257{
258 loff_t end_offs = 0;
259
260 if (FILELAYOUT_LSEG(hdr->lseg)->commit_through_mds ||
261 hdr->res.verf->committed == NFS_FILE_SYNC)
262 return;
263 if (hdr->res.verf->committed == NFS_DATA_SYNC)
264 end_offs = hdr->mds_offset + (loff_t)hdr->res.count;
265
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);
270}
271
272bool
273filelayout_test_devid_unavailable(struct nfs4_deviceid_node *node)
274{
275 return filelayout_test_devid_invalid(node) ||
276 nfs4_test_deviceid_unavailable(node);
277}
278
279static bool
280filelayout_reset_to_mds(struct pnfs_layout_segment *lseg)
281{
282 struct nfs4_deviceid_node *node = FILELAYOUT_DEVID_NODE(lseg);
283
284 return filelayout_test_devid_unavailable(node);
285}
286
287/*
288 * Call ops for the async read/write cases
289 * In the case of dense layouts, the offset needs to be reset to its
290 * original value.
291 */
292static void filelayout_read_prepare(struct rpc_task *task, void *data)
293{
294 struct nfs_pgio_header *hdr = data;
295
296 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
297 rpc_exit(task, -EIO);
298 return;
299 }
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);
303 rpc_exit(task, 0);
304 return;
305 }
306 hdr->pgio_done_cb = filelayout_read_done_cb;
307
308 if (nfs41_setup_sequence(hdr->ds_clp->cl_session,
309 &hdr->args.seq_args,
310 &hdr->res.seq_res,
311 task))
312 return;
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 */
316}
317
318static void filelayout_read_call_done(struct rpc_task *task, void *data)
319{
320 struct nfs_pgio_header *hdr = data;
321
322 dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status);
323
324 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
325 task->tk_status == 0) {
326 nfs41_sequence_done(task, &hdr->res.seq_res);
327 return;
328 }
329
330 /* Note this may cause RPC to be resent */
331 hdr->mds_ops->rpc_call_done(task, data);
332}
333
334static void filelayout_read_count_stats(struct rpc_task *task, void *data)
335{
336 struct nfs_pgio_header *hdr = data;
337
338 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics);
339}
340
341static int filelayout_write_done_cb(struct rpc_task *task,
342 struct nfs_pgio_header *hdr)
343{
344 int err;
345
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);
349
350 switch (err) {
351 case -NFS4ERR_RESET_TO_MDS:
352 filelayout_reset_write(hdr);
353 return task->tk_status;
354 case -EAGAIN:
355 rpc_restart_call_prepare(task);
356 return -EAGAIN;
357 }
358
359 filelayout_set_layoutcommit(hdr);
360
361 /* zero out the fattr */
362 hdr->fattr.valid = 0;
363 if (task->tk_status >= 0)
364 nfs_writeback_update_inode(hdr);
365
366 return 0;
367}
368
369static int filelayout_commit_done_cb(struct rpc_task *task,
370 struct nfs_commit_data *data)
371{
372 int err;
373
374 trace_nfs4_pnfs_commit_ds(data, task->tk_status);
375 err = filelayout_async_handle_error(task, NULL, data->ds_clp,
376 data->lseg);
377
378 switch (err) {
379 case -NFS4ERR_RESET_TO_MDS:
380 pnfs_generic_prepare_to_resend_writes(data);
381 return -EAGAIN;
382 case -EAGAIN:
383 rpc_restart_call_prepare(task);
384 return -EAGAIN;
385 }
386
387 pnfs_set_layoutcommit(data->inode, data->lseg, data->lwb);
388
389 return 0;
390}
391
392static void filelayout_write_prepare(struct rpc_task *task, void *data)
393{
394 struct nfs_pgio_header *hdr = data;
395
396 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
397 rpc_exit(task, -EIO);
398 return;
399 }
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);
403 rpc_exit(task, 0);
404 return;
405 }
406 if (nfs41_setup_sequence(hdr->ds_clp->cl_session,
407 &hdr->args.seq_args,
408 &hdr->res.seq_res,
409 task))
410 return;
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 */
414}
415
416static void filelayout_write_call_done(struct rpc_task *task, void *data)
417{
418 struct nfs_pgio_header *hdr = data;
419
420 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
421 task->tk_status == 0) {
422 nfs41_sequence_done(task, &hdr->res.seq_res);
423 return;
424 }
425
426 /* Note this may cause RPC to be resent */
427 hdr->mds_ops->rpc_call_done(task, data);
428}
429
430static void filelayout_write_count_stats(struct rpc_task *task, void *data)
431{
432 struct nfs_pgio_header *hdr = data;
433
434 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics);
435}
436
437static void filelayout_commit_prepare(struct rpc_task *task, void *data)
438{
439 struct nfs_commit_data *wdata = data;
440
441 nfs41_setup_sequence(wdata->ds_clp->cl_session,
442 &wdata->args.seq_args,
443 &wdata->res.seq_res,
444 task);
445}
446
447static void filelayout_commit_count_stats(struct rpc_task *task, void *data)
448{
449 struct nfs_commit_data *cdata = data;
450
451 rpc_count_iostats(task, NFS_SERVER(cdata->inode)->client->cl_metrics);
452}
453
454static 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,
459};
460
461static 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,
466};
467
468static 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,
473};
474
475static enum pnfs_try_status
476filelayout_read_pagelist(struct nfs_pgio_header *hdr)
477{
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;
482 u32 j, idx;
483 struct nfs_fh *fh;
484
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);
488
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);
493 if (!ds)
494 return PNFS_NOT_ATTEMPTED;
495
496 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode);
497 if (IS_ERR(ds_clnt))
498 return PNFS_NOT_ATTEMPTED;
499
500 dprintk("%s USE DS: %s cl_count %d\n", __func__,
501 ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count));
502
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);
508 if (fh)
509 hdr->args.fh = fh;
510
511 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset);
512 hdr->mds_offset = offset;
513
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;
519}
520
521/* Perform async writes. */
522static enum pnfs_try_status
523filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync)
524{
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;
529 u32 j, idx;
530 struct nfs_fh *fh;
531
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);
536 if (!ds)
537 return PNFS_NOT_ATTEMPTED;
538
539 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode);
540 if (IS_ERR(ds_clnt))
541 return PNFS_NOT_ATTEMPTED;
542
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));
546
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);
552 if (fh)
553 hdr->args.fh = fh;
554 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset);
555
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;
561}
562
563/*
564 * filelayout_check_layout()
565 *
566 * Make sure layout segment parameters are sane WRT the device.
567 * At this point no generic layer initialization of the lseg has occurred,
568 * and nothing has been added to the layout_hdr cache.
569 *
570 */
571static int
572filelayout_check_layout(struct pnfs_layout_hdr *lo,
573 struct nfs4_filelayout_segment *fl,
574 struct nfs4_layoutget_res *lgr,
575 struct nfs4_deviceid *id,
576 gfp_t gfp_flags)
577{
578 struct nfs4_deviceid_node *d;
579 struct nfs4_file_layout_dsaddr *dsaddr;
580 int status = -EINVAL;
581
582 dprintk("--> %s\n", __func__);
583
584 /* FIXME: remove this check when layout segment support is added */
585 if (lgr->range.offset != 0 ||
586 lgr->range.length != NFS4_MAX_UINT64) {
587 dprintk("%s Only whole file layouts supported. Use MDS i/o\n",
588 __func__);
589 goto out;
590 }
591
592 if (fl->pattern_offset > lgr->range.offset) {
593 dprintk("%s pattern_offset %lld too large\n",
594 __func__, fl->pattern_offset);
595 goto out;
596 }
597
598 if (!fl->stripe_unit) {
599 dprintk("%s Invalid stripe unit (%u)\n",
600 __func__, fl->stripe_unit);
601 goto out;
602 }
603
604 /* find and reference the deviceid */
605 d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode), id,
606 lo->plh_lc_cred, gfp_flags);
607 if (d == NULL)
608 goto out;
609
610 dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
611 /* Found deviceid is unavailable */
612 if (filelayout_test_devid_unavailable(&dsaddr->id_node))
613 goto out_put;
614
615 fl->dsaddr = dsaddr;
616
617 if (fl->first_stripe_index >= dsaddr->stripe_count) {
618 dprintk("%s Bad first_stripe_index %u\n",
619 __func__, fl->first_stripe_index);
620 goto out_put;
621 }
622
623 if ((fl->stripe_type == STRIPE_SPARSE &&
624 fl->num_fh > 1 && fl->num_fh != dsaddr->ds_num) ||
625 (fl->stripe_type == STRIPE_DENSE &&
626 fl->num_fh != dsaddr->stripe_count)) {
627 dprintk("%s num_fh %u not valid for given packing\n",
628 __func__, fl->num_fh);
629 goto out_put;
630 }
631
632 status = 0;
633out:
634 dprintk("--> %s returns %d\n", __func__, status);
635 return status;
636out_put:
637 nfs4_fl_put_deviceid(dsaddr);
638 goto out;
639}
640
641static void _filelayout_free_lseg(struct nfs4_filelayout_segment *fl)
642{
643 int i;
644
645 if (fl->fh_array) {
646 for (i = 0; i < fl->num_fh; i++) {
647 if (!fl->fh_array[i])
648 break;
649 kfree(fl->fh_array[i]);
650 }
651 kfree(fl->fh_array);
652 }
653 kfree(fl);
654}
655
656static int
657filelayout_decode_layout(struct pnfs_layout_hdr *flo,
658 struct nfs4_filelayout_segment *fl,
659 struct nfs4_layoutget_res *lgr,
660 struct nfs4_deviceid *id,
661 gfp_t gfp_flags)
662{
663 struct xdr_stream stream;
664 struct xdr_buf buf;
665 struct page *scratch;
666 __be32 *p;
667 uint32_t nfl_util;
668 int i;
669
670 dprintk("%s: set_layout_map Begin\n", __func__);
671
672 scratch = alloc_page(gfp_flags);
673 if (!scratch)
674 return -ENOMEM;
675
676 xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len);
677 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
678
679 /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8),
680 * num_fh (4) */
681 p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20);
682 if (unlikely(!p))
683 goto out_err;
684
685 memcpy(id, p, sizeof(*id));
686 p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
687 nfs4_print_deviceid(id);
688
689 nfl_util = be32_to_cpup(p++);
690 if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS)
691 fl->commit_through_mds = 1;
692 if (nfl_util & NFL4_UFLG_DENSE)
693 fl->stripe_type = STRIPE_DENSE;
694 else
695 fl->stripe_type = STRIPE_SPARSE;
696 fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK;
697
698 fl->first_stripe_index = be32_to_cpup(p++);
699 p = xdr_decode_hyper(p, &fl->pattern_offset);
700 fl->num_fh = be32_to_cpup(p++);
701
702 dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n",
703 __func__, nfl_util, fl->num_fh, fl->first_stripe_index,
704 fl->pattern_offset);
705
706 /* Note that a zero value for num_fh is legal for STRIPE_SPARSE.
707 * Futher checking is done in filelayout_check_layout */
708 if (fl->num_fh >
709 max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT))
710 goto out_err;
711
712 if (fl->num_fh > 0) {
713 fl->fh_array = kcalloc(fl->num_fh, sizeof(fl->fh_array[0]),
714 gfp_flags);
715 if (!fl->fh_array)
716 goto out_err;
717 }
718
719 for (i = 0; i < fl->num_fh; i++) {
720 /* Do we want to use a mempool here? */
721 fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags);
722 if (!fl->fh_array[i])
723 goto out_err;
724
725 p = xdr_inline_decode(&stream, 4);
726 if (unlikely(!p))
727 goto out_err;
728 fl->fh_array[i]->size = be32_to_cpup(p++);
729 if (sizeof(struct nfs_fh) < fl->fh_array[i]->size) {
730 printk(KERN_ERR "NFS: Too big fh %d received %d\n",
731 i, fl->fh_array[i]->size);
732 goto out_err;
733 }
734
735 p = xdr_inline_decode(&stream, fl->fh_array[i]->size);
736 if (unlikely(!p))
737 goto out_err;
738 memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size);
739 dprintk("DEBUG: %s: fh len %d\n", __func__,
740 fl->fh_array[i]->size);
741 }
742
743 __free_page(scratch);
744 return 0;
745
746out_err:
747 __free_page(scratch);
748 return -EIO;
749}
750
751static void
752filelayout_free_lseg(struct pnfs_layout_segment *lseg)
753{
754 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
755
756 dprintk("--> %s\n", __func__);
757 nfs4_fl_put_deviceid(fl->dsaddr);
758 /* This assumes a single RW lseg */
759 if (lseg->pls_range.iomode == IOMODE_RW) {
760 struct nfs4_filelayout *flo;
761
762 flo = FILELAYOUT_FROM_HDR(lseg->pls_layout);
763 flo->commit_info.nbuckets = 0;
764 kfree(flo->commit_info.buckets);
765 flo->commit_info.buckets = NULL;
766 }
767 _filelayout_free_lseg(fl);
768}
769
770static int
771filelayout_alloc_commit_info(struct pnfs_layout_segment *lseg,
772 struct nfs_commit_info *cinfo,
773 gfp_t gfp_flags)
774{
775 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
776 struct pnfs_commit_bucket *buckets;
777 int size, i;
778
779 if (fl->commit_through_mds)
780 return 0;
781
782 size = (fl->stripe_type == STRIPE_SPARSE) ?
783 fl->dsaddr->ds_num : fl->dsaddr->stripe_count;
784
785 if (cinfo->ds->nbuckets >= size) {
786 /* This assumes there is only one IOMODE_RW lseg. What
787 * we really want to do is have a layout_hdr level
788 * dictionary of <multipath_list4, fh> keys, each
789 * associated with a struct list_head, populated by calls
790 * to filelayout_write_pagelist().
791 * */
792 return 0;
793 }
794
795 buckets = kcalloc(size, sizeof(struct pnfs_commit_bucket),
796 gfp_flags);
797 if (!buckets)
798 return -ENOMEM;
799 for (i = 0; i < size; i++) {
800 INIT_LIST_HEAD(&buckets[i].written);
801 INIT_LIST_HEAD(&buckets[i].committing);
802 /* mark direct verifier as unset */
803 buckets[i].direct_verf.committed = NFS_INVALID_STABLE_HOW;
804 }
805
806 spin_lock(&cinfo->inode->i_lock);
807 if (cinfo->ds->nbuckets >= size)
808 goto out;
809 for (i = 0; i < cinfo->ds->nbuckets; i++) {
810 list_splice(&cinfo->ds->buckets[i].written,
811 &buckets[i].written);
812 list_splice(&cinfo->ds->buckets[i].committing,
813 &buckets[i].committing);
814 buckets[i].direct_verf.committed =
815 cinfo->ds->buckets[i].direct_verf.committed;
816 buckets[i].wlseg = cinfo->ds->buckets[i].wlseg;
817 buckets[i].clseg = cinfo->ds->buckets[i].clseg;
818 }
819 swap(cinfo->ds->buckets, buckets);
820 cinfo->ds->nbuckets = size;
821out:
822 spin_unlock(&cinfo->inode->i_lock);
823 kfree(buckets);
824 return 0;
825}
826
827static struct pnfs_layout_segment *
828filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid,
829 struct nfs4_layoutget_res *lgr,
830 gfp_t gfp_flags)
831{
832 struct nfs4_filelayout_segment *fl;
833 int rc;
834 struct nfs4_deviceid id;
835
836 dprintk("--> %s\n", __func__);
837 fl = kzalloc(sizeof(*fl), gfp_flags);
838 if (!fl)
839 return NULL;
840
841 rc = filelayout_decode_layout(layoutid, fl, lgr, &id, gfp_flags);
842 if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, &id, gfp_flags)) {
843 _filelayout_free_lseg(fl);
844 return NULL;
845 }
846 return &fl->generic_hdr;
847}
848
849/*
850 * filelayout_pg_test(). Called by nfs_can_coalesce_requests()
851 *
852 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number
853 * of bytes (maximum @req->wb_bytes) that can be coalesced.
854 */
855static size_t
856filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
857 struct nfs_page *req)
858{
859 unsigned int size;
860 u64 p_stripe, r_stripe;
861 u32 stripe_offset;
862 u64 segment_offset = pgio->pg_lseg->pls_range.offset;
863 u32 stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit;
864
865 /* calls nfs_generic_pg_test */
866 size = pnfs_generic_pg_test(pgio, prev, req);
867 if (!size)
868 return 0;
869
870 /* see if req and prev are in the same stripe */
871 if (prev) {
872 p_stripe = (u64)req_offset(prev) - segment_offset;
873 r_stripe = (u64)req_offset(req) - segment_offset;
874 do_div(p_stripe, stripe_unit);
875 do_div(r_stripe, stripe_unit);
876
877 if (p_stripe != r_stripe)
878 return 0;
879 }
880
881 /* calculate remaining bytes in the current stripe */
882 div_u64_rem((u64)req_offset(req) - segment_offset,
883 stripe_unit,
884 &stripe_offset);
885 WARN_ON_ONCE(stripe_offset > stripe_unit);
886 if (stripe_offset >= stripe_unit)
887 return 0;
888 return min(stripe_unit - (unsigned int)stripe_offset, size);
889}
890
891static void
892filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio,
893 struct nfs_page *req)
894{
895 if (!pgio->pg_lseg) {
896 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
897 req->wb_context,
898 0,
899 NFS4_MAX_UINT64,
900 IOMODE_READ,
901 false,
902 GFP_KERNEL);
903 if (IS_ERR(pgio->pg_lseg)) {
904 pgio->pg_error = PTR_ERR(pgio->pg_lseg);
905 pgio->pg_lseg = NULL;
906 return;
907 }
908 }
909 /* If no lseg, fall back to read through mds */
910 if (pgio->pg_lseg == NULL)
911 nfs_pageio_reset_read_mds(pgio);
912}
913
914static void
915filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio,
916 struct nfs_page *req)
917{
918 struct nfs_commit_info cinfo;
919 int status;
920
921 if (!pgio->pg_lseg) {
922 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
923 req->wb_context,
924 0,
925 NFS4_MAX_UINT64,
926 IOMODE_RW,
927 false,
928 GFP_NOFS);
929 if (IS_ERR(pgio->pg_lseg)) {
930 pgio->pg_error = PTR_ERR(pgio->pg_lseg);
931 pgio->pg_lseg = NULL;
932 return;
933 }
934 }
935
936 /* If no lseg, fall back to write through mds */
937 if (pgio->pg_lseg == NULL)
938 goto out_mds;
939 nfs_init_cinfo(&cinfo, pgio->pg_inode, pgio->pg_dreq);
940 status = filelayout_alloc_commit_info(pgio->pg_lseg, &cinfo, GFP_NOFS);
941 if (status < 0) {
942 pnfs_put_lseg(pgio->pg_lseg);
943 pgio->pg_lseg = NULL;
944 goto out_mds;
945 }
946 return;
947out_mds:
948 nfs_pageio_reset_write_mds(pgio);
949}
950
951static const struct nfs_pageio_ops filelayout_pg_read_ops = {
952 .pg_init = filelayout_pg_init_read,
953 .pg_test = filelayout_pg_test,
954 .pg_doio = pnfs_generic_pg_readpages,
955 .pg_cleanup = pnfs_generic_pg_cleanup,
956};
957
958static const struct nfs_pageio_ops filelayout_pg_write_ops = {
959 .pg_init = filelayout_pg_init_write,
960 .pg_test = filelayout_pg_test,
961 .pg_doio = pnfs_generic_pg_writepages,
962 .pg_cleanup = pnfs_generic_pg_cleanup,
963};
964
965static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j)
966{
967 if (fl->stripe_type == STRIPE_SPARSE)
968 return nfs4_fl_calc_ds_index(&fl->generic_hdr, j);
969 else
970 return j;
971}
972
973static void
974filelayout_mark_request_commit(struct nfs_page *req,
975 struct pnfs_layout_segment *lseg,
976 struct nfs_commit_info *cinfo,
977 u32 ds_commit_idx)
978
979{
980 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
981 u32 i, j;
982
983 if (fl->commit_through_mds) {
984 nfs_request_add_commit_list(req, cinfo);
985 } else {
986 /* Note that we are calling nfs4_fl_calc_j_index on each page
987 * that ends up being committed to a data server. An attractive
988 * alternative is to add a field to nfs_write_data and nfs_page
989 * to store the value calculated in filelayout_write_pagelist
990 * and just use that here.
991 */
992 j = nfs4_fl_calc_j_index(lseg, req_offset(req));
993 i = select_bucket_index(fl, j);
994 pnfs_layout_mark_request_commit(req, lseg, cinfo, i);
995 }
996}
997
998static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i)
999{
1000 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
1001
1002 if (flseg->stripe_type == STRIPE_SPARSE)
1003 return i;
1004 else
1005 return nfs4_fl_calc_ds_index(lseg, i);
1006}
1007
1008static struct nfs_fh *
1009select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i)
1010{
1011 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
1012
1013 if (flseg->stripe_type == STRIPE_SPARSE) {
1014 if (flseg->num_fh == 1)
1015 i = 0;
1016 else if (flseg->num_fh == 0)
1017 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
1018 return NULL;
1019 }
1020 return flseg->fh_array[i];
1021}
1022
1023static int filelayout_initiate_commit(struct nfs_commit_data *data, int how)
1024{
1025 struct pnfs_layout_segment *lseg = data->lseg;
1026 struct nfs4_pnfs_ds *ds;
1027 struct rpc_clnt *ds_clnt;
1028 u32 idx;
1029 struct nfs_fh *fh;
1030
1031 idx = calc_ds_index_from_commit(lseg, data->ds_commit_index);
1032 ds = nfs4_fl_prepare_ds(lseg, idx);
1033 if (!ds)
1034 goto out_err;
1035
1036 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, data->inode);
1037 if (IS_ERR(ds_clnt))
1038 goto out_err;
1039
1040 dprintk("%s ino %lu, how %d cl_count %d\n", __func__,
1041 data->inode->i_ino, how, atomic_read(&ds->ds_clp->cl_count));
1042 data->commit_done_cb = filelayout_commit_done_cb;
1043 atomic_inc(&ds->ds_clp->cl_count);
1044 data->ds_clp = ds->ds_clp;
1045 fh = select_ds_fh_from_commit(lseg, data->ds_commit_index);
1046 if (fh)
1047 data->args.fh = fh;
1048 return nfs_initiate_commit(ds_clnt, data, NFS_PROTO(data->inode),
1049 &filelayout_commit_call_ops, how,
1050 RPC_TASK_SOFTCONN);
1051out_err:
1052 pnfs_generic_prepare_to_resend_writes(data);
1053 pnfs_generic_commit_release(data);
1054 return -EAGAIN;
1055}
1056
1057/* filelayout_search_commit_reqs - Search lists in @cinfo for the head reqest
1058 * for @page
1059 * @cinfo - commit info for current inode
1060 * @page - page to search for matching head request
1061 *
1062 * Returns a the head request if one is found, otherwise returns NULL.
1063 */
1064static struct nfs_page *
1065filelayout_search_commit_reqs(struct nfs_commit_info *cinfo, struct page *page)
1066{
1067 struct nfs_page *freq, *t;
1068 struct pnfs_commit_bucket *b;
1069 int i;
1070
1071 /* Linearly search the commit lists for each bucket until a matching
1072 * request is found */
1073 for (i = 0, b = cinfo->ds->buckets; i < cinfo->ds->nbuckets; i++, b++) {
1074 list_for_each_entry_safe(freq, t, &b->written, wb_list) {
1075 if (freq->wb_page == page)
1076 return freq->wb_head;
1077 }
1078 list_for_each_entry_safe(freq, t, &b->committing, wb_list) {
1079 if (freq->wb_page == page)
1080 return freq->wb_head;
1081 }
1082 }
1083
1084 return NULL;
1085}
1086
1087static int
1088filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages,
1089 int how, struct nfs_commit_info *cinfo)
1090{
1091 return pnfs_generic_commit_pagelist(inode, mds_pages, how, cinfo,
1092 filelayout_initiate_commit);
1093}
1094
1095static struct nfs4_deviceid_node *
1096filelayout_alloc_deviceid_node(struct nfs_server *server,
1097 struct pnfs_device *pdev, gfp_t gfp_flags)
1098{
1099 struct nfs4_file_layout_dsaddr *dsaddr;
1100
1101 dsaddr = nfs4_fl_alloc_deviceid_node(server, pdev, gfp_flags);
1102 if (!dsaddr)
1103 return NULL;
1104 return &dsaddr->id_node;
1105}
1106
1107static void
1108filelayout_free_deviceid_node(struct nfs4_deviceid_node *d)
1109{
1110 nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node));
1111}
1112
1113static struct pnfs_layout_hdr *
1114filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
1115{
1116 struct nfs4_filelayout *flo;
1117
1118 flo = kzalloc(sizeof(*flo), gfp_flags);
1119 return flo != NULL ? &flo->generic_hdr : NULL;
1120}
1121
1122static void
1123filelayout_free_layout_hdr(struct pnfs_layout_hdr *lo)
1124{
1125 kfree(FILELAYOUT_FROM_HDR(lo));
1126}
1127
1128static struct pnfs_ds_commit_info *
1129filelayout_get_ds_info(struct inode *inode)
1130{
1131 struct pnfs_layout_hdr *layout = NFS_I(inode)->layout;
1132
1133 if (layout == NULL)
1134 return NULL;
1135 else
1136 return &FILELAYOUT_FROM_HDR(layout)->commit_info;
1137}
1138
1139static struct pnfs_layoutdriver_type filelayout_type = {
1140 .id = LAYOUT_NFSV4_1_FILES,
1141 .name = "LAYOUT_NFSV4_1_FILES",
1142 .owner = THIS_MODULE,
1143 .alloc_layout_hdr = filelayout_alloc_layout_hdr,
1144 .free_layout_hdr = filelayout_free_layout_hdr,
1145 .alloc_lseg = filelayout_alloc_lseg,
1146 .free_lseg = filelayout_free_lseg,
1147 .pg_read_ops = &filelayout_pg_read_ops,
1148 .pg_write_ops = &filelayout_pg_write_ops,
1149 .get_ds_info = &filelayout_get_ds_info,
1150 .mark_request_commit = filelayout_mark_request_commit,
1151 .clear_request_commit = pnfs_generic_clear_request_commit,
1152 .scan_commit_lists = pnfs_generic_scan_commit_lists,
1153 .recover_commit_reqs = pnfs_generic_recover_commit_reqs,
1154 .search_commit_reqs = filelayout_search_commit_reqs,
1155 .commit_pagelist = filelayout_commit_pagelist,
1156 .read_pagelist = filelayout_read_pagelist,
1157 .write_pagelist = filelayout_write_pagelist,
1158 .alloc_deviceid_node = filelayout_alloc_deviceid_node,
1159 .free_deviceid_node = filelayout_free_deviceid_node,
1160 .sync = pnfs_nfs_generic_sync,
1161};
1162
1163static int __init nfs4filelayout_init(void)
1164{
1165 printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n",
1166 __func__);
1167 return pnfs_register_layoutdriver(&filelayout_type);
1168}
1169
1170static void __exit nfs4filelayout_exit(void)
1171{
1172 printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n",
1173 __func__);
1174 pnfs_unregister_layoutdriver(&filelayout_type);
1175}
1176
1177MODULE_ALIAS("nfs-layouttype4-1");
1178
1179module_init(nfs4filelayout_init);
1180module_exit(nfs4filelayout_exit);
1/*
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.
5 *
6 * Copyright (c) 2002
7 * The Regents of the University of Michigan
8 * All Rights Reserved
9 *
10 * Dean Hildebrand <dhildebz@umich.edu>
11 *
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.
20 *
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
29 * such damages.
30 */
31
32#include <linux/nfs_fs.h>
33#include <linux/nfs_page.h>
34#include <linux/module.h>
35#include <linux/backing-dev.h>
36
37#include <linux/sunrpc/metrics.h>
38
39#include "../nfs4session.h"
40#include "../internal.h"
41#include "../delegation.h"
42#include "filelayout.h"
43#include "../nfs4trace.h"
44
45#define NFSDBG_FACILITY NFSDBG_PNFS_LD
46
47MODULE_LICENSE("GPL");
48MODULE_AUTHOR("Dean Hildebrand <dhildebz@umich.edu>");
49MODULE_DESCRIPTION("The NFSv4 file layout driver");
50
51#define FILELAYOUT_POLL_RETRY_MAX (15*HZ)
52static const struct pnfs_commit_ops filelayout_commit_ops;
53
54static loff_t
55filelayout_get_dense_offset(struct nfs4_filelayout_segment *flseg,
56 loff_t offset)
57{
58 u32 stripe_width = flseg->stripe_unit * flseg->dsaddr->stripe_count;
59 u64 stripe_no;
60 u32 rem;
61
62 offset -= flseg->pattern_offset;
63 stripe_no = div_u64(offset, stripe_width);
64 div_u64_rem(offset, flseg->stripe_unit, &rem);
65
66 return stripe_no * flseg->stripe_unit + rem;
67}
68
69/* This function is used by the layout driver to calculate the
70 * offset of the file on the dserver based on whether the
71 * layout type is STRIPE_DENSE or STRIPE_SPARSE
72 */
73static loff_t
74filelayout_get_dserver_offset(struct pnfs_layout_segment *lseg, loff_t offset)
75{
76 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
77
78 switch (flseg->stripe_type) {
79 case STRIPE_SPARSE:
80 return offset;
81
82 case STRIPE_DENSE:
83 return filelayout_get_dense_offset(flseg, offset);
84 }
85
86 BUG();
87}
88
89static void filelayout_reset_write(struct nfs_pgio_header *hdr)
90{
91 struct rpc_task *task = &hdr->task;
92
93 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
94 dprintk("%s Reset task %5u for i/o through MDS "
95 "(req %s/%llu, %u bytes @ offset %llu)\n", __func__,
96 hdr->task.tk_pid,
97 hdr->inode->i_sb->s_id,
98 (unsigned long long)NFS_FILEID(hdr->inode),
99 hdr->args.count,
100 (unsigned long long)hdr->args.offset);
101
102 task->tk_status = pnfs_write_done_resend_to_mds(hdr);
103 }
104}
105
106static void filelayout_reset_read(struct nfs_pgio_header *hdr)
107{
108 struct rpc_task *task = &hdr->task;
109
110 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
111 dprintk("%s Reset task %5u for i/o through MDS "
112 "(req %s/%llu, %u bytes @ offset %llu)\n", __func__,
113 hdr->task.tk_pid,
114 hdr->inode->i_sb->s_id,
115 (unsigned long long)NFS_FILEID(hdr->inode),
116 hdr->args.count,
117 (unsigned long long)hdr->args.offset);
118
119 task->tk_status = pnfs_read_done_resend_to_mds(hdr);
120 }
121}
122
123static int filelayout_async_handle_error(struct rpc_task *task,
124 struct nfs4_state *state,
125 struct nfs_client *clp,
126 struct pnfs_layout_segment *lseg)
127{
128 struct pnfs_layout_hdr *lo = lseg->pls_layout;
129 struct inode *inode = lo->plh_inode;
130 struct nfs4_deviceid_node *devid = FILELAYOUT_DEVID_NODE(lseg);
131 struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table;
132
133 if (task->tk_status >= 0)
134 return 0;
135
136 switch (task->tk_status) {
137 /* DS session errors */
138 case -NFS4ERR_BADSESSION:
139 case -NFS4ERR_BADSLOT:
140 case -NFS4ERR_BAD_HIGH_SLOT:
141 case -NFS4ERR_DEADSESSION:
142 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
143 case -NFS4ERR_SEQ_FALSE_RETRY:
144 case -NFS4ERR_SEQ_MISORDERED:
145 dprintk("%s ERROR %d, Reset session. Exchangeid "
146 "flags 0x%x\n", __func__, task->tk_status,
147 clp->cl_exchange_flags);
148 nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
149 break;
150 case -NFS4ERR_DELAY:
151 case -NFS4ERR_GRACE:
152 rpc_delay(task, FILELAYOUT_POLL_RETRY_MAX);
153 break;
154 case -NFS4ERR_RETRY_UNCACHED_REP:
155 break;
156 /* Invalidate Layout errors */
157 case -NFS4ERR_ACCESS:
158 case -NFS4ERR_PNFS_NO_LAYOUT:
159 case -ESTALE: /* mapped NFS4ERR_STALE */
160 case -EBADHANDLE: /* mapped NFS4ERR_BADHANDLE */
161 case -EISDIR: /* mapped NFS4ERR_ISDIR */
162 case -NFS4ERR_FHEXPIRED:
163 case -NFS4ERR_WRONG_TYPE:
164 dprintk("%s Invalid layout error %d\n", __func__,
165 task->tk_status);
166 /*
167 * Destroy layout so new i/o will get a new layout.
168 * Layout will not be destroyed until all current lseg
169 * references are put. Mark layout as invalid to resend failed
170 * i/o and all i/o waiting on the slot table to the MDS until
171 * layout is destroyed and a new valid layout is obtained.
172 */
173 pnfs_destroy_layout(NFS_I(inode));
174 rpc_wake_up(&tbl->slot_tbl_waitq);
175 goto reset;
176 /* RPC connection errors */
177 case -ECONNREFUSED:
178 case -EHOSTDOWN:
179 case -EHOSTUNREACH:
180 case -ENETUNREACH:
181 case -EIO:
182 case -ETIMEDOUT:
183 case -EPIPE:
184 dprintk("%s DS connection error %d\n", __func__,
185 task->tk_status);
186 nfs4_mark_deviceid_unavailable(devid);
187 pnfs_error_mark_layout_for_return(inode, lseg);
188 pnfs_set_lo_fail(lseg);
189 rpc_wake_up(&tbl->slot_tbl_waitq);
190 fallthrough;
191 default:
192reset:
193 dprintk("%s Retry through MDS. Error %d\n", __func__,
194 task->tk_status);
195 return -NFS4ERR_RESET_TO_MDS;
196 }
197 task->tk_status = 0;
198 return -EAGAIN;
199}
200
201/* NFS_PROTO call done callback routines */
202
203static int filelayout_read_done_cb(struct rpc_task *task,
204 struct nfs_pgio_header *hdr)
205{
206 int err;
207
208 trace_nfs4_pnfs_read(hdr, task->tk_status);
209 err = filelayout_async_handle_error(task, hdr->args.context->state,
210 hdr->ds_clp, hdr->lseg);
211
212 switch (err) {
213 case -NFS4ERR_RESET_TO_MDS:
214 filelayout_reset_read(hdr);
215 return task->tk_status;
216 case -EAGAIN:
217 rpc_restart_call_prepare(task);
218 return -EAGAIN;
219 }
220
221 return 0;
222}
223
224/*
225 * We reference the rpc_cred of the first WRITE that triggers the need for
226 * a LAYOUTCOMMIT, and use it to send the layoutcommit compound.
227 * rfc5661 is not clear about which credential should be used.
228 */
229static void
230filelayout_set_layoutcommit(struct nfs_pgio_header *hdr)
231{
232 loff_t end_offs = 0;
233
234 if (FILELAYOUT_LSEG(hdr->lseg)->commit_through_mds ||
235 hdr->res.verf->committed == NFS_FILE_SYNC)
236 return;
237 if (hdr->res.verf->committed == NFS_DATA_SYNC)
238 end_offs = hdr->mds_offset + (loff_t)hdr->res.count;
239
240 /* Note: if the write is unstable, don't set end_offs until commit */
241 pnfs_set_layoutcommit(hdr->inode, hdr->lseg, end_offs);
242 dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
243 (unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
244}
245
246bool
247filelayout_test_devid_unavailable(struct nfs4_deviceid_node *node)
248{
249 return filelayout_test_devid_invalid(node) ||
250 nfs4_test_deviceid_unavailable(node);
251}
252
253static bool
254filelayout_reset_to_mds(struct pnfs_layout_segment *lseg)
255{
256 struct nfs4_deviceid_node *node = FILELAYOUT_DEVID_NODE(lseg);
257
258 return filelayout_test_devid_unavailable(node);
259}
260
261/*
262 * Call ops for the async read/write cases
263 * In the case of dense layouts, the offset needs to be reset to its
264 * original value.
265 */
266static void filelayout_read_prepare(struct rpc_task *task, void *data)
267{
268 struct nfs_pgio_header *hdr = data;
269
270 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
271 rpc_exit(task, -EIO);
272 return;
273 }
274 if (filelayout_reset_to_mds(hdr->lseg)) {
275 dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid);
276 filelayout_reset_read(hdr);
277 rpc_exit(task, 0);
278 return;
279 }
280 hdr->pgio_done_cb = filelayout_read_done_cb;
281
282 if (nfs4_setup_sequence(hdr->ds_clp,
283 &hdr->args.seq_args,
284 &hdr->res.seq_res,
285 task))
286 return;
287 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
288 hdr->args.lock_context, FMODE_READ) == -EIO)
289 rpc_exit(task, -EIO); /* lost lock, terminate I/O */
290}
291
292static void filelayout_read_call_done(struct rpc_task *task, void *data)
293{
294 struct nfs_pgio_header *hdr = data;
295
296 dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status);
297
298 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
299 task->tk_status == 0) {
300 nfs41_sequence_done(task, &hdr->res.seq_res);
301 return;
302 }
303
304 /* Note this may cause RPC to be resent */
305 hdr->mds_ops->rpc_call_done(task, data);
306}
307
308static void filelayout_read_count_stats(struct rpc_task *task, void *data)
309{
310 struct nfs_pgio_header *hdr = data;
311
312 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics);
313}
314
315static int filelayout_write_done_cb(struct rpc_task *task,
316 struct nfs_pgio_header *hdr)
317{
318 int err;
319
320 trace_nfs4_pnfs_write(hdr, task->tk_status);
321 err = filelayout_async_handle_error(task, hdr->args.context->state,
322 hdr->ds_clp, hdr->lseg);
323
324 switch (err) {
325 case -NFS4ERR_RESET_TO_MDS:
326 filelayout_reset_write(hdr);
327 return task->tk_status;
328 case -EAGAIN:
329 rpc_restart_call_prepare(task);
330 return -EAGAIN;
331 }
332
333 filelayout_set_layoutcommit(hdr);
334
335 /* zero out the fattr */
336 hdr->fattr.valid = 0;
337 if (task->tk_status >= 0)
338 nfs_writeback_update_inode(hdr);
339
340 return 0;
341}
342
343static int filelayout_commit_done_cb(struct rpc_task *task,
344 struct nfs_commit_data *data)
345{
346 int err;
347
348 trace_nfs4_pnfs_commit_ds(data, task->tk_status);
349 err = filelayout_async_handle_error(task, NULL, data->ds_clp,
350 data->lseg);
351
352 switch (err) {
353 case -NFS4ERR_RESET_TO_MDS:
354 pnfs_generic_prepare_to_resend_writes(data);
355 return -EAGAIN;
356 case -EAGAIN:
357 rpc_restart_call_prepare(task);
358 return -EAGAIN;
359 }
360
361 pnfs_set_layoutcommit(data->inode, data->lseg, data->lwb);
362
363 return 0;
364}
365
366static void filelayout_write_prepare(struct rpc_task *task, void *data)
367{
368 struct nfs_pgio_header *hdr = data;
369
370 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
371 rpc_exit(task, -EIO);
372 return;
373 }
374 if (filelayout_reset_to_mds(hdr->lseg)) {
375 dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid);
376 filelayout_reset_write(hdr);
377 rpc_exit(task, 0);
378 return;
379 }
380 if (nfs4_setup_sequence(hdr->ds_clp,
381 &hdr->args.seq_args,
382 &hdr->res.seq_res,
383 task))
384 return;
385 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
386 hdr->args.lock_context, FMODE_WRITE) == -EIO)
387 rpc_exit(task, -EIO); /* lost lock, terminate I/O */
388}
389
390static void filelayout_write_call_done(struct rpc_task *task, void *data)
391{
392 struct nfs_pgio_header *hdr = data;
393
394 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
395 task->tk_status == 0) {
396 nfs41_sequence_done(task, &hdr->res.seq_res);
397 return;
398 }
399
400 /* Note this may cause RPC to be resent */
401 hdr->mds_ops->rpc_call_done(task, data);
402}
403
404static void filelayout_write_count_stats(struct rpc_task *task, void *data)
405{
406 struct nfs_pgio_header *hdr = data;
407
408 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics);
409}
410
411static void filelayout_commit_prepare(struct rpc_task *task, void *data)
412{
413 struct nfs_commit_data *wdata = data;
414
415 nfs4_setup_sequence(wdata->ds_clp,
416 &wdata->args.seq_args,
417 &wdata->res.seq_res,
418 task);
419}
420
421static void filelayout_commit_count_stats(struct rpc_task *task, void *data)
422{
423 struct nfs_commit_data *cdata = data;
424
425 rpc_count_iostats(task, NFS_SERVER(cdata->inode)->client->cl_metrics);
426}
427
428static const struct rpc_call_ops filelayout_read_call_ops = {
429 .rpc_call_prepare = filelayout_read_prepare,
430 .rpc_call_done = filelayout_read_call_done,
431 .rpc_count_stats = filelayout_read_count_stats,
432 .rpc_release = pnfs_generic_rw_release,
433};
434
435static const struct rpc_call_ops filelayout_write_call_ops = {
436 .rpc_call_prepare = filelayout_write_prepare,
437 .rpc_call_done = filelayout_write_call_done,
438 .rpc_count_stats = filelayout_write_count_stats,
439 .rpc_release = pnfs_generic_rw_release,
440};
441
442static const struct rpc_call_ops filelayout_commit_call_ops = {
443 .rpc_call_prepare = filelayout_commit_prepare,
444 .rpc_call_done = pnfs_generic_write_commit_done,
445 .rpc_count_stats = filelayout_commit_count_stats,
446 .rpc_release = pnfs_generic_commit_release,
447};
448
449static enum pnfs_try_status
450filelayout_read_pagelist(struct nfs_pgio_header *hdr)
451{
452 struct pnfs_layout_segment *lseg = hdr->lseg;
453 struct nfs4_pnfs_ds *ds;
454 struct rpc_clnt *ds_clnt;
455 loff_t offset = hdr->args.offset;
456 u32 j, idx;
457 struct nfs_fh *fh;
458
459 dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n",
460 __func__, hdr->inode->i_ino,
461 hdr->args.pgbase, (size_t)hdr->args.count, offset);
462
463 /* Retrieve the correct rpc_client for the byte range */
464 j = nfs4_fl_calc_j_index(lseg, offset);
465 idx = nfs4_fl_calc_ds_index(lseg, j);
466 ds = nfs4_fl_prepare_ds(lseg, idx);
467 if (!ds)
468 return PNFS_NOT_ATTEMPTED;
469
470 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode);
471 if (IS_ERR(ds_clnt))
472 return PNFS_NOT_ATTEMPTED;
473
474 dprintk("%s USE DS: %s cl_count %d\n", __func__,
475 ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count));
476
477 /* No multipath support. Use first DS */
478 refcount_inc(&ds->ds_clp->cl_count);
479 hdr->ds_clp = ds->ds_clp;
480 hdr->ds_commit_idx = idx;
481 fh = nfs4_fl_select_ds_fh(lseg, j);
482 if (fh)
483 hdr->args.fh = fh;
484
485 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset);
486 hdr->mds_offset = offset;
487
488 /* Perform an asynchronous read to ds */
489 nfs_initiate_pgio(ds_clnt, hdr, hdr->cred,
490 NFS_PROTO(hdr->inode), &filelayout_read_call_ops,
491 0, RPC_TASK_SOFTCONN);
492 return PNFS_ATTEMPTED;
493}
494
495/* Perform async writes. */
496static enum pnfs_try_status
497filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync)
498{
499 struct pnfs_layout_segment *lseg = hdr->lseg;
500 struct nfs4_pnfs_ds *ds;
501 struct rpc_clnt *ds_clnt;
502 loff_t offset = hdr->args.offset;
503 u32 j, idx;
504 struct nfs_fh *fh;
505
506 /* Retrieve the correct rpc_client for the byte range */
507 j = nfs4_fl_calc_j_index(lseg, offset);
508 idx = nfs4_fl_calc_ds_index(lseg, j);
509 ds = nfs4_fl_prepare_ds(lseg, idx);
510 if (!ds)
511 return PNFS_NOT_ATTEMPTED;
512
513 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode);
514 if (IS_ERR(ds_clnt))
515 return PNFS_NOT_ATTEMPTED;
516
517 dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d\n",
518 __func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count,
519 offset, ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count));
520
521 hdr->pgio_done_cb = filelayout_write_done_cb;
522 refcount_inc(&ds->ds_clp->cl_count);
523 hdr->ds_clp = ds->ds_clp;
524 hdr->ds_commit_idx = idx;
525 fh = nfs4_fl_select_ds_fh(lseg, j);
526 if (fh)
527 hdr->args.fh = fh;
528 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset);
529
530 /* Perform an asynchronous write */
531 nfs_initiate_pgio(ds_clnt, hdr, hdr->cred,
532 NFS_PROTO(hdr->inode), &filelayout_write_call_ops,
533 sync, RPC_TASK_SOFTCONN);
534 return PNFS_ATTEMPTED;
535}
536
537static int
538filelayout_check_deviceid(struct pnfs_layout_hdr *lo,
539 struct nfs4_filelayout_segment *fl,
540 gfp_t gfp_flags)
541{
542 struct nfs4_deviceid_node *d;
543 struct nfs4_file_layout_dsaddr *dsaddr;
544 int status = -EINVAL;
545
546 /* Is the deviceid already set? If so, we're good. */
547 if (fl->dsaddr != NULL)
548 return 0;
549
550 /* find and reference the deviceid */
551 d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode), &fl->deviceid,
552 lo->plh_lc_cred, gfp_flags);
553 if (d == NULL)
554 goto out;
555
556 dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
557 /* Found deviceid is unavailable */
558 if (filelayout_test_devid_unavailable(&dsaddr->id_node))
559 goto out_put;
560
561 if (fl->first_stripe_index >= dsaddr->stripe_count) {
562 dprintk("%s Bad first_stripe_index %u\n",
563 __func__, fl->first_stripe_index);
564 goto out_put;
565 }
566
567 if ((fl->stripe_type == STRIPE_SPARSE &&
568 fl->num_fh > 1 && fl->num_fh != dsaddr->ds_num) ||
569 (fl->stripe_type == STRIPE_DENSE &&
570 fl->num_fh != dsaddr->stripe_count)) {
571 dprintk("%s num_fh %u not valid for given packing\n",
572 __func__, fl->num_fh);
573 goto out_put;
574 }
575 status = 0;
576
577 /*
578 * Atomic compare and xchange to ensure we don't scribble
579 * over a non-NULL pointer.
580 */
581 if (cmpxchg(&fl->dsaddr, NULL, dsaddr) != NULL)
582 goto out_put;
583out:
584 return status;
585out_put:
586 nfs4_fl_put_deviceid(dsaddr);
587 goto out;
588}
589
590/*
591 * filelayout_check_layout()
592 *
593 * Make sure layout segment parameters are sane WRT the device.
594 * At this point no generic layer initialization of the lseg has occurred,
595 * and nothing has been added to the layout_hdr cache.
596 *
597 */
598static int
599filelayout_check_layout(struct pnfs_layout_hdr *lo,
600 struct nfs4_filelayout_segment *fl,
601 struct nfs4_layoutget_res *lgr,
602 gfp_t gfp_flags)
603{
604 int status = -EINVAL;
605
606 dprintk("--> %s\n", __func__);
607
608 /* FIXME: remove this check when layout segment support is added */
609 if (lgr->range.offset != 0 ||
610 lgr->range.length != NFS4_MAX_UINT64) {
611 dprintk("%s Only whole file layouts supported. Use MDS i/o\n",
612 __func__);
613 goto out;
614 }
615
616 if (fl->pattern_offset > lgr->range.offset) {
617 dprintk("%s pattern_offset %lld too large\n",
618 __func__, fl->pattern_offset);
619 goto out;
620 }
621
622 if (!fl->stripe_unit) {
623 dprintk("%s Invalid stripe unit (%u)\n",
624 __func__, fl->stripe_unit);
625 goto out;
626 }
627
628 status = 0;
629out:
630 dprintk("--> %s returns %d\n", __func__, status);
631 return status;
632}
633
634static void _filelayout_free_lseg(struct nfs4_filelayout_segment *fl)
635{
636 int i;
637
638 if (fl->fh_array) {
639 for (i = 0; i < fl->num_fh; i++) {
640 if (!fl->fh_array[i])
641 break;
642 kfree(fl->fh_array[i]);
643 }
644 kfree(fl->fh_array);
645 }
646 kfree(fl);
647}
648
649static int
650filelayout_decode_layout(struct pnfs_layout_hdr *flo,
651 struct nfs4_filelayout_segment *fl,
652 struct nfs4_layoutget_res *lgr,
653 gfp_t gfp_flags)
654{
655 struct xdr_stream stream;
656 struct xdr_buf buf;
657 struct page *scratch;
658 __be32 *p;
659 uint32_t nfl_util;
660 int i;
661
662 dprintk("%s: set_layout_map Begin\n", __func__);
663
664 scratch = alloc_page(gfp_flags);
665 if (!scratch)
666 return -ENOMEM;
667
668 xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len);
669 xdr_set_scratch_page(&stream, scratch);
670
671 /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8),
672 * num_fh (4) */
673 p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20);
674 if (unlikely(!p))
675 goto out_err;
676
677 memcpy(&fl->deviceid, p, sizeof(fl->deviceid));
678 p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
679 nfs4_print_deviceid(&fl->deviceid);
680
681 nfl_util = be32_to_cpup(p++);
682 if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS)
683 fl->commit_through_mds = 1;
684 if (nfl_util & NFL4_UFLG_DENSE)
685 fl->stripe_type = STRIPE_DENSE;
686 else
687 fl->stripe_type = STRIPE_SPARSE;
688 fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK;
689
690 fl->first_stripe_index = be32_to_cpup(p++);
691 p = xdr_decode_hyper(p, &fl->pattern_offset);
692 fl->num_fh = be32_to_cpup(p++);
693
694 dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n",
695 __func__, nfl_util, fl->num_fh, fl->first_stripe_index,
696 fl->pattern_offset);
697
698 /* Note that a zero value for num_fh is legal for STRIPE_SPARSE.
699 * Futher checking is done in filelayout_check_layout */
700 if (fl->num_fh >
701 max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT))
702 goto out_err;
703
704 if (fl->num_fh > 0) {
705 fl->fh_array = kcalloc(fl->num_fh, sizeof(fl->fh_array[0]),
706 gfp_flags);
707 if (!fl->fh_array)
708 goto out_err;
709 }
710
711 for (i = 0; i < fl->num_fh; i++) {
712 /* Do we want to use a mempool here? */
713 fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags);
714 if (!fl->fh_array[i])
715 goto out_err;
716
717 p = xdr_inline_decode(&stream, 4);
718 if (unlikely(!p))
719 goto out_err;
720 fl->fh_array[i]->size = be32_to_cpup(p++);
721 if (fl->fh_array[i]->size > NFS_MAXFHSIZE) {
722 printk(KERN_ERR "NFS: Too big fh %d received %d\n",
723 i, fl->fh_array[i]->size);
724 goto out_err;
725 }
726
727 p = xdr_inline_decode(&stream, fl->fh_array[i]->size);
728 if (unlikely(!p))
729 goto out_err;
730 memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size);
731 dprintk("DEBUG: %s: fh len %d\n", __func__,
732 fl->fh_array[i]->size);
733 }
734
735 __free_page(scratch);
736 return 0;
737
738out_err:
739 __free_page(scratch);
740 return -EIO;
741}
742
743static void
744filelayout_free_lseg(struct pnfs_layout_segment *lseg)
745{
746 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
747
748 dprintk("--> %s\n", __func__);
749 if (fl->dsaddr != NULL)
750 nfs4_fl_put_deviceid(fl->dsaddr);
751 /* This assumes a single RW lseg */
752 if (lseg->pls_range.iomode == IOMODE_RW) {
753 struct nfs4_filelayout *flo;
754 struct inode *inode;
755
756 flo = FILELAYOUT_FROM_HDR(lseg->pls_layout);
757 inode = flo->generic_hdr.plh_inode;
758 spin_lock(&inode->i_lock);
759 pnfs_generic_ds_cinfo_release_lseg(&flo->commit_info, lseg);
760 spin_unlock(&inode->i_lock);
761 }
762 _filelayout_free_lseg(fl);
763}
764
765static struct pnfs_layout_segment *
766filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid,
767 struct nfs4_layoutget_res *lgr,
768 gfp_t gfp_flags)
769{
770 struct nfs4_filelayout_segment *fl;
771 int rc;
772
773 dprintk("--> %s\n", __func__);
774 fl = kzalloc(sizeof(*fl), gfp_flags);
775 if (!fl)
776 return NULL;
777
778 rc = filelayout_decode_layout(layoutid, fl, lgr, gfp_flags);
779 if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, gfp_flags)) {
780 _filelayout_free_lseg(fl);
781 return NULL;
782 }
783 return &fl->generic_hdr;
784}
785
786/*
787 * filelayout_pg_test(). Called by nfs_can_coalesce_requests()
788 *
789 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number
790 * of bytes (maximum @req->wb_bytes) that can be coalesced.
791 */
792static size_t
793filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
794 struct nfs_page *req)
795{
796 unsigned int size;
797 u64 p_stripe, r_stripe;
798 u32 stripe_offset;
799 u64 segment_offset = pgio->pg_lseg->pls_range.offset;
800 u32 stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit;
801
802 /* calls nfs_generic_pg_test */
803 size = pnfs_generic_pg_test(pgio, prev, req);
804 if (!size)
805 return 0;
806
807 /* see if req and prev are in the same stripe */
808 if (prev) {
809 p_stripe = (u64)req_offset(prev) - segment_offset;
810 r_stripe = (u64)req_offset(req) - segment_offset;
811 do_div(p_stripe, stripe_unit);
812 do_div(r_stripe, stripe_unit);
813
814 if (p_stripe != r_stripe)
815 return 0;
816 }
817
818 /* calculate remaining bytes in the current stripe */
819 div_u64_rem((u64)req_offset(req) - segment_offset,
820 stripe_unit,
821 &stripe_offset);
822 WARN_ON_ONCE(stripe_offset > stripe_unit);
823 if (stripe_offset >= stripe_unit)
824 return 0;
825 return min(stripe_unit - (unsigned int)stripe_offset, size);
826}
827
828static struct pnfs_layout_segment *
829fl_pnfs_update_layout(struct inode *ino,
830 struct nfs_open_context *ctx,
831 loff_t pos,
832 u64 count,
833 enum pnfs_iomode iomode,
834 bool strict_iomode,
835 gfp_t gfp_flags)
836{
837 struct pnfs_layout_segment *lseg = NULL;
838 struct pnfs_layout_hdr *lo;
839 struct nfs4_filelayout_segment *fl;
840 int status;
841
842 lseg = pnfs_update_layout(ino, ctx, pos, count, iomode, strict_iomode,
843 gfp_flags);
844 if (IS_ERR_OR_NULL(lseg))
845 goto out;
846
847 lo = NFS_I(ino)->layout;
848 fl = FILELAYOUT_LSEG(lseg);
849
850 status = filelayout_check_deviceid(lo, fl, gfp_flags);
851 if (status) {
852 pnfs_put_lseg(lseg);
853 lseg = NULL;
854 }
855out:
856 return lseg;
857}
858
859static void
860filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio,
861 struct nfs_page *req)
862{
863 pnfs_generic_pg_check_layout(pgio);
864 if (!pgio->pg_lseg) {
865 pgio->pg_lseg = fl_pnfs_update_layout(pgio->pg_inode,
866 nfs_req_openctx(req),
867 0,
868 NFS4_MAX_UINT64,
869 IOMODE_READ,
870 false,
871 GFP_KERNEL);
872 if (IS_ERR(pgio->pg_lseg)) {
873 pgio->pg_error = PTR_ERR(pgio->pg_lseg);
874 pgio->pg_lseg = NULL;
875 return;
876 }
877 }
878 /* If no lseg, fall back to read through mds */
879 if (pgio->pg_lseg == NULL)
880 nfs_pageio_reset_read_mds(pgio);
881}
882
883static void
884filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio,
885 struct nfs_page *req)
886{
887 pnfs_generic_pg_check_layout(pgio);
888 if (!pgio->pg_lseg) {
889 pgio->pg_lseg = fl_pnfs_update_layout(pgio->pg_inode,
890 nfs_req_openctx(req),
891 0,
892 NFS4_MAX_UINT64,
893 IOMODE_RW,
894 false,
895 GFP_NOFS);
896 if (IS_ERR(pgio->pg_lseg)) {
897 pgio->pg_error = PTR_ERR(pgio->pg_lseg);
898 pgio->pg_lseg = NULL;
899 return;
900 }
901 }
902
903 /* If no lseg, fall back to write through mds */
904 if (pgio->pg_lseg == NULL)
905 nfs_pageio_reset_write_mds(pgio);
906}
907
908static const struct nfs_pageio_ops filelayout_pg_read_ops = {
909 .pg_init = filelayout_pg_init_read,
910 .pg_test = filelayout_pg_test,
911 .pg_doio = pnfs_generic_pg_readpages,
912 .pg_cleanup = pnfs_generic_pg_cleanup,
913};
914
915static const struct nfs_pageio_ops filelayout_pg_write_ops = {
916 .pg_init = filelayout_pg_init_write,
917 .pg_test = filelayout_pg_test,
918 .pg_doio = pnfs_generic_pg_writepages,
919 .pg_cleanup = pnfs_generic_pg_cleanup,
920};
921
922static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j)
923{
924 if (fl->stripe_type == STRIPE_SPARSE)
925 return nfs4_fl_calc_ds_index(&fl->generic_hdr, j);
926 else
927 return j;
928}
929
930static void
931filelayout_mark_request_commit(struct nfs_page *req,
932 struct pnfs_layout_segment *lseg,
933 struct nfs_commit_info *cinfo,
934 u32 ds_commit_idx)
935
936{
937 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
938 u32 i, j;
939
940 if (fl->commit_through_mds) {
941 nfs_request_add_commit_list(req, cinfo);
942 } else {
943 /* Note that we are calling nfs4_fl_calc_j_index on each page
944 * that ends up being committed to a data server. An attractive
945 * alternative is to add a field to nfs_write_data and nfs_page
946 * to store the value calculated in filelayout_write_pagelist
947 * and just use that here.
948 */
949 j = nfs4_fl_calc_j_index(lseg, req_offset(req));
950 i = select_bucket_index(fl, j);
951 pnfs_layout_mark_request_commit(req, lseg, cinfo, i);
952 }
953}
954
955static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i)
956{
957 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
958
959 if (flseg->stripe_type == STRIPE_SPARSE)
960 return i;
961 else
962 return nfs4_fl_calc_ds_index(lseg, i);
963}
964
965static struct nfs_fh *
966select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i)
967{
968 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
969
970 if (flseg->stripe_type == STRIPE_SPARSE) {
971 if (flseg->num_fh == 1)
972 i = 0;
973 else if (flseg->num_fh == 0)
974 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
975 return NULL;
976 }
977 return flseg->fh_array[i];
978}
979
980static int filelayout_initiate_commit(struct nfs_commit_data *data, int how)
981{
982 struct pnfs_layout_segment *lseg = data->lseg;
983 struct nfs4_pnfs_ds *ds;
984 struct rpc_clnt *ds_clnt;
985 u32 idx;
986 struct nfs_fh *fh;
987
988 idx = calc_ds_index_from_commit(lseg, data->ds_commit_index);
989 ds = nfs4_fl_prepare_ds(lseg, idx);
990 if (!ds)
991 goto out_err;
992
993 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, data->inode);
994 if (IS_ERR(ds_clnt))
995 goto out_err;
996
997 dprintk("%s ino %lu, how %d cl_count %d\n", __func__,
998 data->inode->i_ino, how, refcount_read(&ds->ds_clp->cl_count));
999 data->commit_done_cb = filelayout_commit_done_cb;
1000 refcount_inc(&ds->ds_clp->cl_count);
1001 data->ds_clp = ds->ds_clp;
1002 fh = select_ds_fh_from_commit(lseg, data->ds_commit_index);
1003 if (fh)
1004 data->args.fh = fh;
1005 return nfs_initiate_commit(ds_clnt, data, NFS_PROTO(data->inode),
1006 &filelayout_commit_call_ops, how,
1007 RPC_TASK_SOFTCONN);
1008out_err:
1009 pnfs_generic_prepare_to_resend_writes(data);
1010 pnfs_generic_commit_release(data);
1011 return -EAGAIN;
1012}
1013
1014static int
1015filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages,
1016 int how, struct nfs_commit_info *cinfo)
1017{
1018 return pnfs_generic_commit_pagelist(inode, mds_pages, how, cinfo,
1019 filelayout_initiate_commit);
1020}
1021
1022static struct nfs4_deviceid_node *
1023filelayout_alloc_deviceid_node(struct nfs_server *server,
1024 struct pnfs_device *pdev, gfp_t gfp_flags)
1025{
1026 struct nfs4_file_layout_dsaddr *dsaddr;
1027
1028 dsaddr = nfs4_fl_alloc_deviceid_node(server, pdev, gfp_flags);
1029 if (!dsaddr)
1030 return NULL;
1031 return &dsaddr->id_node;
1032}
1033
1034static void
1035filelayout_free_deviceid_node(struct nfs4_deviceid_node *d)
1036{
1037 nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node));
1038}
1039
1040static struct pnfs_layout_hdr *
1041filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
1042{
1043 struct nfs4_filelayout *flo;
1044
1045 flo = kzalloc(sizeof(*flo), gfp_flags);
1046 if (flo == NULL)
1047 return NULL;
1048 pnfs_init_ds_commit_info(&flo->commit_info);
1049 flo->commit_info.ops = &filelayout_commit_ops;
1050 return &flo->generic_hdr;
1051}
1052
1053static void
1054filelayout_free_layout_hdr(struct pnfs_layout_hdr *lo)
1055{
1056 kfree_rcu(FILELAYOUT_FROM_HDR(lo), generic_hdr.plh_rcu);
1057}
1058
1059static struct pnfs_ds_commit_info *
1060filelayout_get_ds_info(struct inode *inode)
1061{
1062 struct pnfs_layout_hdr *layout = NFS_I(inode)->layout;
1063
1064 if (layout == NULL)
1065 return NULL;
1066 else
1067 return &FILELAYOUT_FROM_HDR(layout)->commit_info;
1068}
1069
1070static void
1071filelayout_setup_ds_info(struct pnfs_ds_commit_info *fl_cinfo,
1072 struct pnfs_layout_segment *lseg)
1073{
1074 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
1075 struct inode *inode = lseg->pls_layout->plh_inode;
1076 struct pnfs_commit_array *array, *new;
1077 unsigned int size = (fl->stripe_type == STRIPE_SPARSE) ?
1078 fl->dsaddr->ds_num : fl->dsaddr->stripe_count;
1079
1080 new = pnfs_alloc_commit_array(size, GFP_NOIO);
1081 if (new) {
1082 spin_lock(&inode->i_lock);
1083 array = pnfs_add_commit_array(fl_cinfo, new, lseg);
1084 spin_unlock(&inode->i_lock);
1085 if (array != new)
1086 pnfs_free_commit_array(new);
1087 }
1088}
1089
1090static void
1091filelayout_release_ds_info(struct pnfs_ds_commit_info *fl_cinfo,
1092 struct inode *inode)
1093{
1094 spin_lock(&inode->i_lock);
1095 pnfs_generic_ds_cinfo_destroy(fl_cinfo);
1096 spin_unlock(&inode->i_lock);
1097}
1098
1099static const struct pnfs_commit_ops filelayout_commit_ops = {
1100 .setup_ds_info = filelayout_setup_ds_info,
1101 .release_ds_info = filelayout_release_ds_info,
1102 .mark_request_commit = filelayout_mark_request_commit,
1103 .clear_request_commit = pnfs_generic_clear_request_commit,
1104 .scan_commit_lists = pnfs_generic_scan_commit_lists,
1105 .recover_commit_reqs = pnfs_generic_recover_commit_reqs,
1106 .search_commit_reqs = pnfs_generic_search_commit_reqs,
1107 .commit_pagelist = filelayout_commit_pagelist,
1108};
1109
1110static struct pnfs_layoutdriver_type filelayout_type = {
1111 .id = LAYOUT_NFSV4_1_FILES,
1112 .name = "LAYOUT_NFSV4_1_FILES",
1113 .owner = THIS_MODULE,
1114 .flags = PNFS_LAYOUTGET_ON_OPEN,
1115 .max_layoutget_response = 4096, /* 1 page or so... */
1116 .alloc_layout_hdr = filelayout_alloc_layout_hdr,
1117 .free_layout_hdr = filelayout_free_layout_hdr,
1118 .alloc_lseg = filelayout_alloc_lseg,
1119 .free_lseg = filelayout_free_lseg,
1120 .pg_read_ops = &filelayout_pg_read_ops,
1121 .pg_write_ops = &filelayout_pg_write_ops,
1122 .get_ds_info = &filelayout_get_ds_info,
1123 .read_pagelist = filelayout_read_pagelist,
1124 .write_pagelist = filelayout_write_pagelist,
1125 .alloc_deviceid_node = filelayout_alloc_deviceid_node,
1126 .free_deviceid_node = filelayout_free_deviceid_node,
1127 .sync = pnfs_nfs_generic_sync,
1128};
1129
1130static int __init nfs4filelayout_init(void)
1131{
1132 printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n",
1133 __func__);
1134 return pnfs_register_layoutdriver(&filelayout_type);
1135}
1136
1137static void __exit nfs4filelayout_exit(void)
1138{
1139 printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n",
1140 __func__);
1141 pnfs_unregister_layoutdriver(&filelayout_type);
1142}
1143
1144MODULE_ALIAS("nfs-layouttype4-1");
1145
1146module_init(nfs4filelayout_init);
1147module_exit(nfs4filelayout_exit);