EmulatorPkg/Unix/Host/EmuThunk.c

   1 /*++ @file
   2   Since the SEC is the only program in our emulation we
   3   must use a UEFI/PI mechanism to export APIs to other modules.
   4   This is the role of the EFI_EMU_THUNK_PROTOCOL.
   5
   6   The mUnixThunkTable exists so that a change to EFI_EMU_THUNK_PROTOCOL
   7   will cause an error in initializing the array if all the member functions
   8   are not added. It looks like adding a element to end and not initializing
   9   it may cause the table to be initaliized with the members at the end being
  10   set to zero. This is bad as jumping to zero will crash.
  11
  12 Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
  13 Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
  14 This program and the accompanying materials
  15 are licensed and made available under the terms and conditions of the BSD License
  16 which accompanies this distribution.  The full text of the license may be found at
  17 http://opensource.org/licenses/bsd-license.php
  18
  19 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  20 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  21
  22 **/
  23
  24 #include "Host.h"
  25
  26 #ifdef __APPLE__
  27 #define DebugAssert _Mangle__DebugAssert
  28
  29 #include <assert.h>
  30 #include <CoreServices/CoreServices.h>
  31 #include <mach/mach.h>
  32 #include <mach/mach_time.h>
  33
  34 #undef DebugAssert
  35 #endif
  36
  37 int settimer_initialized;
  38 struct timeval settimer_timeval;
  39 void (*settimer_callback)(UINT64 delta);
  40
  41 BOOLEAN gEmulatorInterruptEnabled = FALSE;
  42
  43
  44 UINTN
  45 SecWriteStdErr (
  46   IN UINT8     *Buffer,
  47   IN UINTN     NumberOfBytes
  48   )
  49 {
  50   ssize_t Return;
  51
  52   Return = write (STDERR_FILENO, (const void *)Buffer, (size_t)NumberOfBytes);
  53
  54   return (Return == -1) ? 0 : Return;
  55 }
  56
  57
  58 EFI_STATUS
  59 SecConfigStdIn (
  60   VOID
  61   )
  62 {
  63   struct termios tty;
  64
  65   //
  66   // Need to turn off line buffering, ECHO, and make it unbuffered.
  67   //
  68   tcgetattr (STDIN_FILENO, &tty);
  69   tty.c_lflag &= ~(ICANON | ECHO);
  70   tcsetattr (STDIN_FILENO, TCSANOW, &tty);
  71
  72 //  setvbuf (STDIN_FILENO, NULL, _IONBF, 0);
  73
  74   // now ioctl FIONREAD will do what we need
  75   return EFI_SUCCESS;
  76 }
  77
  78 UINTN
  79 SecWriteStdOut (
  80   IN UINT8     *Buffer,
  81   IN UINTN     NumberOfBytes
  82   )
  83 {
  84   ssize_t Return;
  85
  86   Return = write (STDOUT_FILENO, (const void *)Buffer, (size_t)NumberOfBytes);
  87
  88   return (Return == -1) ? 0 : Return;
  89 }
  90
  91 UINTN
  92 SecReadStdIn (
  93   IN UINT8     *Buffer,
  94   IN UINTN     NumberOfBytes
  95   )
  96 {
  97   ssize_t Return;
  98
  99   Return = read (STDIN_FILENO, Buffer, (size_t)NumberOfBytes);
 100
 101   return (Return == -1) ? 0 : Return;
 102 }
 103
 104 BOOLEAN
 105 SecPollStdIn (
 106   VOID
 107   )
 108 {
 109   int Result;
 110   int Bytes;
 111
 112   Result = ioctl (STDIN_FILENO, FIONREAD, &Bytes);
 113   if (Result == -1) {
 114     return FALSE;
 115   }
 116
 117   return (BOOLEAN)(Bytes > 0);
 118 }
 119
 120
 121 VOID *
 122 SecMalloc (
 123   IN  UINTN Size
 124   )
 125 {
 126   return malloc ((size_t)Size);
 127 }
 128
 129 VOID *
 130 SecValloc (
 131   IN  UINTN Size
 132   )
 133 {
 134   return valloc ((size_t)Size);
 135 }
 136
 137 BOOLEAN
 138 SecFree (
 139   IN  VOID *Ptr
 140   )
 141 {
 142   if (EfiSystemMemoryRange (Ptr)) {
 143     // If an address range is in the EFI memory map it was alloced via EFI.
 144     // So don't free those ranges and let the caller know.
 145     return FALSE;
 146   }
 147
 148   free (Ptr);
 149   return TRUE;
 150 }
 151
 152
 153 void
 154 settimer_handler (int sig)
 155 {
 156   struct timeval timeval;
 157   UINT64 delta;
 158
 159   gettimeofday (&timeval, NULL);
 160   delta = ((UINT64)timeval.tv_sec * 1000) + (timeval.tv_usec / 1000)
 161     - ((UINT64)settimer_timeval.tv_sec * 1000)
 162     - (settimer_timeval.tv_usec / 1000);
 163   settimer_timeval = timeval;
 164
 165   if (settimer_callback) {
 166     ReverseGasketUint64 (settimer_callback, delta);
 167   }
 168 }
 169
 170 VOID
 171 SecSetTimer (
 172   IN  UINT64                  PeriodMs,
 173   IN  EMU_SET_TIMER_CALLBACK  CallBack
 174   )
 175 {
 176   struct itimerval timerval;
 177   UINT32 remainder;
 178
 179   if (!settimer_initialized) {
 180     struct sigaction act;
 181
 182     settimer_initialized = 1;
 183     act.sa_handler = settimer_handler;
 184     act.sa_flags = 0;
 185     sigemptyset (&act.sa_mask);
 186     gEmulatorInterruptEnabled = TRUE;
 187     if (sigaction (SIGALRM, &act, NULL) != 0) {
 188       printf ("SetTimer: sigaction error %s\n", strerror (errno));
 189     }
 190     if (gettimeofday (&settimer_timeval, NULL) != 0) {
 191       printf ("SetTimer: gettimeofday error %s\n", strerror (errno));
 192     }
 193   }
 194   timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000);
 195   DivU64x32Remainder(PeriodMs, 1000, &remainder);
 196   timerval.it_value.tv_usec = remainder * 1000;
 197   timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000);
 198   timerval.it_interval = timerval.it_value;
 199
 200   if (setitimer (ITIMER_REAL, &timerval, NULL) != 0) {
 201     printf ("SetTimer: setitimer error %s\n", strerror (errno));
 202   }
 203   settimer_callback = CallBack;
 204 }
 205
 206
 207 VOID
 208 SecEnableInterrupt (
 209   VOID
 210   )
 211 {
 212   sigset_t  sigset;
 213
 214   gEmulatorInterruptEnabled = TRUE;
 215   // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts
 216   // by enabling/disabling SIGALRM.
 217   sigemptyset (&sigset);
 218   sigaddset (&sigset, SIGALRM);
 219   pthread_sigmask (SIG_UNBLOCK, &sigset, NULL);
 220 }
 221
 222
 223 VOID
 224 SecDisableInterrupt (
 225   VOID
 226   )
 227 {
 228   sigset_t  sigset;
 229
 230   // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts
 231   // by enabling/disabling SIGALRM.
 232   sigemptyset (&sigset);
 233   sigaddset (&sigset, SIGALRM);
 234   pthread_sigmask (SIG_BLOCK, &sigset, NULL);
 235   gEmulatorInterruptEnabled = FALSE;
 236 }
 237
 238
 239 BOOLEAN
 240 SecInterruptEanbled (void)
 241 {
 242   return gEmulatorInterruptEnabled;
 243 }
 244
 245
 246 UINT64
 247 QueryPerformanceFrequency (
 248   VOID
 249   )
 250 {
 251   // Hard code to nanoseconds
 252   return 1000000000ULL;
 253 }
 254
 255 UINT64
 256 QueryPerformanceCounter (
 257   VOID
 258   )
 259 {
 260 #if __APPLE__
 261   UINT64          Start;
 262   static mach_timebase_info_data_t    sTimebaseInfo;
 263
 264
 265   Start = mach_absolute_time ();
 266
 267   // Convert to nanoseconds.
 268
 269   // If this is the first time we've run, get the timebase.
 270   // We can use denom == 0 to indicate that sTimebaseInfo is
 271   // uninitialised because it makes no sense to have a zero
 272   // denominator is a fraction.
 273
 274   if ( sTimebaseInfo.denom == 0 ) {
 275       (void) mach_timebase_info(&sTimebaseInfo);
 276   }
 277
 278   // Do the maths. We hope that the multiplication doesn't
 279   // overflow; the price you pay for working in fixed point.
 280
 281   return (Start * sTimebaseInfo.numer) / sTimebaseInfo.denom;
 282 #else
 283   // Need to figure out what to do for Linux?
 284   return 0;
 285 #endif
 286 }
 287
 288
 289
 290 VOID
 291 SecSleep (
 292   IN  UINT64 Nanoseconds
 293   )
 294 {
 295   struct timespec rq, rm;
 296   struct timeval  start, end;
 297   unsigned long  MicroSec;
 298
 299   rq.tv_sec  = DivU64x32 (Nanoseconds, 1000000000);
 300   rq.tv_nsec = ModU64x32 (Nanoseconds, 1000000000);
 301
 302   //
 303   // nanosleep gets interrupted by our timer tic.
 304   // we need to track wall clock time or we will stall for way too long
 305   //
 306   gettimeofday (&start, NULL);
 307   end.tv_sec  = start.tv_sec + rq.tv_sec;
 308   MicroSec = (start.tv_usec + rq.tv_nsec/1000);
 309   end.tv_usec = MicroSec % 1000000;
 310   if (MicroSec > 1000000) {
 311     end.tv_sec++;
 312   }
 313
 314   while (nanosleep (&rq, &rm) == -1) {
 315     if (errno != EINTR) {
 316       break;
 317     }
 318     gettimeofday (&start, NULL);
 319     if (start.tv_sec > end.tv_sec) {
 320       break;
 321     } if ((start.tv_sec == end.tv_sec) && (start.tv_usec > end.tv_usec)) {
 322       break;
 323     }
 324     rq = rm;
 325   }
 326 }
 327
 328
 329 VOID
 330 SecCpuSleep (
 331   VOID
 332   )
 333 {
 334   struct timespec rq, rm;
 335
 336   // nanosleep gets interrupted by the timer tic
 337   rq.tv_sec  = 1;
 338   rq.tv_nsec = 0;
 339
 340   nanosleep (&rq, &rm);
 341 }
 342
 343
 344 VOID
 345 SecExit (
 346   UINTN   Status
 347   )
 348 {
 349   exit (Status);
 350 }
 351
 352
 353 VOID
 354 SecGetTime (
 355   OUT  EFI_TIME               *Time,
 356   OUT EFI_TIME_CAPABILITIES   *Capabilities OPTIONAL
 357   )
 358 {
 359   struct tm *tm;
 360   time_t t;
 361
 362   t = time (NULL);
 363   tm = localtime (&t);
 364
 365   Time->Year = 1900 + tm->tm_year;
 366   Time->Month = tm->tm_mon + 1;
 367   Time->Day = tm->tm_mday;
 368   Time->Hour = tm->tm_hour;
 369   Time->Minute = tm->tm_min;
 370   Time->Second = tm->tm_sec;
 371   Time->Nanosecond = 0;
 372   Time->TimeZone = timezone;
 373   Time->Daylight = (daylight ? EFI_TIME_ADJUST_DAYLIGHT : 0)
 374     | (tm->tm_isdst > 0 ? EFI_TIME_IN_DAYLIGHT : 0);
 375
 376   if (Capabilities != NULL) {
 377     Capabilities->Resolution  = 1;
 378     Capabilities->Accuracy    = 50000000;
 379     Capabilities->SetsToZero  = FALSE;
 380   }
 381 }
 382
 383
 384
 385 VOID
 386 SecSetTime (
 387   IN  EFI_TIME               *Time
 388   )
 389 {
 390   // Don't change the time on the system
 391   // We could save delta to localtime() and have SecGetTime adjust return values?
 392   return;
 393 }
 394
 395
 396 EFI_STATUS
 397 SecGetNextProtocol (
 398   IN  BOOLEAN                 EmuBusDriver,
 399   OUT EMU_IO_THUNK_PROTOCOL   **Instance   OPTIONAL
 400   )
 401 {
 402   return GetNextThunkProtocol (EmuBusDriver, Instance);
 403 }
 404
 405
 406 EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
 407   GasketSecWriteStdErr,
 408   GasketSecConfigStdIn,
 409   GasketSecWriteStdOut,
 410   GasketSecReadStdIn,
 411   GasketSecPollStdIn,
 412   GasketSecMalloc,
 413   GasketSecValloc,
 414   GasketSecFree,
 415   GasketSecPeCoffGetEntryPoint,
 416   GasketSecPeCoffRelocateImageExtraAction,
 417   GasketSecPeCoffUnloadImageExtraAction,
 418   GasketSecEnableInterrupt,
 419   GasketSecDisableInterrupt,
 420   GasketQueryPerformanceFrequency,
 421   GasketQueryPerformanceCounter,
 422   GasketSecSleep,
 423   GasketSecCpuSleep,
 424   GasketSecExit,
 425   GasketSecGetTime,
 426   GasketSecSetTime,
 427   GasketSecSetTimer,
 428   GasketSecGetNextProtocol
 429 };
 430
 431
 432 VOID
 433 SecInitThunkProtocol (
 434   VOID
 435   )
 436 {
 437   // timezone and daylight lib globals depend on tzset be called 1st.
 438   tzset ();
 439 }
 440