diff options
Diffstat (limited to 'StdLib/LibC/Uefi')
| -rw-r--r-- | StdLib/LibC/Uefi/Console.c | 393 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/Console/daConsole.c | 558 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/UefiShell/daShell.c | 650 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/Utility/DevGenisis.c | 139 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/Utility/DevSearch.c | 112 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/Utility/Path.c | 382 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/daConsole.inf | 63 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/daShell.inf | 63 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Devices/daUtility.inf | 56 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/SysCalls.c | 921 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/SysEfi.h | 37 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Uefi.inf | 4 | ||||
| -rw-r--r-- | StdLib/LibC/Uefi/Xform.c | 8 |
13 files changed, 2458 insertions, 928 deletions
diff --git a/StdLib/LibC/Uefi/Console.c b/StdLib/LibC/Uefi/Console.c deleted file mode 100644 index 0c3a21cf45..0000000000 --- a/StdLib/LibC/Uefi/Console.c +++ /dev/null @@ -1,393 +0,0 @@ -/** @file
- File abstractions of the console.
-
- Manipulates EFI_FILE_PROTOCOL abstractions for stdin, stdout, stderr.
-
- Copyright (c) 2010, 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 that 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 <Uefi.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include <LibConfig.h>
-#include <sys/EfiCdefs.h>
-
-#include <stdio.h>
-#include <sys/fcntl.h>
-#include <MainData.h>
-#include <Efi/Console.h>
-
-static const CHAR16 * stdioNames[NUM_SPECIAL] = {
- L"stdin:", L"stdout:", L"stderr:"
-};
-static const int stdioFlags[NUM_SPECIAL] = {
- O_RDONLY, // stdin
- O_WRONLY, // stdout
- O_WRONLY // stderr
-};
-
-static const int stdioMode[NUM_SPECIAL] = {
- 0444, // stdin
- 0222, // stdout
- 0222 // stderr
-};
-
-static
-EFI_STATUS
-EFIAPI
-ConClose(
- IN EFI_FILE_PROTOCOL *This
- )
-{
- ConInstance *Stream;
-
- Stream = BASE_CR(This, ConInstance, Abstraction);
- // Quick check to see if Stream looks reasonable
- if(Stream->Cookie != 0x62416F49) { // Cookie == 'IoAb'
- return RETURN_INVALID_PARAMETER; // Looks like a bad This pointer
- }
- // Nothing to Flush.
- // Mark the Stream as closed.
- Stream->Dev = NULL;
-
- return RETURN_SUCCESS;
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConDelete(
- IN EFI_FILE_PROTOCOL *This
- )
-{
- return RETURN_UNSUPPORTED;
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConRead(
- IN EFI_FILE_PROTOCOL *This,
- IN OUT UINTN *BufferSize,
- OUT VOID *Buffer
- )
-{
- EFI_SIMPLE_TEXT_INPUT_PROTOCOL *Proto;
- ConInstance *Stream;
- CHAR16 *OutPtr;
- EFI_INPUT_KEY Key;
- UINTN NumChar;
- UINTN Edex;
- EFI_STATUS Status;
- UINTN i;
-
- Stream = BASE_CR(This, ConInstance, Abstraction);
- // Quick check to see if Stream looks reasonable
- if(Stream->Cookie != 0x62416F49) { // Cookie == 'IoAb'
- return RETURN_INVALID_PARAMETER; // Looks like a bad This pointer
- }
- if(Stream->Dev == NULL) {
- // Can't read from an unopened Stream
- return RETURN_DEVICE_ERROR;
- }
- if(Stream != &gMD->StdIo[0]) {
- // Read only valid for stdin
- return RETURN_UNSUPPORTED;
- }
- // It looks like things are OK for trying to read
- // We will accumulate *BufferSize characters or until we encounter
- // an "activation" character. Currently any control character.
- Proto = (EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)Stream->Dev;
- OutPtr = Buffer;
- NumChar = (*BufferSize - 1) / sizeof(CHAR16);
- i = 0;
- do {
- Status = gBS->WaitForEvent( 1, &Proto->WaitForKey, &Edex);
- if(Status != EFI_SUCCESS) {
- break;
- }
- Status = Proto->ReadKeyStroke(Proto, &Key);
- if(Status != EFI_SUCCESS) {
- break;
- }
- if(Key.ScanCode == SCAN_NULL) {
- *OutPtr++ = Key.UnicodeChar;
- ++i;
- }
- if(Key.UnicodeChar < 0x0020) { // If a control character, or a scan code
- break;
- }
- } while(i < NumChar);
- *BufferSize = i * sizeof(CHAR16);
- return Status;
-}
-
-/* Write a NULL terminated WCS to the EFI console.
-
- @param[in,out] BufferSize Number of bytes in Buffer. Set to zero if
- the string couldn't be displayed.
- @parem[in] Buffer The WCS string to be displayed
-
-*/
-static
-EFI_STATUS
-EFIAPI
-ConWrite(
- IN EFI_FILE_PROTOCOL *This,
- IN OUT UINTN *BufferSize,
- IN VOID *Buffer
- )
-{
- EFI_STATUS Status;
- EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
- ConInstance *Stream;
- CHAR16 *MyBuf;
- UINTN NumChar;
-
- Stream = BASE_CR(This, ConInstance, Abstraction);
- // Quick check to see if Stream looks reasonable
- if(Stream->Cookie != 0x62416F49) { // Cookie == 'IoAb'
- return RETURN_INVALID_PARAMETER; // Looks like a bad This pointer
- }
- if(Stream->Dev == NULL) {
- // Can't write to an unopened Stream
- return RETURN_DEVICE_ERROR;
- }
- if(Stream == &gMD->StdIo[0]) {
- // Write is not valid for stdin
- return RETURN_UNSUPPORTED;
- }
- // Everything is OK to do the write.
- Proto = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)Stream->Dev;
- MyBuf = (CHAR16 *)Buffer;
- NumChar = *BufferSize;
-
- // Send MyBuf to the console
- Status = Proto->OutputString( Proto, MyBuf);
- // Depending on status, update BufferSize and return
- if(Status != EFI_SUCCESS) {
- *BufferSize = 0; // We don't really know how many characters made it out
- }
- else {
- *BufferSize = NumChar;
- Stream->NumWritten += NumChar;
- }
- return Status;
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConGetPosition(
- IN EFI_FILE_PROTOCOL *This,
- OUT UINT64 *Position
- )
-{
- ConInstance *Stream;
- EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
- XYoffset CursorPos;
-
- Stream = BASE_CR(This, ConInstance, Abstraction);
- // Quick check to see if Stream looks reasonable
- if(Stream->Cookie != 0x62416F49) { // Cookie == 'IoAb'
- return RETURN_INVALID_PARAMETER; // Looks like a bad This pointer
- }
- if(Stream == &gMD->StdIo[0]) {
- // This is stdin
- *Position = Stream->NumRead;
- }
- else {
- Proto = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)Stream->Dev;
- CursorPos.XYpos.Column = (UINT32)Proto->Mode->CursorColumn;
- CursorPos.XYpos.Row = (UINT32)Proto->Mode->CursorRow;
- *Position = CursorPos.Offset;
- }
- return RETURN_SUCCESS;
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConSetPosition(
- IN EFI_FILE_PROTOCOL *This,
- IN UINT64 Position
- )
-{
- ConInstance *Stream;
- EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
- XYoffset CursorPos;
-
- Stream = BASE_CR(This, ConInstance, Abstraction);
- // Quick check to see if Stream looks reasonable
- if(Stream->Cookie != 0x62416F49) { // Cookie == 'IoAb'
- return RETURN_INVALID_PARAMETER; // Looks like a bad This pointer
- }
- if(Stream->Dev == NULL) {
- // Can't write to an unopened Stream
- return RETURN_DEVICE_ERROR;
- }
- if(Stream == &gMD->StdIo[0]) {
- // Seek is not valid for stdin
- return RETURN_UNSUPPORTED;
- }
- // Everything is OK to do the final verification and "seek".
- Proto = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)Stream->Dev;
- CursorPos.Offset = Position;
-
- return Proto->SetCursorPosition(Proto,
- (INTN)CursorPos.XYpos.Column,
- (INTN)CursorPos.XYpos.Row);
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConGetInfo(
- IN EFI_FILE_PROTOCOL *This,
- IN EFI_GUID *InformationType,
- IN OUT UINTN *BufferSize,
- OUT VOID *Buffer
- )
-{
- EFI_FILE_INFO *InfoBuf;
- ConInstance *Stream;
-
- Stream = BASE_CR(This, ConInstance, Abstraction);
- // Quick check to see if Stream looks reasonable
- if((Stream->Cookie != 0x62416F49) || // Cookie == 'IoAb'
- (Buffer == NULL))
- {
- return RETURN_INVALID_PARAMETER;
- }
- if(*BufferSize < sizeof(EFI_FILE_INFO)) {
- *BufferSize = sizeof(EFI_FILE_INFO);
- return RETURN_BUFFER_TOO_SMALL;
- }
- // All of our parameters are correct, so fill in the information.
- (void) ZeroMem(Buffer, sizeof(EFI_FILE_INFO));
- InfoBuf = (EFI_FILE_INFO *)Buffer;
- InfoBuf->Size = sizeof(EFI_FILE_INFO);
- InfoBuf->FileSize = 1;
- InfoBuf->PhysicalSize = 1;
- *BufferSize = sizeof(EFI_FILE_INFO);
-
- return RETURN_SUCCESS;
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConSetInfo(
- IN EFI_FILE_PROTOCOL *This,
- IN EFI_GUID *InformationType,
- IN UINTN BufferSize,
- IN VOID *Buffer
- )
-{
- return RETURN_UNSUPPORTED;
-}
-
-static
-EFI_STATUS
-EFIAPI
-ConFlush(
- IN EFI_FILE_PROTOCOL *This
- )
-{
- return RETURN_SUCCESS;
-}
-
-EFI_STATUS
-EFIAPI
-ConOpen(
- IN EFI_FILE_PROTOCOL *This,
- OUT EFI_FILE_PROTOCOL **NewHandle,
- IN CHAR16 *FileName,
- IN UINT64 OpenMode, // Ignored
- IN UINT64 Attributes // Ignored
- )
-{
- ConInstance *Stream;
- EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
- UINTN Columns;
- UINTN Rows;
- int i;
-
- if((NewHandle == NULL) ||
- (FileName == NULL))
- {
- return RETURN_INVALID_PARAMETER;
- }
- // Process FileName
- for(i = 0; i < NUM_SPECIAL; ++i) {
- if(StrCmp( stdioNames[i], FileName) == 0) {
- break;
- }
- }
- if(i >= NUM_SPECIAL) {
- return RETURN_NO_MAPPING;
- }
- // Get pointer to instance.
- Stream = &gMD->StdIo[i];
- if(Stream->Dev == NULL) {
- // If this stream has been closed, then
- // Initialize instance.
- Stream->Cookie = 0x62416F49;
- Stream->NumRead = 0;
- Stream->NumWritten = 0;
- switch(i) {
- case 0:
- Stream->Dev = gST->ConIn;
- break;
- case 1:
- Stream->Dev = gST->ConOut;
- break;
- case 2:
- if(gST->StdErr == NULL) {
- Stream->Dev = gST->ConOut;
- }
- else {
- Stream->Dev = gST->StdErr;
- }
- break;
- default:
- return RETURN_VOLUME_CORRUPTED; // This is a "should never happen" case.
- }
- Stream->Abstraction.Revision = 0x00010000;
- Stream->Abstraction.Open = &ConOpen;
- Stream->Abstraction.Close = &ConClose;
- Stream->Abstraction.Delete = &ConDelete;
- Stream->Abstraction.Read = &ConRead;
- Stream->Abstraction.Write = &ConWrite;
- Stream->Abstraction.GetPosition = &ConGetPosition;
- Stream->Abstraction.SetPosition = &ConSetPosition;
- Stream->Abstraction.GetInfo = &ConGetInfo;
- Stream->Abstraction.SetInfo = &ConSetInfo;
- Stream->Abstraction.Flush = &ConFlush;
- // Get additional information if this is an Output stream
- if(i != 0) {
- Proto = Stream->Dev;
- Stream->ConOutMode = Proto->Mode->Mode;
- if( Proto->QueryMode(Proto, Stream->ConOutMode, &Columns, &Rows) != RETURN_SUCCESS) {
- Stream->Dev = NULL; // Mark this stream as closed
- return RETURN_INVALID_PARAMETER;
- }
- Stream->MaxConXY.XYpos.Column = (UINT32)Columns;
- Stream->MaxConXY.XYpos.Row = (UINT32)Rows;
- }
- }
- // Save NewHandle and return.
- *NewHandle = &Stream->Abstraction;
-
- return RETURN_SUCCESS;
-}
diff --git a/StdLib/LibC/Uefi/Devices/Console/daConsole.c b/StdLib/LibC/Uefi/Devices/Console/daConsole.c new file mode 100644 index 0000000000..c579959081 --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/Console/daConsole.c @@ -0,0 +1,558 @@ +/** @file
+ Abstract device driver for the UEFI Console.
+
+ Manipulates abstractions for stdin, stdout, stderr.
+
+ Copyright (c) 2010 - 2011, 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 that 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 <Uefi.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Protocol/SimpleTextIn.h>
+#include <Protocol/SimpleTextOut.h>
+
+#include <LibConfig.h>
+#include <sys/EfiSysCall.h>
+
+#include <errno.h>
+#include <wctype.h>
+#include <wchar.h>
+#include <sys/fcntl.h>
+#include <kfile.h>
+#include <Device/Device.h>
+#include <MainData.h>
+
+static const CHAR16* const
+stdioNames[NUM_SPECIAL] = {
+ L"stdin:", L"stdout:", L"stderr:"
+};
+
+static const int stdioFlags[NUM_SPECIAL] = {
+ O_RDONLY, // stdin
+ O_WRONLY, // stdout
+ O_WRONLY // stderr
+};
+
+static DeviceNode *ConNode[NUM_SPECIAL];
+static ConInstance *ConInstanceList;
+
+ssize_t
+WideTtyCvt( CHAR16 *dest, const char *buf, size_t n)
+{
+ UINTN i;
+ wint_t wc;
+
+ for(i = 0; i < n; ++i) {
+ wc = btowc(*buf++);
+ if( wc == 0) {
+ break;
+ };
+ if(wc < 0) {
+ wc = BLOCKELEMENT_LIGHT_SHADE;
+ }
+ if(wc == L'\n') {
+ *dest++ = L'\r';
+ }
+ *dest++ = (CHAR16)wc;
+ }
+ *dest = 0;
+ return (ssize_t)i;
+}
+
+static
+int
+EFIAPI
+da_ConClose(
+ IN struct __filedes *filp
+)
+{
+ ConInstance *Stream;
+
+ Stream = BASE_CR(filp->f_ops, ConInstance, Abstraction);
+ // Quick check to see if Stream looks reasonable
+ if(Stream->Cookie != CON_COOKIE) { // Cookie == 'IoAb'
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1; // Looks like a bad File Descriptor pointer
+ }
+ gMD->StdIo[Stream->InstanceNum] = NULL; // Mark the stream as closed
+ return RETURN_SUCCESS;
+}
+
+static
+off_t
+EFIAPI
+da_ConSeek(
+ struct __filedes *filp,
+ off_t Position,
+ int whence ///< Ignored by Console
+)
+{
+ ConInstance *Stream;
+ EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
+ XYoffset CursorPos;
+
+ Stream = BASE_CR(filp->f_ops, ConInstance, Abstraction);
+ // Quick check to see if Stream looks reasonable
+ if(Stream->Cookie != CON_COOKIE) { // Cookie == 'IoAb'
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1; // Looks like a bad This pointer
+ }
+ if(Stream->InstanceNum == STDIN_FILENO) {
+ // Seek is not valid for stdin
+ EFIerrno = RETURN_UNSUPPORTED;
+ return -1;
+ }
+ // Everything is OK to do the final verification and "seek".
+ Proto = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)Stream->Dev;
+ CursorPos.Offset = Position;
+
+ EFIerrno = Proto->SetCursorPosition(Proto,
+ (INTN)CursorPos.XYpos.Column,
+ (INTN)CursorPos.XYpos.Row);
+
+ if(RETURN_ERROR(EFIerrno)) {
+ return -1;
+ }
+ else {
+ return Position;
+ }
+}
+
+static
+ssize_t
+EFIAPI
+da_ConRead(
+ IN OUT struct __filedes *filp,
+ IN OUT off_t *offset, // Console ignores this
+ IN size_t BufferSize,
+ OUT VOID *Buffer
+)
+{
+ EFI_SIMPLE_TEXT_INPUT_PROTOCOL *Proto;
+ ConInstance *Stream;
+ CHAR16 *OutPtr;
+ EFI_INPUT_KEY Key;
+ UINTN NumChar;
+ UINTN Edex;
+ EFI_STATUS Status = RETURN_SUCCESS;
+ UINTN i;
+
+ Stream = BASE_CR(filp->f_ops, ConInstance, Abstraction);
+ // Quick check to see if Stream looks reasonable
+ if(Stream->Cookie != CON_COOKIE) { // Cookie == 'IoAb'
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1; // Looks like a bad This pointer
+ }
+ if(Stream->InstanceNum != STDIN_FILENO) {
+ // Read only valid for stdin
+ EFIerrno = RETURN_UNSUPPORTED;
+ return -1;
+ }
+ // It looks like things are OK for trying to read
+ // We will accumulate *BufferSize characters or until we encounter
+ // an "activation" character. Currently any control character.
+ Proto = (EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)Stream->Dev;
+ OutPtr = Buffer;
+ NumChar = (BufferSize - 1) / sizeof(CHAR16);
+ i = 0;
+ do {
+ if((Stream->UnGetKey.UnicodeChar == CHAR_NULL) && (Stream->UnGetKey.ScanCode == SCAN_NULL)) {
+ Status = gBS->WaitForEvent( 1, &Proto->WaitForKey, &Edex);
+ if(Status != RETURN_SUCCESS) {
+ break;
+ }
+ Status = Proto->ReadKeyStroke(Proto, &Key);
+ if(Status != RETURN_SUCCESS) {
+ break;
+ }
+ }
+ else {
+ Key.ScanCode = Stream->UnGetKey.ScanCode;
+ Key.UnicodeChar = Stream->UnGetKey.UnicodeChar;
+ Stream->UnGetKey.ScanCode = SCAN_NULL;
+ Stream->UnGetKey.UnicodeChar = CHAR_NULL;
+ }
+ if(Key.ScanCode == SCAN_NULL) {
+ *OutPtr++ = Key.UnicodeChar;
+ ++i;
+ }
+ if(iswcntrl(Key.UnicodeChar)) { // If a control character, or a scan code
+ break;
+ }
+ } while(i < NumChar);
+
+ *OutPtr = L'\0'; // Terminate the input buffer
+ EFIerrno = Status;
+ return (ssize_t)(i * sizeof(CHAR16)); // Will be 0 if we didn't get a key
+}
+
+/* Write a NULL terminated WCS to the EFI console.
+
+ @param[in,out] BufferSize Number of bytes in Buffer. Set to zero if
+ the string couldn't be displayed.
+ @param[in] Buffer The WCS string to be displayed
+
+ @return The number of characters written.
+*/
+static
+ssize_t
+EFIAPI
+da_ConWrite(
+ IN struct __filedes *filp,
+ IN off_t *Position,
+ IN size_t BufferSize,
+ IN const void *Buffer
+ )
+{
+ EFI_STATUS Status;
+ EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
+ ConInstance *Stream;
+ ssize_t NumChar;
+ //XYoffset CursorPos;
+
+ Stream = BASE_CR(filp->f_ops, ConInstance, Abstraction);
+ // Quick check to see if Stream looks reasonable
+ if(Stream->Cookie != CON_COOKIE) { // Cookie == 'IoAb'
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1; // Looks like a bad This pointer
+ }
+ if(Stream->InstanceNum == STDIN_FILENO) {
+ // Write is not valid for stdin
+ EFIerrno = RETURN_UNSUPPORTED;
+ return -1;
+ }
+ // Everything is OK to do the write.
+ Proto = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)Stream->Dev;
+
+ // Convert string from MBCS to WCS and translate \n to \r\n.
+ NumChar = WideTtyCvt(gMD->UString, (const char *)Buffer, BufferSize);
+ //if(NumChar > 0) {
+ // BufferSize = (size_t)(NumChar * sizeof(CHAR16));
+ //}
+ BufferSize = NumChar;
+
+ //if( Position != NULL) {
+ // CursorPos.Offset = (UINT64)*Position;
+
+ // Status = Proto->SetCursorPosition(Proto,
+ // (INTN)CursorPos.XYpos.Column,
+ // (INTN)CursorPos.XYpos.Row);
+ // if(RETURN_ERROR(Status)) {
+ // return -1;
+ // }
+ //}
+
+ // Send the Unicode buffer to the console
+ Status = Proto->OutputString( Proto, gMD->UString);
+ // Depending on status, update BufferSize and return
+ if(RETURN_ERROR(Status)) {
+ BufferSize = 0; // We don't really know how many characters made it out
+ }
+ else {
+ //BufferSize = NumChar;
+ Stream->NumWritten += NumChar;
+ }
+ EFIerrno = Status;
+ return BufferSize;
+}
+
+/** Console-specific helper function for the fstat() function.
+
+ st_size Set to number of characters read for stdin and number written for stdout and stderr.
+ st_physsize 1 for stdin, 0 if QueryMode error, else max X and Y coordinates for the current mode.
+ st_curpos 0 for stdin, current X & Y coordinates for stdout and stderr
+ st_blksize Set to 1 since this is a character device
+
+ All other members of the stat structure are left unchanged.
+**/
+static
+int
+EFIAPI
+da_ConStat(
+ struct __filedes *filp,
+ struct stat *Buffer,
+ void *Something
+ )
+{
+ ConInstance *Stream;
+ EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Proto;
+ XYoffset CursorPos;
+ INT32 OutMode;
+ UINTN ModeCol;
+ UINTN ModeRow;
+
+// ConGetInfo
+ Stream = BASE_CR(filp->f_ops, ConInstance, Abstraction);
+ // Quick check to see if Stream looks reasonable
+ if ((Stream->Cookie != CON_COOKIE) || // Cookie == 'IoAb'
+ (Buffer == NULL))
+ {
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1;
+ }
+ // All of our parameters are correct, so fill in the information.
+ Buffer->st_blksize = 1;
+
+// ConGetPosition
+ if(Stream->InstanceNum == STDIN_FILENO) {
+ // This is stdin
+ Buffer->st_curpos = 0;
+ Buffer->st_size = (off_t)Stream->NumRead;
+ Buffer->st_physsize = 1;
+ }
+ else {
+ Proto = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)Stream->Dev;
+ CursorPos.XYpos.Column = (UINT32)Proto->Mode->CursorColumn;
+ CursorPos.XYpos.Row = (UINT32)Proto->Mode->CursorRow;
+ Buffer->st_curpos = (off_t)CursorPos.Offset;
+ Buffer->st_size = (off_t)Stream->NumWritten;
+
+ OutMode = Proto->Mode->Mode;
+ EFIerrno = Proto->QueryMode(Proto, (UINTN)OutMode, &ModeCol, &ModeRow);
+ if(RETURN_ERROR(EFIerrno)) {
+ Buffer->st_physsize = 0;
+ }
+ else {
+ CursorPos.XYpos.Column = (UINT32)ModeCol;
+ CursorPos.XYpos.Row = (UINT32)ModeRow;
+ Buffer->st_physsize = (off_t)CursorPos.Offset;
+ }
+ }
+ return 0;
+}
+
+static
+int
+EFIAPI
+da_ConIoctl(
+ struct __filedes *filp,
+ ULONGN cmd,
+ void *argp
+ )
+{
+ return -EPERM;
+}
+
+/** Open an abstract Console Device.
+**/
+int
+EFIAPI
+da_ConOpen(
+ struct __filedes *filp,
+ void *DevInstance,
+ wchar_t *Path, // Not used for console devices
+ wchar_t *Flags // Not used for console devices
+ )
+{
+ ConInstance *Stream;
+
+ if((filp == NULL) ||
+ (DevInstance == NULL))
+ {
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1;
+ }
+ Stream = (ConInstance *)DevInstance;
+ // Quick check to see if Stream looks reasonable
+ if(Stream->Cookie != CON_COOKIE) { // Cookie == 'IoAb'
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return -1; // Looks like a bad This pointer
+ }
+ gMD->StdIo[Stream->InstanceNum] = (ConInstance *)DevInstance;
+ filp->f_iflags |= (S_IFREG | _S_IFCHR | _S_ICONSOLE);
+ filp->f_offset = 0;
+ filp->f_ops = &Stream->Abstraction;
+
+ return 0;
+}
+
+#include <sys/poll.h>
+/* Returns a bit mask describing which operations could be completed immediately.
+
+ (POLLIN | POLLRDNORM) A Unicode character is available to read
+ (POLLIN) A ScanCode is ready.
+ (POLLOUT) The device is ready for output - always set on stdout and stderr.
+
+*/
+static
+short
+EFIAPI
+da_ConPoll(
+ struct __filedes *filp,
+ short events
+ )
+{
+ EFI_SIMPLE_TEXT_INPUT_PROTOCOL *Proto;
+ ConInstance *Stream;
+ EFI_STATUS Status = RETURN_SUCCESS;
+ short RdyMask = 0;
+
+ Stream = BASE_CR(filp->f_ops, ConInstance, Abstraction);
+ // Quick check to see if Stream looks reasonable
+ if(Stream->Cookie != CON_COOKIE) { // Cookie == 'IoAb'
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return POLLNVAL; // Looks like a bad filp pointer
+ }
+ if(Stream->InstanceNum == 0) {
+ // Only input is supported for this device
+ Proto = (EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)Stream->Dev;
+ if((Stream->UnGetKey.UnicodeChar == CHAR_NULL) && (Stream->UnGetKey.ScanCode == SCAN_NULL)) {
+ Status = Proto->ReadKeyStroke(Proto, &Stream->UnGetKey);
+ if(Status == RETURN_SUCCESS) {
+ RdyMask = POLLIN;
+ if(Stream->UnGetKey.UnicodeChar != CHAR_NULL) {
+ RdyMask |= POLLRDNORM;
+ }
+ }
+ else {
+ Stream->UnGetKey.ScanCode = SCAN_NULL;
+ Stream->UnGetKey.UnicodeChar = CHAR_NULL;
+ }
+ }
+ }
+ else if(Stream->InstanceNum < NUM_SPECIAL) { // Not 0, is it 1 or 2?
+ // Only output is supported for this device
+ RdyMask = POLLOUT;
+ }
+ else {
+ RdyMask = POLLERR; // Not one of the standard streams
+ }
+ EFIerrno = Status;
+
+ return (RdyMask & (events | POLL_RETONLY));
+}
+
+/** Construct the Console stream devices: stdin, stdout, stderr.
+
+ Allocate the instance structure and populate it with the information for
+ each stream device.
+**/
+RETURN_STATUS
+EFIAPI
+__Cons_construct(
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+)
+{
+ ConInstance *Stream;
+ RETURN_STATUS Status = RETURN_SUCCESS;
+ int i;
+
+ ConInstanceList = (ConInstance *)AllocateZeroPool(NUM_SPECIAL * sizeof(ConInstance));
+ if(ConInstanceList == NULL) {
+ return RETURN_OUT_OF_RESOURCES;
+ }
+
+ for( i = 0; i < NUM_SPECIAL; ++i) {
+ // Get pointer to instance.
+ Stream = &ConInstanceList[i];
+
+ Stream->Cookie = CON_COOKIE;
+ Stream->InstanceNum = i;
+
+ switch(i) {
+ case STDIN_FILENO:
+ Stream->Dev = SystemTable->ConIn;
+ break;
+ case STDOUT_FILENO:
+ Stream->Dev = SystemTable->ConOut;
+ break;
+ case STDERR_FILENO:
+ if(SystemTable->StdErr == NULL) {
+ Stream->Dev = SystemTable->ConOut;
+ }
+ else {
+ Stream->Dev = SystemTable->StdErr;
+ }
+ break;
+ default:
+ return RETURN_VOLUME_CORRUPTED; // This is a "should never happen" case.
+ }
+
+ Stream->Abstraction.fo_close = &da_ConClose;
+ Stream->Abstraction.fo_read = &da_ConRead;
+ Stream->Abstraction.fo_write = &da_ConWrite;
+ Stream->Abstraction.fo_stat = &da_ConStat;
+ Stream->Abstraction.fo_lseek = &da_ConSeek;
+ Stream->Abstraction.fo_fcntl = &fnullop_fcntl;
+ Stream->Abstraction.fo_ioctl = &da_ConIoctl;
+ Stream->Abstraction.fo_poll = &da_ConPoll;
+ Stream->Abstraction.fo_flush = &fnullop_flush;
+ Stream->Abstraction.fo_delete = &fbadop_delete;
+ Stream->Abstraction.fo_mkdir = &fbadop_mkdir;
+ Stream->Abstraction.fo_rmdir = &fbadop_rmdir;
+ Stream->Abstraction.fo_rename = &fbadop_rename;
+
+ Stream->NumRead = 0;
+ Stream->NumWritten = 0;
+ Stream->UnGetKey.ScanCode = SCAN_NULL;
+ Stream->UnGetKey.UnicodeChar = CHAR_NULL;
+
+ if(Stream->Dev == NULL) {
+ continue; // No device for this stream.
+ }
+ ConNode[i] = __DevRegister(stdioNames[i], NULL, &da_ConOpen, Stream, 1, sizeof(ConInstance), stdioFlags[i]);
+ if(ConNode[i] == NULL) {
+ Status = EFIerrno;
+ break;
+ }
+ Stream->Parent = ConNode[i];
+ }
+ return Status;
+}
+
+RETURN_STATUS
+EFIAPI
+__Cons_deconstruct(
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+)
+{
+ int i;
+
+ for(i = 0; i < NUM_SPECIAL; ++i) {
+ if(ConNode[i] != NULL) {
+ FreePool(ConNode[i]);
+ }
+ }
+ if(ConInstanceList != NULL) {
+ FreePool(ConInstanceList);
+ }
+
+ return RETURN_SUCCESS;
+}
+
+/* ######################################################################### */
+#if 0 /* Not implemented for Console */
+
+static
+int
+EFIAPI
+da_ConCntl(
+ struct __filedes *filp,
+ UINT32,
+ void *,
+ void *
+ )
+{
+}
+
+static
+int
+EFIAPI
+da_ConFlush(
+ struct __filedes *filp
+ )
+{
+ return 0;
+}
+#endif /* Not implemented for Console */
diff --git a/StdLib/LibC/Uefi/Devices/UefiShell/daShell.c b/StdLib/LibC/Uefi/Devices/UefiShell/daShell.c new file mode 100644 index 0000000000..37870e8384 --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/UefiShell/daShell.c @@ -0,0 +1,650 @@ +/** @file
+ Abstract device driver for the UEFI Shell-hosted environment.
+
+ In a Shell-hosted environment, this is the driver that is called
+ when no other driver matches.
+
+ Copyright (c) 2011, 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 that accompanies this distribution.
+ The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.
+
+ 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 <Uefi.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/ShellLib.h>
+
+#include <LibConfig.h>
+#include <sys/EfiSysCall.h>
+
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <wctype.h>
+#include <wchar.h>
+#include <sys/fcntl.h>
+#include <kfile.h>
+#include <Device/Device.h>
+#include <MainData.h>
+#include <Efi/SysEfi.h>
+
+static
+int
+EFIAPI
+da_ShellClose(
+ IN struct __filedes *Fp
+)
+{
+ EFIerrno = ShellCloseFile( (SHELL_FILE_HANDLE *)&Fp->devdata);
+ if(RETURN_ERROR(EFIerrno)) {
+ return -1;
+ }
+ return 0;
+}
+
+static
+int
+EFIAPI
+da_ShellDelete(
+ struct __filedes *filp
+ )
+{
+ RETURN_STATUS Status;
+
+ Status = ShellDeleteFile( (SHELL_FILE_HANDLE *)&filp->devdata);
+ if(Status != RETURN_SUCCESS) {
+ errno = EFI2errno(Status);
+ EFIerrno = Status;
+ return -1;
+ }
+ return 0;
+}
+
+static
+off_t
+EFIAPI
+da_ShellSeek(
+ struct __filedes *filp,
+ off_t offset,
+ int whence
+)
+{
+ __off_t CurPos = -1;
+ RETURN_STATUS Status = RETURN_SUCCESS;
+ SHELL_FILE_HANDLE FileHandle;
+
+ FileHandle = (SHELL_FILE_HANDLE)filp->devdata;
+
+ if(whence != SEEK_SET) {
+ // We are doing a relative seek
+ if(whence == SEEK_END) {
+ // seeking relative to EOF, so position there first.
+ Status = ShellSetFilePosition( FileHandle, 0xFFFFFFFFFFFFFFFFULL);
+ }
+ if(Status == RETURN_SUCCESS) {
+ // Now, determine our current position.
+ Status = ShellGetFilePosition( FileHandle, (UINT64 *)&CurPos);
+ }
+ }
+ else {
+ CurPos = 0; // offset is an absolute position for SEEK_SET
+ if(offset < 0) {
+ Status = RETURN_INVALID_PARAMETER;
+ }
+ }
+ if(Status == RETURN_SUCCESS) {
+ /* CurPos now indicates the point we are seeking from, so seek... */
+ Status = ShellSetFilePosition( FileHandle, (UINT64)(CurPos + offset));
+ if(Status == RETURN_SUCCESS) {
+ // Now, determine our final position.
+ Status = ShellGetFilePosition( FileHandle, (UINT64 *)&CurPos);
+ }
+ }
+ if(Status != RETURN_SUCCESS) {
+ if(Status == EFI_UNSUPPORTED) {
+ errno = EISDIR;
+ }
+ else {
+ errno = EFI2errno(Status);
+ }
+ EFIerrno = Status;
+ CurPos = EOF;
+ }
+ return CurPos;
+}
+
+/** The directory path is created with the access permissions specified by
+ perms.
+
+ The directory is closed after it is created.
+
+ @retval 0 The directory was created successfully.
+ @retval -1 An error occurred and an error code is stored in errno.
+**/
+static
+int
+EFIAPI
+da_ShellMkdir(
+ const char *path,
+ __mode_t perms
+ )
+{
+ SHELL_FILE_HANDLE FileHandle;
+ RETURN_STATUS Status;
+ EFI_FILE_INFO *FileInfo;
+ wchar_t *NewPath;
+ int retval = -1;
+
+ // Convert name from MBCS to WCS and change '/' to '\\'
+ NewPath = NormalizePath( path);
+
+ if(NewPath != NULL) {
+ Status = ShellCreateDirectory( NewPath, &FileHandle);
+ if(Status == RETURN_SUCCESS) {
+ FileInfo = ShellGetFileInfo( FileHandle);
+ Status = RETURN_ABORTED; // In case ShellGetFileInfo() failed
+ if(FileInfo != NULL) {
+ FileInfo->Attribute = Omode2EFI(perms);
+ Status = ShellSetFileInfo( FileHandle, FileInfo);
+ FreePool(FileInfo);
+ if(Status == RETURN_SUCCESS) {
+ (void)ShellCloseFile(&FileHandle);
+ retval = 0;
+ }
+ }
+ }
+ errno = EFI2errno(Status);
+ EFIerrno = Status;
+ free(NewPath);
+ }
+ return retval;
+}
+
+static
+ssize_t
+EFIAPI
+da_ShellRead(
+ IN OUT struct __filedes *filp,
+ IN OUT off_t *offset,
+ IN size_t BufferSize,
+ OUT VOID *Buffer
+)
+{
+ ssize_t BufSize;
+ SHELL_FILE_HANDLE FileHandle;
+ RETURN_STATUS Status;
+
+ if(offset != NULL) {
+ BufSize = (ssize_t)da_ShellSeek(filp, *offset, SEEK_SET);
+ if(BufSize >= 0) {
+ filp->f_offset = BufSize;
+ }
+ }
+
+ BufSize = (ssize_t)BufferSize;
+ FileHandle = (SHELL_FILE_HANDLE)filp->devdata;
+
+ Status = ShellReadFile( FileHandle, (UINTN *)&BufSize, Buffer);
+ if(Status != RETURN_SUCCESS) {
+ EFIerrno = Status;
+ errno = EFI2errno(Status);
+ if(Status == RETURN_BUFFER_TOO_SMALL) {
+ BufSize = -BufSize;
+ }
+ else {
+ BufSize = -1;
+ }
+ }
+ else {
+ filp->f_offset += BufSize; // Advance to where we want to read next.
+ }
+ return BufSize;
+}
+
+static
+ssize_t
+EFIAPI
+da_ShellWrite(
+ IN struct __filedes *filp,
+ IN off_t *offset,
+ IN size_t BufferSize,
+ IN const void *Buffer
+ )
+{
+ ssize_t BufSize;
+ SHELL_FILE_HANDLE FileHandle;
+ RETURN_STATUS Status;
+ off_t Position = 0;
+ int How = SEEK_SET;
+
+
+ if((offset != NULL) || (filp->Oflags & O_APPEND)) {
+ if(filp->Oflags & O_APPEND) {
+ Position = 0;
+ How = SEEK_END;
+ }
+ else {
+ Position = *offset;
+ How = SEEK_SET;
+ }
+ BufSize = (ssize_t)da_ShellSeek(filp, Position, How);
+ if(BufSize >= 0) {
+ filp->f_offset = BufSize;
+ }
+ }
+
+ BufSize = (ssize_t)BufferSize;
+ FileHandle = (SHELL_FILE_HANDLE)filp->devdata;
+
+ Status = ShellWriteFile( FileHandle, (UINTN *)&BufSize, (void *)Buffer);
+
+ if(Status != RETURN_SUCCESS) {
+ EFIerrno = Status;
+ errno = EFI2errno(Status);
+ if(Status == EFI_UNSUPPORTED) {
+ errno = EISDIR;
+ }
+ BufSize = -1;
+ }
+ else {
+ filp->f_offset += BufSize; // Advance to where we want to write next.
+ }
+
+ return BufSize;
+}
+
+static
+int
+EFIAPI
+da_ShellStat(
+ struct __filedes *filp,
+ struct stat *statbuf,
+ void *Something
+ )
+{
+ SHELL_FILE_HANDLE FileHandle;
+ EFI_FILE_INFO *FileInfo = NULL;
+ UINT64 Attributes;
+ RETURN_STATUS Status;
+ mode_t newmode;
+
+ FileHandle = (SHELL_FILE_HANDLE)filp->devdata;
+
+ FileInfo = ShellGetFileInfo( FileHandle);
+
+ if(FileInfo != NULL) {
+ // Got the info, now populate statbuf with it
+ statbuf->st_blksize = S_BLKSIZE;
+ statbuf->st_size = FileInfo->FileSize;
+ statbuf->st_physsize = FileInfo->PhysicalSize;
+ statbuf->st_birthtime = Efi2Time( &FileInfo->CreateTime);
+ statbuf->st_atime = Efi2Time( &FileInfo->LastAccessTime);
+ statbuf->st_mtime = Efi2Time( &FileInfo->ModificationTime);
+ Attributes = FileInfo->Attribute;
+ newmode = (mode_t)(Attributes << S_EFISHIFT) | S_ACC_READ;
+ if((Attributes & EFI_FILE_DIRECTORY) == 0) {
+ newmode |= _S_IFREG;
+ if((Attributes & EFI_FILE_READ_ONLY) == 0) {
+ newmode |= S_ACC_WRITE;
+ }
+ }
+ else {
+ newmode |= _S_IFDIR;
+ }
+ statbuf->st_mode = newmode;
+ Status = RETURN_SUCCESS;
+ }
+ else {
+ Status = RETURN_DEVICE_ERROR;
+ }
+ errno = EFI2errno(Status);
+ EFIerrno = Status;
+
+ if(FileInfo != NULL) {
+ FreePool(FileInfo); // Release the buffer allocated by the GetInfo function
+ }
+ return errno? -1 : 0;
+}
+
+static
+int
+EFIAPI
+da_ShellIoctl(
+ struct __filedes *filp,
+ ULONGN cmd,
+ void *argp ///< May be a pointer or a value
+ )
+{
+ return 0;
+}
+
+/** Open an abstract Shell File.
+**/
+int
+EFIAPI
+da_ShellOpen(
+ struct __filedes *filp,
+ void *DevInstance,
+ wchar_t *Path,
+ wchar_t *Flags
+ )
+{
+ UINT64 OpenMode;
+ UINT64 Attributes;
+ SHELL_FILE_HANDLE FileHandle;
+ GenericInstance *Gip;
+ char *NPath;
+ RETURN_STATUS Status;
+ int oflags;
+
+ EFIerrno = RETURN_SUCCESS;
+
+ //Attributes = Omode2EFI(mode);
+ Attributes = 0;
+
+ // Convert oflags to Attributes
+ oflags = filp->Oflags;
+ OpenMode = Oflags2EFI(oflags);
+ if(OpenMode == 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* Do we care if the file already exists?
+ If O_TRUNC, then delete the file. It will be created anew subsequently.
+ If O_EXCL, then error if the file exists and O_CREAT is set.
+
+ !!!!!!!!! Change this to use ShellSetFileInfo() to actually truncate the file
+ !!!!!!!!! instead of deleting and re-creating it.
+ */
+ if((oflags & O_TRUNC) || ((oflags & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT))) {
+ Status = ShellIsFile( Path );
+ if(Status == RETURN_SUCCESS) {
+ // The file exists
+ if(oflags & O_TRUNC) {
+ NPath = AllocateZeroPool(1024);
+ if(NPath == NULL) {
+ errno = ENOMEM;
+ EFIerrno = RETURN_OUT_OF_RESOURCES;
+ return -1;
+ }
+ wcstombs(NPath, Path, 1024);
+ // We do a truncate by deleting the existing file and creating a new one.
+ if(unlink(NPath) != 0) {
+ filp->f_iflags = 0; // Release our reservation on this FD
+ FreePool(NPath);
+ return -1; // errno and EFIerrno are already set.
+ }
+ FreePool(NPath);
+ }
+ else if((oflags & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT)) {
+ errno = EEXIST;
+ EFIerrno = RETURN_ACCESS_DENIED;
+ filp->f_iflags = 0; // Release our reservation on this FD
+ return -1;
+ }
+ }
+ }
+
+ // Call the EFI Shell's Open function
+ Status = ShellOpenFileByName( Path, &FileHandle, OpenMode, Attributes);
+ if(RETURN_ERROR(Status)) {
+ filp->f_iflags = 0; // Release our reservation on this FD
+ // Set errno based upon Status
+ errno = EFI2errno(Status);
+ EFIerrno = Status;
+ return -1;
+ }
+ // Successfully got a regular File
+ filp->f_iflags |= S_IFREG;
+
+ // Update the info in the fd
+ filp->devdata = (void *)FileHandle;
+
+ Gip = (GenericInstance *)DevInstance;
+ filp->f_offset = 0;
+ filp->f_ops = &Gip->Abstraction;
+// filp->devdata = FileHandle;
+
+ return 0;
+}
+
+#include <sys/poll.h>
+/* Returns a bit mask describing which operations could be completed immediately.
+
+ For now, assume the file system, via the shell, is always ready.
+
+ (POLLIN | POLLRDNORM) The file system is ready to be read.
+ (POLLOUT) The file system is ready for output.
+
+*/
+static
+short
+EFIAPI
+da_ShellPoll(
+ struct __filedes *filp,
+ short events
+ )
+{
+ UINT32 RdyMask;
+ short retval = 0;
+
+ RdyMask = (UINT32)filp->Oflags;
+
+ switch(RdyMask & O_ACCMODE) {
+ case O_RDONLY:
+ retval = (POLLIN | POLLRDNORM);
+ break;
+
+ case O_WRONLY:
+ retval = POLLOUT;
+ break;
+
+ case O_RDWR:
+ retval = (POLLIN | POLLRDNORM | POLLOUT);
+ break;
+
+ default:
+ retval = POLLERR;
+ break;
+ }
+ return (retval & (events | POLL_RETONLY));
+}
+
+static
+int
+EFIAPI
+da_ShellRename(
+ const char *from,
+ const char *to
+ )
+{
+ RETURN_STATUS Status;
+ EFI_FILE_INFO *NewFileInfo;
+ EFI_FILE_INFO *OldFileInfo;
+ char *NewFn;
+ int OldFd;
+ SHELL_FILE_HANDLE FileHandle;
+
+ // Open old file
+ OldFd = open(from, O_RDWR, 0);
+ if(OldFd >= 0) {
+ FileHandle = (SHELL_FILE_HANDLE)gMD->fdarray[OldFd].devdata;
+
+ NewFileInfo = malloc(sizeof(EFI_FILE_INFO) + PATH_MAX);
+ if(NewFileInfo != NULL) {
+ OldFileInfo = ShellGetFileInfo( FileHandle);
+ if(OldFileInfo != NULL) {
+ // Copy the Old file info into our new buffer, and free the old.
+ memcpy(OldFileInfo, NewFileInfo, sizeof(EFI_FILE_INFO));
+ FreePool(OldFileInfo);
+ // Strip off all but the file name portion of new
+ NewFn = strrchr(to, '/');
+ if(NewFn == NULL) {
+ NewFn = strrchr(to, '\\');
+ if(NewFn == NULL) {
+ NewFn = (char *)to;
+ }
+ }
+ // Convert new name from MBCS to WCS
+ (void)AsciiStrToUnicodeStr( NewFn, gMD->UString);
+ // Copy the new file name into our new file info buffer
+ wcsncpy(NewFileInfo->FileName, gMD->UString, wcslen(gMD->UString)+1);
+ // Apply the new file name
+ Status = ShellSetFileInfo(FileHandle, NewFileInfo);
+ free(NewFileInfo);
+ if(Status == EFI_SUCCESS) {
+ // File has been successfully renamed. We are DONE!
+ return 0;
+ }
+ errno = EFI2errno( Status );
+ EFIerrno = Status;
+ }
+ else {
+ errno = EIO;
+ }
+ }
+ else {
+ errno = ENOMEM;
+ }
+ }
+ return -1;
+}
+
+static
+int
+EFIAPI
+da_ShellRmdir(
+ struct __filedes *filp
+ )
+{
+ SHELL_FILE_HANDLE FileHandle;
+ RETURN_STATUS Status = RETURN_SUCCESS;
+ EFI_FILE_INFO *FileInfo = NULL;
+ int Count = 0;
+ BOOLEAN NoFile = FALSE;
+
+ errno = 0; // Make it easier to see if we have an error later
+
+ FileHandle = (SHELL_FILE_HANDLE)filp->devdata;
+
+ FileInfo = ShellGetFileInfo(FileHandle);
+ if(FileInfo != NULL) {
+ if((FileInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
+ errno = ENOTDIR;
+ }
+ else {
+ // See if the directory has any entries other than ".." and ".".
+ FreePool(FileInfo); // Free up the buffer from ShellGetFileInfo()
+ Status = ShellFindFirstFile( FileHandle, &FileInfo);
+ if(Status == RETURN_SUCCESS) {
+ ++Count;
+ while(Count < 3) {
+ Status = ShellFindNextFile( FileHandle, FileInfo, &NoFile);
+ if(Status == RETURN_SUCCESS) {
+ if(NoFile) {
+ break;
+ }
+ ++Count;
+ }
+ else {
+ Count = 99;
+ }
+ }
+ FreePool(FileInfo); // Free buffer from ShellFindFirstFile()
+ if(Count < 3) {
+ // Directory is empty
+ Status = ShellDeleteFile( &FileHandle);
+ if(Status == RETURN_SUCCESS) {
+ EFIerrno = RETURN_SUCCESS;
+ return 0;
+ /* ######## SUCCESSFUL RETURN ######## */
+ }
+ }
+ else {
+ if(Count == 99) {
+ errno = EIO;
+ }
+ else {
+ errno = ENOTEMPTY;
+ }
+ }
+ }
+ }
+ }
+ else {
+ errno = EIO;
+ }
+ EFIerrno = Status;
+ if(errno == 0) {
+ errno = EFI2errno( Status );
+ }
+ return -1;
+}
+
+/** Construct an instance of the abstract Shell device.
+
+ Allocate the instance structure and populate it with the information for
+ the device.
+**/
+RETURN_STATUS
+EFIAPI
+__ctor_DevShell(
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+)
+{
+ GenericInstance *Stream;
+ DeviceNode *Node;
+ RETURN_STATUS Status;
+
+ Stream = (GenericInstance *)AllocateZeroPool(sizeof(GenericInstance));
+ if(Stream == NULL) {
+ return RETURN_OUT_OF_RESOURCES;
+ }
+
+ Stream->Cookie = CON_COOKIE;
+ Stream->InstanceNum = 1;
+ Stream->Dev = NULL;
+ Stream->Abstraction.fo_close = &da_ShellClose;
+ Stream->Abstraction.fo_read = &da_ShellRead;
+ Stream->Abstraction.fo_write = &da_ShellWrite;
+ Stream->Abstraction.fo_fcntl = &fnullop_fcntl;
+ Stream->Abstraction.fo_poll = &da_ShellPoll;
+ Stream->Abstraction.fo_flush = &fnullop_flush;
+ Stream->Abstraction.fo_stat = &da_ShellStat;
+ Stream->Abstraction.fo_ioctl = &fbadop_ioctl;
+ Stream->Abstraction.fo_delete = &da_ShellDelete;
+ Stream->Abstraction.fo_rmdir = &da_ShellRmdir;
+ Stream->Abstraction.fo_mkdir = &da_ShellMkdir;
+ Stream->Abstraction.fo_rename = &da_ShellRename;
+ Stream->Abstraction.fo_lseek = &da_ShellSeek;
+
+ Node = __DevRegister(NULL, NULL, &da_ShellOpen, Stream, 1, sizeof(GenericInstance), O_RDWR);
+ Status = EFIerrno;
+ Stream->Parent = Node;
+
+ return Status;
+}
+
+RETURN_STATUS
+EFIAPI
+__dtor_DevShell(
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+)
+{
+ if(daDefaultDevice != NULL) {
+ if(daDefaultDevice->InstanceList != NULL) {
+ FreePool(daDefaultDevice->InstanceList);
+ }
+ FreePool(daDefaultDevice);
+ }
+ return RETURN_SUCCESS;
+}
diff --git a/StdLib/LibC/Uefi/Devices/Utility/DevGenisis.c b/StdLib/LibC/Uefi/Devices/Utility/DevGenisis.c new file mode 100644 index 0000000000..2bdb33ac53 --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/Utility/DevGenisis.c @@ -0,0 +1,139 @@ +/** @file
+ Device Abstraction: device creation utility functions.
+
+ Copyright (c) 2011, 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 that 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 <Uefi.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+
+#include <LibConfig.h>
+
+#include <errno.h>
+#include <sys/poll.h>
+#include <kfile.h>
+#include <Device/Device.h>
+#include <MainData.h>
+
+LIST_ENTRY daDeviceList = INITIALIZE_LIST_HEAD_VARIABLE(daDeviceList);
+DeviceNode *daDefaultDevice = NULL; ///< Device to use if nothing else found
+DeviceNode *daRootDevice = NULL; ///< Device containing the root file system
+DeviceNode *daCurrentDevice = NULL; ///< Device currently being accessed
+
+/* Commonly used fileops
+ fnullop_* Does nothing and returns success.
+ fbadop_* Does nothing and returns EPERM
+*/
+int fnullop_fcntl (struct __filedes *filp, UINT32 Cmd, void *p3, void *p4)
+{ return 0; }
+
+short fnullop_poll (struct __filedes *filp, short Events)
+{
+ return ((POLLIN | POLLRDNORM | POLLOUT) & Events);
+}
+
+int fnullop_flush (struct __filedes *filp)
+{ return 0; }
+
+int fbadop_stat (struct __filedes *filp, struct stat *StatBuf, void *Buf)
+{ return -EPERM; }
+
+int fbadop_ioctl (struct __filedes *filp, ULONGN Cmd, void *argp)
+{ return -EPERM; }
+
+int fbadop_delete (struct __filedes *filp)
+{ return -EPERM; }
+
+int fbadop_mkdir (const char *path, __mode_t perms)
+{ return -EPERM; }
+
+int fbadop_rename (const char *from, const char *to)
+{ return -EPERM; }
+
+int fbadop_rmdir (struct __filedes *filp)
+{ return -EPERM; }
+
+/** Add a new device to the device list.
+ If both DevName and DevProto are NULL, register this as the Default device.
+
+ @param DevName Name of the device to add.
+ @param DevProto Pointer to the GUID identifying the protocol associated with this device.
+ If DevProto is NULL, startup code will not try to find instances
+ of this device.
+ @param OpenFunc Pointer to the device's Open function.
+ @param InstanceList Optional pointer to the device's initialized instance list.
+ If InstanceList is NULL, the application startup code will
+ scan for instances of the protocol identified by DevProto and
+ populate the InstanceList in the order those protocols are found.
+ @param NumInstance Number of instances in InstanceList.
+ @param Modes Bit-mapped flags indicating operations (R, W, RW, ...) permitted to this device.
+
+**/
+DeviceNode *
+EFIAPI
+__DevRegister(
+ IN const CHAR16 *DevName,
+ IN GUID *DevProto,
+ IN FO_OPEN OpenFunc,
+ IN void *InstanceList,
+ IN int NumInstance,
+ IN UINT32 InstanceSize,
+ IN UINT32 Modes
+ )
+{
+ DeviceNode *Node;
+ GenericInstance *GIp;
+ char *GenPtr;
+ int i;
+
+ /* Validate parameters */
+ if(((DevName == NULL) && (DevProto != NULL)) ||
+ (OpenFunc == NULL)) {
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return NULL;
+ }
+ Node = (DeviceNode *)AllocateZeroPool(sizeof(DeviceNode));
+ if(Node == NULL) {
+ EFIerrno = RETURN_OUT_OF_RESOURCES;
+ return NULL;
+ }
+
+ Node->DevName = DevName;
+ Node->DevProto = DevProto;
+ Node->InstanceList = InstanceList;
+ Node->OpenFunc = OpenFunc;
+ Node->InstanceSize = InstanceSize;
+ Node->NumInstances = NumInstance;
+ Node->OpModes = Modes;
+
+ /* Update the Parent member of each element of the InstanceList */
+ if(InstanceList != NULL) {
+ GenPtr = InstanceList;
+
+ for(i = 0; i < NumInstance; ++i) { // Iterate through each element of InstanceList
+ GIp = (GenericInstance *)GenPtr;
+ GIp->Parent = Node; // Initializing the Parent member & InstanceNum
+ //GIp->InstanceNum = i;
+ GenPtr += InstanceSize;
+ }
+ }
+ if(DevName == NULL) {
+ if(daDefaultDevice != NULL) {
+ EFIerrno = RETURN_INVALID_PARAMETER;
+ return NULL;
+ }
+ daDefaultDevice = Node;
+ }
+ else {
+ (void) InsertTailList(&daDeviceList, &Node->DevList);
+ }
+ EFIerrno = RETURN_SUCCESS;
+ return Node;
+}
diff --git a/StdLib/LibC/Uefi/Devices/Utility/DevSearch.c b/StdLib/LibC/Uefi/Devices/Utility/DevSearch.c new file mode 100644 index 0000000000..b0fc7bacd1 --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/Utility/DevSearch.c @@ -0,0 +1,112 @@ +/** @file
+ Device Abstraction: Search device list for a matching device.
+
+ Copyright (c) 2011, 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 that 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 <Uefi.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+
+#include <LibConfig.h>
+
+#include <errno.h>
+#include <kfile.h>
+#include <Device/Device.h>
+#include <MainData.h>
+
+/** Find a DeviceNode matching DevName or DevProto, or both.
+
+ If DevName is NULL, then the device name is not used in the search.
+ If DevProto is NULL, then the protocol GUID is not used in the search.
+ If both are NULL, then INVALID_PARAMETER is returned.
+ If both DevName and DevProto are specified, then both must match.
+ If both are specified but only one matches, then DEVICE_ERROR is returned.
+
+ @param DevName Name of the Device Abstraction to find.
+ @param DevProto GUID of the Protocol associated with the Device Abstraction.
+ @param Node Pointer to the pointer to receive the found Device Node's address.
+
+ @retval RETURN_SUCCESS The desired Device Node was found.
+ @retval RETURN_INVALID_PARAMETER Both DevName and DevProto are NULL or Node is NULL.
+ @retval RETURN_DEVICE_ERROR DevName matched but DevProto did not.
+ @retval RETURN_NOT_FOUND The desired device was not found.
+**/
+EFI_STATUS
+EFIAPI
+__DevSearch(
+ IN CHAR16 *DevName,
+ IN GUID *DevProto,
+ OUT DeviceNode **Node
+ )
+{
+ RETURN_STATUS Status = RETURN_NOT_FOUND;
+ DeviceNode *WorkNode;
+ INT32 DevMatched;
+
+ if(((DevName == NULL) && (DevProto == NULL)) || (Node == NULL)) {
+ Status = RETURN_INVALID_PARAMETER;
+ }
+ else {
+ if(IsListEmpty((LIST_ENTRY *)&daDeviceList)) {
+ Status = RETURN_NOT_FOUND;
+ }
+ else {
+ /* Traverse the list of Device Nodes hunting for a match */
+ WorkNode = (DeviceNode *)GetFirstNode((LIST_ENTRY *)&daDeviceList);
+ do {
+ /* Use DevMatched to keep track of the three match conditions. */
+ DevMatched = 0;
+ if(DevName != NULL) {
+ ++DevMatched;
+ if(wcsncmp(DevName, WorkNode->DevName, wcslen(WorkNode->DevName)) == 0) {
+ ++DevMatched;
+ }
+ }
+ /* At this point, DevMatched has one of the following values:
+ 0 DevName == NULL, no name comparison
+ 1 DevName did not match WorkNode's name
+ 2 DevName MATCHED
+ */
+ if((DevMatched != 1) && (DevProto != NULL) && (WorkNode->DevProto != NULL)) {
+ /* Only bother with the GUID comparison if:
+ * There was NOT a name mismatch
+ * DevProto is NOT NULL -- there is a GUID to compare
+ * WorkNode->DevProto is NOT NULL
+ */
+ if(CompareGuid(DevProto, WorkNode->DevProto)) {
+ // GUIDs matched, we found it
+ Status = RETURN_SUCCESS;
+ *Node = WorkNode;
+ break;
+ }
+ else {
+ // GUIDs did not match
+ if(DevMatched == 2) {
+ // Name matched, GUID did not!
+ Status = RETURN_DEVICE_ERROR;
+ break; // Don't try any more, we have an internal problem
+ }
+ }
+ }
+ else {
+ if(DevMatched == 2) {
+ // Device Name matched, GUIDs skipped
+ Status = RETURN_SUCCESS;
+ *Node = WorkNode;
+ break;
+ }
+ }
+ // Check the next device in the list
+ WorkNode = (DeviceNode *)GetNextNode(&daDeviceList, (LIST_ENTRY *)WorkNode);
+ } while(&daDeviceList != (LIST_ENTRY *)WorkNode);
+ }
+ }
+ return Status;
+}
diff --git a/StdLib/LibC/Uefi/Devices/Utility/Path.c b/StdLib/LibC/Uefi/Devices/Utility/Path.c new file mode 100644 index 0000000000..92bb1a20b7 --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/Utility/Path.c @@ -0,0 +1,382 @@ +/** @file
+ Device Abstraction: Path manipulation utilities.
+
+ Copyright (c) 2011, 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 that 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 <Library/BaseLib.h>
+
+#include <LibConfig.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <wctype.h>
+#include <kfile.h>
+#include <Device/Device.h>
+#include <MainData.h>
+
+/** Identify the type of path pointed to by Path.
+
+ Paths are classified based upon their initial character sequences.
+ ^\\ Absolute Path
+ ^\. Relative Path
+ ^[^:\\]: Mapping Path
+ .* Relative Path
+
+ Mapping paths are broken into two parts at the ':'. The part to the left of the ':'
+ is the Map Name, pointed to by Path, and the part to the right of the ':' is pointed
+ to by NewPath.
+
+ If Path was not a Mapping Path, then NewPath is set to Path.
+
+ @param[in] Path Pointer to the path to be classified.
+ @param[out] NewPath Pointer to the path portion of a mapping path.
+ @param[out] Length Length of the Map Name portion of the path.
+
+ @retval PathAbsolute Path is an absolute path. NewPath points to the first '\'.
+ @retval PathRelative Path is a relative path. NewPath = Path.
+ @retval PathMapping Path is a mapping path. NewPath points to the character following ':'.
+ @retval PathError Path is NULL.
+**/
+PATH_CLASS
+EFIAPI
+ClassifyPath(
+ IN wchar_t * Path,
+ OUT wchar_t ** NewPath,
+ OUT int * const Length
+ )
+{
+ size_t MapLen;
+
+ if(Path == NULL) {
+ return PathError; // Bad parameter
+ }
+ if(NewPath != NULL) {
+ *NewPath = Path; // Setup default condition
+ }
+ if((*Path == L'\\') || (*Path == L'\0')) {
+ return PathAbsolute;
+ }
+ if(*Path == L'.') {
+ return PathRelative;
+ }
+ /* The easy stuff has been done, now see if this is a mapping path.
+ See if there is a ':' in Path that isn't the first character and is before
+ any '\\' characters.
+ */
+ MapLen = wcscspn(Path, L"\\:");
+ if(Length != NULL) {
+ *Length = (int)MapLen;
+ }
+ /* MapLen == 0 means that the first character is a ':'
+ == PathLen means that there are no '\\' or ':'
+ Otherwise, Path[MapLen] == ':' for a mapping path
+ or '\\' for a relative path.
+ */
+ if(MapLen == 0) {
+ return PathError;
+ }
+ if(Path[MapLen] == L':') {
+ if(NewPath != NULL) {
+ *NewPath = &Path[MapLen + 1]; // Point to character after then ':'. Might be '\0'.
+ }
+ return PathMapping;
+ }
+ return PathRelative;
+}
+
+/* Normalize a narrow-character path and produce a wide-character path
+ that has forward slashes replaced with backslashes.
+ Backslashes are directory separators in UEFI File Paths.
+
+ It is the caller's responsibility to eventually free() the returned buffer.
+
+ @param[in] path A pointer to the narrow-character path to be normalized.
+
+ @return A pointer to a buffer containing the normalized, wide-character, path.
+*/
+wchar_t *
+NormalizePath( const char *path)
+{
+ wchar_t *temp;
+ wchar_t *OldPath;
+ wchar_t *NewPath;
+ size_t Length;
+
+ OldPath = AsciiStrToUnicodeStr(path, gMD->UString);
+ Length = wcslen(OldPath) + 1;
+
+ NewPath = calloc(Length, sizeof(wchar_t));
+ if(NewPath != NULL) {
+ temp = NewPath;
+ for( ; *OldPath; ++OldPath) {
+ if(*OldPath == L'/') {
+ *temp = L'\\';
+ }
+ else {
+ *temp = *OldPath;
+ }
+ ++temp;
+ }
+ }
+ else {
+ errno = ENOMEM;
+ EFIerrno = RETURN_OUT_OF_RESOURCES;
+ }
+ return NewPath;
+}
+
+/** Process a wide character string representing a Mapping Path and extract the instance number.
+
+ The instance number is the sequence of decimal digits immediately to the left
+ of the ":" in the Map Name portion of a Mapping Path.
+
+ This function is called with a pointer to beginning of the Map Name.
+ Thus Path[Length] must be a ':' and Path[Length - 1] must be a decimal digit.
+ If either of these are not true, an instance value of 0 is returned.
+
+ If Path is NULL, an instance value of 0 is returned.
+
+ @param[in] Path Points to the beginning of a Mapping Path
+ @param[in] Length Number of valid characters to the left of the ':'
+
+ @return Returns either 0 or the value of the contiguous digits to the left of the ':'.
+**/
+int
+EFIAPI
+PathInstance(
+ const wchar_t *Path,
+ int Length
+ )
+{
+ wchar_t *temp;
+ int instance = 0;
+
+ if((Path != NULL) && (Path[Length] == L':') && (Length > 0)) {
+ for(temp = __UNCONST(&Path[Length - 1]); Length > 0; --Length) {
+ if(!iswdigit(*temp)) {
+ break;
+ }
+ --temp;
+ }
+ instance = (int)wcstol(temp+1, NULL, 10);
+ }
+ return instance;
+}
+
+/** Transform a relative path into an absolute path.
+
+ If Path is NULL, return NULL.
+ Otherwise, pre-pend the CWD to Path then process the resulting path to:
+ - Replace "/./" with "/"
+ - Replace "/<dirname>/../" with "/"
+ - Do not allow one to back up past the root, "/"
+
+ Also sets the Current Working Device to the Root Device.
+
+ Path must be a previously allocated buffer. PathAdjust will
+ allocate a new buffer to hold the results of the transformation
+ and free Path. A pointer to the newly allocated buffer is returned.
+
+ @param[in] Path A pointer to the path to be transformed. This buffer
+ will always be freed.
+
+ @return A pointer to a buffer containing the transformed path.
+**/
+wchar_t *
+EFIAPI
+PathAdjust(
+ wchar_t *Path
+ )
+{
+ wchar_t *NewPath;
+
+ NewPath = calloc(PATH_MAX, sizeof(wchar_t));
+ if(NewPath != NULL) {
+ wmemcpy(NewPath, Path, PATH_MAX);
+ }
+ else {
+ errno = ENOMEM;
+ }
+ free(Path);
+ return NewPath;
+}
+
+/** Replace the leading portion of Path with any aliases.
+
+ Aliases are read from /etc/fstab. If there is an associated device, the
+ Current Working Device is set to that device.
+
+ Path must be a previously allocated buffer. PathAlias will
+ allocate a new buffer to hold the results of the transformation
+ then free Path. A pointer to the newly allocated buffer is returned.
+
+ @param[in] Path A pointer to the original, unaliased, path. This
+ buffer is always freed.
+ @param[out] Node Filled in with a pointer to the Device Node describing
+ the device abstraction associated with this path.
+
+ @return A pointer to a buffer containing the aliased path.
+**/
+wchar_t *
+EFIAPI
+PathAlias(
+ wchar_t *Path,
+ DeviceNode **Node
+ )
+{
+ wchar_t *NewPath;
+
+ NewPath = calloc(PATH_MAX, sizeof(wchar_t));
+ if(NewPath != NULL) {
+ wmemcpy(NewPath, Path, PATH_MAX);
+ }
+ else {
+ errno = ENOMEM;
+ }
+ free(Path);
+ *Node = NULL;
+ return NewPath;
+}
+
+/** Parse a path producing the target device, device instance, and file path.
+
+ @param[in] path
+ @param[out] FullPath
+ @param[out] DevNode
+ @param[out] Which
+
+ @retval RETURN_SUCCESS The path was parsed successfully.
+ @retval RETURN_NOT_FOUND The path does not map to a valid device.
+ @retval RETURN_OUT_OF_RESOURCES Insufficient memory to calloc a MapName buffer.
+ The errno variable is set to ENOMEM.
+ @retval RETURN_INVALID_PARAMETER The path parameter is not valid.
+ The errno variable is set to EINVAL.
+**/
+RETURN_STATUS
+EFIAPI
+ParsePath(
+ IN const char *path,
+ OUT wchar_t **FullPath,
+ OUT DeviceNode **DevNode,
+ OUT int *Which
+ )
+{
+ int MapLen;
+ PATH_CLASS PathClass;
+ wchar_t *NewPath;
+ wchar_t *WPath = NULL;
+ wchar_t *MPath = NULL;
+ DeviceNode *Node = NULL;
+ RETURN_STATUS Status = RETURN_NOT_FOUND;
+ int Instance = 0;
+ BOOLEAN ReMapped;
+
+ ReMapped = FALSE;
+
+ // Convert name from MBCS to WCS and change '/' to '\\'
+ WPath = NormalizePath( path);
+ PathClass = ClassifyPath(WPath, &NewPath, &MapLen);
+
+reclassify:
+ switch(PathClass) {
+ case PathMapping:
+ if(!ReMapped) {
+ if((NewPath == NULL) || (*NewPath == L'\0')) { /* Nothing after the ':' */
+ PathClass = PathAbsolute;
+ }
+ else {
+ Instance = PathInstance(WPath, MapLen);
+ PathClass = ClassifyPath(NewPath, NULL, NULL);
+ }
+ ReMapped = TRUE;
+ if(WPath[MapLen] == L':') {
+ // Get the Map Name, including the trailing ':'. */
+ MPath = calloc(MapLen+2, sizeof(wchar_t));
+ if(MPath != NULL) {
+ wmemcpy(MPath, WPath, MapLen+2);
+ }
+ else {
+ errno = ENOMEM;
+ Status = RETURN_OUT_OF_RESOURCES;
+ break; // Exit the switch(PathClass) statement.
+ }
+ }
+ if(WPath != NewPath) {
+ /* Shift the RHS of the path down to the start of the buffer. */
+ wmemmove(WPath, NewPath, wcslen(NewPath)+1);
+ NewPath = WPath;
+ }
+ goto reclassify;
+ }
+ /* Fall through to PathError if Remapped.
+ This means that the path looked like "foo:bar:something".
+ */
+
+ case PathError:
+ errno = EINVAL;
+ Status = RETURN_INVALID_PARAMETER;
+ break;
+
+ case PathRelative:
+ /* Transform a relative path into an Absolute path.
+ Prepends CWD and handles ./ and ../ entries.
+ It is the caller's responsibility to free the space
+ allocated to WPath.
+ */
+ WPath = PathAdjust(NewPath); // WPath was malloc()ed by PathAdjust
+
+ case PathAbsolute:
+ /* Perform any path aliasing. For example: /dev/foo -> { node.foo, "" }
+ The current volume and directory are updated in the path as needed.
+ It is the caller's responsibility to free the space
+ allocated to WPath.
+ */
+ Status = RETURN_SUCCESS;
+ WPath = PathAlias(WPath, &Node); // PathAlias frees its argument and malloc()s a new one.
+ break;
+ }
+ if(!RETURN_ERROR(Status)) {
+ *FullPath = WPath;
+ *Which = Instance;
+
+ /* At this point, WPath is an absolute path,
+ MPath is either NULL or points to the Map Name,
+ and Instance is the instance number.
+ */
+ if(MPath == NULL) {
+ /* This is NOT a mapped path. */
+ if(Node == NULL) {
+ Node = daDefaultDevice;
+ }
+ if(Node != NULL) {
+ Status = RETURN_SUCCESS;
+ }
+ }
+ else {
+ /* This is a mapped path. */
+ Status = __DevSearch( MPath, NULL, &Node);
+ if(Status == RETURN_NOT_FOUND) {
+ Node = daDefaultDevice;
+
+ if(Node != NULL) {
+ Status = RETURN_SUCCESS;
+ }
+ }
+ }
+ if(DevNode != NULL) {
+ *DevNode = Node;
+ }
+ }
+ if(MPath != NULL) {
+ free(MPath); // We don't need this any more.
+ }
+ return Status;
+}
diff --git a/StdLib/LibC/Uefi/Devices/daConsole.inf b/StdLib/LibC/Uefi/Devices/daConsole.inf new file mode 100644 index 0000000000..17865e4fec --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/daConsole.inf @@ -0,0 +1,63 @@ +## @file
+# Standard C library: Console Device Abstraction.
+#
+# Copyright (c) 2011, 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.
+#
+#
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = DevConsole
+ FILE_GUID = 42c078ef-14a8-4e30-9329-6f12d796e54a
+ MODULE_TYPE = UEFI_APPLICATION
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = DevConsole
+ CONSTRUCTOR = __Cons_construct
+ DESTRUCTOR = __Cons_deconstruct
+
+#
+# VALID_ARCHITECTURES = IA32 X64 IPF
+#
+
+[Sources]
+ Console/daConsole.c
+
+[Packages]
+ StdLib/StdLib.dec
+ StdLibPrivateInternalFiles/DoNotUse.dec
+ MdePkg/MdePkg.dec
+ ShellPkg/ShellPkg.dec
+
+[LibraryClasses]
+ BaseLib
+ BaseMemoryLib
+ MemoryAllocationLib
+ UefiBootServicesTableLib
+ LibC
+ LibWchar
+ LibUefi
+ DevUtility
+
+[Protocols]
+ gEfiSimpleTextInProtocolGuid
+ gEfiSimpleTextOutProtocolGuid
+
+################################################################
+#
+# The Build Options, below, are only used when building the C library.
+# DO NOT use them when building your application!
+# Nasty things could happen if you do.
+#
+# /Oi is required for Microsoft VC++ to allow "intrinsic" functions to be
+# defined in this library.
+#
+#[BuildOptions]
+# MSFT:*_*_*_CC_FLAGS = /Oi-
diff --git a/StdLib/LibC/Uefi/Devices/daShell.inf b/StdLib/LibC/Uefi/Devices/daShell.inf new file mode 100644 index 0000000000..7b56f37363 --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/daShell.inf @@ -0,0 +1,63 @@ +## @file
+# Standard C library: Shell-Hosted Device Abstraction.
+#
+# When this library is included in an application, it creates the default device.
+# This allows every device type not recognized to be passed to the shell for processing.
+#
+# Copyright (c) 2011, 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.
+#
+#
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = DevShell
+ FILE_GUID = 42c078ef-14a8-4e30-9329-6f12d796e54a
+ MODULE_TYPE = UEFI_APPLICATION
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = DevShell
+ CONSTRUCTOR = __ctor_DevShell
+ DESTRUCTOR = __dtor_DevShell
+
+#
+# VALID_ARCHITECTURES = IA32 X64 IPF
+#
+
+[Sources]
+ UefiShell/daShell.c
+
+[Packages]
+ StdLib/StdLib.dec
+ StdLibPrivateInternalFiles/DoNotUse.dec
+ MdePkg/MdePkg.dec
+ ShellPkg/ShellPkg.dec
+
+[LibraryClasses]
+ BaseLib
+ MemoryAllocationLib
+ UefiBootServicesTableLib
+ LibC
+ LibString
+ LibStdLib
+ LibWchar
+ LibUefi
+ DevUtility
+
+################################################################
+#
+# The Build Options, below, are only used when building the C library.
+# DO NOT use them when building your application!
+# Nasty things could happen if you do.
+#
+# /Oi is required for Microsoft VC++ to allow "intrinsic" functions to be
+# defined in this library.
+#
+#[BuildOptions]
+# MSFT:*_*_*_CC_FLAGS = /Oi-
diff --git a/StdLib/LibC/Uefi/Devices/daUtility.inf b/StdLib/LibC/Uefi/Devices/daUtility.inf new file mode 100644 index 0000000000..53daad28ac --- /dev/null +++ b/StdLib/LibC/Uefi/Devices/daUtility.inf @@ -0,0 +1,56 @@ +## @file
+# Standard C library: Console Device Abstraction.
+#
+# Copyright (c) 2011, 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.
+#
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = DevUtility
+ FILE_GUID = 42c078ef-14a8-4e30-9329-6f12d796e54a
+ MODULE_TYPE = UEFI_APPLICATION
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = DevUtility
+
+#
+# VALID_ARCHITECTURES = IA32 X64 IPF
+#
+
+[Sources]
+ Utility/DevGenisis.c
+ Utility/DevSearch.c
+ Utility/Path.c
+
+[Packages]
+ StdLib/StdLib.dec
+ StdLibPrivateInternalFiles/DoNotUse.dec
+ MdePkg/MdePkg.dec
+ ShellPkg/ShellPkg.dec
+
+[LibraryClasses]
+ BaseLib
+ BaseMemoryLib
+ MemoryAllocationLib
+ LibC
+ LibWchar
+ LibUefi
+
+################################################################
+#
+# The Build Options, below, are only used when building the C library.
+# DO NOT use them when building your application!
+# Nasty things could happen if you do.
+#
+# /Oi- is required for Microsoft VC++ to allow "intrinsic" functions to be
+# defined in this library.
+#
+#[BuildOptions]
+# MSFT:*_*_*_CC_FLAGS = /Oi-
diff --git a/StdLib/LibC/Uefi/SysCalls.c b/StdLib/LibC/Uefi/SysCalls.c index 624d45878e..b3ca5b89b4 100644 --- a/StdLib/LibC/Uefi/SysCalls.c +++ b/StdLib/LibC/Uefi/SysCalls.c @@ -13,6 +13,7 @@ **/
#include <Uefi.h>
#include <Library/UefiLib.h>
+#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/ShellLib.h>
@@ -23,40 +24,22 @@ #include <sys/ansi.h>
#include <errno.h>
#include <stdarg.h>
+#include <stdlib.h>
#include <string.h>
#include <wchar.h>
+#include <sys/poll.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <sys/syslimits.h>
-#include "SysEfi.h"
+#include <Efi/SysEfi.h>
+#include <kfile.h>
+#include <Device/Device.h>
#include <MainData.h>
#include <extern.h> // Library/include/extern.h: Private to implementation
-#include <Efi/Console.h>
-
-/* Macros only used in this file. */
-// Parameters for the ValidateFD function.
-#define VALID_OPEN 1
-#define VALID_CLOSED 0
-#define VALID_DONT_CARE -1
-
+#include <sys/EfiSysCall.h>
/* EFI versions of BSD system calls used in stdio */
-/* Normalize path so that forward slashes are replaced with backslashes.
- Backslashes are required for UEFI.
-*/
-static void
-NormalizePath( const CHAR16 *path)
-{
- CHAR16 *temp;
-
- for( temp = (CHAR16 *)path; *temp; ++temp) {
- if(*temp == L'/') {
- *temp = L'\\';
- }
- }
-}
-
/* Validate that fd refers to a valid file descriptor.
IsOpen is interpreted as follows:
- Positive fd must be OPEN
@@ -66,15 +49,18 @@ NormalizePath( const CHAR16 *path) @retval TRUE fd is VALID
@retval FALSE fd is INVALID
*/
-static BOOLEAN
+BOOLEAN
ValidateFD( int fd, int IsOpen)
{
+ struct __filedes *filp;
BOOLEAN retval = FALSE;
if((fd >= 0) && (fd < OPEN_MAX)) {
+ filp = &gMD->fdarray[fd];
retval = TRUE;
if(IsOpen >= 0) {
- retval = (BOOLEAN)(gMD->fdarray[fd].State != 0); // TRUE if OPEN
+ retval = (BOOLEAN)((filp->f_iflags != 0) && // TRUE if OPEN
+ FILE_IS_USABLE(filp)); // and Usable (not Larval or Closing)
if(IsOpen == VALID_CLOSED) {
retval = (BOOLEAN)!retval; // We want TRUE if CLOSED
}
@@ -91,7 +77,7 @@ ValidateFD( int fd, int IsOpen) @return Returns -1 if there are no free FDs. Otherwise returns the
found fd.
*/
-static int
+int
FindFreeFD( int MinFd )
{
struct __filedes *Mfd;
@@ -102,8 +88,8 @@ FindFreeFD( int MinFd ) // Get an available fd
for(i=MinFd; i < OPEN_MAX; ++i) {
- if(Mfd[i].State == 0) {
- Mfd[i].State = S_ISYSTEM; // Temporarily mark this fd as reserved
+ if(Mfd[i].f_iflags == 0) {
+ Mfd[i].f_iflags = FIF_LARVAL; // Temporarily mark this fd as reserved
fd = i;
break;
}
@@ -111,6 +97,22 @@ FindFreeFD( int MinFd ) return fd;
}
+/* Mark that an open file is to be deleted when closed. */
+int
+DeleteOnClose(int fd)
+{
+ int retval = 0;
+
+ if(ValidateFD( fd, VALID_OPEN)) {
+ gMD->fdarray[fd].f_iflags |= FIF_DELCLOSE;
+ }
+ else {
+ errno = EBADF;
+ retval = -1;
+ }
+ return retval;
+}
+
/** The isatty() function tests whether fildes, an open file descriptor,
is associated with a terminal device.
@@ -119,15 +121,14 @@ FindFreeFD( int MinFd ) EBADF if fildes is not a valid open FD.
**/
int
-isatty (int fildes)
+isatty (int fd)
{
int retval = 0;
- EFI_FILE_HANDLE FileHandle;
+ struct __filedes *Fp;
- if(ValidateFD( fildes, VALID_OPEN)) {
- FileHandle = gMD->fdarray[fildes].FileHandle;
- retval = (FileHandle >= &gMD->StdIo[0].Abstraction) &&
- (FileHandle <= &gMD->StdIo[2].Abstraction);
+ if(ValidateFD( fd, VALID_OPEN)) {
+ Fp = &gMD->fdarray[fd];
+ retval = Fp->f_iflags & _S_ITTY;
}
else {
errno = EBADF;
@@ -138,16 +139,19 @@ isatty (int fildes) static BOOLEAN
IsDupFd( int fd)
{
- EFI_FILE_HANDLE FileHandle;
+ void * DevData;
+ const struct fileops *FileOps;
int i;
BOOLEAN Ret = FALSE;
if(ValidateFD( fd, VALID_OPEN )) {
- FileHandle = gMD->fdarray[fd].FileHandle;
+ FileOps = gMD->fdarray[fd].f_ops;
+ DevData = gMD->fdarray[fd].devdata;
for(i=0; i < OPEN_MAX; ++i) {
if(i == fd) continue;
- if(gMD->fdarray[i].State != 0) { // TRUE if fd is OPEN
- if(gMD->fdarray[i].FileHandle == FileHandle) {
+ if(ValidateFD( i, VALID_OPEN )) { // TRUE if fd is valid and OPEN
+ if((gMD->fdarray[i].f_ops == FileOps)
+ &&(gMD->fdarray[i].devdata == DevData )) {
Ret = TRUE;
break;
}
@@ -160,36 +164,37 @@ IsDupFd( int fd) static int
_closeX (int fd, int NewState)
{
- struct __filedes *Mfd;
- RETURN_STATUS Status;
+ struct __filedes *Fp;
int retval = 0;
- Status = EFIerrno = RETURN_SUCCESS; // In case of error before the EFI call.
-
// Verify my pointers and get my FD.
if(ValidateFD( fd, VALID_OPEN )) {
- Mfd = &gMD->fdarray[fd];
- // Check if there are duplicates using this FileHandle
+ Fp = &gMD->fdarray[fd];
+ // Check if there are other users of this FileHandle
+ if(Fp->RefCount == 1) { // There should be no other users
if(! IsDupFd(fd)) {
// Only do the close if no one else is using the FileHandle
- if(isatty(fd)) {
- Status = Mfd->FileHandle->Close( Mfd->FileHandle);
+ if(Fp->f_iflags & FIF_DELCLOSE) {
+ /* Handle files marked "Delete on Close". */
+ if(Fp->f_ops->fo_delete != NULL) {
+ retval = Fp->f_ops->fo_delete(Fp);
+ }
}
else {
- Status = ShellCloseFile( (SHELL_FILE_HANDLE *)&Mfd->FileHandle);
+ retval = Fp->f_ops->fo_close( Fp);
}
}
- Mfd->State = NewState; // Close this FD or reserve it
- if(Status != RETURN_SUCCESS) {
- errno = EFI2errno(Status);
- EFIerrno = Status;
- retval = -1;
+ Fp->f_iflags = NewState; // Close this FD or reserve it
+ Fp->RefCount = 0; // No one using this FD
+ }
+ else {
+ --Fp->RefCount; /* One less user of this FD */
}
}
else {
// Bad FD
- errno = EBADF;
retval = -1;
+ errno = EBADF;
}
return retval;
}
@@ -210,41 +215,28 @@ close (int fd) return _closeX(fd, 0);
}
-/* Wide character version of unlink */
+/**
+**/
int
-Uunlink (const wchar_t *Path)
+unlink (const char *path)
{
- EFI_FILE_HANDLE FileHandle;
- RETURN_STATUS Status;
+ struct __filedes *Fp;
+ int fd;
+ int retval = -1;
EFIerrno = RETURN_SUCCESS;
- NormalizePath( Path);
- // We can only delete open files.
- Status = ShellOpenFileByName( Path, (SHELL_FILE_HANDLE *)&FileHandle, 3, 0);
- if(Status != RETURN_SUCCESS) {
- errno = EFI2errno(Status);
- EFIerrno = Status;
- return -1;
+ fd = open(path, O_WRONLY, 0);
+ if(fd >= 0) {
+ Fp = &gMD->fdarray[fd];
+
+ if(Fp->f_ops->fo_delete != NULL) {
+ retval = Fp->f_ops->fo_delete(Fp);
}
- Status = ShellDeleteFile( (SHELL_FILE_HANDLE *)&FileHandle);
- if(Status != RETURN_SUCCESS) {
- errno = EFI2errno(Status);
- EFIerrno = Status;
- return -1;
+ Fp->f_iflags = 0; // Close this FD
+ Fp->RefCount = 0; // No one using this FD
}
- return 0;
-}
-
-/**
-**/
-int
-unlink (const char *path)
-{
- // Convert path from MBCS to WCS
- (void)AsciiStrToUnicodeStr( path, gMD->UString);
-
- return Uunlink(gMD->UString);
+ return retval;
}
/** The fcntl() function shall perform the operations described below on open
@@ -366,23 +358,23 @@ fcntl (int fildes, int cmd, ...) break;
//case F_SETFL:
case F_SETFD:
- retval = MyFd->State;
- break;
- case F_SETOWN:
- retval = MyFd->SocProc;
- MyFd->SocProc = va_arg(p3, int);
+ retval = MyFd->f_iflags;
break;
+ //case F_SETOWN:
+ // retval = MyFd->SocProc;
+ // MyFd->SocProc = va_arg(p3, int);
+ // break;
case F_GETFD:
//retval = MyFd->Oflags;
- retval = MyFd->State;
+ retval = MyFd->f_iflags;
break;
case F_GETFL:
- //retval = MyFd->State;
+ //retval = MyFd->f_iflags;
retval = MyFd->Oflags;
break;
- case F_GETOWN:
- retval = MyFd->SocProc;
- break;
+ //case F_GETOWN:
+ // retval = MyFd->SocProc;
+ // break;
default:
errno = EINVAL;
break;
@@ -441,9 +433,10 @@ dup2 (int fildes, int fildes2) retval = fildes2;
if( fildes != fildes2) {
if(ValidateFD( fildes2, VALID_DONT_CARE)) {
- gMD->fdarray[fildes2].State = S_ISYSTEM; // Mark the file closed, but reserved
+ gMD->fdarray[fildes2].f_iflags = FIF_LARVAL; // Mark the file closed, but reserved
(void)memcpy(&gMD->fdarray[fildes2], // Duplicate fildes into fildes2
&gMD->fdarray[fildes], sizeof(struct __filedes));
+ gMD->fdarray[fildes2].MyFD = (UINT16)fildes2;
}
else {
errno = EBADF;
@@ -486,53 +479,21 @@ dup2 (int fildes, int fildes2) indicate the error.
**/
__off_t
-lseek (int fildes, __off_t offset, int how)
+lseek (int fd, __off_t offset, int how)
{
__off_t CurPos = -1;
- RETURN_STATUS Status = RETURN_SUCCESS;
- EFI_FILE_HANDLE FileHandle;
+// RETURN_STATUS Status = RETURN_SUCCESS;
+ struct __filedes *filp;
EFIerrno = RETURN_SUCCESS; // In case of error without an EFI call
if( how == SEEK_SET || how == SEEK_CUR || how == SEEK_END) {
- if(ValidateFD( fildes, VALID_OPEN)) {
+ if(ValidateFD( fd, VALID_OPEN)) {
+ filp = &gMD->fdarray[fd];
// Both of our parameters have been verified as valid
- FileHandle = gMD->fdarray[fildes].FileHandle;
- CurPos = 0;
- if(isatty(fildes)) {
- Status = FileHandle->SetPosition( FileHandle, offset);
- CurPos = offset;
- }
- else {
- if(how != SEEK_SET) {
- // We are doing a relative seek
- if(how == SEEK_END) {
- // seeking relative to EOF, so position there first.
- Status = ShellSetFilePosition( (SHELL_FILE_HANDLE)FileHandle, 0xFFFFFFFFFFFFFFFFULL);
- }
- if(Status == RETURN_SUCCESS) {
- // Now, determine our current position.
- Status = ShellGetFilePosition( (SHELL_FILE_HANDLE)FileHandle, (UINT64 *)&CurPos);
- }
- }
- if(Status == RETURN_SUCCESS) {
- /* CurPos now indicates the point we are seeking from, so seek... */
- Status = ShellSetFilePosition( (SHELL_FILE_HANDLE)FileHandle, (UINT64)(CurPos + offset));
- if(Status == RETURN_SUCCESS) {
- // Now, determine our final position.
- Status = ShellGetFilePosition( (SHELL_FILE_HANDLE)FileHandle, (UINT64 *)&CurPos);
- }
- }
- if(Status != RETURN_SUCCESS) {
- EFIerrno = Status;
- CurPos = -1;
- if(Status == EFI_UNSUPPORTED) {
- errno = EISDIR;
- }
- else {
- errno = EFI2errno(Status);
- }
- }
+ CurPos = filp->f_ops->fo_lseek( filp, offset, how);
+ if(CurPos >= 0) {
+ filp->f_offset = CurPos;
}
}
else {
@@ -551,37 +512,35 @@ lseek (int fildes, __off_t offset, int how) The directory is closed after it is created.
@retval 0 The directory was created successfully.
- @retval -1 An error occurred and an error code is stored in errno.
+ @retval -1 An error occurred and error codes are stored in errno and EFIerrno.
**/
int
mkdir (const char *path, __mode_t perms)
{
- EFI_FILE_HANDLE FileHandle;
+ wchar_t *NewPath;
+ DeviceNode *Node;
+ char *GenI;
RETURN_STATUS Status;
- EFI_FILE_INFO *FileInfo;
-
- // Convert name from MBCS to WCS
- (void)AsciiStrToUnicodeStr( path, gMD->UString);
- NormalizePath( gMD->UString);
+ int Instance = 0;
+ int retval = 0;
-//Print(L"%a( \"%s\", 0x%8X)\n", __func__, gMD->UString, perms);
- Status = ShellCreateDirectory( gMD->UString, (SHELL_FILE_HANDLE *)&FileHandle);
+ Status = ParsePath(path, &NewPath, &Node, &Instance);
if(Status == RETURN_SUCCESS) {
- FileInfo = ShellGetFileInfo( FileHandle);
- if(FileInfo != NULL) {
- FileInfo->Attribute = Omode2EFI(perms);
- Status = ShellSetFileInfo( FileHandle, FileInfo);
- FreePool(FileInfo);
- if(Status == RETURN_SUCCESS) {
- (void)ShellCloseFile((SHELL_FILE_HANDLE *)&FileHandle);
- return 0;
+ GenI = Node->InstanceList;
+ if(GenI == NULL) {
+ errno = EPERM;
+ retval = -1;
}
+ else {
+ GenI += (Instance * Node->InstanceSize);
+ retval = ((GenericInstance *)GenI)->Abstraction.fo_mkdir( path, perms);
+ }
+ free(NewPath);
}
+ else {
+ retval = -1;
}
- errno = EFI2errno(Status);
- EFIerrno = Status;
-
- return -1;
+ return retval;
}
/** Open a file.
@@ -608,112 +567,215 @@ mkdir (const char *path, __mode_t perms) O_EXCL -- if O_CREAT is also set, open will fail if the file already exists.
**/
int
-open (const char *name, int oflags, int mode)
+open (const char *path, int oflags, int mode)
{
- EFI_FILE_HANDLE FileHandle;
- struct __filedes *Mfd;
+ wchar_t *NewPath;
+ DeviceNode *Node;
+ char *GenI = NULL;
+ struct __filedes *filp;
+ int Instance = 0;
RETURN_STATUS Status;
UINT64 OpenMode;
- UINT64 Attributes;
int fd = -1;
- UINT32 NewState;
+ int doresult;
- EFIerrno = RETURN_SUCCESS;
- Mfd = gMD->fdarray;
-
- // Convert name from MBCS to WCS
- (void)AsciiStrToUnicodeStr( name, gMD->UString);
- NormalizePath( gMD->UString);
-
- // Convert oflags to Attributes
- OpenMode = Oflags2EFI(oflags);
- if(OpenMode == 0) {
- errno = EINVAL;
- return -1;
+ Status = ParsePath(path, &NewPath, &Node, &Instance);
+ if(Status == RETURN_SUCCESS) {
+ if((Node != NULL) &&
+ ((GenI = Node->InstanceList) == NULL)) {
+ errno = EPERM;
}
-
- //Attributes = Omode2EFI(mode);
- Attributes = 0;
-
+ else {
// Could add a test to see if the file name begins with a period.
// If it does, then add the HIDDEN flag to Attributes.
// Get an available fd
- fd = FindFreeFD( 0 );
+ fd = FindFreeFD( VALID_CLOSED );
if( fd < 0 ) {
// All available FDs are in use
errno = EMFILE;
return -1;
}
+ filp = &gMD->fdarray[fd];
+ // Save the flags and mode in the File Descriptor
+ filp->Oflags = oflags;
+ filp->Omode = mode;
+
+ GenI += (Instance * Node->InstanceSize);
+ doresult = Node->OpenFunc(filp, GenI, NewPath, NULL);
+ if(doresult < 0) {
+ filp->f_iflags = 0; // Release this FD
+ fd = -1; // Indicate an error
+ }
+ else {
+ // Re-use OpenMode in order to build our final f_iflags value
+ OpenMode = ( mode & S_ACC_READ ) ? S_ACC_READ : 0;
+ OpenMode |= ( mode & S_ACC_WRITE ) ? S_ACC_WRITE : 0;
- Status = ConOpen( NULL, &FileHandle, gMD->UString, OpenMode, Attributes);
- if(Status == RETURN_NO_MAPPING) {
- // Not a console device, how about a regular file device?
-
- /* Do we care if the file already exists?
- If O_TRUNC, then delete the file. It will be created anew subsequently.
- If O_EXCL, then error if the file exists and O_CREAT is set.
-
- !!!!!!!!! Change this to use ShellSetFileInfo() to actually truncate the file
- !!!!!!!!! instead of deleting and re-creating it.
- */
- if((oflags & O_TRUNC) || ((oflags & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT))) {
- Status = ShellIsFile( gMD->UString );
- if(Status == RETURN_SUCCESS) {
- // The file exists
- if(oflags & O_TRUNC) {
- // We do a truncate by deleting the existing file and creating a new one.
- if(Uunlink(gMD->UString) != 0) {
- Mfd[fd].State = 0; // Release our reservation on this FD
- return -1; // errno and EFIerrno are already set.
+ filp->f_iflags |= (UINT32)OpenMode;
+ ++filp->RefCount;
+ FILE_SET_MATURE(filp);
+ }
}
+ free(NewPath);
}
- else if(oflags & (O_EXCL | O_CREAT)) {
- errno = EEXIST;
- EFIerrno = Status;
- Mfd[fd].State = 0; // Release our reservation on this FD
+ // return the fd of our now open file
+ return fd;
+}
+
+
+/**
+ Poll a list of file descriptors.
+
+ The ::poll routine waits for up to timeout milliseconds for an event
+ to occur on one or more of the file descriptors listed. The event
+ types of interested are specified for each file descriptor in the events
+ field. The actual event detected is returned in the revents field of
+ the array. The
+ <a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/poll.html">POSIX</a>
+ documentation is available online.
+
+ @param [in] pfd Address of an array of pollfd structures.
+
+ @param [in] nfds Number of elements in the array of pollfd structures.
+
+ @param [in] timeout Length of time in milliseconds to wait for the event
+
+ @returns The number of file descriptors with detected events. Zero
+ indicates that the call timed out and -1 indicates an error.
+
+ **/
+int
+poll (
+ struct pollfd * pfd,
+ nfds_t nfds,
+ int timeout
+ )
+{
+ struct __filedes * pDescriptor;
+ struct pollfd * pEnd;
+ struct pollfd * pPollFD;
+ int SelectedFDs;
+ EFI_STATUS Status;
+ EFI_EVENT Timer;
+ UINT64 TimerTicks;
+
+ //
+ // Create the timer for the timeout
+ //
+ Timer = NULL;
+ Status = EFI_SUCCESS;
+ if ( INFTIM != timeout ) {
+ Status = gBS->CreateEvent ( EVT_TIMER,
+ TPL_NOTIFY,
+ NULL,
+ NULL,
+ &Timer );
+ if ( !EFI_ERROR ( Status )) {
+ //
+ // Start the timeout timer
+ //
+ TimerTicks = timeout;
+ TimerTicks *= 1000 * 10;
+ Status = gBS->SetTimer ( Timer,
+ TimerRelative,
+ TimerTicks );
+ }
+ else {
+ SelectedFDs = -1;
+ errno = ENOMEM;
+ }
+ }
+ if ( !EFI_ERROR ( Status )) {
+ //
+ // Poll until an event is detected or the timer fires
+ //
+ SelectedFDs = 0;
+ errno = 0;
+ do {
+ //
+ // Poll the list of file descriptors
+ //
+ pPollFD = pfd;
+ pEnd = &pPollFD [ nfds ];
+ while ( pEnd > pPollFD ) {
+ //
+ // Validate the file descriptor
+ //
+ if ( !ValidateFD ( pPollFD->fd, VALID_OPEN )) {
+ errno = EINVAL;
return -1;
}
+
+ //
+ // Poll the device or file
+ //
+ pDescriptor = &gMD->fdarray [ pPollFD->fd ];
+ pPollFD->revents = pDescriptor->f_ops->fo_poll ( pDescriptor,
+ pPollFD->events );
+
+ //
+ // Determine if this file descriptor detected an event
+ //
+ if ( 0 != pPollFD->revents ) {
+ //
+ // Select this descriptor
+ //
+ SelectedFDs += 1;
+ }
+
+ //
+ // Set the next file descriptor
+ //
+ pPollFD += 1;
}
+
+ //
+ // Check for timeout
+ //
+ if ( NULL != Timer ) {
+ Status = gBS->CheckEvent ( Timer );
+ if ( EFI_SUCCESS == Status ) {
+ //
+ // Timeout
+ //
+ break;
+ }
+ else if ( EFI_NOT_READY == Status ) {
+ Status = EFI_SUCCESS;
}
- // Call the EFI Shell's Open function
- Status = ShellOpenFileByName( gMD->UString, (SHELL_FILE_HANDLE *)&FileHandle, OpenMode, Attributes);
- if(RETURN_ERROR(Status)) {
- Mfd[fd].State = 0; // Release our reservation on this FD
- // Set errno based upon Status
- errno = EFI2errno(Status);
- EFIerrno = Status;
- return -1;
}
- // Successfully got a regular File
- NewState = S_IFREG;
+ } while (( 0 == SelectedFDs )
+ && ( EFI_SUCCESS == Status ));
+ //
+ // Stop the timer
+ //
+ if ( NULL != Timer ) {
+ gBS->SetTimer ( Timer,
+ TimerCancel,
+ 0 );
}
- else if(Status != RETURN_SUCCESS) {
- // Set errno based upon Status
- errno = EFI2errno(Status);
- EFIerrno = Status;
- return -1;
}
else {
- // Succesfully got a Console stream
- NewState = S_IFREG | _S_ITTY | _S_IFCHR;
+ SelectedFDs = -1;
+ errno = EAGAIN;
}
- // Update the info in the fd
- Mfd[fd].FileHandle = FileHandle;
- Mfd[fd].Oflags = oflags;
- Mfd[fd].Omode = mode;
+ //
+ // Release the timer
+ //
+ if ( NULL != Timer ) {
+ gBS->CloseEvent ( Timer );
+ }
- // Re-use OpenMode in order to build our final State value
- OpenMode = ( mode & S_ACC_READ ) ? S_ACC_READ : 0;
- OpenMode |= ( mode & S_ACC_WRITE ) ? S_ACC_WRITE : 0;
+ //
+ // Return the number of selected file system descriptors
+ //
+ return SelectedFDs;
+}
- Mfd[fd].State = NewState | (UINT32)OpenMode;
- // return the fd of our now open file
- return fd;
-}
/** The rename() function changes the name of a file.
The old argument points to the pathname of the file to be renamed. The new
@@ -745,168 +807,54 @@ open (const char *name, int oflags, int mode) shall be changed or created.
**/
int
-rename (const char *old, const char *new)
-{
- // UINT64 InfoSize;
- // RETURN_STATUS Status;
- // EFI_FILE_INFO *NewFileInfo = NULL;
- // EFI_FILE_INFO *OldFileInfo;
- // char *Newfn;
- // int OldFd;
-
- //// Open old file
- // OldFd = open(old, O_RDONLY, 0);
- // if(OldFd >= 0) {
- // NewFileInfo = malloc(sizeof(EFI_FILE_INFO) + PATH_MAX);
- // if(NewFileInfo != NULL) {
- // OldFileInfo = ShellGetFileInfo( FileHandle);
- // if(OldFileInfo != NULL) {
- // // Copy the Old file info into our new buffer, and free the old.
- // memcpy(OldFileInfo, NewFileInfo, sizeof(EFI_FILE_INFO));
- // FreePool(OldFileInfo);
- // // Strip off all but the file name portion of new
- // NewFn = strrchr(new, '/');
- // if(NewFn == NULL) {
- // NewFn = strrchr(new '\\');
- // if(NewFn == NULL) {
- // NewFn = new;
- // }
- // }
- // // Convert new name from MBCS to WCS
- // (void)AsciiStrToUnicodeStr( NewFn, gMD->UString);
- // // Copy the new file name into our new file info buffer
- // wcsncpy(NewFileInfo->FileName, gMD->UString, wcslen(gMD->UString)+1);
- // // Apply the new file name
- // Status = ShellSetFileInfo(FileHandle);
- // if(Status == EFI_SUCCESS) {
- // // File has been successfully renamed. We are DONE!
- // return 0;
- // }
- // errno = EFI2errno( Status );
- // EFIerrno = Status;
- // }
- // else {
- // errno = EIO;
- // }
- // }
- // else {
- // errno = ENOMEM;
- // }
- // }
- return -1;
-}
-
-/**
-**/
-int
-rmdir (const char *path)
+EFIAPI
+rename(
+ const char *from,
+ const char *to
+ )
{
- EFI_FILE_HANDLE FileHandle;
- RETURN_STATUS Status;
- EFI_FILE_INFO *FileInfo = NULL;
- int Count = 0;
- BOOLEAN NoFile = FALSE;
-
- errno = 0; // Make it easier to see if we have an error later
-
- // Convert name from MBCS to WCS
- (void)AsciiStrToUnicodeStr( path, gMD->UString);
- NormalizePath( gMD->UString);
-
-//Print(L"%a( \"%s\")\n", __func__, gMD->UString);
- Status = ShellOpenFileByName( gMD->UString, (SHELL_FILE_HANDLE *)&FileHandle,
- (EFI_FILE_MODE_READ || EFI_FILE_MODE_WRITE), 0);
+ wchar_t *FromPath;
+ DeviceNode *FromNode;
+ char *GenI;
+ int Instance = 0;
+ RETURN_STATUS Status;
+ int retval = -1;
+
+ Status = ParsePath(from, &FromPath, &FromNode, &Instance);
if(Status == RETURN_SUCCESS) {
- FileInfo = ShellGetFileInfo( (SHELL_FILE_HANDLE)FileHandle);
- if(FileInfo != NULL) {
- if((FileInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
- errno = ENOTDIR;
+ GenI = FromNode->InstanceList;
+ if(GenI == NULL) {
+ errno = EPERM;
+ retval = -1;
}
else {
- // See if the directory has any entries other than ".." and ".".
- FreePool(FileInfo); // Free up the buffer from ShellGetFileInfo()
- Status = ShellFindFirstFile( (SHELL_FILE_HANDLE)FileHandle, &FileInfo);
- if(Status == RETURN_SUCCESS) {
- ++Count;
- while(Count < 3) {
- Status = ShellFindNextFile( (SHELL_FILE_HANDLE)FileHandle, FileInfo, &NoFile);
- if(Status == RETURN_SUCCESS) {
- if(NoFile) {
- break;
+ GenI += (Instance * FromNode->InstanceSize);
+ retval = ((GenericInstance *)GenI)->Abstraction.fo_rename( from, to);
}
- ++Count;
- }
- else {
- Count = 99;
+ free(FromPath);
}
- }
- FreePool(FileInfo); // Free buffer from ShellFindFirstFile()
- if(Count < 3) {
- // Directory is empty
- Status = ShellDeleteFile( (SHELL_FILE_HANDLE *)&FileHandle);
- if(Status == RETURN_SUCCESS) {
- EFIerrno = RETURN_SUCCESS;
- return 0;
- /* ######## SUCCESSFUL RETURN ######## */
- }
- }
- else {
- if(Count == 99) {
- errno = EIO;
- }
- else {
- errno = ENOTEMPTY;
- }
- }
- }
- }
- }
- else {
- errno = EIO;
- }
- }
- EFIerrno = Status;
- if(errno == 0) {
- errno = EFI2errno( Status );
- }
- return -1;
+ return retval;
}
-/* Internal File Info. worker function for stat and fstat. */
-static
-EFI_STATUS
-_EFI_FileInfo( EFI_FILE_INFO *FileInfo, struct stat *statbuf)
+/**
+**/
+int
+EFIAPI
+rmdir(
+ const char *path
+ )
{
- UINT64 Attributes;
- RETURN_STATUS Status;
- mode_t newmode;
-
- if(FileInfo != NULL) {
- // Got the info, now populate statbuf with it
- statbuf->st_blksize = S_BLKSIZE;
- statbuf->st_size = FileInfo->Size;
- statbuf->st_physsize = FileInfo->PhysicalSize;
- statbuf->st_birthtime = Efi2Time( &FileInfo->CreateTime);
- statbuf->st_atime = Efi2Time( &FileInfo->LastAccessTime);
- statbuf->st_mtime = Efi2Time( &FileInfo->ModificationTime);
- Attributes = FileInfo->Attribute;
- newmode = (mode_t)(Attributes << S_EFISHIFT) | S_ACC_READ;
- if((Attributes & EFI_FILE_DIRECTORY) == 0) {
- newmode |= _S_IFREG;
- if((Attributes & EFI_FILE_READ_ONLY) == 0) {
- statbuf->st_mode |= S_ACC_WRITE;
+ struct __filedes *filp;
+ int fd;
+ int retval = -1;
+
+ fd = open(path, O_RDWR, 0);
+ if(fd >= 0) {
+ filp = &gMD->fdarray[fd];
+
+ retval = filp->f_ops->fo_rmdir(filp);
}
- }
- else {
- newmode |= _S_IFDIR;
- }
- statbuf->st_mode = newmode;
- Status = RETURN_SUCCESS;
- }
- else {
- Status = RETURN_DEVICE_ERROR;
- }
- return Status;
+ return retval;
}
/** The fstat() function obtains information about an open file associated
@@ -935,7 +883,7 @@ _EFI_FileInfo( EFI_FILE_INFO *FileInfo, struct stat *statbuf) - st_gid Set to zero.
- st_nlink Set to one.
- @param[in] fildes File descriptor as returned from open().
+ @param[in] fd File descriptor as returned from open().
@param[out] statbuf Buffer in which the file status is put.
@retval 0 Successful Completion.
@@ -943,37 +891,19 @@ _EFI_FileInfo( EFI_FILE_INFO *FileInfo, struct stat *statbuf) identify the error.
**/
int
-fstat (int fildes, struct stat *statbuf)
+fstat (int fd, struct stat *statbuf)
{
- EFI_FILE_HANDLE FileHandle;
- RETURN_STATUS Status = RETURN_SUCCESS;
- EFI_FILE_INFO *FileInfo = NULL;
- UINTN FinfoSize = sizeof(EFI_FILE_INFO);
+ int retval = -1;
+ struct __filedes *filp;
- if(ValidateFD( fildes, VALID_OPEN)) {
- FileHandle = gMD->fdarray[fildes].FileHandle;
- if(isatty(fildes)) {
- FileInfo = AllocateZeroPool(FinfoSize);
- if(FileInfo != NULL) {
- Status = FileHandle->GetInfo( FileHandle, 0, &FinfoSize, FileInfo);
+ if(ValidateFD( fd, VALID_OPEN)) {
+ filp = &gMD->fdarray[fd];
+ retval = filp->f_ops->fo_stat(filp, statbuf, NULL);
}
else {
- Status = RETURN_OUT_OF_RESOURCES;
+ errno = EBADF;
}
- }
- else {
- FileInfo = ShellGetFileInfo( FileHandle);
- }
- Status = _EFI_FileInfo( FileInfo, statbuf);
- }
- errno = EFI2errno(Status);
- EFIerrno = Status;
-
- if(FileInfo != NULL) {
- FreePool(FileInfo); // Release the buffer allocated by the GetInfo function
- }
-
- return errno? -1 : 0;
+ return retval;
}
/** Obtains information about the file pointed to by path.
@@ -988,26 +918,17 @@ fstat (int fildes, struct stat *statbuf) int
stat (const char *path, void *statbuf)
{
- EFI_FILE_HANDLE FileHandle;
- RETURN_STATUS Status;
- EFI_FILE_INFO *FileInfo;
-
- errno = 0; // Make it easier to see if we have an error later
-
- // Convert name from MBCS to WCS
- (void)AsciiStrToUnicodeStr( path, gMD->UString);
- NormalizePath( gMD->UString);
-
- Status = ShellOpenFileByName( gMD->UString, (SHELL_FILE_HANDLE *)&FileHandle, EFI_FILE_MODE_READ, 0ULL);
- if(Status == RETURN_SUCCESS) {
- FileInfo = ShellGetFileInfo( FileHandle);
- Status = _EFI_FileInfo( FileInfo, (struct stat *)statbuf);
- (void)ShellCloseFile( (SHELL_FILE_HANDLE *)&FileHandle);
+ int fd;
+ int retval = -1;
+ struct __filedes *filp;
+
+ fd = open(path, O_RDONLY, 0);
+ if(fd >= 0) {
+ filp = &gMD->fdarray[fd];
+ retval = filp->f_ops->fo_stat( filp, statbuf, NULL);
+ close(fd);
}
- errno = EFI2errno(Status);
- EFIerrno = Status;
-
- return errno? -1 : 0;
+ return retval;
}
/** Same as stat since EFI doesn't have symbolic links. **/
@@ -1017,6 +938,33 @@ lstat (const char *path, struct stat *statbuf) return stat(path, statbuf);
}
+/** Control a device.
+**/
+int
+ioctl(
+ int fd,
+ unsigned long request,
+ ...
+ )
+{
+ int retval = -1;
+ struct __filedes *filp;
+ va_list argp;
+
+ va_start(argp, request);
+
+ if(ValidateFD( fd, VALID_OPEN)) {
+ filp = &gMD->fdarray[fd];
+ retval = filp->f_ops->fo_ioctl(filp, request, argp);
+ }
+ else {
+ errno = EBADF;
+ }
+ va_end(argp);
+
+ return retval;
+}
+
/** Read from a file.
The read() function shall attempt to read nbyte bytes from the file
@@ -1083,59 +1031,22 @@ lstat (const char *path, struct stat *statbuf) ssize_t
read (int fildes, void *buf, size_t nbyte)
{
+ struct __filedes *filp;
ssize_t BufSize;
- EFI_FILE_HANDLE FileHandle;
- RETURN_STATUS Status;
BufSize = (ssize_t)nbyte;
if(ValidateFD( fildes, VALID_OPEN)) {
- FileHandle = gMD->fdarray[fildes].FileHandle;
- if(isatty(fildes)) {
- Status = FileHandle->Read( FileHandle, (UINTN *)&BufSize, buf);
- }
- else {
- Status = ShellReadFile( FileHandle, (UINTN *)&BufSize, buf);
- }
- if(Status != RETURN_SUCCESS) {
- EFIerrno = Status;
- errno = EFI2errno(Status);
- if(Status == RETURN_BUFFER_TOO_SMALL) {
- BufSize = -BufSize;
- }
- else {
- BufSize = -1;
- }
- }
+ filp = &gMD->fdarray[fildes];
+
+ BufSize = filp->f_ops->fo_read(filp, &filp->f_offset, nbyte, buf);
}
else {
errno = EBADF;
+ BufSize = -EBADF;
}
return BufSize;
}
-ssize_t
-WideTtyCvt( CHAR16 *dest, const char *buf, size_t n)
-{
- UINTN i;
- wint_t wc;
-
- for(i = 0; i < n; ++i) {
- wc = btowc(*buf++);
- if( wc == 0) {
- break;
- };
- if(wc < 0) {
- wc = BLOCKELEMENT_LIGHT_SHADE;
- }
- if(wc == L'\n') {
- *dest++ = L'\r';
- }
- *dest++ = (CHAR16)wc;
- }
- *dest = 0;
- return (ssize_t)i;
-}
-
/** Write data to a file.
This function writes the specified number of bytes to the file at the current
@@ -1159,40 +1070,62 @@ WideTtyCvt( CHAR16 *dest, const char *buf, size_t n) QUESTION: Should writes to stdout or stderr always succeed?
**/
ssize_t
-write (int fildes, const void *buf, size_t n)
+write (int fd, const void *buf, size_t nbyte)
{
+ struct __filedes *filp;
ssize_t BufSize;
- EFI_FILE_HANDLE FileHandle;
- RETURN_STATUS Status = RETURN_SUCCESS;
- ssize_t UniBufSz;
+// EFI_FILE_HANDLE FileHandle;
+// RETURN_STATUS Status = RETURN_SUCCESS;
+
+ BufSize = (ssize_t)nbyte;
- BufSize = (ssize_t)n;
+ if(ValidateFD( fd, VALID_OPEN)) {
+ filp = &gMD->fdarray[fd];
- if(ValidateFD( fildes, VALID_OPEN)) {
- FileHandle = gMD->fdarray[fildes].FileHandle;
- if(isatty(fildes)) {
- // Convert string from MBCS to WCS and translate \n to \r\n.
- UniBufSz = WideTtyCvt(gMD->UString, (const char *)buf, n);
- if(UniBufSz > 0) {
- BufSize = (ssize_t)(UniBufSz * sizeof(CHAR16));
- Status = FileHandle->Write( FileHandle, (UINTN *)&BufSize, (void *)gMD->UString);
- BufSize = (ssize_t)n; // Always pretend all was output
- }
+ BufSize = filp->f_ops->fo_write(filp, &filp->f_offset, nbyte, buf);
}
else {
- Status = ShellWriteFile( FileHandle, (UINTN *)&BufSize, (void *)buf);
- }
- if(Status != RETURN_SUCCESS) {
- EFIerrno = Status;
- errno = EFI2errno(Status);
- if(Status == EFI_UNSUPPORTED) {
- errno = EISDIR;
+ errno = EBADF;
+ BufSize = -EBADF;
}
- BufSize = -1;
+ return BufSize;
+}
+
+/** Gets the current working directory.
+
+ The getcwd() function shall place an absolute pathname of the current
+ working directory in the array pointed to by buf, and return buf. The
+ pathname copied to the array shall contain no components that are
+ symbolic links. The size argument is the size in bytes of the character
+ array pointed to by the buf argument.
+
+ @param[in,out] buf The buffer to fill.
+ @param[in] size The number of bytes in buffer.
+
+ @retval NULL The function failed.
+ @retval NULL Buf was NULL.
+ @retval NULL Size was 0.
+ @return buf The function completed successfully. See errno for info.
+**/
+char
+*getcwd (char *buf, size_t size)
+{
+ CONST CHAR16 *Cwd;
+
+ if (size == 0 || buf == NULL) {
+ errno = EINVAL;
+ return NULL;
}
+
+ Cwd = ShellGetCurrentDir(NULL);
+ if (Cwd == NULL) {
+ errno = EACCES;
+ return NULL;
}
- else {
- errno = EBADF;
+ if (size < ((StrLen (Cwd) + 1) * sizeof (CHAR8))) {
+ errno = ERANGE;
+ return (NULL);
}
- return BufSize;
+
+ return (UnicodeStrToAsciiStr(Cwd, buf));
}
diff --git a/StdLib/LibC/Uefi/SysEfi.h b/StdLib/LibC/Uefi/SysEfi.h deleted file mode 100644 index fa9dc38cdd..0000000000 --- a/StdLib/LibC/Uefi/SysEfi.h +++ /dev/null @@ -1,37 +0,0 @@ -/** @file
- Declarations local to the Uefi SysCalls module of the Standard C Library.
-
- Copyright (c) 2010, 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 that 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.
-
-**/
-#ifndef _SYSEFI_H
-#define _SYSEFI_H
-#include <Protocol/SimpleFileSystem.h>
-
-#define EFI_FILE_MODE_MASK ( EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE )
-#define OMODE_MASK 0xFFFF00UL
-#define OMODE_SHIFT 8
-
-#define S_ACC_READ ( S_IRUSR | S_IRGRP | S_IROTH | S_IXUSR | S_IXGRP | S_IXOTH )
-#define S_ACC_WRITE ( S_IWUSR | S_IWGRP | S_IWOTH )
-#define S_ACC_MASK ( S_IRWXU | S_IRWXG | S_IRWXO )
-
-UINT64
-Oflags2EFI( int oflags);
-
-UINT64
-Omode2EFI( int mode);
-
-/* Converts the first several EFI status values into the appropriate errno value.
-*/
-int
-EFI2errno( RETURN_STATUS Status);
-
-#endif /* _SYSEFI_H */
diff --git a/StdLib/LibC/Uefi/Uefi.inf b/StdLib/LibC/Uefi/Uefi.inf index ca6437abe0..084d6c4fc3 100644 --- a/StdLib/LibC/Uefi/Uefi.inf +++ b/StdLib/LibC/Uefi/Uefi.inf @@ -1,7 +1,7 @@ ## @file
# Standard C library: UEFI "system calls".
#
-# Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2010 - 2011, 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
@@ -28,7 +28,6 @@ [Sources]
SysCalls.c
Xform.c
- Console.c
[Packages]
StdLib/StdLib.dec
@@ -47,3 +46,4 @@ LibLocale
LibString
LibTime
+ DevUtility
diff --git a/StdLib/LibC/Uefi/Xform.c b/StdLib/LibC/Uefi/Xform.c index 21eff6fb9d..6b15da3563 100644 --- a/StdLib/LibC/Uefi/Xform.c +++ b/StdLib/LibC/Uefi/Xform.c @@ -1,7 +1,7 @@ /** @file
Value transformations between stdio and the UEFI environment.
- Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2010 - 2011, 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 that accompanies this distribution.
The full text of the license may be found at
@@ -18,7 +18,7 @@ #include <errno.h>
#include <fcntl.h>
-#include "SysEfi.h"
+#include <Efi/SysEfi.h>
/** Translate the Open flags into a Uefi Open Modes value.
@@ -44,6 +44,10 @@ Oflags2EFI( int oflags ) // Build the Open Modes
flags = (UINT64)((oflags & O_ACCMODE) + 1); // Handle the Read/Write flags
+ if(flags & EFI_FILE_MODE_WRITE) { // Asking for write only?
+ // EFI says the only two RW modes are read-only and read+write.
+ flags = EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE;
+ }
if(oflags & (O_CREAT | O_TRUNC)) { // Now add the Create flag.
// Also added if O_TRUNC set since we will need to create a new file.
// We just set the flags here since the only valid EFI mode with create
|