#include "util.h"
#ifdef __x86_64__
-UINT64 ticks_read(VOID) {
+UINT64 ticks_read(void) {
UINT64 a, d;
__asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
return (d << 32) | a;
}
#elif defined(__i386__)
-UINT64 ticks_read(VOID) {
+UINT64 ticks_read(void) {
UINT64 val;
__asm__ volatile ("rdtsc" : "=A" (val));
return val;
}
#elif defined(__aarch64__)
-UINT64 ticks_read(VOID) {
+UINT64 ticks_read(void) {
UINT64 val;
__asm__ volatile ("mrs %0, cntpct_el0" : "=r" (val));
return val;
}
#else
-UINT64 ticks_read(VOID) {
+UINT64 ticks_read(void) {
UINT64 val = 1;
return val;
}
#endif
#if defined(__aarch64__)
-UINT64 ticks_freq(VOID) {
+UINT64 ticks_freq(void) {
UINT64 freq;
__asm__ volatile ("mrs %0, cntfrq_el0": "=r" (freq));
return freq;
}
#else
/* count TSC ticks during a millisecond delay */
-UINT64 ticks_freq(VOID) {
+UINT64 ticks_freq(void) {
UINT64 ticks_start, ticks_end;
ticks_start = ticks_read();
- uefi_call_wrapper(BS->Stall, 1, 1000);
+ BS->Stall(1000);
ticks_end = ticks_read();
return (ticks_end - ticks_start) * 1000UL;
}
#endif
-UINT64 time_usec(VOID) {
+UINT64 time_usec(void) {
UINT64 ticks;
static UINT64 freq;
return EFI_INVALID_PARAMETER;
}
-EFI_STATUS efivar_set_raw(const EFI_GUID *vendor, const CHAR16 *name, const VOID *buf, UINTN size, UINT32 flags) {
+EFI_STATUS efivar_set_raw(const EFI_GUID *vendor, const CHAR16 *name, const void *buf, UINTN size, UINT32 flags) {
assert(vendor);
assert(name);
assert(buf || size == 0);
flags |= EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
- return uefi_call_wrapper(RT->SetVariable, 5, (CHAR16*) name, (EFI_GUID *) vendor, flags, size, (VOID*) buf);
+ return RT->SetVariable((CHAR16 *) name, (EFI_GUID *) vendor, flags, size, (void *) buf);
}
EFI_STATUS efivar_set(const EFI_GUID *vendor, const CHAR16 *name, const CHAR16 *value, UINT32 flags) {
return EFI_SUCCESS;
/* Return buffer directly if it happens to be NUL terminated already */
- if (size >= sizeof(CHAR16) && buf[size/sizeof(CHAR16)] == 0) {
+ if (size >= sizeof(CHAR16) && buf[size / sizeof(CHAR16) - 1] == 0) {
*value = TAKE_PTR(buf);
return EFI_SUCCESS;
}
/* Make sure a terminating NUL is available at the end */
- val = AllocatePool(size + sizeof(CHAR16));
- if (!val)
- return EFI_OUT_OF_RESOURCES;
+ val = xallocate_pool(size + sizeof(CHAR16));
CopyMem(val, buf, size);
- val[size / sizeof(CHAR16)] = 0; /* NUL terminate */
+ val[size / sizeof(CHAR16) - 1] = 0; /* NUL terminate */
*value = val;
return EFI_SUCCESS;
assert(name);
l = sizeof(CHAR16 *) * EFI_MAXIMUM_VARIABLE_SIZE;
- buf = AllocatePool(l);
- if (!buf)
- return EFI_OUT_OF_RESOURCES;
+ buf = xallocate_pool(l);
- err = uefi_call_wrapper(RT->GetVariable, 5, (CHAR16*) name, (EFI_GUID *)vendor, NULL, &l, buf);
+ err = RT->GetVariable((CHAR16 *) name, (EFI_GUID *) vendor, NULL, &l, buf);
if (!EFI_ERROR(err)) {
if (buffer)
return err;
}
-VOID efivar_set_time_usec(const EFI_GUID *vendor, const CHAR16 *name, UINT64 usec) {
+void efivar_set_time_usec(const EFI_GUID *vendor, const CHAR16 *name, UINT64 usec) {
CHAR16 str[32];
assert(vendor);
return len;
}
-CHAR16 *stra_to_str(const CHAR8 *stra) {
+CHAR16 *xstra_to_str(const CHAR8 *stra) {
UINTN strlen;
UINTN len;
UINTN i;
assert(stra);
len = strlena(stra);
- str = AllocatePool((len + 1) * sizeof(CHAR16));
+ str = xnew(CHAR16, len + 1);
strlen = 0;
i = 0;
return str;
}
-CHAR16 *stra_to_path(const CHAR8 *stra) {
+CHAR16 *xstra_to_path(const CHAR8 *stra) {
CHAR16 *str;
UINTN strlen;
UINTN len;
assert(stra);
len = strlena(stra);
- str = AllocatePool((len + 2) * sizeof(CHAR16));
+ str = xnew(CHAR16, len + 2);
str[0] = '\\';
strlen = 1;
}
EFI_STATUS file_read(EFI_FILE_HANDLE dir, const CHAR16 *name, UINTN off, UINTN size, CHAR8 **ret, UINTN *ret_size) {
- _cleanup_(FileHandleClosep) EFI_FILE_HANDLE handle = NULL;
+ _cleanup_(file_handle_closep) EFI_FILE_HANDLE handle = NULL;
_cleanup_freepool_ CHAR8 *buf = NULL;
EFI_STATUS err;
assert(name);
assert(ret);
- err = uefi_call_wrapper(dir->Open, 5, dir, &handle, (CHAR16*) name, EFI_FILE_MODE_READ, 0ULL);
+ err = dir->Open(dir, &handle, (CHAR16*) name, EFI_FILE_MODE_READ, 0ULL);
if (EFI_ERROR(err))
return err;
}
if (off > 0) {
- err = uefi_call_wrapper(handle->SetPosition, 2, handle, off);
+ err = handle->SetPosition(handle, off);
if (EFI_ERROR(err))
return err;
}
- buf = AllocatePool(size + 1);
- if (!buf)
- return EFI_OUT_OF_RESOURCES;
-
- err = uefi_call_wrapper(handle->Read, 3, handle, &size, buf);
+ buf = xallocate_pool(size + 1);
+ err = handle->Read(handle, &size, buf);
if (EFI_ERROR(err))
return err;
return err;
}
-VOID log_error_stall(const CHAR16 *fmt, ...) {
+void log_error_stall(const CHAR16 *fmt, ...) {
va_list args;
assert(fmt);
- uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, EFI_LIGHTRED|EFI_BACKGROUND_BLACK);
+ INT32 attr = ST->ConOut->Mode->Attribute;
+ ST->ConOut->SetAttribute(ST->ConOut, EFI_LIGHTRED|EFI_BACKGROUND_BLACK);
+
+ if (ST->ConOut->Mode->CursorColumn > 0)
+ Print(L"\n");
- Print(L"\n");
va_start(args, fmt);
VPrint(fmt, args);
va_end(args);
+
Print(L"\n");
- uefi_call_wrapper(BS->Stall, 1, 3 * 1000 * 1000);
+ ST->ConOut->SetAttribute(ST->ConOut, attr);
+
+ /* Give the user a chance to see the message. */
+ BS->Stall(3 * 1000 * 1000);
}
EFI_STATUS log_oom(void) {
return EFI_OUT_OF_RESOURCES;
}
-VOID *memmem_safe(const VOID *haystack, UINTN haystack_len, const VOID *needle, UINTN needle_len) {
- assert(haystack || haystack_len == 0);
- assert(needle || needle_len == 0);
-
- if (needle_len == 0)
- return (VOID*)haystack;
-
- for (const CHAR8 *h = haystack, *n = needle; haystack_len >= needle_len; h++, haystack_len--)
- if (*h == *n && CompareMem(h + 1, n + 1, needle_len - 1) == 0)
- return (VOID*)h;
-
- return NULL;
-}
-
-VOID print_at(UINTN x, UINTN y, UINTN attr, const CHAR16 *str) {
+void print_at(UINTN x, UINTN y, UINTN attr, const CHAR16 *str) {
assert(str);
- uefi_call_wrapper(ST->ConOut->SetCursorPosition, 3, ST->ConOut, x, y);
- uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, attr);
- uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, (CHAR16*)str);
+ ST->ConOut->SetCursorPosition(ST->ConOut, x, y);
+ ST->ConOut->SetAttribute(ST->ConOut, attr);
+ ST->ConOut->OutputString(ST->ConOut, (CHAR16*)str);
}
-VOID clear_screen(UINTN attr) {
- uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, attr);
- uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut);
+void clear_screen(UINTN attr) {
+ ST->ConOut->SetAttribute(ST->ConOut, attr);
+ ST->ConOut->ClearScreen(ST->ConOut);
}
void sort_pointer_array(
- VOID **array,
+ void **array,
UINTN n_members,
compare_pointer_func_t compare) {
EFI_FILE_INFO **ret,
UINTN *ret_size) {
- static const EFI_GUID EfiFileInfoGuid = EFI_FILE_INFO_ID;
- UINTN size = OFFSETOF(EFI_FILE_INFO, FileName) + 256;
+ UINTN size = offsetof(EFI_FILE_INFO, FileName) + 256;
_cleanup_freepool_ EFI_FILE_INFO *fi = NULL;
EFI_STATUS err;
/* A lot like LibFileInfo() but with useful error propagation */
- fi = AllocatePool(size);
- if (!fi)
- return EFI_OUT_OF_RESOURCES;
-
- err = uefi_call_wrapper(handle->GetInfo, 4, handle, (EFI_GUID*) &EfiFileInfoGuid, &size, fi);
+ fi = xallocate_pool(size);
+ err = handle->GetInfo(handle, &GenericFileInfo, &size, fi);
if (err == EFI_BUFFER_TOO_SMALL) {
FreePool(fi);
- fi = AllocatePool(size); /* GetInfo tells us the required size, let's use that now */
- if (!fi)
- return EFI_OUT_OF_RESOURCES;
-
- err = uefi_call_wrapper(handle->GetInfo, 4, handle, (EFI_GUID*) &EfiFileInfoGuid, &size, fi);
+ fi = xallocate_pool(size); /* GetInfo tells us the required size, let's use that now */
+ err = handle->GetInfo(handle, &GenericFileInfo, &size, fi);
}
if (EFI_ERROR(err))
* the specified buffer needs to be freed by caller, after final use. */
if (!*buffer) {
- sz = OFFSETOF(EFI_FILE_INFO, FileName) /* + 256 */;
-
- *buffer = AllocatePool(sz);
- if (!*buffer)
- return EFI_OUT_OF_RESOURCES;
-
+ sz = offsetof(EFI_FILE_INFO, FileName) /* + 256 */;
+ *buffer = xallocate_pool(sz);
*buffer_size = sz;
} else
sz = *buffer_size;
- err = uefi_call_wrapper(handle->Read, 3, handle, &sz, *buffer);
+ err = handle->Read(handle, &sz, *buffer);
if (err == EFI_BUFFER_TOO_SMALL) {
FreePool(*buffer);
-
- *buffer = AllocatePool(sz);
- if (!*buffer) {
- *buffer_size = 0;
- return EFI_OUT_OF_RESOURCES;
- }
-
+ *buffer = xallocate_pool(sz);
*buffer_size = sz;
-
- err = uefi_call_wrapper(handle->Read, 3, handle, &sz, *buffer);
+ err = handle->Read(handle, &sz, *buffer);
}
if (EFI_ERROR(err))
return err;
return c;
}
-CHAR8 *strndup8(const CHAR8 *p, UINTN sz) {
+INTN strncasecmpa(const CHAR8 *a, const CHAR8 *b, UINTN maxlen) {
+ if (!a || !b)
+ return CMP(a, b);
+
+ while (maxlen > 0) {
+ CHAR8 ca = *a, cb = *b;
+ if (ca >= 'A' && ca <= 'Z')
+ ca += 'a' - 'A';
+ if (cb >= 'A' && cb <= 'Z')
+ cb += 'a' - 'A';
+ if (!ca || ca != cb)
+ return ca - cb;
+
+ a++;
+ b++;
+ maxlen--;
+ }
+
+ return 0;
+}
+
+CHAR8 *xstrndup8(const CHAR8 *p, UINTN sz) {
CHAR8 *n;
/* Following efilib's naming scheme this function would be called strndupa(), but we already have a
sz = strnlena(p, sz);
- n = AllocatePool(sz + 1);
- if (!n)
- return NULL;
+ n = xallocate_pool(sz + 1);
if (sz > 0)
CopyMem(n, p, sz);
const CHAR16 *path,
EFI_FILE_HANDLE *ret) {
- _cleanup_(FileHandleClosep) EFI_FILE_HANDLE dir = NULL;
+ _cleanup_(file_handle_closep) EFI_FILE_HANDLE dir = NULL;
_cleanup_freepool_ EFI_FILE_INFO *file_info = NULL;
EFI_STATUS err;
/* Opens a file, and then verifies it is actually a directory */
- err = uefi_call_wrapper(
- root->Open, 5,
- root,
- &dir,
- (CHAR16*) path,
- EFI_FILE_MODE_READ,
- 0ULL);
+ err = root->Open(root, &dir, (CHAR16*) path, EFI_FILE_MODE_READ, 0ULL);
if (EFI_ERROR(err))
return err;
err = get_file_info_harder(dir, &file_info, NULL);
if (EFI_ERROR(err))
return err;
- if (!(file_info->Attribute & EFI_FILE_DIRECTORY))
+ if (!FLAGS_SET(file_info->Attribute, EFI_FILE_DIRECTORY))
return EFI_LOAD_ERROR;
*ret = TAKE_PTR(dir);
return EFI_SUCCESS;
}
-UINT64 get_os_indications_supported(VOID) {
+UINT64 get_os_indications_supported(void) {
UINT64 osind;
EFI_STATUS err;
return osind;
}
+
+#ifdef EFI_DEBUG
+__attribute__((noinline)) void debug_break(void) {
+ /* This is a poor programmer's breakpoint to wait until a debugger
+ * has attached to us. Just "set variable wait = 0" or "return" to continue. */
+ volatile BOOLEAN wait = TRUE;
+ while (wait)
+ /* Prefer asm based stalling so that gdb has a source location to present. */
+#if defined(__i386__) || defined(__x86_64__)
+ asm volatile("pause");
+#elif defined(__aarch64__)
+ asm volatile("wfi");
+#else
+ BS->Stall(5000);
+#endif
+}
+#endif
projects / thirdparty / systemd.git / blobdiff