History

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: Christoph Hellwig <hch@lst.de> [andy: also update the UUID_LE/UUID_BE macros including fallout] Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Reviewed-by: Amir Goldstein <amir73il@gmail.com> Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com> Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>

Christoph Hellwig committed 9 years ago

Commit f9727a11 parent 60927bc6 files · +73 −62Browse files

Unified · Split

6 files
  1. fs/xfs/xfs_linux.h +0 −2
  2. include/linux/uuid.h +32 −23
  3. include/uapi/linux/uuid.h +8 −4
  4. lib/test_uuid.c +16 −16
  5. lib/uuid.c +15 −15
  6. lib/vsprintf.c +2 −2
fs/xfs/xfs_linux.h+0−2
@@ -39,8 +39,6 @@ typedef __s64 xfs_daddr_t; /* <disk address> type */ · 38 unmodified lines
39typedef __u32 xfs_dev_t;39typedef __u32 xfs_dev_t;
40typedef __u32 xfs_nlink_t;40typedef __u32 xfs_nlink_t;
41 41
42typedef uuid_be uuid_t;
43
44#include "xfs_types.h"42#include "xfs_types.h"
45 43
46#include "kmem.h"44#include "kmem.h"
include/linux/uuid.h+32−23
@@ -20,46 +20,55 @@ · 19 unmodified lines
20 20
21typedef struct {21typedef struct {
22 __u8 b[16];22 __u8 b[16];
23} uuid_be;23} uuid_t;
24 24
25#define UUID_BE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \25#define UUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
26((uuid_be) \26((uuid_t) \
27{{ ((a) >> 24) & 0xff, ((a) >> 16) & 0xff, ((a) >> 8) & 0xff, (a) & 0xff, \27{{ ((a) >> 24) & 0xff, ((a) >> 16) & 0xff, ((a) >> 8) & 0xff, (a) & 0xff, \
28 ((b) >> 8) & 0xff, (b) & 0xff, \28 ((b) >> 8) & 0xff, (b) & 0xff, \
29 ((c) >> 8) & 0xff, (c) & 0xff, \29 ((c) >> 8) & 0xff, (c) & 0xff, \
30 (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})30 (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
31 31
32#define NULL_UUID_BE \
33 UUID_BE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, \
34 0x00, 0x00, 0x00, 0x00)
35
36/*32/*
37 * The length of a UUID string ("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")33 * The length of a UUID string ("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
38 * not including trailing NUL.34 * not including trailing NUL.
39 */35 */
40#define UUID_STRING_LEN 3636#define UUID_STRING_LEN 36
41 37
42static inline int uuid_le_cmp(const uuid_le u1, const uuid_le u2)
43{
44 return memcmp(&u1, &u2, sizeof(uuid_le));
45}
46
47static inline int uuid_be_cmp(const uuid_be u1, const uuid_be u2)
48{
49 return memcmp(&u1, &u2, sizeof(uuid_be));
50}
51
52void generate_random_uuid(unsigned char uuid[16]);38void generate_random_uuid(unsigned char uuid[16]);
53 39
54extern void uuid_le_gen(uuid_le *u);40extern void guid_gen(guid_t *u);
55extern void uuid_be_gen(uuid_be *u);41extern void uuid_gen(uuid_t *u);
56 42
57bool __must_check uuid_is_valid(const char *uuid);43bool __must_check uuid_is_valid(const char *uuid);
58 44
59extern const u8 uuid_le_index[16];45extern const u8 guid_index[16];
60extern const u8 uuid_be_index[16];46extern const u8 uuid_index[16];
47
48int guid_parse(const char *uuid, guid_t *u);
49int uuid_parse(const char *uuid, uuid_t *u);
61 50
62int uuid_le_to_bin(const char *uuid, uuid_le *u);51/* backwards compatibility, don't use in new code */
63int uuid_be_to_bin(const char *uuid, uuid_be *u);52typedef uuid_t uuid_be;
53#define UUID_BE(a, _b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
54 UUID_INIT(a, _b, c, d0, d1, d2, d3, d4, d5, d6, d7)
55#define NULL_UUID_BE \
56 UUID_BE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, \
57 0x00, 0x00, 0x00, 0x00)
58
59#define uuid_le_gen(u) guid_gen(u)
60#define uuid_be_gen(u) uuid_gen(u)
61#define uuid_le_to_bin(guid, u) guid_parse(guid, u)
62#define uuid_be_to_bin(uuid, u) uuid_parse(uuid, u)
63
64static inline int uuid_le_cmp(const guid_t u1, const guid_t u2)
65{
66 return memcmp(&u1, &u2, sizeof(guid_t));
67}
68
69static inline int uuid_be_cmp(const uuid_t u1, const uuid_t u2)
70{
71 return memcmp(&u1, &u2, sizeof(uuid_t));
72}
64 73
65#endif74#endif
include/uapi/linux/uuid.h+8−4
@@ -22,17 +22,21 @@ · 21 unmodified lines
22 22
23typedef struct {23typedef struct {
24 __u8 b[16];24 __u8 b[16];
25} uuid_le;25} guid_t;
26 26
27#define UUID_LE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \27#define GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
28((uuid_le) \28((guid_t) \
29{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \29{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
30 (b) & 0xff, ((b) >> 8) & 0xff, \30 (b) & 0xff, ((b) >> 8) & 0xff, \
31 (c) & 0xff, ((c) >> 8) & 0xff, \31 (c) & 0xff, ((c) >> 8) & 0xff, \
32 (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})32 (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
33 33
34/* backwards compatibility, don't use in new code */
35typedef guid_t uuid_le;
36#define UUID_LE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
37 GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)
34#define NULL_UUID_LE \38#define NULL_UUID_LE \
35 UUID_LE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, \39 UUID_LE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, \
36 0x00, 0x00, 0x00, 0x00)40 0x00, 0x00, 0x00, 0x00)
37 41
38#endif /* _UAPI_LINUX_UUID_H_ */42#endif /* _UAPI_LINUX_UUID_H_ */
lib/test_uuid.c+16−16
@@ -11,25 +11,25 @@ · 10 unmodified lines
11 11
12struct test_uuid_data {12struct test_uuid_data {
13 const char *uuid;13 const char *uuid;
14 uuid_le le;14 guid_t le;
15 uuid_be be;15 uuid_t be;
16};16};
17 17
18static const struct test_uuid_data test_uuid_test_data[] = {18static const struct test_uuid_data test_uuid_test_data[] = {
19 {19 {
20 .uuid = "c33f4995-3701-450e-9fbf-206a2e98e576",20 .uuid = "c33f4995-3701-450e-9fbf-206a2e98e576",
21 .le = UUID_LE(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),21 .le = GUID_INIT(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),
22 .be = UUID_BE(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),22 .be = UUID_INIT(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),
23 },23 },
24 {24 {
25 .uuid = "64b4371c-77c1-48f9-8221-29f054fc023b",25 .uuid = "64b4371c-77c1-48f9-8221-29f054fc023b",
26 .le = UUID_LE(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),26 .le = GUID_INIT(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),
27 .be = UUID_BE(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),27 .be = UUID_INIT(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),
28 },28 },
29 {29 {
30 .uuid = "0cb4ddff-a545-4401-9d06-688af53e7f84",30 .uuid = "0cb4ddff-a545-4401-9d06-688af53e7f84",
31 .le = UUID_LE(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),31 .le = GUID_INIT(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),
32 .be = UUID_BE(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),32 .be = UUID_INIT(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),
33 },33 },
34};34};
35 35
@@ -61,13 +61,13 @@ static void __init test_uuid_failed(const char *prefix, bool wrong, bool be, · 25 unmodified lines
61 61
62static void __init test_uuid_test(const struct test_uuid_data *data)62static void __init test_uuid_test(const struct test_uuid_data *data)
63{63{
64 uuid_le le;64 guid_t le;
65 uuid_be be;65 uuid_t be;
66 char buf[48];66 char buf[48];
67 67
68 /* LE */68 /* LE */
69 total_tests++;69 total_tests++;
70 if (uuid_le_to_bin(data->uuid, &le))70 if (guid_parse(data->uuid, &le))
71 test_uuid_failed("conversion", false, false, data->uuid, NULL);71 test_uuid_failed("conversion", false, false, data->uuid, NULL);
72 72
73 total_tests++;73 total_tests++;
@@ -78,7 +78,7 @@ static void __init test_uuid_test(const struct test_uuid_data *data) · 4 unmodified lines
78 78
79 /* BE */79 /* BE */
80 total_tests++;80 total_tests++;
81 if (uuid_be_to_bin(data->uuid, &be))81 if (uuid_parse(data->uuid, &be))
82 test_uuid_failed("conversion", false, true, data->uuid, NULL);82 test_uuid_failed("conversion", false, true, data->uuid, NULL);
83 83
84 total_tests++;84 total_tests++;
@@ -90,17 +90,17 @@ static void __init test_uuid_test(const struct test_uuid_data *data) · 5 unmodified lines
90 90
91static void __init test_uuid_wrong(const char *data)91static void __init test_uuid_wrong(const char *data)
92{92{
93 uuid_le le;93 guid_t le;
94 uuid_be be;94 uuid_t be;
95 95
96 /* LE */96 /* LE */
97 total_tests++;97 total_tests++;
98 if (!uuid_le_to_bin(data, &le))98 if (!guid_parse(data, &le))
99 test_uuid_failed("negative", true, false, data, NULL);99 test_uuid_failed("negative", true, false, data, NULL);
100 100
101 /* BE */101 /* BE */
102 total_tests++;102 total_tests++;
103 if (!uuid_be_to_bin(data, &be))103 if (!uuid_parse(data, &be))
104 test_uuid_failed("negative", true, true, data, NULL);104 test_uuid_failed("negative", true, true, data, NULL);
105}105}
106 106
lib/uuid.c+15−15
@@ -21,10 +21,10 @@ · 20 unmodified lines
21#include <linux/uuid.h>21#include <linux/uuid.h>
22#include <linux/random.h>22#include <linux/random.h>
23 23
24const u8 uuid_le_index[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};24const u8 guid_index[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
25EXPORT_SYMBOL(uuid_le_index);25EXPORT_SYMBOL(guid_index);
26const u8 uuid_be_index[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};26const u8 uuid_index[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
27EXPORT_SYMBOL(uuid_be_index);27EXPORT_SYMBOL(uuid_index);
28 28
29/***************************************************************29/***************************************************************
30 * Random UUID interface30 * Random UUID interface
@@ -53,21 +53,21 @@ static void __uuid_gen_common(__u8 b[16]) · 22 unmodified lines
53 b[8] = (b[8] & 0x3F) | 0x80;53 b[8] = (b[8] & 0x3F) | 0x80;
54}54}
55 55
56void uuid_le_gen(uuid_le *lu)56void guid_gen(guid_t *lu)
57{57{
58 __uuid_gen_common(lu->b);58 __uuid_gen_common(lu->b);
59 /* version 4 : random generation */59 /* version 4 : random generation */
60 lu->b[7] = (lu->b[7] & 0x0F) | 0x40;60 lu->b[7] = (lu->b[7] & 0x0F) | 0x40;
61}61}
62EXPORT_SYMBOL_GPL(uuid_le_gen);62EXPORT_SYMBOL_GPL(guid_gen);
63 63
64void uuid_be_gen(uuid_be *bu)64void uuid_gen(uuid_t *bu)
65{65{
66 __uuid_gen_common(bu->b);66 __uuid_gen_common(bu->b);
67 /* version 4 : random generation */67 /* version 4 : random generation */
68 bu->b[6] = (bu->b[6] & 0x0F) | 0x40;68 bu->b[6] = (bu->b[6] & 0x0F) | 0x40;
69}69}
70EXPORT_SYMBOL_GPL(uuid_be_gen);70EXPORT_SYMBOL_GPL(uuid_gen);
71 71
72/**72/**
73 * uuid_is_valid - checks if UUID string valid73 * uuid_is_valid - checks if UUID string valid
@@ -97,7 +97,7 @@ bool uuid_is_valid(const char *uuid) · 23 unmodified lines
97}97}
98EXPORT_SYMBOL(uuid_is_valid);98EXPORT_SYMBOL(uuid_is_valid);
99 99
100static int __uuid_to_bin(const char *uuid, __u8 b[16], const u8 ei[16])100static int __uuid_parse(const char *uuid, __u8 b[16], const u8 ei[16])
101{101{
102 static const u8 si[16] = {0,2,4,6,9,11,14,16,19,21,24,26,28,30,32,34};102 static const u8 si[16] = {0,2,4,6,9,11,14,16,19,21,24,26,28,30,32,34};
103 unsigned int i;103 unsigned int i;
@@ -115,14 +115,14 @@ static int __uuid_to_bin(const char *uuid, __u8 b[16], const u8 ei[16]) · 11 unmodified lines
115 return 0;115 return 0;
116}116}
117 117
118int uuid_le_to_bin(const char *uuid, uuid_le *u)118int guid_parse(const char *uuid, guid_t *u)
119{119{
120 return __uuid_to_bin(uuid, u->b, uuid_le_index);120 return __uuid_parse(uuid, u->b, guid_index);
121}121}
122EXPORT_SYMBOL(uuid_le_to_bin);122EXPORT_SYMBOL(guid_parse);
123 123
124int uuid_be_to_bin(const char *uuid, uuid_be *u)124int uuid_parse(const char *uuid, uuid_t *u)
125{125{
126 return __uuid_to_bin(uuid, u->b, uuid_be_index);126 return __uuid_parse(uuid, u->b, uuid_index);
127}127}
128EXPORT_SYMBOL(uuid_be_to_bin);128EXPORT_SYMBOL(uuid_parse);
lib/vsprintf.c+2−2
@@ -1308,14 +1308,14 @@ char *uuid_string(char *buf, char *end, const u8 *addr, · 1307 unmodified lines
1308 char uuid[UUID_STRING_LEN + 1];1308 char uuid[UUID_STRING_LEN + 1];
1309 char *p = uuid;1309 char *p = uuid;
1310 int i;1310 int i;
1311 const u8 *index = uuid_be_index;1311 const u8 *index = uuid_index;
1312 bool uc = false;1312 bool uc = false;
1313 1313
1314 switch (*(++fmt)) {1314 switch (*(++fmt)) {
1315 case 'L':1315 case 'L':
1316 uc = true; /* fall-through */1316 uc = true; /* fall-through */
1317 case 'l':1317 case 'l':
1318 index = uuid_le_index;1318 index = guid_index;
1319 break;1319 break;
1320 case 'B':1320 case 'B':
1321 uc = true;1321 uc = true;