xref: /openbmc/linux/drivers/md/dm-linear.c (revision fc062ad8)
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"
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/blkdev.h>
11 #include <linux/bio.h>
12 #include <linux/dax.h>
13 #include <linux/slab.h>
14 #include <linux/device-mapper.h>
15 
16 #define DM_MSG_PREFIX "linear"
17 
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;
32 	unsigned long long tmp;
33 	char dummy;
34 	int ret;
35 
36 	if (argc != 2) {
37 		ti->error = "Invalid argument count";
38 		return -EINVAL;
39 	}
40 
41 	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
42 	if (lc == NULL) {
43 		ti->error = "Cannot allocate linear context";
44 		return -ENOMEM;
45 	}
46 
47 	ret = -EINVAL;
48 	if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1 || tmp != (sector_t)tmp) {
49 		ti->error = "Invalid device sector";
50 		goto bad;
51 	}
52 	lc->start = tmp;
53 
54 	ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &lc->dev);
55 	if (ret) {
56 		ti->error = "Device lookup failed";
57 		goto bad;
58 	}
59 
60 	ti->num_flush_bios = 1;
61 	ti->num_discard_bios = 1;
62 	ti->num_secure_erase_bios = 1;
63 	ti->num_write_same_bios = 1;
64 	ti->num_write_zeroes_bios = 1;
65 	ti->private = lc;
66 	return 0;
67 
68       bad:
69 	kfree(lc);
70 	return ret;
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 
81 static sector_t linear_map_sector(struct dm_target *ti, sector_t bi_sector)
82 {
83 	struct linear_c *lc = ti->private;
84 
85 	return lc->start + dm_target_offset(ti, bi_sector);
86 }
87 
88 static void linear_map_bio(struct dm_target *ti, struct bio *bio)
89 {
90 	struct linear_c *lc = ti->private;
91 
92 	bio_set_dev(bio, lc->dev->bdev);
93 	if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio)))
94 		bio->bi_iter.bi_sector =
95 			linear_map_sector(ti, bio->bi_iter.bi_sector);
96 }
97 
98 static int linear_map(struct dm_target *ti, struct bio *bio)
99 {
100 	linear_map_bio(ti, bio);
101 
102 	return DM_MAPIO_REMAPPED;
103 }
104 
105 static void linear_status(struct dm_target *ti, status_type_t type,
106 			  unsigned status_flags, char *result, unsigned maxlen)
107 {
108 	struct linear_c *lc = (struct linear_c *) ti->private;
109 
110 	switch (type) {
111 	case STATUSTYPE_INFO:
112 		result[0] = '\0';
113 		break;
114 
115 	case STATUSTYPE_TABLE:
116 		snprintf(result, maxlen, "%s %llu", lc->dev->name,
117 				(unsigned long long)lc->start);
118 		break;
119 	}
120 }
121 
122 static int linear_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
123 {
124 	struct linear_c *lc = (struct linear_c *) ti->private;
125 	struct dm_dev *dev = lc->dev;
126 
127 	*bdev = dev->bdev;
128 
129 	/*
130 	 * Only pass ioctls through if the device sizes match exactly.
131 	 */
132 	if (lc->start ||
133 	    ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT)
134 		return 1;
135 	return 0;
136 }
137 
138 #ifdef CONFIG_BLK_DEV_ZONED
139 static int linear_report_zones(struct dm_target *ti,
140 		struct dm_report_zones_args *args, unsigned int nr_zones)
141 {
142 	struct linear_c *lc = ti->private;
143 
144 	return dm_report_zones(lc->dev->bdev, lc->start,
145 			       linear_map_sector(ti, args->next_sector),
146 			       args, nr_zones);
147 }
148 #else
149 #define linear_report_zones NULL
150 #endif
151 
152 static int linear_iterate_devices(struct dm_target *ti,
153 				  iterate_devices_callout_fn fn, void *data)
154 {
155 	struct linear_c *lc = ti->private;
156 
157 	return fn(ti, lc->dev, lc->start, ti->len, data);
158 }
159 
160 #if IS_ENABLED(CONFIG_DAX_DRIVER)
161 static long linear_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
162 		long nr_pages, void **kaddr, pfn_t *pfn)
163 {
164 	long ret;
165 	struct linear_c *lc = ti->private;
166 	struct block_device *bdev = lc->dev->bdev;
167 	struct dax_device *dax_dev = lc->dev->dax_dev;
168 	sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
169 
170 	dev_sector = linear_map_sector(ti, sector);
171 	ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff);
172 	if (ret)
173 		return ret;
174 	return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn);
175 }
176 
177 static size_t linear_dax_copy_from_iter(struct dm_target *ti, pgoff_t pgoff,
178 		void *addr, size_t bytes, struct iov_iter *i)
179 {
180 	struct linear_c *lc = ti->private;
181 	struct block_device *bdev = lc->dev->bdev;
182 	struct dax_device *dax_dev = lc->dev->dax_dev;
183 	sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
184 
185 	dev_sector = linear_map_sector(ti, sector);
186 	if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff))
187 		return 0;
188 	return dax_copy_from_iter(dax_dev, pgoff, addr, bytes, i);
189 }
190 
191 static size_t linear_dax_copy_to_iter(struct dm_target *ti, pgoff_t pgoff,
192 		void *addr, size_t bytes, struct iov_iter *i)
193 {
194 	struct linear_c *lc = ti->private;
195 	struct block_device *bdev = lc->dev->bdev;
196 	struct dax_device *dax_dev = lc->dev->dax_dev;
197 	sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
198 
199 	dev_sector = linear_map_sector(ti, sector);
200 	if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff))
201 		return 0;
202 	return dax_copy_to_iter(dax_dev, pgoff, addr, bytes, i);
203 }
204 
205 static int linear_dax_zero_page_range(struct dm_target *ti, pgoff_t pgoff,
206 				      size_t nr_pages)
207 {
208 	int ret;
209 	struct linear_c *lc = ti->private;
210 	struct block_device *bdev = lc->dev->bdev;
211 	struct dax_device *dax_dev = lc->dev->dax_dev;
212 	sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
213 
214 	dev_sector = linear_map_sector(ti, sector);
215 	ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages << PAGE_SHIFT, &pgoff);
216 	if (ret)
217 		return ret;
218 	return dax_zero_page_range(dax_dev, pgoff, nr_pages);
219 }
220 
221 #else
222 #define linear_dax_direct_access NULL
223 #define linear_dax_copy_from_iter NULL
224 #define linear_dax_copy_to_iter NULL
225 #define linear_dax_zero_page_range NULL
226 #endif
227 
228 static struct target_type linear_target = {
229 	.name   = "linear",
230 	.version = {1, 4, 0},
231 	.features = DM_TARGET_PASSES_INTEGRITY | DM_TARGET_NOWAIT |
232 		    DM_TARGET_ZONED_HM | DM_TARGET_PASSES_CRYPTO,
233 	.report_zones = linear_report_zones,
234 	.module = THIS_MODULE,
235 	.ctr    = linear_ctr,
236 	.dtr    = linear_dtr,
237 	.map    = linear_map,
238 	.status = linear_status,
239 	.prepare_ioctl = linear_prepare_ioctl,
240 	.iterate_devices = linear_iterate_devices,
241 	.direct_access = linear_dax_direct_access,
242 	.dax_copy_from_iter = linear_dax_copy_from_iter,
243 	.dax_copy_to_iter = linear_dax_copy_to_iter,
244 	.dax_zero_page_range = linear_dax_zero_page_range,
245 };
246 
247 int __init dm_linear_init(void)
248 {
249 	int r = dm_register_target(&linear_target);
250 
251 	if (r < 0)
252 		DMERR("register failed %d", r);
253 
254 	return r;
255 }
256 
257 void dm_linear_exit(void)
258 {
259 	dm_unregister_target(&linear_target);
260 }
261