I have recently started developing EFI applications, and I am encountering an issue I can’t seem to resolve. Here’s my setup and the problem:

I am using QEMU to test my EFI application.

I can successfully display messages using the Print function.

However, when I try to use uefi_call_wrapper, my application gets stuck in an infinite loop or hangs indefinitely.

The same problem occurs when I attempt to use a protocol, such as EFI_RNG_PROTOCOL.
Could anyone guide me on why this might be happening or suggest any debugging steps to identify the root cause?

Thank you in advance for your help!

code:

#include <efi.h>
#include <efilib.h>

EFI_STATUS
efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE* systab)
{
    SIMPLE_TEXT_OUTPUT_INTERFACE* conout;

    InitializeLib(image, systab);

  Print(L"Hello world WORKrn");

    conout = systab->ConOut;
    uefi_call_wrapper(conout->OutputString, 2, conout, u"WHY WHY :(rn");

    return EFI_SUCCESS;
}

My makefile (don’t judge it too harshly, I don’t usually use it):

# Project name
PROJECT = EFI-APP

# Architecture
ARCH = x86_64

# Valid architectures
VALID_ARCHS = aarch64 arm ia32 ia64 loongarch64 mips64el riscv64 x86_64

# Check architecture
check-arch:
    @if ! echo "$(VALID_ARCHS)" | grep -w -q "$(ARCH)"; then 
        echo "Invalid ARCH: $(ARCH)"; 
        exit 1; 
    fi

# SUBSYSTEM values
# 10 = EFI application
# 11 = EFI boot service driver
# 12 = EFI runtime driver
SUBSYSTEM = 10

# Check subsystem
check-subsystem:
    @if [ "$(SUBSYSTEM)" -lt 10 ] || [ "$(SUBSYSTEM)" -gt 12 ]; then 
        echo "Invalid SUBSYSTEM: $(SUBSYSTEM)"; 
        exit 1; 
    fi

# Compiler
CC = $(ARCH)-linux-gnu-gcc

# Check GCC
check-gcc:
    @if ! command -v $(ARCH)-linux-gnu-gcc >/dev/null 2>&1; then 
        echo "GCC is not installed for $(ARCH)"; 
        exit 1; 
    fi

# Linker
LD = $(ARCH)-linux-gnu-ld

# Check LD
check-ld:
    @if ! command -v $(ARCH)-linux-gnu-ld >/dev/null 2>&1; then 
        echo "LD is not installed for $(ARCH)"; 
        exit 1; 
    fi

# Object copy
OBJ = $(ARCH)-linux-gnu-objcopy

# Check OBJCOPY
check-objcopy:
    @if ! command -v $(ARCH)-linux-gnu-objcopy >/dev/null 2>&1; then 
        echo "OBJCOPY is not installed for $(ARCH)"; 
        exit 1; 
    fi

# GNU-EFI directory
GNUEFI_DIR = gnu-efi

# Check GNU-EFI directory
check-gnuefi:
    @if [ ! -d "$(GNUEFI_DIR)" ]; then 
        echo "GNU-EFI directory not found"; 
        echo "Please init git submodule"; 
        exit 1; 
    fi

# Build GNU-EFI
build-gnuefi:
    @if [ ! -d "$(GNUEFI_DIR)/$(ARCH)" ]; then 
        echo "Building GNU-EFI for $(ARCH)"; 
        $(MAKE) -s -C $(GNUEFI_DIR) ARCH=$(ARCH); 
    fi

# Directories
SRC_DIR = src
OUTPUT_DIR = build
OBJ_DIR = $(OUTPUT_DIR)/obj
SO_DIR = $(OUTPUT_DIR)/so
EFI_DIR = $(OUTPUT_DIR)/efi

# Source and object files
SRC_FILES = $(wildcard $(SRC_DIR)/*.c)
OBJ_FILES = $(patsubst $(SRC_DIR)/%.c,$(OBJ_DIR)/%.o,$(SRC_FILES))

# Compilation flags
CFLAGS = -I$(GNUEFI_DIR)/inc -fpic -ffreestanding -fno-stack-protector -fno-stack-check -fshort-wchar -mno-red-zone -maccumulate-outgoing-args

# Linking flags
LDFLAGS = -shared -Bsymbolic -L$(GNUEFI_DIR)/$(ARCH)/lib -L$(GNUEFI_DIR)/$(ARCH)/gnuefi -T$(GNUEFI_DIR)/gnuefi/elf_$(ARCH)_efi.lds $(GNUEFI_DIR)/$(ARCH)/gnuefi/crt0-efi-$(ARCH).o -lgnuefi -lefi

# Objcopy flags
OBJCOPY_FLAGS = -j .text -j .sdata -j .data -j .rodata -j .dynamic -j .dynsym -j .rel -j .rela -j .rel.* -j .rela.* -j .reloc --target efi-app-$(ARCH) --subsystem=$(SUBSYSTEM)

# Default target
all: check build-gnuefi build

# Check target
check: check-arch check-subsystem check-gcc check-ld check-objcopy check-gnuefi

# Build target
build: $(EFI_DIR)/$(PROJECT).efi

# Compile .c files to .o files
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
    @mkdir -p $(OBJ_DIR)
    @$(CC) $(CFLAGS) -c $< -o $@

# Link .o files to .so file
$(SO_DIR)/$(PROJECT).so: $(OBJ_FILES)
    @mkdir -p $(SO_DIR)
    @$(LD) $(LDFLAGS) -o $@ $^

# Convert .so file to .efi file
$(EFI_DIR)/$(PROJECT).efi: $(SO_DIR)/$(PROJECT).so
    @mkdir -p $(EFI_DIR)
    @$(OBJ) $(OBJCOPY_FLAGS) $< $@
    @echo "fs0:$(PROJECT).efi" > $(EFI_DIR)/startup.nsh

# Clean target
clean:
    @rm -rf $(OUTPUT_DIR)

#QEMU
QEMU = qemu-system-${ARCH}

check-qemu:
    @if ! command -v $(QEMU) >/dev/null 2>&1; then 
        echo "QEMU is not installed for $(ARCH)"; 
        exit 1; 
    fi
run: check-qemu $(EFI_DIR)/$(PROJECT).efi
    @$(QEMU) -drive if=pflash,format=raw,readonly=on,file=firmware/OVMF.fd -drive format=raw,file=fat:rw:$(EFI_DIR) -net none

I expected the uefi_call_wrapper function to allow me to invoke UEFI protocols and functions without causing the application to hang.