Loading...
1/*
2 * Copyright (C) 2020 Red Hat GmbH
3 *
4 * This file is released under the GPL.
5 *
6 * Device-mapper target to emulate smaller logical block
7 * size on backing devices exposing (natively) larger ones.
8 *
9 * E.g. 512 byte sector emulation on 4K native disks.
10 */
11
12#include "dm.h"
13#include <linux/module.h>
14#include <linux/workqueue.h>
15#include <linux/dm-bufio.h>
16
17#define DM_MSG_PREFIX "ebs"
18
19static void ebs_dtr(struct dm_target *ti);
20
21/* Emulated block size context. */
22struct ebs_c {
23 struct dm_dev *dev; /* Underlying device to emulate block size on. */
24 struct dm_bufio_client *bufio; /* Use dm-bufio for read and read-modify-write processing. */
25 struct workqueue_struct *wq; /* Workqueue for ^ processing of bios. */
26 struct work_struct ws; /* Work item used for ^. */
27 struct bio_list bios_in; /* Worker bios input list. */
28 spinlock_t lock; /* Guard bios input list above. */
29 sector_t start; /* <start> table line argument, see ebs_ctr below. */
30 unsigned int e_bs; /* Emulated block size in sectors exposed to upper layer. */
31 unsigned int u_bs; /* Underlying block size in sectors retrievd from/set on lower layer device. */
32 unsigned char block_shift; /* bitshift sectors -> blocks used in dm-bufio API. */
33 bool u_bs_set:1; /* Flag to indicate underlying block size is set on table line. */
34};
35
36static inline sector_t __sector_to_block(struct ebs_c *ec, sector_t sector)
37{
38 return sector >> ec->block_shift;
39}
40
41static inline sector_t __block_mod(sector_t sector, unsigned int bs)
42{
43 return sector & (bs - 1);
44}
45
46/* Return number of blocks for a bio, accounting for misalignement of start and end sectors. */
47static inline unsigned int __nr_blocks(struct ebs_c *ec, struct bio *bio)
48{
49 sector_t end_sector = __block_mod(bio->bi_iter.bi_sector, ec->u_bs) + bio_sectors(bio);
50
51 return __sector_to_block(ec, end_sector) + (__block_mod(end_sector, ec->u_bs) ? 1 : 0);
52}
53
54static inline bool __ebs_check_bs(unsigned int bs)
55{
56 return bs && is_power_of_2(bs);
57}
58
59/*
60 * READ/WRITE:
61 *
62 * copy blocks between bufio blocks and bio vector's (partial/overlapping) pages.
63 */
64static int __ebs_rw_bvec(struct ebs_c *ec, int rw, struct bio_vec *bv, struct bvec_iter *iter)
65{
66 int r = 0;
67 unsigned char *ba, *pa;
68 unsigned int cur_len;
69 unsigned int bv_len = bv->bv_len;
70 unsigned int buf_off = to_bytes(__block_mod(iter->bi_sector, ec->u_bs));
71 sector_t block = __sector_to_block(ec, iter->bi_sector);
72 struct dm_buffer *b;
73
74 if (unlikely(!bv->bv_page || !bv_len))
75 return -EIO;
76
77 pa = page_address(bv->bv_page) + bv->bv_offset;
78
79 /* Handle overlapping page <-> blocks */
80 while (bv_len) {
81 cur_len = min(dm_bufio_get_block_size(ec->bufio) - buf_off, bv_len);
82
83 /* Avoid reading for writes in case bio vector's page overwrites block completely. */
84 if (rw == READ || buf_off || bv_len < dm_bufio_get_block_size(ec->bufio))
85 ba = dm_bufio_read(ec->bufio, block, &b);
86 else
87 ba = dm_bufio_new(ec->bufio, block, &b);
88
89 if (unlikely(IS_ERR(ba))) {
90 /*
91 * Carry on with next buffer, if any, to issue all possible
92 * data but return error.
93 */
94 r = PTR_ERR(ba);
95 } else {
96 /* Copy data to/from bio to buffer if read/new was successful above. */
97 ba += buf_off;
98 if (rw == READ) {
99 memcpy(pa, ba, cur_len);
100 flush_dcache_page(bv->bv_page);
101 } else {
102 flush_dcache_page(bv->bv_page);
103 memcpy(ba, pa, cur_len);
104 dm_bufio_mark_partial_buffer_dirty(b, buf_off, buf_off + cur_len);
105 }
106
107 dm_bufio_release(b);
108 }
109
110 pa += cur_len;
111 bv_len -= cur_len;
112 buf_off = 0;
113 block++;
114 }
115
116 return r;
117}
118
119/* READ/WRITE: iterate bio vector's copying between (partial) pages and bufio blocks. */
120static int __ebs_rw_bio(struct ebs_c *ec, int rw, struct bio *bio)
121{
122 int r = 0, rr;
123 struct bio_vec bv;
124 struct bvec_iter iter;
125
126 bio_for_each_bvec(bv, bio, iter) {
127 rr = __ebs_rw_bvec(ec, rw, &bv, &iter);
128 if (rr)
129 r = rr;
130 }
131
132 return r;
133}
134
135/*
136 * Discard bio's blocks, i.e. pass discards down.
137 *
138 * Avoid discarding partial blocks at beginning and end;
139 * return 0 in case no blocks can be discarded as a result.
140 */
141static int __ebs_discard_bio(struct ebs_c *ec, struct bio *bio)
142{
143 sector_t block, blocks, sector = bio->bi_iter.bi_sector;
144
145 block = __sector_to_block(ec, sector);
146 blocks = __nr_blocks(ec, bio);
147
148 /*
149 * Partial first underlying block (__nr_blocks() may have
150 * resulted in one block).
151 */
152 if (__block_mod(sector, ec->u_bs)) {
153 block++;
154 blocks--;
155 }
156
157 /* Partial last underlying block if any. */
158 if (blocks && __block_mod(bio_end_sector(bio), ec->u_bs))
159 blocks--;
160
161 return blocks ? dm_bufio_issue_discard(ec->bufio, block, blocks) : 0;
162}
163
164/* Release blocks them from the bufio cache. */
165static void __ebs_forget_bio(struct ebs_c *ec, struct bio *bio)
166{
167 sector_t blocks, sector = bio->bi_iter.bi_sector;
168
169 blocks = __nr_blocks(ec, bio);
170
171 dm_bufio_forget_buffers(ec->bufio, __sector_to_block(ec, sector), blocks);
172}
173
174/* Worker funtion to process incoming bios. */
175static void __ebs_process_bios(struct work_struct *ws)
176{
177 int r;
178 bool write = false;
179 sector_t block1, block2;
180 struct ebs_c *ec = container_of(ws, struct ebs_c, ws);
181 struct bio *bio;
182 struct bio_list bios;
183
184 bio_list_init(&bios);
185
186 spin_lock_irq(&ec->lock);
187 bios = ec->bios_in;
188 bio_list_init(&ec->bios_in);
189 spin_unlock_irq(&ec->lock);
190
191 /* Prefetch all read and any mis-aligned write buffers */
192 bio_list_for_each(bio, &bios) {
193 block1 = __sector_to_block(ec, bio->bi_iter.bi_sector);
194 if (bio_op(bio) == REQ_OP_READ)
195 dm_bufio_prefetch(ec->bufio, block1, __nr_blocks(ec, bio));
196 else if (bio_op(bio) == REQ_OP_WRITE && !(bio->bi_opf & REQ_PREFLUSH)) {
197 block2 = __sector_to_block(ec, bio_end_sector(bio));
198 if (__block_mod(bio->bi_iter.bi_sector, ec->u_bs))
199 dm_bufio_prefetch(ec->bufio, block1, 1);
200 if (__block_mod(bio_end_sector(bio), ec->u_bs) && block2 != block1)
201 dm_bufio_prefetch(ec->bufio, block2, 1);
202 }
203 }
204
205 bio_list_for_each(bio, &bios) {
206 r = -EIO;
207 if (bio_op(bio) == REQ_OP_READ)
208 r = __ebs_rw_bio(ec, READ, bio);
209 else if (bio_op(bio) == REQ_OP_WRITE) {
210 write = true;
211 r = __ebs_rw_bio(ec, WRITE, bio);
212 } else if (bio_op(bio) == REQ_OP_DISCARD) {
213 __ebs_forget_bio(ec, bio);
214 r = __ebs_discard_bio(ec, bio);
215 }
216
217 if (r < 0)
218 bio->bi_status = errno_to_blk_status(r);
219 }
220
221 /*
222 * We write dirty buffers after processing I/O on them
223 * but before we endio thus addressing REQ_FUA/REQ_SYNC.
224 */
225 r = write ? dm_bufio_write_dirty_buffers(ec->bufio) : 0;
226
227 while ((bio = bio_list_pop(&bios))) {
228 /* Any other request is endioed. */
229 if (unlikely(r && bio_op(bio) == REQ_OP_WRITE))
230 bio_io_error(bio);
231 else
232 bio_endio(bio);
233 }
234}
235
236/*
237 * Construct an emulated block size mapping: <dev_path> <offset> <ebs> [<ubs>]
238 *
239 * <dev_path>: path of the underlying device
240 * <offset>: offset in 512 bytes sectors into <dev_path>
241 * <ebs>: emulated block size in units of 512 bytes exposed to the upper layer
242 * [<ubs>]: underlying block size in units of 512 bytes imposed on the lower layer;
243 * optional, if not supplied, retrieve logical block size from underlying device
244 */
245static int ebs_ctr(struct dm_target *ti, unsigned int argc, char **argv)
246{
247 int r;
248 unsigned short tmp1;
249 unsigned long long tmp;
250 char dummy;
251 struct ebs_c *ec;
252
253 if (argc < 3 || argc > 4) {
254 ti->error = "Invalid argument count";
255 return -EINVAL;
256 }
257
258 ec = ti->private = kzalloc(sizeof(*ec), GFP_KERNEL);
259 if (!ec) {
260 ti->error = "Cannot allocate ebs context";
261 return -ENOMEM;
262 }
263
264 r = -EINVAL;
265 if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1 ||
266 tmp != (sector_t)tmp ||
267 (sector_t)tmp >= ti->len) {
268 ti->error = "Invalid device offset sector";
269 goto bad;
270 }
271 ec->start = tmp;
272
273 if (sscanf(argv[2], "%hu%c", &tmp1, &dummy) != 1 ||
274 !__ebs_check_bs(tmp1) ||
275 to_bytes(tmp1) > PAGE_SIZE) {
276 ti->error = "Invalid emulated block size";
277 goto bad;
278 }
279 ec->e_bs = tmp1;
280
281 if (argc > 3) {
282 if (sscanf(argv[3], "%hu%c", &tmp1, &dummy) != 1 || !__ebs_check_bs(tmp1)) {
283 ti->error = "Invalid underlying block size";
284 goto bad;
285 }
286 ec->u_bs = tmp1;
287 ec->u_bs_set = true;
288 } else
289 ec->u_bs_set = false;
290
291 r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ec->dev);
292 if (r) {
293 ti->error = "Device lookup failed";
294 ec->dev = NULL;
295 goto bad;
296 }
297
298 r = -EINVAL;
299 if (!ec->u_bs_set) {
300 ec->u_bs = to_sector(bdev_logical_block_size(ec->dev->bdev));
301 if (!__ebs_check_bs(ec->u_bs)) {
302 ti->error = "Invalid retrieved underlying block size";
303 goto bad;
304 }
305 }
306
307 if (!ec->u_bs_set && ec->e_bs == ec->u_bs)
308 DMINFO("Emulation superfluous: emulated equal to underlying block size");
309
310 if (__block_mod(ec->start, ec->u_bs)) {
311 ti->error = "Device offset must be multiple of underlying block size";
312 goto bad;
313 }
314
315 ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1, 0, NULL, NULL);
316 if (IS_ERR(ec->bufio)) {
317 ti->error = "Cannot create dm bufio client";
318 r = PTR_ERR(ec->bufio);
319 ec->bufio = NULL;
320 goto bad;
321 }
322
323 ec->wq = alloc_ordered_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM);
324 if (!ec->wq) {
325 ti->error = "Cannot create dm-" DM_MSG_PREFIX " workqueue";
326 r = -ENOMEM;
327 goto bad;
328 }
329
330 ec->block_shift = __ffs(ec->u_bs);
331 INIT_WORK(&ec->ws, &__ebs_process_bios);
332 bio_list_init(&ec->bios_in);
333 spin_lock_init(&ec->lock);
334
335 ti->num_flush_bios = 1;
336 ti->num_discard_bios = 1;
337 ti->num_secure_erase_bios = 0;
338 ti->num_write_same_bios = 0;
339 ti->num_write_zeroes_bios = 0;
340 return 0;
341bad:
342 ebs_dtr(ti);
343 return r;
344}
345
346static void ebs_dtr(struct dm_target *ti)
347{
348 struct ebs_c *ec = ti->private;
349
350 if (ec->wq)
351 destroy_workqueue(ec->wq);
352 if (ec->bufio)
353 dm_bufio_client_destroy(ec->bufio);
354 if (ec->dev)
355 dm_put_device(ti, ec->dev);
356 kfree(ec);
357}
358
359static int ebs_map(struct dm_target *ti, struct bio *bio)
360{
361 struct ebs_c *ec = ti->private;
362
363 bio_set_dev(bio, ec->dev->bdev);
364 bio->bi_iter.bi_sector = ec->start + dm_target_offset(ti, bio->bi_iter.bi_sector);
365
366 if (unlikely(bio_op(bio) == REQ_OP_FLUSH))
367 return DM_MAPIO_REMAPPED;
368 /*
369 * Only queue for bufio processing in case of partial or overlapping buffers
370 * -or-
371 * emulation with ebs == ubs aiming for tests of dm-bufio overhead.
372 */
373 if (likely(__block_mod(bio->bi_iter.bi_sector, ec->u_bs) ||
374 __block_mod(bio_end_sector(bio), ec->u_bs) ||
375 ec->e_bs == ec->u_bs)) {
376 spin_lock_irq(&ec->lock);
377 bio_list_add(&ec->bios_in, bio);
378 spin_unlock_irq(&ec->lock);
379
380 queue_work(ec->wq, &ec->ws);
381
382 return DM_MAPIO_SUBMITTED;
383 }
384
385 /* Forget any buffer content relative to this direct backing device I/O. */
386 __ebs_forget_bio(ec, bio);
387
388 return DM_MAPIO_REMAPPED;
389}
390
391static void ebs_status(struct dm_target *ti, status_type_t type,
392 unsigned status_flags, char *result, unsigned maxlen)
393{
394 struct ebs_c *ec = ti->private;
395
396 switch (type) {
397 case STATUSTYPE_INFO:
398 *result = '\0';
399 break;
400 case STATUSTYPE_TABLE:
401 snprintf(result, maxlen, ec->u_bs_set ? "%s %llu %u %u" : "%s %llu %u",
402 ec->dev->name, (unsigned long long) ec->start, ec->e_bs, ec->u_bs);
403 break;
404 }
405}
406
407static int ebs_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
408{
409 struct ebs_c *ec = ti->private;
410 struct dm_dev *dev = ec->dev;
411
412 /*
413 * Only pass ioctls through if the device sizes match exactly.
414 */
415 *bdev = dev->bdev;
416 return !!(ec->start || ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT);
417}
418
419static void ebs_io_hints(struct dm_target *ti, struct queue_limits *limits)
420{
421 struct ebs_c *ec = ti->private;
422
423 limits->logical_block_size = to_bytes(ec->e_bs);
424 limits->physical_block_size = to_bytes(ec->u_bs);
425 limits->alignment_offset = limits->physical_block_size;
426 blk_limits_io_min(limits, limits->logical_block_size);
427}
428
429static int ebs_iterate_devices(struct dm_target *ti,
430 iterate_devices_callout_fn fn, void *data)
431{
432 struct ebs_c *ec = ti->private;
433
434 return fn(ti, ec->dev, ec->start, ti->len, data);
435}
436
437static struct target_type ebs_target = {
438 .name = "ebs",
439 .version = {1, 0, 1},
440 .features = DM_TARGET_PASSES_INTEGRITY,
441 .module = THIS_MODULE,
442 .ctr = ebs_ctr,
443 .dtr = ebs_dtr,
444 .map = ebs_map,
445 .status = ebs_status,
446 .io_hints = ebs_io_hints,
447 .prepare_ioctl = ebs_prepare_ioctl,
448 .iterate_devices = ebs_iterate_devices,
449};
450
451static int __init dm_ebs_init(void)
452{
453 int r = dm_register_target(&ebs_target);
454
455 if (r < 0)
456 DMERR("register failed %d", r);
457
458 return r;
459}
460
461static void dm_ebs_exit(void)
462{
463 dm_unregister_target(&ebs_target);
464}
465
466module_init(dm_ebs_init);
467module_exit(dm_ebs_exit);
468
469MODULE_AUTHOR("Heinz Mauelshagen <dm-devel@redhat.com>");
470MODULE_DESCRIPTION(DM_NAME " emulated block size target");
471MODULE_LICENSE("GPL");
1/*
2 * Copyright (C) 2020 Red Hat GmbH
3 *
4 * This file is released under the GPL.
5 *
6 * Device-mapper target to emulate smaller logical block
7 * size on backing devices exposing (natively) larger ones.
8 *
9 * E.g. 512 byte sector emulation on 4K native disks.
10 */
11
12#include "dm.h"
13#include <linux/module.h>
14#include <linux/workqueue.h>
15#include <linux/dm-bufio.h>
16
17#define DM_MSG_PREFIX "ebs"
18
19static void ebs_dtr(struct dm_target *ti);
20
21/* Emulated block size context. */
22struct ebs_c {
23 struct dm_dev *dev; /* Underlying device to emulate block size on. */
24 struct dm_bufio_client *bufio; /* Use dm-bufio for read and read-modify-write processing. */
25 struct workqueue_struct *wq; /* Workqueue for ^ processing of bios. */
26 struct work_struct ws; /* Work item used for ^. */
27 struct bio_list bios_in; /* Worker bios input list. */
28 spinlock_t lock; /* Guard bios input list above. */
29 sector_t start; /* <start> table line argument, see ebs_ctr below. */
30 unsigned int e_bs; /* Emulated block size in sectors exposed to upper layer. */
31 unsigned int u_bs; /* Underlying block size in sectors retrieved from/set on lower layer device. */
32 unsigned char block_shift; /* bitshift sectors -> blocks used in dm-bufio API. */
33 bool u_bs_set:1; /* Flag to indicate underlying block size is set on table line. */
34};
35
36static inline sector_t __sector_to_block(struct ebs_c *ec, sector_t sector)
37{
38 return sector >> ec->block_shift;
39}
40
41static inline sector_t __block_mod(sector_t sector, unsigned int bs)
42{
43 return sector & (bs - 1);
44}
45
46/* Return number of blocks for a bio, accounting for misalignment of start and end sectors. */
47static inline unsigned int __nr_blocks(struct ebs_c *ec, struct bio *bio)
48{
49 sector_t end_sector = __block_mod(bio->bi_iter.bi_sector, ec->u_bs) + bio_sectors(bio);
50
51 return __sector_to_block(ec, end_sector) + (__block_mod(end_sector, ec->u_bs) ? 1 : 0);
52}
53
54static inline bool __ebs_check_bs(unsigned int bs)
55{
56 return bs && is_power_of_2(bs);
57}
58
59/*
60 * READ/WRITE:
61 *
62 * copy blocks between bufio blocks and bio vector's (partial/overlapping) pages.
63 */
64static int __ebs_rw_bvec(struct ebs_c *ec, enum req_op op, struct bio_vec *bv,
65 struct bvec_iter *iter)
66{
67 int r = 0;
68 unsigned char *ba, *pa;
69 unsigned int cur_len;
70 unsigned int bv_len = bv->bv_len;
71 unsigned int buf_off = to_bytes(__block_mod(iter->bi_sector, ec->u_bs));
72 sector_t block = __sector_to_block(ec, iter->bi_sector);
73 struct dm_buffer *b;
74
75 if (unlikely(!bv->bv_page || !bv_len))
76 return -EIO;
77
78 pa = bvec_virt(bv);
79
80 /* Handle overlapping page <-> blocks */
81 while (bv_len) {
82 cur_len = min(dm_bufio_get_block_size(ec->bufio) - buf_off, bv_len);
83
84 /* Avoid reading for writes in case bio vector's page overwrites block completely. */
85 if (op == REQ_OP_READ || buf_off || bv_len < dm_bufio_get_block_size(ec->bufio))
86 ba = dm_bufio_read(ec->bufio, block, &b);
87 else
88 ba = dm_bufio_new(ec->bufio, block, &b);
89
90 if (IS_ERR(ba)) {
91 /*
92 * Carry on with next buffer, if any, to issue all possible
93 * data but return error.
94 */
95 r = PTR_ERR(ba);
96 } else {
97 /* Copy data to/from bio to buffer if read/new was successful above. */
98 ba += buf_off;
99 if (op == REQ_OP_READ) {
100 memcpy(pa, ba, cur_len);
101 flush_dcache_page(bv->bv_page);
102 } else {
103 flush_dcache_page(bv->bv_page);
104 memcpy(ba, pa, cur_len);
105 dm_bufio_mark_partial_buffer_dirty(b, buf_off, buf_off + cur_len);
106 }
107
108 dm_bufio_release(b);
109 }
110
111 pa += cur_len;
112 bv_len -= cur_len;
113 buf_off = 0;
114 block++;
115 }
116
117 return r;
118}
119
120/* READ/WRITE: iterate bio vector's copying between (partial) pages and bufio blocks. */
121static int __ebs_rw_bio(struct ebs_c *ec, enum req_op op, struct bio *bio)
122{
123 int r = 0, rr;
124 struct bio_vec bv;
125 struct bvec_iter iter;
126
127 bio_for_each_bvec(bv, bio, iter) {
128 rr = __ebs_rw_bvec(ec, op, &bv, &iter);
129 if (rr)
130 r = rr;
131 }
132
133 return r;
134}
135
136/*
137 * Discard bio's blocks, i.e. pass discards down.
138 *
139 * Avoid discarding partial blocks at beginning and end;
140 * return 0 in case no blocks can be discarded as a result.
141 */
142static int __ebs_discard_bio(struct ebs_c *ec, struct bio *bio)
143{
144 sector_t block, blocks, sector = bio->bi_iter.bi_sector;
145
146 block = __sector_to_block(ec, sector);
147 blocks = __nr_blocks(ec, bio);
148
149 /*
150 * Partial first underlying block (__nr_blocks() may have
151 * resulted in one block).
152 */
153 if (__block_mod(sector, ec->u_bs)) {
154 block++;
155 blocks--;
156 }
157
158 /* Partial last underlying block if any. */
159 if (blocks && __block_mod(bio_end_sector(bio), ec->u_bs))
160 blocks--;
161
162 return blocks ? dm_bufio_issue_discard(ec->bufio, block, blocks) : 0;
163}
164
165/* Release blocks them from the bufio cache. */
166static void __ebs_forget_bio(struct ebs_c *ec, struct bio *bio)
167{
168 sector_t blocks, sector = bio->bi_iter.bi_sector;
169
170 blocks = __nr_blocks(ec, bio);
171
172 dm_bufio_forget_buffers(ec->bufio, __sector_to_block(ec, sector), blocks);
173}
174
175/* Worker function to process incoming bios. */
176static void __ebs_process_bios(struct work_struct *ws)
177{
178 int r;
179 bool write = false;
180 sector_t block1, block2;
181 struct ebs_c *ec = container_of(ws, struct ebs_c, ws);
182 struct bio *bio;
183 struct bio_list bios;
184
185 bio_list_init(&bios);
186
187 spin_lock_irq(&ec->lock);
188 bios = ec->bios_in;
189 bio_list_init(&ec->bios_in);
190 spin_unlock_irq(&ec->lock);
191
192 /* Prefetch all read and any mis-aligned write buffers */
193 bio_list_for_each(bio, &bios) {
194 block1 = __sector_to_block(ec, bio->bi_iter.bi_sector);
195 if (bio_op(bio) == REQ_OP_READ)
196 dm_bufio_prefetch(ec->bufio, block1, __nr_blocks(ec, bio));
197 else if (bio_op(bio) == REQ_OP_WRITE && !(bio->bi_opf & REQ_PREFLUSH)) {
198 block2 = __sector_to_block(ec, bio_end_sector(bio));
199 if (__block_mod(bio->bi_iter.bi_sector, ec->u_bs))
200 dm_bufio_prefetch(ec->bufio, block1, 1);
201 if (__block_mod(bio_end_sector(bio), ec->u_bs) && block2 != block1)
202 dm_bufio_prefetch(ec->bufio, block2, 1);
203 }
204 }
205
206 bio_list_for_each(bio, &bios) {
207 r = -EIO;
208 if (bio_op(bio) == REQ_OP_READ)
209 r = __ebs_rw_bio(ec, REQ_OP_READ, bio);
210 else if (bio_op(bio) == REQ_OP_WRITE) {
211 write = true;
212 r = __ebs_rw_bio(ec, REQ_OP_WRITE, bio);
213 } else if (bio_op(bio) == REQ_OP_DISCARD) {
214 __ebs_forget_bio(ec, bio);
215 r = __ebs_discard_bio(ec, bio);
216 }
217
218 if (r < 0)
219 bio->bi_status = errno_to_blk_status(r);
220 }
221
222 /*
223 * We write dirty buffers after processing I/O on them
224 * but before we endio thus addressing REQ_FUA/REQ_SYNC.
225 */
226 r = write ? dm_bufio_write_dirty_buffers(ec->bufio) : 0;
227
228 while ((bio = bio_list_pop(&bios))) {
229 /* Any other request is endioed. */
230 if (unlikely(r && bio_op(bio) == REQ_OP_WRITE))
231 bio_io_error(bio);
232 else
233 bio_endio(bio);
234 }
235}
236
237/*
238 * Construct an emulated block size mapping: <dev_path> <offset> <ebs> [<ubs>]
239 *
240 * <dev_path>: path of the underlying device
241 * <offset>: offset in 512 bytes sectors into <dev_path>
242 * <ebs>: emulated block size in units of 512 bytes exposed to the upper layer
243 * [<ubs>]: underlying block size in units of 512 bytes imposed on the lower layer;
244 * optional, if not supplied, retrieve logical block size from underlying device
245 */
246static int ebs_ctr(struct dm_target *ti, unsigned int argc, char **argv)
247{
248 int r;
249 unsigned short tmp1;
250 unsigned long long tmp;
251 char dummy;
252 struct ebs_c *ec;
253
254 if (argc < 3 || argc > 4) {
255 ti->error = "Invalid argument count";
256 return -EINVAL;
257 }
258
259 ec = ti->private = kzalloc(sizeof(*ec), GFP_KERNEL);
260 if (!ec) {
261 ti->error = "Cannot allocate ebs context";
262 return -ENOMEM;
263 }
264
265 r = -EINVAL;
266 if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1 ||
267 tmp != (sector_t)tmp ||
268 (sector_t)tmp >= ti->len) {
269 ti->error = "Invalid device offset sector";
270 goto bad;
271 }
272 ec->start = tmp;
273
274 if (sscanf(argv[2], "%hu%c", &tmp1, &dummy) != 1 ||
275 !__ebs_check_bs(tmp1) ||
276 to_bytes(tmp1) > PAGE_SIZE) {
277 ti->error = "Invalid emulated block size";
278 goto bad;
279 }
280 ec->e_bs = tmp1;
281
282 if (argc > 3) {
283 if (sscanf(argv[3], "%hu%c", &tmp1, &dummy) != 1 || !__ebs_check_bs(tmp1)) {
284 ti->error = "Invalid underlying block size";
285 goto bad;
286 }
287 ec->u_bs = tmp1;
288 ec->u_bs_set = true;
289 } else
290 ec->u_bs_set = false;
291
292 r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ec->dev);
293 if (r) {
294 ti->error = "Device lookup failed";
295 ec->dev = NULL;
296 goto bad;
297 }
298
299 r = -EINVAL;
300 if (!ec->u_bs_set) {
301 ec->u_bs = to_sector(bdev_logical_block_size(ec->dev->bdev));
302 if (!__ebs_check_bs(ec->u_bs)) {
303 ti->error = "Invalid retrieved underlying block size";
304 goto bad;
305 }
306 }
307
308 if (!ec->u_bs_set && ec->e_bs == ec->u_bs)
309 DMINFO("Emulation superfluous: emulated equal to underlying block size");
310
311 if (__block_mod(ec->start, ec->u_bs)) {
312 ti->error = "Device offset must be multiple of underlying block size";
313 goto bad;
314 }
315
316 ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1,
317 0, NULL, NULL, 0);
318 if (IS_ERR(ec->bufio)) {
319 ti->error = "Cannot create dm bufio client";
320 r = PTR_ERR(ec->bufio);
321 ec->bufio = NULL;
322 goto bad;
323 }
324
325 ec->wq = alloc_ordered_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM);
326 if (!ec->wq) {
327 ti->error = "Cannot create dm-" DM_MSG_PREFIX " workqueue";
328 r = -ENOMEM;
329 goto bad;
330 }
331
332 ec->block_shift = __ffs(ec->u_bs);
333 INIT_WORK(&ec->ws, &__ebs_process_bios);
334 bio_list_init(&ec->bios_in);
335 spin_lock_init(&ec->lock);
336
337 ti->num_flush_bios = 1;
338 ti->num_discard_bios = 1;
339 ti->num_secure_erase_bios = 0;
340 ti->num_write_zeroes_bios = 0;
341 return 0;
342bad:
343 ebs_dtr(ti);
344 return r;
345}
346
347static void ebs_dtr(struct dm_target *ti)
348{
349 struct ebs_c *ec = ti->private;
350
351 if (ec->wq)
352 destroy_workqueue(ec->wq);
353 if (ec->bufio)
354 dm_bufio_client_destroy(ec->bufio);
355 if (ec->dev)
356 dm_put_device(ti, ec->dev);
357 kfree(ec);
358}
359
360static int ebs_map(struct dm_target *ti, struct bio *bio)
361{
362 struct ebs_c *ec = ti->private;
363
364 bio_set_dev(bio, ec->dev->bdev);
365 bio->bi_iter.bi_sector = ec->start + dm_target_offset(ti, bio->bi_iter.bi_sector);
366
367 if (unlikely(bio_op(bio) == REQ_OP_FLUSH))
368 return DM_MAPIO_REMAPPED;
369 /*
370 * Only queue for bufio processing in case of partial or overlapping buffers
371 * -or-
372 * emulation with ebs == ubs aiming for tests of dm-bufio overhead.
373 */
374 if (likely(__block_mod(bio->bi_iter.bi_sector, ec->u_bs) ||
375 __block_mod(bio_end_sector(bio), ec->u_bs) ||
376 ec->e_bs == ec->u_bs)) {
377 spin_lock_irq(&ec->lock);
378 bio_list_add(&ec->bios_in, bio);
379 spin_unlock_irq(&ec->lock);
380
381 queue_work(ec->wq, &ec->ws);
382
383 return DM_MAPIO_SUBMITTED;
384 }
385
386 /* Forget any buffer content relative to this direct backing device I/O. */
387 __ebs_forget_bio(ec, bio);
388
389 return DM_MAPIO_REMAPPED;
390}
391
392static void ebs_status(struct dm_target *ti, status_type_t type,
393 unsigned status_flags, char *result, unsigned maxlen)
394{
395 struct ebs_c *ec = ti->private;
396
397 switch (type) {
398 case STATUSTYPE_INFO:
399 *result = '\0';
400 break;
401 case STATUSTYPE_TABLE:
402 snprintf(result, maxlen, ec->u_bs_set ? "%s %llu %u %u" : "%s %llu %u",
403 ec->dev->name, (unsigned long long) ec->start, ec->e_bs, ec->u_bs);
404 break;
405 case STATUSTYPE_IMA:
406 *result = '\0';
407 break;
408 }
409}
410
411static int ebs_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
412{
413 struct ebs_c *ec = ti->private;
414 struct dm_dev *dev = ec->dev;
415
416 /*
417 * Only pass ioctls through if the device sizes match exactly.
418 */
419 *bdev = dev->bdev;
420 return !!(ec->start || ti->len != bdev_nr_sectors(dev->bdev));
421}
422
423static void ebs_io_hints(struct dm_target *ti, struct queue_limits *limits)
424{
425 struct ebs_c *ec = ti->private;
426
427 limits->logical_block_size = to_bytes(ec->e_bs);
428 limits->physical_block_size = to_bytes(ec->u_bs);
429 limits->alignment_offset = limits->physical_block_size;
430 blk_limits_io_min(limits, limits->logical_block_size);
431}
432
433static int ebs_iterate_devices(struct dm_target *ti,
434 iterate_devices_callout_fn fn, void *data)
435{
436 struct ebs_c *ec = ti->private;
437
438 return fn(ti, ec->dev, ec->start, ti->len, data);
439}
440
441static struct target_type ebs_target = {
442 .name = "ebs",
443 .version = {1, 0, 1},
444 .features = DM_TARGET_PASSES_INTEGRITY,
445 .module = THIS_MODULE,
446 .ctr = ebs_ctr,
447 .dtr = ebs_dtr,
448 .map = ebs_map,
449 .status = ebs_status,
450 .io_hints = ebs_io_hints,
451 .prepare_ioctl = ebs_prepare_ioctl,
452 .iterate_devices = ebs_iterate_devices,
453};
454
455static int __init dm_ebs_init(void)
456{
457 int r = dm_register_target(&ebs_target);
458
459 if (r < 0)
460 DMERR("register failed %d", r);
461
462 return r;
463}
464
465static void dm_ebs_exit(void)
466{
467 dm_unregister_target(&ebs_target);
468}
469
470module_init(dm_ebs_init);
471module_exit(dm_ebs_exit);
472
473MODULE_AUTHOR("Heinz Mauelshagen <dm-devel@redhat.com>");
474MODULE_DESCRIPTION(DM_NAME " emulated block size target");
475MODULE_LICENSE("GPL");