1 /*- 2 * Copyright (c) 2015-2016 Landon Fuller <landonf@FreeBSD.org> 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 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13 * redistribution must be conditioned upon including a substantially 14 * similar Disclaimer requirement for further binary redistribution. 15 * 16 * NO WARRANTY 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 20 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 21 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 22 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 27 * THE POSSIBILITY OF SUCH DAMAGES. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 35 #ifdef _KERNEL 36 37 #include <sys/ctype.h> 38 #include <sys/kernel.h> 39 #include <sys/limits.h> 40 #include <sys/malloc.h> 41 #include <sys/systm.h> 42 43 #include <machine/_inttypes.h> 44 45 #else /* !_KERNEL */ 46 47 #include <ctype.h> 48 #include <errno.h> 49 #include <inttypes.h> 50 #include <limits.h> 51 #include <stdbool.h> 52 #include <stdio.h> 53 #include <stdint.h> 54 #include <stdlib.h> 55 #include <string.h> 56 57 #endif /* _KERNEL */ 58 59 #include "bhnd_nvram_io.h" 60 #include "bhnd_nvram_private.h" 61 #include "bhnd_nvram_value.h" 62 63 #include "bhnd_nvram_map_data.h" 64 65 /* 66 * Common NVRAM/SPROM support, including NVRAM variable map 67 * lookup. 68 */ 69 70 #ifdef _KERNEL 71 MALLOC_DEFINE(M_BHND_NVRAM, "bhnd_nvram", "bhnd nvram data"); 72 #endif 73 74 /* 75 * CRC-8 lookup table used to checksum SPROM and NVRAM data via 76 * bhnd_nvram_crc8(). 77 * 78 * Generated with following parameters: 79 * polynomial: CRC-8 (x^8 + x^7 + x^6 + x^4 + x^2 + 1) 80 * reflected bits: false 81 * reversed: true 82 */ 83 const uint8_t bhnd_nvram_crc8_tab[] = { 84 0x00, 0xf7, 0xb9, 0x4e, 0x25, 0xd2, 0x9c, 0x6b, 0x4a, 0xbd, 0xf3, 85 0x04, 0x6f, 0x98, 0xd6, 0x21, 0x94, 0x63, 0x2d, 0xda, 0xb1, 0x46, 86 0x08, 0xff, 0xde, 0x29, 0x67, 0x90, 0xfb, 0x0c, 0x42, 0xb5, 0x7f, 87 0x88, 0xc6, 0x31, 0x5a, 0xad, 0xe3, 0x14, 0x35, 0xc2, 0x8c, 0x7b, 88 0x10, 0xe7, 0xa9, 0x5e, 0xeb, 0x1c, 0x52, 0xa5, 0xce, 0x39, 0x77, 89 0x80, 0xa1, 0x56, 0x18, 0xef, 0x84, 0x73, 0x3d, 0xca, 0xfe, 0x09, 90 0x47, 0xb0, 0xdb, 0x2c, 0x62, 0x95, 0xb4, 0x43, 0x0d, 0xfa, 0x91, 91 0x66, 0x28, 0xdf, 0x6a, 0x9d, 0xd3, 0x24, 0x4f, 0xb8, 0xf6, 0x01, 92 0x20, 0xd7, 0x99, 0x6e, 0x05, 0xf2, 0xbc, 0x4b, 0x81, 0x76, 0x38, 93 0xcf, 0xa4, 0x53, 0x1d, 0xea, 0xcb, 0x3c, 0x72, 0x85, 0xee, 0x19, 94 0x57, 0xa0, 0x15, 0xe2, 0xac, 0x5b, 0x30, 0xc7, 0x89, 0x7e, 0x5f, 95 0xa8, 0xe6, 0x11, 0x7a, 0x8d, 0xc3, 0x34, 0xab, 0x5c, 0x12, 0xe5, 96 0x8e, 0x79, 0x37, 0xc0, 0xe1, 0x16, 0x58, 0xaf, 0xc4, 0x33, 0x7d, 97 0x8a, 0x3f, 0xc8, 0x86, 0x71, 0x1a, 0xed, 0xa3, 0x54, 0x75, 0x82, 98 0xcc, 0x3b, 0x50, 0xa7, 0xe9, 0x1e, 0xd4, 0x23, 0x6d, 0x9a, 0xf1, 99 0x06, 0x48, 0xbf, 0x9e, 0x69, 0x27, 0xd0, 0xbb, 0x4c, 0x02, 0xf5, 100 0x40, 0xb7, 0xf9, 0x0e, 0x65, 0x92, 0xdc, 0x2b, 0x0a, 0xfd, 0xb3, 101 0x44, 0x2f, 0xd8, 0x96, 0x61, 0x55, 0xa2, 0xec, 0x1b, 0x70, 0x87, 102 0xc9, 0x3e, 0x1f, 0xe8, 0xa6, 0x51, 0x3a, 0xcd, 0x83, 0x74, 0xc1, 103 0x36, 0x78, 0x8f, 0xe4, 0x13, 0x5d, 0xaa, 0x8b, 0x7c, 0x32, 0xc5, 104 0xae, 0x59, 0x17, 0xe0, 0x2a, 0xdd, 0x93, 0x64, 0x0f, 0xf8, 0xb6, 105 0x41, 0x60, 0x97, 0xd9, 0x2e, 0x45, 0xb2, 0xfc, 0x0b, 0xbe, 0x49, 106 0x07, 0xf0, 0x9b, 0x6c, 0x22, 0xd5, 0xf4, 0x03, 0x4d, 0xba, 0xd1, 107 0x26, 0x68, 0x9f 108 }; 109 110 /** 111 * Return a human readable name for @p type. 112 * 113 * @param type The type to query. 114 */ 115 const char * 116 bhnd_nvram_type_name(bhnd_nvram_type type) 117 { 118 switch (type) { 119 case BHND_NVRAM_TYPE_UINT8: 120 return ("uint8"); 121 case BHND_NVRAM_TYPE_UINT16: 122 return ("uint16"); 123 case BHND_NVRAM_TYPE_UINT32: 124 return ("uint32"); 125 case BHND_NVRAM_TYPE_UINT64: 126 return ("uint64"); 127 case BHND_NVRAM_TYPE_CHAR: 128 return ("char"); 129 case BHND_NVRAM_TYPE_INT8: 130 return ("int8"); 131 case BHND_NVRAM_TYPE_INT16: 132 return ("int16"); 133 case BHND_NVRAM_TYPE_INT32: 134 return ("int32"); 135 case BHND_NVRAM_TYPE_INT64: 136 return ("int64"); 137 case BHND_NVRAM_TYPE_STRING: 138 return ("string"); 139 case BHND_NVRAM_TYPE_BOOL: 140 return ("bool"); 141 case BHND_NVRAM_TYPE_NULL: 142 return ("null"); 143 case BHND_NVRAM_TYPE_DATA: 144 return ("data"); 145 case BHND_NVRAM_TYPE_UINT8_ARRAY: 146 return ("uint8[]"); 147 case BHND_NVRAM_TYPE_UINT16_ARRAY: 148 return ("uint16[]"); 149 case BHND_NVRAM_TYPE_UINT32_ARRAY: 150 return ("uint32[]"); 151 case BHND_NVRAM_TYPE_UINT64_ARRAY: 152 return ("uint64[]"); 153 case BHND_NVRAM_TYPE_INT8_ARRAY: 154 return ("int8[]"); 155 case BHND_NVRAM_TYPE_INT16_ARRAY: 156 return ("int16[]"); 157 case BHND_NVRAM_TYPE_INT32_ARRAY: 158 return ("int32[]"); 159 case BHND_NVRAM_TYPE_INT64_ARRAY: 160 return ("int64[]"); 161 case BHND_NVRAM_TYPE_CHAR_ARRAY: 162 return ("char[]"); 163 case BHND_NVRAM_TYPE_STRING_ARRAY: 164 return ("string[]"); 165 case BHND_NVRAM_TYPE_BOOL_ARRAY: 166 return ("bool[]"); 167 } 168 169 /* Quiesce gcc4.2 */ 170 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 171 } 172 173 /** 174 * Return true if @p type is a signed integer type, false otherwise. 175 * 176 * Will return false for all array types. 177 * 178 * @param type The type to query. 179 */ 180 bool 181 bhnd_nvram_is_signed_type(bhnd_nvram_type type) 182 { 183 switch (type) { 184 case BHND_NVRAM_TYPE_INT8: 185 case BHND_NVRAM_TYPE_INT16: 186 case BHND_NVRAM_TYPE_INT32: 187 case BHND_NVRAM_TYPE_INT64: 188 BHND_NV_ASSERT(bhnd_nvram_is_int_type(type), ("non-int type?")); 189 return (true); 190 191 case BHND_NVRAM_TYPE_CHAR: 192 case BHND_NVRAM_TYPE_UINT8: 193 case BHND_NVRAM_TYPE_UINT16: 194 case BHND_NVRAM_TYPE_UINT32: 195 case BHND_NVRAM_TYPE_UINT64: 196 case BHND_NVRAM_TYPE_STRING: 197 case BHND_NVRAM_TYPE_BOOL: 198 case BHND_NVRAM_TYPE_NULL: 199 case BHND_NVRAM_TYPE_DATA: 200 case BHND_NVRAM_TYPE_UINT8_ARRAY: 201 case BHND_NVRAM_TYPE_UINT16_ARRAY: 202 case BHND_NVRAM_TYPE_UINT32_ARRAY: 203 case BHND_NVRAM_TYPE_UINT64_ARRAY: 204 case BHND_NVRAM_TYPE_INT8_ARRAY: 205 case BHND_NVRAM_TYPE_INT16_ARRAY: 206 case BHND_NVRAM_TYPE_INT32_ARRAY: 207 case BHND_NVRAM_TYPE_INT64_ARRAY: 208 case BHND_NVRAM_TYPE_CHAR_ARRAY: 209 case BHND_NVRAM_TYPE_STRING_ARRAY: 210 case BHND_NVRAM_TYPE_BOOL_ARRAY: 211 return (false); 212 } 213 214 /* Quiesce gcc4.2 */ 215 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 216 } 217 218 /** 219 * Return true if @p type is an unsigned integer type, false otherwise. 220 * 221 * @param type The type to query. 222 * 223 * @return Will return false for all array types. 224 * @return Will return true for BHND_NVRAM_TYPE_CHAR. 225 */ 226 bool 227 bhnd_nvram_is_unsigned_type(bhnd_nvram_type type) 228 { 229 /* If an integer type, must be either signed or unsigned */ 230 if (!bhnd_nvram_is_int_type(type)) 231 return (false); 232 233 return (!bhnd_nvram_is_signed_type(type)); 234 } 235 236 /** 237 * Return true if bhnd_nvram_is_signed_type() or bhnd_nvram_is_unsigned_type() 238 * returns true for @p type. 239 * 240 * @param type The type to query. 241 */ 242 bool 243 bhnd_nvram_is_int_type(bhnd_nvram_type type) 244 { 245 switch (type) { 246 case BHND_NVRAM_TYPE_UINT8: 247 case BHND_NVRAM_TYPE_UINT16: 248 case BHND_NVRAM_TYPE_UINT32: 249 case BHND_NVRAM_TYPE_UINT64: 250 case BHND_NVRAM_TYPE_INT8: 251 case BHND_NVRAM_TYPE_INT16: 252 case BHND_NVRAM_TYPE_INT32: 253 case BHND_NVRAM_TYPE_INT64: 254 return (true); 255 256 case BHND_NVRAM_TYPE_CHAR: 257 case BHND_NVRAM_TYPE_STRING: 258 case BHND_NVRAM_TYPE_BOOL: 259 case BHND_NVRAM_TYPE_NULL: 260 case BHND_NVRAM_TYPE_DATA: 261 case BHND_NVRAM_TYPE_UINT8_ARRAY: 262 case BHND_NVRAM_TYPE_UINT16_ARRAY: 263 case BHND_NVRAM_TYPE_UINT32_ARRAY: 264 case BHND_NVRAM_TYPE_UINT64_ARRAY: 265 case BHND_NVRAM_TYPE_INT8_ARRAY: 266 case BHND_NVRAM_TYPE_INT16_ARRAY: 267 case BHND_NVRAM_TYPE_INT32_ARRAY: 268 case BHND_NVRAM_TYPE_INT64_ARRAY: 269 case BHND_NVRAM_TYPE_CHAR_ARRAY: 270 case BHND_NVRAM_TYPE_STRING_ARRAY: 271 case BHND_NVRAM_TYPE_BOOL_ARRAY: 272 return (false); 273 } 274 275 /* Quiesce gcc4.2 */ 276 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 277 } 278 279 /** 280 * Return true if @p type is an array type, false otherwise. 281 * 282 * @param type The type to query. 283 */ 284 bool 285 bhnd_nvram_is_array_type(bhnd_nvram_type type) 286 { 287 switch (type) { 288 case BHND_NVRAM_TYPE_UINT8: 289 case BHND_NVRAM_TYPE_UINT16: 290 case BHND_NVRAM_TYPE_UINT32: 291 case BHND_NVRAM_TYPE_UINT64: 292 case BHND_NVRAM_TYPE_INT8: 293 case BHND_NVRAM_TYPE_INT16: 294 case BHND_NVRAM_TYPE_INT32: 295 case BHND_NVRAM_TYPE_INT64: 296 case BHND_NVRAM_TYPE_CHAR: 297 case BHND_NVRAM_TYPE_STRING: 298 case BHND_NVRAM_TYPE_BOOL: 299 case BHND_NVRAM_TYPE_NULL: 300 case BHND_NVRAM_TYPE_DATA: 301 return (false); 302 303 case BHND_NVRAM_TYPE_UINT8_ARRAY: 304 case BHND_NVRAM_TYPE_UINT16_ARRAY: 305 case BHND_NVRAM_TYPE_UINT32_ARRAY: 306 case BHND_NVRAM_TYPE_UINT64_ARRAY: 307 case BHND_NVRAM_TYPE_INT8_ARRAY: 308 case BHND_NVRAM_TYPE_INT16_ARRAY: 309 case BHND_NVRAM_TYPE_INT32_ARRAY: 310 case BHND_NVRAM_TYPE_INT64_ARRAY: 311 case BHND_NVRAM_TYPE_CHAR_ARRAY: 312 case BHND_NVRAM_TYPE_STRING_ARRAY: 313 case BHND_NVRAM_TYPE_BOOL_ARRAY: 314 return (true); 315 } 316 317 /* Quiesce gcc4.2 */ 318 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 319 } 320 321 /** 322 * If @p type is an array type, return the base element type. Otherwise, 323 * returns @p type. 324 * 325 * @param type The type to query. 326 */ 327 bhnd_nvram_type 328 bhnd_nvram_base_type(bhnd_nvram_type type) 329 { 330 switch (type) { 331 case BHND_NVRAM_TYPE_UINT8: 332 case BHND_NVRAM_TYPE_UINT16: 333 case BHND_NVRAM_TYPE_UINT32: 334 case BHND_NVRAM_TYPE_UINT64: 335 case BHND_NVRAM_TYPE_INT8: 336 case BHND_NVRAM_TYPE_INT16: 337 case BHND_NVRAM_TYPE_INT32: 338 case BHND_NVRAM_TYPE_INT64: 339 case BHND_NVRAM_TYPE_CHAR: 340 case BHND_NVRAM_TYPE_STRING: 341 case BHND_NVRAM_TYPE_BOOL: 342 case BHND_NVRAM_TYPE_NULL: 343 case BHND_NVRAM_TYPE_DATA: 344 return (type); 345 346 case BHND_NVRAM_TYPE_UINT8_ARRAY: return (BHND_NVRAM_TYPE_UINT8); 347 case BHND_NVRAM_TYPE_UINT16_ARRAY: return (BHND_NVRAM_TYPE_UINT16); 348 case BHND_NVRAM_TYPE_UINT32_ARRAY: return (BHND_NVRAM_TYPE_UINT32); 349 case BHND_NVRAM_TYPE_UINT64_ARRAY: return (BHND_NVRAM_TYPE_UINT64); 350 case BHND_NVRAM_TYPE_INT8_ARRAY: return (BHND_NVRAM_TYPE_INT8); 351 case BHND_NVRAM_TYPE_INT16_ARRAY: return (BHND_NVRAM_TYPE_INT16); 352 case BHND_NVRAM_TYPE_INT32_ARRAY: return (BHND_NVRAM_TYPE_INT32); 353 case BHND_NVRAM_TYPE_INT64_ARRAY: return (BHND_NVRAM_TYPE_INT64); 354 case BHND_NVRAM_TYPE_CHAR_ARRAY: return (BHND_NVRAM_TYPE_CHAR); 355 case BHND_NVRAM_TYPE_STRING_ARRAY: return (BHND_NVRAM_TYPE_STRING); 356 case BHND_NVRAM_TYPE_BOOL_ARRAY: return (BHND_NVRAM_TYPE_BOOL); 357 } 358 359 /* Quiesce gcc4.2 */ 360 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 361 } 362 363 /** 364 * Return the raw data type used to represent values of @p type, or return 365 * @p type is @p type is not a complex type. 366 * 367 * @param type The type to query. 368 */ 369 bhnd_nvram_type 370 bhnd_nvram_raw_type(bhnd_nvram_type type) 371 { 372 switch (type) { 373 case BHND_NVRAM_TYPE_CHAR: 374 return (BHND_NVRAM_TYPE_UINT8); 375 376 case BHND_NVRAM_TYPE_CHAR_ARRAY: 377 return (BHND_NVRAM_TYPE_UINT8_ARRAY); 378 379 case BHND_NVRAM_TYPE_BOOL: { 380 _Static_assert(sizeof(bhnd_nvram_bool_t) == sizeof(uint8_t), 381 "bhnd_nvram_bool_t must be uint8-representable"); 382 return (BHND_NVRAM_TYPE_UINT8); 383 } 384 385 case BHND_NVRAM_TYPE_BOOL_ARRAY: 386 return (BHND_NVRAM_TYPE_UINT8_ARRAY); 387 388 case BHND_NVRAM_TYPE_DATA: 389 return (BHND_NVRAM_TYPE_UINT8_ARRAY); 390 391 case BHND_NVRAM_TYPE_STRING: 392 case BHND_NVRAM_TYPE_STRING_ARRAY: 393 return (BHND_NVRAM_TYPE_UINT8_ARRAY); 394 395 case BHND_NVRAM_TYPE_UINT8: 396 case BHND_NVRAM_TYPE_UINT16: 397 case BHND_NVRAM_TYPE_UINT32: 398 case BHND_NVRAM_TYPE_UINT64: 399 case BHND_NVRAM_TYPE_INT8: 400 case BHND_NVRAM_TYPE_INT16: 401 case BHND_NVRAM_TYPE_INT32: 402 case BHND_NVRAM_TYPE_INT64: 403 case BHND_NVRAM_TYPE_NULL: 404 case BHND_NVRAM_TYPE_UINT8_ARRAY: 405 case BHND_NVRAM_TYPE_UINT16_ARRAY: 406 case BHND_NVRAM_TYPE_UINT32_ARRAY: 407 case BHND_NVRAM_TYPE_UINT64_ARRAY: 408 case BHND_NVRAM_TYPE_INT8_ARRAY: 409 case BHND_NVRAM_TYPE_INT16_ARRAY: 410 case BHND_NVRAM_TYPE_INT32_ARRAY: 411 case BHND_NVRAM_TYPE_INT64_ARRAY: 412 return (type); 413 } 414 415 /* Quiesce gcc4.2 */ 416 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 417 } 418 419 /** 420 * Return the size, in bytes, of a single element of @p type, or 0 421 * if @p type is a variable-width type. 422 * 423 * @param type The type to query. 424 */ 425 size_t 426 bhnd_nvram_type_width(bhnd_nvram_type type) 427 { 428 switch (type) { 429 case BHND_NVRAM_TYPE_STRING: 430 case BHND_NVRAM_TYPE_STRING_ARRAY: 431 case BHND_NVRAM_TYPE_DATA: 432 return (0); 433 434 case BHND_NVRAM_TYPE_NULL: 435 return (0); 436 437 case BHND_NVRAM_TYPE_BOOL: 438 case BHND_NVRAM_TYPE_BOOL_ARRAY: 439 return (sizeof(bhnd_nvram_bool_t)); 440 441 case BHND_NVRAM_TYPE_CHAR: 442 case BHND_NVRAM_TYPE_CHAR_ARRAY: 443 case BHND_NVRAM_TYPE_UINT8: 444 case BHND_NVRAM_TYPE_UINT8_ARRAY: 445 case BHND_NVRAM_TYPE_INT8: 446 case BHND_NVRAM_TYPE_INT8_ARRAY: 447 return (sizeof(uint8_t)); 448 449 case BHND_NVRAM_TYPE_UINT16: 450 case BHND_NVRAM_TYPE_UINT16_ARRAY: 451 case BHND_NVRAM_TYPE_INT16: 452 case BHND_NVRAM_TYPE_INT16_ARRAY: 453 return (sizeof(uint16_t)); 454 455 case BHND_NVRAM_TYPE_UINT32: 456 case BHND_NVRAM_TYPE_UINT32_ARRAY: 457 case BHND_NVRAM_TYPE_INT32: 458 case BHND_NVRAM_TYPE_INT32_ARRAY: 459 return (sizeof(uint32_t)); 460 461 case BHND_NVRAM_TYPE_UINT64: 462 case BHND_NVRAM_TYPE_UINT64_ARRAY: 463 case BHND_NVRAM_TYPE_INT64: 464 case BHND_NVRAM_TYPE_INT64_ARRAY: 465 return (sizeof(uint64_t)); 466 } 467 468 /* Quiesce gcc4.2 */ 469 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 470 } 471 472 /** 473 * Return the native host alignment for values of @p type. 474 * 475 * @param type The type to query. 476 */ 477 size_t 478 bhnd_nvram_type_host_align(bhnd_nvram_type type) 479 { 480 switch (type) { 481 case BHND_NVRAM_TYPE_CHAR: 482 case BHND_NVRAM_TYPE_CHAR_ARRAY: 483 case BHND_NVRAM_TYPE_DATA: 484 case BHND_NVRAM_TYPE_STRING: 485 case BHND_NVRAM_TYPE_STRING_ARRAY: 486 return (_Alignof(uint8_t)); 487 case BHND_NVRAM_TYPE_BOOL: 488 case BHND_NVRAM_TYPE_BOOL_ARRAY: { 489 _Static_assert(sizeof(bhnd_nvram_bool_t) == sizeof(uint8_t), 490 "bhnd_nvram_bool_t must be uint8-representable"); 491 return (_Alignof(uint8_t)); 492 } 493 case BHND_NVRAM_TYPE_NULL: 494 return (1); 495 case BHND_NVRAM_TYPE_UINT8: 496 case BHND_NVRAM_TYPE_UINT8_ARRAY: 497 return (_Alignof(uint8_t)); 498 case BHND_NVRAM_TYPE_UINT16: 499 case BHND_NVRAM_TYPE_UINT16_ARRAY: 500 return (_Alignof(uint16_t)); 501 case BHND_NVRAM_TYPE_UINT32: 502 case BHND_NVRAM_TYPE_UINT32_ARRAY: 503 return (_Alignof(uint32_t)); 504 case BHND_NVRAM_TYPE_UINT64: 505 case BHND_NVRAM_TYPE_UINT64_ARRAY: 506 return (_Alignof(uint64_t)); 507 case BHND_NVRAM_TYPE_INT8: 508 case BHND_NVRAM_TYPE_INT8_ARRAY: 509 return (_Alignof(int8_t)); 510 case BHND_NVRAM_TYPE_INT16: 511 case BHND_NVRAM_TYPE_INT16_ARRAY: 512 return (_Alignof(int16_t)); 513 case BHND_NVRAM_TYPE_INT32: 514 case BHND_NVRAM_TYPE_INT32_ARRAY: 515 return (_Alignof(int32_t)); 516 case BHND_NVRAM_TYPE_INT64: 517 case BHND_NVRAM_TYPE_INT64_ARRAY: 518 return (_Alignof(int64_t)); 519 } 520 521 /* Quiesce gcc4.2 */ 522 BHND_NV_PANIC("bhnd nvram type %u unknown", type); 523 } 524 525 /** 526 * Iterate over all strings in the @p inp string array (@see 527 * BHNF_NVRAM_TYPE_STRING_ARRAY). 528 * 529 * @param inp The string array to be iterated. This must be a 530 * buffer of one or more NUL-terminated strings. 531 * @param ilen The size, in bytes, of @p inp, including any 532 * terminating NUL character(s). 533 * @param prev The pointer previously returned by 534 * bhnd_nvram_string_array_next(), or NULL to begin 535 * iteration. 536 * @param[in,out] olen If @p prev is non-NULL, @p olen must be a 537 * pointer to the length previously returned by 538 * bhnd_nvram_string_array_next(). On success, will 539 * be set to the next element's length, in bytes. 540 * 541 * @retval non-NULL A reference to the next NUL-terminated string 542 * @retval NULL If the end of the string array is reached. 543 */ 544 const char * 545 bhnd_nvram_string_array_next(const char *inp, size_t ilen, const char *prev, 546 size_t *olen) 547 { 548 return (bhnd_nvram_value_array_next(inp, ilen, 549 BHND_NVRAM_TYPE_STRING_ARRAY, prev, olen)); 550 } 551 552 /* used by bhnd_nvram_find_vardefn() */ 553 static int 554 bhnd_nvram_find_vardefn_compare(const void *key, const void *rhs) 555 { 556 const struct bhnd_nvram_vardefn *r = rhs; 557 558 return (strcmp((const char *)key, r->name)); 559 } 560 561 /** 562 * Find and return the variable definition for @p varname, if any. 563 * 564 * @param varname variable name 565 * 566 * @retval bhnd_nvram_vardefn If a valid definition for @p varname is found. 567 * @retval NULL If no definition for @p varname is found. 568 */ 569 const struct bhnd_nvram_vardefn * 570 bhnd_nvram_find_vardefn(const char *varname) 571 { 572 return (bsearch(varname, bhnd_nvram_vardefns, bhnd_nvram_num_vardefns, 573 sizeof(bhnd_nvram_vardefns[0]), bhnd_nvram_find_vardefn_compare)); 574 } 575 576 /** 577 * Return the variable ID for a variable definition. 578 * 579 * @param defn Variable definition previously returned by 580 * bhnd_nvram_find_vardefn() or bhnd_nvram_get_vardefn(). 581 */ 582 size_t 583 bhnd_nvram_get_vardefn_id(const struct bhnd_nvram_vardefn *defn) 584 { 585 BHND_NV_ASSERT( 586 defn >= bhnd_nvram_vardefns && 587 defn <= &bhnd_nvram_vardefns[bhnd_nvram_num_vardefns-1], 588 ("invalid variable definition pointer %p", defn)); 589 590 return (defn - bhnd_nvram_vardefns); 591 } 592 593 /** 594 * Return the variable definition with the given @p id, or NULL 595 * if no such variable ID is defined. 596 * 597 * @param id variable ID. 598 * 599 * @retval bhnd_nvram_vardefn If a valid definition for @p id is found. 600 * @retval NULL If no definition for @p id is found. 601 */ 602 const struct bhnd_nvram_vardefn * 603 bhnd_nvram_get_vardefn(size_t id) 604 { 605 if (id >= bhnd_nvram_num_vardefns) 606 return (NULL); 607 608 return (&bhnd_nvram_vardefns[id]); 609 } 610 611 /** 612 * Validate an NVRAM variable name. 613 * 614 * Scans for special characters (path delimiters, value delimiters, path 615 * alias prefixes), returning false if the given name cannot be used 616 * as a relative NVRAM key. 617 * 618 * @param name A relative NVRAM variable name to validate. 619 * 620 * @retval true If @p name is a valid relative NVRAM key. 621 * @retval false If @p name should not be used as a relative NVRAM key. 622 */ 623 bool 624 bhnd_nvram_validate_name(const char *name) 625 { 626 /* Reject path-prefixed variable names */ 627 if (bhnd_nvram_trim_path_name(name) != name) 628 return (false); 629 630 /* Reject device path alias declarations (devpath[1-9][0-9]*.*\0) */ 631 if (strncmp(name, "devpath", strlen("devpath")) == 0) { 632 const char *p; 633 char *endp; 634 635 /* Check for trailing [1-9][0-9]* */ 636 p = name + strlen("devpath"); 637 strtoul(p, &endp, 10); 638 if (endp != p) 639 return (false); 640 } 641 642 /* Scan for [^A-Za-z_0-9] */ 643 for (const char *p = name; *p != '\0'; p++) { 644 switch (*p) { 645 /* [0-9_] */ 646 case '0': case '1': case '2': case '3': case '4': 647 case '5': case '6': case '7': case '8': case '9': 648 case '_': 649 break; 650 651 /* [A-Za-z] */ 652 default: 653 if (!bhnd_nv_isalpha(*p)) 654 return (false); 655 break; 656 } 657 } 658 659 return (true); 660 } 661 662 /** 663 * Parses the string in the optionally NUL-terminated @p str to as an integer 664 * value of @p otype, accepting any integer format supported by the standard 665 * strtoul(). 666 * 667 * - Any leading whitespace in @p str -- as defined by the equivalent of 668 * calling isspace_l() with an ASCII locale -- will be ignored. 669 * - A @p str may be prefixed with a single optional '+' or '-' sign denoting 670 * signedness. 671 * - A hexadecimal @p str may include an '0x' or '0X' prefix, denoting that a 672 * base 16 integer follows. 673 * - An octal @p str may include a '0' prefix, denoting that an octal integer 674 * follows. 675 * 676 * If a @p base of 0 is specified, the base will be determined according 677 * to the string's initial prefix, as per strtoul()'s documented behavior. 678 * 679 * When parsing a base 16 integer to a signed representation, if no explicit 680 * sign prefix is given, the string will be parsed as the raw two's complement 681 * representation of the signed integer value. 682 * 683 * @param str The string to be parsed. 684 * @param maxlen The maximum number of bytes to be read in 685 * @p str. 686 * @param base The input string's base (2-36), or 0. 687 * @param[out] nbytes On success or failure, will be set to the total 688 * number of parsed bytes. If the total number of 689 * bytes is not desired, a NULL pointer may be 690 * provided. 691 * @param[out] outp On success, the parsed integer value will be 692 * written to @p outp. This argment may be NULL if 693 * the value is not desired. 694 * @param[in,out] olen The capacity of @p outp. On success, will be set 695 * to the actual size of the requested value. 696 * @param otype The integer type to be parsed. 697 * 698 * @retval 0 success 699 * @retval EINVAL if an invalid @p base is specified. 700 * @retval EINVAL if an unsupported (or non-integer) @p otype is 701 * specified. 702 * @retval ENOMEM If @p outp is non-NULL and a buffer of @p olen is too 703 * small to hold the requested value. 704 * @retval EFTYPE if @p str cannot be parsed as an integer of @p base. 705 * @retval ERANGE If the integer parsed from @p str is too large to be 706 * represented as a value of @p otype. 707 */ 708 int 709 bhnd_nvram_parse_int(const char *str, size_t maxlen, u_int base, 710 size_t *nbytes, void *outp, size_t *olen, bhnd_nvram_type otype) 711 { 712 uint64_t value; 713 uint64_t carry_max, value_max; 714 uint64_t type_max; 715 size_t limit, local_nbytes; 716 size_t ndigits; 717 bool negative, sign, twos_compl; 718 719 /* Must be an integer type */ 720 if (!bhnd_nvram_is_int_type(otype)) 721 return (EINVAL); 722 723 /* Determine output byte limit */ 724 if (outp != NULL) 725 limit = *olen; 726 else 727 limit = 0; 728 729 /* We always need a byte count. If the caller provides a NULL nbytes, 730 * track our position in a stack variable */ 731 if (nbytes == NULL) 732 nbytes = &local_nbytes; 733 734 value = 0; 735 ndigits = 0; 736 *nbytes = 0; 737 negative = false; 738 sign = false; 739 740 /* Validate the specified base */ 741 if (base != 0 && !(base >= 2 && base <= 36)) 742 return (EINVAL); 743 744 /* Skip any leading whitespace */ 745 for (; *nbytes < maxlen; (*nbytes)++) { 746 if (!bhnd_nv_isspace(str[*nbytes])) 747 break; 748 } 749 750 /* Empty string? */ 751 if (*nbytes == maxlen) 752 return (EFTYPE); 753 754 /* Parse and skip sign */ 755 if (str[*nbytes] == '-') { 756 negative = true; 757 sign = true; 758 (*nbytes)++; 759 } else if (str[*nbytes] == '+') { 760 sign = true; 761 (*nbytes)++; 762 } 763 764 /* Truncated after sign character? */ 765 if (*nbytes == maxlen) 766 return (EFTYPE); 767 768 /* Identify (or validate) hex base, skipping 0x/0X prefix */ 769 if (base == 16 || base == 0) { 770 /* Check for (and skip) 0x/0X prefix */ 771 if (maxlen - *nbytes >= 2 && str[*nbytes] == '0' && 772 (str[*nbytes+1] == 'x' || str[*nbytes+1] == 'X')) 773 { 774 base = 16; 775 (*nbytes) += 2; 776 } 777 } 778 779 /* Truncated after hex prefix? */ 780 if (*nbytes == maxlen) 781 return (EFTYPE); 782 783 /* Differentiate decimal/octal by looking for a leading 0 */ 784 if (base == 0) { 785 if (str[*nbytes] == '0') { 786 base = 8; 787 } else { 788 base = 10; 789 } 790 } 791 792 /* Only enable twos-compliment signed integer parsing enabled if the 793 * input is base 16, and no explicit sign prefix was provided */ 794 if (!sign && base == 16) 795 twos_compl = true; 796 else 797 twos_compl = false; 798 799 /* Determine the maximum value representable by the requested type */ 800 switch (otype) { 801 case BHND_NVRAM_TYPE_CHAR: 802 case BHND_NVRAM_TYPE_UINT8: 803 type_max = (uint64_t)UINT8_MAX; 804 break; 805 case BHND_NVRAM_TYPE_UINT16: 806 type_max = (uint64_t)UINT16_MAX; 807 break; 808 case BHND_NVRAM_TYPE_UINT32: 809 type_max = (uint64_t)UINT32_MAX; 810 break; 811 case BHND_NVRAM_TYPE_UINT64: 812 type_max = (uint64_t)UINT64_MAX; 813 break; 814 815 case BHND_NVRAM_TYPE_INT8: 816 if (twos_compl) 817 type_max = (uint64_t)UINT8_MAX; 818 else if (negative) 819 type_max = -(uint64_t)INT8_MIN; 820 else 821 type_max = (uint64_t)INT8_MAX; 822 break; 823 824 case BHND_NVRAM_TYPE_INT16: 825 if (twos_compl) 826 type_max = (uint64_t)UINT16_MAX; 827 else if (negative) 828 type_max = -(uint64_t)INT16_MIN; 829 else 830 type_max = (uint64_t)INT16_MAX; 831 break; 832 833 case BHND_NVRAM_TYPE_INT32: 834 if (twos_compl) 835 type_max = (uint64_t)UINT32_MAX; 836 else if (negative) 837 type_max = -(uint64_t)INT32_MIN; 838 else 839 type_max = (uint64_t)INT32_MAX; 840 break; 841 842 case BHND_NVRAM_TYPE_INT64: 843 if (twos_compl) 844 type_max = (uint64_t)UINT64_MAX; 845 else if (negative) 846 type_max = -(uint64_t)INT64_MIN; 847 else 848 type_max = (uint64_t)INT64_MAX; 849 break; 850 851 default: 852 BHND_NV_LOG("unsupported integer type: %d\n", otype); 853 return (EINVAL); 854 } 855 856 /* The maximum value after which an additional carry would overflow */ 857 value_max = type_max / (uint64_t)base; 858 859 /* The maximum carry value given a value equal to value_max */ 860 carry_max = type_max % (uint64_t)base; 861 862 /* Consume input until we hit maxlen or a non-digit character */ 863 for (; *nbytes < maxlen; (*nbytes)++) { 864 u_long carry; 865 char c; 866 867 /* Parse carry value */ 868 c = str[*nbytes]; 869 if (bhnd_nv_isdigit(c)) { 870 carry = c - '0'; 871 } else if (bhnd_nv_isxdigit(c)) { 872 if (bhnd_nv_isupper(c)) 873 carry = (c - 'A') + 10; 874 else 875 carry = (c - 'a') + 10; 876 } else { 877 /* Hit first non-digit character */ 878 break; 879 } 880 881 /* If carry is outside the base, it's not a valid digit 882 * in the current parse context; consider it a non-digit 883 * character */ 884 if (carry >= (uint64_t)base) 885 break; 886 887 /* Increment count of parsed digits */ 888 ndigits++; 889 890 if (value > value_max) { 891 /* -Any- carry value would overflow */ 892 return (ERANGE); 893 } else if (value == value_max && carry > carry_max) { 894 /* -This- carry value would overflow */ 895 return (ERANGE); 896 } 897 898 value *= (uint64_t)base; 899 value += carry; 900 } 901 902 /* If we hit a non-digit character before parsing the first digit, 903 * we hit an empty integer string. */ 904 if (ndigits == 0) 905 return (EFTYPE); 906 907 if (negative) 908 value = -value; 909 910 /* Provide (and verify) required length */ 911 *olen = bhnd_nvram_type_width(otype); 912 if (outp == NULL) 913 return (0); 914 else if (limit < *olen) 915 return (ENOMEM); 916 917 /* Provide result */ 918 switch (otype) { 919 case BHND_NVRAM_TYPE_CHAR: 920 case BHND_NVRAM_TYPE_UINT8: 921 *(uint8_t *)outp = (uint8_t)value; 922 break; 923 case BHND_NVRAM_TYPE_UINT16: 924 *(uint16_t *)outp = (uint16_t)value; 925 break; 926 case BHND_NVRAM_TYPE_UINT32: 927 *(uint32_t *)outp = (uint32_t)value; 928 break; 929 case BHND_NVRAM_TYPE_UINT64: 930 *(uint64_t *)outp = (uint64_t)value; 931 break; 932 933 case BHND_NVRAM_TYPE_INT8: 934 *(int8_t *)outp = (int8_t)(int64_t)value; 935 break; 936 case BHND_NVRAM_TYPE_INT16: 937 *(int16_t *)outp = (int16_t)(int64_t)value; 938 break; 939 case BHND_NVRAM_TYPE_INT32: 940 *(int32_t *)outp = (int32_t)(int64_t)value; 941 break; 942 case BHND_NVRAM_TYPE_INT64: 943 *(int64_t *)outp = (int64_t)value; 944 break; 945 default: 946 /* unreachable */ 947 BHND_NV_PANIC("unhandled type %d\n", otype); 948 } 949 950 return (0); 951 } 952 953 /** 954 * Trim leading path (pci/1/1) or path alias (0:) prefix from @p name, if any, 955 * returning a pointer to the start of the relative variable name. 956 * 957 * @par Examples 958 * 959 * - "/foo" -> "foo" 960 * - "dev/pci/foo" -> "foo" 961 * - "0:foo" -> "foo" 962 * - "foo" -> "foo" 963 * 964 * @param name The string to be trimmed. 965 * 966 * @return A pointer to the start of the relative variable name in @p name. 967 */ 968 const char * 969 bhnd_nvram_trim_path_name(const char *name) 970 { 971 char *endp; 972 973 /* path alias prefix? (0:varname) */ 974 if (bhnd_nv_isdigit(*name)) { 975 /* Parse '0...:' alias prefix, if it exists */ 976 strtoul(name, &endp, 10); 977 if (endp != name && *endp == ':') { 978 /* Variable name follows 0: prefix */ 979 return (endp+1); 980 } 981 } 982 983 /* device path prefix? (pci/1/1/varname) */ 984 if ((endp = strrchr(name, '/')) != NULL) { 985 /* Variable name follows the final path separator '/' */ 986 return (endp+1); 987 } 988 989 /* variable name is not prefixed */ 990 return (name); 991 } 992 993 /** 994 * Parse a 'name=value' string. 995 * 996 * @param env The string to be parsed. 997 * @param env_len The length of @p envp. 998 * @param delim The delimiter used in @p envp. This will generally be '='. 999 * @param[out] name If not NULL, a pointer to the name string. This argument 1000 * may be NULL. 1001 * @param[out] name_len On success, the length of the name substring. This 1002 * argument may be NULL. 1003 * @param[out] value On success, a pointer to the value substring. This argument 1004 * may be NULL. 1005 * @param[out] value_len On success, the length of the value substring. This 1006 * argument may be NULL. 1007 * 1008 * @retval 0 success 1009 * @retval EINVAL if parsing @p envp fails. 1010 */ 1011 int 1012 bhnd_nvram_parse_env(const char *env, size_t env_len, char delim, 1013 const char **name, size_t *name_len, const char **value, size_t *value_len) 1014 { 1015 const char *p; 1016 1017 /* Name */ 1018 if ((p = memchr(env, delim, env_len)) == NULL) { 1019 BHND_NV_LOG("delimiter '%c' not found in '%.*s'\n", delim, 1020 BHND_NV_PRINT_WIDTH(env_len), env); 1021 return (EINVAL); 1022 } 1023 1024 /* Name */ 1025 if (name != NULL) 1026 *name = env; 1027 if (name_len != NULL) 1028 *name_len = p - env; 1029 1030 /* Skip delim */ 1031 p++; 1032 1033 /* Value */ 1034 if (value != NULL) 1035 *value = p; 1036 if (value_len != NULL) 1037 *value_len = env_len - (p - env); 1038 1039 return (0); 1040 } 1041 1042 1043 /** 1044 * Parse a field value, returning the actual pointer to the first 1045 * non-whitespace character and the total size of the field. 1046 * 1047 * @param[in,out] inp The field string to parse. Will be updated to point 1048 * at the first non-whitespace character found. 1049 * @param ilen The length of @p inp, in bytes. 1050 * @param delim The field delimiter to search for. 1051 * 1052 * @return Returns the actual size of the field data. 1053 */ 1054 size_t 1055 bhnd_nvram_parse_field(const char **inp, size_t ilen, char delim) 1056 { 1057 const char *p, *sp; 1058 1059 /* Skip any leading whitespace */ 1060 for (sp = *inp; (size_t)(sp-*inp) < ilen && bhnd_nv_isspace(*sp); sp++) 1061 continue; 1062 1063 *inp = sp; 1064 1065 /* Find the last field character */ 1066 for (p = *inp; (size_t)(p - *inp) < ilen; p++) { 1067 if (*p == delim || *p == '\0') 1068 break; 1069 } 1070 1071 return (p - *inp); 1072 } 1073 1074 /** 1075 * Parse a field value, returning the actual pointer to the first 1076 * non-whitespace character and the total size of the field, minus 1077 * any trailing whitespace. 1078 * 1079 * @param[in,out] inp The field string to parse. Will be updated to point 1080 * at the first non-whitespace character found. 1081 * @param ilen The length of the parsed field, in bytes, excluding the 1082 * field elimiter and any trailing whitespace. 1083 * @param delim The field delimiter to search for. 1084 * 1085 * @return Returns the actual size of the field data. 1086 */ 1087 size_t 1088 bhnd_nvram_trim_field(const char **inp, size_t ilen, char delim) 1089 { 1090 const char *sp; 1091 size_t plen; 1092 1093 plen = bhnd_nvram_parse_field(inp, ilen, delim); 1094 1095 /* Trim trailing whitespace */ 1096 sp = *inp; 1097 while (plen > 0) { 1098 if (!bhnd_nv_isspace(*(sp + plen - 1))) 1099 break; 1100 1101 plen--; 1102 } 1103 1104 return (plen); 1105 } 1106