src/boot/efi/util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /*
   3  * This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the GNU Lesser General Public License as published by
   5  * the Free Software Foundation; either version 2.1 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * Copyright (C) 2012-2013 Kay Sievers <kay@vrfy.org>
  14  * Copyright (C) 2012 Harald Hoyer <harald@redhat.com>
  15  */
  16
  17 #include <efi.h>
  18 #include <efilib.h>
  19
  20 #include "util.h"
  21
  22 /*
  23  * Allocated random UUID, intended to be shared across tools that implement
  24  * the (ESP)\loader\entries\<vendor>-<revision>.conf convention and the
  25  * associated EFI variables.
  26  */
  27 static const EFI_GUID loader_guid = { 0x4a67b082, 0x0a4c, 0x41cf, {0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f} };
  28
  29 #ifdef __x86_64__
  30 UINT64 ticks_read(VOID) {
  31         UINT64 a, d;
  32         __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
  33         return (d << 32) | a;
  34 }
  35 #elif defined(__i386__)
  36 UINT64 ticks_read(VOID) {
  37         UINT64 val;
  38         __asm__ volatile ("rdtsc" : "=A" (val));
  39         return val;
  40 }
  41 #else
  42 UINT64 ticks_read(VOID) {
  43         UINT64 val = 1;
  44         return val;
  45 }
  46 #endif
  47
  48 /* count TSC ticks during a millisecond delay */
  49 UINT64 ticks_freq(VOID) {
  50         UINT64 ticks_start, ticks_end;
  51
  52         ticks_start = ticks_read();
  53         uefi_call_wrapper(BS->Stall, 1, 1000);
  54         ticks_end = ticks_read();
  55
  56         return (ticks_end - ticks_start) * 1000;
  57 }
  58
  59 UINT64 time_usec(VOID) {
  60         UINT64 ticks;
  61         static UINT64 freq;
  62
  63         ticks = ticks_read();
  64         if (ticks == 0)
  65                 return 0;
  66
  67         if (freq == 0) {
  68                 freq = ticks_freq();
  69                 if (freq == 0)
  70                         return 0;
  71         }
  72
  73         return 1000 * 1000 * ticks / freq;
  74 }
  75
  76 EFI_STATUS parse_boolean(CHAR8 *v, BOOLEAN *b) {
  77         if (strcmpa(v, (CHAR8 *)"1") == 0 ||
  78             strcmpa(v, (CHAR8 *)"yes") == 0 ||
  79             strcmpa(v, (CHAR8 *)"y") == 0 ||
  80             strcmpa(v, (CHAR8 *)"true") == 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                 *b = FALSE;
  90                 return EFI_SUCCESS;
  91         }
  92
  93         return EFI_INVALID_PARAMETER;
  94 }
  95
  96 EFI_STATUS efivar_set_raw(const EFI_GUID *vendor, CHAR16 *name, CHAR8 *buf, UINTN size, BOOLEAN persistent) {
  97         UINT32 flags;
  98
  99         flags = EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS;
 100         if (persistent)
 101                 flags |= EFI_VARIABLE_NON_VOLATILE;
 102
 103         return uefi_call_wrapper(RT->SetVariable, 5, name, (EFI_GUID *)vendor, flags, size, buf);
 104 }
 105
 106 EFI_STATUS efivar_set(CHAR16 *name, CHAR16 *value, BOOLEAN persistent) {
 107         return efivar_set_raw(&loader_guid, name, (CHAR8 *)value, value ? (StrLen(value)+1) * sizeof(CHAR16) : 0, persistent);
 108 }
 109
 110 EFI_STATUS efivar_set_int(CHAR16 *name, UINTN i, BOOLEAN persistent) {
 111         CHAR16 str[32];
 112
 113         SPrint(str, 32, L"%d", i);
 114         return efivar_set(name, str, persistent);
 115 }
 116
 117 EFI_STATUS efivar_get(CHAR16 *name, CHAR16 **value) {
 118         _cleanup_freepool_ CHAR8 *buf = NULL;
 119         CHAR16 *val;
 120         UINTN size;
 121         EFI_STATUS err;
 122
 123         err = efivar_get_raw(&loader_guid, name, &buf, &size);
 124         if (EFI_ERROR(err))
 125                 return err;
 126
 127         val = StrDuplicate((CHAR16 *)buf);
 128         if (!val)
 129                 return EFI_OUT_OF_RESOURCES;
 130
 131         *value = val;
 132         return EFI_SUCCESS;
 133 }
 134
 135 EFI_STATUS efivar_get_int(CHAR16 *name, UINTN *i) {
 136         _cleanup_freepool_ CHAR16 *val = NULL;
 137         EFI_STATUS err;
 138
 139         err = efivar_get(name, &val);
 140         if (!EFI_ERROR(err))
 141                 *i = Atoi(val);
 142
 143         return err;
 144 }
 145
 146 EFI_STATUS efivar_get_raw(const EFI_GUID *vendor, CHAR16 *name, CHAR8 **buffer, UINTN *size) {
 147         _cleanup_freepool_ CHAR8 *buf = NULL;
 148         UINTN l;
 149         EFI_STATUS err;
 150
 151         l = sizeof(CHAR16 *) * EFI_MAXIMUM_VARIABLE_SIZE;
 152         buf = AllocatePool(l);
 153         if (!buf)
 154                 return EFI_OUT_OF_RESOURCES;
 155
 156         err = uefi_call_wrapper(RT->GetVariable, 5, name, (EFI_GUID *)vendor, NULL, &l, buf);
 157         if (!EFI_ERROR(err)) {
 158                 *buffer = buf;
 159                 buf = NULL;
 160                 if (size)
 161                         *size = l;
 162         }
 163
 164         return err;
 165 }
 166
 167 VOID efivar_set_time_usec(CHAR16 *name, UINT64 usec) {
 168         CHAR16 str[32];
 169
 170         if (usec == 0)
 171                 usec = time_usec();
 172         if (usec == 0)
 173                 return;
 174
 175         SPrint(str, 32, L"%ld", usec);
 176         efivar_set(name, str, FALSE);
 177 }
 178
 179 static INTN utf8_to_16(CHAR8 *stra, CHAR16 *c) {
 180         CHAR16 unichar;
 181         UINTN len;
 182         UINTN i;
 183
 184         if (stra[0] < 0x80)
 185                 len = 1;
 186         else if ((stra[0] & 0xe0) == 0xc0)
 187                 len = 2;
 188         else if ((stra[0] & 0xf0) == 0xe0)
 189                 len = 3;
 190         else if ((stra[0] & 0xf8) == 0xf0)
 191                 len = 4;
 192         else if ((stra[0] & 0xfc) == 0xf8)
 193                 len = 5;
 194         else if ((stra[0] & 0xfe) == 0xfc)
 195                 len = 6;
 196         else
 197                 return -1;
 198
 199         switch (len) {
 200         case 1:
 201                 unichar = stra[0];
 202                 break;
 203         case 2:
 204                 unichar = stra[0] & 0x1f;
 205                 break;
 206         case 3:
 207                 unichar = stra[0] & 0x0f;
 208                 break;
 209         case 4:
 210                 unichar = stra[0] & 0x07;
 211                 break;
 212         case 5:
 213                 unichar = stra[0] & 0x03;
 214                 break;
 215         case 6:
 216                 unichar = stra[0] & 0x01;
 217                 break;
 218         }
 219
 220         for (i = 1; i < len; i++) {
 221                 if ((stra[i] & 0xc0) != 0x80)
 222                         return -1;
 223                 unichar <<= 6;
 224                 unichar |= stra[i] & 0x3f;
 225         }
 226
 227         *c = unichar;
 228         return len;
 229 }
 230
 231 CHAR16 *stra_to_str(CHAR8 *stra) {
 232         UINTN strlen;
 233         UINTN len;
 234         UINTN i;
 235         CHAR16 *str;
 236
 237         len = strlena(stra);
 238         str = AllocatePool((len + 1) * sizeof(CHAR16));
 239
 240         strlen = 0;
 241         i = 0;
 242         while (i < len) {
 243                 INTN utf8len;
 244
 245                 utf8len = utf8_to_16(stra + i, str + strlen);
 246                 if (utf8len <= 0) {
 247                         /* invalid utf8 sequence, skip the garbage */
 248                         i++;
 249                         continue;
 250                 }
 251
 252                 strlen++;
 253                 i += utf8len;
 254         }
 255         str[strlen] = '\0';
 256         return str;
 257 }
 258
 259 CHAR16 *stra_to_path(CHAR8 *stra) {
 260         CHAR16 *str;
 261         UINTN strlen;
 262         UINTN len;
 263         UINTN i;
 264
 265         len = strlena(stra);
 266         str = AllocatePool((len + 2) * sizeof(CHAR16));
 267
 268         str[0] = '\\';
 269         strlen = 1;
 270         i = 0;
 271         while (i < len) {
 272                 INTN utf8len;
 273
 274                 utf8len = utf8_to_16(stra + i, str + strlen);
 275                 if (utf8len <= 0) {
 276                         /* invalid utf8 sequence, skip the garbage */
 277                         i++;
 278                         continue;
 279                 }
 280
 281                 if (str[strlen] == '/')
 282                         str[strlen] = '\\';
 283                 if (str[strlen] == '\\' && str[strlen-1] == '\\') {
 284                         /* skip double slashes */
 285                         i += utf8len;
 286                         continue;
 287                 }
 288
 289                 strlen++;
 290                 i += utf8len;
 291         }
 292         str[strlen] = '\0';
 293         return str;
 294 }
 295
 296 CHAR8 *strchra(CHAR8 *s, CHAR8 c) {
 297         do {
 298                 if (*s == c)
 299                         return s;
 300         } while (*s++);
 301         return NULL;
 302 }
 303
 304 EFI_STATUS file_read(EFI_FILE_HANDLE dir, CHAR16 *name, UINTN off, UINTN size, CHAR8 **content, UINTN *content_size) {
 305         EFI_FILE_HANDLE handle;
 306         _cleanup_freepool_ CHAR8 *buf = NULL;
 307         EFI_STATUS err;
 308
 309         err = uefi_call_wrapper(dir->Open, 5, dir, &handle, name, EFI_FILE_MODE_READ, 0ULL);
 310         if (EFI_ERROR(err))
 311                 return err;
 312
 313         if (size == 0) {
 314                 _cleanup_freepool_ EFI_FILE_INFO *info;
 315
 316                 info = LibFileInfo(handle);
 317                 size = info->FileSize+1;
 318         }
 319
 320         if (off > 0) {
 321                 err = uefi_call_wrapper(handle->SetPosition, 2, handle, off);
 322                 if (EFI_ERROR(err))
 323                         return err;
 324         }
 325
 326         buf = AllocatePool(size + 1);
 327         err = uefi_call_wrapper(handle->Read, 3, handle, &size, buf);
 328         if (!EFI_ERROR(err)) {
 329                 buf[size] = '\0';
 330                 *content = buf;
 331                 buf = NULL;
 332                 if (content_size)
 333                         *content_size = size;
 334         }
 335         uefi_call_wrapper(handle->Close, 1, handle);
 336
 337         return err;
 338 }