vfs: trivial __d_lookup_rcu() cleanups
[linux-2.6.git] / fs / nfs / nfs4filelayout.c
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
36 #include "internal.h"
37 #include "nfs4filelayout.h"
38
39 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
40
41 MODULE_LICENSE("GPL");
42 MODULE_AUTHOR("Dean Hildebrand <dhildebz@umich.edu>");
43 MODULE_DESCRIPTION("The NFSv4 file layout driver");
44
45 #define FILELAYOUT_POLL_RETRY_MAX     (15*HZ)
46
47 static loff_t
48 filelayout_get_dense_offset(struct nfs4_filelayout_segment *flseg,
49                             loff_t offset)
50 {
51         u32 stripe_width = flseg->stripe_unit * flseg->dsaddr->stripe_count;
52         u64 stripe_no;
53         u32 rem;
54
55         offset -= flseg->pattern_offset;
56         stripe_no = div_u64(offset, stripe_width);
57         div_u64_rem(offset, flseg->stripe_unit, &rem);
58
59         return stripe_no * flseg->stripe_unit + rem;
60 }
61
62 /* This function is used by the layout driver to calculate the
63  * offset of the file on the dserver based on whether the
64  * layout type is STRIPE_DENSE or STRIPE_SPARSE
65  */
66 static loff_t
67 filelayout_get_dserver_offset(struct pnfs_layout_segment *lseg, loff_t offset)
68 {
69         struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
70
71         switch (flseg->stripe_type) {
72         case STRIPE_SPARSE:
73                 return offset;
74
75         case STRIPE_DENSE:
76                 return filelayout_get_dense_offset(flseg, offset);
77         }
78
79         BUG();
80 }
81
82 static int filelayout_async_handle_error(struct rpc_task *task,
83                                          struct nfs4_state *state,
84                                          struct nfs_client *clp,
85                                          int *reset)
86 {
87         if (task->tk_status >= 0)
88                 return 0;
89
90         *reset = 0;
91
92         switch (task->tk_status) {
93         case -NFS4ERR_BADSESSION:
94         case -NFS4ERR_BADSLOT:
95         case -NFS4ERR_BAD_HIGH_SLOT:
96         case -NFS4ERR_DEADSESSION:
97         case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
98         case -NFS4ERR_SEQ_FALSE_RETRY:
99         case -NFS4ERR_SEQ_MISORDERED:
100                 dprintk("%s ERROR %d, Reset session. Exchangeid "
101                         "flags 0x%x\n", __func__, task->tk_status,
102                         clp->cl_exchange_flags);
103                 nfs4_schedule_session_recovery(clp->cl_session);
104                 break;
105         case -NFS4ERR_DELAY:
106         case -NFS4ERR_GRACE:
107         case -EKEYEXPIRED:
108                 rpc_delay(task, FILELAYOUT_POLL_RETRY_MAX);
109                 break;
110         case -NFS4ERR_RETRY_UNCACHED_REP:
111                 break;
112         default:
113                 dprintk("%s DS error. Retry through MDS %d\n", __func__,
114                         task->tk_status);
115                 *reset = 1;
116                 break;
117         }
118         task->tk_status = 0;
119         return -EAGAIN;
120 }
121
122 /* NFS_PROTO call done callback routines */
123
124 static int filelayout_read_done_cb(struct rpc_task *task,
125                                 struct nfs_read_data *data)
126 {
127         int reset = 0;
128
129         dprintk("%s DS read\n", __func__);
130
131         if (filelayout_async_handle_error(task, data->args.context->state,
132                                           data->ds_clp, &reset) == -EAGAIN) {
133                 dprintk("%s calling restart ds_clp %p ds_clp->cl_session %p\n",
134                         __func__, data->ds_clp, data->ds_clp->cl_session);
135                 if (reset) {
136                         pnfs_set_lo_fail(data->lseg);
137                         nfs4_reset_read(task, data);
138                 }
139                 rpc_restart_call_prepare(task);
140                 return -EAGAIN;
141         }
142
143         return 0;
144 }
145
146 /*
147  * We reference the rpc_cred of the first WRITE that triggers the need for
148  * a LAYOUTCOMMIT, and use it to send the layoutcommit compound.
149  * rfc5661 is not clear about which credential should be used.
150  */
151 static void
152 filelayout_set_layoutcommit(struct nfs_write_data *wdata)
153 {
154         if (FILELAYOUT_LSEG(wdata->lseg)->commit_through_mds ||
155             wdata->res.verf->committed == NFS_FILE_SYNC)
156                 return;
157
158         pnfs_set_layoutcommit(wdata);
159         dprintk("%s ionde %lu pls_end_pos %lu\n", __func__, wdata->inode->i_ino,
160                 (unsigned long) NFS_I(wdata->inode)->layout->plh_lwb);
161 }
162
163 /*
164  * Call ops for the async read/write cases
165  * In the case of dense layouts, the offset needs to be reset to its
166  * original value.
167  */
168 static void filelayout_read_prepare(struct rpc_task *task, void *data)
169 {
170         struct nfs_read_data *rdata = (struct nfs_read_data *)data;
171
172         rdata->read_done_cb = filelayout_read_done_cb;
173
174         if (nfs41_setup_sequence(rdata->ds_clp->cl_session,
175                                 &rdata->args.seq_args, &rdata->res.seq_res,
176                                 0, task))
177                 return;
178
179         rpc_call_start(task);
180 }
181
182 static void filelayout_read_call_done(struct rpc_task *task, void *data)
183 {
184         struct nfs_read_data *rdata = (struct nfs_read_data *)data;
185
186         dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status);
187
188         /* Note this may cause RPC to be resent */
189         rdata->mds_ops->rpc_call_done(task, data);
190 }
191
192 static void filelayout_read_release(void *data)
193 {
194         struct nfs_read_data *rdata = (struct nfs_read_data *)data;
195
196         rdata->mds_ops->rpc_release(data);
197 }
198
199 static int filelayout_write_done_cb(struct rpc_task *task,
200                                 struct nfs_write_data *data)
201 {
202         int reset = 0;
203
204         if (filelayout_async_handle_error(task, data->args.context->state,
205                                           data->ds_clp, &reset) == -EAGAIN) {
206                 dprintk("%s calling restart ds_clp %p ds_clp->cl_session %p\n",
207                         __func__, data->ds_clp, data->ds_clp->cl_session);
208                 if (reset) {
209                         pnfs_set_lo_fail(data->lseg);
210                         nfs4_reset_write(task, data);
211                 }
212                 rpc_restart_call_prepare(task);
213                 return -EAGAIN;
214         }
215
216         filelayout_set_layoutcommit(data);
217         return 0;
218 }
219
220 /* Fake up some data that will cause nfs_commit_release to retry the writes. */
221 static void prepare_to_resend_writes(struct nfs_write_data *data)
222 {
223         struct nfs_page *first = nfs_list_entry(data->pages.next);
224
225         data->task.tk_status = 0;
226         memcpy(data->verf.verifier, first->wb_verf.verifier,
227                sizeof(first->wb_verf.verifier));
228         data->verf.verifier[0]++; /* ensure verifier mismatch */
229 }
230
231 static int filelayout_commit_done_cb(struct rpc_task *task,
232                                      struct nfs_write_data *data)
233 {
234         int reset = 0;
235
236         if (filelayout_async_handle_error(task, data->args.context->state,
237                                           data->ds_clp, &reset) == -EAGAIN) {
238                 dprintk("%s calling restart ds_clp %p ds_clp->cl_session %p\n",
239                         __func__, data->ds_clp, data->ds_clp->cl_session);
240                 if (reset) {
241                         prepare_to_resend_writes(data);
242                         pnfs_set_lo_fail(data->lseg);
243                 } else
244                         rpc_restart_call_prepare(task);
245                 return -EAGAIN;
246         }
247
248         return 0;
249 }
250
251 static void filelayout_write_prepare(struct rpc_task *task, void *data)
252 {
253         struct nfs_write_data *wdata = (struct nfs_write_data *)data;
254
255         if (nfs41_setup_sequence(wdata->ds_clp->cl_session,
256                                 &wdata->args.seq_args, &wdata->res.seq_res,
257                                 0, task))
258                 return;
259
260         rpc_call_start(task);
261 }
262
263 static void filelayout_write_call_done(struct rpc_task *task, void *data)
264 {
265         struct nfs_write_data *wdata = (struct nfs_write_data *)data;
266
267         /* Note this may cause RPC to be resent */
268         wdata->mds_ops->rpc_call_done(task, data);
269 }
270
271 static void filelayout_write_release(void *data)
272 {
273         struct nfs_write_data *wdata = (struct nfs_write_data *)data;
274
275         wdata->mds_ops->rpc_release(data);
276 }
277
278 static void filelayout_commit_release(void *data)
279 {
280         struct nfs_write_data *wdata = (struct nfs_write_data *)data;
281
282         nfs_commit_release_pages(wdata);
283         if (atomic_dec_and_test(&NFS_I(wdata->inode)->commits_outstanding))
284                 nfs_commit_clear_lock(NFS_I(wdata->inode));
285         nfs_commitdata_release(wdata);
286 }
287
288 struct rpc_call_ops filelayout_read_call_ops = {
289         .rpc_call_prepare = filelayout_read_prepare,
290         .rpc_call_done = filelayout_read_call_done,
291         .rpc_release = filelayout_read_release,
292 };
293
294 struct rpc_call_ops filelayout_write_call_ops = {
295         .rpc_call_prepare = filelayout_write_prepare,
296         .rpc_call_done = filelayout_write_call_done,
297         .rpc_release = filelayout_write_release,
298 };
299
300 struct rpc_call_ops filelayout_commit_call_ops = {
301         .rpc_call_prepare = filelayout_write_prepare,
302         .rpc_call_done = filelayout_write_call_done,
303         .rpc_release = filelayout_commit_release,
304 };
305
306 static enum pnfs_try_status
307 filelayout_read_pagelist(struct nfs_read_data *data)
308 {
309         struct pnfs_layout_segment *lseg = data->lseg;
310         struct nfs4_pnfs_ds *ds;
311         loff_t offset = data->args.offset;
312         u32 j, idx;
313         struct nfs_fh *fh;
314         int status;
315
316         dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n",
317                 __func__, data->inode->i_ino,
318                 data->args.pgbase, (size_t)data->args.count, offset);
319
320         if (test_bit(NFS_DEVICEID_INVALID, &FILELAYOUT_DEVID_NODE(lseg)->flags))
321                 return PNFS_NOT_ATTEMPTED;
322
323         /* Retrieve the correct rpc_client for the byte range */
324         j = nfs4_fl_calc_j_index(lseg, offset);
325         idx = nfs4_fl_calc_ds_index(lseg, j);
326         ds = nfs4_fl_prepare_ds(lseg, idx);
327         if (!ds) {
328                 /* Either layout fh index faulty, or ds connect failed */
329                 set_bit(lo_fail_bit(IOMODE_RW), &lseg->pls_layout->plh_flags);
330                 set_bit(lo_fail_bit(IOMODE_READ), &lseg->pls_layout->plh_flags);
331                 return PNFS_NOT_ATTEMPTED;
332         }
333         dprintk("%s USE DS: %s\n", __func__, ds->ds_remotestr);
334
335         /* No multipath support. Use first DS */
336         data->ds_clp = ds->ds_clp;
337         fh = nfs4_fl_select_ds_fh(lseg, j);
338         if (fh)
339                 data->args.fh = fh;
340
341         data->args.offset = filelayout_get_dserver_offset(lseg, offset);
342         data->mds_offset = offset;
343
344         /* Perform an asynchronous read to ds */
345         status = nfs_initiate_read(data, ds->ds_clp->cl_rpcclient,
346                                    &filelayout_read_call_ops);
347         BUG_ON(status != 0);
348         return PNFS_ATTEMPTED;
349 }
350
351 /* Perform async writes. */
352 static enum pnfs_try_status
353 filelayout_write_pagelist(struct nfs_write_data *data, int sync)
354 {
355         struct pnfs_layout_segment *lseg = data->lseg;
356         struct nfs4_pnfs_ds *ds;
357         loff_t offset = data->args.offset;
358         u32 j, idx;
359         struct nfs_fh *fh;
360         int status;
361
362         if (test_bit(NFS_DEVICEID_INVALID, &FILELAYOUT_DEVID_NODE(lseg)->flags))
363                 return PNFS_NOT_ATTEMPTED;
364
365         /* Retrieve the correct rpc_client for the byte range */
366         j = nfs4_fl_calc_j_index(lseg, offset);
367         idx = nfs4_fl_calc_ds_index(lseg, j);
368         ds = nfs4_fl_prepare_ds(lseg, idx);
369         if (!ds) {
370                 printk(KERN_ERR "%s: prepare_ds failed, use MDS\n", __func__);
371                 set_bit(lo_fail_bit(IOMODE_RW), &lseg->pls_layout->plh_flags);
372                 set_bit(lo_fail_bit(IOMODE_READ), &lseg->pls_layout->plh_flags);
373                 return PNFS_NOT_ATTEMPTED;
374         }
375         dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s\n", __func__,
376                 data->inode->i_ino, sync, (size_t) data->args.count, offset,
377                 ds->ds_remotestr);
378
379         data->write_done_cb = filelayout_write_done_cb;
380         data->ds_clp = ds->ds_clp;
381         fh = nfs4_fl_select_ds_fh(lseg, j);
382         if (fh)
383                 data->args.fh = fh;
384         /*
385          * Get the file offset on the dserver. Set the write offset to
386          * this offset and save the original offset.
387          */
388         data->args.offset = filelayout_get_dserver_offset(lseg, offset);
389
390         /* Perform an asynchronous write */
391         status = nfs_initiate_write(data, ds->ds_clp->cl_rpcclient,
392                                     &filelayout_write_call_ops, sync);
393         BUG_ON(status != 0);
394         return PNFS_ATTEMPTED;
395 }
396
397 /*
398  * filelayout_check_layout()
399  *
400  * Make sure layout segment parameters are sane WRT the device.
401  * At this point no generic layer initialization of the lseg has occurred,
402  * and nothing has been added to the layout_hdr cache.
403  *
404  */
405 static int
406 filelayout_check_layout(struct pnfs_layout_hdr *lo,
407                         struct nfs4_filelayout_segment *fl,
408                         struct nfs4_layoutget_res *lgr,
409                         struct nfs4_deviceid *id,
410                         gfp_t gfp_flags)
411 {
412         struct nfs4_deviceid_node *d;
413         struct nfs4_file_layout_dsaddr *dsaddr;
414         int status = -EINVAL;
415         struct nfs_server *nfss = NFS_SERVER(lo->plh_inode);
416
417         dprintk("--> %s\n", __func__);
418
419         /* FIXME: remove this check when layout segment support is added */
420         if (lgr->range.offset != 0 ||
421             lgr->range.length != NFS4_MAX_UINT64) {
422                 dprintk("%s Only whole file layouts supported. Use MDS i/o\n",
423                         __func__);
424                 goto out;
425         }
426
427         if (fl->pattern_offset > lgr->range.offset) {
428                 dprintk("%s pattern_offset %lld too large\n",
429                                 __func__, fl->pattern_offset);
430                 goto out;
431         }
432
433         if (!fl->stripe_unit || fl->stripe_unit % PAGE_SIZE) {
434                 dprintk("%s Invalid stripe unit (%u)\n",
435                         __func__, fl->stripe_unit);
436                 goto out;
437         }
438
439         /* find and reference the deviceid */
440         d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode)->pnfs_curr_ld,
441                                    NFS_SERVER(lo->plh_inode)->nfs_client, id);
442         if (d == NULL) {
443                 dsaddr = get_device_info(lo->plh_inode, id, gfp_flags);
444                 if (dsaddr == NULL)
445                         goto out;
446         } else
447                 dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
448         /* Found deviceid is being reaped */
449         if (test_bit(NFS_DEVICEID_INVALID, &dsaddr->id_node.flags))
450                         goto out_put;
451
452         fl->dsaddr = dsaddr;
453
454         if (fl->first_stripe_index >= dsaddr->stripe_count) {
455                 dprintk("%s Bad first_stripe_index %u\n",
456                                 __func__, fl->first_stripe_index);
457                 goto out_put;
458         }
459
460         if ((fl->stripe_type == STRIPE_SPARSE &&
461             fl->num_fh > 1 && fl->num_fh != dsaddr->ds_num) ||
462             (fl->stripe_type == STRIPE_DENSE &&
463             fl->num_fh != dsaddr->stripe_count)) {
464                 dprintk("%s num_fh %u not valid for given packing\n",
465                         __func__, fl->num_fh);
466                 goto out_put;
467         }
468
469         if (fl->stripe_unit % nfss->rsize || fl->stripe_unit % nfss->wsize) {
470                 dprintk("%s Stripe unit (%u) not aligned with rsize %u "
471                         "wsize %u\n", __func__, fl->stripe_unit, nfss->rsize,
472                         nfss->wsize);
473         }
474
475         status = 0;
476 out:
477         dprintk("--> %s returns %d\n", __func__, status);
478         return status;
479 out_put:
480         nfs4_fl_put_deviceid(dsaddr);
481         goto out;
482 }
483
484 static void filelayout_free_fh_array(struct nfs4_filelayout_segment *fl)
485 {
486         int i;
487
488         for (i = 0; i < fl->num_fh; i++) {
489                 if (!fl->fh_array[i])
490                         break;
491                 kfree(fl->fh_array[i]);
492         }
493         kfree(fl->fh_array);
494         fl->fh_array = NULL;
495 }
496
497 static void
498 _filelayout_free_lseg(struct nfs4_filelayout_segment *fl)
499 {
500         filelayout_free_fh_array(fl);
501         kfree(fl);
502 }
503
504 static int
505 filelayout_decode_layout(struct pnfs_layout_hdr *flo,
506                          struct nfs4_filelayout_segment *fl,
507                          struct nfs4_layoutget_res *lgr,
508                          struct nfs4_deviceid *id,
509                          gfp_t gfp_flags)
510 {
511         struct xdr_stream stream;
512         struct xdr_buf buf;
513         struct page *scratch;
514         __be32 *p;
515         uint32_t nfl_util;
516         int i;
517
518         dprintk("%s: set_layout_map Begin\n", __func__);
519
520         scratch = alloc_page(gfp_flags);
521         if (!scratch)
522                 return -ENOMEM;
523
524         xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len);
525         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
526
527         /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8),
528          * num_fh (4) */
529         p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20);
530         if (unlikely(!p))
531                 goto out_err;
532
533         memcpy(id, p, sizeof(*id));
534         p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
535         nfs4_print_deviceid(id);
536
537         nfl_util = be32_to_cpup(p++);
538         if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS)
539                 fl->commit_through_mds = 1;
540         if (nfl_util & NFL4_UFLG_DENSE)
541                 fl->stripe_type = STRIPE_DENSE;
542         else
543                 fl->stripe_type = STRIPE_SPARSE;
544         fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK;
545
546         fl->first_stripe_index = be32_to_cpup(p++);
547         p = xdr_decode_hyper(p, &fl->pattern_offset);
548         fl->num_fh = be32_to_cpup(p++);
549
550         dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n",
551                 __func__, nfl_util, fl->num_fh, fl->first_stripe_index,
552                 fl->pattern_offset);
553
554         /* Note that a zero value for num_fh is legal for STRIPE_SPARSE.
555          * Futher checking is done in filelayout_check_layout */
556         if (fl->num_fh >
557             max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT))
558                 goto out_err;
559
560         if (fl->num_fh > 0) {
561                 fl->fh_array = kzalloc(fl->num_fh * sizeof(struct nfs_fh *),
562                                        gfp_flags);
563                 if (!fl->fh_array)
564                         goto out_err;
565         }
566
567         for (i = 0; i < fl->num_fh; i++) {
568                 /* Do we want to use a mempool here? */
569                 fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags);
570                 if (!fl->fh_array[i])
571                         goto out_err_free;
572
573                 p = xdr_inline_decode(&stream, 4);
574                 if (unlikely(!p))
575                         goto out_err_free;
576                 fl->fh_array[i]->size = be32_to_cpup(p++);
577                 if (sizeof(struct nfs_fh) < fl->fh_array[i]->size) {
578                         printk(KERN_ERR "Too big fh %d received %d\n",
579                                i, fl->fh_array[i]->size);
580                         goto out_err_free;
581                 }
582
583                 p = xdr_inline_decode(&stream, fl->fh_array[i]->size);
584                 if (unlikely(!p))
585                         goto out_err_free;
586                 memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size);
587                 dprintk("DEBUG: %s: fh len %d\n", __func__,
588                         fl->fh_array[i]->size);
589         }
590
591         __free_page(scratch);
592         return 0;
593
594 out_err_free:
595         filelayout_free_fh_array(fl);
596 out_err:
597         __free_page(scratch);
598         return -EIO;
599 }
600
601 static void
602 filelayout_free_lseg(struct pnfs_layout_segment *lseg)
603 {
604         struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
605
606         dprintk("--> %s\n", __func__);
607         nfs4_fl_put_deviceid(fl->dsaddr);
608         kfree(fl->commit_buckets);
609         _filelayout_free_lseg(fl);
610 }
611
612 static struct pnfs_layout_segment *
613 filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid,
614                       struct nfs4_layoutget_res *lgr,
615                       gfp_t gfp_flags)
616 {
617         struct nfs4_filelayout_segment *fl;
618         int rc;
619         struct nfs4_deviceid id;
620
621         dprintk("--> %s\n", __func__);
622         fl = kzalloc(sizeof(*fl), gfp_flags);
623         if (!fl)
624                 return NULL;
625
626         rc = filelayout_decode_layout(layoutid, fl, lgr, &id, gfp_flags);
627         if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, &id, gfp_flags)) {
628                 _filelayout_free_lseg(fl);
629                 return NULL;
630         }
631
632         /* This assumes there is only one IOMODE_RW lseg.  What
633          * we really want to do is have a layout_hdr level
634          * dictionary of <multipath_list4, fh> keys, each
635          * associated with a struct list_head, populated by calls
636          * to filelayout_write_pagelist().
637          * */
638         if ((!fl->commit_through_mds) && (lgr->range.iomode == IOMODE_RW)) {
639                 int i;
640                 int size = (fl->stripe_type == STRIPE_SPARSE) ?
641                         fl->dsaddr->ds_num : fl->dsaddr->stripe_count;
642
643                 fl->commit_buckets = kcalloc(size, sizeof(struct list_head), gfp_flags);
644                 if (!fl->commit_buckets) {
645                         filelayout_free_lseg(&fl->generic_hdr);
646                         return NULL;
647                 }
648                 fl->number_of_buckets = size;
649                 for (i = 0; i < size; i++)
650                         INIT_LIST_HEAD(&fl->commit_buckets[i]);
651         }
652         return &fl->generic_hdr;
653 }
654
655 /*
656  * filelayout_pg_test(). Called by nfs_can_coalesce_requests()
657  *
658  * return true  : coalesce page
659  * return false : don't coalesce page
660  */
661 static bool
662 filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
663                    struct nfs_page *req)
664 {
665         u64 p_stripe, r_stripe;
666         u32 stripe_unit;
667
668         if (!pnfs_generic_pg_test(pgio, prev, req) ||
669             !nfs_generic_pg_test(pgio, prev, req))
670                 return false;
671
672         p_stripe = (u64)prev->wb_index << PAGE_CACHE_SHIFT;
673         r_stripe = (u64)req->wb_index << PAGE_CACHE_SHIFT;
674         stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit;
675
676         do_div(p_stripe, stripe_unit);
677         do_div(r_stripe, stripe_unit);
678
679         return (p_stripe == r_stripe);
680 }
681
682 void
683 filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio,
684                         struct nfs_page *req)
685 {
686         BUG_ON(pgio->pg_lseg != NULL);
687
688         pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
689                                            req->wb_context,
690                                            0,
691                                            NFS4_MAX_UINT64,
692                                            IOMODE_READ,
693                                            GFP_KERNEL);
694         /* If no lseg, fall back to read through mds */
695         if (pgio->pg_lseg == NULL)
696                 nfs_pageio_reset_read_mds(pgio);
697 }
698
699 void
700 filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio,
701                          struct nfs_page *req)
702 {
703         BUG_ON(pgio->pg_lseg != NULL);
704
705         pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
706                                            req->wb_context,
707                                            0,
708                                            NFS4_MAX_UINT64,
709                                            IOMODE_RW,
710                                            GFP_NOFS);
711         /* If no lseg, fall back to write through mds */
712         if (pgio->pg_lseg == NULL)
713                 nfs_pageio_reset_write_mds(pgio);
714 }
715
716 static const struct nfs_pageio_ops filelayout_pg_read_ops = {
717         .pg_init = filelayout_pg_init_read,
718         .pg_test = filelayout_pg_test,
719         .pg_doio = pnfs_generic_pg_readpages,
720 };
721
722 static const struct nfs_pageio_ops filelayout_pg_write_ops = {
723         .pg_init = filelayout_pg_init_write,
724         .pg_test = filelayout_pg_test,
725         .pg_doio = pnfs_generic_pg_writepages,
726 };
727
728 static bool filelayout_mark_pnfs_commit(struct pnfs_layout_segment *lseg)
729 {
730         return !FILELAYOUT_LSEG(lseg)->commit_through_mds;
731 }
732
733 static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j)
734 {
735         if (fl->stripe_type == STRIPE_SPARSE)
736                 return nfs4_fl_calc_ds_index(&fl->generic_hdr, j);
737         else
738                 return j;
739 }
740
741 struct list_head *filelayout_choose_commit_list(struct nfs_page *req)
742 {
743         struct pnfs_layout_segment *lseg = req->wb_commit_lseg;
744         struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
745         u32 i, j;
746         struct list_head *list;
747
748         /* Note that we are calling nfs4_fl_calc_j_index on each page
749          * that ends up being committed to a data server.  An attractive
750          * alternative is to add a field to nfs_write_data and nfs_page
751          * to store the value calculated in filelayout_write_pagelist
752          * and just use that here.
753          */
754         j = nfs4_fl_calc_j_index(lseg,
755                                  (loff_t)req->wb_index << PAGE_CACHE_SHIFT);
756         i = select_bucket_index(fl, j);
757         list = &fl->commit_buckets[i];
758         if (list_empty(list)) {
759                 /* Non-empty buckets hold a reference on the lseg */
760                 get_lseg(lseg);
761         }
762         return list;
763 }
764
765 static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i)
766 {
767         struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
768
769         if (flseg->stripe_type == STRIPE_SPARSE)
770                 return i;
771         else
772                 return nfs4_fl_calc_ds_index(lseg, i);
773 }
774
775 static struct nfs_fh *
776 select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i)
777 {
778         struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
779
780         if (flseg->stripe_type == STRIPE_SPARSE) {
781                 if (flseg->num_fh == 1)
782                         i = 0;
783                 else if (flseg->num_fh == 0)
784                         /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
785                         return NULL;
786         }
787         return flseg->fh_array[i];
788 }
789
790 static int filelayout_initiate_commit(struct nfs_write_data *data, int how)
791 {
792         struct pnfs_layout_segment *lseg = data->lseg;
793         struct nfs4_pnfs_ds *ds;
794         u32 idx;
795         struct nfs_fh *fh;
796
797         idx = calc_ds_index_from_commit(lseg, data->ds_commit_index);
798         ds = nfs4_fl_prepare_ds(lseg, idx);
799         if (!ds) {
800                 printk(KERN_ERR "%s: prepare_ds failed, use MDS\n", __func__);
801                 set_bit(lo_fail_bit(IOMODE_RW), &lseg->pls_layout->plh_flags);
802                 set_bit(lo_fail_bit(IOMODE_READ), &lseg->pls_layout->plh_flags);
803                 prepare_to_resend_writes(data);
804                 data->mds_ops->rpc_release(data);
805                 return -EAGAIN;
806         }
807         dprintk("%s ino %lu, how %d\n", __func__, data->inode->i_ino, how);
808         data->write_done_cb = filelayout_commit_done_cb;
809         data->ds_clp = ds->ds_clp;
810         fh = select_ds_fh_from_commit(lseg, data->ds_commit_index);
811         if (fh)
812                 data->args.fh = fh;
813         return nfs_initiate_commit(data, ds->ds_clp->cl_rpcclient,
814                                    &filelayout_commit_call_ops, how);
815 }
816
817 /*
818  * This is only useful while we are using whole file layouts.
819  */
820 static struct pnfs_layout_segment *find_only_write_lseg(struct inode *inode)
821 {
822         struct pnfs_layout_segment *lseg, *rv = NULL;
823
824         spin_lock(&inode->i_lock);
825         list_for_each_entry(lseg, &NFS_I(inode)->layout->plh_segs, pls_list)
826                 if (lseg->pls_range.iomode == IOMODE_RW)
827                         rv = get_lseg(lseg);
828         spin_unlock(&inode->i_lock);
829         return rv;
830 }
831
832 static int alloc_ds_commits(struct inode *inode, struct list_head *list)
833 {
834         struct pnfs_layout_segment *lseg;
835         struct nfs4_filelayout_segment *fl;
836         struct nfs_write_data *data;
837         int i, j;
838
839         /* Won't need this when non-whole file layout segments are supported
840          * instead we will use a pnfs_layout_hdr structure */
841         lseg = find_only_write_lseg(inode);
842         if (!lseg)
843                 return 0;
844         fl = FILELAYOUT_LSEG(lseg);
845         for (i = 0; i < fl->number_of_buckets; i++) {
846                 if (list_empty(&fl->commit_buckets[i]))
847                         continue;
848                 data = nfs_commitdata_alloc();
849                 if (!data)
850                         goto out_bad;
851                 data->ds_commit_index = i;
852                 data->lseg = lseg;
853                 list_add(&data->pages, list);
854         }
855         put_lseg(lseg);
856         return 0;
857
858 out_bad:
859         for (j = i; j < fl->number_of_buckets; j++) {
860                 if (list_empty(&fl->commit_buckets[i]))
861                         continue;
862                 nfs_retry_commit(&fl->commit_buckets[i], lseg);
863                 put_lseg(lseg);  /* associated with emptying bucket */
864         }
865         put_lseg(lseg);
866         /* Caller will clean up entries put on list */
867         return -ENOMEM;
868 }
869
870 /* This follows nfs_commit_list pretty closely */
871 static int
872 filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages,
873                            int how)
874 {
875         struct nfs_write_data   *data, *tmp;
876         LIST_HEAD(list);
877
878         if (!list_empty(mds_pages)) {
879                 data = nfs_commitdata_alloc();
880                 if (!data)
881                         goto out_bad;
882                 data->lseg = NULL;
883                 list_add(&data->pages, &list);
884         }
885
886         if (alloc_ds_commits(inode, &list))
887                 goto out_bad;
888
889         list_for_each_entry_safe(data, tmp, &list, pages) {
890                 list_del_init(&data->pages);
891                 atomic_inc(&NFS_I(inode)->commits_outstanding);
892                 if (!data->lseg) {
893                         nfs_init_commit(data, mds_pages, NULL);
894                         nfs_initiate_commit(data, NFS_CLIENT(inode),
895                                             data->mds_ops, how);
896                 } else {
897                         nfs_init_commit(data, &FILELAYOUT_LSEG(data->lseg)->commit_buckets[data->ds_commit_index], data->lseg);
898                         filelayout_initiate_commit(data, how);
899                 }
900         }
901         return 0;
902  out_bad:
903         list_for_each_entry_safe(data, tmp, &list, pages) {
904                 nfs_retry_commit(&data->pages, data->lseg);
905                 list_del_init(&data->pages);
906                 nfs_commit_free(data);
907         }
908         nfs_retry_commit(mds_pages, NULL);
909         nfs_commit_clear_lock(NFS_I(inode));
910         return -ENOMEM;
911 }
912
913 static void
914 filelayout_free_deveiceid_node(struct nfs4_deviceid_node *d)
915 {
916         nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node));
917 }
918
919 static struct pnfs_layoutdriver_type filelayout_type = {
920         .id                     = LAYOUT_NFSV4_1_FILES,
921         .name                   = "LAYOUT_NFSV4_1_FILES",
922         .owner                  = THIS_MODULE,
923         .alloc_lseg             = filelayout_alloc_lseg,
924         .free_lseg              = filelayout_free_lseg,
925         .pg_read_ops            = &filelayout_pg_read_ops,
926         .pg_write_ops           = &filelayout_pg_write_ops,
927         .mark_pnfs_commit       = filelayout_mark_pnfs_commit,
928         .choose_commit_list     = filelayout_choose_commit_list,
929         .commit_pagelist        = filelayout_commit_pagelist,
930         .read_pagelist          = filelayout_read_pagelist,
931         .write_pagelist         = filelayout_write_pagelist,
932         .free_deviceid_node     = filelayout_free_deveiceid_node,
933 };
934
935 static int __init nfs4filelayout_init(void)
936 {
937         printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n",
938                __func__);
939         return pnfs_register_layoutdriver(&filelayout_type);
940 }
941
942 static void __exit nfs4filelayout_exit(void)
943 {
944         printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n",
945                __func__);
946         pnfs_unregister_layoutdriver(&filelayout_type);
947 }
948
949 MODULE_ALIAS("nfs-layouttype4-1");
950
951 module_init(nfs4filelayout_init);
952 module_exit(nfs4filelayout_exit);