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 }