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