2 * linux/fs/nfs/blocklayout/blocklayout.c
4 * Module for the NFSv4.1 pNFS block layout driver.
6 * Copyright (c) 2006 The Regents of the University of Michigan.
9 * Andy Adamson <andros@citi.umich.edu>
10 * Fred Isaman <iisaman@umich.edu>
12 * permission is granted to use, copy, create derivative works and
13 * redistribute this software and such derivative works for any purpose,
14 * so long as the name of the university of michigan is not used in
15 * any advertising or publicity pertaining to the use or distribution
16 * of this software without specific, written prior authorization. if
17 * the above copyright notice or any other identification of the
18 * university of michigan is included in any copy of any portion of
19 * this software, then the disclaimer below must also be included.
21 * this software is provided as is, without representation from the
22 * university of michigan as to its fitness for any purpose, and without
23 * warranty by the university of michigan of any kind, either express
24 * or implied, including without limitation the implied warranties of
25 * merchantability and fitness for a particular purpose. the regents
26 * of the university of michigan shall not be liable for any damages,
27 * including special, indirect, incidental, or consequential damages,
28 * with respect to any claim arising out or in connection with the use
29 * of the software, even if it has been or is hereafter advised of the
30 * possibility of such damages.
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/mount.h>
36 #include <linux/namei.h>
37 #include <linux/bio.h> /* struct bio */
38 #include <linux/buffer_head.h> /* various write calls */
39 #include <linux/prefetch.h>
41 #include "blocklayout.h"
43 #define NFSDBG_FACILITY NFSDBG_PNFS_LD
45 MODULE_LICENSE("GPL");
46 MODULE_AUTHOR("Andy Adamson <andros@citi.umich.edu>");
47 MODULE_DESCRIPTION("The NFSv4.1 pNFS Block layout driver");
49 struct dentry
*bl_device_pipe
;
50 wait_queue_head_t bl_wq
;
52 static void print_page(struct page
*page
)
54 dprintk("PRINTPAGE page %p\n", page
);
55 dprintk(" PagePrivate %d\n", PagePrivate(page
));
56 dprintk(" PageUptodate %d\n", PageUptodate(page
));
57 dprintk(" PageError %d\n", PageError(page
));
58 dprintk(" PageDirty %d\n", PageDirty(page
));
59 dprintk(" PageReferenced %d\n", PageReferenced(page
));
60 dprintk(" PageLocked %d\n", PageLocked(page
));
61 dprintk(" PageWriteback %d\n", PageWriteback(page
));
62 dprintk(" PageMappedToDisk %d\n", PageMappedToDisk(page
));
66 /* Given the be associated with isect, determine if page data needs to be
69 static int is_hole(struct pnfs_block_extent
*be
, sector_t isect
)
71 if (be
->be_state
== PNFS_BLOCK_NONE_DATA
)
73 else if (be
->be_state
!= PNFS_BLOCK_INVALID_DATA
)
76 return !bl_is_sector_init(be
->be_inval
, isect
);
79 /* Given the be associated with isect, determine if page data can be
82 static int is_writable(struct pnfs_block_extent
*be
, sector_t isect
)
84 return (be
->be_state
== PNFS_BLOCK_READWRITE_DATA
||
85 be
->be_state
== PNFS_BLOCK_INVALID_DATA
);
88 /* The data we are handed might be spread across several bios. We need
89 * to track when the last one is finished.
93 struct rpc_call_ops call_ops
;
94 void (*pnfs_callback
) (void *data
);
98 static inline struct parallel_io
*alloc_parallel(void *data
)
100 struct parallel_io
*rv
;
102 rv
= kmalloc(sizeof(*rv
), GFP_NOFS
);
105 kref_init(&rv
->refcnt
);
110 static inline void get_parallel(struct parallel_io
*p
)
112 kref_get(&p
->refcnt
);
115 static void destroy_parallel(struct kref
*kref
)
117 struct parallel_io
*p
= container_of(kref
, struct parallel_io
, refcnt
);
119 dprintk("%s enter\n", __func__
);
120 p
->pnfs_callback(p
->data
);
124 static inline void put_parallel(struct parallel_io
*p
)
126 kref_put(&p
->refcnt
, destroy_parallel
);
130 bl_submit_bio(int rw
, struct bio
*bio
)
133 get_parallel(bio
->bi_private
);
134 dprintk("%s submitting %s bio %u@%llu\n", __func__
,
135 rw
== READ
? "read" : "write",
136 bio
->bi_size
, (unsigned long long)bio
->bi_sector
);
142 static struct bio
*bl_alloc_init_bio(int npg
, sector_t isect
,
143 struct pnfs_block_extent
*be
,
144 void (*end_io
)(struct bio
*, int err
),
145 struct parallel_io
*par
)
149 npg
= min(npg
, BIO_MAX_PAGES
);
150 bio
= bio_alloc(GFP_NOIO
, npg
);
151 if (!bio
&& (current
->flags
& PF_MEMALLOC
)) {
152 while (!bio
&& (npg
/= 2))
153 bio
= bio_alloc(GFP_NOIO
, npg
);
157 bio
->bi_sector
= isect
- be
->be_f_offset
+ be
->be_v_offset
;
158 bio
->bi_bdev
= be
->be_mdev
;
159 bio
->bi_end_io
= end_io
;
160 bio
->bi_private
= par
;
165 static struct bio
*bl_add_page_to_bio(struct bio
*bio
, int npg
, int rw
,
166 sector_t isect
, struct page
*page
,
167 struct pnfs_block_extent
*be
,
168 void (*end_io
)(struct bio
*, int err
),
169 struct parallel_io
*par
)
173 bio
= bl_alloc_init_bio(npg
, isect
, be
, end_io
, par
);
175 return ERR_PTR(-ENOMEM
);
177 if (bio_add_page(bio
, page
, PAGE_CACHE_SIZE
, 0) < PAGE_CACHE_SIZE
) {
178 bio
= bl_submit_bio(rw
, bio
);
184 /* This is basically copied from mpage_end_io_read */
185 static void bl_end_io_read(struct bio
*bio
, int err
)
187 struct parallel_io
*par
= bio
->bi_private
;
188 const int uptodate
= test_bit(BIO_UPTODATE
, &bio
->bi_flags
);
189 struct bio_vec
*bvec
= bio
->bi_io_vec
+ bio
->bi_vcnt
- 1;
190 struct nfs_read_data
*rdata
= (struct nfs_read_data
*)par
->data
;
193 struct page
*page
= bvec
->bv_page
;
195 if (--bvec
>= bio
->bi_io_vec
)
196 prefetchw(&bvec
->bv_page
->flags
);
198 SetPageUptodate(page
);
199 } while (bvec
>= bio
->bi_io_vec
);
201 if (!rdata
->pnfs_error
)
202 rdata
->pnfs_error
= -EIO
;
203 pnfs_set_lo_fail(rdata
->lseg
);
209 static void bl_read_cleanup(struct work_struct
*work
)
211 struct rpc_task
*task
;
212 struct nfs_read_data
*rdata
;
213 dprintk("%s enter\n", __func__
);
214 task
= container_of(work
, struct rpc_task
, u
.tk_work
);
215 rdata
= container_of(task
, struct nfs_read_data
, task
);
216 pnfs_ld_read_done(rdata
);
220 bl_end_par_io_read(void *data
)
222 struct nfs_read_data
*rdata
= data
;
224 INIT_WORK(&rdata
->task
.u
.tk_work
, bl_read_cleanup
);
225 schedule_work(&rdata
->task
.u
.tk_work
);
228 /* We don't want normal .rpc_call_done callback used, so we replace it
231 static void bl_rpc_do_nothing(struct rpc_task
*task
, void *calldata
)
236 static enum pnfs_try_status
237 bl_read_pagelist(struct nfs_read_data
*rdata
)
240 struct bio
*bio
= NULL
;
241 struct pnfs_block_extent
*be
= NULL
, *cow_read
= NULL
;
242 sector_t isect
, extent_length
= 0;
243 struct parallel_io
*par
;
244 loff_t f_offset
= rdata
->args
.offset
;
245 size_t count
= rdata
->args
.count
;
246 struct page
**pages
= rdata
->args
.pages
;
247 int pg_index
= rdata
->args
.pgbase
>> PAGE_CACHE_SHIFT
;
249 dprintk("%s enter nr_pages %u offset %lld count %Zd\n", __func__
,
250 rdata
->npages
, f_offset
, count
);
252 par
= alloc_parallel(rdata
);
255 par
->call_ops
= *rdata
->mds_ops
;
256 par
->call_ops
.rpc_call_done
= bl_rpc_do_nothing
;
257 par
->pnfs_callback
= bl_end_par_io_read
;
258 /* At this point, we can no longer jump to use_mds */
260 isect
= (sector_t
) (f_offset
>> SECTOR_SHIFT
);
261 /* Code assumes extents are page-aligned */
262 for (i
= pg_index
; i
< rdata
->npages
; i
++) {
263 if (!extent_length
) {
264 /* We've used up the previous extent */
266 bl_put_extent(cow_read
);
267 bio
= bl_submit_bio(READ
, bio
);
268 /* Get the next one */
269 be
= bl_find_get_extent(BLK_LSEG2EXT(rdata
->lseg
),
272 rdata
->pnfs_error
= -EIO
;
275 extent_length
= be
->be_length
-
276 (isect
- be
->be_f_offset
);
278 sector_t cow_length
= cow_read
->be_length
-
279 (isect
- cow_read
->be_f_offset
);
280 extent_length
= min(extent_length
, cow_length
);
283 hole
= is_hole(be
, isect
);
284 if (hole
&& !cow_read
) {
285 bio
= bl_submit_bio(READ
, bio
);
286 /* Fill hole w/ zeroes w/o accessing device */
287 dprintk("%s Zeroing page for hole\n", __func__
);
288 zero_user_segment(pages
[i
], 0, PAGE_CACHE_SIZE
);
289 print_page(pages
[i
]);
290 SetPageUptodate(pages
[i
]);
292 struct pnfs_block_extent
*be_read
;
294 be_read
= (hole
&& cow_read
) ? cow_read
: be
;
295 bio
= bl_add_page_to_bio(bio
, rdata
->npages
- i
, READ
,
296 isect
, pages
[i
], be_read
,
297 bl_end_io_read
, par
);
299 rdata
->pnfs_error
= PTR_ERR(bio
);
304 isect
+= PAGE_CACHE_SECTORS
;
305 extent_length
-= PAGE_CACHE_SECTORS
;
307 if ((isect
<< SECTOR_SHIFT
) >= rdata
->inode
->i_size
) {
309 rdata
->res
.count
= rdata
->inode
->i_size
- f_offset
;
311 rdata
->res
.count
= (isect
<< SECTOR_SHIFT
) - f_offset
;
315 bl_put_extent(cow_read
);
316 bl_submit_bio(READ
, bio
);
318 return PNFS_ATTEMPTED
;
321 dprintk("Giving up and using normal NFS\n");
322 return PNFS_NOT_ATTEMPTED
;
325 static void mark_extents_written(struct pnfs_block_layout
*bl
,
326 __u64 offset
, __u32 count
)
329 struct pnfs_block_extent
*be
;
331 dprintk("%s(%llu, %u)\n", __func__
, offset
, count
);
334 isect
= (offset
& (long)(PAGE_CACHE_MASK
)) >> SECTOR_SHIFT
;
335 end
= (offset
+ count
+ PAGE_CACHE_SIZE
- 1) & (long)(PAGE_CACHE_MASK
);
336 end
>>= SECTOR_SHIFT
;
337 while (isect
< end
) {
339 be
= bl_find_get_extent(bl
, isect
, NULL
);
340 BUG_ON(!be
); /* FIXME */
341 len
= min(end
, be
->be_f_offset
+ be
->be_length
) - isect
;
342 if (be
->be_state
== PNFS_BLOCK_INVALID_DATA
)
343 bl_mark_for_commit(be
, isect
, len
); /* What if fails? */
349 static void bl_end_io_write_zero(struct bio
*bio
, int err
)
351 struct parallel_io
*par
= bio
->bi_private
;
352 const int uptodate
= test_bit(BIO_UPTODATE
, &bio
->bi_flags
);
353 struct bio_vec
*bvec
= bio
->bi_io_vec
+ bio
->bi_vcnt
- 1;
354 struct nfs_write_data
*wdata
= (struct nfs_write_data
*)par
->data
;
357 struct page
*page
= bvec
->bv_page
;
359 if (--bvec
>= bio
->bi_io_vec
)
360 prefetchw(&bvec
->bv_page
->flags
);
361 /* This is the zeroing page we added */
362 end_page_writeback(page
);
363 page_cache_release(page
);
364 } while (bvec
>= bio
->bi_io_vec
);
366 if (!wdata
->pnfs_error
)
367 wdata
->pnfs_error
= -EIO
;
368 pnfs_set_lo_fail(wdata
->lseg
);
374 /* This is basically copied from mpage_end_io_read */
375 static void bl_end_io_write(struct bio
*bio
, int err
)
377 struct parallel_io
*par
= bio
->bi_private
;
378 const int uptodate
= test_bit(BIO_UPTODATE
, &bio
->bi_flags
);
379 struct nfs_write_data
*wdata
= (struct nfs_write_data
*)par
->data
;
382 if (!wdata
->pnfs_error
)
383 wdata
->pnfs_error
= -EIO
;
384 pnfs_set_lo_fail(wdata
->lseg
);
390 /* Function scheduled for call during bl_end_par_io_write,
391 * it marks sectors as written and extends the commitlist.
393 static void bl_write_cleanup(struct work_struct
*work
)
395 struct rpc_task
*task
;
396 struct nfs_write_data
*wdata
;
397 dprintk("%s enter\n", __func__
);
398 task
= container_of(work
, struct rpc_task
, u
.tk_work
);
399 wdata
= container_of(task
, struct nfs_write_data
, task
);
400 if (!wdata
->pnfs_error
) {
401 /* Marks for LAYOUTCOMMIT */
402 mark_extents_written(BLK_LSEG2EXT(wdata
->lseg
),
403 wdata
->args
.offset
, wdata
->args
.count
);
405 pnfs_ld_write_done(wdata
);
408 /* Called when last of bios associated with a bl_write_pagelist call finishes */
409 static void bl_end_par_io_write(void *data
)
411 struct nfs_write_data
*wdata
= data
;
413 wdata
->task
.tk_status
= 0;
414 wdata
->verf
.committed
= NFS_FILE_SYNC
;
415 INIT_WORK(&wdata
->task
.u
.tk_work
, bl_write_cleanup
);
416 schedule_work(&wdata
->task
.u
.tk_work
);
419 /* FIXME STUB - mark intersection of layout and page as bad, so is not
422 static void mark_bad_read(void)
428 * map_block: map a requested I/0 block (isect) into an offset in the LVM
432 map_block(struct buffer_head
*bh
, sector_t isect
, struct pnfs_block_extent
*be
)
434 dprintk("%s enter be=%p\n", __func__
, be
);
436 set_buffer_mapped(bh
);
437 bh
->b_bdev
= be
->be_mdev
;
438 bh
->b_blocknr
= (isect
- be
->be_f_offset
+ be
->be_v_offset
) >>
439 (be
->be_mdev
->bd_inode
->i_blkbits
- SECTOR_SHIFT
);
441 dprintk("%s isect %llu, bh->b_blocknr %ld, using bsize %Zd\n",
442 __func__
, (unsigned long long)isect
, (long)bh
->b_blocknr
,
447 /* Given an unmapped page, zero it or read in page for COW, page is locked
451 init_page_for_write(struct page
*page
, struct pnfs_block_extent
*cow_read
)
453 struct buffer_head
*bh
= NULL
;
457 dprintk("%s enter, %p\n", __func__
, page
);
458 BUG_ON(PageUptodate(page
));
460 zero_user_segment(page
, 0, PAGE_SIZE
);
461 SetPageUptodate(page
);
465 bh
= alloc_page_buffers(page
, PAGE_CACHE_SIZE
, 0);
471 isect
= (sector_t
) page
->index
<< PAGE_CACHE_SECTOR_SHIFT
;
472 map_block(bh
, isect
, cow_read
);
473 if (!bh_uptodate_or_lock(bh
))
474 ret
= bh_submit_read(bh
);
477 SetPageUptodate(page
);
480 bl_put_extent(cow_read
);
482 free_buffer_head(bh
);
484 /* Need to mark layout with bad read...should now
485 * just use nfs4 for reads and writes.
492 static enum pnfs_try_status
493 bl_write_pagelist(struct nfs_write_data
*wdata
, int sync
)
495 int i
, ret
, npg_zero
, pg_index
, last
= 0;
496 struct bio
*bio
= NULL
;
497 struct pnfs_block_extent
*be
= NULL
, *cow_read
= NULL
;
498 sector_t isect
, last_isect
= 0, extent_length
= 0;
499 struct parallel_io
*par
;
500 loff_t offset
= wdata
->args
.offset
;
501 size_t count
= wdata
->args
.count
;
502 struct page
**pages
= wdata
->args
.pages
;
507 NFS_SERVER(wdata
->inode
)->pnfs_blksize
>> PAGE_CACHE_SHIFT
;
509 dprintk("%s enter, %Zu@%lld\n", __func__
, count
, offset
);
510 /* At this point, wdata->pages is a (sequential) list of nfs_pages.
511 * We want to write each, and if there is an error set pnfs_error
512 * to have it redone using nfs.
514 par
= alloc_parallel(wdata
);
516 return PNFS_NOT_ATTEMPTED
;
517 par
->call_ops
= *wdata
->mds_ops
;
518 par
->call_ops
.rpc_call_done
= bl_rpc_do_nothing
;
519 par
->pnfs_callback
= bl_end_par_io_write
;
520 /* At this point, have to be more careful with error handling */
522 isect
= (sector_t
) ((offset
& (long)PAGE_CACHE_MASK
) >> SECTOR_SHIFT
);
523 be
= bl_find_get_extent(BLK_LSEG2EXT(wdata
->lseg
), isect
, &cow_read
);
524 if (!be
|| !is_writable(be
, isect
)) {
525 dprintk("%s no matching extents!\n", __func__
);
526 wdata
->pnfs_error
= -EINVAL
;
530 /* First page inside INVALID extent */
531 if (be
->be_state
== PNFS_BLOCK_INVALID_DATA
) {
532 temp
= offset
>> PAGE_CACHE_SHIFT
;
533 npg_zero
= do_div(temp
, npg_per_block
);
534 isect
= (sector_t
) (((offset
- npg_zero
* PAGE_CACHE_SIZE
) &
535 (long)PAGE_CACHE_MASK
) >> SECTOR_SHIFT
);
536 extent_length
= be
->be_length
- (isect
- be
->be_f_offset
);
539 dprintk("%s need to zero %d pages\n", __func__
, npg_zero
);
540 for (;npg_zero
> 0; npg_zero
--) {
541 if (bl_is_sector_init(be
->be_inval
, isect
)) {
542 dprintk("isect %llu already init\n",
543 (unsigned long long)isect
);
546 /* page ref released in bl_end_io_write_zero */
547 index
= isect
>> PAGE_CACHE_SECTOR_SHIFT
;
548 dprintk("%s zero %dth page: index %lu isect %llu\n",
549 __func__
, npg_zero
, index
,
550 (unsigned long long)isect
);
552 find_or_create_page(wdata
->inode
->i_mapping
, index
,
555 dprintk("%s oom\n", __func__
);
556 wdata
->pnfs_error
= -ENOMEM
;
560 /* PageDirty: Other will write this out
561 * PageWriteback: Other is writing this out
562 * PageUptodate: It was read before
563 * sector_initialized: already written out
565 if (PageDirty(page
) || PageWriteback(page
)) {
568 page_cache_release(page
);
571 if (!PageUptodate(page
)) {
572 /* New page, readin or zero it */
573 init_page_for_write(page
, cow_read
);
575 set_page_writeback(page
);
578 ret
= bl_mark_sectors_init(be
->be_inval
, isect
,
582 dprintk("%s bl_mark_sectors_init fail %d\n",
584 end_page_writeback(page
);
585 page_cache_release(page
);
586 wdata
->pnfs_error
= ret
;
589 bio
= bl_add_page_to_bio(bio
, npg_zero
, WRITE
,
591 bl_end_io_write_zero
, par
);
593 wdata
->pnfs_error
= PTR_ERR(bio
);
597 /* FIXME: This should be done in bi_end_io */
598 mark_extents_written(BLK_LSEG2EXT(wdata
->lseg
),
599 page
->index
<< PAGE_CACHE_SHIFT
,
602 isect
+= PAGE_CACHE_SECTORS
;
603 extent_length
-= PAGE_CACHE_SECTORS
;
608 bio
= bl_submit_bio(WRITE
, bio
);
611 pg_index
= wdata
->args
.pgbase
>> PAGE_CACHE_SHIFT
;
612 for (i
= pg_index
; i
< wdata
->npages
; i
++) {
613 if (!extent_length
) {
614 /* We've used up the previous extent */
616 bio
= bl_submit_bio(WRITE
, bio
);
617 /* Get the next one */
618 be
= bl_find_get_extent(BLK_LSEG2EXT(wdata
->lseg
),
620 if (!be
|| !is_writable(be
, isect
)) {
621 wdata
->pnfs_error
= -EINVAL
;
624 extent_length
= be
->be_length
-
625 (isect
- be
->be_f_offset
);
627 if (be
->be_state
== PNFS_BLOCK_INVALID_DATA
) {
628 ret
= bl_mark_sectors_init(be
->be_inval
, isect
,
632 dprintk("%s bl_mark_sectors_init fail %d\n",
634 wdata
->pnfs_error
= ret
;
638 bio
= bl_add_page_to_bio(bio
, wdata
->npages
- i
, WRITE
,
640 bl_end_io_write
, par
);
642 wdata
->pnfs_error
= PTR_ERR(bio
);
646 isect
+= PAGE_CACHE_SECTORS
;
648 extent_length
-= PAGE_CACHE_SECTORS
;
651 /* Last page inside INVALID extent */
652 if (be
->be_state
== PNFS_BLOCK_INVALID_DATA
) {
653 bio
= bl_submit_bio(WRITE
, bio
);
654 temp
= last_isect
>> PAGE_CACHE_SECTOR_SHIFT
;
655 npg_zero
= npg_per_block
- do_div(temp
, npg_per_block
);
656 if (npg_zero
< npg_per_block
) {
658 goto fill_invalid_ext
;
663 wdata
->res
.count
= (last_isect
<< SECTOR_SHIFT
) - (offset
);
664 if (count
< wdata
->res
.count
) {
665 wdata
->res
.count
= count
;
669 bl_submit_bio(WRITE
, bio
);
671 return PNFS_ATTEMPTED
;
674 /* FIXME - range ignored */
676 release_extents(struct pnfs_block_layout
*bl
, struct pnfs_layout_range
*range
)
679 struct pnfs_block_extent
*be
;
681 spin_lock(&bl
->bl_ext_lock
);
682 for (i
= 0; i
< EXTENT_LISTS
; i
++) {
683 while (!list_empty(&bl
->bl_extents
[i
])) {
684 be
= list_first_entry(&bl
->bl_extents
[i
],
685 struct pnfs_block_extent
,
687 list_del(&be
->be_node
);
691 spin_unlock(&bl
->bl_ext_lock
);
695 release_inval_marks(struct pnfs_inval_markings
*marks
)
697 struct pnfs_inval_tracking
*pos
, *temp
;
699 list_for_each_entry_safe(pos
, temp
, &marks
->im_tree
.mtt_stub
, it_link
) {
700 list_del(&pos
->it_link
);
706 static void bl_free_layout_hdr(struct pnfs_layout_hdr
*lo
)
708 struct pnfs_block_layout
*bl
= BLK_LO2EXT(lo
);
710 dprintk("%s enter\n", __func__
);
711 release_extents(bl
, NULL
);
712 release_inval_marks(&bl
->bl_inval
);
716 static struct pnfs_layout_hdr
*bl_alloc_layout_hdr(struct inode
*inode
,
719 struct pnfs_block_layout
*bl
;
721 dprintk("%s enter\n", __func__
);
722 bl
= kzalloc(sizeof(*bl
), gfp_flags
);
725 spin_lock_init(&bl
->bl_ext_lock
);
726 INIT_LIST_HEAD(&bl
->bl_extents
[0]);
727 INIT_LIST_HEAD(&bl
->bl_extents
[1]);
728 INIT_LIST_HEAD(&bl
->bl_commit
);
729 INIT_LIST_HEAD(&bl
->bl_committing
);
731 bl
->bl_blocksize
= NFS_SERVER(inode
)->pnfs_blksize
>> SECTOR_SHIFT
;
732 BL_INIT_INVAL_MARKS(&bl
->bl_inval
, bl
->bl_blocksize
);
733 return &bl
->bl_layout
;
736 static void bl_free_lseg(struct pnfs_layout_segment
*lseg
)
738 dprintk("%s enter\n", __func__
);
742 /* We pretty much ignore lseg, and store all data layout wide, so we
743 * can correctly merge.
745 static struct pnfs_layout_segment
*bl_alloc_lseg(struct pnfs_layout_hdr
*lo
,
746 struct nfs4_layoutget_res
*lgr
,
749 struct pnfs_layout_segment
*lseg
;
752 dprintk("%s enter\n", __func__
);
753 lseg
= kzalloc(sizeof(*lseg
), gfp_flags
);
755 return ERR_PTR(-ENOMEM
);
756 status
= nfs4_blk_process_layoutget(lo
, lgr
, gfp_flags
);
758 /* We don't want to call the full-blown bl_free_lseg,
759 * since on error extents were not touched.
762 return ERR_PTR(status
);
768 bl_encode_layoutcommit(struct pnfs_layout_hdr
*lo
, struct xdr_stream
*xdr
,
769 const struct nfs4_layoutcommit_args
*arg
)
771 dprintk("%s enter\n", __func__
);
772 encode_pnfs_block_layoutupdate(BLK_LO2EXT(lo
), xdr
, arg
);
776 bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data
*lcdata
)
778 struct pnfs_layout_hdr
*lo
= NFS_I(lcdata
->args
.inode
)->layout
;
780 dprintk("%s enter\n", __func__
);
781 clean_pnfs_block_layoutupdate(BLK_LO2EXT(lo
), &lcdata
->args
, lcdata
->res
.status
);
784 static void free_blk_mountid(struct block_mount_id
*mid
)
787 struct pnfs_block_dev
*dev
, *tmp
;
789 /* No need to take bm_lock as we are last user freeing bm_devlist */
790 list_for_each_entry_safe(dev
, tmp
, &mid
->bm_devlist
, bm_node
) {
791 list_del(&dev
->bm_node
);
792 bl_free_block_dev(dev
);
798 /* This is mostly copied from the filelayout's get_device_info function.
799 * It seems much of this should be at the generic pnfs level.
801 static struct pnfs_block_dev
*
802 nfs4_blk_get_deviceinfo(struct nfs_server
*server
, const struct nfs_fh
*fh
,
803 struct nfs4_deviceid
*d_id
)
805 struct pnfs_device
*dev
;
806 struct pnfs_block_dev
*rv
;
809 struct page
**pages
= NULL
;
813 * Use the session max response size as the basis for setting
814 * GETDEVICEINFO's maxcount
816 max_resp_sz
= server
->nfs_client
->cl_session
->fc_attrs
.max_resp_sz
;
817 max_pages
= max_resp_sz
>> PAGE_SHIFT
;
818 dprintk("%s max_resp_sz %u max_pages %d\n",
819 __func__
, max_resp_sz
, max_pages
);
821 dev
= kmalloc(sizeof(*dev
), GFP_NOFS
);
823 dprintk("%s kmalloc failed\n", __func__
);
824 return ERR_PTR(-ENOMEM
);
827 pages
= kzalloc(max_pages
* sizeof(struct page
*), GFP_NOFS
);
830 return ERR_PTR(-ENOMEM
);
832 for (i
= 0; i
< max_pages
; i
++) {
833 pages
[i
] = alloc_page(GFP_NOFS
);
835 rv
= ERR_PTR(-ENOMEM
);
840 memcpy(&dev
->dev_id
, d_id
, sizeof(*d_id
));
841 dev
->layout_type
= LAYOUT_BLOCK_VOLUME
;
844 dev
->pglen
= PAGE_SIZE
* max_pages
;
847 dprintk("%s: dev_id: %s\n", __func__
, dev
->dev_id
.data
);
848 rc
= nfs4_proc_getdeviceinfo(server
, dev
);
849 dprintk("%s getdevice info returns %d\n", __func__
, rc
);
855 rv
= nfs4_blk_decode_device(server
, dev
);
857 for (i
= 0; i
< max_pages
; i
++)
858 __free_page(pages
[i
]);
865 bl_set_layoutdriver(struct nfs_server
*server
, const struct nfs_fh
*fh
)
867 struct block_mount_id
*b_mt_id
= NULL
;
868 struct pnfs_devicelist
*dlist
= NULL
;
869 struct pnfs_block_dev
*bdev
;
870 LIST_HEAD(block_disklist
);
873 dprintk("%s enter\n", __func__
);
875 if (server
->pnfs_blksize
== 0) {
876 dprintk("%s Server did not return blksize\n", __func__
);
879 b_mt_id
= kzalloc(sizeof(struct block_mount_id
), GFP_NOFS
);
884 /* Initialize nfs4 block layout mount id */
885 spin_lock_init(&b_mt_id
->bm_lock
);
886 INIT_LIST_HEAD(&b_mt_id
->bm_devlist
);
888 dlist
= kmalloc(sizeof(struct pnfs_devicelist
), GFP_NOFS
);
894 while (!dlist
->eof
) {
895 status
= nfs4_proc_getdevicelist(server
, fh
, dlist
);
898 dprintk("%s GETDEVICELIST numdevs=%i, eof=%i\n",
899 __func__
, dlist
->num_devs
, dlist
->eof
);
900 for (i
= 0; i
< dlist
->num_devs
; i
++) {
901 bdev
= nfs4_blk_get_deviceinfo(server
, fh
,
904 status
= PTR_ERR(bdev
);
907 spin_lock(&b_mt_id
->bm_lock
);
908 list_add(&bdev
->bm_node
, &b_mt_id
->bm_devlist
);
909 spin_unlock(&b_mt_id
->bm_lock
);
912 dprintk("%s SUCCESS\n", __func__
);
913 server
->pnfs_ld_data
= b_mt_id
;
920 free_blk_mountid(b_mt_id
);
925 bl_clear_layoutdriver(struct nfs_server
*server
)
927 struct block_mount_id
*b_mt_id
= server
->pnfs_ld_data
;
929 dprintk("%s enter\n", __func__
);
930 free_blk_mountid(b_mt_id
);
931 dprintk("%s RETURNS\n", __func__
);
935 static const struct nfs_pageio_ops bl_pg_read_ops
= {
936 .pg_init
= pnfs_generic_pg_init_read
,
937 .pg_test
= pnfs_generic_pg_test
,
938 .pg_doio
= pnfs_generic_pg_readpages
,
941 static const struct nfs_pageio_ops bl_pg_write_ops
= {
942 .pg_init
= pnfs_generic_pg_init_write
,
943 .pg_test
= pnfs_generic_pg_test
,
944 .pg_doio
= pnfs_generic_pg_writepages
,
947 static struct pnfs_layoutdriver_type blocklayout_type
= {
948 .id
= LAYOUT_BLOCK_VOLUME
,
949 .name
= "LAYOUT_BLOCK_VOLUME",
950 .read_pagelist
= bl_read_pagelist
,
951 .write_pagelist
= bl_write_pagelist
,
952 .alloc_layout_hdr
= bl_alloc_layout_hdr
,
953 .free_layout_hdr
= bl_free_layout_hdr
,
954 .alloc_lseg
= bl_alloc_lseg
,
955 .free_lseg
= bl_free_lseg
,
956 .encode_layoutcommit
= bl_encode_layoutcommit
,
957 .cleanup_layoutcommit
= bl_cleanup_layoutcommit
,
958 .set_layoutdriver
= bl_set_layoutdriver
,
959 .clear_layoutdriver
= bl_clear_layoutdriver
,
960 .pg_read_ops
= &bl_pg_read_ops
,
961 .pg_write_ops
= &bl_pg_write_ops
,
964 static const struct rpc_pipe_ops bl_upcall_ops
= {
965 .upcall
= rpc_pipe_generic_upcall
,
966 .downcall
= bl_pipe_downcall
,
967 .destroy_msg
= bl_pipe_destroy_msg
,
970 static int __init
nfs4blocklayout_init(void)
972 struct vfsmount
*mnt
;
976 dprintk("%s: NFSv4 Block Layout Driver Registering...\n", __func__
);
978 ret
= pnfs_register_layoutdriver(&blocklayout_type
);
982 init_waitqueue_head(&bl_wq
);
984 mnt
= rpc_get_mount();
990 ret
= vfs_path_lookup(mnt
->mnt_root
,
992 NFS_PIPE_DIRNAME
, 0, &path
);
996 bl_device_pipe
= rpc_mkpipe(path
.dentry
, "blocklayout", NULL
,
999 if (IS_ERR(bl_device_pipe
)) {
1000 ret
= PTR_ERR(bl_device_pipe
);
1009 pnfs_unregister_layoutdriver(&blocklayout_type
);
1013 static void __exit
nfs4blocklayout_exit(void)
1015 dprintk("%s: NFSv4 Block Layout Driver Unregistering...\n",
1018 pnfs_unregister_layoutdriver(&blocklayout_type
);
1019 rpc_unlink(bl_device_pipe
);
1023 MODULE_ALIAS("nfs-layouttype4-3");
1025 module_init(nfs4blocklayout_init
);
1026 module_exit(nfs4blocklayout_exit
);