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