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
 11struct 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
 27static 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 */
 38static 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;
104err:
105	cleanup_unstripe(uc, ti);
106	return -EINVAL;
107}
108
109static void unstripe_dtr(struct dm_target *ti)
110{
111	struct unstripe_c *uc = ti->private;
112
113	cleanup_unstripe(uc, ti);
114}
115
116static 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
134static 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
144static 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	case STATUSTYPE_IMA:
161		*result = '\0';
162		break;
163	}
164}
165
166static int unstripe_iterate_devices(struct dm_target *ti,
167				    iterate_devices_callout_fn fn, void *data)
168{
169	struct unstripe_c *uc = ti->private;
170
171	return fn(ti, uc->dev, uc->physical_start, ti->len, data);
172}
173
174static void unstripe_io_hints(struct dm_target *ti,
175			       struct queue_limits *limits)
176{
177	struct unstripe_c *uc = ti->private;
178
179	limits->chunk_sectors = uc->chunk_size;
180}
181
182static struct target_type unstripe_target = {
183	.name = "unstriped",
184	.version = {1, 1, 0},
185	.features = DM_TARGET_NOWAIT,
186	.module = THIS_MODULE,
187	.ctr = unstripe_ctr,
188	.dtr = unstripe_dtr,
189	.map = unstripe_map,
190	.status = unstripe_status,
191	.iterate_devices = unstripe_iterate_devices,
192	.io_hints = unstripe_io_hints,
193};
194
195static int __init dm_unstripe_init(void)
196{
197	return dm_register_target(&unstripe_target);
198}
199
200static void __exit dm_unstripe_exit(void)
201{
202	dm_unregister_target(&unstripe_target);
203}
204
205module_init(dm_unstripe_init);
206module_exit(dm_unstripe_exit);
207
208MODULE_DESCRIPTION(DM_NAME " unstriped target");
209MODULE_ALIAS("dm-unstriped");
210MODULE_AUTHOR("Scott Bauer <scott.bauer@intel.com>");
211MODULE_LICENSE("GPL");