]>
git.ipfire.org Git - people/ms/u-boot.git/blob - cmd/gpt.c
2 * cmd_gpt.c -- GPT (GUID Partition Table) handling command
5 * Lukasz Majewski <l.majewski@majess.pl>
7 * Copyright (C) 2012 Samsung Electronics
8 * author: Lukasz Majewski <l.majewski@samsung.com>
9 * author: Piotr Wilczek <p.wilczek@samsung.com>
11 * SPDX-License-Identifier: GPL-2.0+
19 #include <linux/ctype.h>
23 #ifndef CONFIG_PARTITION_UUIDS
24 #error CONFIG_PARTITION_UUIDS must be enabled for CONFIG_CMD_GPT to be enabled
28 * extract_env(): Expand env name from string format '&{env_name}'
29 * and return pointer to the env (if the env is set)
31 * @param str - pointer to string
32 * @param env - pointer to pointer to extracted env
34 * @return - zero on successful expand and env is set
36 static int extract_env(const char *str
, char **env
)
40 #ifdef CONFIG_RANDOM_UUID
41 char uuid_str
[UUID_STR_LEN
+ 1];
44 if (!str
|| strlen(str
) < 4)
47 if (!((strncmp(str
, "${", 2) == 0) && (str
[strlen(str
) - 1] == '}')))
54 memset(s
+ strlen(s
) - 1, '\0', 1);
55 memmove(s
, s
+ 2, strlen(s
) - 1);
59 #ifdef CONFIG_RANDOM_UUID
60 debug("%s unset. ", str
);
61 gen_rand_uuid_str(uuid_str
, UUID_STR_FORMAT_STD
);
66 debug("Set to random.\n");
69 debug("Can't get random UUID.\n");
72 debug("%s unset.\n", str
);
75 debug("%s get from environment.\n", str
);
86 * extract_val(): Extract value from a key=value pair list (comma separated).
87 * Only value for the given key is returend.
88 * Function allocates memory for the value, remember to free!
90 * @param str - pointer to string with key=values pairs
91 * @param key - pointer to the key to search for
93 * @return - pointer to allocated string with the value
95 static char *extract_val(const char *str
, const char *key
)
101 strcopy
= strdup(str
);
113 if (strcmp(k
, key
) == 0) {
125 * found_key(): Found key without value in parameter list (comma separated).
127 * @param str - pointer to string with key
128 * @param key - pointer to the key to search for
130 * @return - true on found key
132 static bool found_key(const char *str
, const char *key
)
138 strcopy
= strdup(str
);
147 if (strcmp(k
, key
) == 0) {
159 * set_gpt_info(): Fill partition information from string
160 * function allocates memory, remember to free!
162 * @param dev_desc - pointer block device descriptor
163 * @param str_part - pointer to string with partition information
164 * @param str_disk_guid - pointer to pointer to allocated string with disk guid
165 * @param partitions - pointer to pointer to allocated partitions array
166 * @param parts_count - number of partitions
168 * @return - zero on success, otherwise error
171 static int set_gpt_info(struct blk_desc
*dev_desc
,
172 const char *str_part
,
173 char **str_disk_guid
,
174 disk_partition_t
**partitions
,
181 disk_partition_t
*parts
;
183 uint64_t size_ll
, start_ll
;
186 debug("%s: lba num: 0x%x %d\n", __func__
,
187 (unsigned int)dev_desc
->lba
, (unsigned int)dev_desc
->lba
);
189 if (str_part
== NULL
)
192 str
= strdup(str_part
);
194 /* extract disk guid */
196 val
= extract_val(str
, "uuid_disk");
198 #ifdef CONFIG_RANDOM_UUID
199 *str_disk_guid
= malloc(UUID_STR_LEN
+ 1);
200 gen_rand_uuid_str(*str_disk_guid
, UUID_STR_FORMAT_STD
);
206 val
= strsep(&val
, ";");
207 if (extract_env(val
, &p
))
209 *str_disk_guid
= strdup(p
);
211 /* Move s to first partition */
221 /* calculate expected number of partitions */
229 /* allocate memory for partitions */
230 parts
= calloc(sizeof(disk_partition_t
), p_count
);
232 /* retrieve partitions data from string */
233 for (i
= 0; i
< p_count
; i
++) {
234 tok
= strsep(&s
, ";");
240 val
= extract_val(tok
, "uuid");
242 /* 'uuid' is optional if random uuid's are enabled */
243 #ifdef CONFIG_RANDOM_UUID
244 gen_rand_uuid_str(parts
[i
].uuid
, UUID_STR_FORMAT_STD
);
250 if (extract_env(val
, &p
))
252 if (strlen(p
) >= sizeof(parts
[i
].uuid
)) {
253 printf("Wrong uuid format for partition %d\n", i
);
257 strcpy((char *)parts
[i
].uuid
, p
);
260 #ifdef CONFIG_PARTITION_TYPE_GUID
262 val
= extract_val(tok
, "type");
264 /* 'type' is optional */
265 if (extract_env(val
, &p
))
267 if (strlen(p
) >= sizeof(parts
[i
].type_guid
)) {
268 printf("Wrong type guid format for partition %d\n",
273 strcpy((char *)parts
[i
].type_guid
, p
);
278 val
= extract_val(tok
, "name");
279 if (!val
) { /* name is mandatory */
283 if (extract_env(val
, &p
))
285 if (strlen(p
) >= sizeof(parts
[i
].name
)) {
289 strcpy((char *)parts
[i
].name
, p
);
293 val
= extract_val(tok
, "size");
294 if (!val
) { /* 'size' is mandatory */
298 if (extract_env(val
, &p
))
300 if ((strcmp(p
, "-") == 0)) {
301 /* remove first usable lba and last block */
302 parts
[i
].size
= dev_desc
->lba
- 34 - 1 - offset
;
304 size_ll
= ustrtoull(p
, &p
, 0);
305 parts
[i
].size
= lldiv(size_ll
, dev_desc
->blksz
);
311 val
= extract_val(tok
, "start");
312 if (val
) { /* start address is optional */
313 if (extract_env(val
, &p
))
315 start_ll
= ustrtoull(p
, &p
, 0);
316 parts
[i
].start
= lldiv(start_ll
, dev_desc
->blksz
);
320 offset
+= parts
[i
].size
+ parts
[i
].start
;
323 if (found_key(tok
, "bootable"))
324 parts
[i
].bootable
= 1;
327 *parts_count
= p_count
;
334 free(*str_disk_guid
);
340 static int gpt_default(struct blk_desc
*blk_dev_desc
, const char *str_part
)
345 disk_partition_t
*partitions
= NULL
;
347 /* fill partitions */
348 ret
= set_gpt_info(blk_dev_desc
, str_part
,
349 &str_disk_guid
, &partitions
, &part_count
);
352 printf("No partition list provided\n");
354 printf("Missing disk guid\n");
355 if ((ret
== -3) || (ret
== -4))
356 printf("Partition list incomplete\n");
360 /* save partitions layout to disk */
361 ret
= gpt_restore(blk_dev_desc
, str_disk_guid
, partitions
, part_count
);
368 static int gpt_verify(struct blk_desc
*blk_dev_desc
, const char *str_part
)
370 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header
, gpt_head
, 1,
371 blk_dev_desc
->blksz
);
372 disk_partition_t
*partitions
= NULL
;
373 gpt_entry
*gpt_pte
= NULL
;
378 /* fill partitions */
379 ret
= set_gpt_info(blk_dev_desc
, str_part
,
380 &str_disk_guid
, &partitions
, &part_count
);
383 printf("No partition list provided - only basic check\n");
384 ret
= gpt_verify_headers(blk_dev_desc
, gpt_head
,
389 printf("Missing disk guid\n");
390 if ((ret
== -3) || (ret
== -4))
391 printf("Partition list incomplete\n");
395 /* Check partition layout with provided pattern */
396 ret
= gpt_verify_partitions(blk_dev_desc
, partitions
, part_count
,
406 * do_gpt(): Perform GPT operations
408 * @param cmdtp - command name
413 * @return zero on success; otherwise error
415 static int do_gpt(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
417 int ret
= CMD_RET_SUCCESS
;
420 struct blk_desc
*blk_dev_desc
= NULL
;
422 if (argc
< 4 || argc
> 5)
423 return CMD_RET_USAGE
;
425 dev
= (int)simple_strtoul(argv
[3], &ep
, 10);
426 if (!ep
|| ep
[0] != '\0') {
427 printf("'%s' is not a number\n", argv
[3]);
428 return CMD_RET_USAGE
;
430 blk_dev_desc
= blk_get_dev(argv
[2], dev
);
432 printf("%s: %s dev %d NOT available\n",
433 __func__
, argv
[2], dev
);
434 return CMD_RET_FAILURE
;
437 if ((strcmp(argv
[1], "write") == 0) && (argc
== 5)) {
438 printf("Writing GPT: ");
439 ret
= gpt_default(blk_dev_desc
, argv
[4]);
440 } else if ((strcmp(argv
[1], "verify") == 0)) {
441 ret
= gpt_verify(blk_dev_desc
, argv
[4]);
442 printf("Verify GPT: ");
444 return CMD_RET_USAGE
;
449 return CMD_RET_FAILURE
;
452 printf("success!\n");
453 return CMD_RET_SUCCESS
;
456 U_BOOT_CMD(gpt
, CONFIG_SYS_MAXARGS
, 1, do_gpt
,
457 "GUID Partition Table",
458 "<command> <interface> <dev> <partitions_list>\n"
459 " - GUID partition table restoration and validity check\n"
460 " Restore or verify GPT information on a device connected\n"
463 " gpt write mmc 0 $partitions\n"
464 " gpt verify mmc 0 $partitions\n"