1 /* 2 * Copyright (C) 2017 Intel Corporation. 3 * 4 * This file is released under the GPL. 5 */ 6 7 #include "dm.h" 8 9 #include <linux/module.h> 10 11 struct unstripe_c { 12 struct dm_dev *dev; 13 sector_t physical_start; 14 15 uint32_t stripes; 16 17 uint32_t unstripe; 18 sector_t unstripe_width; 19 sector_t unstripe_offset; 20 21 uint32_t chunk_size; 22 u8 chunk_shift; 23 }; 24 25 #define DM_MSG_PREFIX "unstriped" 26 27 static void cleanup_unstripe(struct unstripe_c *uc, struct dm_target *ti) 28 { 29 if (uc->dev) 30 dm_put_device(ti, uc->dev); 31 kfree(uc); 32 } 33 34 /* 35 * Contruct an unstriped mapping. 36 * <number of stripes> <chunk size> <stripe #> <dev_path> <offset> 37 */ 38 static int unstripe_ctr(struct dm_target *ti, unsigned int argc, char **argv) 39 { 40 struct unstripe_c *uc; 41 sector_t tmp_len; 42 unsigned long long start; 43 char dummy; 44 45 if (argc != 5) { 46 ti->error = "Invalid number of arguments"; 47 return -EINVAL; 48 } 49 50 uc = kzalloc(sizeof(*uc), GFP_KERNEL); 51 if (!uc) { 52 ti->error = "Memory allocation for unstriped context failed"; 53 return -ENOMEM; 54 } 55 56 if (kstrtouint(argv[0], 10, &uc->stripes) || !uc->stripes) { 57 ti->error = "Invalid stripe count"; 58 goto err; 59 } 60 61 if (kstrtouint(argv[1], 10, &uc->chunk_size) || !uc->chunk_size) { 62 ti->error = "Invalid chunk_size"; 63 goto err; 64 } 65 66 if (kstrtouint(argv[2], 10, &uc->unstripe)) { 67 ti->error = "Invalid stripe number"; 68 goto err; 69 } 70 71 if (uc->unstripe > uc->stripes && uc->stripes > 1) { 72 ti->error = "Please provide stripe between [0, # of stripes]"; 73 goto err; 74 } 75 76 if (dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &uc->dev)) { 77 ti->error = "Couldn't get striped device"; 78 goto err; 79 } 80 81 if (sscanf(argv[4], "%llu%c", &start, &dummy) != 1 || start != (sector_t)start) { 82 ti->error = "Invalid striped device offset"; 83 goto err; 84 } 85 uc->physical_start = start; 86 87 uc->unstripe_offset = uc->unstripe * uc->chunk_size; 88 uc->unstripe_width = (uc->stripes - 1) * uc->chunk_size; 89 uc->chunk_shift = is_power_of_2(uc->chunk_size) ? fls(uc->chunk_size) - 1 : 0; 90 91 tmp_len = ti->len; 92 if (sector_div(tmp_len, uc->chunk_size)) { 93 ti->error = "Target length not divisible by chunk size"; 94 goto err; 95 } 96 97 if (dm_set_target_max_io_len(ti, uc->chunk_size)) { 98 ti->error = "Failed to set max io len"; 99 goto err; 100 } 101 102 ti->private = uc; 103 return 0; 104 err: 105 cleanup_unstripe(uc, ti); 106 return -EINVAL; 107 } 108 109 static void unstripe_dtr(struct dm_target *ti) 110 { 111 struct unstripe_c *uc = ti->private; 112 113 cleanup_unstripe(uc, ti); 114 } 115 116 static sector_t map_to_core(struct dm_target *ti, struct bio *bio) 117 { 118 struct unstripe_c *uc = ti->private; 119 sector_t sector = bio->bi_iter.bi_sector; 120 sector_t tmp_sector = sector; 121 122 /* Shift us up to the right "row" on the stripe */ 123 if (uc->chunk_shift) 124 tmp_sector >>= uc->chunk_shift; 125 else 126 sector_div(tmp_sector, uc->chunk_size); 127 128 sector += uc->unstripe_width * tmp_sector; 129 130 /* Account for what stripe we're operating on */ 131 return sector + uc->unstripe_offset; 132 } 133 134 static int unstripe_map(struct dm_target *ti, struct bio *bio) 135 { 136 struct unstripe_c *uc = ti->private; 137 138 bio_set_dev(bio, uc->dev->bdev); 139 bio->bi_iter.bi_sector = map_to_core(ti, bio) + uc->physical_start; 140 141 return DM_MAPIO_REMAPPED; 142 } 143 144 static void unstripe_status(struct dm_target *ti, status_type_t type, 145 unsigned int status_flags, char *result, unsigned int maxlen) 146 { 147 struct unstripe_c *uc = ti->private; 148 unsigned int sz = 0; 149 150 switch (type) { 151 case STATUSTYPE_INFO: 152 break; 153 154 case STATUSTYPE_TABLE: 155 DMEMIT("%d %llu %d %s %llu", 156 uc->stripes, (unsigned long long)uc->chunk_size, uc->unstripe, 157 uc->dev->name, (unsigned long long)uc->physical_start); 158 break; 159 } 160 } 161 162 static int unstripe_iterate_devices(struct dm_target *ti, 163 iterate_devices_callout_fn fn, void *data) 164 { 165 struct unstripe_c *uc = ti->private; 166 167 return fn(ti, uc->dev, uc->physical_start, ti->len, data); 168 } 169 170 static void unstripe_io_hints(struct dm_target *ti, 171 struct queue_limits *limits) 172 { 173 struct unstripe_c *uc = ti->private; 174 175 limits->chunk_sectors = uc->chunk_size; 176 } 177 178 static struct target_type unstripe_target = { 179 .name = "unstriped", 180 .version = {1, 1, 0}, 181 .module = THIS_MODULE, 182 .ctr = unstripe_ctr, 183 .dtr = unstripe_dtr, 184 .map = unstripe_map, 185 .status = unstripe_status, 186 .iterate_devices = unstripe_iterate_devices, 187 .io_hints = unstripe_io_hints, 188 }; 189 190 static int __init dm_unstripe_init(void) 191 { 192 return dm_register_target(&unstripe_target); 193 } 194 195 static void __exit dm_unstripe_exit(void) 196 { 197 dm_unregister_target(&unstripe_target); 198 } 199 200 module_init(dm_unstripe_init); 201 module_exit(dm_unstripe_exit); 202 203 MODULE_DESCRIPTION(DM_NAME " unstriped target"); 204 MODULE_ALIAS("dm-unstriped"); 205 MODULE_AUTHOR("Scott Bauer <scott.bauer@intel.com>"); 206 MODULE_LICENSE("GPL"); 207