1 /* $NetBSD: gpt_uuid.c,v 1.29 2026/02/09 08:08:36 kre Exp $ */ 2 3 /*- 4 * Copyright (c) 2014 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #if HAVE_NBTOOL_CONFIG_H 30 #include "nbtool_config.h" 31 #endif 32 33 #include <sys/cdefs.h> 34 #ifdef __RCSID 35 __RCSID("$NetBSD: gpt_uuid.c,v 1.29 2026/02/09 08:08:36 kre Exp $"); 36 #endif 37 38 #include <err.h> 39 #include <fcntl.h> 40 #include <stdio.h> 41 #include <unistd.h> 42 43 #include "map.h" 44 #include "gpt.h" 45 #include "gpt_private.h" 46 47 #if defined(HAVE_SYS_ENDIAN_H) || ! defined(HAVE_NBTOOL_CONFIG_H) 48 #include <sys/endian.h> 49 #endif 50 51 52 const gpt_uuid_t gpt_uuid_nil; 53 54 struct dce_uuid { 55 uint32_t time_low; 56 uint16_t time_mid; 57 uint16_t time_hi_and_version; 58 uint8_t clock_seq_hi_and_reserved; 59 uint8_t clock_seq_low; 60 uint8_t node[6]; 61 }; 62 63 static const struct { 64 struct dce_uuid u; 65 const char *n; 66 const char *d; 67 } gpt_nv[] = { 68 /* Must match the gpt_type_t enum in gpt_uuid.h */ 69 { GPT_ENT_TYPE_APPLE_HFS, "apple", "Apple HFS" }, 70 { GPT_ENT_TYPE_APPLE_UFS, "apple-ufs", "Apple UFS" }, 71 { GPT_ENT_TYPE_BIOS, "bios", "BIOS Boot" }, 72 { GPT_ENT_TYPE_EFI, "efi", "EFI System" }, 73 { GPT_ENT_TYPE_FREEBSD, "fbsd-legacy", "FreeBSD legacy" }, 74 { GPT_ENT_TYPE_FREEBSD_SWAP, "fbsd-swap", "FreeBSD swap" }, 75 { GPT_ENT_TYPE_FREEBSD_UFS, "fbsd-ufs", "FreeBSD UFS/UFS2" }, 76 { GPT_ENT_TYPE_FREEBSD_VINUM, "fbsd-vinum", "FreeBSD vinum" }, 77 { GPT_ENT_TYPE_FREEBSD_ZFS, "zfs", "ZFS" }, 78 { GPT_ENT_TYPE_LINUX_DATA, "linux-data", "Linux data" }, 79 { GPT_ENT_TYPE_LINUX_RAID, "linux-raid", "Linux RAID" }, 80 { GPT_ENT_TYPE_LINUX_SWAP, "linux-swap", "Linux swap" }, 81 { GPT_ENT_TYPE_LINUX_LVM, "linux-lvm", "Linux LVM" }, 82 { GPT_ENT_TYPE_LINUX_XBOOTLDR, "linux-xbootldr", "Linux XBOOTLDR" }, 83 { GPT_ENT_TYPE_MS_BASIC_DATA, "windows", "Windows basic data" }, 84 { GPT_ENT_TYPE_MS_RESERVED, "windows-reserved", "Windows reserved" }, 85 { GPT_ENT_TYPE_MS_RECOVERY, "windows-recovery", "Windows recovery" }, 86 { GPT_ENT_TYPE_NETBSD_CCD, "ccd", "NetBSD ccd component" }, 87 { GPT_ENT_TYPE_NETBSD_CGD, "cgd", "NetBSD Cryptographic Disk" }, 88 { GPT_ENT_TYPE_NETBSD_FFS, "ffs", "NetBSD FFSv1/FFSv2" }, 89 { GPT_ENT_TYPE_NETBSD_LFS, "lfs", "NetBSD LFS" }, 90 { GPT_ENT_TYPE_NETBSD_RAIDFRAME, "raid", 91 "NetBSD RAIDFrame component" }, 92 { GPT_ENT_TYPE_NETBSD_SWAP, "swap", "NetBSD swap" }, 93 { GPT_ENT_TYPE_OPENBSD_DATA, "obsd", "OpenBSD data" }, 94 { GPT_ENT_TYPE_VMWARE_VMKCORE, "vmcore", "VMware VMkernel core dump" }, 95 { GPT_ENT_TYPE_VMWARE_VMFS, "vmfs", "VMware VMFS" }, 96 { GPT_ENT_TYPE_VMWARE_RESERVED, "vmreserved", "VMware reserved" }, 97 { GPT_ENT_TYPE_SIFIVE_BBL, "sifive-bbl", "SiFive BBL" }, 98 }; 99 100 static void 101 gpt_uuid_to_dce(const gpt_uuid_t buf, struct dce_uuid *uuid) 102 { 103 const uint8_t *p = buf; 104 size_t i; 105 106 uuid->time_low = le32dec(p); 107 uuid->time_mid = le16dec(p + 4); 108 uuid->time_hi_and_version = le16dec(p + 6); 109 uuid->clock_seq_hi_and_reserved = p[8]; 110 uuid->clock_seq_low = p[9]; 111 for (i = 0; i < sizeof(uuid->node); i++) 112 uuid->node[i] = p[10 + i]; 113 } 114 115 static void 116 gpt_dce_to_uuid(const struct dce_uuid *uuid, uint8_t *buf) 117 { 118 uint8_t *p = buf; 119 size_t i; 120 121 le32enc(p, uuid->time_low); 122 le16enc(p + 4, uuid->time_mid); 123 le16enc(p + 6, uuid->time_hi_and_version); 124 p[8] = uuid->clock_seq_hi_and_reserved; 125 p[9] = uuid->clock_seq_low; 126 for (i = 0; i < sizeof(uuid->node); i++) 127 p[10 + i] = uuid->node[i]; 128 } 129 130 static int 131 gpt_uuid_numeric(char *buf, size_t bufsiz, const struct dce_uuid *u) 132 { 133 return snprintf(buf, bufsiz, 134 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", 135 u->time_low, u->time_mid, u->time_hi_and_version, 136 u->clock_seq_hi_and_reserved, u->clock_seq_low, u->node[0], 137 u->node[1], u->node[2], u->node[3], u->node[4], u->node[5]); 138 } 139 140 141 static int 142 gpt_uuid_symbolic(char *buf, size_t bufsiz, const struct dce_uuid *u) 143 { 144 size_t i; 145 146 for (i = 0; i < __arraycount(gpt_nv); i++) 147 if (memcmp(&gpt_nv[i].u, u, sizeof(*u)) == 0) { 148 if (gpt_nv[i].n) 149 return (int)strlcpy(buf, gpt_nv[i].n, bufsiz); 150 break; 151 } 152 return -1; 153 } 154 155 static int 156 gpt_uuid_descriptive(char *buf, size_t bufsiz, const struct dce_uuid *u) 157 { 158 size_t i; 159 160 for (i = 0; i < __arraycount(gpt_nv); i++) 161 if (memcmp(&gpt_nv[i].u, u, sizeof(*u)) == 0) { 162 if (gpt_nv[i].d) 163 return (int)strlcpy(buf, gpt_nv[i].d, bufsiz); 164 break; 165 } 166 return -1; 167 } 168 169 int 170 gpt_uuid_snprintf(char *buf, size_t bufsiz, const char *fmt, 171 const gpt_uuid_t uu) 172 { 173 struct dce_uuid u; 174 gpt_uuid_to_dce(uu, &u); 175 176 if (fmt[1] == 's') { 177 int r; 178 if ((r = gpt_uuid_symbolic(buf, bufsiz, &u)) != -1) 179 return r; 180 } 181 if (fmt[1] == 'l') { 182 int r; 183 if ((r = gpt_uuid_descriptive(buf, bufsiz, &u)) != -1) 184 return r; 185 } 186 return gpt_uuid_numeric(buf, bufsiz, &u); 187 } 188 189 static int 190 gpt_uuid_parse_numeric(const char *s, struct dce_uuid *u) 191 { 192 int n; 193 194 if (s == NULL || *s == '\0') { 195 memset(u, 0, sizeof(*u)); 196 return 0; 197 } 198 199 n = sscanf(s, 200 "%8x-%4hx-%4hx-%2hhx%2hhx-%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx", 201 &u->time_low, &u->time_mid, &u->time_hi_and_version, 202 &u->clock_seq_hi_and_reserved, &u->clock_seq_low, &u->node[0], 203 &u->node[1], &u->node[2], &u->node[3], &u->node[4], &u->node[5]); 204 205 /* Make sure we have all conversions. */ 206 if (n != 11) 207 return -1; 208 209 /* We have a successful scan. Check semantics... */ 210 n = u->clock_seq_hi_and_reserved; 211 if ((n & 0x80) != 0x00 && /* variant 0? */ 212 (n & 0xc0) != 0x80 && /* variant 1? */ 213 (n & 0xe0) != 0xc0) /* variant 2? */ 214 return -1; 215 return 0; 216 } 217 218 static int 219 gpt_uuid_parse_symbolic(const char *s, struct dce_uuid *u) 220 { 221 size_t i; 222 223 for (i = 0; i < __arraycount(gpt_nv); i++) 224 if (gpt_nv[i].n && strcmp(gpt_nv[i].n, s) == 0) { 225 *u = gpt_nv[i].u; 226 return 0; 227 } 228 return -1; 229 } 230 231 int 232 gpt_uuid_parse(const char *s, gpt_uuid_t uuid) 233 { 234 struct dce_uuid u; 235 236 if (gpt_uuid_parse_numeric(s, &u) != -1) { 237 gpt_dce_to_uuid(&u, uuid); 238 return 0; 239 } 240 241 if (gpt_uuid_parse_symbolic(s, &u) == -1) 242 return -1; 243 244 gpt_dce_to_uuid(&u, uuid); 245 return 0; 246 } 247 248 size_t 249 gpt_uuid_query( 250 void (*func)(const char *uuid, const char *short_name, const char *desc)) 251 { 252 size_t i; 253 char buf[64]; 254 255 if (func != NULL) { 256 for (i = 0; i < __arraycount(gpt_nv); i++) { 257 gpt_uuid_numeric(buf, sizeof(buf), &gpt_nv[i].u); 258 (*func)(buf, gpt_nv[i].n, gpt_nv[i].d); 259 } 260 } 261 return __arraycount(gpt_nv); 262 } 263 264 #ifndef GPT_UUID_QUERY_ONLY 265 void 266 gpt_uuid_help(const char *prefix) 267 { 268 size_t i; 269 270 for (i = 0; i < __arraycount(gpt_nv); i++) 271 printf("%s%18.18s\t%s\n", prefix, 272 gpt_nv[i].n ? gpt_nv[i].n : "-", 273 gpt_nv[i].d ? gpt_nv[i].d : "?"); 274 } 275 276 void 277 gpt_uuid_create(gpt_type_t t, gpt_uuid_t u, uint16_t *b, size_t s) 278 { 279 gpt_dce_to_uuid(&gpt_nv[t].u, u); 280 if (b) 281 utf8_to_utf16((const uint8_t *)gpt_nv[t].d, b, s / sizeof(*b)); 282 } 283 284 static int 285 gpt_uuid_random(gpt_t gpt, struct dce_uuid *u, size_t n) 286 { 287 int fd; 288 uint8_t *p; 289 ssize_t nread; 290 291 /* Randomly generate the content. */ 292 fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC); 293 if (fd == -1) { 294 gpt_warn(gpt, "Can't open `/dev/urandom'"); 295 return -1; 296 } 297 for (p = (uint8_t *)u; n > 0; p += nread, n -= (size_t)nread) { 298 nread = read(fd, p, n); 299 if (nread < 0) { 300 gpt_warn(gpt, "Can't read `/dev/urandom'"); 301 goto out; 302 } 303 if (nread == 0) { 304 gpt_warnx(gpt, "EOF from /dev/urandom"); 305 goto out; 306 } 307 if ((size_t)nread > n) { 308 gpt_warnx(gpt, "read too much: %zd > %zu", nread, n); 309 goto out; 310 } 311 } 312 (void)close(fd); 313 314 /* Set the version number to 4. */ 315 u->time_hi_and_version &= (uint16_t)~0xf000; 316 u->time_hi_and_version |= 0x4000; 317 318 return 0; 319 out: 320 (void)close(fd); 321 return -1; 322 } 323 324 /* 325 * For reproducible builds, we can base UUIDs on one external timestamp. 326 * 327 * Bump timestamp by one 100ns unit to make them unique within a GPT. 328 * Use zero clock sequence and node id, ideally these should also be 329 * passed as input. 330 */ 331 static int 332 gpt_uuid_tstamp(gpt_t gpt, struct dce_uuid *u, size_t l __unused) 333 { 334 uint64_t x; 335 336 /* check for underflow/overflow of 60bit UUID time */ 337 if (gpt->timestamp < -12219292800 || 338 gpt->timestamp > 103072857660) 339 return -1; 340 341 /* 342 * Convert to UUID epoch (Gregorian) 343 * and 100ns units 344 */ 345 x = (uint64_t)(gpt->timestamp + 12219292800) * 10000000; 346 347 /* Make UUID unique */ 348 x += gpt->uuidgen++; 349 350 /* Set UUID fields for version 1 */ 351 u->time_low = x & UINT64_C(0xffffffff); 352 u->time_mid = (x >> 32) & 0xffff; 353 u->time_hi_and_version = (unsigned short)(0x1000 | ((x >> 48) & 0xfff)); 354 355 /* 356 * The clock sequence should make UUIDs unique in case 357 * the clock went backwards. 358 */ 359 u->clock_seq_hi_and_reserved = 0; 360 u->clock_seq_low = 0; 361 362 /* 363 * A unique system identifier (usually MAC address) 364 */ 365 memset(u->node, 0, sizeof(u->node)); 366 367 return 0; 368 } 369 370 int 371 gpt_uuid_generate(gpt_t gpt, gpt_uuid_t t) 372 { 373 int rv; 374 struct dce_uuid u; 375 376 if (gpt && (gpt->flags & GPT_TIMESTAMP)) 377 rv = gpt_uuid_tstamp(gpt, &u, sizeof(u)); 378 else 379 rv = gpt_uuid_random(gpt, &u, sizeof(u)); 380 381 if (rv == -1) 382 return -1; 383 384 /* Fix the reserved bits. */ 385 u.clock_seq_hi_and_reserved &= (uint8_t)~0x40U; 386 u.clock_seq_hi_and_reserved |= 0x80; 387 388 gpt_dce_to_uuid(&u, t); 389 return 0; 390 } 391 #endif 392
Indexes created Sun Aug 02 00:25:04 UTC 2026