FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_uuid.c
1 /*-
2 * Copyright (c) 2002 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD: releng/6.1/sys/kern/kern_uuid.c 158179 2006-04-30 16:44:43Z cvs2svn $");
29
30 #include <sys/param.h>
31 #include <sys/endian.h>
32 #include <sys/kernel.h>
33 #include <sys/lock.h>
34 #include <sys/mutex.h>
35 #include <sys/sbuf.h>
36 #include <sys/socket.h>
37 #include <sys/sysproto.h>
38 #include <sys/systm.h>
39 #include <sys/uuid.h>
40
41 #include <net/if.h>
42 #include <net/if_dl.h>
43 #include <net/if_types.h>
44
45 /*
46 * See also:
47 * http://www.opengroup.org/dce/info/draft-leach-uuids-guids-01.txt
48 * http://www.opengroup.org/onlinepubs/009629399/apdxa.htm
49 *
50 * Note that the generator state is itself an UUID, but the time and clock
51 * sequence fields are written in the native byte order.
52 */
53
54 CTASSERT(sizeof(struct uuid) == 16);
55
56 /* We use an alternative, more convenient representation in the generator. */
57 struct uuid_private {
58 union {
59 uint64_t ll; /* internal. */
60 struct {
61 uint32_t low;
62 uint16_t mid;
63 uint16_t hi;
64 } x;
65 } time;
66 uint16_t seq; /* Big-endian. */
67 uint16_t node[UUID_NODE_LEN>>1];
68 };
69
70 CTASSERT(sizeof(struct uuid_private) == 16);
71
72 static struct uuid_private uuid_last;
73
74 static struct mtx uuid_mutex;
75 MTX_SYSINIT(uuid_lock, &uuid_mutex, "UUID generator mutex lock", MTX_DEF);
76
77 /*
78 * Return the first MAC address we encounter or, if none was found,
79 * construct a sufficiently random multicast address. We don't try
80 * to return the same MAC address as previously returned. We always
81 * generate a new multicast address if no MAC address exists in the
82 * system.
83 * It would be nice to know if 'ifnet' or any of its sub-structures
84 * has been changed in any way. If not, we could simply skip the
85 * scan and safely return the MAC address we returned before.
86 */
87 static void
88 uuid_node(uint16_t *node)
89 {
90 struct ifnet *ifp;
91 struct ifaddr *ifa;
92 struct sockaddr_dl *sdl;
93 int i;
94
95 IFNET_RLOCK();
96 TAILQ_FOREACH(ifp, &ifnet, if_link) {
97 /* Walk the address list */
98 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
99 sdl = (struct sockaddr_dl*)ifa->ifa_addr;
100 if (sdl != NULL && sdl->sdl_family == AF_LINK &&
101 sdl->sdl_type == IFT_ETHER) {
102 /* Got a MAC address. */
103 bcopy(LLADDR(sdl), node, UUID_NODE_LEN);
104 IFNET_RUNLOCK();
105 return;
106 }
107 }
108 }
109 IFNET_RUNLOCK();
110
111 for (i = 0; i < (UUID_NODE_LEN>>1); i++)
112 node[i] = (uint16_t)arc4random();
113 *((uint8_t*)node) |= 0x01;
114 }
115
116 /*
117 * Get the current time as a 60 bit count of 100-nanosecond intervals
118 * since 00:00:00.00, October 15,1582. We apply a magic offset to convert
119 * the Unix time since 00:00:00.00, Januari 1, 1970 to the date of the
120 * Gregorian reform to the Christian calendar.
121 */
122 static uint64_t
123 uuid_time(void)
124 {
125 struct bintime bt;
126 uint64_t time = 0x01B21DD213814000LL;
127
128 bintime(&bt);
129 time += (uint64_t)bt.sec * 10000000LL;
130 time += (10000000LL * (uint32_t)(bt.frac >> 32)) >> 32;
131 return (time & ((1LL << 60) - 1LL));
132 }
133
134 #ifndef _SYS_SYSPROTO_H_
135 struct uuidgen_args {
136 struct uuid *store;
137 int count;
138 };
139 #endif
140
141 int
142 uuidgen(struct thread *td, struct uuidgen_args *uap)
143 {
144 struct uuid_private uuid;
145 uint64_t time;
146 int error;
147
148 /*
149 * Limit the number of UUIDs that can be created at the same time
150 * to some arbitrary number. This isn't really necessary, but I
151 * like to have some sort of upper-bound that's less than 2G :-)
152 * XXX needs to be tunable.
153 */
154 if (uap->count < 1 || uap->count > 2048)
155 return (EINVAL);
156
157 /* XXX: pre-validate accessibility to the whole of the UUID store? */
158
159 mtx_lock(&uuid_mutex);
160
161 uuid_node(uuid.node);
162 time = uuid_time();
163
164 if (uuid_last.time.ll == 0LL || uuid_last.node[0] != uuid.node[0] ||
165 uuid_last.node[1] != uuid.node[1] ||
166 uuid_last.node[2] != uuid.node[2])
167 uuid.seq = (uint16_t)arc4random() & 0x3fff;
168 else if (uuid_last.time.ll >= time)
169 uuid.seq = (uuid_last.seq + 1) & 0x3fff;
170 else
171 uuid.seq = uuid_last.seq;
172
173 uuid_last = uuid;
174 uuid_last.time.ll = (time + uap->count - 1) & ((1LL << 60) - 1LL);
175
176 mtx_unlock(&uuid_mutex);
177
178 /* Set sequence and variant and deal with byte order. */
179 uuid.seq = htobe16(uuid.seq | 0x8000);
180
181 /* XXX: this should copyout larger chunks at a time. */
182 do {
183 /* Set time and version (=1) and deal with byte order. */
184 uuid.time.x.low = (uint32_t)time;
185 uuid.time.x.mid = (uint16_t)(time >> 32);
186 uuid.time.x.hi = ((uint16_t)(time >> 48) & 0xfff) | (1 << 12);
187 error = copyout(&uuid, uap->store, sizeof(uuid));
188 uap->store++;
189 uap->count--;
190 time++;
191 } while (uap->count > 0 && !error);
192
193 return (error);
194 }
195
196 int
197 snprintf_uuid(char *buf, size_t sz, struct uuid *uuid)
198 {
199 struct uuid_private *id;
200 int cnt;
201
202 id = (struct uuid_private *)uuid;
203 cnt = snprintf(buf, sz, "%08x-%04x-%04x-%04x-%04x%04x%04x",
204 id->time.x.low, id->time.x.mid, id->time.x.hi, be16toh(id->seq),
205 be16toh(id->node[0]), be16toh(id->node[1]), be16toh(id->node[2]));
206 return (cnt);
207 }
208
209 int
210 printf_uuid(struct uuid *uuid)
211 {
212 char buf[38];
213
214 snprintf_uuid(buf, sizeof(buf), uuid);
215 return (printf("%s", buf));
216 }
217
218 int
219 sbuf_printf_uuid(struct sbuf *sb, struct uuid *uuid)
220 {
221 char buf[38];
222
223 snprintf_uuid(buf, sizeof(buf), uuid);
224 return (sbuf_printf(sb, "%s", buf));
225 }
226
227 /*
228 * Encode/Decode UUID into byte-stream.
229 * http://www.opengroup.org/dce/info/draft-leach-uuids-guids-01.txt
230 *
231 * 0 1 2 3
232 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
233 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
234 * | time_low |
235 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
236 * | time_mid | time_hi_and_version |
237 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
238 * |clk_seq_hi_res | clk_seq_low | node (0-1) |
239 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
240 * | node (2-5) |
241 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
242 */
243
244 void
245 le_uuid_enc(void *buf, struct uuid const *uuid)
246 {
247 u_char *p;
248 int i;
249
250 p = buf;
251 le32enc(p, uuid->time_low);
252 le16enc(p + 4, uuid->time_mid);
253 le16enc(p + 6, uuid->time_hi_and_version);
254 p[8] = uuid->clock_seq_hi_and_reserved;
255 p[9] = uuid->clock_seq_low;
256 for (i = 0; i < _UUID_NODE_LEN; i++)
257 p[10 + i] = uuid->node[i];
258 }
259
260 void
261 le_uuid_dec(void const *buf, struct uuid *uuid)
262 {
263 u_char const *p;
264 int i;
265
266 p = buf;
267 uuid->time_low = le32dec(p);
268 uuid->time_mid = le16dec(p + 4);
269 uuid->time_hi_and_version = le16dec(p + 6);
270 uuid->clock_seq_hi_and_reserved = p[8];
271 uuid->clock_seq_low = p[9];
272 for (i = 0; i < _UUID_NODE_LEN; i++)
273 uuid->node[i] = p[10 + i];
274 }
275 void
276 be_uuid_enc(void *buf, struct uuid const *uuid)
277 {
278 u_char *p;
279 int i;
280
281 p = buf;
282 be32enc(p, uuid->time_low);
283 be16enc(p + 4, uuid->time_mid);
284 be16enc(p + 6, uuid->time_hi_and_version);
285 p[8] = uuid->clock_seq_hi_and_reserved;
286 p[9] = uuid->clock_seq_low;
287 for (i = 0; i < _UUID_NODE_LEN; i++)
288 p[10 + i] = uuid->node[i];
289 }
290
291 void
292 be_uuid_dec(void const *buf, struct uuid *uuid)
293 {
294 u_char const *p;
295 int i;
296
297 p = buf;
298 uuid->time_low = be32dec(p);
299 uuid->time_mid = le16dec(p + 4);
300 uuid->time_hi_and_version = be16dec(p + 6);
301 uuid->clock_seq_hi_and_reserved = p[8];
302 uuid->clock_seq_low = p[9];
303 for (i = 0; i < _UUID_NODE_LEN; i++)
304 uuid->node[i] = p[10 + i];
305 }
Cache object: 175e174afd151383ed10abc2fe6f7e57
|