1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2013 HUAWEI 4 * Author: Cai Zhiyong <caizhiyong@huawei.com> 5 * 6 * Read block device partition table from the command line. 7 * Typically used for fixed block (eMMC) embedded devices. 8 * It has no MBR, so saves storage space. Bootloader can be easily accessed 9 * by absolute address of data on the block device. 10 * Users can easily change the partition. 11 * 12 * The format for the command line is just like mtdparts. 13 * 14 * For further information, see "Documentation/block/cmdline-partition.rst" 15 * 16 */ 17 #include <linux/blkdev.h> 18 #include <linux/fs.h> 19 #include <linux/slab.h> 20 #include "check.h" 21 22 23 /* partition flags */ 24 #define PF_RDONLY 0x01 /* Device is read only */ 25 #define PF_POWERUP_LOCK 0x02 /* Always locked after reset */ 26 27 struct cmdline_subpart { 28 char name[BDEVNAME_SIZE]; /* partition name, such as 'rootfs' */ 29 sector_t from; 30 sector_t size; 31 int flags; 32 struct cmdline_subpart *next_subpart; 33 }; 34 35 struct cmdline_parts { 36 char name[BDEVNAME_SIZE]; /* block device, such as 'mmcblk0' */ 37 unsigned int nr_subparts; 38 struct cmdline_subpart *subpart; 39 struct cmdline_parts *next_parts; 40 }; 41 42 static int parse_subpart(struct cmdline_subpart **subpart, char *partdef) 43 { 44 int ret = 0; 45 struct cmdline_subpart *new_subpart; 46 47 *subpart = NULL; 48 49 new_subpart = kzalloc(sizeof(struct cmdline_subpart), GFP_KERNEL); 50 if (!new_subpart) 51 return -ENOMEM; 52 53 if (*partdef == '-') { 54 new_subpart->size = (sector_t)(~0ULL); 55 partdef++; 56 } else { 57 new_subpart->size = (sector_t)memparse(partdef, &partdef); 58 if (new_subpart->size < (sector_t)PAGE_SIZE) { 59 pr_warn("cmdline partition size is invalid."); 60 ret = -EINVAL; 61 goto fail; 62 } 63 } 64 65 if (*partdef == '@') { 66 partdef++; 67 new_subpart->from = (sector_t)memparse(partdef, &partdef); 68 } else { 69 new_subpart->from = (sector_t)(~0ULL); 70 } 71 72 if (*partdef == '(') { 73 int length; 74 char *next = strchr(++partdef, ')'); 75 76 if (!next) { 77 pr_warn("cmdline partition format is invalid."); 78 ret = -EINVAL; 79 goto fail; 80 } 81 82 length = min_t(int, next - partdef, 83 sizeof(new_subpart->name) - 1); 84 strncpy(new_subpart->name, partdef, length); 85 new_subpart->name[length] = '\0'; 86 87 partdef = ++next; 88 } else 89 new_subpart->name[0] = '\0'; 90 91 new_subpart->flags = 0; 92 93 if (!strncmp(partdef, "ro", 2)) { 94 new_subpart->flags |= PF_RDONLY; 95 partdef += 2; 96 } 97 98 if (!strncmp(partdef, "lk", 2)) { 99 new_subpart->flags |= PF_POWERUP_LOCK; 100 partdef += 2; 101 } 102 103 *subpart = new_subpart; 104 return 0; 105 fail: 106 kfree(new_subpart); 107 return ret; 108 } 109 110 static void free_subpart(struct cmdline_parts *parts) 111 { 112 struct cmdline_subpart *subpart; 113 114 while (parts->subpart) { 115 subpart = parts->subpart; 116 parts->subpart = subpart->next_subpart; 117 kfree(subpart); 118 } 119 } 120 121 static int parse_parts(struct cmdline_parts **parts, const char *bdevdef) 122 { 123 int ret = -EINVAL; 124 char *next; 125 int length; 126 struct cmdline_subpart **next_subpart; 127 struct cmdline_parts *newparts; 128 char buf[BDEVNAME_SIZE + 32 + 4]; 129 130 *parts = NULL; 131 132 newparts = kzalloc(sizeof(struct cmdline_parts), GFP_KERNEL); 133 if (!newparts) 134 return -ENOMEM; 135 136 next = strchr(bdevdef, ':'); 137 if (!next) { 138 pr_warn("cmdline partition has no block device."); 139 goto fail; 140 } 141 142 length = min_t(int, next - bdevdef, sizeof(newparts->name) - 1); 143 strncpy(newparts->name, bdevdef, length); 144 newparts->name[length] = '\0'; 145 newparts->nr_subparts = 0; 146 147 next_subpart = &newparts->subpart; 148 149 while (next && *(++next)) { 150 bdevdef = next; 151 next = strchr(bdevdef, ','); 152 153 length = (!next) ? (sizeof(buf) - 1) : 154 min_t(int, next - bdevdef, sizeof(buf) - 1); 155 156 strncpy(buf, bdevdef, length); 157 buf[length] = '\0'; 158 159 ret = parse_subpart(next_subpart, buf); 160 if (ret) 161 goto fail; 162 163 newparts->nr_subparts++; 164 next_subpart = &(*next_subpart)->next_subpart; 165 } 166 167 if (!newparts->subpart) { 168 pr_warn("cmdline partition has no valid partition."); 169 ret = -EINVAL; 170 goto fail; 171 } 172 173 *parts = newparts; 174 175 return 0; 176 fail: 177 free_subpart(newparts); 178 kfree(newparts); 179 return ret; 180 } 181 182 static void cmdline_parts_free(struct cmdline_parts **parts) 183 { 184 struct cmdline_parts *next_parts; 185 186 while (*parts) { 187 next_parts = (*parts)->next_parts; 188 free_subpart(*parts); 189 kfree(*parts); 190 *parts = next_parts; 191 } 192 } 193 194 static int cmdline_parts_parse(struct cmdline_parts **parts, 195 const char *cmdline) 196 { 197 int ret; 198 char *buf; 199 char *pbuf; 200 char *next; 201 struct cmdline_parts **next_parts; 202 203 *parts = NULL; 204 205 next = pbuf = buf = kstrdup(cmdline, GFP_KERNEL); 206 if (!buf) 207 return -ENOMEM; 208 209 next_parts = parts; 210 211 while (next && *pbuf) { 212 next = strchr(pbuf, ';'); 213 if (next) 214 *next = '\0'; 215 216 ret = parse_parts(next_parts, pbuf); 217 if (ret) 218 goto fail; 219 220 if (next) 221 pbuf = ++next; 222 223 next_parts = &(*next_parts)->next_parts; 224 } 225 226 if (!*parts) { 227 pr_warn("cmdline partition has no valid partition."); 228 ret = -EINVAL; 229 goto fail; 230 } 231 232 ret = 0; 233 done: 234 kfree(buf); 235 return ret; 236 237 fail: 238 cmdline_parts_free(parts); 239 goto done; 240 } 241 242 static struct cmdline_parts *cmdline_parts_find(struct cmdline_parts *parts, 243 const char *bdev) 244 { 245 while (parts && strncmp(bdev, parts->name, sizeof(parts->name))) 246 parts = parts->next_parts; 247 return parts; 248 } 249 250 static char *cmdline; 251 static struct cmdline_parts *bdev_parts; 252 253 static int add_part(int slot, struct cmdline_subpart *subpart, 254 struct parsed_partitions *state) 255 { 256 int label_min; 257 struct partition_meta_info *info; 258 char tmp[sizeof(info->volname) + 4]; 259 260 if (slot >= state->limit) 261 return 1; 262 263 put_partition(state, slot, subpart->from >> 9, 264 subpart->size >> 9); 265 266 info = &state->parts[slot].info; 267 268 label_min = min_t(int, sizeof(info->volname) - 1, 269 sizeof(subpart->name)); 270 strncpy(info->volname, subpart->name, label_min); 271 info->volname[label_min] = '\0'; 272 273 snprintf(tmp, sizeof(tmp), "(%s)", info->volname); 274 strlcat(state->pp_buf, tmp, PAGE_SIZE); 275 276 state->parts[slot].has_info = true; 277 278 return 0; 279 } 280 281 static int cmdline_parts_set(struct cmdline_parts *parts, sector_t disk_size, 282 struct parsed_partitions *state) 283 { 284 sector_t from = 0; 285 struct cmdline_subpart *subpart; 286 int slot = 1; 287 288 for (subpart = parts->subpart; subpart; 289 subpart = subpart->next_subpart, slot++) { 290 if (subpart->from == (sector_t)(~0ULL)) 291 subpart->from = from; 292 else 293 from = subpart->from; 294 295 if (from >= disk_size) 296 break; 297 298 if (subpart->size > (disk_size - from)) 299 subpart->size = disk_size - from; 300 301 from += subpart->size; 302 303 if (add_part(slot, subpart, state)) 304 break; 305 } 306 307 return slot; 308 } 309 310 static int __init cmdline_parts_setup(char *s) 311 { 312 cmdline = s; 313 return 1; 314 } 315 __setup("blkdevparts=", cmdline_parts_setup); 316 317 static bool has_overlaps(sector_t from, sector_t size, 318 sector_t from2, sector_t size2) 319 { 320 sector_t end = from + size; 321 sector_t end2 = from2 + size2; 322 323 if (from >= from2 && from < end2) 324 return true; 325 326 if (end > from2 && end <= end2) 327 return true; 328 329 if (from2 >= from && from2 < end) 330 return true; 331 332 if (end2 > from && end2 <= end) 333 return true; 334 335 return false; 336 } 337 338 static inline void overlaps_warns_header(void) 339 { 340 pr_warn("Overlapping partitions are used in command line partitions."); 341 pr_warn("Don't use filesystems on overlapping partitions:"); 342 } 343 344 static void cmdline_parts_verifier(int slot, struct parsed_partitions *state) 345 { 346 int i; 347 bool header = true; 348 349 for (; slot < state->limit && state->parts[slot].has_info; slot++) { 350 for (i = slot+1; i < state->limit && state->parts[i].has_info; 351 i++) { 352 if (has_overlaps(state->parts[slot].from, 353 state->parts[slot].size, 354 state->parts[i].from, 355 state->parts[i].size)) { 356 if (header) { 357 header = false; 358 overlaps_warns_header(); 359 } 360 pr_warn("%s[%llu,%llu] overlaps with " 361 "%s[%llu,%llu].", 362 state->parts[slot].info.volname, 363 (u64)state->parts[slot].from << 9, 364 (u64)state->parts[slot].size << 9, 365 state->parts[i].info.volname, 366 (u64)state->parts[i].from << 9, 367 (u64)state->parts[i].size << 9); 368 } 369 } 370 } 371 } 372 373 /* 374 * Purpose: allocate cmdline partitions. 375 * Returns: 376 * -1 if unable to read the partition table 377 * 0 if this isn't our partition table 378 * 1 if successful 379 */ 380 int cmdline_partition(struct parsed_partitions *state) 381 { 382 sector_t disk_size; 383 struct cmdline_parts *parts; 384 385 if (cmdline) { 386 if (bdev_parts) 387 cmdline_parts_free(&bdev_parts); 388 389 if (cmdline_parts_parse(&bdev_parts, cmdline)) { 390 cmdline = NULL; 391 return -1; 392 } 393 cmdline = NULL; 394 } 395 396 if (!bdev_parts) 397 return 0; 398 399 parts = cmdline_parts_find(bdev_parts, state->disk->disk_name); 400 if (!parts) 401 return 0; 402 403 disk_size = get_capacity(state->disk) << 9; 404 405 cmdline_parts_set(parts, disk_size, state); 406 cmdline_parts_verifier(1, state); 407 408 strlcat(state->pp_buf, "\n", PAGE_SIZE); 409 410 return 1; 411 } 412