Add BlockIO support to the emulator, still needs testing. Also update Emulator start code to only pass 2 args in place of 3. The 3rd argument is not needed. Still need a function as the BaseLib functoin does not have the correct calling conventions. Cleanup build script for binary shell case.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11718 6f19259b-4bc3-4df7-8a09-765794883524
author: andrewfish <andrewfish@6f19259b-4bc3-4df7-8a09-765794883524> 2011-05-31 20:23:36 +0000
committer: andrewfish <andrewfish@6f19259b-4bc3-4df7-8a09-765794883524> 2011-05-31 20:23:36 +0000
commit: d59326d3a871f1df6e9416334ca2181ac4373d42 (patch)
tree: 1ed7cfdd245be8f6edcb3061a371cdaf4c835734 /InOsEmuPkg/Unix
parent: 283d361e98f2e7da579b022426d3dfb4fc1e33a8 (diff)
download: edk2-platforms-d59326d3a871f1df6e9416334ca2181ac4373d42.tar.xz
7 files changed, 1073 insertions, 32 deletions
diff --git a/InOsEmuPkg/Unix/Sec/BlockIo.c b/InOsEmuPkg/Unix/Sec/BlockIo.c
new file mode 100644
index 0000000000..3fc1d3f9aa
--- /dev/null
+++ b/InOsEmuPkg/Unix/Sec/BlockIo.c
@@ -0,0 +1,1053 @@
+/**@file
+
+Copyright (c) 2004 - 2009, Intel Corporation. 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.             
+
+Module Name:
+
+  UnixBlockIo.c
+
+Abstract:
+
+  Produce block IO abstractions for real devices on your PC using Posix APIs.
+  The configuration of what devices to mount or emulate comes from UNIX 
+  environment variables. The variables must be visible to the Microsoft* 
+  Developer Studio for them to work.
+
+  <F>ixed       - Fixed disk like a hard drive.
+  <R>emovable   - Removable media like a floppy or CD-ROM.
+  Read <O>nly   - Write protected device.
+  Read <W>rite  - Read write device.
+  <block count> - Decimal number of blocks a device supports.
+  <block size>  - Decimal number of bytes per block.
+
+  UNIX envirnonment variable contents. '<' and '>' are not part of the variable, 
+  they are just used to make this help more readable. There should be no 
+  spaces between the ';'. Extra spaces will break the variable. A '!' is 
+  used to seperate multiple devices in a variable.
+
+  EFI_EMU_VIRTUAL_DISKS = 
+    <F | R><O | W>;<block count>;<block size>[!...]
+
+  EFI_EMU_PHYSICAL_DISKS =
+    <drive letter>:<F | R><O | W>;<block count>;<block size>[!...]
+
+  Virtual Disks: These devices use a file to emulate a hard disk or removable
+                 media device. 
+                 
+    Thus a 20 MB emulated hard drive would look like:
+    EFI_EMU_VIRTUAL_DISKS=FW;40960;512
+
+    A 1.44MB emulated floppy with a block size of 1024 would look like:
+    EFI_EMU_VIRTUAL_DISKS=RW;1440;1024
+
+  Physical Disks: These devices use UNIX to open a real device in your system
+
+    Thus a 120 MB floppy would look like:
+    EFI_EMU_PHYSICAL_DISKS=B:RW;245760;512
+
+    Thus a standard CD-ROM floppy would look like:
+    EFI_EMU_PHYSICAL_DISKS=Z:RO;307200;2048
+
+
+  * Other names and brands may be claimed as the property of others.
+
+**/
+
+#include <fcntl.h>
+#include <unistd.h>
+#include "UnixBlockIo.h"
+
+//
+// Block IO protocol member functions
+//
+EFI_STATUS
+EFIAPI
+UnixBlockIoReadBlocks (
+  IN EFI_BLOCK_IO_PROTOCOL  *This,
+  IN UINT32                 MediaId,
+  IN EFI_LBA                Lba,
+  IN UINTN                  BufferSize,
+  OUT VOID                  *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoWriteBlocks (
+  IN EFI_BLOCK_IO_PROTOCOL  *This,
+  IN UINT32                 MediaId,
+  IN EFI_LBA                Lba,
+  IN UINTN                  BufferSize,
+  IN VOID                   *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoFlushBlocks (
+  IN EFI_BLOCK_IO_PROTOCOL  *This
+  );
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoResetBlock (
+  IN EFI_BLOCK_IO_PROTOCOL  *This,
+  IN BOOLEAN                ExtendedVerification
+  );
+
+//
+// Private Worker functions
+//
+EFI_STATUS
+UnixBlockIoCreateMapping (
+  IN EMU_IO_THUNK_PROTOCOL             *EmuIoThunk,
+  IN EFI_HANDLE                         EfiDeviceHandle,
+  IN CHAR16                             *Filename,
+  IN BOOLEAN                            ReadOnly,
+  IN BOOLEAN                            RemovableMedia,
+  IN UINTN                              NumberOfBlocks,
+  IN UINTN                              BlockSize
+  );
+
+EFI_STATUS
+UnixBlockIoReadWriteCommon (
+  IN  EMU_BLOCK_IO_PRIVATE *Private,
+  IN UINT32                   MediaId,
+  IN EFI_LBA                  Lba,
+  IN UINTN                    BufferSize,
+  IN VOID                     *Buffer,
+  IN CHAR8                    *CallerName
+  );
+
+EFI_STATUS
+UnixBlockIoError (
+  IN EMU_BLOCK_IO_PRIVATE      *Private
+  );
+
+EFI_STATUS
+UnixBlockIoOpenDevice (
+  EMU_BLOCK_IO_PRIVATE         *Private
+  );
+
+CHAR16                                    *
+GetNextElementPastTerminator (
+  IN  CHAR16  *EnvironmentVariable,
+  IN  CHAR16  Terminator
+  );
+
+
+
+EFI_DRIVER_BINDING_PROTOCOL gUnixBlockIoDriverBinding = {
+  UnixBlockIoDriverBindingSupported,
+  UnixBlockIoDriverBindingStart,
+  UnixBlockIoDriverBindingStop,
+  0xa,
+  NULL,
+  NULL
+};
+
+/**
+  The user Entry Point for module UnixBlockIo. The user code starts with this function.
+
+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  
+  @param[in] SystemTable    A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS       The entry point is executed successfully.
+  @retval other             Some error occurs when executing this entry point.
+
+**/
+EFI_STATUS
+EFIAPI
+InitializeUnixBlockIo(
+  IN EFI_HANDLE           ImageHandle,
+  IN EFI_SYSTEM_TABLE     *SystemTable
+  )
+{
+  EFI_STATUS              Status;
+
+  Status = EfiLibInstallAllDriverProtocols2 (
+             ImageHandle,
+             SystemTable,
+             &gUnixBlockIoDriverBinding,
+             ImageHandle,
+             &gUnixBlockIoComponentName,
+             &gUnixBlockIoComponentName2,
+             NULL,
+             &gUnixBlockIoDriverDiagnostics,
+             &gUnixBlockIoDriverDiagnostics2
+             );
+  ASSERT_EFI_ERROR (Status);
+
+
+  return Status;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoDriverBindingSupported (
+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN  EFI_HANDLE                   Handle,
+  IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  )
+/*++
+
+Routine Description:
+
+Arguments:
+
+Returns:
+
+  None
+
+**/
+{
+  EFI_STATUS              Status;
+  EMU_IO_THUNK_PROTOCOL  *EmuIoThunk;
+
+  //
+  // Open the IO Abstraction(s) needed to perform the supported test
+  //
+  Status = gBS->OpenProtocol (
+                  Handle,
+                  &gEmuIoThunkProtocolGuid,
+                  (VOID **)&EmuIoThunk,
+                  This->DriverBindingHandle,
+                  Handle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Make sure the UnixThunkProtocol is valid
+  //
+  Status = EFI_UNSUPPORTED;
+  if (EmuIoThunk->UnixThunk->Signature == EFI_EMU_THUNK_PROTOCOL_SIGNATURE) {
+
+    //
+    // Check the GUID to see if this is a handle type the driver supports
+    //
+    if (CompareGuid (EmuIoThunk->TypeGuid, &gEfiUnixVirtualDisksGuid) ) {
+      Status = EFI_SUCCESS;
+    }
+  }
+
+  //
+  // Close the I/O Abstraction(s) used to perform the supported test
+  //
+  gBS->CloseProtocol (
+        Handle,
+        &gEmuIoThunkProtocolGuid,
+        This->DriverBindingHandle,
+        Handle
+        );
+  return Status;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoDriverBindingStart (
+  IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
+  IN  EFI_HANDLE                    Handle,
+  IN  EFI_DEVICE_PATH_PROTOCOL      *RemainingDevicePath
+  )
+/*++
+
+Routine Description:
+
+Arguments:
+
+Returns:
+
+  None
+
+**/
+{
+  EFI_STATUS                  Status;
+  EMU_IO_THUNK_PROTOCOL       *EmuIoThunk;
+  CHAR16                      Buffer[FILENAME_BUFFER_SIZE];
+  CHAR16                      *Str;
+  BOOLEAN                     RemovableMedia;
+  BOOLEAN                     WriteProtected;
+  UINTN                       NumberOfBlocks;
+  UINTN                       BlockSize;
+  INTN                        i;
+
+  //
+  // Grab the protocols we need
+  //
+  
+  Status = gBS->OpenProtocol (
+                  Handle,
+                  &gEmuIoThunkProtocolGuid,
+                  (void *)&EmuIoThunk,
+                  This->DriverBindingHandle,
+                  Handle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Set DiskType
+  //
+  if (!CompareGuid (EmuIoThunk->TypeGuid, &gEfiUnixVirtualDisksGuid)) {
+    Status = EFI_UNSUPPORTED;
+    goto Done;
+  }
+
+  Status  = EFI_NOT_FOUND;
+  //  Extract filename.
+  Str     = EmuIoThunk->EnvString;
+  i = 0;
+  while (*Str && *Str != ':')
+    Buffer[i++] = *Str++;
+  Buffer[i] = 0;
+  if (*Str != ':') {
+    goto Done;
+  }
+
+  Str++;
+
+  RemovableMedia = FALSE;
+  WriteProtected = TRUE;
+  NumberOfBlocks = 0;
+  BlockSize = 512;
+  do {
+    if (*Str == 'R' || *Str == 'F') {
+      RemovableMedia = (BOOLEAN) (*Str == 'R');
+      Str++;
+    }
+    if (*Str == 'O' || *Str == 'W') {
+      WriteProtected  = (BOOLEAN) (*Str == 'O');
+      Str++;
+    }
+    if (*Str == 0)
+      break;
+    if (*Str != ';')
+      goto Done;
+    Str++;
+
+    NumberOfBlocks  = Atoi (Str);
+    Str       = GetNextElementPastTerminator (Str, ';');
+    if (NumberOfBlocks == 0)
+      break;
+
+    BlockSize = Atoi (Str);
+    if (BlockSize != 0)
+      Str       = GetNextElementPastTerminator (Str, ';');
+  } while (0);
+
+  //
+  // If we get here the variable is valid so do the work.
+  //
+  Status = UnixBlockIoCreateMapping (
+              EmuIoThunk,
+              Handle,
+              Buffer,
+              WriteProtected,
+              RemovableMedia,
+              NumberOfBlocks,
+              BlockSize
+              );
+
+Done:
+  if (EFI_ERROR (Status)) {
+    gBS->CloseProtocol (
+          Handle,
+          &gEmuIoThunkProtocolGuid,
+          This->DriverBindingHandle,
+          Handle
+          );
+  }
+
+  return Status;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoDriverBindingStop (
+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN  EFI_HANDLE                   Handle,
+  IN  UINTN                        NumberOfChildren,
+  IN  EFI_HANDLE                   *ChildHandleBuffer
+  )
+{
+  EFI_BLOCK_IO_PROTOCOL   *BlockIo;
+  EFI_STATUS              Status;
+  EMU_BLOCK_IO_PRIVATE *Private;
+
+  //
+  // Get our context back
+  //
+  Status = gBS->OpenProtocol (
+                  Handle,
+                  &gEfiBlockIoProtocolGuid,
+                  (void *)&BlockIo,
+                  This->DriverBindingHandle,
+                  Handle,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Private = EMU_BLOCK_IO_PRIVATE_DATA_FROM_THIS (BlockIo);
+
+  //
+  // BugBug: If we need to kick people off, we need to make Uninstall Close the handles.
+  //         We could pass in our image handle or FLAG our open to be closed via
+  //         Unistall (== to saying any CloseProtocol will close our open)
+  //
+  Status = gBS->UninstallMultipleProtocolInterfaces (
+                  Private->EfiHandle,
+                  &gEfiBlockIoProtocolGuid,
+                  &Private->BlockIo,
+                  NULL
+                  );
+  if (!EFI_ERROR (Status)) {
+
+    Status = gBS->CloseProtocol (
+                    Handle,
+                    &gEmuIoThunkProtocolGuid,
+                    This->DriverBindingHandle,
+                    Handle
+                    );
+
+    //
+    // Shut down our device
+    //
+    Private->UnixThunk->Close (Private->fd);
+
+    //
+    // Free our instance data
+    //
+    FreeUnicodeStringTable (Private->ControllerNameTable);
+
+    gBS->FreePool (Private);
+  }
+
+  return Status;
+}
+
+CHAR16 *
+GetNextElementPastTerminator (
+  IN  CHAR16  *EnvironmentVariable,
+  IN  CHAR16  Terminator
+  )
+/*++
+
+Routine Description:
+
+  Worker function to parse environment variables.
+
+Arguments:
+  EnvironmentVariable - Envirnment variable to parse.
+
+  Terminator          - Terminator to parse for.
+
+Returns: 
+
+  Pointer to next eliment past the first occurence of Terminator or the '\0'
+  at the end of the string.
+
+**/
+{
+  CHAR16  *Ptr;
+
+  for (Ptr = EnvironmentVariable; *Ptr != '\0'; Ptr++) {
+    if (*Ptr == Terminator) {
+      Ptr++;
+      break;
+    }
+  }
+
+  return Ptr;
+}
+
+EFI_STATUS
+UnixBlockIoCreateMapping (
+  IN EMU_IO_THUNK_PROTOCOL             *EmuIoThunk,
+  IN EFI_HANDLE                         EfiDeviceHandle,
+  IN CHAR16                             *Filename,
+  IN BOOLEAN                            ReadOnly,
+  IN BOOLEAN                            RemovableMedia,
+  IN UINTN                              NumberOfBlocks,
+  IN UINTN                              BlockSize
+  )
+{
+  EFI_STATUS              Status;
+  EFI_BLOCK_IO_PROTOCOL   *BlockIo;
+  EMU_BLOCK_IO_PRIVATE *Private;
+  UINTN                   Index;
+
+  Status = gBS->AllocatePool (
+                  EfiBootServicesData,
+                  sizeof (EMU_BLOCK_IO_PRIVATE),
+                  (void *)&Private
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  EfiInitializeLock (&Private->Lock, TPL_NOTIFY);
+
+  Private->UnixThunk = EmuIoThunk->UnixThunk;
+
+  Private->Signature  = EMU_BLOCK_IO_PRIVATE_SIGNATURE;
+  Private->LastBlock  = NumberOfBlocks - 1;
+  Private->BlockSize  = BlockSize;
+
+  for (Index = 0; Filename[Index] != 0; Index++) {
+    Private->Filename[Index] = Filename[Index];
+  }
+
+  Private->Filename[Index]      = 0;
+
+  Private->Mode                 = (ReadOnly ? O_RDONLY : O_RDWR);
+
+  Private->NumberOfBlocks       = NumberOfBlocks;
+  Private->fd                   = -1;
+
+  Private->ControllerNameTable  = NULL;
+
+  AddUnicodeString (
+    "eng",
+    gUnixBlockIoComponentName.SupportedLanguages,
+    &Private->ControllerNameTable,
+    Filename
+    );
+
+  BlockIo = &Private->BlockIo;
+  BlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION;
+  BlockIo->Media = &Private->Media;
+  BlockIo->Media->BlockSize = Private->BlockSize;
+  BlockIo->Media->LastBlock = Private->NumberOfBlocks - 1;
+  BlockIo->Media->MediaId = 0;;
+
+  BlockIo->Reset = UnixBlockIoResetBlock;
+  BlockIo->ReadBlocks = UnixBlockIoReadBlocks;
+  BlockIo->WriteBlocks = UnixBlockIoWriteBlocks;
+  BlockIo->FlushBlocks = UnixBlockIoFlushBlocks;
+
+  BlockIo->Media->ReadOnly = ReadOnly;
+  BlockIo->Media->RemovableMedia = RemovableMedia;
+  BlockIo->Media->LogicalPartition = FALSE;
+  BlockIo->Media->MediaPresent = TRUE;
+  BlockIo->Media->WriteCaching = FALSE;
+
+  BlockIo->Media->IoAlign = 1;
+
+  Private->EfiHandle  = EfiDeviceHandle;
+  Status              = UnixBlockIoOpenDevice (Private);
+  if (!EFI_ERROR (Status)) {
+
+    Status = gBS->InstallMultipleProtocolInterfaces (
+                    &Private->EfiHandle,
+                    &gEfiBlockIoProtocolGuid,
+                    &Private->BlockIo,
+                    NULL
+                    );
+    if (EFI_ERROR (Status)) {
+      FreeUnicodeStringTable (Private->ControllerNameTable);
+      gBS->FreePool (Private);
+    }
+
+    DEBUG ((EFI_D_ERROR, "BlockDevice added: %s\n", Filename));
+  }
+
+  return Status;
+}
+
+EFI_STATUS
+UnixBlockIoOpenDevice (
+  EMU_BLOCK_IO_PRIVATE                 *Private
+  )
+{
+  EFI_STATUS            Status;
+  UINT64                FileSize;
+  UINT64                EndOfFile;
+  EFI_BLOCK_IO_PROTOCOL *BlockIo;
+
+  BlockIo = &Private->BlockIo;
+  EfiAcquireLock (&Private->Lock);
+
+  //
+  // If the device is already opened, close it
+  //
+  if (Private->fd >= 0) {
+    BlockIo->Reset (BlockIo, FALSE);
+  }
+
+  //
+  // Open the device
+  //
+  Private->fd = Private->UnixThunk->Open (Private->Filename, Private->Mode, 0644);
+  if (Private->fd < 0) {
+    DEBUG ((EFI_D_INFO, "PlOpenBlock: Could not open %a\n", Private->Filename));
+    BlockIo->Media->MediaPresent  = FALSE;
+    Status                        = EFI_NO_MEDIA;
+    goto Done;
+  }
+
+  if (!BlockIo->Media->MediaPresent) {
+    //
+    // BugBug: try to emulate if a CD appears - notify drivers to check it out
+    //
+    BlockIo->Media->MediaPresent = TRUE;
+    EfiReleaseLock (&Private->Lock);
+    EfiAcquireLock (&Private->Lock);
+  }
+
+  //
+  // get the size of the file
+  //
+  Status = SetFilePointer64 (Private, 0, &FileSize, SEEK_END);
+  if (EFI_ERROR (Status)) {
+    FileSize = MultU64x32 (Private->NumberOfBlocks, Private->BlockSize);
+    DEBUG ((EFI_D_ERROR, "PlOpenBlock: Could not get filesize of %a\n", Private->Filename));
+    Status = EFI_UNSUPPORTED;
+    goto Done;
+  }
+
+  if (Private->NumberOfBlocks == 0) {
+    Private->NumberOfBlocks = DivU64x32 (FileSize, Private->BlockSize);
+    Private->LastBlock = Private->NumberOfBlocks - 1;
+    Private->Media.LastBlock = Private->LastBlock;
+  }
+
+  EndOfFile = MultU64x32 (Private->NumberOfBlocks, Private->BlockSize);
+
+  if (FileSize != EndOfFile) {
+    //
+    // file is not the proper size, change it
+    //
+    DEBUG ((EFI_D_INIT, "PlOpenBlock: Initializing block device: %a\n", Private->Filename));
+
+    //
+    // first set it to 0
+    //
+    Private->UnixThunk->FTruncate (Private->fd, 0);
+
+    //
+    // then set it to the needed file size (OS will zero fill it)
+    //
+    Private->UnixThunk->FTruncate (Private->fd, EndOfFile);
+  }
+
+  DEBUG ((EFI_D_INIT, "%HPlOpenBlock: opened %a%N\n", Private->Filename));
+  Status = EFI_SUCCESS;
+
+Done:
+  if (EFI_ERROR (Status)) {
+    if (Private->fd >= 0) {
+      BlockIo->Reset (BlockIo, FALSE);
+    }
+  }
+
+  EfiReleaseLock (&Private->Lock);
+  return Status;
+}
+
+EFI_STATUS
+UnixBlockIoError (
+  IN EMU_BLOCK_IO_PRIVATE      *Private
+  )
+{
+  return EFI_DEVICE_ERROR;
+
+#if 0
+  EFI_BLOCK_IO_PROTOCOL *BlockIo;
+  EFI_STATUS            Status;
+  BOOLEAN               ReinstallBlockIoFlag;
+
+
+  BlockIo = &Private->BlockIo;
+
+  switch (Private->UnixThunk->GetLastError ()) {
+
+  case ERROR_NOT_READY:
+    Status                        = EFI_NO_MEDIA;
+    BlockIo->Media->ReadOnly      = FALSE;
+    BlockIo->Media->MediaPresent  = FALSE;
+    ReinstallBlockIoFlag          = FALSE;
+    break;
+
+  case ERROR_WRONG_DISK:
+    BlockIo->Media->ReadOnly      = FALSE;
+    BlockIo->Media->MediaPresent  = TRUE;
+    BlockIo->Media->MediaId += 1;
+    ReinstallBlockIoFlag  = TRUE;
+    Status                = EFI_MEDIA_CHANGED;
+    break;
+
+  case ERROR_WRITE_PROTECT:
+    BlockIo->Media->ReadOnly  = TRUE;
+    ReinstallBlockIoFlag      = FALSE;
+    Status                    = EFI_WRITE_PROTECTED;
+    break;
+
+  default:
+    ReinstallBlockIoFlag  = FALSE;
+    Status                = EFI_DEVICE_ERROR;
+    break;
+  }
+
+  if (ReinstallBlockIoFlag) {
+    BlockIo->Reset (BlockIo, FALSE);
+
+    gBS->ReinstallProtocolInterface (
+          Private->EfiHandle,
+          &gEfiBlockIoProtocolGuid,
+          BlockIo,
+          BlockIo
+          );
+  }
+
+  return Status;
+#endif
+}
+
+EFI_STATUS
+UnixBlockIoReadWriteCommon (
+  IN  EMU_BLOCK_IO_PRIVATE     *Private,
+  IN UINT32                       MediaId,
+  IN EFI_LBA                      Lba,
+  IN UINTN                        BufferSize,
+  IN VOID                         *Buffer,
+  IN CHAR8                        *CallerName
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       BlockSize;
+  UINT64      LastBlock;
+  INT64       DistanceToMove;
+  UINT64      DistanceMoved;
+
+  if (Private->fd < 0) {
+    Status = UnixBlockIoOpenDevice (Private);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+
+  if (!Private->Media.MediaPresent) {
+    DEBUG ((EFI_D_INIT, "%s: No Media\n", CallerName));
+    return EFI_NO_MEDIA;
+  }
+
+  if (Private->Media.MediaId != MediaId) {
+    return EFI_MEDIA_CHANGED;
+  }
+
+  if ((UINTN) Buffer % Private->Media.IoAlign != 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  //
+  // Verify buffer size
+  //
+  BlockSize = Private->BlockSize;
+  if (BufferSize == 0) {
+    DEBUG ((EFI_D_INIT, "%s: Zero length read\n", CallerName));
+    return EFI_SUCCESS;
+  }
+
+  if ((BufferSize % BlockSize) != 0) {
+    DEBUG ((EFI_D_INIT, "%s: Invalid read size\n", CallerName));
+    return EFI_BAD_BUFFER_SIZE;
+  }
+
+  LastBlock = Lba + (BufferSize / BlockSize) - 1;
+  if (LastBlock > Private->LastBlock) {
+    DEBUG ((EFI_D_INIT, "ReadBlocks: Attempted to read off end of device\n"));
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Seek to End of File
+  //
+  DistanceToMove = MultU64x32 (Lba, BlockSize);
+  Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, SEEK_SET);
+
+  if (EFI_ERROR (Status)) {
+    DEBUG ((EFI_D_INIT, "WriteBlocks: SetFilePointer failed\n"));
+    return UnixBlockIoError (Private);
+  }
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoReadBlocks (
+  IN EFI_BLOCK_IO_PROTOCOL  *This,
+  IN UINT32                 MediaId,
+  IN EFI_LBA                Lba,
+  IN UINTN                  BufferSize,
+  OUT VOID                  *Buffer
+  )
+/*++
+
+  Routine Description:
+    Read BufferSize bytes from Lba into Buffer.
+
+  Arguments:
+    This       - Protocol instance pointer.
+    MediaId    - Id of the media, changes every time the media is replaced.
+    Lba        - The starting Logical Block Address to read from
+    BufferSize - Size of Buffer, must be a multiple of device block size.
+    Buffer     - Buffer containing read data
+
+  Returns:
+    EFI_SUCCESS           - The data was read correctly from the device.
+    EFI_DEVICE_ERROR      - The device reported an error while performing the read.
+    EFI_NO_MEDIA          - There is no media in the device.
+    EFI_MEDIA_CHANGED     - The MediaId does not matched the current device.
+    EFI_BAD_BUFFER_SIZE   - The Buffer was not a multiple of the block size of the 
+                            device.
+    EFI_INVALID_PARAMETER - The read request contains device addresses that are not 
+                            valid for the device.
+
+**/
+{
+  EMU_BLOCK_IO_PRIVATE *Private;
+  ssize_t                 len;
+  EFI_STATUS              Status;
+  EFI_TPL                 OldTpl;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  Private = EMU_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
+
+  Status  = UnixBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "UnixReadBlocks");
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  len = Private->UnixThunk->Read (Private->fd, Buffer, BufferSize);
+  if (len != BufferSize) {
+    DEBUG ((EFI_D_INIT, "ReadBlocks: ReadFile failed.\n"));
+    Status = UnixBlockIoError (Private);
+    goto Done;
+  }
+
+  //
+  // If we wrote then media is present.
+  //
+  This->Media->MediaPresent = TRUE;
+  Status = EFI_SUCCESS;
+
+Done:
+  gBS->RestoreTPL (OldTpl);
+  return Status;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoWriteBlocks (
+  IN EFI_BLOCK_IO_PROTOCOL  *This,
+  IN UINT32                 MediaId,
+  IN EFI_LBA                Lba,
+  IN UINTN                  BufferSize,
+  IN VOID                   *Buffer
+  )
+/*++
+
+  Routine Description:
+    Write BufferSize bytes from Lba into Buffer.
+
+  Arguments:
+    This       - Protocol instance pointer.
+    MediaId    - Id of the media, changes every time the media is replaced.
+    Lba        - The starting Logical Block Address to read from
+    BufferSize - Size of Buffer, must be a multiple of device block size.
+    Buffer     - Buffer containing read data
+
+  Returns:
+    EFI_SUCCESS           - The data was written correctly to the device.
+    EFI_WRITE_PROTECTED   - The device can not be written to.
+    EFI_DEVICE_ERROR      - The device reported an error while performing the write.
+    EFI_NO_MEDIA          - There is no media in the device.
+    EFI_MEDIA_CHNAGED     - The MediaId does not matched the current device.
+    EFI_BAD_BUFFER_SIZE   - The Buffer was not a multiple of the block size of the 
+                            device.
+    EFI_INVALID_PARAMETER - The write request contains a LBA that is not 
+                            valid for the device.
+
+**/
+{
+  EMU_BLOCK_IO_PRIVATE *Private;
+  ssize_t                 len;
+  EFI_STATUS              Status;
+  EFI_TPL                 OldTpl;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  Private = EMU_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
+
+  Status  = UnixBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "UnixWriteBlocks");
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  len = Private->UnixThunk->Write (Private->fd, Buffer, BufferSize);
+  if (len != BufferSize) {
+    DEBUG ((EFI_D_INIT, "ReadBlocks: WriteFile failed.\n"));
+    Status = UnixBlockIoError (Private);
+    goto Done;
+  }
+
+  //
+  // If the write succeeded, we are not write protected and media is present.
+  //
+  This->Media->MediaPresent = TRUE;
+  This->Media->ReadOnly     = FALSE;
+  Status = EFI_SUCCESS;
+
+Done:
+  gBS->RestoreTPL (OldTpl);
+  return Status;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoFlushBlocks (
+  IN EFI_BLOCK_IO_PROTOCOL  *This
+  )
+/*++
+
+  Routine Description:
+    Flush the Block Device.
+
+  Arguments:
+    This             - Protocol instance pointer.
+
+  Returns:
+    EFI_SUCCESS      - All outstanding data was written to the device
+    EFI_DEVICE_ERROR - The device reported an error while writting back the data
+    EFI_NO_MEDIA     - There is no media in the device.
+
+**/
+{
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+UnixBlockIoResetBlock (
+  IN EFI_BLOCK_IO_PROTOCOL  *This,
+  IN BOOLEAN                ExtendedVerification
+  )
+/*++
+
+  Routine Description:
+    Reset the Block Device.
+
+  Arguments:
+    This                 - Protocol instance pointer.
+    ExtendedVerification - Driver may perform diagnostics on reset.
+
+  Returns:
+    EFI_SUCCESS           - The device was reset.
+    EFI_DEVICE_ERROR      - The device is not functioning properly and could 
+                            not be reset.
+
+**/
+{
+  EMU_BLOCK_IO_PRIVATE *Private;
+  EFI_TPL               OldTpl;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+  
+  Private = EMU_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
+
+  if (Private->fd >= 0) {
+    Private->UnixThunk->Close (Private->fd);
+    Private->fd = -1;
+  }
+
+  gBS->RestoreTPL (OldTpl);
+
+  return EFI_SUCCESS;
+}
+
+UINTN
+Atoi (
+  CHAR16  *String
+  )
+/*++
+
+Routine Description:
+
+  Convert a unicode string to a UINTN
+
+Arguments:
+
+  String - Unicode string.
+
+Returns: 
+
+  UINTN of the number represented by String.  
+
+**/
+{
+  UINTN   Number;
+  CHAR16  *Str;
+
+  //
+  // skip preceeding white space
+  //
+  Str = String;
+  while ((*Str) && (*Str == ' ')) {
+    Str++;
+  }
+  //
+  // Convert ot a Number
+  //
+  Number = 0;
+  while (*Str != '\0') {
+    if ((*Str >= '0') && (*Str <= '9')) {
+      Number = (Number * 10) +*Str - '0';
+    } else {
+      break;
+    }
+
+    Str++;
+  }
+
+  return Number;
+}
+
+
+/*++
+
+This function extends the capability of SetFilePointer to accept 64 bit parameters
+
+**/
+EFI_STATUS
+SetFilePointer64 (
+  IN  EMU_BLOCK_IO_PRIVATE    *Private,
+  IN  INT64                      DistanceToMove,
+  OUT UINT64                     *NewFilePointer,
+  IN  INT32                      MoveMethod
+  )
+{
+  EFI_STATUS    Status;
+  off_t         res;
+
+  Status = EFI_SUCCESS;
+  res = Private->UnixThunk->Lseek(Private->fd, DistanceToMove, MoveMethod);
+  if (res == -1) {
+    Status = EFI_INVALID_PARAMETER;
+  }
+
+  if (NewFilePointer != NULL) {
+    *NewFilePointer = res;
+  }
+
+  return Status;
+}
diff --git a/InOsEmuPkg/Unix/Sec/SecMain.c b/InOsEmuPkg/Unix/Sec/SecMain.c
index c00268b383..9c0990b2cd 100644
--- a/InOsEmuPkg/Unix/Sec/SecMain.c
+++ b/InOsEmuPkg/Unix/Sec/SecMain.c
@@ -458,7 +458,6 @@ SecLoadFromCore (
     (SWITCH_STACK_ENTRY_POINT) (UINTN) PeiCoreEntryPoint,
     SecCoreData,
     (VOID *)gPpiList,
-    NULL,
     TopOfStack
     );
   //
diff --git a/InOsEmuPkg/Unix/Sec/SecMain.h b/InOsEmuPkg/Unix/Sec/SecMain.h
index 00ab7a61ab..19e5f17147 100644
--- a/InOsEmuPkg/Unix/Sec/SecMain.h
+++ b/InOsEmuPkg/Unix/Sec/SecMain.h
@@ -283,7 +283,6 @@ PeiSwitchStacks (
   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
   IN      VOID                      *Context1,  OPTIONAL
   IN      VOID                      *Context2,  OPTIONAL
-  IN      VOID                      *Context3,  OPTIONAL
   IN      VOID                      *NewStack
   );
 
diff --git a/InOsEmuPkg/Unix/Sec/X64/SwitchStack.S b/InOsEmuPkg/Unix/Sec/X64/SwitchStack.S
index 76567ac0e1..8a57b781b5 100644
--- a/InOsEmuPkg/Unix/Sec/X64/SwitchStack.S
+++ b/InOsEmuPkg/Unix/Sec/X64/SwitchStack.S
@@ -16,7 +16,7 @@
 #------------------------------------------------------------------------------
 # Routine Description:
 #
-#   Routine for switching stacks with 3 parameters EFI ABI
+#   Routine for switching stacks with 2 parameters EFI ABI
 #   Convert UNIX to EFI ABI
 #
 # Arguments:
@@ -24,8 +24,7 @@
 #   (rdi) EntryPoint    - Entry point with new stack.
 #   (rsi) Context1      - Parameter1 for entry point. (rcx)
 #   (rdx) Context2      - Parameter2 for entry point. (rdx) 
-#   (rcx) Context3      - Parameter3 for entry point. (r8)
-#   (r8)  NewStack      - The pointer to new stack.
+#   (rcx) NewStack      - The pointer to new stack.
 #
 # Returns:
 #
@@ -37,11 +36,11 @@ ASM_PFX(PeiSwitchStacks):
     pushq   $0            // tells gdb to stop unwinding frame
     movq    %rsp, %rbp
 
-    movq    %r8,  %rsp
+    movq    %rcx, %rsp    // update stack pointer
     
-    movq    %rdi, %rax
-    movq    %rsi, %rcx
-    movq    %rcx, %r8    
+    movq    %rdi, %rax    // entry point to %rax
+    movq    %rsi, %rcx    // Adjust Context1
+                          // Context2 already in the rigth spot
     
     #
     # Reserve space for register parameters (rcx, rdx, r8 & r9) on the stack,
diff --git a/InOsEmuPkg/Unix/UnixX64.dsc b/InOsEmuPkg/Unix/UnixX64.dsc
index dcae0176ff..06b7b34322 100644
--- a/InOsEmuPkg/Unix/UnixX64.dsc
+++ b/InOsEmuPkg/Unix/UnixX64.dsc
@@ -356,9 +356,9 @@
   InOsEmuPkg/EmuBusDriverDxe/EmuBusDriverDxe.inf
   InOsEmuPkg/EmuGopDxe/EmuGopDxe.inf
   InOsEmuPkg/EmuSimpleFileSystemDxe/EmuSimpleFileSystemDxe.inf
+  InOsEmuPkg/EmuBlockIoDxe/EmuBlockIoDxe.inf
 
 !if $(0)
-  UnixPkg/UnixBlockIoDxe/UnixBlockIo.inf
   UnixPkg/UnixSerialIoDxe/UnixSerialIo.inf
   UnixPkg/UnixConsoleDxe/UnixConsole.inf
   UnixPkg/UnixSimpleFileSystemDxe/UnixSimpleFileSystem.inf
diff --git a/InOsEmuPkg/Unix/UnixX64.fdf b/InOsEmuPkg/Unix/UnixX64.fdf
index 0ba58a39d0..14e5b6022a 100644
--- a/InOsEmuPkg/Unix/UnixX64.fdf
+++ b/InOsEmuPkg/Unix/UnixX64.fdf
@@ -253,24 +253,18 @@ INF  MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Dxe.inf
 INF FatPkg/EnhancedFatDxe/Fat.inf
 !else
 # Used checked in Visual Studio binaries
-INF  RuleOverride = BINARY USE = X64 FatBinPkg/EnhancedFatDxe/Fat.inf
+FILE DRIVER = 961578FE-B6B7-44c3-AF35-6BC705CD2B1F {
+    SECTION PE32 = FatBinPkg/EnhancedFatDxe/X64/Fat.efi
+  }
 !endif
 
 !if $(BUILD_NEW_SHELL)
 INF  ShellPkg/Application/Shell/Shell.inf
 !else
-!if $(USE_NEW_SHELL)
-INF  ShellBinPkg/UefiShell/UefiShell.inf
-!else
- FILE APPLICATION = PCD(gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdShellFile) {
-!if $(BUILD_OLD_SHELL)
-  SECTION PE32 = Build/GccShellPkg/DEBUG_XCLANG/X64/ShellFull.efi
-!else
-  SECTION PE32 = EdkShellBinPkg/FullShell/X64/Shell_Full.efi
-!endif
-  SECTION UI = "Shell"
- }
-!endif
+# Used checked in Visual Studio binaries
+FILE APPLICATION = PCD(gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdShellFile) {
+    SECTION PE32 = EdkShellBinPkg/FullShell/X64/Shell_Full.efi
+  }
 !endif
 
 FILE FREEFORM = PCD(gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdLogoFile) {
diff --git a/InOsEmuPkg/Unix/build64.sh b/InOsEmuPkg/Unix/build64.sh
index e575a9266e..a9294be02e 100755
--- a/InOsEmuPkg/Unix/build64.sh
+++ b/InOsEmuPkg/Unix/build64.sh
@@ -43,7 +43,8 @@ fi
 TARGET_TOOLS=MYTOOLS
 UNIXPKG_TOOLS=GCC44
 NETWORK_SUPPORT=
-COMPILE_BINS=
+BUILD_NEW_SHELL=
+BUILD_FAT=
 case `uname` in
   CYGWIN*) echo Cygwin not fully supported yet. ;;
   Darwin*)
@@ -56,8 +57,9 @@ case `uname` in
         TARGET_TOOLS=XCODE32
         UNIXPKG_TOOLS=XCLANG
       fi
-      NETWORK_SUPPORT="-D NETWORK_SUPPORT"
-      COMPILE_BINS="-D COMPILE_BINS"
+#      NETWORK_SUPPORT="-D NETWORK_SUPPORT"
+#      BUILD_NEW_SHELL="-D BUILD_NEW_SHELL"
+#      BUILD_FAT="-D BUILD_FAT"
       ;;
   Linux*) TARGET_TOOLS=ELFGCC ;;
 
@@ -112,11 +114,6 @@ do
     exit $?
   fi
 
-  if [[ $arg == shell ]]; then
-    build -p $WORKSPACE/ShellPkg/ShellPkg.dsc -a X64 -t $UNIXPKG_TOOLS -n 3 $2 $3 $4 $5 $6 $7 $8
-    cp Build/Shell/DEBUG_$UNIXPKG_TOOLS/X64/Shell.efi ShellBinPkg/UefiShell/X64/Shell.efi
-    exit $?
-  fi
 done
 
 
@@ -126,7 +123,7 @@ done
 echo $PATH
 echo `which build`
 build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc      -a X64 -t $TARGET_TOOLS -D SEC_ONLY -n 3 $1 $2 $3 $4 $5 $6 $7 $8  modules
-build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc      -a X64 -t $UNIXPKG_TOOLS $NETWORK_SUPPORT -n 3 $1 $2 $3 $4 $5 $6 $7 $8
+build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc      -a X64 -t $UNIXPKG_TOOLS $NETWORK_SUPPORT $BUILD_NEW_SHELL $BUILD_FAT -n 3 $1 $2 $3 $4 $5 $6 $7 $8
 cp $WORKSPACE/Build/EmuUnixX64/DEBUG_"$TARGET_TOOLS"/X64/SecMain $WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/X64
 exit $?
author	andrewfish <andrewfish@6f19259b-4bc3-4df7-8a09-765794883524>	2011-05-31 20:23:36 +0000
committer	andrewfish <andrewfish@6f19259b-4bc3-4df7-8a09-765794883524>	2011-05-31 20:23:36 +0000
commit	d59326d3a871f1df6e9416334ca2181ac4373d42 (patch)
tree	1ed7cfdd245be8f6edcb3061a371cdaf4c835734 /InOsEmuPkg/Unix
parent	283d361e98f2e7da579b022426d3dfb4fc1e33a8 (diff)
download	edk2-platforms-d59326d3a871f1df6e9416334ca2181ac4373d42.tar.xz