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         BS->Stall(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 RT->SetVariable((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 = xallocate_pool(size + sizeof(CHAR16));
 184
 185         CopyMem(val, buf, size);
 186         val[size / sizeof(CHAR16)] = 0; /* NUL terminate */
 187
 188         *value = val;
 189         return EFI_SUCCESS;
 190 }
 191
 192 EFI_STATUS efivar_get_uint_string(const EFI_GUID *vendor, const CHAR16 *name, UINTN *i) {
 193         _cleanup_freepool_ CHAR16 *val = NULL;
 194         EFI_STATUS err;
 195
 196         assert(vendor);
 197         assert(name);
 198         assert(i);
 199
 200         err = efivar_get(vendor, name, &val);
 201         if (!EFI_ERROR(err))
 202                 *i = Atoi(val);
 203
 204         return err;
 205 }
 206
 207 EFI_STATUS efivar_get_uint32_le(const EFI_GUID *vendor, const CHAR16 *name, UINT32 *ret) {
 208         _cleanup_freepool_ CHAR8 *buf = NULL;
 209         UINTN size;
 210         EFI_STATUS err;
 211
 212         assert(vendor);
 213         assert(name);
 214
 215         err = efivar_get_raw(vendor, name, &buf, &size);
 216         if (!EFI_ERROR(err) && ret) {
 217                 if (size != sizeof(UINT32))
 218                         return EFI_BUFFER_TOO_SMALL;
 219
 220                 *ret = (UINT32) buf[0] << 0U | (UINT32) buf[1] << 8U | (UINT32) buf[2] << 16U |
 221                         (UINT32) buf[3] << 24U;
 222         }
 223
 224         return err;
 225 }
 226
 227 EFI_STATUS efivar_get_uint64_le(const EFI_GUID *vendor, const CHAR16 *name, UINT64 *ret) {
 228         _cleanup_freepool_ CHAR8 *buf = NULL;
 229         UINTN size;
 230         EFI_STATUS err;
 231
 232         assert(vendor);
 233         assert(name);
 234
 235         err = efivar_get_raw(vendor, name, &buf, &size);
 236         if (!EFI_ERROR(err) && ret) {
 237                 if (size != sizeof(UINT64))
 238                         return EFI_BUFFER_TOO_SMALL;
 239
 240                 *ret = (UINT64) buf[0] << 0U | (UINT64) buf[1] << 8U | (UINT64) buf[2] << 16U |
 241                         (UINT64) buf[3] << 24U | (UINT64) buf[4] << 32U | (UINT64) buf[5] << 40U |
 242                         (UINT64) buf[6] << 48U | (UINT64) buf[7] << 56U;
 243         }
 244
 245         return err;
 246 }
 247
 248 EFI_STATUS efivar_get_raw(const EFI_GUID *vendor, const CHAR16 *name, CHAR8 **buffer, UINTN *size) {
 249         _cleanup_freepool_ CHAR8 *buf = NULL;
 250         UINTN l;
 251         EFI_STATUS err;
 252
 253         assert(vendor);
 254         assert(name);
 255
 256         l = sizeof(CHAR16 *) * EFI_MAXIMUM_VARIABLE_SIZE;
 257         buf = xallocate_pool(l);
 258
 259         err = RT->GetVariable((CHAR16 *) name, (EFI_GUID *) vendor, NULL, &l, buf);
 260         if (!EFI_ERROR(err)) {
 261
 262                 if (buffer)
 263                         *buffer = TAKE_PTR(buf);
 264
 265                 if (size)
 266                         *size = l;
 267         }
 268
 269         return err;
 270 }
 271
 272 EFI_STATUS efivar_get_boolean_u8(const EFI_GUID *vendor, const CHAR16 *name, BOOLEAN *ret) {
 273         _cleanup_freepool_ CHAR8 *b = NULL;
 274         UINTN size;
 275         EFI_STATUS err;
 276
 277         assert(vendor);
 278         assert(name);
 279         assert(ret);
 280
 281         err = efivar_get_raw(vendor, name, &b, &size);
 282         if (!EFI_ERROR(err))
 283                 *ret = *b > 0;
 284
 285         return err;
 286 }
 287
 288 void efivar_set_time_usec(const EFI_GUID *vendor, const CHAR16 *name, UINT64 usec) {
 289         CHAR16 str[32];
 290
 291         assert(vendor);
 292         assert(name);
 293
 294         if (usec == 0)
 295                 usec = time_usec();
 296         if (usec == 0)
 297                 return;
 298
 299         SPrint(str, ELEMENTSOF(str), L"%ld", usec);
 300         efivar_set(vendor, name, str, 0);
 301 }
 302
 303 static INTN utf8_to_16(const CHAR8 *stra, CHAR16 *c) {
 304         CHAR16 unichar;
 305         UINTN len;
 306
 307         assert(stra);
 308         assert(c);
 309
 310         if (!(stra[0] & 0x80))
 311                 len = 1;
 312         else if ((stra[0] & 0xe0) == 0xc0)
 313                 len = 2;
 314         else if ((stra[0] & 0xf0) == 0xe0)
 315                 len = 3;
 316         else if ((stra[0] & 0xf8) == 0xf0)
 317                 len = 4;
 318         else if ((stra[0] & 0xfc) == 0xf8)
 319                 len = 5;
 320         else if ((stra[0] & 0xfe) == 0xfc)
 321                 len = 6;
 322         else
 323                 return -1;
 324
 325         switch (len) {
 326         case 1:
 327                 unichar = stra[0];
 328                 break;
 329         case 2:
 330                 unichar = stra[0] & 0x1f;
 331                 break;
 332         case 3:
 333                 unichar = stra[0] & 0x0f;
 334                 break;
 335         case 4:
 336                 unichar = stra[0] & 0x07;
 337                 break;
 338         case 5:
 339                 unichar = stra[0] & 0x03;
 340                 break;
 341         case 6:
 342                 unichar = stra[0] & 0x01;
 343                 break;
 344         }
 345
 346         for (UINTN i = 1; i < len; i++) {
 347                 if ((stra[i] & 0xc0) != 0x80)
 348                         return -1;
 349                 unichar <<= 6;
 350                 unichar |= stra[i] & 0x3f;
 351         }
 352
 353         *c = unichar;
 354         return len;
 355 }
 356
 357 CHAR16 *xstra_to_str(const CHAR8 *stra) {
 358         UINTN strlen;
 359         UINTN len;
 360         UINTN i;
 361         CHAR16 *str;
 362
 363         assert(stra);
 364
 365         len = strlena(stra);
 366         str = xnew(CHAR16, len + 1);
 367
 368         strlen = 0;
 369         i = 0;
 370         while (i < len) {
 371                 INTN utf8len;
 372
 373                 utf8len = utf8_to_16(stra + i, str + strlen);
 374                 if (utf8len <= 0) {
 375                         /* invalid utf8 sequence, skip the garbage */
 376                         i++;
 377                         continue;
 378                 }
 379
 380                 strlen++;
 381                 i += utf8len;
 382         }
 383         str[strlen] = '\0';
 384         return str;
 385 }
 386
 387 CHAR16 *xstra_to_path(const CHAR8 *stra) {
 388         CHAR16 *str;
 389         UINTN strlen;
 390         UINTN len;
 391         UINTN i;
 392
 393         assert(stra);
 394
 395         len = strlena(stra);
 396         str = xnew(CHAR16, len + 2);
 397
 398         str[0] = '\\';
 399         strlen = 1;
 400         i = 0;
 401         while (i < len) {
 402                 INTN utf8len;
 403
 404                 utf8len = utf8_to_16(stra + i, str + strlen);
 405                 if (utf8len <= 0) {
 406                         /* invalid utf8 sequence, skip the garbage */
 407                         i++;
 408                         continue;
 409                 }
 410
 411                 if (str[strlen] == '/')
 412                         str[strlen] = '\\';
 413                 if (str[strlen] == '\\' && str[strlen-1] == '\\') {
 414                         /* skip double slashes */
 415                         i += utf8len;
 416                         continue;
 417                 }
 418
 419                 strlen++;
 420                 i += utf8len;
 421         }
 422         str[strlen] = '\0';
 423         return str;
 424 }
 425
 426 CHAR8 *strchra(const CHAR8 *s, CHAR8 c) {
 427         if (!s)
 428                 return NULL;
 429
 430         do {
 431                 if (*s == c)
 432                         return (CHAR8*) s;
 433         } while (*s++);
 434
 435         return NULL;
 436 }
 437
 438 EFI_STATUS file_read(EFI_FILE_HANDLE dir, const CHAR16 *name, UINTN off, UINTN size, CHAR8 **ret, UINTN *ret_size) {
 439         _cleanup_(FileHandleClosep) EFI_FILE_HANDLE handle = NULL;
 440         _cleanup_freepool_ CHAR8 *buf = NULL;
 441         EFI_STATUS err;
 442
 443         assert(name);
 444         assert(ret);
 445
 446         err = dir->Open(dir, &handle, (CHAR16*) name, EFI_FILE_MODE_READ, 0ULL);
 447         if (EFI_ERROR(err))
 448                 return err;
 449
 450         if (size == 0) {
 451                 _cleanup_freepool_ EFI_FILE_INFO *info = NULL;
 452
 453                 err = get_file_info_harder(handle, &info, NULL);
 454                 if (EFI_ERROR(err))
 455                         return err;
 456
 457                 size = info->FileSize+1;
 458         }
 459
 460         if (off > 0) {
 461                 err = handle->SetPosition(handle, off);
 462                 if (EFI_ERROR(err))
 463                         return err;
 464         }
 465
 466         buf = xallocate_pool(size + 1);
 467         err = handle->Read(handle, &size, buf);
 468         if (EFI_ERROR(err))
 469                 return err;
 470
 471         buf[size] = '\0';
 472
 473         *ret = TAKE_PTR(buf);
 474         if (ret_size)
 475                 *ret_size = size;
 476
 477         return err;
 478 }
 479
 480 void log_error_stall(const CHAR16 *fmt, ...) {
 481         va_list args;
 482
 483         assert(fmt);
 484
 485         INT32 attr = ST->ConOut->Mode->Attribute;
 486         ST->ConOut->SetAttribute(ST->ConOut, EFI_LIGHTRED|EFI_BACKGROUND_BLACK);
 487
 488         if (ST->ConOut->Mode->CursorColumn > 0)
 489                 Print(L"\n");
 490
 491         va_start(args, fmt);
 492         VPrint(fmt, args);
 493         va_end(args);
 494
 495         Print(L"\n");
 496
 497         ST->ConOut->SetAttribute(ST->ConOut, attr);
 498
 499         /* Give the user a chance to see the message. */
 500         BS->Stall(3 * 1000 * 1000);
 501 }
 502
 503 EFI_STATUS log_oom(void) {
 504         log_error_stall(L"Out of memory.");
 505         return EFI_OUT_OF_RESOURCES;
 506 }
 507
 508 void *memmem_safe(const void *haystack, UINTN haystack_len, const void *needle, UINTN needle_len) {
 509         assert(haystack || haystack_len == 0);
 510         assert(needle || needle_len == 0);
 511
 512         if (needle_len == 0)
 513                 return (void*)haystack;
 514
 515         for (const CHAR8 *h = haystack, *n = needle; haystack_len >= needle_len; h++, haystack_len--)
 516                 if (*h == *n && CompareMem(h + 1, n + 1, needle_len - 1) == 0)
 517                         return (void*)h;
 518
 519         return NULL;
 520 }
 521
 522 void print_at(UINTN x, UINTN y, UINTN attr, const CHAR16 *str) {
 523         assert(str);
 524         ST->ConOut->SetCursorPosition(ST->ConOut, x, y);
 525         ST->ConOut->SetAttribute(ST->ConOut, attr);
 526         ST->ConOut->OutputString(ST->ConOut, (CHAR16*)str);
 527 }
 528
 529 void clear_screen(UINTN attr) {
 530         ST->ConOut->SetAttribute(ST->ConOut, attr);
 531         ST->ConOut->ClearScreen(ST->ConOut);
 532 }
 533
 534 void sort_pointer_array(
 535                 void **array,
 536                 UINTN n_members,
 537                 compare_pointer_func_t compare) {
 538
 539         assert(array || n_members == 0);
 540         assert(compare);
 541
 542         if (n_members <= 1)
 543                 return;
 544
 545         for (UINTN i = 1; i < n_members; i++) {
 546                 BOOLEAN more = FALSE;
 547
 548                 for (UINTN k = 0; k < n_members - i; k++) {
 549                         void *entry;
 550
 551                         if (compare(array[k], array[k+1]) <= 0)
 552                                 continue;
 553
 554                         entry = array[k];
 555                         array[k] = array[k+1];
 556                         array[k+1] = entry;
 557                         more = TRUE;
 558                 }
 559                 if (!more)
 560                         break;
 561         }
 562 }
 563
 564 EFI_STATUS get_file_info_harder(
 565                 EFI_FILE_HANDLE handle,
 566                 EFI_FILE_INFO **ret,
 567                 UINTN *ret_size) {
 568
 569         UINTN size = OFFSETOF(EFI_FILE_INFO, FileName) + 256;
 570         _cleanup_freepool_ EFI_FILE_INFO *fi = NULL;
 571         EFI_STATUS err;
 572
 573         assert(handle);
 574         assert(ret);
 575
 576         /* A lot like LibFileInfo() but with useful error propagation */
 577
 578         fi = xallocate_pool(size);
 579         err = handle->GetInfo(handle, &GenericFileInfo, &size, fi);
 580         if (err == EFI_BUFFER_TOO_SMALL) {
 581                 FreePool(fi);
 582                 fi = xallocate_pool(size);  /* GetInfo tells us the required size, let's use that now */
 583                 err = handle->GetInfo(handle, &GenericFileInfo, &size, fi);
 584         }
 585
 586         if (EFI_ERROR(err))
 587                 return err;
 588
 589         *ret = TAKE_PTR(fi);
 590
 591         if (ret_size)
 592                 *ret_size = size;
 593
 594         return EFI_SUCCESS;
 595 }
 596
 597 EFI_STATUS readdir_harder(
 598                 EFI_FILE_HANDLE handle,
 599                 EFI_FILE_INFO **buffer,
 600                 UINTN *buffer_size) {
 601
 602         EFI_STATUS err;
 603         UINTN sz;
 604
 605         assert(handle);
 606         assert(buffer);
 607         assert(buffer_size);
 608
 609         /* buffer/buffer_size are both in and output parameters. Should be zero-initialized initially, and
 610          * the specified buffer needs to be freed by caller, after final use. */
 611
 612         if (!*buffer) {
 613                 sz = OFFSETOF(EFI_FILE_INFO, FileName) /* + 256 */;
 614                 *buffer = xallocate_pool(sz);
 615                 *buffer_size = sz;
 616         } else
 617                 sz = *buffer_size;
 618
 619         err = handle->Read(handle, &sz, *buffer);
 620         if (err == EFI_BUFFER_TOO_SMALL) {
 621                 FreePool(*buffer);
 622                 *buffer = xallocate_pool(sz);
 623                 *buffer_size = sz;
 624                 err = handle->Read(handle, &sz, *buffer);
 625         }
 626         if (EFI_ERROR(err))
 627                 return err;
 628
 629         if (sz == 0) {
 630                 /* End of directory */
 631                 FreePool(*buffer);
 632                 *buffer = NULL;
 633                 *buffer_size = 0;
 634         }
 635
 636         return EFI_SUCCESS;
 637 }
 638
 639 UINTN strnlena(const CHAR8 *p, UINTN maxlen) {
 640         UINTN c;
 641
 642         if (!p)
 643                 return 0;
 644
 645         for (c = 0; c < maxlen; c++)
 646                 if (p[c] == 0)
 647                         break;
 648
 649         return c;
 650 }
 651
 652 CHAR8 *xstrndup8(const CHAR8 *p, UINTN sz) {
 653         CHAR8 *n;
 654
 655         /* Following efilib's naming scheme this function would be called strndupa(), but we already have a
 656          * function named like this in userspace, and it does something different there, hence to minimize
 657          * confusion, let's pick a different name here */
 658
 659         assert(p || sz == 0);
 660
 661         sz = strnlena(p, sz);
 662
 663         n = xallocate_pool(sz + 1);
 664
 665         if (sz > 0)
 666                 CopyMem(n, p, sz);
 667         n[sz] = 0;
 668
 669         return n;
 670 }
 671
 672 BOOLEAN is_ascii(const CHAR16 *f) {
 673         if (!f)
 674                 return FALSE;
 675
 676         for (; *f != 0; f++)
 677                 if (*f > 127)
 678                         return FALSE;
 679
 680         return TRUE;
 681 }
 682
 683 CHAR16 **strv_free(CHAR16 **v) {
 684         if (!v)
 685                 return NULL;
 686
 687         for (CHAR16 **i = v; *i; i++)
 688                 FreePool(*i);
 689
 690         FreePool(v);
 691         return NULL;
 692 }
 693
 694 EFI_STATUS open_directory(
 695                 EFI_FILE_HANDLE root,
 696                 const CHAR16 *path,
 697                 EFI_FILE_HANDLE *ret) {
 698
 699         _cleanup_(FileHandleClosep) EFI_FILE_HANDLE dir = NULL;
 700         _cleanup_freepool_ EFI_FILE_INFO *file_info = NULL;
 701         EFI_STATUS err;
 702
 703         assert(root);
 704
 705         /* Opens a file, and then verifies it is actually a directory */
 706
 707         err = root->Open(root, &dir, (CHAR16*) path, EFI_FILE_MODE_READ, 0ULL);
 708         if (EFI_ERROR(err))
 709                 return err;
 710
 711         err = get_file_info_harder(dir, &file_info, NULL);
 712         if (EFI_ERROR(err))
 713                 return err;
 714         if (!FLAGS_SET(file_info->Attribute, EFI_FILE_DIRECTORY))
 715                 return EFI_LOAD_ERROR;
 716
 717         *ret = TAKE_PTR(dir);
 718         return EFI_SUCCESS;
 719 }
 720
 721 UINT64 get_os_indications_supported(void) {
 722         UINT64 osind;
 723         EFI_STATUS err;
 724
 725         /* Returns the supported OS indications. If we can't acquire it, returns a zeroed out mask, i.e. no
 726          * supported features. */
 727
 728         err = efivar_get_uint64_le(EFI_GLOBAL_GUID, L"OsIndicationsSupported", &osind);
 729         if (EFI_ERROR(err))
 730                 return 0;
 731
 732         return osind;
 733 }