leandrof/u-boot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

part_efi: move uuid<->string conversion functions into lib/uuid.c

Browse Source 
This commit introduces cleanup for uuid library.
Changes:
- move uuid<->string conversion functions into lib/uuid.c so they can be
  used by code outside part_efi.c.
- rename uuid_string() to uuid_bin_to_str() for consistency with existing
  uuid_str_to_bin()
- add an error return code to uuid_str_to_bin()
- update existing code to the new library functions.

Signed-off-by: Przemyslaw Marczak <p.marczak@samsung.com>
Cc: Stephen Warren <swarren@nvidia.com>
Cc: Lukasz Majewski <l.majewski@samsung.com>
Cc: trini@ti.com
This commit is contained in:
Przemyslaw Marczak 2014-04-02 10:20:02 +02:00 committed by Tom Rini
parent 3f62971162
commit a96a0e6153
4 changed files with 68 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
disk/part_efi.c
View File

@ -63,26 +63,6 @@ static char *print_efiname(gpt_entry *pte)
return name;
}
static void uuid_string(unsigned char *uuid, char *str)
{
static const u8 le[16] = {3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11,
12, 13, 14, 15};
int i;
for (i = 0; i < 16; i++) {
sprintf(str, "%02x", uuid[le[i]]);
str += 2;
switch (i) {
case 3:
case 5:
case 7:
case 9:
*str++ = '-';
break;
}
}
}
static efi_guid_t system_guid = PARTITION_SYSTEM_GUID;
static inline int is_bootable(gpt_entry *p)
@ -103,6 +83,7 @@ void print_part_efi(block_dev_desc_t * dev_desc)
gpt_entry *gpt_pte = NULL;
int i = 0;
char uuid[37];
unsigned char *uuid_bin;
if (!dev_desc) {
printf("%s: Invalid Argument(s)\n", __func__);
@ -132,9 +113,11 @@ void print_part_efi(block_dev_desc_t * dev_desc)
le64_to_cpu(gpt_pte[i].ending_lba),
print_efiname(&gpt_pte[i]));
printf("\tattrs:\t0x%016llx\n", gpt_pte[i].attributes.raw);
uuid_string(gpt_pte[i].partition_type_guid.b, uuid);
uuid_bin = (unsigned char *)gpt_pte[i].partition_type_guid.b;
uuid_bin_to_str(uuid_bin, uuid);
printf("\ttype:\t%s\n", uuid);
uuid_string(gpt_pte[i].unique_partition_guid.b, uuid);
uuid_bin = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
uuid_bin_to_str(uuid_bin, uuid);
printf("\tuuid:\t%s\n", uuid);
}
@ -182,7 +165,7 @@ int get_partition_info_efi(block_dev_desc_t * dev_desc, int part,
sprintf((char *)info->type, "U-Boot");
info->bootable = is_bootable(&gpt_pte[part - 1]);
#ifdef CONFIG_PARTITION_UUIDS
uuid_string(gpt_pte[part - 1].unique_partition_guid.b, info->uuid);
uuid_bin_to_str(gpt_pte[part - 1].unique_partition_guid.b, info->uuid);
#endif
debug("%s: start 0x" LBAF ", size 0x" LBAF ", name %s", __func__,
@ -237,60 +220,6 @@ static int set_protective_mbr(block_dev_desc_t *dev_desc)
return 0;
}
/**
* string_uuid(); Convert UUID stored as string to bytes
*
* @param uuid - UUID represented as string
* @param dst - GUID buffer
*
* @return return 0 on successful conversion
*/
static int string_uuid(char *uuid, u8 *dst)
{
efi_guid_t guid;
u16 b, c, d;
u64 e;
u32 a;
u8 *p;
u8 i;
const u8 uuid_str_len = 36;
/* The UUID is written in text: */
/* 1 9 14 19 24 */
/* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx */
debug("%s: uuid: %s\n", __func__, uuid);
if (strlen(uuid) != uuid_str_len)
return -1;
for (i = 0; i < uuid_str_len; i++) {
if ((i == 8) || (i == 13) || (i == 18) || (i == 23)) {
if (uuid[i] != '-')
return -1;
} else {
if (!isxdigit(uuid[i]))
return -1;
}
}
a = (u32)simple_strtoul(uuid, NULL, 16);
b = (u16)simple_strtoul(uuid + 9, NULL, 16);
c = (u16)simple_strtoul(uuid + 14, NULL, 16);
d = (u16)simple_strtoul(uuid + 19, NULL, 16);
e = (u64)simple_strtoull(uuid + 24, NULL, 16);
p = (u8 *) &e;
guid = EFI_GUID(a, b, c, d >> 8, d & 0xFF,
*(p + 5), *(p + 4), *(p + 3),
*(p + 2), *(p + 1) , *p);
memcpy(dst, guid.b, sizeof(efi_guid_t));
return 0;
}
int write_gpt_table(block_dev_desc_t *dev_desc,
gpt_header *gpt_h, gpt_entry *gpt_e)
{
@ -358,6 +287,7 @@ int gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e,
size_t efiname_len, dosname_len;
#ifdef CONFIG_PARTITION_UUIDS
char *str_uuid;
unsigned char *bin_uuid;
#endif
for (i = 0; i < parts; i++) {
@ -391,7 +321,9 @@ int gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e,
#ifdef CONFIG_PARTITION_UUIDS
str_uuid = partitions[i].uuid;
if (string_uuid(str_uuid, gpt_e[i].unique_partition_guid.b)) {
bin_uuid = gpt_e[i].unique_partition_guid.b;
if (uuid_str_to_bin(str_uuid, bin_uuid)) {
printf("Partition no. %d: invalid guid: %s\n",
i, str_uuid);
return -1;
@ -438,7 +370,7 @@ int gpt_fill_header(block_dev_desc_t *dev_desc, gpt_header *gpt_h,
gpt_h->header_crc32 = 0;
gpt_h->partition_entry_array_crc32 = 0;
if (string_uuid(str_guid, gpt_h->disk_guid.b))
if (uuid_str_to_bin(str_guid, gpt_h->disk_guid.b))
return -1;
return 0;

3
include/common.h
View File

@ -822,7 +822,8 @@ void udelay (unsigned long);
void mdelay(unsigned long);
/* lib/uuid.c */
void uuid_str_to_bin(const char *uuid, unsigned char *out);
void uuid_bin_to_str(unsigned char *uuid, char *str);
int uuid_str_to_bin(char *uuid, unsigned char *out);
int uuid_str_valid(const char *uuid);
/* lib/vsprintf.c */

1
lib/Makefile
View File

@ -61,6 +61,7 @@ obj-y += string.o
obj-y += time.o
obj-$(CONFIG_TRACE) += trace.o
obj-$(CONFIG_BOOTP_PXE) += uuid.o
obj-$(CONFIG_PARTITION_UUIDS) += uuid.o
obj-y += vsprintf.o
obj-$(CONFIG_LIB_RAND) += rand.o

61
lib/uuid.c
View File

@ -5,18 +5,40 @@
*/
#include <linux/ctype.h>
#include "common.h"
#include <errno.h>
#include <common.h>
#define UUID_STR_LEN 36
/*
* This is what a UUID string looks like.
* UUID - Universally Unique IDentifier - 128 bits unique number.
* There are 5 versions and one variant of UUID defined by RFC4122
* specification. Depends on version uuid number base on a time,
* host name, MAC address or random data.
*
* x is a hexadecimal character. fields are separated by '-'s. When converting
* to a binary UUID, le means the field should be converted to little endian,
* and be means it should be converted to big endian.
* UUID binary format (16 bytes):
*
* 4B-2B-2B-2B-6B (big endian - network byte order)
*
* UUID string is 36 length of characters (36 bytes):
*
* 0 9 14 19 24
* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
* be be be be be
*
* where x is a hexadecimal character. Fields are separated by '-'s.
* When converting to a binary UUID, le means the field should be converted
* to little endian and be means it should be converted to big endian.
*
* UUID is also used as GUID (Globally Unique Identifier) with the same binary
* format but it differs in string format like below.
*
* GUID:
* 0 9 14 19 24
* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
* le le le be be
*
* GUID is used e.g. in GPT (GUID Partition Table) as a partiions unique id.
*/
int uuid_str_valid(const char *uuid)
@ -43,14 +65,17 @@ int uuid_str_valid(const char *uuid)
return 1;
}
void uuid_str_to_bin(const char *uuid, unsigned char *out)
int uuid_str_to_bin(char *uuid, unsigned char *out)
{
uint16_t tmp16;
uint32_t tmp32;
uint64_t tmp64;
if (!uuid || !out)
return;
return -EINVAL;
if (strlen(uuid) != UUID_STR_LEN)
return -EINVAL;
tmp32 = cpu_to_le32(simple_strtoul(uuid, NULL, 16));
memcpy(out, &tmp32, 4);
@ -66,4 +91,26 @@ void uuid_str_to_bin(const char *uuid, unsigned char *out)
tmp64 = cpu_to_be64(simple_strtoull(uuid + 24, NULL, 16));
memcpy(out + 10, (char *)&tmp64 + 2, 6);
return 0;
}
void uuid_bin_to_str(unsigned char *uuid, char *str)
{
static const u8 le[16] = {3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11,
12, 13, 14, 15};
int i;
for (i = 0; i < 16; i++) {
sprintf(str, "%02x", uuid[le[i]]);
str += 2;
switch (i) {
case 3:
case 5:
case 7:
case 9:
*str++ = '-';
break;
}
}
}