1 /*
2 * Copyright (C) 2001-2003 Sistina Software (UK) Limited.
3 *
4 * This file is released under the GPL.
5 */
6
7 #include "dm.h"
8
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/blkdev.h>
12 #include <linux/bio.h>
13 #include <linux/slab.h>
14
15 struct stripe {
16 struct dm_dev *dev;
17 sector_t physical_start;
18 };
19
20 struct stripe_c {
21 uint32_t stripes;
22
23 /* The size of this target / num. stripes */
24 sector_t stripe_width;
25
26 /* stripe chunk size */
27 uint32_t chunk_shift;
28 sector_t chunk_mask;
29
30 struct stripe stripe[0];
31 };
32
33 static inline struct stripe_c *alloc_context(unsigned int stripes)
34 {
35 size_t len;
36
37 if (array_too_big(sizeof(struct stripe_c), sizeof(struct stripe),
38 stripes))
39 return NULL;
40
41 len = sizeof(struct stripe_c) + (sizeof(struct stripe) * stripes);
42
43 return kmalloc(len, GFP_KERNEL);
44 }
45
46 /*
47 * Parse a single <dev> <sector> pair
48 */
49 static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
50 unsigned int stripe, char **argv)
51 {
52 unsigned long long start;
53
54 if (sscanf(argv[1], "%llu", &start) != 1)
55 return -EINVAL;
56
57 if (dm_get_device(ti, argv[0], start, sc->stripe_width,
58 dm_table_get_mode(ti->table),
59 &sc->stripe[stripe].dev))
60 return -ENXIO;
61
62 sc->stripe[stripe].physical_start = start;
63 return 0;
64 }
65
66 /*
67 * Construct a striped mapping.
68 * <number of stripes> <chunk size (2^^n)> [<dev_path> <offset>]+
69 */
70 static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
71 {
72 struct stripe_c *sc;
73 sector_t width;
74 uint32_t stripes;
75 uint32_t chunk_size;
76 char *end;
77 int r;
78 unsigned int i;
79
80 if (argc < 2) {
81 ti->error = "dm-stripe: Not enough arguments";
82 return -EINVAL;
83 }
84
85 stripes = simple_strtoul(argv[0], &end, 10);
86 if (*end) {
87 ti->error = "dm-stripe: Invalid stripe count";
88 return -EINVAL;
89 }
90
91 chunk_size = simple_strtoul(argv[1], &end, 10);
92 if (*end) {
93 ti->error = "dm-stripe: Invalid chunk_size";
94 return -EINVAL;
95 }
96
97 /*
98 * chunk_size is a power of two
99 */
100 if (!chunk_size || (chunk_size & (chunk_size - 1)) ||
101 (chunk_size < (PAGE_SIZE >> SECTOR_SHIFT))) {
102 ti->error = "dm-stripe: Invalid chunk size";
103 return -EINVAL;
104 }
105
106 if (ti->len & (chunk_size - 1)) {
107 ti->error = "dm-stripe: Target length not divisible by "
108 "chunk size";
109 return -EINVAL;
110 }
111
112 width = ti->len;
113 if (sector_div(width, stripes)) {
114 ti->error = "dm-stripe: Target length not divisible by "
115 "number of stripes";
116 return -EINVAL;
117 }
118
119 /*
120 * Do we have enough arguments for that many stripes ?
121 */
122 if (argc != (2 + 2 * stripes)) {
123 ti->error = "dm-stripe: Not enough destinations "
124 "specified";
125 return -EINVAL;
126 }
127
128 sc = alloc_context(stripes);
129 if (!sc) {
130 ti->error = "dm-stripe: Memory allocation for striped context "
131 "failed";
132 return -ENOMEM;
133 }
134
135 sc->stripes = stripes;
136 sc->stripe_width = width;
137 ti->split_io = chunk_size;
138
139 sc->chunk_mask = ((sector_t) chunk_size) - 1;
140 for (sc->chunk_shift = 0; chunk_size; sc->chunk_shift++)
141 chunk_size >>= 1;
142 sc->chunk_shift--;
143
144 /*
145 * Get the stripe destinations.
146 */
147 for (i = 0; i < stripes; i++) {
148 argv += 2;
149
150 r = get_stripe(ti, sc, i, argv);
151 if (r < 0) {
152 ti->error = "dm-stripe: Couldn't parse stripe "
153 "destination";
154 while (i--)
155 dm_put_device(ti, sc->stripe[i].dev);
156 kfree(sc);
157 return r;
158 }
159 }
160
161 ti->private = sc;
162 return 0;
163 }
164
165 static void stripe_dtr(struct dm_target *ti)
166 {
167 unsigned int i;
168 struct stripe_c *sc = (struct stripe_c *) ti->private;
169
170 for (i = 0; i < sc->stripes; i++)
171 dm_put_device(ti, sc->stripe[i].dev);
172
173 kfree(sc);
174 }
175
176 static int stripe_map(struct dm_target *ti, struct bio *bio,
177 union map_info *map_context)
178 {
179 struct stripe_c *sc = (struct stripe_c *) ti->private;
180
181 sector_t offset = bio->bi_sector - ti->begin;
182 sector_t chunk = offset >> sc->chunk_shift;
183 uint32_t stripe = sector_div(chunk, sc->stripes);
184
185 bio->bi_bdev = sc->stripe[stripe].dev->bdev;
186 bio->bi_sector = sc->stripe[stripe].physical_start +
187 (chunk << sc->chunk_shift) + (offset & sc->chunk_mask);
188 return 1;
189 }
190
191 static int stripe_status(struct dm_target *ti,
192 status_type_t type, char *result, unsigned int maxlen)
193 {
194 struct stripe_c *sc = (struct stripe_c *) ti->private;
195 unsigned int sz = 0;
196 unsigned int i;
197
198 switch (type) {
199 case STATUSTYPE_INFO:
200 result[0] = '\0';
201 break;
202
203 case STATUSTYPE_TABLE:
204 DMEMIT("%d %llu", sc->stripes,
205 (unsigned long long)sc->chunk_mask + 1);
206 for (i = 0; i < sc->stripes; i++)
207 DMEMIT(" %s %llu", sc->stripe[i].dev->name,
208 (unsigned long long)sc->stripe[i].physical_start);
209 break;
210 }
211 return 0;
212 }
213
214 static struct target_type stripe_target = {
215 .name = "striped",
216 .version= {1, 0, 2},
217 .module = THIS_MODULE,
218 .ctr = stripe_ctr,
219 .dtr = stripe_dtr,
220 .map = stripe_map,
221 .status = stripe_status,
222 };
223
224 int __init dm_stripe_init(void)
225 {
226 int r;
227
228 r = dm_register_target(&stripe_target);
229 if (r < 0)
230 DMWARN("striped target registration failed");
231
232 return r;
233 }
234
235 void dm_stripe_exit(void)
236 {
237 if (dm_unregister_target(&stripe_target))
238 DMWARN("striped target unregistration failed");
239
240 return;
241 }
242
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.