2 * NVDIMM Block Window Driver
3 * Copyright (c) 2014, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 #include <linux/blkdev.h>
17 #include <linux/genhd.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
21 #include <linux/sizes.h>
24 struct nd_blk_device
{
25 struct request_queue
*queue
;
27 struct nd_namespace_blk
*nsblk
;
28 struct nd_blk_region
*ndbr
;
34 static int nd_blk_major
;
36 static u32
nd_blk_meta_size(struct nd_blk_device
*blk_dev
)
38 return blk_dev
->nsblk
->lbasize
- blk_dev
->sector_size
;
41 static resource_size_t
to_dev_offset(struct nd_namespace_blk
*nsblk
,
42 resource_size_t ns_offset
, unsigned int len
)
46 for (i
= 0; i
< nsblk
->num_resources
; i
++) {
47 if (ns_offset
< resource_size(nsblk
->res
[i
])) {
48 if (ns_offset
+ len
> resource_size(nsblk
->res
[i
])) {
49 dev_WARN_ONCE(&nsblk
->common
.dev
, 1,
53 return nsblk
->res
[i
]->start
+ ns_offset
;
55 ns_offset
-= resource_size(nsblk
->res
[i
]);
58 dev_WARN_ONCE(&nsblk
->common
.dev
, 1, "request out of range\n");
62 #ifdef CONFIG_BLK_DEV_INTEGRITY
63 static int nd_blk_rw_integrity(struct nd_blk_device
*blk_dev
,
64 struct bio_integrity_payload
*bip
, u64 lba
,
67 unsigned int len
= nd_blk_meta_size(blk_dev
);
68 resource_size_t dev_offset
, ns_offset
;
69 struct nd_namespace_blk
*nsblk
;
70 struct nd_blk_region
*ndbr
;
73 nsblk
= blk_dev
->nsblk
;
75 ns_offset
= lba
* blk_dev
->internal_lbasize
+ blk_dev
->sector_size
;
76 dev_offset
= to_dev_offset(nsblk
, ns_offset
, len
);
77 if (dev_offset
== SIZE_MAX
)
85 bv
= bvec_iter_bvec(bip
->bip_vec
, bip
->bip_iter
);
87 * The 'bv' obtained from bvec_iter_bvec has its .bv_len and
88 * .bv_offset already adjusted for iter->bi_bvec_done, and we
89 * can use those directly
92 cur_len
= min(len
, bv
.bv_len
);
93 iobuf
= kmap_atomic(bv
.bv_page
);
94 err
= ndbr
->do_io(ndbr
, dev_offset
, iobuf
+ bv
.bv_offset
,
101 dev_offset
+= cur_len
;
102 bvec_iter_advance(bip
->bip_vec
, &bip
->bip_iter
, cur_len
);
108 #else /* CONFIG_BLK_DEV_INTEGRITY */
109 static int nd_blk_rw_integrity(struct nd_blk_device
*blk_dev
,
110 struct bio_integrity_payload
*bip
, u64 lba
,
117 static int nd_blk_do_bvec(struct nd_blk_device
*blk_dev
,
118 struct bio_integrity_payload
*bip
, struct page
*page
,
119 unsigned int len
, unsigned int off
, int rw
,
122 struct nd_blk_region
*ndbr
= blk_dev
->ndbr
;
123 resource_size_t dev_offset
, ns_offset
;
129 unsigned int cur_len
;
132 * If we don't have an integrity payload, we don't have to
133 * split the bvec into sectors, as this would cause unnecessary
134 * Block Window setup/move steps. the do_io routine is capable
135 * of handling len <= PAGE_SIZE.
137 cur_len
= bip
? min(len
, blk_dev
->sector_size
) : len
;
139 lba
= div_u64(sector
<< SECTOR_SHIFT
, blk_dev
->sector_size
);
140 ns_offset
= lba
* blk_dev
->internal_lbasize
;
141 dev_offset
= to_dev_offset(blk_dev
->nsblk
, ns_offset
, cur_len
);
142 if (dev_offset
== SIZE_MAX
)
145 iobuf
= kmap_atomic(page
);
146 err
= ndbr
->do_io(ndbr
, dev_offset
, iobuf
+ off
, cur_len
, rw
);
147 kunmap_atomic(iobuf
);
152 err
= nd_blk_rw_integrity(blk_dev
, bip
, lba
, rw
);
158 sector
+= blk_dev
->sector_size
>> SECTOR_SHIFT
;
164 static void nd_blk_make_request(struct request_queue
*q
, struct bio
*bio
)
166 struct block_device
*bdev
= bio
->bi_bdev
;
167 struct gendisk
*disk
= bdev
->bd_disk
;
168 struct bio_integrity_payload
*bip
;
169 struct nd_blk_device
*blk_dev
;
170 struct bvec_iter iter
;
175 * bio_integrity_enabled also checks if the bio already has an
176 * integrity payload attached. If it does, we *don't* do a
177 * bio_integrity_prep here - the payload has been generated by
178 * another kernel subsystem, and we just pass it through.
180 if (bio_integrity_enabled(bio
) && bio_integrity_prep(bio
)) {
185 bip
= bio_integrity(bio
);
186 blk_dev
= disk
->private_data
;
187 rw
= bio_data_dir(bio
);
188 bio_for_each_segment(bvec
, bio
, iter
) {
189 unsigned int len
= bvec
.bv_len
;
191 BUG_ON(len
> PAGE_SIZE
);
192 err
= nd_blk_do_bvec(blk_dev
, bip
, bvec
.bv_page
, len
,
193 bvec
.bv_offset
, rw
, iter
.bi_sector
);
195 dev_info(&blk_dev
->nsblk
->common
.dev
,
196 "io error in %s sector %lld, len %d,\n",
197 (rw
== READ
) ? "READ" : "WRITE",
198 (unsigned long long) iter
.bi_sector
, len
);
207 static int nd_blk_rw_bytes(struct nd_namespace_common
*ndns
,
208 resource_size_t offset
, void *iobuf
, size_t n
, int rw
)
210 struct nd_blk_device
*blk_dev
= dev_get_drvdata(ndns
->claim
);
211 struct nd_namespace_blk
*nsblk
= blk_dev
->nsblk
;
212 struct nd_blk_region
*ndbr
= blk_dev
->ndbr
;
213 resource_size_t dev_offset
;
215 dev_offset
= to_dev_offset(nsblk
, offset
, n
);
217 if (unlikely(offset
+ n
> blk_dev
->disk_size
)) {
218 dev_WARN_ONCE(&ndns
->dev
, 1, "request out of range\n");
222 if (dev_offset
== SIZE_MAX
)
225 return ndbr
->do_io(ndbr
, dev_offset
, iobuf
, n
, rw
);
228 static const struct block_device_operations nd_blk_fops
= {
229 .owner
= THIS_MODULE
,
232 static int nd_blk_attach_disk(struct nd_namespace_common
*ndns
,
233 struct nd_blk_device
*blk_dev
)
235 resource_size_t available_disk_size
;
236 struct gendisk
*disk
;
239 internal_nlba
= div_u64(blk_dev
->disk_size
, blk_dev
->internal_lbasize
);
240 available_disk_size
= internal_nlba
* blk_dev
->sector_size
;
242 blk_dev
->queue
= blk_alloc_queue(GFP_KERNEL
);
246 blk_queue_make_request(blk_dev
->queue
, nd_blk_make_request
);
247 blk_queue_max_hw_sectors(blk_dev
->queue
, UINT_MAX
);
248 blk_queue_bounce_limit(blk_dev
->queue
, BLK_BOUNCE_ANY
);
249 blk_queue_logical_block_size(blk_dev
->queue
, blk_dev
->sector_size
);
250 queue_flag_set_unlocked(QUEUE_FLAG_NONROT
, blk_dev
->queue
);
252 disk
= blk_dev
->disk
= alloc_disk(0);
254 blk_cleanup_queue(blk_dev
->queue
);
258 disk
->driverfs_dev
= &ndns
->dev
;
259 disk
->major
= nd_blk_major
;
260 disk
->first_minor
= 0;
261 disk
->fops
= &nd_blk_fops
;
262 disk
->private_data
= blk_dev
;
263 disk
->queue
= blk_dev
->queue
;
264 disk
->flags
= GENHD_FL_EXT_DEVT
;
265 nvdimm_namespace_disk_name(ndns
, disk
->disk_name
);
266 set_capacity(disk
, 0);
269 if (nd_blk_meta_size(blk_dev
)) {
270 int rc
= nd_integrity_init(disk
, nd_blk_meta_size(blk_dev
));
275 blk_cleanup_queue(blk_dev
->queue
);
280 set_capacity(disk
, available_disk_size
>> SECTOR_SHIFT
);
284 static int nd_blk_probe(struct device
*dev
)
286 struct nd_namespace_common
*ndns
;
287 struct nd_namespace_blk
*nsblk
;
288 struct nd_blk_device
*blk_dev
;
291 ndns
= nvdimm_namespace_common_probe(dev
);
293 return PTR_ERR(ndns
);
295 blk_dev
= kzalloc(sizeof(*blk_dev
), GFP_KERNEL
);
299 nsblk
= to_nd_namespace_blk(&ndns
->dev
);
300 blk_dev
->disk_size
= nvdimm_namespace_capacity(ndns
);
301 blk_dev
->ndbr
= to_nd_blk_region(dev
->parent
);
302 blk_dev
->nsblk
= to_nd_namespace_blk(&ndns
->dev
);
303 blk_dev
->internal_lbasize
= roundup(nsblk
->lbasize
,
304 INT_LBASIZE_ALIGNMENT
);
305 blk_dev
->sector_size
= ((nsblk
->lbasize
>= 4096) ? 4096 : 512);
306 dev_set_drvdata(dev
, blk_dev
);
308 ndns
->rw_bytes
= nd_blk_rw_bytes
;
310 rc
= nvdimm_namespace_attach_btt(ndns
);
311 else if (nd_btt_probe(ndns
, blk_dev
) == 0) {
312 /* we'll come back as btt-blk */
315 rc
= nd_blk_attach_disk(ndns
, blk_dev
);
321 static void nd_blk_detach_disk(struct nd_blk_device
*blk_dev
)
323 del_gendisk(blk_dev
->disk
);
324 put_disk(blk_dev
->disk
);
325 blk_cleanup_queue(blk_dev
->queue
);
328 static int nd_blk_remove(struct device
*dev
)
330 struct nd_blk_device
*blk_dev
= dev_get_drvdata(dev
);
333 nvdimm_namespace_detach_btt(to_nd_btt(dev
)->ndns
);
335 nd_blk_detach_disk(blk_dev
);
341 static struct nd_device_driver nd_blk_driver
= {
342 .probe
= nd_blk_probe
,
343 .remove
= nd_blk_remove
,
347 .type
= ND_DRIVER_NAMESPACE_BLK
,
350 static int __init
nd_blk_init(void)
354 rc
= register_blkdev(0, "nd_blk");
359 rc
= nd_driver_register(&nd_blk_driver
);
362 unregister_blkdev(nd_blk_major
, "nd_blk");
367 static void __exit
nd_blk_exit(void)
369 driver_unregister(&nd_blk_driver
.drv
);
370 unregister_blkdev(nd_blk_major
, "nd_blk");
373 MODULE_AUTHOR("Ross Zwisler <ross.zwisler@linux.intel.com>");
374 MODULE_LICENSE("GPL v2");
375 MODULE_ALIAS_ND_DEVICE(ND_DEVICE_NAMESPACE_BLK
);
376 module_init(nd_blk_init
);
377 module_exit(nd_blk_exit
);