src/boot/efi/util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <efi.h>
   4 #include <efilib.h>
   5
   6 #include "util.h"
   7
   8 #ifdef __x86_64__
   9 UINT64 ticks_read(VOID) {
  10         UINT64 a, d;
  11         __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
  12         return (d << 32) | a;
  13 }
  14 #elif defined(__i386__)
  15 UINT64 ticks_read(VOID) {
  16         UINT64 val;
  17         __asm__ volatile ("rdtsc" : "=A" (val));
  18         return val;
  19 }
  20 #elif defined(__aarch64__)
  21 UINT64 ticks_read(VOID) {
  22         UINT64 val;
  23         __asm__ volatile ("mrs %0, cntpct_el0" : "=r" (val));
  24         return val;
  25 }
  26 #else
  27 UINT64 ticks_read(VOID) {
  28         UINT64 val = 1;
  29         return val;
  30 }
  31 #endif
  32
  33 #if defined(__aarch64__)
  34 UINT64 ticks_freq(VOID) {
  35         UINT64 freq;
  36         __asm__ volatile ("mrs %0, cntfrq_el0": "=r" (freq));
  37         return freq;
  38 }
  39 #else
  40 /* count TSC ticks during a millisecond delay */
  41 UINT64 ticks_freq(VOID) {
  42         UINT64 ticks_start, ticks_end;
  43
  44         ticks_start = ticks_read();
  45         uefi_call_wrapper(BS->Stall, 1, 1000);
  46         ticks_end = ticks_read();
  47
  48         return (ticks_end - ticks_start) * 1000UL;
  49 }
  50 #endif
  51
  52 UINT64 time_usec(VOID) {
  53         UINT64 ticks;
  54         static UINT64 freq;
  55
  56         ticks = ticks_read();
  57         if (ticks == 0)
  58                 return 0;
  59
  60         if (freq == 0) {
  61                 freq = ticks_freq();
  62                 if (freq == 0)
  63                         return 0;
  64         }
  65
  66         return 1000UL * 1000UL * ticks / freq;
  67 }
  68
  69 EFI_STATUS parse_boolean(const CHAR8 *v, BOOLEAN *b) {
  70         assert(b);
  71
  72         if (!v)
  73                 return EFI_INVALID_PARAMETER;
  74
  75         if (strcmpa(v, (CHAR8 *)"1") == 0 ||
  76             strcmpa(v, (CHAR8 *)"yes") == 0 ||
  77             strcmpa(v, (CHAR8 *)"y") == 0 ||
  78             strcmpa(v, (CHAR8 *)"true") == 0 ||
  79             strcmpa(v, (CHAR8 *)"t") == 0 ||
  80             strcmpa(v, (CHAR8 *)"on") == 0) {
  81                 *b = TRUE;
  82                 return EFI_SUCCESS;
  83         }
  84
  85         if (strcmpa(v, (CHAR8 *)"0") == 0 ||
  86             strcmpa(v, (CHAR8 *)"no") == 0 ||
  87             strcmpa(v, (CHAR8 *)"n") == 0 ||
  88             strcmpa(v, (CHAR8 *)"false") == 0 ||
  89             strcmpa(v, (CHAR8 *)"f") == 0 ||
  90             strcmpa(v, (CHAR8 *)"off") == 0) {
  91                 *b = FALSE;
  92                 return EFI_SUCCESS;
  93         }
  94
  95         return EFI_INVALID_PARAMETER;
  96 }
  97
  98 EFI_STATUS efivar_set_raw(const EFI_GUID *vendor, const CHAR16 *name, const VOID *buf, UINTN size, UINT32 flags) {
  99         assert(vendor);
 100         assert(name);
 101         assert(buf || size == 0);
 102
 103         flags |= EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
 104         return uefi_call_wrapper(RT->SetVariable, 5, (CHAR16*) name, (EFI_GUID *)vendor, flags, size, (VOID*) buf);
 105 }
 106
 107 EFI_STATUS efivar_set(const EFI_GUID *vendor, const CHAR16 *name, const CHAR16 *value, UINT32 flags) {
 108         assert(vendor);
 109         assert(name);
 110
 111         return efivar_set_raw(vendor, name, value, value ? StrSize(value) : 0, flags);
 112 }
 113
 114 EFI_STATUS efivar_set_uint_string(const EFI_GUID *vendor, const CHAR16 *name, UINTN i, UINT32 flags) {
 115         CHAR16 str[32];
 116
 117         assert(vendor);
 118         assert(name);
 119
 120         SPrint(str, ELEMENTSOF(str), L"%u", i);
 121         return efivar_set(vendor, name, str, flags);
 122 }
 123
 124 EFI_STATUS efivar_set_uint32_le(const EFI_GUID *vendor, const CHAR16 *name, UINT32 value, UINT32 flags) {
 125         UINT8 buf[4];
 126
 127         assert(vendor);
 128         assert(name);
 129
 130         buf[0] = (UINT8)(value >> 0U & 0xFF);
 131         buf[1] = (UINT8)(value >> 8U & 0xFF);
 132         buf[2] = (UINT8)(value >> 16U & 0xFF);
 133         buf[3] = (UINT8)(value >> 24U & 0xFF);
 134
 135         return efivar_set_raw(vendor, name, buf, sizeof(buf), flags);
 136 }
 137
 138 EFI_STATUS efivar_set_uint64_le(const EFI_GUID *vendor, const CHAR16 *name, UINT64 value, UINT32 flags) {
 139         UINT8 buf[8];
 140
 141         assert(vendor);
 142         assert(name);
 143
 144         buf[0] = (UINT8)(value >> 0U & 0xFF);
 145         buf[1] = (UINT8)(value >> 8U & 0xFF);
 146         buf[2] = (UINT8)(value >> 16U & 0xFF);
 147         buf[3] = (UINT8)(value >> 24U & 0xFF);
 148         buf[4] = (UINT8)(value >> 32U & 0xFF);
 149         buf[5] = (UINT8)(value >> 40U & 0xFF);
 150         buf[6] = (UINT8)(value >> 48U & 0xFF);
 151         buf[7] = (UINT8)(value >> 56U & 0xFF);
 152
 153         return efivar_set_raw(vendor, name, buf, sizeof(buf), flags);
 154 }
 155
 156 EFI_STATUS efivar_get(const EFI_GUID *vendor, const CHAR16 *name, CHAR16 **value) {
 157         _cleanup_freepool_ CHAR16 *buf = NULL;
 158         EFI_STATUS err;
 159         CHAR16 *val;
 160         UINTN size;
 161
 162         assert(vendor);
 163         assert(name);
 164
 165         err = efivar_get_raw(vendor, name, (CHAR8**)&buf, &size);
 166         if (EFI_ERROR(err))
 167                 return err;
 168
 169         /* Make sure there are no incomplete characters in the buffer */
 170         if ((size % sizeof(CHAR16)) != 0)
 171                 return EFI_INVALID_PARAMETER;
 172
 173         if (!value)
 174                 return EFI_SUCCESS;
 175
 176         /* Return buffer directly if it happens to be NUL terminated already */
 177         if (size >= sizeof(CHAR16) && buf[size/sizeof(CHAR16)] == 0) {
 178                 *value = TAKE_PTR(buf);
 179                 return EFI_SUCCESS;
 180         }
 181
 182         /* Make sure a terminating NUL is available at the end */
 183         val = AllocatePool(size + sizeof(CHAR16));
 184         if (!val)
 185                 return EFI_OUT_OF_RESOURCES;
 186
 187         CopyMem(val, buf, size);
 188         val[size / sizeof(CHAR16)] = 0; /* NUL terminate */
 189
 190         *value = val;
 191         return EFI_SUCCESS;
 192 }
 193
 194 EFI_STATUS efivar_get_uint_string(const EFI_GUID *vendor, const CHAR16 *name, UINTN *i) {
 195         _cleanup_freepool_ CHAR16 *val = NULL;
 196         EFI_STATUS err;
 197
 198         assert(vendor);
 199         assert(name);
 200         assert(i);
 201
 202         err = efivar_get(vendor, name, &val);
 203         if (!EFI_ERROR(err))
 204                 *i = Atoi(val);
 205
 206         return err;
 207 }
 208
 209 EFI_STATUS efivar_get_uint32_le(const EFI_GUID *vendor, const CHAR16 *name, UINT32 *ret) {
 210         _cleanup_freepool_ CHAR8 *buf = NULL;
 211         UINTN size;
 212         EFI_STATUS err;
 213
 214         assert(vendor);
 215         assert(name);
 216
 217         err = efivar_get_raw(vendor, name, &buf, &size);
 218         if (!EFI_ERROR(err) && ret) {
 219                 if (size != sizeof(UINT32))
 220                         return EFI_BUFFER_TOO_SMALL;
 221
 222                 *ret = (UINT32) buf[0] << 0U | (UINT32) buf[1] << 8U | (UINT32) buf[2] << 16U |
 223                         (UINT32) buf[3] << 24U;
 224         }
 225
 226         return err;
 227 }
 228
 229 EFI_STATUS efivar_get_uint64_le(const EFI_GUID *vendor, const CHAR16 *name, UINT64 *ret) {
 230         _cleanup_freepool_ CHAR8 *buf = NULL;
 231         UINTN size;
 232         EFI_STATUS err;
 233
 234         assert(vendor);
 235         assert(name);
 236
 237         err = efivar_get_raw(vendor, name, &buf, &size);
 238         if (!EFI_ERROR(err) && ret) {
 239                 if (size != sizeof(UINT64))
 240                         return EFI_BUFFER_TOO_SMALL;
 241
 242                 *ret = (UINT64) buf[0] << 0U | (UINT64) buf[1] << 8U | (UINT64) buf[2] << 16U |
 243                         (UINT64) buf[3] << 24U | (UINT64) buf[4] << 32U | (UINT64) buf[5] << 40U |
 244                         (UINT64) buf[6] << 48U | (UINT64) buf[7] << 56U;
 245         }
 246
 247         return err;
 248 }
 249
 250 EFI_STATUS efivar_get_raw(const EFI_GUID *vendor, const CHAR16 *name, CHAR8 **buffer, UINTN *size) {
 251         _cleanup_freepool_ CHAR8 *buf = NULL;
 252         UINTN l;
 253         EFI_STATUS err;
 254
 255         assert(vendor);
 256         assert(name);
 257
 258         l = sizeof(CHAR16 *) * EFI_MAXIMUM_VARIABLE_SIZE;
 259         buf = AllocatePool(l);
 260         if (!buf)
 261                 return EFI_OUT_OF_RESOURCES;
 262
 263         err = uefi_call_wrapper(RT->GetVariable, 5, (CHAR16*) name, (EFI_GUID *)vendor, NULL, &l, buf);
 264         if (!EFI_ERROR(err)) {
 265
 266                 if (buffer)
 267                         *buffer = TAKE_PTR(buf);
 268
 269                 if (size)
 270                         *size = l;
 271         }
 272
 273         return err;
 274 }
 275
 276 EFI_STATUS efivar_get_boolean_u8(const EFI_GUID *vendor, const CHAR16 *name, BOOLEAN *ret) {
 277         _cleanup_freepool_ CHAR8 *b = NULL;
 278         UINTN size;
 279         EFI_STATUS err;
 280
 281         assert(vendor);
 282         assert(name);
 283         assert(ret);
 284
 285         err = efivar_get_raw(vendor, name, &b, &size);
 286         if (!EFI_ERROR(err))
 287                 *ret = *b > 0;
 288
 289         return err;
 290 }
 291
 292 VOID efivar_set_time_usec(const EFI_GUID *vendor, const CHAR16 *name, UINT64 usec) {
 293         CHAR16 str[32];
 294
 295         assert(vendor);
 296         assert(name);
 297
 298         if (usec == 0)
 299                 usec = time_usec();
 300         if (usec == 0)
 301                 return;
 302
 303         SPrint(str, ELEMENTSOF(str), L"%ld", usec);
 304         efivar_set(vendor, name, str, 0);
 305 }
 306
 307 static INTN utf8_to_16(const CHAR8 *stra, CHAR16 *c) {
 308         CHAR16 unichar;
 309         UINTN len;
 310
 311         assert(stra);
 312         assert(c);
 313
 314         if (!(stra[0] & 0x80))
 315                 len = 1;
 316         else if ((stra[0] & 0xe0) == 0xc0)
 317                 len = 2;
 318         else if ((stra[0] & 0xf0) == 0xe0)
 319                 len = 3;
 320         else if ((stra[0] & 0xf8) == 0xf0)
 321                 len = 4;
 322         else if ((stra[0] & 0xfc) == 0xf8)
 323                 len = 5;
 324         else if ((stra[0] & 0xfe) == 0xfc)
 325                 len = 6;
 326         else
 327                 return -1;
 328
 329         switch (len) {
 330         case 1:
 331                 unichar = stra[0];
 332                 break;
 333         case 2:
 334                 unichar = stra[0] & 0x1f;
 335                 break;
 336         case 3:
 337                 unichar = stra[0] & 0x0f;
 338                 break;
 339         case 4:
 340                 unichar = stra[0] & 0x07;
 341                 break;
 342         case 5:
 343                 unichar = stra[0] & 0x03;
 344                 break;
 345         case 6:
 346                 unichar = stra[0] & 0x01;
 347                 break;
 348         }
 349
 350         for (UINTN i = 1; i < len; i++) {
 351                 if ((stra[i] & 0xc0) != 0x80)
 352                         return -1;
 353                 unichar <<= 6;
 354                 unichar |= stra[i] & 0x3f;
 355         }
 356
 357         *c = unichar;
 358         return len;
 359 }
 360
 361 CHAR16 *stra_to_str(const CHAR8 *stra) {
 362         UINTN strlen;
 363         UINTN len;
 364         UINTN i;
 365         CHAR16 *str;
 366
 367         assert(stra);
 368
 369         len = strlena(stra);
 370         str = AllocatePool((len + 1) * sizeof(CHAR16));
 371
 372         strlen = 0;
 373         i = 0;
 374         while (i < len) {
 375                 INTN utf8len;
 376
 377                 utf8len = utf8_to_16(stra + i, str + strlen);
 378                 if (utf8len <= 0) {
 379                         /* invalid utf8 sequence, skip the garbage */
 380                         i++;
 381                         continue;
 382                 }
 383
 384                 strlen++;
 385                 i += utf8len;
 386         }
 387         str[strlen] = '\0';
 388         return str;
 389 }
 390
 391 CHAR16 *stra_to_path(const CHAR8 *stra) {
 392         CHAR16 *str;
 393         UINTN strlen;
 394         UINTN len;
 395         UINTN i;
 396
 397         assert(stra);
 398
 399         len = strlena(stra);
 400         str = AllocatePool((len + 2) * sizeof(CHAR16));
 401
 402         str[0] = '\\';
 403         strlen = 1;
 404         i = 0;
 405         while (i < len) {
 406                 INTN utf8len;
 407
 408                 utf8len = utf8_to_16(stra + i, str + strlen);
 409                 if (utf8len <= 0) {
 410                         /* invalid utf8 sequence, skip the garbage */
 411                         i++;
 412                         continue;
 413                 }
 414
 415                 if (str[strlen] == '/')
 416                         str[strlen] = '\\';
 417                 if (str[strlen] == '\\' && str[strlen-1] == '\\') {
 418                         /* skip double slashes */
 419                         i += utf8len;
 420                         continue;
 421                 }
 422
 423                 strlen++;
 424                 i += utf8len;
 425         }
 426         str[strlen] = '\0';
 427         return str;
 428 }
 429
 430 CHAR8 *strchra(const CHAR8 *s, CHAR8 c) {
 431         assert(s);
 432         do {
 433                 if (*s == c)
 434                         return (CHAR8*) s;
 435         } while (*s++);
 436         return NULL;
 437 }
 438
 439 EFI_STATUS file_read(EFI_FILE_HANDLE dir, const CHAR16 *name, UINTN off, UINTN size, CHAR8 **ret, UINTN *ret_size) {
 440         _cleanup_(FileHandleClosep) EFI_FILE_HANDLE handle = NULL;
 441         _cleanup_freepool_ CHAR8 *buf = NULL;
 442         EFI_STATUS err;
 443
 444         assert(name);
 445         assert(ret);
 446
 447         err = uefi_call_wrapper(dir->Open, 5, dir, &handle, (CHAR16*) name, EFI_FILE_MODE_READ, 0ULL);
 448         if (EFI_ERROR(err))
 449                 return err;
 450
 451         if (size == 0) {
 452                 _cleanup_freepool_ EFI_FILE_INFO *info = NULL;
 453
 454                 info = LibFileInfo(handle);
 455                 if (!info)
 456                         return EFI_OUT_OF_RESOURCES;
 457
 458                 size = info->FileSize+1;
 459         }
 460
 461         if (off > 0) {
 462                 err = uefi_call_wrapper(handle->SetPosition, 2, handle, off);
 463                 if (EFI_ERROR(err))
 464                         return err;
 465         }
 466
 467         buf = AllocatePool(size + 1);
 468         if (!buf)
 469                 return EFI_OUT_OF_RESOURCES;
 470
 471         err = uefi_call_wrapper(handle->Read, 3, handle, &size, buf);
 472         if (EFI_ERROR(err))
 473                 return err;
 474
 475         buf[size] = '\0';
 476
 477         *ret = TAKE_PTR(buf);
 478         if (ret_size)
 479                 *ret_size = size;
 480
 481         return err;
 482 }
 483
 484 VOID log_error_stall(const CHAR16 *fmt, ...) {
 485         va_list args;
 486
 487         assert(fmt);
 488
 489         uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTRED|EFI_BACKGROUND_BLACK);
 490
 491         Print(L"\n");
 492         va_start(args, fmt);
 493         VPrint(fmt, args);
 494         va_end(args);
 495         Print(L"\n");
 496
 497         uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000);
 498 }
 499
 500 EFI_STATUS log_oom(void) {
 501         log_error_stall(L"Out of memory.");
 502         return EFI_OUT_OF_RESOURCES;
 503 }
 504
 505 VOID *memmem_safe(const VOID *haystack, UINTN haystack_len, const VOID *needle, UINTN needle_len) {
 506         assert(haystack || haystack_len == 0);
 507         assert(needle || needle_len == 0);
 508
 509         if (needle_len == 0)
 510                 return (VOID*)haystack;
 511
 512         for (const CHAR8 *h = haystack, *n = needle; haystack_len >= needle_len; h++, haystack_len--)
 513                 if (*h == *n && CompareMem(h + 1, n + 1, needle_len - 1) == 0)
 514                         return (VOID*)h;
 515
 516         return NULL;
 517 }