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; | |
00716545 | 62 | ti->num_secure_erase_bios = 1; |
55a62eef | 63 | ti->num_write_same_bios = 1; |
ac62d620 | 64 | ti->num_write_zeroes_bios = 1; |
1da177e4 LT |
65 | ti->private = lc; |
66 | return 0; | |
67 | ||
68 | bad: | |
69 | kfree(lc); | |
e80d1c80 | 70 | return ret; |
1da177e4 LT |
71 | } |
72 | ||
73 | static void linear_dtr(struct dm_target *ti) | |
74 | { | |
75 | struct linear_c *lc = (struct linear_c *) ti->private; | |
76 | ||
77 | dm_put_device(ti, lc->dev); | |
78 | kfree(lc); | |
79 | } | |
80 | ||
7bc3447b | 81 | static sector_t linear_map_sector(struct dm_target *ti, sector_t bi_sector) |
1da177e4 | 82 | { |
7bc3447b MB |
83 | struct linear_c *lc = ti->private; |
84 | ||
b441a262 | 85 | return lc->start + dm_target_offset(ti, bi_sector); |
7bc3447b MB |
86 | } |
87 | ||
88 | static void linear_map_bio(struct dm_target *ti, struct bio *bio) | |
89 | { | |
90 | struct linear_c *lc = ti->private; | |
1da177e4 | 91 | |
74d46992 | 92 | bio_set_dev(bio, lc->dev->bdev); |
0be12c1c | 93 | if (bio_sectors(bio) || bio_op(bio) == REQ_OP_ZONE_RESET) |
4f024f37 KO |
94 | bio->bi_iter.bi_sector = |
95 | linear_map_sector(ti, bio->bi_iter.bi_sector); | |
7bc3447b MB |
96 | } |
97 | ||
7de3ee57 | 98 | static int linear_map(struct dm_target *ti, struct bio *bio) |
7bc3447b MB |
99 | { |
100 | linear_map_bio(ti, bio); | |
1da177e4 | 101 | |
d2a7ad29 | 102 | return DM_MAPIO_REMAPPED; |
1da177e4 LT |
103 | } |
104 | ||
0be12c1c DLM |
105 | static int linear_end_io(struct dm_target *ti, struct bio *bio, |
106 | blk_status_t *error) | |
107 | { | |
108 | struct linear_c *lc = ti->private; | |
109 | ||
110 | if (!*error && bio_op(bio) == REQ_OP_ZONE_REPORT) | |
111 | dm_remap_zone_report(ti, bio, lc->start); | |
112 | ||
113 | return DM_ENDIO_DONE; | |
114 | } | |
115 | ||
fd7c092e MP |
116 | static void linear_status(struct dm_target *ti, status_type_t type, |
117 | unsigned status_flags, char *result, unsigned maxlen) | |
1da177e4 LT |
118 | { |
119 | struct linear_c *lc = (struct linear_c *) ti->private; | |
120 | ||
121 | switch (type) { | |
122 | case STATUSTYPE_INFO: | |
123 | result[0] = '\0'; | |
124 | break; | |
125 | ||
126 | case STATUSTYPE_TABLE: | |
4ee218cd AM |
127 | snprintf(result, maxlen, "%s %llu", lc->dev->name, |
128 | (unsigned long long)lc->start); | |
1da177e4 LT |
129 | break; |
130 | } | |
1da177e4 LT |
131 | } |
132 | ||
5bd5e8d8 | 133 | static int linear_prepare_ioctl(struct dm_target *ti, struct block_device **bdev) |
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 | ||
976431b0 | 157 | #if IS_ENABLED(CONFIG_DAX_DRIVER) |
817bf402 DW |
158 | static long linear_dax_direct_access(struct dm_target *ti, pgoff_t pgoff, |
159 | long nr_pages, void **kaddr, pfn_t *pfn) | |
84b22f83 | 160 | { |
817bf402 | 161 | long ret; |
84b22f83 TK |
162 | struct linear_c *lc = ti->private; |
163 | struct block_device *bdev = lc->dev->bdev; | |
817bf402 DW |
164 | struct dax_device *dax_dev = lc->dev->dax_dev; |
165 | sector_t dev_sector, sector = pgoff * PAGE_SECTORS; | |
166 | ||
167 | dev_sector = linear_map_sector(ti, sector); | |
168 | ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff); | |
169 | if (ret) | |
170 | return ret; | |
171 | return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn); | |
84b22f83 TK |
172 | } |
173 | ||
7e026c8c DW |
174 | static size_t linear_dax_copy_from_iter(struct dm_target *ti, pgoff_t pgoff, |
175 | void *addr, size_t bytes, struct iov_iter *i) | |
176 | { | |
177 | struct linear_c *lc = ti->private; | |
178 | struct block_device *bdev = lc->dev->bdev; | |
179 | struct dax_device *dax_dev = lc->dev->dax_dev; | |
180 | sector_t dev_sector, sector = pgoff * PAGE_SECTORS; | |
181 | ||
182 | dev_sector = linear_map_sector(ti, sector); | |
183 | if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff)) | |
184 | return 0; | |
185 | return dax_copy_from_iter(dax_dev, pgoff, addr, bytes, i); | |
186 | } | |
187 | ||
976431b0 DW |
188 | #else |
189 | #define linear_dax_direct_access NULL | |
190 | #define linear_dax_copy_from_iter NULL | |
191 | #endif | |
192 | ||
1da177e4 LT |
193 | static struct target_type linear_target = { |
194 | .name = "linear", | |
0be12c1c DLM |
195 | .version = {1, 4, 0}, |
196 | .features = DM_TARGET_PASSES_INTEGRITY | DM_TARGET_ZONED_HM, | |
1da177e4 LT |
197 | .module = THIS_MODULE, |
198 | .ctr = linear_ctr, | |
199 | .dtr = linear_dtr, | |
200 | .map = linear_map, | |
0be12c1c | 201 | .end_io = linear_end_io, |
1da177e4 | 202 | .status = linear_status, |
e56f81e0 | 203 | .prepare_ioctl = linear_prepare_ioctl, |
af4874e0 | 204 | .iterate_devices = linear_iterate_devices, |
817bf402 | 205 | .direct_access = linear_dax_direct_access, |
7e026c8c | 206 | .dax_copy_from_iter = linear_dax_copy_from_iter, |
1da177e4 LT |
207 | }; |
208 | ||
209 | int __init dm_linear_init(void) | |
210 | { | |
211 | int r = dm_register_target(&linear_target); | |
212 | ||
213 | if (r < 0) | |
72d94861 | 214 | DMERR("register failed %d", r); |
1da177e4 LT |
215 | |
216 | return r; | |
217 | } | |
218 | ||
219 | void dm_linear_exit(void) | |
220 | { | |
10d3bd09 | 221 | dm_unregister_target(&linear_target); |
1da177e4 | 222 | } |