Linux 6.10-rc5
[linux.git] / drivers / md / dm-target.c
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(&_lock);
37
38         tt = __find_target_type(name);
39         if (tt && !try_module_get(tt->module))
40                 tt = NULL;
41
42         up_read(&_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(&_lock);
66         module_put(tt->module);
67         up_read(&_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(&_lock);
76         list_for_each_entry(tt, &_targets, list)
77                 iter_func(tt, param);
78         up_read(&_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(&_lock);
88         if (__find_target_type(tt->name)) {
89                 DMERR("%s: '%s' target already registered",
90                       __func__, tt->name);
91                 rv = -EEXIST;
92         } else {
93                 list_add(&tt->list, &_targets);
94         }
95         up_write(&_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(&_lock);
104         if (!__find_target_type(tt->name)) {
105                 DMCRIT("Unregistering unrecognised target: %s", tt->name);
106                 BUG();
107         }
108
109         list_del(&tt->list);
110
111         up_write(&_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(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(tt, args[0], dm_table_get_mode(tt->table), &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(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(tt, ioec->dev);
190                 kfree(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(ioec->dev->bdev, ioec->start,
232                                io_err_map_sector(ti, 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_hw_discard_sectors = UINT_MAX;
253         limits->discard_granularity = 512;
254 }
255
256 static long io_err_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
257                 long nr_pages, enum dax_access_mode mode, void **kaddr,
258                 pfn_t *pfn)
259 {
260         return -EIO;
261 }
262
263 static struct target_type error_target = {
264         .name = "error",
265         .version = {1, 7, 0},
266         .features = DM_TARGET_WILDCARD | DM_TARGET_ZONED_HM,
267         .ctr  = io_err_ctr,
268         .dtr  = io_err_dtr,
269         .map  = io_err_map,
270         .clone_and_map_rq = io_err_clone_and_map_rq,
271         .release_clone_rq = io_err_release_clone_rq,
272         .iterate_devices = io_err_iterate_devices,
273         .io_hints = io_err_io_hints,
274         .direct_access = io_err_dax_direct_access,
275         .report_zones = io_err_report_zones,
276 };
277
278 int __init dm_target_init(void)
279 {
280         return dm_register_target(&error_target);
281 }
282
283 void dm_target_exit(void)
284 {
285         dm_unregister_target(&error_target);
286 }