summaryrefslogtreecommitdiffstats
path: root/EmulatorPkg/Unix/Host/EmuThunk.c
diff options
context:
space:
mode:
Diffstat (limited to 'EmulatorPkg/Unix/Host/EmuThunk.c')
-rw-r--r--EmulatorPkg/Unix/Host/EmuThunk.c432
1 files changed, 432 insertions, 0 deletions
diff --git a/EmulatorPkg/Unix/Host/EmuThunk.c b/EmulatorPkg/Unix/Host/EmuThunk.c
new file mode 100644
index 0000000000..fe68603d3f
--- /dev/null
+++ b/EmulatorPkg/Unix/Host/EmuThunk.c
@@ -0,0 +1,432 @@
+/*++ @file
+ Since the SEC is the only program in our emulation we
+ must use a UEFI/PI mechanism to export APIs to other modules.
+ This is the role of the EFI_EMU_THUNK_PROTOCOL.
+
+ The mUnixThunkTable exists so that a change to EFI_EMU_THUNK_PROTOCOL
+ will cause an error in initializing the array if all the member functions
+ are not added. It looks like adding a element to end and not initializing
+ it may cause the table to be initaliized with the members at the end being
+ set to zero. This is bad as jumping to zero will crash.
+
+Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include "SecMain.h"
+
+#ifdef __APPLE__
+#define DebugAssert _Mangle__DebugAssert
+
+#include <assert.h>
+#include <CoreServices/CoreServices.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+
+#undef DebugAssert
+#endif
+
+int settimer_initialized;
+struct timeval settimer_timeval;
+void (*settimer_callback)(UINT64 delta);
+
+BOOLEAN gEmulatorInterruptEnabled = FALSE;
+
+
+UINTN
+SecWriteStdErr (
+ IN UINT8 *Buffer,
+ IN UINTN NumberOfBytes
+ )
+{
+ ssize_t Return;
+
+ Return = write (STDERR_FILENO, (const void *)Buffer, (size_t)NumberOfBytes);
+
+ return (Return == -1) ? 0 : Return;
+}
+
+
+EFI_STATUS
+SecConfigStdIn (
+ VOID
+ )
+{
+ struct termios tty;
+
+ //
+ // Need to turn off line buffering, ECHO, and make it unbuffered.
+ //
+ tcgetattr (STDIN_FILENO, &tty);
+ tty.c_lflag &= ~(ICANON | ECHO);
+ tcsetattr (STDIN_FILENO, TCSANOW, &tty);
+
+// setvbuf (STDIN_FILENO, NULL, _IONBF, 0);
+
+ // now ioctl FIONREAD will do what we need
+ return EFI_SUCCESS;
+}
+
+UINTN
+SecWriteStdOut (
+ IN UINT8 *Buffer,
+ IN UINTN NumberOfBytes
+ )
+{
+ ssize_t Return;
+
+ Return = write (STDOUT_FILENO, (const void *)Buffer, (size_t)NumberOfBytes);
+
+ return (Return == -1) ? 0 : Return;
+}
+
+UINTN
+SecReadStdIn (
+ IN UINT8 *Buffer,
+ IN UINTN NumberOfBytes
+ )
+{
+ ssize_t Return;
+
+ Return = read (STDIN_FILENO, Buffer, (size_t)NumberOfBytes);
+
+ return (Return == -1) ? 0 : Return;
+}
+
+BOOLEAN
+SecPollStdIn (
+ VOID
+ )
+{
+ int Result;
+ int Bytes;
+
+ Result = ioctl (STDIN_FILENO, FIONREAD, &Bytes);
+ if (Result == -1) {
+ return FALSE;
+ }
+
+ return (BOOLEAN)(Bytes > 0);
+}
+
+
+VOID *
+SecMalloc (
+ IN UINTN Size
+ )
+{
+ return malloc ((size_t)Size);
+}
+
+VOID *
+SecValloc (
+ IN UINTN Size
+ )
+{
+ return valloc ((size_t)Size);
+}
+
+BOOLEAN
+SecFree (
+ IN VOID *Ptr
+ )
+{
+ if (EfiSystemMemoryRange (Ptr)) {
+ // If an address range is in the EFI memory map it was alloced via EFI.
+ // So don't free those ranges and let the caller know.
+ return FALSE;
+ }
+
+ free (Ptr);
+ return TRUE;
+}
+
+
+void
+settimer_handler (int sig)
+{
+ struct timeval timeval;
+ UINT64 delta;
+
+ gettimeofday (&timeval, NULL);
+ delta = ((UINT64)timeval.tv_sec * 1000) + (timeval.tv_usec / 1000)
+ - ((UINT64)settimer_timeval.tv_sec * 1000)
+ - (settimer_timeval.tv_usec / 1000);
+ settimer_timeval = timeval;
+
+ if (settimer_callback) {
+ ReverseGasketUint64 (settimer_callback, delta);
+ }
+}
+
+VOID
+SecSetTimer (
+ IN UINT64 PeriodMs,
+ IN EMU_SET_TIMER_CALLBACK CallBack
+ )
+{
+ struct itimerval timerval;
+ UINT32 remainder;
+
+ if (!settimer_initialized) {
+ struct sigaction act;
+
+ settimer_initialized = 1;
+ act.sa_handler = settimer_handler;
+ act.sa_flags = 0;
+ sigemptyset (&act.sa_mask);
+ gEmulatorInterruptEnabled = TRUE;
+ if (sigaction (SIGALRM, &act, NULL) != 0) {
+ printf ("SetTimer: sigaction error %s\n", strerror (errno));
+ }
+ if (gettimeofday (&settimer_timeval, NULL) != 0) {
+ printf ("SetTimer: gettimeofday error %s\n", strerror (errno));
+ }
+ }
+ timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000);
+ DivU64x32Remainder(PeriodMs, 1000, &remainder);
+ timerval.it_value.tv_usec = remainder * 1000;
+ timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000);
+ timerval.it_interval = timerval.it_value;
+
+ if (setitimer (ITIMER_REAL, &timerval, NULL) != 0) {
+ printf ("SetTimer: setitimer error %s\n", strerror (errno));
+ }
+ settimer_callback = CallBack;
+}
+
+
+VOID
+SecEnableInterrupt (
+ VOID
+ )
+{
+ sigset_t sigset;
+
+ gEmulatorInterruptEnabled = TRUE;
+ // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts
+ // by enabling/disabling SIGALRM.
+ sigemptyset (&sigset);
+ sigaddset (&sigset, SIGALRM);
+ pthread_sigmask (SIG_UNBLOCK, &sigset, NULL);
+}
+
+
+VOID
+SecDisableInterrupt (
+ VOID
+ )
+{
+ sigset_t sigset;
+
+ // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts
+ // by enabling/disabling SIGALRM.
+ sigemptyset (&sigset);
+ sigaddset (&sigset, SIGALRM);
+ pthread_sigmask (SIG_BLOCK, &sigset, NULL);
+ gEmulatorInterruptEnabled = FALSE;
+}
+
+
+BOOLEAN
+SecInterruptEanbled (void)
+{
+ return gEmulatorInterruptEnabled;
+}
+
+
+UINT64
+QueryPerformanceFrequency (
+ VOID
+ )
+{
+ // Hard code to nanoseconds
+ return 1000000000ULL;
+}
+
+UINT64
+QueryPerformanceCounter (
+ VOID
+ )
+{
+#if __APPLE__
+ UINT64 Start;
+ Nanoseconds elapsedNano;
+
+ Start = mach_absolute_time ();
+
+ // Convert to nanoseconds.
+
+ // Have to do some pointer fun because AbsoluteToNanoseconds
+ // works in terms of UnsignedWide, which is a structure rather
+ // than a proper 64-bit integer.
+ elapsedNano = AbsoluteToNanoseconds (*(AbsoluteTime *) &Start);
+
+ return *(uint64_t *) &elapsedNano;
+#else
+ // Need to figure out what to do for Linux?
+ return 0;
+#endif
+}
+
+
+
+VOID
+SecSleep (
+ IN UINT64 Nanoseconds
+ )
+{
+ struct timespec rq, rm;
+ struct timeval start, end;
+ unsigned long MicroSec;
+
+ rq.tv_sec = DivU64x32 (Nanoseconds, 1000000000);
+ rq.tv_nsec = ModU64x32 (Nanoseconds, 1000000000);
+
+ //
+ // nanosleep gets interrupted by our timer tic.
+ // we need to track wall clock time or we will stall for way too long
+ //
+ gettimeofday (&start, NULL);
+ end.tv_sec = start.tv_sec + rq.tv_sec;
+ MicroSec = (start.tv_usec + rq.tv_nsec/1000);
+ end.tv_usec = MicroSec % 1000000;
+ if (MicroSec > 1000000) {
+ end.tv_sec++;
+ }
+
+ while (nanosleep (&rq, &rm) == -1) {
+ if (errno != EINTR) {
+ break;
+ }
+ gettimeofday (&start, NULL);
+ if (start.tv_sec > end.tv_sec) {
+ break;
+ } if ((start.tv_sec == end.tv_sec) && (start.tv_usec > end.tv_usec)) {
+ break;
+ }
+ rq = rm;
+ }
+}
+
+
+VOID
+SecCpuSleep (
+ VOID
+ )
+{
+ struct timespec rq, rm;
+
+ // nanosleep gets interrupted by the timer tic
+ rq.tv_sec = 1;
+ rq.tv_nsec = 0;
+
+ nanosleep (&rq, &rm);
+}
+
+
+VOID
+SecExit (
+ UINTN Status
+ )
+{
+ exit (Status);
+}
+
+
+VOID
+SecGetTime (
+ OUT EFI_TIME *Time,
+ OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL
+ )
+{
+ struct tm *tm;
+ time_t t;
+
+ t = time (NULL);
+ tm = localtime (&t);
+
+ Time->Year = 1900 + tm->tm_year;
+ Time->Month = tm->tm_mon + 1;
+ Time->Day = tm->tm_mday;
+ Time->Hour = tm->tm_hour;
+ Time->Minute = tm->tm_min;
+ Time->Second = tm->tm_sec;
+ Time->Nanosecond = 0;
+ Time->TimeZone = timezone;
+ Time->Daylight = (daylight ? EFI_TIME_ADJUST_DAYLIGHT : 0)
+ | (tm->tm_isdst > 0 ? EFI_TIME_IN_DAYLIGHT : 0);
+
+ if (Capabilities != NULL) {
+ Capabilities->Resolution = 1;
+ Capabilities->Accuracy = 50000000;
+ Capabilities->SetsToZero = FALSE;
+ }
+}
+
+
+
+VOID
+SecSetTime (
+ IN EFI_TIME *Time
+ )
+{
+ // Don't change the time on the system
+ // We could save delta to localtime() and have SecGetTime adjust return values?
+ return;
+}
+
+
+EFI_STATUS
+SecGetNextProtocol (
+ IN BOOLEAN EmuBusDriver,
+ OUT EMU_IO_THUNK_PROTOCOL **Instance OPTIONAL
+ )
+{
+ return GetNextThunkProtocol (EmuBusDriver, Instance);
+}
+
+
+EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
+ GasketSecWriteStdErr,
+ GasketSecConfigStdIn,
+ GasketSecWriteStdOut,
+ GasketSecReadStdIn,
+ GasketSecPollStdIn,
+ GasketSecMalloc,
+ GasketSecValloc,
+ GasketSecFree,
+ GasketSecPeCoffGetEntryPoint,
+ GasketSecPeCoffRelocateImageExtraAction,
+ GasketSecPeCoffUnloadImageExtraAction,
+ GasketSecEnableInterrupt,
+ GasketSecDisableInterrupt,
+ GasketQueryPerformanceFrequency,
+ GasketQueryPerformanceCounter,
+ GasketSecSleep,
+ GasketSecCpuSleep,
+ GasketSecExit,
+ GasketSecGetTime,
+ GasketSecSetTime,
+ GasketSecSetTimer,
+ GasketSecGetNextProtocol
+};
+
+
+VOID
+SecInitThunkProtocol (
+ VOID
+ )
+{
+ // timezone and daylight lib globals depend on tzset be called 1st.
+ tzset ();
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-14 15:19:41 +0000