xref: /openbmc/linux/drivers/md/dm-init.c (revision 8b326742)
1 // SPDX-License-Identifier: GPL-2.0-only
2 
3 /*
4  * Copyright (C) 2017 The Chromium OS Authors <chromium-os-dev@chromium.org>
5  *
6  * This file is released under the GPLv2.
7  */
8 
9 #include <linux/ctype.h>
10 #include <linux/delay.h>
11 #include <linux/device.h>
12 #include <linux/device-mapper.h>
13 #include <linux/init.h>
14 #include <linux/list.h>
15 #include <linux/moduleparam.h>
16 
17 #define DM_MSG_PREFIX "init"
18 #define DM_MAX_DEVICES 256
19 #define DM_MAX_TARGETS 256
20 #define DM_MAX_STR_SIZE 4096
21 #define DM_MAX_WAITFOR 256
22 
23 static char *create;
24 
25 static char *waitfor[DM_MAX_WAITFOR];
26 
27 /*
28  * Format: dm-mod.create=<name>,<uuid>,<minor>,<flags>,<table>[,<table>+][;<name>,<uuid>,<minor>,<flags>,<table>[,<table>+]+]
29  * Table format: <start_sector> <num_sectors> <target_type> <target_args>
30  * Block devices to wait for to become available before setting up tables:
31  * dm-mod.waitfor=<device1>[,..,<deviceN>]
32  *
33  * See Documentation/admin-guide/device-mapper/dm-init.rst for dm-mod.create="..." format
34  * details.
35  */
36 
37 struct dm_device {
38 	struct dm_ioctl dmi;
39 	struct dm_target_spec *table[DM_MAX_TARGETS];
40 	char *target_args_array[DM_MAX_TARGETS];
41 	struct list_head list;
42 };
43 
44 static const char * const dm_allowed_targets[] __initconst = {
45 	"crypt",
46 	"delay",
47 	"linear",
48 	"snapshot-origin",
49 	"striped",
50 	"verity",
51 };
52 
dm_verify_target_type(const char * target)53 static int __init dm_verify_target_type(const char *target)
54 {
55 	unsigned int i;
56 
57 	for (i = 0; i < ARRAY_SIZE(dm_allowed_targets); i++) {
58 		if (!strcmp(dm_allowed_targets[i], target))
59 			return 0;
60 	}
61 	return -EINVAL;
62 }
63 
dm_setup_cleanup(struct list_head * devices)64 static void __init dm_setup_cleanup(struct list_head *devices)
65 {
66 	struct dm_device *dev, *tmp;
67 	unsigned int i;
68 
69 	list_for_each_entry_safe(dev, tmp, devices, list) {
70 		list_del(&dev->list);
71 		for (i = 0; i < dev->dmi.target_count; i++) {
72 			kfree(dev->table[i]);
73 			kfree(dev->target_args_array[i]);
74 		}
75 		kfree(dev);
76 	}
77 }
78 
79 /**
80  * str_field_delimit - delimit a string based on a separator char.
81  * @str: the pointer to the string to delimit.
82  * @separator: char that delimits the field
83  *
84  * Find a @separator and replace it by '\0'.
85  * Remove leading and trailing spaces.
86  * Return the remainder string after the @separator.
87  */
str_field_delimit(char ** str,char separator)88 static char __init *str_field_delimit(char **str, char separator)
89 {
90 	char *s;
91 
92 	/* TODO: add support for escaped characters */
93 	*str = skip_spaces(*str);
94 	s = strchr(*str, separator);
95 	/* Delimit the field and remove trailing spaces */
96 	if (s)
97 		*s = '\0';
98 	*str = strim(*str);
99 	return s ? ++s : NULL;
100 }
101 
102 /**
103  * dm_parse_table_entry - parse a table entry
104  * @dev: device to store the parsed information.
105  * @str: the pointer to a string with the format:
106  *	<start_sector> <num_sectors> <target_type> <target_args>[, ...]
107  *
108  * Return the remainder string after the table entry, i.e, after the comma which
109  * delimits the entry or NULL if reached the end of the string.
110  */
dm_parse_table_entry(struct dm_device * dev,char * str)111 static char __init *dm_parse_table_entry(struct dm_device *dev, char *str)
112 {
113 	const unsigned int n = dev->dmi.target_count - 1;
114 	struct dm_target_spec *sp;
115 	unsigned int i;
116 	/* fields:  */
117 	char *field[4];
118 	char *next;
119 
120 	field[0] = str;
121 	/* Delimit first 3 fields that are separated by space */
122 	for (i = 0; i < ARRAY_SIZE(field) - 1; i++) {
123 		field[i + 1] = str_field_delimit(&field[i], ' ');
124 		if (!field[i + 1])
125 			return ERR_PTR(-EINVAL);
126 	}
127 	/* Delimit last field that can be terminated by comma */
128 	next = str_field_delimit(&field[i], ',');
129 
130 	sp = kzalloc(sizeof(*sp), GFP_KERNEL);
131 	if (!sp)
132 		return ERR_PTR(-ENOMEM);
133 	dev->table[n] = sp;
134 
135 	/* start_sector */
136 	if (kstrtoull(field[0], 0, &sp->sector_start))
137 		return ERR_PTR(-EINVAL);
138 	/* num_sector */
139 	if (kstrtoull(field[1], 0, &sp->length))
140 		return ERR_PTR(-EINVAL);
141 	/* target_type */
142 	strscpy(sp->target_type, field[2], sizeof(sp->target_type));
143 	if (dm_verify_target_type(sp->target_type)) {
144 		DMERR("invalid type \"%s\"", sp->target_type);
145 		return ERR_PTR(-EINVAL);
146 	}
147 	/* target_args */
148 	dev->target_args_array[n] = kstrndup(field[3], DM_MAX_STR_SIZE,
149 					     GFP_KERNEL);
150 	if (!dev->target_args_array[n])
151 		return ERR_PTR(-ENOMEM);
152 
153 	return next;
154 }
155 
156 /**
157  * dm_parse_table - parse "dm-mod.create=" table field
158  * @dev: device to store the parsed information.
159  * @str: the pointer to a string with the format:
160  *	<table>[,<table>+]
161  */
dm_parse_table(struct dm_device * dev,char * str)162 static int __init dm_parse_table(struct dm_device *dev, char *str)
163 {
164 	char *table_entry = str;
165 
166 	while (table_entry) {
167 		DMDEBUG("parsing table \"%s\"", str);
168 		if (++dev->dmi.target_count > DM_MAX_TARGETS) {
169 			DMERR("too many targets %u > %d",
170 			      dev->dmi.target_count, DM_MAX_TARGETS);
171 			return -EINVAL;
172 		}
173 		table_entry = dm_parse_table_entry(dev, table_entry);
174 		if (IS_ERR(table_entry)) {
175 			DMERR("couldn't parse table");
176 			return PTR_ERR(table_entry);
177 		}
178 	}
179 
180 	return 0;
181 }
182 
183 /**
184  * dm_parse_device_entry - parse a device entry
185  * @dev: device to store the parsed information.
186  * @str: the pointer to a string with the format:
187  *	name,uuid,minor,flags,table[; ...]
188  *
189  * Return the remainder string after the table entry, i.e, after the semi-colon
190  * which delimits the entry or NULL if reached the end of the string.
191  */
dm_parse_device_entry(struct dm_device * dev,char * str)192 static char __init *dm_parse_device_entry(struct dm_device *dev, char *str)
193 {
194 	/* There are 5 fields: name,uuid,minor,flags,table; */
195 	char *field[5];
196 	unsigned int i;
197 	char *next;
198 
199 	field[0] = str;
200 	/* Delimit first 4 fields that are separated by comma */
201 	for (i = 0; i < ARRAY_SIZE(field) - 1; i++) {
202 		field[i+1] = str_field_delimit(&field[i], ',');
203 		if (!field[i+1])
204 			return ERR_PTR(-EINVAL);
205 	}
206 	/* Delimit last field that can be delimited by semi-colon */
207 	next = str_field_delimit(&field[i], ';');
208 
209 	/* name */
210 	strscpy(dev->dmi.name, field[0], sizeof(dev->dmi.name));
211 	/* uuid */
212 	strscpy(dev->dmi.uuid, field[1], sizeof(dev->dmi.uuid));
213 	/* minor */
214 	if (strlen(field[2])) {
215 		if (kstrtoull(field[2], 0, &dev->dmi.dev) ||
216 		    dev->dmi.dev >= (1 << MINORBITS))
217 			return ERR_PTR(-EINVAL);
218 		dev->dmi.dev = huge_encode_dev((dev_t)dev->dmi.dev);
219 		dev->dmi.flags |= DM_PERSISTENT_DEV_FLAG;
220 	}
221 	/* flags */
222 	if (!strcmp(field[3], "ro"))
223 		dev->dmi.flags |= DM_READONLY_FLAG;
224 	else if (strcmp(field[3], "rw"))
225 		return ERR_PTR(-EINVAL);
226 	/* table */
227 	if (dm_parse_table(dev, field[4]))
228 		return ERR_PTR(-EINVAL);
229 
230 	return next;
231 }
232 
233 /**
234  * dm_parse_devices - parse "dm-mod.create=" argument
235  * @devices: list of struct dm_device to store the parsed information.
236  * @str: the pointer to a string with the format:
237  *	<device>[;<device>+]
238  */
dm_parse_devices(struct list_head * devices,char * str)239 static int __init dm_parse_devices(struct list_head *devices, char *str)
240 {
241 	unsigned long ndev = 0;
242 	struct dm_device *dev;
243 	char *device = str;
244 
245 	DMDEBUG("parsing \"%s\"", str);
246 	while (device) {
247 		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
248 		if (!dev)
249 			return -ENOMEM;
250 		list_add_tail(&dev->list, devices);
251 
252 		if (++ndev > DM_MAX_DEVICES) {
253 			DMERR("too many devices %lu > %d",
254 			      ndev, DM_MAX_DEVICES);
255 			return -EINVAL;
256 		}
257 
258 		device = dm_parse_device_entry(dev, device);
259 		if (IS_ERR(device)) {
260 			DMERR("couldn't parse device");
261 			return PTR_ERR(device);
262 		}
263 	}
264 
265 	return 0;
266 }
267 
268 /**
269  * dm_init_init - parse "dm-mod.create=" argument and configure drivers
270  */
dm_init_init(void)271 static int __init dm_init_init(void)
272 {
273 	struct dm_device *dev;
274 	LIST_HEAD(devices);
275 	char *str;
276 	int i, r;
277 
278 	if (!create)
279 		return 0;
280 
281 	if (strlen(create) >= DM_MAX_STR_SIZE) {
282 		DMERR("Argument is too big. Limit is %d", DM_MAX_STR_SIZE);
283 		return -EINVAL;
284 	}
285 	str = kstrndup(create, DM_MAX_STR_SIZE, GFP_KERNEL);
286 	if (!str)
287 		return -ENOMEM;
288 
289 	r = dm_parse_devices(&devices, str);
290 	if (r)
291 		goto out;
292 
293 	DMINFO("waiting for all devices to be available before creating mapped devices");
294 	wait_for_device_probe();
295 
296 	for (i = 0; i < ARRAY_SIZE(waitfor); i++) {
297 		if (waitfor[i]) {
298 			dev_t dev;
299 
300 			DMINFO("waiting for device %s ...", waitfor[i]);
301 			while (early_lookup_bdev(waitfor[i], &dev))
302 				fsleep(5000);
303 		}
304 	}
305 
306 	if (waitfor[0])
307 		DMINFO("all devices available");
308 
309 	list_for_each_entry(dev, &devices, list) {
310 		if (dm_early_create(&dev->dmi, dev->table,
311 				    dev->target_args_array))
312 			break;
313 	}
314 out:
315 	kfree(str);
316 	dm_setup_cleanup(&devices);
317 	return r;
318 }
319 
320 late_initcall(dm_init_init);
321 
322 module_param(create, charp, 0);
323 MODULE_PARM_DESC(create, "Create a mapped device in early boot");
324 
325 module_param_array(waitfor, charp, NULL, 0);
326 MODULE_PARM_DESC(waitfor, "Devices to wait for before setting up tables");
327