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 * BHND_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 * @see BHND_NVRAM_TYPE_STRING_ARRAY 545 */ 546 const char * 547 bhnd_nvram_string_array_next(const char *inp, size_t ilen, const char *prev, 548 size_t *olen) 549 { 550 return (bhnd_nvram_value_array_next(inp, ilen, 551 BHND_NVRAM_TYPE_STRING_ARRAY, prev, olen)); 552 } 553 554 /* used by bhnd_nvram_find_vardefn() */ 555 static int 556 bhnd_nvram_find_vardefn_compare(const void *key, const void *rhs) 557 { 558 const struct bhnd_nvram_vardefn *r = rhs; 559 560 return (strcmp((const char *)key, r->name)); 561 } 562 563 /** 564 * Find and return the variable definition for @p varname, if any. 565 * 566 * @param varname variable name 567 * 568 * @retval bhnd_nvram_vardefn If a valid definition for @p varname is found. 569 * @retval NULL If no definition for @p varname is found. 570 */ 571 const struct bhnd_nvram_vardefn * 572 bhnd_nvram_find_vardefn(const char *varname) 573 { 574 return (bsearch(varname, bhnd_nvram_vardefns, bhnd_nvram_num_vardefns, 575 sizeof(bhnd_nvram_vardefns[0]), bhnd_nvram_find_vardefn_compare)); 576 } 577 578 /** 579 * Return the variable ID for a variable definition. 580 * 581 * @param defn Variable definition previously returned by 582 * bhnd_nvram_find_vardefn() or bhnd_nvram_get_vardefn(). 583 */ 584 size_t 585 bhnd_nvram_get_vardefn_id(const struct bhnd_nvram_vardefn *defn) 586 { 587 BHND_NV_ASSERT( 588 defn >= bhnd_nvram_vardefns && 589 defn <= &bhnd_nvram_vardefns[bhnd_nvram_num_vardefns-1], 590 ("invalid variable definition pointer %p", defn)); 591 592 return (defn - bhnd_nvram_vardefns); 593 } 594 595 /** 596 * Return the variable definition with the given @p id, or NULL 597 * if no such variable ID is defined. 598 * 599 * @param id variable ID. 600 * 601 * @retval bhnd_nvram_vardefn If a valid definition for @p id is found. 602 * @retval NULL If no definition for @p id is found. 603 */ 604 const struct bhnd_nvram_vardefn * 605 bhnd_nvram_get_vardefn(size_t id) 606 { 607 if (id >= bhnd_nvram_num_vardefns) 608 return (NULL); 609 610 return (&bhnd_nvram_vardefns[id]); 611 } 612 613 /** 614 * Validate an NVRAM variable name. 615 * 616 * Scans for special characters (path delimiters, value delimiters, path 617 * alias prefixes), returning false if the given name cannot be used 618 * as a relative NVRAM key. 619 * 620 * @param name A relative NVRAM variable name to validate. 621 * 622 * @retval true If @p name is a valid relative NVRAM key. 623 * @retval false If @p name should not be used as a relative NVRAM key. 624 */ 625 bool 626 bhnd_nvram_validate_name(const char *name) 627 { 628 /* Reject path-prefixed variable names */ 629 if (bhnd_nvram_trim_path_name(name) != name) 630 return (false); 631 632 /* Reject device path alias declarations (devpath[1-9][0-9]*.*\0) */ 633 if (strncmp(name, "devpath", strlen("devpath")) == 0) { 634 const char *p; 635 char *endp; 636 637 /* Check for trailing [1-9][0-9]* */ 638 p = name + strlen("devpath"); 639 strtoul(p, &endp, 10); 640 if (endp != p) 641 return (false); 642 } 643 644 /* Scan for [^A-Za-z_0-9] */ 645 for (const char *p = name; *p != '\0'; p++) { 646 switch (*p) { 647 /* [0-9_] */ 648 case '0': case '1': case '2': case '3': case '4': 649 case '5': case '6': case '7': case '8': case '9': 650 case '_': 651 break; 652 653 /* [A-Za-z] */ 654 default: 655 if (!bhnd_nv_isalpha(*p)) 656 return (false); 657 break; 658 } 659 } 660 661 return (true); 662 } 663 664 /** 665 * Parses the string in the optionally NUL-terminated @p str to as an integer 666 * value of @p otype, accepting any integer format supported by the standard 667 * strtoul(). 668 * 669 * - Any leading whitespace in @p str -- as defined by the equivalent of 670 * calling isspace_l() with an ASCII locale -- will be ignored. 671 * - A @p str may be prefixed with a single optional '+' or '-' sign denoting 672 * signedness. 673 * - A hexadecimal @p str may include an '0x' or '0X' prefix, denoting that a 674 * base 16 integer follows. 675 * - An octal @p str may include a '0' prefix, denoting that an octal integer 676 * follows. 677 * 678 * If a @p base of 0 is specified, the base will be determined according 679 * to the string's initial prefix, as per strtoul()'s documented behavior. 680 * 681 * When parsing a base 16 integer to a signed representation, if no explicit 682 * sign prefix is given, the string will be parsed as the raw two's complement 683 * representation of the signed integer value. 684 * 685 * @param str The string to be parsed. 686 * @param maxlen The maximum number of bytes to be read in 687 * @p str. 688 * @param base The input string's base (2-36), or 0. 689 * @param[out] nbytes On success or failure, will be set to the total 690 * number of parsed bytes. If the total number of 691 * bytes is not desired, a NULL pointer may be 692 * provided. 693 * @param[out] outp On success, the parsed integer value will be 694 * written to @p outp. This argment may be NULL if 695 * the value is not desired. 696 * @param[in,out] olen The capacity of @p outp. On success, will be set 697 * to the actual size of the requested value. 698 * @param otype The integer type to be parsed. 699 * 700 * @retval 0 success 701 * @retval EINVAL if an invalid @p base is specified. 702 * @retval EINVAL if an unsupported (or non-integer) @p otype is 703 * specified. 704 * @retval ENOMEM If @p outp is non-NULL and a buffer of @p olen is too 705 * small to hold the requested value. 706 * @retval EFTYPE if @p str cannot be parsed as an integer of @p base. 707 * @retval ERANGE If the integer parsed from @p str is too large to be 708 * represented as a value of @p otype. 709 */ 710 int 711 bhnd_nvram_parse_int(const char *str, size_t maxlen, u_int base, 712 size_t *nbytes, void *outp, size_t *olen, bhnd_nvram_type otype) 713 { 714 uint64_t value; 715 uint64_t carry_max, value_max; 716 uint64_t type_max; 717 size_t limit, local_nbytes; 718 size_t ndigits; 719 bool negative, sign, twos_compl; 720 721 /* Must be an integer type */ 722 if (!bhnd_nvram_is_int_type(otype)) 723 return (EINVAL); 724 725 /* Determine output byte limit */ 726 if (outp != NULL) 727 limit = *olen; 728 else 729 limit = 0; 730 731 /* We always need a byte count. If the caller provides a NULL nbytes, 732 * track our position in a stack variable */ 733 if (nbytes == NULL) 734 nbytes = &local_nbytes; 735 736 value = 0; 737 ndigits = 0; 738 *nbytes = 0; 739 negative = false; 740 sign = false; 741 742 /* Validate the specified base */ 743 if (base != 0 && !(base >= 2 && base <= 36)) 744 return (EINVAL); 745 746 /* Skip any leading whitespace */ 747 for (; *nbytes < maxlen; (*nbytes)++) { 748 if (!bhnd_nv_isspace(str[*nbytes])) 749 break; 750 } 751 752 /* Empty string? */ 753 if (*nbytes == maxlen) 754 return (EFTYPE); 755 756 /* Parse and skip sign */ 757 if (str[*nbytes] == '-') { 758 negative = true; 759 sign = true; 760 (*nbytes)++; 761 } else if (str[*nbytes] == '+') { 762 sign = true; 763 (*nbytes)++; 764 } 765 766 /* Truncated after sign character? */ 767 if (*nbytes == maxlen) 768 return (EFTYPE); 769 770 /* Identify (or validate) hex base, skipping 0x/0X prefix */ 771 if (base == 16 || base == 0) { 772 /* Check for (and skip) 0x/0X prefix */ 773 if (maxlen - *nbytes >= 2 && str[*nbytes] == '0' && 774 (str[*nbytes+1] == 'x' || str[*nbytes+1] == 'X')) 775 { 776 base = 16; 777 (*nbytes) += 2; 778 } 779 } 780 781 /* Truncated after hex prefix? */ 782 if (*nbytes == maxlen) 783 return (EFTYPE); 784 785 /* Differentiate decimal/octal by looking for a leading 0 */ 786 if (base == 0) { 787 if (str[*nbytes] == '0') { 788 base = 8; 789 } else { 790 base = 10; 791 } 792 } 793 794 /* Only enable twos-compliment signed integer parsing enabled if the 795 * input is base 16, and no explicit sign prefix was provided */ 796 if (!sign && base == 16) 797 twos_compl = true; 798 else 799 twos_compl = false; 800 801 /* Determine the maximum value representable by the requested type */ 802 switch (otype) { 803 case BHND_NVRAM_TYPE_CHAR: 804 case BHND_NVRAM_TYPE_UINT8: 805 type_max = (uint64_t)UINT8_MAX; 806 break; 807 case BHND_NVRAM_TYPE_UINT16: 808 type_max = (uint64_t)UINT16_MAX; 809 break; 810 case BHND_NVRAM_TYPE_UINT32: 811 type_max = (uint64_t)UINT32_MAX; 812 break; 813 case BHND_NVRAM_TYPE_UINT64: 814 type_max = (uint64_t)UINT64_MAX; 815 break; 816 817 case BHND_NVRAM_TYPE_INT8: 818 if (twos_compl) 819 type_max = (uint64_t)UINT8_MAX; 820 else if (negative) 821 type_max = -(uint64_t)INT8_MIN; 822 else 823 type_max = (uint64_t)INT8_MAX; 824 break; 825 826 case BHND_NVRAM_TYPE_INT16: 827 if (twos_compl) 828 type_max = (uint64_t)UINT16_MAX; 829 else if (negative) 830 type_max = -(uint64_t)INT16_MIN; 831 else 832 type_max = (uint64_t)INT16_MAX; 833 break; 834 835 case BHND_NVRAM_TYPE_INT32: 836 if (twos_compl) 837 type_max = (uint64_t)UINT32_MAX; 838 else if (negative) 839 type_max = -(uint64_t)INT32_MIN; 840 else 841 type_max = (uint64_t)INT32_MAX; 842 break; 843 844 case BHND_NVRAM_TYPE_INT64: 845 if (twos_compl) 846 type_max = (uint64_t)UINT64_MAX; 847 else if (negative) 848 type_max = -(uint64_t)INT64_MIN; 849 else 850 type_max = (uint64_t)INT64_MAX; 851 break; 852 853 default: 854 BHND_NV_LOG("unsupported integer type: %d\n", otype); 855 return (EINVAL); 856 } 857 858 /* The maximum value after which an additional carry would overflow */ 859 value_max = type_max / (uint64_t)base; 860 861 /* The maximum carry value given a value equal to value_max */ 862 carry_max = type_max % (uint64_t)base; 863 864 /* Consume input until we hit maxlen or a non-digit character */ 865 for (; *nbytes < maxlen; (*nbytes)++) { 866 u_long carry; 867 char c; 868 869 /* Parse carry value */ 870 c = str[*nbytes]; 871 if (bhnd_nv_isdigit(c)) { 872 carry = c - '0'; 873 } else if (bhnd_nv_isxdigit(c)) { 874 if (bhnd_nv_isupper(c)) 875 carry = (c - 'A') + 10; 876 else 877 carry = (c - 'a') + 10; 878 } else { 879 /* Hit first non-digit character */ 880 break; 881 } 882 883 /* If carry is outside the base, it's not a valid digit 884 * in the current parse context; consider it a non-digit 885 * character */ 886 if (carry >= (uint64_t)base) 887 break; 888 889 /* Increment count of parsed digits */ 890 ndigits++; 891 892 if (value > value_max) { 893 /* -Any- carry value would overflow */ 894 return (ERANGE); 895 } else if (value == value_max && carry > carry_max) { 896 /* -This- carry value would overflow */ 897 return (ERANGE); 898 } 899 900 value *= (uint64_t)base; 901 value += carry; 902 } 903 904 /* If we hit a non-digit character before parsing the first digit, 905 * we hit an empty integer string. */ 906 if (ndigits == 0) 907 return (EFTYPE); 908 909 if (negative) 910 value = -value; 911 912 /* Provide (and verify) required length */ 913 *olen = bhnd_nvram_type_width(otype); 914 if (outp == NULL) 915 return (0); 916 else if (limit < *olen) 917 return (ENOMEM); 918 919 /* Provide result */ 920 switch (otype) { 921 case BHND_NVRAM_TYPE_CHAR: 922 case BHND_NVRAM_TYPE_UINT8: 923 *(uint8_t *)outp = (uint8_t)value; 924 break; 925 case BHND_NVRAM_TYPE_UINT16: 926 *(uint16_t *)outp = (uint16_t)value; 927 break; 928 case BHND_NVRAM_TYPE_UINT32: 929 *(uint32_t *)outp = (uint32_t)value; 930 break; 931 case BHND_NVRAM_TYPE_UINT64: 932 *(uint64_t *)outp = (uint64_t)value; 933 break; 934 935 case BHND_NVRAM_TYPE_INT8: 936 *(int8_t *)outp = (int8_t)(int64_t)value; 937 break; 938 case BHND_NVRAM_TYPE_INT16: 939 *(int16_t *)outp = (int16_t)(int64_t)value; 940 break; 941 case BHND_NVRAM_TYPE_INT32: 942 *(int32_t *)outp = (int32_t)(int64_t)value; 943 break; 944 case BHND_NVRAM_TYPE_INT64: 945 *(int64_t *)outp = (int64_t)value; 946 break; 947 default: 948 /* unreachable */ 949 BHND_NV_PANIC("unhandled type %d\n", otype); 950 } 951 952 return (0); 953 } 954 955 /** 956 * Trim leading path (pci/1/1) or path alias (0:) prefix from @p name, if any, 957 * returning a pointer to the start of the relative variable name. 958 * 959 * @par Examples 960 * 961 * - "/foo" -> "foo" 962 * - "dev/pci/foo" -> "foo" 963 * - "0:foo" -> "foo" 964 * - "foo" -> "foo" 965 * 966 * @param name The string to be trimmed. 967 * 968 * @return A pointer to the start of the relative variable name in @p name. 969 */ 970 const char * 971 bhnd_nvram_trim_path_name(const char *name) 972 { 973 char *endp; 974 975 /* path alias prefix? (0:varname) */ 976 if (bhnd_nv_isdigit(*name)) { 977 /* Parse '0...:' alias prefix, if it exists */ 978 strtoul(name, &endp, 10); 979 if (endp != name && *endp == ':') { 980 /* Variable name follows 0: prefix */ 981 return (endp+1); 982 } 983 } 984 985 /* device path prefix? (pci/1/1/varname) */ 986 if ((endp = strrchr(name, '/')) != NULL) { 987 /* Variable name follows the final path separator '/' */ 988 return (endp+1); 989 } 990 991 /* variable name is not prefixed */ 992 return (name); 993 } 994 995 /** 996 * Parse a 'name=value' string. 997 * 998 * @param env The string to be parsed. 999 * @param env_len The length of @p envp. 1000 * @param delim The delimiter used in @p envp. This will generally be '='. 1001 * @param[out] name If not NULL, a pointer to the name string. This argument 1002 * may be NULL. 1003 * @param[out] name_len On success, the length of the name substring. This 1004 * argument may be NULL. 1005 * @param[out] value On success, a pointer to the value substring. This argument 1006 * may be NULL. 1007 * @param[out] value_len On success, the length of the value substring. This 1008 * argument may be NULL. 1009 * 1010 * @retval 0 success 1011 * @retval EINVAL if parsing @p envp fails. 1012 */ 1013 int 1014 bhnd_nvram_parse_env(const char *env, size_t env_len, char delim, 1015 const char **name, size_t *name_len, const char **value, size_t *value_len) 1016 { 1017 const char *p; 1018 1019 /* Name */ 1020 if ((p = memchr(env, delim, env_len)) == NULL) { 1021 BHND_NV_LOG("delimiter '%c' not found in '%.*s'\n", delim, 1022 BHND_NV_PRINT_WIDTH(env_len), env); 1023 return (EINVAL); 1024 } 1025 1026 /* Name */ 1027 if (name != NULL) 1028 *name = env; 1029 if (name_len != NULL) 1030 *name_len = p - env; 1031 1032 /* Skip delim */ 1033 p++; 1034 1035 /* Value */ 1036 if (value != NULL) 1037 *value = p; 1038 if (value_len != NULL) 1039 *value_len = env_len - (p - env); 1040 1041 return (0); 1042 } 1043 1044 1045 /** 1046 * Parse a field value, returning the actual pointer to the first 1047 * non-whitespace character and the total size of the field. 1048 * 1049 * @param[in,out] inp The field string to parse. Will be updated to point 1050 * at the first non-whitespace character found. 1051 * @param ilen The length of @p inp, in bytes. 1052 * @param delim The field delimiter to search for. 1053 * 1054 * @return Returns the actual size of the field data. 1055 */ 1056 size_t 1057 bhnd_nvram_parse_field(const char **inp, size_t ilen, char delim) 1058 { 1059 const char *p, *sp; 1060 1061 /* Skip any leading whitespace */ 1062 for (sp = *inp; (size_t)(sp-*inp) < ilen && bhnd_nv_isspace(*sp); sp++) 1063 continue; 1064 1065 *inp = sp; 1066 1067 /* Find the last field character */ 1068 for (p = *inp; (size_t)(p - *inp) < ilen; p++) { 1069 if (*p == delim || *p == '\0') 1070 break; 1071 } 1072 1073 return (p - *inp); 1074 } 1075 1076 /** 1077 * Parse a field value, returning the actual pointer to the first 1078 * non-whitespace character and the total size of the field, minus 1079 * any trailing whitespace. 1080 * 1081 * @param[in,out] inp The field string to parse. Will be updated to point 1082 * at the first non-whitespace character found. 1083 * @param ilen The length of the parsed field, in bytes, excluding the 1084 * field elimiter and any trailing whitespace. 1085 * @param delim The field delimiter to search for. 1086 * 1087 * @return Returns the actual size of the field data. 1088 */ 1089 size_t 1090 bhnd_nvram_trim_field(const char **inp, size_t ilen, char delim) 1091 { 1092 const char *sp; 1093 size_t plen; 1094 1095 plen = bhnd_nvram_parse_field(inp, ilen, delim); 1096 1097 /* Trim trailing whitespace */ 1098 sp = *inp; 1099 while (plen > 0) { 1100 if (!bhnd_nv_isspace(*(sp + plen - 1))) 1101 break; 1102 1103 plen--; 1104 } 1105 1106 return (plen); 1107 } 1108