2 * Copyright (C) 2010 The Chromium OS Authors <chromium-os-dev@chromium.org>
4 * Based on do_mounts_md.c
6 * This file is released under the GPL.
8 #include <linux/async.h>
9 #include <linux/ctype.h>
10 #include <linux/device-mapper.h>
12 #include <linux/string.h>
13 #include <linux/delay.h>
15 #include "do_mounts.h"
17 #define DM_MAX_DEVICES 256
18 #define DM_MAX_TARGETS 256
19 #define DM_MAX_NAME 32
20 #define DM_MAX_UUID 129
21 #define DM_NO_UUID "none"
23 #define DM_MSG_PREFIX "init"
25 /* Separators used for parsing the dm= argument. */
26 #define DM_FIELD_SEP " "
27 #define DM_LINE_SEP ","
28 #define DM_ANY_SEP DM_FIELD_SEP DM_LINE_SEP
31 * When the device-mapper and any targets are compiled into the kernel
32 * (not a module), one or more device-mappers may be created and used
33 * as the root device at boot time with the parameters given with the
36 * Multiple device-mappers can be stacked specifing the number of
37 * devices. A device can have multiple targets if the the number of
38 * targets is specified.
40 * TODO(taysom:defect 32847)
41 * In the future, the <num> field will be mandatory.
43 * <device> ::= [<num>] <device-mapper>+
44 * <device-mapper> ::= <head> "," <target>+
45 * <head> ::= <name> <uuid> <mode> [<num>]
46 * <target> ::= <start> <length> <type> <options> ","
47 * <mode> ::= "ro" | "rw"
48 * <uuid> ::= xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | "none"
49 * <type> ::= "verity" | "bootcache" | ...
54 * device=aa55b119-2a47-8c45-946a-5ac57765011f+1
55 * signature=76e9be054b15884a9fa85973e9cb274c93afadb6
56 * cache_start=1768000 max_blocks=100000 size_limit=23 max_trace=20000,
58 * 0 1740800 verity payload=254:0 hashtree=254:0 hashstart=1740800 alg=sha1
59 * root_hexdigest=76e9be054b15884a9fa85973e9cb274c93afadb6
60 * salt=5b3549d54d6c7a3837b9b81ed72e49463a64c03680c47835bef94d768e5646fe
63 * 1. uuid is a label for the device and we set it to "none".
64 * 2. The <num> field will be optional initially and assumed to be 1.
65 * Once all the scripts that set these fields have been set, it will
69 struct dm_setup_target
{
74 /* simple singly linked list */
75 struct dm_setup_target
*next
;
81 char name
[DM_MAX_NAME
];
82 char uuid
[DM_MAX_UUID
];
83 unsigned long num_targets
;
84 struct dm_setup_target
*target
;
86 struct dm_device
*next
;
97 unsigned long num_devices
;
99 } dm_setup_args __initdata
;
101 static __initdata
int dm_early_setup
;
103 static int __init
get_dm_option(struct dm_option
*opt
, const char *accept
)
105 char *str
= opt
->next
;
111 str
= skip_spaces(str
);
113 endp
= strpbrk(str
, accept
);
114 if (!endp
) { /* act like strchrnul */
115 opt
->len
= strlen(str
);
116 endp
= str
+ opt
->len
;
118 opt
->len
= endp
- str
;
122 /* Don't advance past the nul. */
125 opt
->next
= endp
+ 1;
127 return opt
->len
!= 0;
130 static int __init
dm_setup_cleanup(struct dm_device
*devices
)
132 struct dm_device
*dev
= devices
;
135 struct dm_device
*old_dev
= dev
;
136 struct dm_setup_target
*target
= dev
->target
;
138 struct dm_setup_target
*old_target
= target
;
140 kfree(target
->params
);
141 target
= target
->next
;
145 BUG_ON(dev
->target_count
);
152 static char * __init
dm_parse_device(struct dm_device
*dev
, char *str
)
154 struct dm_option opt
;
157 /* Grab the logical name of the device to be exported to udev */
159 if (!get_dm_option(&opt
, DM_FIELD_SEP
)) {
160 DMERR("failed to parse device name");
163 len
= min(opt
.len
+ 1, sizeof(dev
->name
));
164 strlcpy(dev
->name
, opt
.start
, len
); /* includes nul */
166 /* Grab the UUID value or "none" */
167 if (!get_dm_option(&opt
, DM_FIELD_SEP
)) {
168 DMERR("failed to parse device uuid");
171 len
= min(opt
.len
+ 1, sizeof(dev
->uuid
));
172 strlcpy(dev
->uuid
, opt
.start
, len
);
174 /* Determine if the table/device will be read only or read-write */
175 get_dm_option(&opt
, DM_ANY_SEP
);
176 if (!strncmp("ro", opt
.start
, opt
.len
)) {
178 } else if (!strncmp("rw", opt
.start
, opt
.len
)) {
181 DMERR("failed to parse table mode");
185 /* Optional number field */
186 /* XXX: The <num> field will be mandatory in the next round */
187 if (opt
.delim
== DM_FIELD_SEP
[0]) {
188 if (!get_dm_option(&opt
, DM_LINE_SEP
))
190 dev
->num_targets
= simple_strtoul(opt
.start
, NULL
, 10);
192 dev
->num_targets
= 1;
194 if (dev
->num_targets
> DM_MAX_TARGETS
) {
195 DMERR("too many targets %lu > %d",
196 dev
->num_targets
, DM_MAX_TARGETS
);
204 static char * __init
dm_parse_targets(struct dm_device
*dev
, char *str
)
206 struct dm_option opt
;
207 struct dm_setup_target
**target
= &dev
->target
;
208 unsigned long num_targets
= dev
->num_targets
;
211 /* Targets are defined as per the table format but with a
212 * comma as a newline separator. */
214 for (i
= 0; i
< num_targets
; i
++) {
215 *target
= kzalloc(sizeof(struct dm_setup_target
), GFP_KERNEL
);
217 DMERR("failed to allocate memory for target %s<%ld>",
223 if (!get_dm_option(&opt
, DM_FIELD_SEP
)) {
224 DMERR("failed to parse starting sector"
225 " for target %s<%ld>", dev
->name
, i
);
228 (*target
)->begin
= simple_strtoull(opt
.start
, NULL
, 10);
230 if (!get_dm_option(&opt
, DM_FIELD_SEP
)) {
231 DMERR("failed to parse length for target %s<%ld>",
235 (*target
)->length
= simple_strtoull(opt
.start
, NULL
, 10);
237 if (get_dm_option(&opt
, DM_FIELD_SEP
))
238 (*target
)->type
= kstrndup(opt
.start
, opt
.len
,
240 if (!((*target
)->type
)) {
241 DMERR("failed to parse type for target %s<%ld>",
245 if (get_dm_option(&opt
, DM_LINE_SEP
))
246 (*target
)->params
= kstrndup(opt
.start
, opt
.len
,
248 if (!((*target
)->params
)) {
249 DMERR("failed to parse params for target %s<%ld>",
253 target
= &((*target
)->next
);
255 DMDEBUG("parsed %d targets", dev
->target_count
);
263 static struct dm_device
* __init
dm_parse_args(void)
265 struct dm_device
*devices
= NULL
;
266 struct dm_device
**tail
= &devices
;
267 struct dm_device
*dev
;
268 char *str
= dm_setup_args
.str
;
269 unsigned long num_devices
= dm_setup_args
.num_devices
;
274 for (i
= 0; i
< num_devices
; i
++) {
275 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
277 DMERR("failed to allocated memory for dev");
283 * devices are given minor numbers 0 - n-1
284 * in the order they are found in the arg
288 str
= dm_parse_device(dev
, str
);
289 if (!str
) /* NULL indicates error in parsing, bail */
292 str
= dm_parse_targets(dev
, str
);
298 dm_setup_cleanup(devices
);
303 * Parse the command-line parameters given our kernel, but do not
304 * actually try to invoke the DM device now; that is handled by
305 * dm_setup_drives after the low-level disk drivers have initialised.
306 * dm format is described at the top of the file.
308 * Because dm minor numbers are assigned in assending order starting with 0,
309 * You can assume the first device is /dev/dm-0, the next device is /dev/dm-1,
312 static int __init
dm_setup(char *str
)
314 struct dm_option opt
;
315 unsigned long num_devices
;
318 DMDEBUG("str is NULL");
322 if (!get_dm_option(&opt
, DM_FIELD_SEP
))
324 if (isdigit(opt
.start
[0])) { /* XXX: Optional number field */
325 num_devices
= simple_strtoul(opt
.start
, NULL
, 10);
329 /* Don't advance str */
331 if (num_devices
> DM_MAX_DEVICES
) {
332 DMDEBUG("too many devices %lu > %d",
333 num_devices
, DM_MAX_DEVICES
);
335 dm_setup_args
.str
= str
;
336 dm_setup_args
.num_devices
= num_devices
;
337 DMINFO("will configure %lu devices", num_devices
);
342 DMWARN("Invalid arguments supplied to dm=.");
346 static void __init
dm_setup_drives(void)
348 struct mapped_device
*md
= NULL
;
349 struct dm_table
*table
= NULL
;
350 struct dm_setup_target
*target
;
351 struct dm_device
*dev
;
353 fmode_t fmode
= FMODE_READ
;
354 struct dm_device
*devices
;
356 devices
= dm_parse_args();
358 for (dev
= devices
; dev
; dev
= dev
->next
) {
359 if (dm_create(dev
->minor
, &md
)) {
360 DMDEBUG("failed to create the device");
363 DMDEBUG("created device '%s'", dm_device_name(md
));
366 * In addition to flagging the table below, the disk must be
367 * set explicitly ro/rw.
369 set_disk_ro(dm_disk(md
), dev
->ro
);
372 fmode
|= FMODE_WRITE
;
373 if (dm_table_create(&table
, fmode
, dev
->target_count
, md
)) {
374 DMDEBUG("failed to create the table");
375 goto dm_table_create_fail
;
380 for (target
= dev
->target
; target
; target
= target
->next
) {
381 DMINFO("adding target '%llu %llu %s %s'",
382 (unsigned long long) target
->begin
,
383 (unsigned long long) target
->length
,
384 target
->type
, target
->params
);
385 if (dm_table_add_target(table
, target
->type
,
389 DMDEBUG("failed to add the target"
391 goto add_target_fail
;
394 if (dm_table_complete(table
)) {
395 DMDEBUG("failed to complete the table");
396 goto table_complete_fail
;
399 /* Suspend the device so that we can bind it to the table. */
400 if (dm_suspend(md
, 0)) {
401 DMDEBUG("failed to suspend the device pre-bind");
405 /* Initial table load: acquire type of table. */
406 dm_set_md_type(md
, dm_table_get_type(table
));
408 /* Setup md->queue to reflect md's type. */
409 if (dm_setup_md_queue(md
, table
)) {
410 DMWARN("unable to set up device queue for new table.");
411 goto setup_md_queue_fail
;
415 * Bind the table to the device. This is the only way
416 * to associate md->map with the table and set the disk
419 if (dm_swap_table(md
, table
)) { /* should return NULL. */
420 DMDEBUG("failed to bind the device to the table");
421 goto table_bind_fail
;
424 /* Finally, resume and the device should be ready. */
426 DMDEBUG("failed to resume the device");
430 /* Export the dm device via the ioctl interface */
431 if (!strcmp(DM_NO_UUID
, dev
->uuid
))
433 if (dm_ioctl_export(md
, dev
->name
, uuid
)) {
434 DMDEBUG("failed to export device with given"
439 dm_unlock_md_type(md
);
441 DMINFO("dm-%d is ready", dev
->minor
);
443 dm_setup_cleanup(devices
);
453 dm_unlock_md_type(md
);
454 dm_table_create_fail
:
457 DMWARN("starting dm-%d (%s) failed",
458 dev
->minor
, dev
->name
);
459 dm_setup_cleanup(devices
);
462 __setup("dm=", dm_setup
);
464 void __init
dm_run_setup(void)
468 DMINFO("attempting early device configuration.");