Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f9727a17 authored by Christoph Hellwig's avatar Christoph Hellwig
Browse files

uuid: rename uuid types 



Our "little endian" UUID really is a Wintel GUID, so rename it and its
helpers such (guid_t).  The big endian UUID is the only true one, so
give it the name uuid_t.  The uuid_le and uuid_be names are retained for
now, but will hopefully go away soon.  The exception to that are the _cmp
helpers that will be replaced by better primitives ASAP and thus don't
get the new names.

Also the _to_bin helpers are named to match the better named uuid_parse
routine in userspace.

Also remove the existing typedef in XFS that's now been superceeded by
the generic type name.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
[andy: also update the UUID_LE/UUID_BE macros including fallout]
Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Reviewed-by: default avatarAmir Goldstein <amir73il@gmail.com>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
parent 60927bc3

fs/xfs/xfs_linux.h

+0 −2
Original line number Diff line number Diff line
@@ -39,8 +39,6 @@ typedef __s64 xfs_daddr_t; /* <disk address> type */ 
typedef __u32			xfs_dev_t;

typedef __u32			xfs_nlink_t;



typedef uuid_be			uuid_t;



#include "xfs_types.h"



#include "kmem.h"

include/linux/uuid.h

+32 −23
Original line number Diff line number Diff line
@@ -20,46 +20,55 @@ 


typedef struct {

	__u8 b[16];

} uuid_be;

} uuid_t;



#define UUID_BE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)		\

((uuid_be)								\

#define UUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)			\

((uuid_t)								\

{{ ((a) >> 24) & 0xff, ((a) >> 16) & 0xff, ((a) >> 8) & 0xff, (a) & 0xff, \

   ((b) >> 8) & 0xff, (b) & 0xff,					\

   ((c) >> 8) & 0xff, (c) & 0xff,					\

   (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})



#define NULL_UUID_BE							\

	UUID_BE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00,	\

		0x00, 0x00, 0x00, 0x00)



/*

 * The length of a UUID string ("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")

 * not including trailing NUL.

 */

#define	UUID_STRING_LEN		36



static inline int uuid_le_cmp(const uuid_le u1, const uuid_le u2)

{

	return memcmp(&u1, &u2, sizeof(uuid_le));

}



static inline int uuid_be_cmp(const uuid_be u1, const uuid_be u2)

{

	return memcmp(&u1, &u2, sizeof(uuid_be));

}



void generate_random_uuid(unsigned char uuid[16]);



extern void uuid_le_gen(uuid_le *u);

extern void uuid_be_gen(uuid_be *u);

extern void guid_gen(guid_t *u);

extern void uuid_gen(uuid_t *u);



bool __must_check uuid_is_valid(const char *uuid);



extern const u8 uuid_le_index[16];

extern const u8 uuid_be_index[16];

extern const u8 guid_index[16];

extern const u8 uuid_index[16];



int guid_parse(const char *uuid, guid_t *u);

int uuid_parse(const char *uuid, uuid_t *u);



int uuid_le_to_bin(const char *uuid, uuid_le *u);

int uuid_be_to_bin(const char *uuid, uuid_be *u);

/* backwards compatibility, don't use in new code */

typedef uuid_t uuid_be;

#define UUID_BE(a, _b, c, d0, d1, d2, d3, d4, d5, d6, d7) \

	UUID_INIT(a, _b, c, d0, d1, d2, d3, d4, d5, d6, d7)

#define NULL_UUID_BE 							\

	UUID_BE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00,	\

	     0x00, 0x00, 0x00, 0x00)



#define uuid_le_gen(u)		guid_gen(u)

#define uuid_be_gen(u)		uuid_gen(u)

#define uuid_le_to_bin(guid, u)	guid_parse(guid, u)

#define uuid_be_to_bin(uuid, u)	uuid_parse(uuid, u)



static inline int uuid_le_cmp(const guid_t u1, const guid_t u2)

{

	return memcmp(&u1, &u2, sizeof(guid_t));

}



static inline int uuid_be_cmp(const uuid_t u1, const uuid_t u2)

{

	return memcmp(&u1, &u2, sizeof(uuid_t));

}



#endif

include/uapi/linux/uuid.h

+8 −4
Original line number Diff line number Diff line
@@ -22,15 +22,19 @@ 


typedef struct {

	__u8 b[16];

} uuid_le;

} guid_t;



#define UUID_LE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)		\

((uuid_le)								\

#define GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)			\

((guid_t)								\

{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \

   (b) & 0xff, ((b) >> 8) & 0xff,					\

   (c) & 0xff, ((c) >> 8) & 0xff,					\

   (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})



/* backwards compatibility, don't use in new code */

typedef guid_t uuid_le;

#define UUID_LE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)		\

	GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)

#define NULL_UUID_LE							\

	UUID_LE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00,	\

	     0x00, 0x00, 0x00, 0x00)

lib/test_uuid.c

+16 −16
Original line number Diff line number Diff line
@@ -11,25 +11,25 @@ 


struct test_uuid_data {

	const char *uuid;

	uuid_le le;

	uuid_be be;

	guid_t le;

	uuid_t be;

};



static const struct test_uuid_data test_uuid_test_data[] = {

	{

		.uuid = "c33f4995-3701-450e-9fbf-206a2e98e576",

		.le = UUID_LE(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),

		.be = UUID_BE(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),

		.le = GUID_INIT(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),

		.be = UUID_INIT(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),

	},

	{

		.uuid = "64b4371c-77c1-48f9-8221-29f054fc023b",

		.le = UUID_LE(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),

		.be = UUID_BE(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),

		.le = GUID_INIT(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),

		.be = UUID_INIT(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),

	},

	{

		.uuid = "0cb4ddff-a545-4401-9d06-688af53e7f84",

		.le = UUID_LE(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),

		.be = UUID_BE(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),

		.le = GUID_INIT(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),

		.be = UUID_INIT(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),

	},

};
@@ -61,13 +61,13 @@ static void __init test_uuid_failed(const char *prefix, bool wrong, bool be, 


static void __init test_uuid_test(const struct test_uuid_data *data)

{

	uuid_le le;

	uuid_be be;

	guid_t le;

	uuid_t be;

	char buf[48];



	/* LE */

	total_tests++;

	if (uuid_le_to_bin(data->uuid, &le))

	if (guid_parse(data->uuid, &le))

		test_uuid_failed("conversion", false, false, data->uuid, NULL);



	total_tests++;
@@ -78,7 +78,7 @@ static void __init test_uuid_test(const struct test_uuid_data *data) 


	/* BE */

	total_tests++;

	if (uuid_be_to_bin(data->uuid, &be))

	if (uuid_parse(data->uuid, &be))

		test_uuid_failed("conversion", false, true, data->uuid, NULL);



	total_tests++;
@@ -90,17 +90,17 @@ static void __init test_uuid_test(const struct test_uuid_data *data) 


static void __init test_uuid_wrong(const char *data)

{

	uuid_le le;

	uuid_be be;

	guid_t le;

	uuid_t be;



	/* LE */

	total_tests++;

	if (!uuid_le_to_bin(data, &le))

	if (!guid_parse(data, &le))

		test_uuid_failed("negative", true, false, data, NULL);



	/* BE */

	total_tests++;

	if (!uuid_be_to_bin(data, &be))

	if (!uuid_parse(data, &be))

		test_uuid_failed("negative", true, true, data, NULL);

}

lib/uuid.c

+15 −15
Original line number Diff line number Diff line
@@ -21,10 +21,10 @@ 
#include <linux/uuid.h>

#include <linux/random.h>



const u8 uuid_le_index[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};

EXPORT_SYMBOL(uuid_le_index);

const u8 uuid_be_index[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

EXPORT_SYMBOL(uuid_be_index);

const u8 guid_index[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};

EXPORT_SYMBOL(guid_index);

const u8 uuid_index[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

EXPORT_SYMBOL(uuid_index);



/***************************************************************

 * Random UUID interface
@@ -53,21 +53,21 @@ static void __uuid_gen_common(__u8 b[16]) 
	b[8] = (b[8] & 0x3F) | 0x80;

}



void uuid_le_gen(uuid_le *lu)

void guid_gen(guid_t *lu)

{

	__uuid_gen_common(lu->b);

	/* version 4 : random generation */

	lu->b[7] = (lu->b[7] & 0x0F) | 0x40;

}

EXPORT_SYMBOL_GPL(uuid_le_gen);

EXPORT_SYMBOL_GPL(guid_gen);



void uuid_be_gen(uuid_be *bu)

void uuid_gen(uuid_t *bu)

{

	__uuid_gen_common(bu->b);

	/* version 4 : random generation */

	bu->b[6] = (bu->b[6] & 0x0F) | 0x40;

}

EXPORT_SYMBOL_GPL(uuid_be_gen);

EXPORT_SYMBOL_GPL(uuid_gen);



/**

  * uuid_is_valid - checks if UUID string valid
@@ -97,7 +97,7 @@ bool uuid_is_valid(const char *uuid) 
}

EXPORT_SYMBOL(uuid_is_valid);



static int __uuid_to_bin(const char *uuid, __u8 b[16], const u8 ei[16])

static int __uuid_parse(const char *uuid, __u8 b[16], const u8 ei[16])

{

	static const u8 si[16] = {0,2,4,6,9,11,14,16,19,21,24,26,28,30,32,34};

	unsigned int i;
@@ -115,14 +115,14 @@ static int __uuid_to_bin(const char *uuid, __u8 b[16], const u8 ei[16]) 
	return 0;

}



int uuid_le_to_bin(const char *uuid, uuid_le *u)

int guid_parse(const char *uuid, guid_t *u)

{

	return __uuid_to_bin(uuid, u->b, uuid_le_index);

	return __uuid_parse(uuid, u->b, guid_index);

}

EXPORT_SYMBOL(uuid_le_to_bin);

EXPORT_SYMBOL(guid_parse);



int uuid_be_to_bin(const char *uuid, uuid_be *u)

int uuid_parse(const char *uuid, uuid_t *u)

{

	return __uuid_to_bin(uuid, u->b, uuid_be_index);

	return __uuid_parse(uuid, u->b, uuid_index);

}

EXPORT_SYMBOL(uuid_be_to_bin);
 
EXPORT_SYMBOL(uuid_parse);