]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright (C) 2001-2003 Sistina Software (UK) Limited. | |
3 | * | |
4 | * This file is released under the GPL. | |
5 | */ | |
6 | ||
7 | #include "dm.h" | |
1da177e4 LT |
8 | #include <linux/module.h> |
9 | #include <linux/init.h> | |
10 | #include <linux/blkdev.h> | |
11 | #include <linux/bio.h> | |
817bf402 | 12 | #include <linux/dax.h> |
1da177e4 | 13 | #include <linux/slab.h> |
586e80e6 | 14 | #include <linux/device-mapper.h> |
1da177e4 | 15 | |
72d94861 AK |
16 | #define DM_MSG_PREFIX "linear" |
17 | ||
1da177e4 LT |
18 | /* |
19 | * Linear: maps a linear range of a device. | |
20 | */ | |
21 | struct linear_c { | |
22 | struct dm_dev *dev; | |
23 | sector_t start; | |
24 | }; | |
25 | ||
26 | /* | |
27 | * Construct a linear mapping: <dev_path> <offset> | |
28 | */ | |
29 | static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv) | |
30 | { | |
31 | struct linear_c *lc; | |
4ee218cd | 32 | unsigned long long tmp; |
31998ef1 | 33 | char dummy; |
e80d1c80 | 34 | int ret; |
1da177e4 LT |
35 | |
36 | if (argc != 2) { | |
72d94861 | 37 | ti->error = "Invalid argument count"; |
1da177e4 LT |
38 | return -EINVAL; |
39 | } | |
40 | ||
41 | lc = kmalloc(sizeof(*lc), GFP_KERNEL); | |
42 | if (lc == NULL) { | |
00272c85 | 43 | ti->error = "Cannot allocate linear context"; |
1da177e4 LT |
44 | return -ENOMEM; |
45 | } | |
46 | ||
e80d1c80 | 47 | ret = -EINVAL; |
31998ef1 | 48 | if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1) { |
00272c85 | 49 | ti->error = "Invalid device sector"; |
1da177e4 LT |
50 | goto bad; |
51 | } | |
4ee218cd | 52 | lc->start = tmp; |
1da177e4 | 53 | |
e80d1c80 VG |
54 | ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &lc->dev); |
55 | if (ret) { | |
00272c85 | 56 | ti->error = "Device lookup failed"; |
1da177e4 LT |
57 | goto bad; |
58 | } | |
59 | ||
55a62eef AK |
60 | ti->num_flush_bios = 1; |
61 | ti->num_discard_bios = 1; | |
62 | ti->num_write_same_bios = 1; | |
ac62d620 | 63 | ti->num_write_zeroes_bios = 1; |
1da177e4 LT |
64 | ti->private = lc; |
65 | return 0; | |
66 | ||
67 | bad: | |
68 | kfree(lc); | |
e80d1c80 | 69 | return ret; |
1da177e4 LT |
70 | } |
71 | ||
72 | static void linear_dtr(struct dm_target *ti) | |
73 | { | |
74 | struct linear_c *lc = (struct linear_c *) ti->private; | |
75 | ||
76 | dm_put_device(ti, lc->dev); | |
77 | kfree(lc); | |
78 | } | |
79 | ||
7bc3447b | 80 | static sector_t linear_map_sector(struct dm_target *ti, sector_t bi_sector) |
1da177e4 | 81 | { |
7bc3447b MB |
82 | struct linear_c *lc = ti->private; |
83 | ||
b441a262 | 84 | return lc->start + dm_target_offset(ti, bi_sector); |
7bc3447b MB |
85 | } |
86 | ||
87 | static void linear_map_bio(struct dm_target *ti, struct bio *bio) | |
88 | { | |
89 | struct linear_c *lc = ti->private; | |
1da177e4 | 90 | |
74d46992 | 91 | bio_set_dev(bio, lc->dev->bdev); |
0be12c1c | 92 | if (bio_sectors(bio) || bio_op(bio) == REQ_OP_ZONE_RESET) |
4f024f37 KO |
93 | bio->bi_iter.bi_sector = |
94 | linear_map_sector(ti, bio->bi_iter.bi_sector); | |
7bc3447b MB |
95 | } |
96 | ||
7de3ee57 | 97 | static int linear_map(struct dm_target *ti, struct bio *bio) |
7bc3447b MB |
98 | { |
99 | linear_map_bio(ti, bio); | |
1da177e4 | 100 | |
d2a7ad29 | 101 | return DM_MAPIO_REMAPPED; |
1da177e4 LT |
102 | } |
103 | ||
0be12c1c DLM |
104 | static int linear_end_io(struct dm_target *ti, struct bio *bio, |
105 | blk_status_t *error) | |
106 | { | |
107 | struct linear_c *lc = ti->private; | |
108 | ||
109 | if (!*error && bio_op(bio) == REQ_OP_ZONE_REPORT) | |
110 | dm_remap_zone_report(ti, bio, lc->start); | |
111 | ||
112 | return DM_ENDIO_DONE; | |
113 | } | |
114 | ||
fd7c092e MP |
115 | static void linear_status(struct dm_target *ti, status_type_t type, |
116 | unsigned status_flags, char *result, unsigned maxlen) | |
1da177e4 LT |
117 | { |
118 | struct linear_c *lc = (struct linear_c *) ti->private; | |
119 | ||
120 | switch (type) { | |
121 | case STATUSTYPE_INFO: | |
122 | result[0] = '\0'; | |
123 | break; | |
124 | ||
125 | case STATUSTYPE_TABLE: | |
4ee218cd AM |
126 | snprintf(result, maxlen, "%s %llu", lc->dev->name, |
127 | (unsigned long long)lc->start); | |
1da177e4 LT |
128 | break; |
129 | } | |
1da177e4 LT |
130 | } |
131 | ||
e56f81e0 CH |
132 | static int linear_prepare_ioctl(struct dm_target *ti, |
133 | struct block_device **bdev, fmode_t *mode) | |
ab17ffa4 MB |
134 | { |
135 | struct linear_c *lc = (struct linear_c *) ti->private; | |
ec8013be | 136 | struct dm_dev *dev = lc->dev; |
e56f81e0 CH |
137 | |
138 | *bdev = dev->bdev; | |
ec8013be PB |
139 | |
140 | /* | |
141 | * Only pass ioctls through if the device sizes match exactly. | |
142 | */ | |
143 | if (lc->start || | |
144 | ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT) | |
e56f81e0 CH |
145 | return 1; |
146 | return 0; | |
ab17ffa4 MB |
147 | } |
148 | ||
af4874e0 MS |
149 | static int linear_iterate_devices(struct dm_target *ti, |
150 | iterate_devices_callout_fn fn, void *data) | |
151 | { | |
152 | struct linear_c *lc = ti->private; | |
153 | ||
5dea271b | 154 | return fn(ti, lc->dev, lc->start, ti->len, data); |
af4874e0 MS |
155 | } |
156 | ||
817bf402 DW |
157 | static long linear_dax_direct_access(struct dm_target *ti, pgoff_t pgoff, |
158 | long nr_pages, void **kaddr, pfn_t *pfn) | |
84b22f83 | 159 | { |
817bf402 | 160 | long ret; |
84b22f83 TK |
161 | struct linear_c *lc = ti->private; |
162 | struct block_device *bdev = lc->dev->bdev; | |
817bf402 DW |
163 | struct dax_device *dax_dev = lc->dev->dax_dev; |
164 | sector_t dev_sector, sector = pgoff * PAGE_SECTORS; | |
165 | ||
166 | dev_sector = linear_map_sector(ti, sector); | |
167 | ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff); | |
168 | if (ret) | |
169 | return ret; | |
170 | return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn); | |
84b22f83 TK |
171 | } |
172 | ||
7e026c8c DW |
173 | static size_t linear_dax_copy_from_iter(struct dm_target *ti, pgoff_t pgoff, |
174 | void *addr, size_t bytes, struct iov_iter *i) | |
175 | { | |
176 | struct linear_c *lc = ti->private; | |
177 | struct block_device *bdev = lc->dev->bdev; | |
178 | struct dax_device *dax_dev = lc->dev->dax_dev; | |
179 | sector_t dev_sector, sector = pgoff * PAGE_SECTORS; | |
180 | ||
181 | dev_sector = linear_map_sector(ti, sector); | |
182 | if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff)) | |
183 | return 0; | |
184 | return dax_copy_from_iter(dax_dev, pgoff, addr, bytes, i); | |
185 | } | |
186 | ||
1da177e4 LT |
187 | static struct target_type linear_target = { |
188 | .name = "linear", | |
0be12c1c DLM |
189 | .version = {1, 4, 0}, |
190 | .features = DM_TARGET_PASSES_INTEGRITY | DM_TARGET_ZONED_HM, | |
1da177e4 LT |
191 | .module = THIS_MODULE, |
192 | .ctr = linear_ctr, | |
193 | .dtr = linear_dtr, | |
194 | .map = linear_map, | |
0be12c1c | 195 | .end_io = linear_end_io, |
1da177e4 | 196 | .status = linear_status, |
e56f81e0 | 197 | .prepare_ioctl = linear_prepare_ioctl, |
af4874e0 | 198 | .iterate_devices = linear_iterate_devices, |
817bf402 | 199 | .direct_access = linear_dax_direct_access, |
7e026c8c | 200 | .dax_copy_from_iter = linear_dax_copy_from_iter, |
1da177e4 LT |
201 | }; |
202 | ||
203 | int __init dm_linear_init(void) | |
204 | { | |
205 | int r = dm_register_target(&linear_target); | |
206 | ||
207 | if (r < 0) | |
72d94861 | 208 | DMERR("register failed %d", r); |
1da177e4 LT |
209 | |
210 | return r; | |
211 | } | |
212 | ||
213 | void dm_linear_exit(void) | |
214 | { | |
10d3bd09 | 215 | dm_unregister_target(&linear_target); |
1da177e4 | 216 | } |