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 = 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 = RT->GetVariable((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         if (!str)
 372                 return NULL;
 373
 374         strlen = 0;
 375         i = 0;
 376         while (i < len) {
 377                 INTN utf8len;
 378
 379                 utf8len = utf8_to_16(stra + i, str + strlen);
 380                 if (utf8len <= 0) {
 381                         /* invalid utf8 sequence, skip the garbage */
 382                         i++;
 383                         continue;
 384                 }
 385
 386                 strlen++;
 387                 i += utf8len;
 388         }
 389         str[strlen] = '\0';
 390         return str;
 391 }
 392
 393 CHAR16 *stra_to_path(const CHAR8 *stra) {
 394         CHAR16 *str;
 395         UINTN strlen;
 396         UINTN len;
 397         UINTN i;
 398
 399         assert(stra);
 400
 401         len = strlena(stra);
 402         str = AllocatePool((len + 2) * sizeof(CHAR16));
 403         if (!str)
 404                 return NULL;
 405
 406         str[0] = '\\';
 407         strlen = 1;
 408         i = 0;
 409         while (i < len) {
 410                 INTN utf8len;
 411
 412                 utf8len = utf8_to_16(stra + i, str + strlen);
 413                 if (utf8len <= 0) {
 414                         /* invalid utf8 sequence, skip the garbage */
 415                         i++;
 416                         continue;
 417                 }
 418
 419                 if (str[strlen] == '/')
 420                         str[strlen] = '\\';
 421                 if (str[strlen] == '\\' && str[strlen-1] == '\\') {
 422                         /* skip double slashes */
 423                         i += utf8len;
 424                         continue;
 425                 }
 426
 427                 strlen++;
 428                 i += utf8len;
 429         }
 430         str[strlen] = '\0';
 431         return str;
 432 }
 433
 434 CHAR8 *strchra(const CHAR8 *s, CHAR8 c) {
 435         if (!s)
 436                 return NULL;
 437
 438         do {
 439                 if (*s == c)
 440                         return (CHAR8*) s;
 441         } while (*s++);
 442
 443         return NULL;
 444 }
 445
 446 EFI_STATUS file_read(EFI_FILE_HANDLE dir, const CHAR16 *name, UINTN off, UINTN size, CHAR8 **ret, UINTN *ret_size) {
 447         _cleanup_(FileHandleClosep) EFI_FILE_HANDLE handle = NULL;
 448         _cleanup_freepool_ CHAR8 *buf = NULL;
 449         EFI_STATUS err;
 450
 451         assert(name);
 452         assert(ret);
 453
 454         err = dir->Open(dir, &handle, (CHAR16*) name, EFI_FILE_MODE_READ, 0ULL);
 455         if (EFI_ERROR(err))
 456                 return err;
 457
 458         if (size == 0) {
 459                 _cleanup_freepool_ EFI_FILE_INFO *info = NULL;
 460
 461                 err = get_file_info_harder(handle, &info, NULL);
 462                 if (EFI_ERROR(err))
 463                         return err;
 464
 465                 size = info->FileSize+1;
 466         }
 467
 468         if (off > 0) {
 469                 err = handle->SetPosition(handle, off);
 470                 if (EFI_ERROR(err))
 471                         return err;
 472         }
 473
 474         buf = AllocatePool(size + 1);
 475         if (!buf)
 476                 return EFI_OUT_OF_RESOURCES;
 477
 478         err = handle->Read(handle, &size, buf);
 479         if (EFI_ERROR(err))
 480                 return err;
 481
 482         buf[size] = '\0';
 483
 484         *ret = TAKE_PTR(buf);
 485         if (ret_size)
 486                 *ret_size = size;
 487
 488         return err;
 489 }
 490
 491 void log_error_stall(const CHAR16 *fmt, ...) {
 492         va_list args;
 493
 494         assert(fmt);
 495
 496         ST->ConOut->SetAttribute(ST->ConOut, EFI_LIGHTRED|EFI_BACKGROUND_BLACK);
 497
 498         Print(L"\n");
 499         va_start(args, fmt);
 500         VPrint(fmt, args);
 501         va_end(args);
 502         Print(L"\n");
 503
 504         BS->Stall(3 * 1000 * 1000);
 505 }
 506
 507 EFI_STATUS log_oom(void) {
 508         log_error_stall(L"Out of memory.");
 509         return EFI_OUT_OF_RESOURCES;
 510 }
 511
 512 void *memmem_safe(const void *haystack, UINTN haystack_len, const void *needle, UINTN needle_len) {
 513         assert(haystack || haystack_len == 0);
 514         assert(needle || needle_len == 0);
 515
 516         if (needle_len == 0)
 517                 return (void*)haystack;
 518
 519         for (const CHAR8 *h = haystack, *n = needle; haystack_len >= needle_len; h++, haystack_len--)
 520                 if (*h == *n && CompareMem(h + 1, n + 1, needle_len - 1) == 0)
 521                         return (void*)h;
 522
 523         return NULL;
 524 }
 525
 526 void print_at(UINTN x, UINTN y, UINTN attr, const CHAR16 *str) {
 527         assert(str);
 528         ST->ConOut->SetCursorPosition(ST->ConOut, x, y);
 529         ST->ConOut->SetAttribute(ST->ConOut, attr);
 530         ST->ConOut->OutputString(ST->ConOut, (CHAR16*)str);
 531 }
 532
 533 void clear_screen(UINTN attr) {
 534         ST->ConOut->SetAttribute(ST->ConOut, attr);
 535         ST->ConOut->ClearScreen(ST->ConOut);
 536 }
 537
 538 void sort_pointer_array(
 539                 void **array,
 540                 UINTN n_members,
 541                 compare_pointer_func_t compare) {
 542
 543         assert(array || n_members == 0);
 544         assert(compare);
 545
 546         if (n_members <= 1)
 547                 return;
 548
 549         for (UINTN i = 1; i < n_members; i++) {
 550                 BOOLEAN more = FALSE;
 551
 552                 for (UINTN k = 0; k < n_members - i; k++) {
 553                         void *entry;
 554
 555                         if (compare(array[k], array[k+1]) <= 0)
 556                                 continue;
 557
 558                         entry = array[k];
 559                         array[k] = array[k+1];
 560                         array[k+1] = entry;
 561                         more = TRUE;
 562                 }
 563                 if (!more)
 564                         break;
 565         }
 566 }
 567
 568 EFI_STATUS get_file_info_harder(
 569                 EFI_FILE_HANDLE handle,
 570                 EFI_FILE_INFO **ret,
 571                 UINTN *ret_size) {
 572
 573         UINTN size = OFFSETOF(EFI_FILE_INFO, FileName) + 256;
 574         _cleanup_freepool_ EFI_FILE_INFO *fi = NULL;
 575         EFI_STATUS err;
 576
 577         assert(handle);
 578         assert(ret);
 579
 580         /* A lot like LibFileInfo() but with useful error propagation */
 581
 582         fi = AllocatePool(size);
 583         if (!fi)
 584                 return EFI_OUT_OF_RESOURCES;
 585
 586         err = handle->GetInfo(handle, &GenericFileInfo, &size, fi);
 587         if (err == EFI_BUFFER_TOO_SMALL) {
 588                 FreePool(fi);
 589                 fi = AllocatePool(size);  /* GetInfo tells us the required size, let's use that now */
 590                 if (!fi)
 591                         return EFI_OUT_OF_RESOURCES;
 592
 593                 err = handle->GetInfo(handle, &GenericFileInfo, &size, fi);
 594         }
 595
 596         if (EFI_ERROR(err))
 597                 return err;
 598
 599         *ret = TAKE_PTR(fi);
 600
 601         if (ret_size)
 602                 *ret_size = size;
 603
 604         return EFI_SUCCESS;
 605 }
 606
 607 EFI_STATUS readdir_harder(
 608                 EFI_FILE_HANDLE handle,
 609                 EFI_FILE_INFO **buffer,
 610                 UINTN *buffer_size) {
 611
 612         EFI_STATUS err;
 613         UINTN sz;
 614
 615         assert(handle);
 616         assert(buffer);
 617         assert(buffer_size);
 618
 619         /* buffer/buffer_size are both in and output parameters. Should be zero-initialized initially, and
 620          * the specified buffer needs to be freed by caller, after final use. */
 621
 622         if (!*buffer) {
 623                 sz = OFFSETOF(EFI_FILE_INFO, FileName) /* + 256 */;
 624
 625                 *buffer = AllocatePool(sz);
 626                 if (!*buffer)
 627                         return EFI_OUT_OF_RESOURCES;
 628
 629                 *buffer_size = sz;
 630         } else
 631                 sz = *buffer_size;
 632
 633         err = handle->Read(handle, &sz, *buffer);
 634         if (err == EFI_BUFFER_TOO_SMALL) {
 635                 FreePool(*buffer);
 636
 637                 *buffer = AllocatePool(sz);
 638                 if (!*buffer) {
 639                         *buffer_size = 0;
 640                         return EFI_OUT_OF_RESOURCES;
 641                 }
 642
 643                 *buffer_size = sz;
 644
 645                 err = handle->Read(handle, &sz, *buffer);
 646         }
 647         if (EFI_ERROR(err))
 648                 return err;
 649
 650         if (sz == 0) {
 651                 /* End of directory */
 652                 FreePool(*buffer);
 653                 *buffer = NULL;
 654                 *buffer_size = 0;
 655         }
 656
 657         return EFI_SUCCESS;
 658 }
 659
 660 UINTN strnlena(const CHAR8 *p, UINTN maxlen) {
 661         UINTN c;
 662
 663         if (!p)
 664                 return 0;
 665
 666         for (c = 0; c < maxlen; c++)
 667                 if (p[c] == 0)
 668                         break;
 669
 670         return c;
 671 }
 672
 673 CHAR8 *strndup8(const CHAR8 *p, UINTN sz) {
 674         CHAR8 *n;
 675
 676         /* Following efilib's naming scheme this function would be called strndupa(), but we already have a
 677          * function named like this in userspace, and it does something different there, hence to minimize
 678          * confusion, let's pick a different name here */
 679
 680         assert(p || sz == 0);
 681
 682         sz = strnlena(p, sz);
 683
 684         n = AllocatePool(sz + 1);
 685         if (!n)
 686                 return NULL;
 687
 688         if (sz > 0)
 689                 CopyMem(n, p, sz);
 690         n[sz] = 0;
 691
 692         return n;
 693 }
 694
 695 BOOLEAN is_ascii(const CHAR16 *f) {
 696         if (!f)
 697                 return FALSE;
 698
 699         for (; *f != 0; f++)
 700                 if (*f > 127)
 701                         return FALSE;
 702
 703         return TRUE;
 704 }
 705
 706 CHAR16 **strv_free(CHAR16 **v) {
 707         if (!v)
 708                 return NULL;
 709
 710         for (CHAR16 **i = v; *i; i++)
 711                 FreePool(*i);
 712
 713         FreePool(v);
 714         return NULL;
 715 }
 716
 717 EFI_STATUS open_directory(
 718                 EFI_FILE_HANDLE root,
 719                 const CHAR16 *path,
 720                 EFI_FILE_HANDLE *ret) {
 721
 722         _cleanup_(FileHandleClosep) EFI_FILE_HANDLE dir = NULL;
 723         _cleanup_freepool_ EFI_FILE_INFO *file_info = NULL;
 724         EFI_STATUS err;
 725
 726         assert(root);
 727
 728         /* Opens a file, and then verifies it is actually a directory */
 729
 730         err = root->Open(root, &dir, (CHAR16*) path, EFI_FILE_MODE_READ, 0ULL);
 731         if (EFI_ERROR(err))
 732                 return err;
 733
 734         err = get_file_info_harder(dir, &file_info, NULL);
 735         if (EFI_ERROR(err))
 736                 return err;
 737         if (!(file_info->Attribute & EFI_FILE_DIRECTORY))
 738                 return EFI_LOAD_ERROR;
 739
 740         *ret = TAKE_PTR(dir);
 741         return EFI_SUCCESS;
 742 }
 743
 744 UINT64 get_os_indications_supported(void) {
 745         UINT64 osind;
 746         EFI_STATUS err;
 747
 748         /* Returns the supported OS indications. If we can't acquire it, returns a zeroed out mask, i.e. no
 749          * supported features. */
 750
 751         err = efivar_get_uint64_le(EFI_GLOBAL_GUID, L"OsIndicationsSupported", &osind);
 752         if (EFI_ERROR(err))
 753                 return 0;
 754
 755         return osind;
 756 }