1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * cmd_gpt.c -- GPT (GUID Partition Table) handling command
4 *
5 * Copyright (C) 2015
6 * Lukasz Majewski <l.majewski@majess.pl>
7 *
8 * Copyright (C) 2012 Samsung Electronics
9 * author: Lukasz Majewski <l.majewski@samsung.com>
10 * author: Piotr Wilczek <p.wilczek@samsung.com>
11 */
12
13 #include <common.h>
14 #include <blk.h>
15 #include <env.h>
16 #include <log.h>
17 #include <malloc.h>
18 #include <command.h>
19 #include <part.h>
20 #include <part_efi.h>
21 #include <exports.h>
22 #include <uuid.h>
23 #include <linux/ctype.h>
24 #include <div64.h>
25 #include <memalign.h>
26 #include <linux/compat.h>
27 #include <linux/err.h>
28 #include <linux/sizes.h>
29 #include <stdlib.h>
30
31 static LIST_HEAD(disk_partitions);
32
33 /**
34 * extract_env(): Expand env name from string format '&{env_name}'
35 * and return pointer to the env (if the env is set)
36 *
37 * @param str - pointer to string
38 * @param env - pointer to pointer to extracted env
39 *
40 * @return - zero on successful expand and env is set
41 */
extract_env(const char * str,char ** env)42 static int extract_env(const char *str, char **env)
43 {
44 int ret = -1;
45 char *e, *s;
46 #ifdef CONFIG_RANDOM_UUID
47 char uuid_str[UUID_STR_LEN + 1];
48 #endif
49
50 if (!str || strlen(str) < 4)
51 return -1;
52
53 if (!((strncmp(str, "${", 2) == 0) && (str[strlen(str) - 1] == '}')))
54 return -1;
55
56 s = strdup(str);
57 if (s == NULL)
58 return -1;
59
60 memset(s + strlen(s) - 1, '\0', 1);
61 memmove(s, s + 2, strlen(s) - 1);
62
63 e = env_get(s);
64 if (e == NULL) {
65 #ifdef CONFIG_RANDOM_UUID
66 debug("%s unset. ", str);
67 gen_rand_uuid_str(uuid_str, UUID_STR_FORMAT_GUID);
68 env_set(s, uuid_str);
69
70 e = env_get(s);
71 if (e) {
72 debug("Set to random.\n");
73 ret = 0;
74 } else {
75 debug("Can't get random UUID.\n");
76 }
77 #else
78 debug("%s unset.\n", str);
79 #endif
80 } else {
81 debug("%s get from environment.\n", str);
82 ret = 0;
83 }
84
85 *env = e;
86 free(s);
87
88 return ret;
89 }
90
91 /**
92 * extract_val(): Extract value from a key=value pair list (comma separated).
93 * Only value for the given key is returend.
94 * Function allocates memory for the value, remember to free!
95 *
96 * @param str - pointer to string with key=values pairs
97 * @param key - pointer to the key to search for
98 *
99 * @return - pointer to allocated string with the value
100 */
extract_val(const char * str,const char * key)101 static char *extract_val(const char *str, const char *key)
102 {
103 char *v, *k;
104 char *s, *strcopy;
105 char *new = NULL;
106
107 strcopy = strdup(str);
108 if (strcopy == NULL)
109 return NULL;
110
111 s = strcopy;
112 while (s) {
113 v = strsep(&s, ",");
114 if (!v)
115 break;
116 k = strsep(&v, "=");
117 if (!k)
118 break;
119 if (strcmp(k, key) == 0) {
120 new = strdup(v);
121 break;
122 }
123 }
124
125 free(strcopy);
126
127 return new;
128 }
129
130 /**
131 * found_key(): Found key without value in parameter list (comma separated).
132 *
133 * @param str - pointer to string with key
134 * @param key - pointer to the key to search for
135 *
136 * @return - true on found key
137 */
found_key(const char * str,const char * key)138 static bool found_key(const char *str, const char *key)
139 {
140 char *k;
141 char *s, *strcopy;
142 bool result = false;
143
144 strcopy = strdup(str);
145 if (!strcopy)
146 return NULL;
147
148 s = strcopy;
149 while (s) {
150 k = strsep(&s, ",");
151 if (!k)
152 break;
153 if (strcmp(k, key) == 0) {
154 result = true;
155 break;
156 }
157 }
158
159 free(strcopy);
160
161 return result;
162 }
163
calc_parts_list_len(int numparts)164 static int calc_parts_list_len(int numparts)
165 {
166 int partlistlen = UUID_STR_LEN + 1 + strlen("uuid_disk=");
167 /* for the comma */
168 partlistlen++;
169
170 /* per-partition additions; numparts starts at 1, so this should be correct */
171 partlistlen += numparts * (strlen("name=,") + PART_NAME_LEN + 1);
172 /* see part.h for definition of struct disk_partition */
173 partlistlen += numparts * (strlen("start=MiB,") + sizeof(lbaint_t) + 1);
174 partlistlen += numparts * (strlen("size=MiB,") + sizeof(lbaint_t) + 1);
175 partlistlen += numparts * (strlen("uuid=;") + UUID_STR_LEN + 1);
176 /* for the terminating null */
177 partlistlen++;
178 debug("Length of partitions_list is %d for %d partitions\n", partlistlen,
179 numparts);
180 return partlistlen;
181 }
182
183 #ifdef CONFIG_CMD_GPT_RENAME
del_gpt_info(void)184 static void del_gpt_info(void)
185 {
186 struct list_head *pos = &disk_partitions;
187 struct disk_part *curr;
188 while (!list_empty(pos)) {
189 curr = list_entry(pos->next, struct disk_part, list);
190 list_del(pos->next);
191 free(curr);
192 }
193 }
194
allocate_disk_part(struct disk_partition * info,int partnum)195 static struct disk_part *allocate_disk_part(struct disk_partition *info,
196 int partnum)
197 {
198 struct disk_part *newpart;
199 newpart = calloc(1, sizeof(struct disk_part));
200 if (!newpart)
201 return ERR_PTR(-ENOMEM);
202
203 newpart->gpt_part_info.start = info->start;
204 newpart->gpt_part_info.size = info->size;
205 newpart->gpt_part_info.blksz = info->blksz;
206 strncpy((char *)newpart->gpt_part_info.name, (const char *)info->name,
207 PART_NAME_LEN);
208 newpart->gpt_part_info.name[PART_NAME_LEN - 1] = '\0';
209 strncpy((char *)newpart->gpt_part_info.type, (const char *)info->type,
210 PART_TYPE_LEN);
211 newpart->gpt_part_info.type[PART_TYPE_LEN - 1] = '\0';
212 newpart->gpt_part_info.bootable = info->bootable;
213 #ifdef CONFIG_PARTITION_UUIDS
214 strncpy(newpart->gpt_part_info.uuid, (const char *)info->uuid,
215 UUID_STR_LEN);
216 /* UUID_STR_LEN is correct, as uuid[]'s length is UUID_STR_LEN+1 chars */
217 newpart->gpt_part_info.uuid[UUID_STR_LEN] = '\0';
218 #endif
219 newpart->partnum = partnum;
220
221 return newpart;
222 }
223
prettyprint_part_size(char * sizestr,lbaint_t partsize,lbaint_t blksize)224 static void prettyprint_part_size(char *sizestr, lbaint_t partsize,
225 lbaint_t blksize)
226 {
227 unsigned long long partbytes, partmegabytes;
228
229 partbytes = partsize * blksize;
230 partmegabytes = lldiv(partbytes, SZ_1M);
231 snprintf(sizestr, 16, "%lluMiB", partmegabytes);
232 }
233
print_gpt_info(void)234 static void print_gpt_info(void)
235 {
236 struct list_head *pos;
237 struct disk_part *curr;
238 char partstartstr[16];
239 char partsizestr[16];
240
241 list_for_each(pos, &disk_partitions) {
242 curr = list_entry(pos, struct disk_part, list);
243 prettyprint_part_size(partstartstr, curr->gpt_part_info.start,
244 curr->gpt_part_info.blksz);
245 prettyprint_part_size(partsizestr, curr->gpt_part_info.size,
246 curr->gpt_part_info.blksz);
247
248 printf("Partition %d:\n", curr->partnum);
249 printf("Start %s, size %s\n", partstartstr, partsizestr);
250 printf("Block size %lu, name %s\n", curr->gpt_part_info.blksz,
251 curr->gpt_part_info.name);
252 printf("Type %s, bootable %d\n", curr->gpt_part_info.type,
253 curr->gpt_part_info.bootable & PART_BOOTABLE);
254 #ifdef CONFIG_PARTITION_UUIDS
255 printf("UUID %s\n", curr->gpt_part_info.uuid);
256 #endif
257 printf("\n");
258 }
259 }
260
261 /*
262 * create the string that upstream 'gpt write' command will accept as an
263 * argument
264 *
265 * From doc/README.gpt, Format of partitions layout:
266 * "uuid_disk=...;name=u-boot,size=60MiB,uuid=...;
267 * name=kernel,size=60MiB,uuid=...;"
268 * The fields 'name' and 'size' are mandatory for every partition.
269 * The field 'start' is optional. The fields 'uuid' and 'uuid_disk'
270 * are optional if CONFIG_RANDOM_UUID is enabled.
271 */
create_gpt_partitions_list(int numparts,const char * guid,char * partitions_list)272 static int create_gpt_partitions_list(int numparts, const char *guid,
273 char *partitions_list)
274 {
275 struct list_head *pos;
276 struct disk_part *curr;
277 char partstr[PART_NAME_LEN + 1];
278
279 if (!partitions_list)
280 return -EINVAL;
281
282 strcpy(partitions_list, "uuid_disk=");
283 strncat(partitions_list, guid, UUID_STR_LEN + 1);
284 strcat(partitions_list, ";");
285
286 list_for_each(pos, &disk_partitions) {
287 curr = list_entry(pos, struct disk_part, list);
288 strcat(partitions_list, "name=");
289 strncat(partitions_list, (const char *)curr->gpt_part_info.name,
290 PART_NAME_LEN + 1);
291 sprintf(partstr, ",start=0x%llx",
292 (unsigned long long)curr->gpt_part_info.start *
293 curr->gpt_part_info.blksz);
294 /* one extra byte for NULL */
295 strncat(partitions_list, partstr, PART_NAME_LEN + 1);
296 sprintf(partstr, ",size=0x%llx",
297 (unsigned long long)curr->gpt_part_info.size *
298 curr->gpt_part_info.blksz);
299 strncat(partitions_list, partstr, PART_NAME_LEN + 1);
300
301 strcat(partitions_list, ",uuid=");
302 strncat(partitions_list, curr->gpt_part_info.uuid,
303 UUID_STR_LEN + 1);
304 strcat(partitions_list, ";");
305 }
306 return 0;
307 }
308
309 /*
310 * read partition info into disk_partitions list where
311 * it can be printed or modified
312 */
get_gpt_info(struct blk_desc * dev_desc)313 static int get_gpt_info(struct blk_desc *dev_desc)
314 {
315 /* start partition numbering at 1, as U-Boot does */
316 int valid_parts = 0, p, ret;
317 struct disk_partition info;
318 struct disk_part *new_disk_part;
319
320 /*
321 * Always re-read partition info from device, in case
322 * it has changed
323 */
324 INIT_LIST_HEAD(&disk_partitions);
325
326 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
327 ret = part_get_info(dev_desc, p, &info);
328 if (ret)
329 continue;
330
331 /* Add 1 here because counter is zero-based but p1 is
332 the first partition */
333 new_disk_part = allocate_disk_part(&info, valid_parts+1);
334 if (IS_ERR(new_disk_part))
335 goto out;
336
337 list_add_tail(&new_disk_part->list, &disk_partitions);
338 valid_parts++;
339 }
340 if (valid_parts == 0) {
341 printf("** No valid partitions found **\n");
342 goto out;
343 }
344 return valid_parts;
345 out:
346 if (valid_parts >= 1)
347 del_gpt_info();
348 return -ENODEV;
349 }
350
351 /* a wrapper to test get_gpt_info */
do_get_gpt_info(struct blk_desc * dev_desc)352 static int do_get_gpt_info(struct blk_desc *dev_desc)
353 {
354 int ret;
355
356 ret = get_gpt_info(dev_desc);
357 if (ret > 0) {
358 print_gpt_info();
359 del_gpt_info();
360 return 0;
361 }
362 return ret;
363 }
364 #endif
365
366 /**
367 * set_gpt_info(): Fill partition information from string
368 * function allocates memory, remember to free!
369 *
370 * @param dev_desc - pointer block device descriptor
371 * @param str_part - pointer to string with partition information
372 * @param str_disk_guid - pointer to pointer to allocated string with disk guid
373 * @param partitions - pointer to pointer to allocated partitions array
374 * @param parts_count - number of partitions
375 *
376 * @return - zero on success, otherwise error
377 *
378 */
set_gpt_info(struct blk_desc * dev_desc,const char * str_part,char ** str_disk_guid,struct disk_partition ** partitions,u8 * parts_count)379 static int set_gpt_info(struct blk_desc *dev_desc,
380 const char *str_part,
381 char **str_disk_guid,
382 struct disk_partition **partitions,
383 u8 *parts_count)
384 {
385 char *tok, *str, *s;
386 int i;
387 char *val, *p;
388 int p_count;
389 struct disk_partition *parts;
390 int errno = 0;
391 uint64_t size_ll, start_ll;
392 lbaint_t offset = 0;
393 int max_str_part = calc_parts_list_len(MAX_SEARCH_PARTITIONS);
394
395 debug("%s: lba num: 0x%x %d\n", __func__,
396 (unsigned int)dev_desc->lba, (unsigned int)dev_desc->lba);
397
398 if (str_part == NULL)
399 return -1;
400
401 str = strdup(str_part);
402 if (str == NULL)
403 return -ENOMEM;
404
405 /* extract disk guid */
406 s = str;
407 val = extract_val(str, "uuid_disk");
408 if (!val) {
409 #ifdef CONFIG_RANDOM_UUID
410 *str_disk_guid = malloc(UUID_STR_LEN + 1);
411 if (*str_disk_guid == NULL)
412 return -ENOMEM;
413 gen_rand_uuid_str(*str_disk_guid, UUID_STR_FORMAT_STD);
414 #else
415 free(str);
416 return -2;
417 #endif
418 } else {
419 val = strsep(&val, ";");
420 if (extract_env(val, &p))
421 p = val;
422 *str_disk_guid = strdup(p);
423 free(val);
424 /* Move s to first partition */
425 strsep(&s, ";");
426 }
427 if (s == NULL) {
428 printf("Error: is the partitions string NULL-terminated?\n");
429 return -EINVAL;
430 }
431 if (strnlen(s, max_str_part) == 0)
432 return -3;
433
434 i = strnlen(s, max_str_part) - 1;
435 if (s[i] == ';')
436 s[i] = '\0';
437
438 /* calculate expected number of partitions */
439 p_count = 1;
440 p = s;
441 while (*p) {
442 if (*p++ == ';')
443 p_count++;
444 }
445
446 /* allocate memory for partitions */
447 parts = calloc(sizeof(struct disk_partition), p_count);
448 if (parts == NULL)
449 return -ENOMEM;
450
451 /* retrieve partitions data from string */
452 for (i = 0; i < p_count; i++) {
453 tok = strsep(&s, ";");
454
455 if (tok == NULL)
456 break;
457
458 /* uuid */
459 val = extract_val(tok, "uuid");
460 if (!val) {
461 /* 'uuid' is optional if random uuid's are enabled */
462 #ifdef CONFIG_RANDOM_UUID
463 gen_rand_uuid_str(parts[i].uuid, UUID_STR_FORMAT_STD);
464 #else
465 errno = -4;
466 goto err;
467 #endif
468 } else {
469 if (extract_env(val, &p))
470 p = val;
471 if (strnlen(p, max_str_part) >= sizeof(parts[i].uuid)) {
472 printf("Wrong uuid format for partition %d\n", i);
473 errno = -4;
474 goto err;
475 }
476 strncpy((char *)parts[i].uuid, p, max_str_part);
477 free(val);
478 }
479 #ifdef CONFIG_PARTITION_TYPE_GUID
480 /* guid */
481 val = extract_val(tok, "type");
482 if (val) {
483 /* 'type' is optional */
484 if (extract_env(val, &p))
485 p = val;
486 if (strnlen(p, max_str_part) >= sizeof(parts[i].type_guid)) {
487 printf("Wrong type guid format for partition %d\n",
488 i);
489 errno = -4;
490 goto err;
491 }
492 strncpy((char *)parts[i].type_guid, p, max_str_part);
493 free(val);
494 }
495 #endif
496 /* name */
497 val = extract_val(tok, "name");
498 if (!val) { /* name is mandatory */
499 errno = -4;
500 goto err;
501 }
502 if (extract_env(val, &p))
503 p = val;
504 if (strnlen(p, max_str_part) >= sizeof(parts[i].name)) {
505 errno = -4;
506 goto err;
507 }
508 strncpy((char *)parts[i].name, p, max_str_part);
509 free(val);
510
511 /* size */
512 val = extract_val(tok, "size");
513 if (!val) { /* 'size' is mandatory */
514 errno = -4;
515 goto err;
516 }
517 if (extract_env(val, &p))
518 p = val;
519 if ((strcmp(p, "-") == 0)) {
520 /* Let part efi module to auto extend the size */
521 parts[i].size = 0;
522 } else {
523 size_ll = ustrtoull(p, &p, 0);
524 parts[i].size = lldiv(size_ll, dev_desc->blksz);
525 }
526
527 free(val);
528
529 /* start address */
530 val = extract_val(tok, "start");
531 if (val) { /* start address is optional */
532 if (extract_env(val, &p))
533 p = val;
534 start_ll = ustrtoull(p, &p, 0);
535 parts[i].start = lldiv(start_ll, dev_desc->blksz);
536 free(val);
537 }
538
539 offset += parts[i].size + parts[i].start;
540
541 /* bootable */
542 if (found_key(tok, "bootable"))
543 parts[i].bootable = PART_BOOTABLE;
544 }
545
546 *parts_count = p_count;
547 *partitions = parts;
548 free(str);
549
550 return 0;
551 err:
552 free(str);
553 free(*str_disk_guid);
554 free(parts);
555
556 return errno;
557 }
558
gpt_default(struct blk_desc * blk_dev_desc,const char * str_part)559 static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part)
560 {
561 int ret;
562 char *str_disk_guid;
563 u8 part_count = 0;
564 struct disk_partition *partitions = NULL;
565
566 /* fill partitions */
567 ret = set_gpt_info(blk_dev_desc, str_part,
568 &str_disk_guid, &partitions, &part_count);
569 if (ret) {
570 if (ret == -1)
571 printf("No partition list provided\n");
572 if (ret == -2)
573 printf("Missing disk guid\n");
574 if ((ret == -3) || (ret == -4))
575 printf("Partition list incomplete\n");
576 return -1;
577 }
578
579 /* save partitions layout to disk */
580 ret = gpt_restore(blk_dev_desc, str_disk_guid, partitions, part_count);
581 free(str_disk_guid);
582 free(partitions);
583
584 return ret;
585 }
586
gpt_verify(struct blk_desc * blk_dev_desc,const char * str_part)587 static int gpt_verify(struct blk_desc *blk_dev_desc, const char *str_part)
588 {
589 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1,
590 blk_dev_desc->blksz);
591 struct disk_partition *partitions = NULL;
592 gpt_entry *gpt_pte = NULL;
593 char *str_disk_guid;
594 u8 part_count = 0;
595 int ret = 0;
596
597 /* fill partitions */
598 ret = set_gpt_info(blk_dev_desc, str_part,
599 &str_disk_guid, &partitions, &part_count);
600 if (ret) {
601 if (ret == -1) {
602 printf("No partition list provided - only basic check\n");
603 ret = gpt_verify_headers(blk_dev_desc, gpt_head,
604 &gpt_pte);
605 goto out;
606 }
607 if (ret == -2)
608 printf("Missing disk guid\n");
609 if ((ret == -3) || (ret == -4))
610 printf("Partition list incomplete\n");
611 return -1;
612 }
613
614 /* Check partition layout with provided pattern */
615 ret = gpt_verify_partitions(blk_dev_desc, partitions, part_count,
616 gpt_head, &gpt_pte);
617 free(str_disk_guid);
618 free(partitions);
619 out:
620 free(gpt_pte);
621 return ret;
622 }
623
do_disk_guid(struct blk_desc * dev_desc,char * const namestr)624 static int do_disk_guid(struct blk_desc *dev_desc, char * const namestr)
625 {
626 int ret;
627 char disk_guid[UUID_STR_LEN + 1];
628
629 ret = get_disk_guid(dev_desc, disk_guid);
630 if (ret < 0)
631 return CMD_RET_FAILURE;
632
633 if (namestr)
634 env_set(namestr, disk_guid);
635 else
636 printf("%s\n", disk_guid);
637
638 return ret;
639 }
640
641 #ifdef CONFIG_CMD_GPT_RENAME
do_rename_gpt_parts(struct blk_desc * dev_desc,char * subcomm,char * name1,char * name2)642 static int do_rename_gpt_parts(struct blk_desc *dev_desc, char *subcomm,
643 char *name1, char *name2)
644 {
645 struct list_head *pos;
646 struct disk_part *curr;
647 struct disk_partition *new_partitions = NULL;
648 char disk_guid[UUID_STR_LEN + 1];
649 char *partitions_list, *str_disk_guid = NULL;
650 u8 part_count = 0;
651 int partlistlen, ret, numparts = 0, partnum, i = 1, ctr1 = 0, ctr2 = 0;
652
653 if ((subcomm == NULL) || (name1 == NULL) || (name2 == NULL) ||
654 (strcmp(subcomm, "swap") && (strcmp(subcomm, "rename"))))
655 return -EINVAL;
656
657 ret = get_disk_guid(dev_desc, disk_guid);
658 if (ret < 0)
659 return ret;
660 /*
661 * Allocates disk_partitions, requiring matching call to del_gpt_info()
662 * if successful.
663 */
664 numparts = get_gpt_info(dev_desc);
665 if (numparts <= 0)
666 return numparts ? numparts : -ENODEV;
667
668 partlistlen = calc_parts_list_len(numparts);
669 partitions_list = malloc(partlistlen);
670 if (!partitions_list) {
671 del_gpt_info();
672 return -ENOMEM;
673 }
674 memset(partitions_list, '\0', partlistlen);
675
676 ret = create_gpt_partitions_list(numparts, disk_guid, partitions_list);
677 if (ret < 0) {
678 free(partitions_list);
679 return ret;
680 }
681 /*
682 * Uncomment the following line to print a string that 'gpt write'
683 * or 'gpt verify' will accept as input.
684 */
685 debug("OLD partitions_list is %s with %u chars\n", partitions_list,
686 (unsigned)strlen(partitions_list));
687
688 /* set_gpt_info allocates new_partitions and str_disk_guid */
689 ret = set_gpt_info(dev_desc, partitions_list, &str_disk_guid,
690 &new_partitions, &part_count);
691 if (ret < 0)
692 goto out;
693
694 if (!strcmp(subcomm, "swap")) {
695 if ((strlen(name1) > PART_NAME_LEN) || (strlen(name2) > PART_NAME_LEN)) {
696 printf("Names longer than %d characters are truncated.\n", PART_NAME_LEN);
697 ret = -EINVAL;
698 goto out;
699 }
700 list_for_each(pos, &disk_partitions) {
701 curr = list_entry(pos, struct disk_part, list);
702 if (!strcmp((char *)curr->gpt_part_info.name, name1)) {
703 strcpy((char *)curr->gpt_part_info.name, name2);
704 ctr1++;
705 } else if (!strcmp((char *)curr->gpt_part_info.name, name2)) {
706 strcpy((char *)curr->gpt_part_info.name, name1);
707 ctr2++;
708 }
709 }
710 if ((ctr1 + ctr2 < 2) || (ctr1 != ctr2)) {
711 printf("Cannot swap partition names except in pairs.\n");
712 ret = -EINVAL;
713 goto out;
714 }
715 } else { /* rename */
716 if (strlen(name2) > PART_NAME_LEN) {
717 printf("Names longer than %d characters are truncated.\n", PART_NAME_LEN);
718 ret = -EINVAL;
719 goto out;
720 }
721 partnum = (int)simple_strtol(name1, NULL, 10);
722 if ((partnum < 0) || (partnum > numparts)) {
723 printf("Illegal partition number %s\n", name1);
724 ret = -EINVAL;
725 goto out;
726 }
727 ret = part_get_info(dev_desc, partnum, new_partitions);
728 if (ret < 0)
729 goto out;
730
731 /* U-Boot partition numbering starts at 1 */
732 list_for_each(pos, &disk_partitions) {
733 curr = list_entry(pos, struct disk_part, list);
734 if (i == partnum) {
735 strcpy((char *)curr->gpt_part_info.name, name2);
736 break;
737 }
738 i++;
739 }
740 }
741
742 ret = create_gpt_partitions_list(numparts, disk_guid, partitions_list);
743 if (ret < 0)
744 goto out;
745 debug("NEW partitions_list is %s with %u chars\n", partitions_list,
746 (unsigned)strlen(partitions_list));
747
748 ret = set_gpt_info(dev_desc, partitions_list, &str_disk_guid,
749 &new_partitions, &part_count);
750 /*
751 * Even though valid pointers are here passed into set_gpt_info(),
752 * it mallocs again, and there's no way to tell which failed.
753 */
754 if (ret < 0)
755 goto out;
756
757 debug("Writing new partition table\n");
758 ret = gpt_restore(dev_desc, disk_guid, new_partitions, numparts);
759 if (ret < 0) {
760 printf("Writing new partition table failed\n");
761 goto out;
762 }
763
764 debug("Reading back new partition table\n");
765 /*
766 * Empty the existing disk_partitions list, as otherwise the memory in
767 * the original list is unreachable.
768 */
769 del_gpt_info();
770 numparts = get_gpt_info(dev_desc);
771 if (numparts <= 0) {
772 ret = numparts ? numparts : -ENODEV;
773 goto out;
774 }
775 printf("new partition table with %d partitions is:\n", numparts);
776 print_gpt_info();
777 out:
778 del_gpt_info();
779 #ifdef CONFIG_RANDOM_UUID
780 free(str_disk_guid);
781 #endif
782 free(new_partitions);
783 free(partitions_list);
784 return ret;
785 }
786 #endif
787
788 /**
789 * do_gpt(): Perform GPT operations
790 *
791 * @param cmdtp - command name
792 * @param flag
793 * @param argc
794 * @param argv
795 *
796 * @return zero on success; otherwise error
797 */
do_gpt(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])798 static int do_gpt(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
799 {
800 int ret = CMD_RET_SUCCESS;
801 int dev = 0;
802 char *ep;
803 struct blk_desc *blk_dev_desc = NULL;
804
805 #ifndef CONFIG_CMD_GPT_RENAME
806 if (argc < 4 || argc > 5)
807 #else
808 if (argc < 4 || argc > 6)
809 #endif
810 return CMD_RET_USAGE;
811
812 dev = (int)simple_strtoul(argv[3], &ep, 10);
813 if (!ep || ep[0] != '\0') {
814 printf("'%s' is not a number\n", argv[3]);
815 return CMD_RET_USAGE;
816 }
817 blk_dev_desc = blk_get_dev(argv[2], dev);
818 if (!blk_dev_desc) {
819 printf("%s: %s dev %d NOT available\n",
820 __func__, argv[2], dev);
821 return CMD_RET_FAILURE;
822 }
823
824 if ((strcmp(argv[1], "write") == 0) && (argc == 5)) {
825 printf("Writing GPT: ");
826 ret = gpt_default(blk_dev_desc, argv[4]);
827 } else if ((strcmp(argv[1], "verify") == 0)) {
828 ret = gpt_verify(blk_dev_desc, argv[4]);
829 printf("Verify GPT: ");
830 } else if (strcmp(argv[1], "guid") == 0) {
831 ret = do_disk_guid(blk_dev_desc, argv[4]);
832 #ifdef CONFIG_CMD_GPT_RENAME
833 } else if (strcmp(argv[1], "read") == 0) {
834 ret = do_get_gpt_info(blk_dev_desc);
835 } else if ((strcmp(argv[1], "swap") == 0) ||
836 (strcmp(argv[1], "rename") == 0)) {
837 ret = do_rename_gpt_parts(blk_dev_desc, argv[1], argv[4], argv[5]);
838 #endif
839 } else {
840 return CMD_RET_USAGE;
841 }
842
843 if (ret) {
844 printf("error!\n");
845 return CMD_RET_FAILURE;
846 }
847
848 printf("success!\n");
849 return CMD_RET_SUCCESS;
850 }
851
852 U_BOOT_CMD(gpt, CONFIG_SYS_MAXARGS, 1, do_gpt,
853 "GUID Partition Table",
854 "<command> <interface> <dev> <partitions_list>\n"
855 " - GUID partition table restoration and validity check\n"
856 " Restore or verify GPT information on a device connected\n"
857 " to interface\n"
858 " Example usage:\n"
859 " gpt write mmc 0 $partitions\n"
860 " gpt verify mmc 0 $partitions\n"
861 " gpt guid <interface> <dev>\n"
862 " - print disk GUID\n"
863 " gpt guid <interface> <dev> <varname>\n"
864 " - set environment variable to disk GUID\n"
865 " Example usage:\n"
866 " gpt guid mmc 0\n"
867 " gpt guid mmc 0 varname\n"
868 #ifdef CONFIG_CMD_GPT_RENAME
869 "gpt partition renaming commands:\n"
870 " gpt read <interface> <dev>\n"
871 " - read GPT into a data structure for manipulation\n"
872 " gpt swap <interface> <dev> <name1> <name2>\n"
873 " - change all partitions named name1 to name2\n"
874 " and vice-versa\n"
875 " gpt rename <interface> <dev> <part> <name>\n"
876 " - rename the specified partition\n"
877 " Example usage:\n"
878 " gpt swap mmc 0 foo bar\n"
879 " gpt rename mmc 0 3 foo\n"
880 #endif
881 );
882