1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2001 Sistina Software (UK) Limited |
4 | * |
5 | * This file is released under the GPL. |
6 | */ |
7 | |
8 | #include "dm-core.h" |
9 | |
10 | #include <linux/module.h> |
11 | #include <linux/init.h> |
12 | #include <linux/kmod.h> |
13 | #include <linux/bio.h> |
14 | #include <linux/dax.h> |
15 | |
16 | #define DM_MSG_PREFIX "target" |
17 | |
18 | static LIST_HEAD(_targets); |
19 | static DECLARE_RWSEM(_lock); |
20 | |
21 | static inline struct target_type *__find_target_type(const char *name) |
22 | { |
23 | struct target_type *tt; |
24 | |
25 | list_for_each_entry(tt, &_targets, list) |
26 | if (!strcmp(name, tt->name)) |
27 | return tt; |
28 | |
29 | return NULL; |
30 | } |
31 | |
32 | static struct target_type *get_target_type(const char *name) |
33 | { |
34 | struct target_type *tt; |
35 | |
36 | down_read(sem: &_lock); |
37 | |
38 | tt = __find_target_type(name); |
39 | if (tt && !try_module_get(module: tt->module)) |
40 | tt = NULL; |
41 | |
42 | up_read(sem: &_lock); |
43 | return tt; |
44 | } |
45 | |
46 | static void load_module(const char *name) |
47 | { |
48 | request_module("dm-%s" , name); |
49 | } |
50 | |
51 | struct target_type *dm_get_target_type(const char *name) |
52 | { |
53 | struct target_type *tt = get_target_type(name); |
54 | |
55 | if (!tt) { |
56 | load_module(name); |
57 | tt = get_target_type(name); |
58 | } |
59 | |
60 | return tt; |
61 | } |
62 | |
63 | void dm_put_target_type(struct target_type *tt) |
64 | { |
65 | down_read(sem: &_lock); |
66 | module_put(module: tt->module); |
67 | up_read(sem: &_lock); |
68 | } |
69 | |
70 | int dm_target_iterate(void (*iter_func)(struct target_type *tt, |
71 | void *param), void *param) |
72 | { |
73 | struct target_type *tt; |
74 | |
75 | down_read(sem: &_lock); |
76 | list_for_each_entry(tt, &_targets, list) |
77 | iter_func(tt, param); |
78 | up_read(sem: &_lock); |
79 | |
80 | return 0; |
81 | } |
82 | |
83 | int dm_register_target(struct target_type *tt) |
84 | { |
85 | int rv = 0; |
86 | |
87 | down_write(sem: &_lock); |
88 | if (__find_target_type(name: tt->name)) { |
89 | DMERR("%s: '%s' target already registered" , |
90 | __func__, tt->name); |
91 | rv = -EEXIST; |
92 | } else { |
93 | list_add(new: &tt->list, head: &_targets); |
94 | } |
95 | up_write(sem: &_lock); |
96 | |
97 | return rv; |
98 | } |
99 | EXPORT_SYMBOL(dm_register_target); |
100 | |
101 | void dm_unregister_target(struct target_type *tt) |
102 | { |
103 | down_write(sem: &_lock); |
104 | if (!__find_target_type(name: tt->name)) { |
105 | DMCRIT("Unregistering unrecognised target: %s" , tt->name); |
106 | BUG(); |
107 | } |
108 | |
109 | list_del(entry: &tt->list); |
110 | |
111 | up_write(sem: &_lock); |
112 | } |
113 | EXPORT_SYMBOL(dm_unregister_target); |
114 | |
115 | /* |
116 | * io-err: always fails an io, useful for bringing |
117 | * up LVs that have holes in them. |
118 | */ |
119 | struct io_err_c { |
120 | struct dm_dev *dev; |
121 | sector_t start; |
122 | }; |
123 | |
124 | static int io_err_get_args(struct dm_target *tt, unsigned int argc, char **args) |
125 | { |
126 | unsigned long long start; |
127 | struct io_err_c *ioec; |
128 | char dummy; |
129 | int ret; |
130 | |
131 | ioec = kmalloc(size: sizeof(*ioec), GFP_KERNEL); |
132 | if (!ioec) { |
133 | tt->error = "Cannot allocate io_err context" ; |
134 | return -ENOMEM; |
135 | } |
136 | |
137 | ret = -EINVAL; |
138 | if (sscanf(args[1], "%llu%c" , &start, &dummy) != 1 || |
139 | start != (sector_t)start) { |
140 | tt->error = "Invalid device sector" ; |
141 | goto bad; |
142 | } |
143 | ioec->start = start; |
144 | |
145 | ret = dm_get_device(ti: tt, path: args[0], mode: dm_table_get_mode(t: tt->table), result: &ioec->dev); |
146 | if (ret) { |
147 | tt->error = "Device lookup failed" ; |
148 | goto bad; |
149 | } |
150 | |
151 | tt->private = ioec; |
152 | |
153 | return 0; |
154 | |
155 | bad: |
156 | kfree(objp: ioec); |
157 | |
158 | return ret; |
159 | } |
160 | |
161 | static int io_err_ctr(struct dm_target *tt, unsigned int argc, char **args) |
162 | { |
163 | /* |
164 | * If we have arguments, assume it is the path to the backing |
165 | * block device and its mapping start sector (same as dm-linear). |
166 | * In this case, get the device so that we can get its limits. |
167 | */ |
168 | if (argc == 2) { |
169 | int ret = io_err_get_args(tt, argc, args); |
170 | |
171 | if (ret) |
172 | return ret; |
173 | } |
174 | |
175 | /* |
176 | * Return error for discards instead of -EOPNOTSUPP |
177 | */ |
178 | tt->num_discard_bios = 1; |
179 | tt->discards_supported = true; |
180 | |
181 | return 0; |
182 | } |
183 | |
184 | static void io_err_dtr(struct dm_target *tt) |
185 | { |
186 | struct io_err_c *ioec = tt->private; |
187 | |
188 | if (ioec) { |
189 | dm_put_device(ti: tt, d: ioec->dev); |
190 | kfree(objp: ioec); |
191 | } |
192 | } |
193 | |
194 | static int io_err_map(struct dm_target *tt, struct bio *bio) |
195 | { |
196 | return DM_MAPIO_KILL; |
197 | } |
198 | |
199 | static int io_err_clone_and_map_rq(struct dm_target *ti, struct request *rq, |
200 | union map_info *map_context, |
201 | struct request **clone) |
202 | { |
203 | return DM_MAPIO_KILL; |
204 | } |
205 | |
206 | static void io_err_release_clone_rq(struct request *clone, |
207 | union map_info *map_context) |
208 | { |
209 | } |
210 | |
211 | #ifdef CONFIG_BLK_DEV_ZONED |
212 | static sector_t io_err_map_sector(struct dm_target *ti, sector_t bi_sector) |
213 | { |
214 | struct io_err_c *ioec = ti->private; |
215 | |
216 | return ioec->start + dm_target_offset(ti, bi_sector); |
217 | } |
218 | |
219 | static int io_err_report_zones(struct dm_target *ti, |
220 | struct dm_report_zones_args *args, unsigned int nr_zones) |
221 | { |
222 | struct io_err_c *ioec = ti->private; |
223 | |
224 | /* |
225 | * This should never be called when we do not have a backing device |
226 | * as that mean the target is not a zoned one. |
227 | */ |
228 | if (WARN_ON_ONCE(!ioec)) |
229 | return -EIO; |
230 | |
231 | return dm_report_zones(bdev: ioec->dev->bdev, start: ioec->start, |
232 | sector: io_err_map_sector(ti, bi_sector: args->next_sector), |
233 | args, nr_zones); |
234 | } |
235 | #else |
236 | #define io_err_report_zones NULL |
237 | #endif |
238 | |
239 | static int io_err_iterate_devices(struct dm_target *ti, |
240 | iterate_devices_callout_fn fn, void *data) |
241 | { |
242 | struct io_err_c *ioec = ti->private; |
243 | |
244 | if (!ioec) |
245 | return 0; |
246 | |
247 | return fn(ti, ioec->dev, ioec->start, ti->len, data); |
248 | } |
249 | |
250 | static void io_err_io_hints(struct dm_target *ti, struct queue_limits *limits) |
251 | { |
252 | limits->max_discard_sectors = UINT_MAX; |
253 | limits->max_hw_discard_sectors = UINT_MAX; |
254 | limits->discard_granularity = 512; |
255 | } |
256 | |
257 | static long io_err_dax_direct_access(struct dm_target *ti, pgoff_t pgoff, |
258 | long nr_pages, enum dax_access_mode mode, void **kaddr, |
259 | pfn_t *pfn) |
260 | { |
261 | return -EIO; |
262 | } |
263 | |
264 | static struct target_type error_target = { |
265 | .name = "error" , |
266 | .version = {1, 7, 0}, |
267 | .features = DM_TARGET_WILDCARD | DM_TARGET_ZONED_HM, |
268 | .ctr = io_err_ctr, |
269 | .dtr = io_err_dtr, |
270 | .map = io_err_map, |
271 | .clone_and_map_rq = io_err_clone_and_map_rq, |
272 | .release_clone_rq = io_err_release_clone_rq, |
273 | .iterate_devices = io_err_iterate_devices, |
274 | .io_hints = io_err_io_hints, |
275 | .direct_access = io_err_dax_direct_access, |
276 | .report_zones = io_err_report_zones, |
277 | }; |
278 | |
279 | int __init dm_target_init(void) |
280 | { |
281 | return dm_register_target(&error_target); |
282 | } |
283 | |
284 | void dm_target_exit(void) |
285 | { |
286 | dm_unregister_target(&error_target); |
287 | } |
288 | |