3 Copyright (c) 2006 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14 UnixSimpleFileSystem.c
18 Produce Simple File System abstractions for directories on your PC using Posix APIs.
19 The configuration of what devices to mount or emulate comes from UNIX
20 environment variables. The variables must be visible to the Microsoft*
21 Developer Studio for them to work.
23 * Other names and brands may be claimed as the property of others.
27 #include "UnixSimpleFileSystem.h"
29 EFI_DRIVER_BINDING_PROTOCOL gUnixSimpleFileSystemDriverBinding
= {
30 UnixSimpleFileSystemDriverBindingSupported
,
31 UnixSimpleFileSystemDriverBindingStart
,
32 UnixSimpleFileSystemDriverBindingStop
,
48 Locate the first occurance of a character in a string.
52 Str - Pointer to NULL terminated unicode string.
53 Chr - Character to locate.
57 If Str is NULL, then NULL is returned.
58 If Chr is not contained in Str, then NULL is returned.
59 If Chr is contained in Str, then a pointer to the first occurance of Chr in Str is returned.
67 while (*Str
!= '\0' && *Str
!= Chr
) {
71 return (*Str
== Chr
) ? Str
: NULL
;
83 TODO: Add function description
87 Buffer - TODO: add argument description
88 Length - TODO: add argument description
92 TODO: add return values
96 if (Buffer
== NULL
|| Length
== 0) {
100 if (*(UINT8
*) Buffer
!= 0) {
105 if (!CompareMem (Buffer
, (UINT8
*) Buffer
+ 1, Length
- 1)) {
122 TODO: Add function description
126 Str - TODO: add argument description
127 Count - TODO: add argument description
131 TODO: add return values
137 if (AsciiStrLen (Str
) < Count
) {
141 for (Pointer
= Str
; *(Pointer
+ Count
); Pointer
++) {
142 *Pointer
= *(Pointer
+ Count
);
145 *Pointer
= *(Pointer
+ Count
);
152 UnixSimpleFileSystemDriverBindingSupported (
153 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
154 IN EFI_HANDLE ControllerHandle
,
155 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
161 Check to see if the driver supports a given controller.
165 This - A pointer to an instance of the EFI_DRIVER_BINDING_PROTOCOL.
167 ControllerHandle - EFI handle of the controller to test.
169 RemainingDevicePath - Pointer to remaining portion of a device path.
173 EFI_SUCCESS - The device specified by ControllerHandle and RemainingDevicePath is supported by the driver
176 EFI_ALREADY_STARTED - The device specified by ControllerHandle and RemainingDevicePath is already being managed by
177 the driver specified by This.
179 EFI_ACCESS_DENIED - The device specified by ControllerHandle and RemainingDevicePath is already being managed by
180 a different driver or an application that requires exclusive access.
182 EFI_UNSUPPORTED - The device specified by ControllerHandle and RemainingDevicePath is not supported by the
183 driver specified by This.
188 EFI_UNIX_IO_PROTOCOL
*UnixIo
;
191 // Open the IO Abstraction(s) needed to perform the supported test
193 Status
= gBS
->OpenProtocol (
195 &gEfiUnixIoProtocolGuid
,
197 This
->DriverBindingHandle
,
199 EFI_OPEN_PROTOCOL_BY_DRIVER
201 if (EFI_ERROR (Status
)) {
206 // Make sure GUID is for a File System handle.
208 Status
= EFI_UNSUPPORTED
;
209 if (CompareGuid (UnixIo
->TypeGuid
, &gEfiUnixFileSystemGuid
)) {
210 Status
= EFI_SUCCESS
;
214 // Close the I/O Abstraction(s) used to perform the supported test
218 &gEfiUnixIoProtocolGuid
,
219 This
->DriverBindingHandle
,
228 UnixSimpleFileSystemDriverBindingStart (
229 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
230 IN EFI_HANDLE ControllerHandle
,
231 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
237 Starts a device controller or a bus controller.
241 This - A pointer to an instance of the EFI_DRIVER_BINDING_PROTOCOL.
243 ControllerHandle - EFI handle of the controller to start.
245 RemainingDevicePath - Pointer to remaining portion of a device path.
249 EFI_SUCCESS - The device or bus controller has been started.
251 EFI_DEVICE_ERROR - The device could not be started due to a device failure.
253 EFI_OUT_OF_RESOURCES - The request could not be completed due to lack of resources.
258 EFI_UNIX_IO_PROTOCOL
*UnixIo
;
259 UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
*Private
;
265 // Open the IO Abstraction(s) needed
267 Status
= gBS
->OpenProtocol (
269 &gEfiUnixIoProtocolGuid
,
271 This
->DriverBindingHandle
,
273 EFI_OPEN_PROTOCOL_BY_DRIVER
275 if (EFI_ERROR (Status
)) {
282 if (!CompareGuid (UnixIo
->TypeGuid
, &gEfiUnixFileSystemGuid
)) {
283 Status
= EFI_UNSUPPORTED
;
287 Status
= gBS
->AllocatePool (
289 sizeof (UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
),
292 if (EFI_ERROR (Status
)) {
296 Private
->Signature
= UNIX_SIMPLE_FILE_SYSTEM_PRIVATE_SIGNATURE
;
297 Private
->UnixThunk
= UnixIo
->UnixThunk
;
298 Private
->FilePath
= NULL
;
299 Private
->VolumeLabel
= NULL
;
301 Status
= gBS
->AllocatePool (
303 StrLen (UnixIo
->EnvString
) + 1,
304 (VOID
**)&Private
->FilePath
307 if (EFI_ERROR (Status
)) {
311 for (i
= 0; UnixIo
->EnvString
[i
] != 0; i
++)
312 Private
->FilePath
[i
] = UnixIo
->EnvString
[i
];
313 Private
->FilePath
[i
] = 0;
315 Private
->VolumeLabel
= NULL
;
316 Status
= gBS
->AllocatePool (
318 StrSize (L
"EFI_EMULATED"),
319 (VOID
**)&Private
->VolumeLabel
322 if (EFI_ERROR (Status
)) {
326 StrCpy (Private
->VolumeLabel
, L
"EFI_EMULATED");
328 Private
->SimpleFileSystem
.Revision
= EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION
;
329 Private
->SimpleFileSystem
.OpenVolume
= UnixSimpleFileSystemOpenVolume
;
331 Private
->ControllerNameTable
= NULL
;
335 gUnixSimpleFileSystemComponentName
.SupportedLanguages
,
336 &Private
->ControllerNameTable
,
340 Status
= gBS
->InstallMultipleProtocolInterfaces (
342 &gEfiSimpleFileSystemProtocolGuid
,
343 &Private
->SimpleFileSystem
,
348 if (EFI_ERROR (Status
)) {
350 if (Private
!= NULL
) {
352 if (Private
->VolumeLabel
!= NULL
)
353 gBS
->FreePool (Private
->VolumeLabel
);
354 if (Private
->FilePath
!= NULL
)
355 gBS
->FreePool (Private
->FilePath
);
356 FreeUnicodeStringTable (Private
->ControllerNameTable
);
358 gBS
->FreePool (Private
);
363 &gEfiUnixIoProtocolGuid
,
364 This
->DriverBindingHandle
,
374 UnixSimpleFileSystemDriverBindingStop (
375 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
376 IN EFI_HANDLE ControllerHandle
,
377 IN UINTN NumberOfChildren
,
378 IN EFI_HANDLE
*ChildHandleBuffer
384 TODO: Add function description
388 This - A pointer to an instance of the EFI_DRIVER_BINDING_PROTOCOL.
390 ControllerHandle - A handle to the device to be stopped.
392 NumberOfChildren - The number of child device handles in ChildHandleBuffer.
394 ChildHandleBuffer - An array of child device handles to be freed.
398 EFI_SUCCESS - The device has been stopped.
400 EFI_DEVICE_ERROR - The device could not be stopped due to a device failure.
403 // TODO: EFI_UNSUPPORTED - add return value to function comment
406 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
407 UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
*Private
;
410 // Get our context back
412 Status
= gBS
->OpenProtocol (
414 &gEfiSimpleFileSystemProtocolGuid
,
415 (VOID
**)&SimpleFileSystem
,
416 This
->DriverBindingHandle
,
418 EFI_OPEN_PROTOCOL_GET_PROTOCOL
420 if (EFI_ERROR (Status
)) {
421 return EFI_UNSUPPORTED
;
424 Private
= UNIX_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (SimpleFileSystem
);
427 // Uninstall the Simple File System Protocol from ControllerHandle
429 Status
= gBS
->UninstallMultipleProtocolInterfaces (
431 &gEfiSimpleFileSystemProtocolGuid
,
432 &Private
->SimpleFileSystem
,
435 if (!EFI_ERROR (Status
)) {
436 Status
= gBS
->CloseProtocol (
438 &gEfiUnixIoProtocolGuid
,
439 This
->DriverBindingHandle
,
444 if (!EFI_ERROR (Status
)) {
446 // Free our instance data
448 FreeUnicodeStringTable (Private
->ControllerNameTable
);
450 gBS
->FreePool (Private
);
458 UnixSimpleFileSystemOpenVolume (
459 IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*This
,
466 Open the root directory on a volume.
470 This - A pointer to the volume to open.
472 Root - A pointer to storage for the returned opened file handle of the root directory.
476 EFI_SUCCESS - The volume was opened.
478 EFI_UNSUPPORTED - The volume does not support the requested file system type.
480 EFI_NO_MEDIA - The device has no media.
482 EFI_DEVICE_ERROR - The device reported an error.
484 EFI_VOLUME_CORRUPTED - The file system structures are corrupted.
486 EFI_ACCESS_DENIED - The service denied access to the file.
488 EFI_OUT_OF_RESOURCES - The file volume could not be opened due to lack of resources.
490 EFI_MEDIA_CHANGED - The device has new media or the media is no longer supported.
493 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
496 UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
*Private
;
497 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
500 if (This
== NULL
|| Root
== NULL
) {
501 return EFI_INVALID_PARAMETER
;
503 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
505 Private
= UNIX_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (This
);
508 Status
= gBS
->AllocatePool (
510 sizeof (UNIX_EFI_FILE_PRIVATE
),
511 (VOID
**)&PrivateFile
513 if (EFI_ERROR (Status
)) {
517 PrivateFile
->FileName
= NULL
;
518 Status
= gBS
->AllocatePool (
520 AsciiStrSize (Private
->FilePath
),
521 (VOID
**)&PrivateFile
->FileName
523 if (EFI_ERROR (Status
)) {
527 AsciiStrCpy (PrivateFile
->FileName
, Private
->FilePath
);
528 PrivateFile
->Signature
= UNIX_EFI_FILE_PRIVATE_SIGNATURE
;
529 PrivateFile
->UnixThunk
= Private
->UnixThunk
;
530 PrivateFile
->SimpleFileSystem
= This
;
531 PrivateFile
->IsRootDirectory
= TRUE
;
532 PrivateFile
->IsDirectoryPath
= TRUE
;
533 PrivateFile
->IsOpenedByRead
= TRUE
;
534 PrivateFile
->EfiFile
.Revision
= EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION
;
535 PrivateFile
->EfiFile
.Open
= UnixSimpleFileSystemOpen
;
536 PrivateFile
->EfiFile
.Close
= UnixSimpleFileSystemClose
;
537 PrivateFile
->EfiFile
.Delete
= UnixSimpleFileSystemDelete
;
538 PrivateFile
->EfiFile
.Read
= UnixSimpleFileSystemRead
;
539 PrivateFile
->EfiFile
.Write
= UnixSimpleFileSystemWrite
;
540 PrivateFile
->EfiFile
.GetPosition
= UnixSimpleFileSystemGetPosition
;
541 PrivateFile
->EfiFile
.SetPosition
= UnixSimpleFileSystemSetPosition
;
542 PrivateFile
->EfiFile
.GetInfo
= UnixSimpleFileSystemGetInfo
;
543 PrivateFile
->EfiFile
.SetInfo
= UnixSimpleFileSystemSetInfo
;
544 PrivateFile
->EfiFile
.Flush
= UnixSimpleFileSystemFlush
;
545 PrivateFile
->fd
= -1;
546 PrivateFile
->Dir
= NULL
;
547 PrivateFile
->Dirent
= NULL
;
549 *Root
= &PrivateFile
->EfiFile
;
551 PrivateFile
->Dir
= PrivateFile
->UnixThunk
->OpenDir(PrivateFile
->FileName
);
553 if (PrivateFile
->Dir
== NULL
) {
554 Status
= EFI_ACCESS_DENIED
;
557 Status
= EFI_SUCCESS
;
561 if (EFI_ERROR (Status
)) {
563 if (PrivateFile
->FileName
) {
564 gBS
->FreePool (PrivateFile
->FileName
);
567 gBS
->FreePool (PrivateFile
);
571 gBS
->RestoreTPL (OldTpl
);
578 UnixSimpleFileSystemOpen (
580 OUT EFI_FILE
**NewHandle
,
589 Open a file relative to the source file location.
593 This - A pointer to the source file location.
595 NewHandle - Pointer to storage for the new file handle.
597 FileName - Pointer to the file name to be opened.
599 OpenMode - File open mode information.
601 Attributes - File creation attributes.
605 EFI_SUCCESS - The file was opened.
607 EFI_NOT_FOUND - The file could not be found in the volume.
609 EFI_NO_MEDIA - The device has no media.
611 EFI_MEDIA_CHANGED - The device has new media or the media is no longer supported.
613 EFI_DEVICE_ERROR - The device reported an error.
615 EFI_VOLUME_CORRUPTED - The file system structures are corrupted.
617 EFI_WRITE_PROTECTED - The volume or file is write protected.
619 EFI_ACCESS_DENIED - The service denied access to the file.
621 EFI_OUT_OF_RESOURCES - Not enough resources were available to open the file.
623 EFI_VOLUME_FULL - There is not enough space left to create the new file.
626 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
627 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
628 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
629 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
632 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
633 UNIX_EFI_FILE_PRIVATE
*NewPrivateFile
;
634 UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
*PrivateRoot
;
643 BOOLEAN TrailingDash
;
648 TrailingDash
= FALSE
;
651 // Check for obvious invalid parameters.
653 if (This
== NULL
|| NewHandle
== NULL
|| FileName
== NULL
) {
654 return EFI_INVALID_PARAMETER
;
658 case EFI_FILE_MODE_CREATE
| EFI_FILE_MODE_READ
| EFI_FILE_MODE_WRITE
:
659 if (Attributes
&~EFI_FILE_VALID_ATTR
) {
660 return EFI_INVALID_PARAMETER
;
663 if (Attributes
& EFI_FILE_READ_ONLY
) {
664 return EFI_INVALID_PARAMETER
;
670 case EFI_FILE_MODE_READ
:
671 case EFI_FILE_MODE_READ
| EFI_FILE_MODE_WRITE
:
675 return EFI_INVALID_PARAMETER
;
679 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
680 PrivateRoot
= UNIX_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (PrivateFile
->SimpleFileSystem
);
681 NewPrivateFile
= NULL
;
684 // BUGBUG: assume an open of root
685 // if current location, return current data
687 if (StrCmp (FileName
, L
"\\") == 0
688 || (StrCmp (FileName
, L
".") == 0 && PrivateFile
->IsRootDirectory
)) {
690 // BUGBUG: assume an open root
693 Status
= UnixSimpleFileSystemOpenVolume (PrivateFile
->SimpleFileSystem
, &Root
);
694 NewPrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (Root
);
698 if (FileName
[StrLen (FileName
) - 1] == L
'\\') {
700 FileName
[StrLen (FileName
) - 1] = 0;
704 // Attempt to open the file
706 Status
= gBS
->AllocatePool (
708 sizeof (UNIX_EFI_FILE_PRIVATE
),
709 (VOID
**)&NewPrivateFile
712 if (EFI_ERROR (Status
)) {
716 CopyMem (NewPrivateFile
, PrivateFile
, sizeof (UNIX_EFI_FILE_PRIVATE
));
718 NewPrivateFile
->FileName
= NULL
;
719 Status
= gBS
->AllocatePool (
721 AsciiStrSize (PrivateFile
->FileName
) + 1 + StrLen (FileName
) + 1,
722 (VOID
**)&NewPrivateFile
->FileName
725 if (EFI_ERROR (Status
)) {
729 if (*FileName
== L
'\\') {
730 AsciiStrCpy (NewPrivateFile
->FileName
, PrivateRoot
->FilePath
);
734 AsciiStrCpy (NewPrivateFile
->FileName
, PrivateFile
->FileName
);
737 Dst
= NewPrivateFile
->FileName
+ AsciiStrLen(NewPrivateFile
->FileName
);
738 GuardPointer
= NewPrivateFile
->FileName
+ AsciiStrLen(PrivateRoot
->FilePath
);
740 // Convert unicode to ascii and '\' to '/'
752 // Get rid of . and .., except leading . or ..
756 // GuardPointer protect simplefilesystem root path not be destroyed
761 while (!LoopFinish
) {
765 for (ParseFileName
= GuardPointer
; *ParseFileName
; ParseFileName
++) {
766 if (*ParseFileName
== '.' &&
767 (*(ParseFileName
+ 1) == 0 || *(ParseFileName
+ 1) == '/') &&
768 *(ParseFileName
- 1) == '/'
774 CutPrefix (ParseFileName
- 1, 2);
779 if (*ParseFileName
== '.' &&
780 *(ParseFileName
+ 1) == '.' &&
781 (*(ParseFileName
+ 2) == 0 || *(ParseFileName
+ 2) == '/') &&
782 *(ParseFileName
- 1) == '/'
788 while (ParseFileName
!= GuardPointer
) {
791 if (*ParseFileName
== '/') {
797 // cut /.. and its left directory
799 CutPrefix (ParseFileName
, Count
);
806 if (AsciiStrCmp (NewPrivateFile
->FileName
, PrivateRoot
->FilePath
) == 0) {
807 NewPrivateFile
->IsRootDirectory
= TRUE
;
808 gBS
->FreePool (NewPrivateFile
->FileName
);
809 gBS
->FreePool (NewPrivateFile
);
813 RealFileName
= NewPrivateFile
->FileName
+ AsciiStrLen(NewPrivateFile
->FileName
) - 1;
814 while (RealFileName
> NewPrivateFile
->FileName
&& *RealFileName
!= '/')
817 TempChar
= *(RealFileName
- 1);
818 *(RealFileName
- 1) = 0;
820 *(RealFileName
- 1) = TempChar
;
825 // Test whether file or directory
827 NewPrivateFile
->IsRootDirectory
= FALSE
;
828 NewPrivateFile
->fd
= -1;
829 NewPrivateFile
->Dir
= NULL
;
830 if (OpenMode
& EFI_FILE_MODE_CREATE
) {
831 if (Attributes
& EFI_FILE_DIRECTORY
) {
832 NewPrivateFile
->IsDirectoryPath
= TRUE
;
834 NewPrivateFile
->IsDirectoryPath
= FALSE
;
838 int res
= NewPrivateFile
->UnixThunk
->Stat (NewPrivateFile
->FileName
, &finfo
);
839 if (res
== 0 && S_ISDIR(finfo
.st_mode
))
840 NewPrivateFile
->IsDirectoryPath
= TRUE
;
842 NewPrivateFile
->IsDirectoryPath
= FALSE
;
845 if (OpenMode
& EFI_FILE_MODE_WRITE
) {
846 NewPrivateFile
->IsOpenedByRead
= FALSE
;
848 NewPrivateFile
->IsOpenedByRead
= TRUE
;
851 Status
= EFI_SUCCESS
;
854 // deal with directory
856 if (NewPrivateFile
->IsDirectoryPath
) {
858 if ((OpenMode
& EFI_FILE_MODE_CREATE
)) {
860 // Create a directory
862 if (NewPrivateFile
->UnixThunk
->MkDir (NewPrivateFile
->FileName
, 0777) != 0) {
865 LastError
= PrivateFile
->UnixThunk
->GetErrno ();
866 if (LastError
!= EEXIST
) {
867 //gBS->FreePool (TempFileName);
868 Status
= EFI_ACCESS_DENIED
;
874 NewPrivateFile
->Dir
= NewPrivateFile
->UnixThunk
->OpenDir
875 (NewPrivateFile
->FileName
);
877 if (NewPrivateFile
->Dir
== NULL
) {
878 if (PrivateFile
->UnixThunk
->GetErrno () == EACCES
) {
879 Status
= EFI_ACCESS_DENIED
;
881 Status
= EFI_NOT_FOUND
;
891 NewPrivateFile
->fd
= NewPrivateFile
->UnixThunk
->Open
892 (NewPrivateFile
->FileName
,
893 ((OpenMode
& EFI_FILE_MODE_CREATE
) ? O_CREAT
: 0)
894 | (NewPrivateFile
->IsOpenedByRead
? O_RDONLY
: O_RDWR
),
896 if (NewPrivateFile
->fd
< 0) {
897 if (PrivateFile
->UnixThunk
->GetErrno () == ENOENT
) {
898 Status
= EFI_NOT_FOUND
;
900 Status
= EFI_ACCESS_DENIED
;
905 if ((OpenMode
& EFI_FILE_MODE_CREATE
) && Status
== EFI_SUCCESS
) {
912 Status
= UnixSimpleFileSystemGetInfo (&NewPrivateFile
->EfiFile
, &gEfiFileInfoGuid
, &InfoSize
, Info
);
914 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
915 Status
= EFI_DEVICE_ERROR
;
919 Status
= gBS
->AllocatePool (
925 if (EFI_ERROR (Status
)) {
929 Status
= UnixSimpleFileSystemGetInfo (&NewPrivateFile
->EfiFile
, &gEfiFileInfoGuid
, &InfoSize
, Info
);
931 if (EFI_ERROR (Status
)) {
935 Info
->Attribute
= Attributes
;
937 UnixSimpleFileSystemSetInfo (&NewPrivateFile
->EfiFile
, &gEfiFileInfoGuid
, InfoSize
, Info
);
942 FileName
[StrLen (FileName
) + 1] = 0;
943 FileName
[StrLen (FileName
)] = L
'\\';
946 if (EFI_ERROR (Status
)) {
947 if (NewPrivateFile
) {
948 if (NewPrivateFile
->FileName
) {
949 gBS
->FreePool (NewPrivateFile
->FileName
);
952 gBS
->FreePool (NewPrivateFile
);
955 *NewHandle
= &NewPrivateFile
->EfiFile
;
963 UnixSimpleFileSystemClose (
970 Close the specified file handle.
974 This - Pointer to a returned opened file handle.
978 EFI_SUCCESS - The file handle has been closed.
981 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
983 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
987 return EFI_INVALID_PARAMETER
;
990 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
992 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
994 if (PrivateFile
->fd
>= 0) {
995 PrivateFile
->UnixThunk
->Close (PrivateFile
->fd
);
997 if (PrivateFile
->Dir
!= NULL
) {
998 PrivateFile
->UnixThunk
->CloseDir (PrivateFile
->Dir
);
1001 PrivateFile
->fd
= -1;
1002 PrivateFile
->Dir
= NULL
;
1004 if (PrivateFile
->FileName
) {
1005 gBS
->FreePool (PrivateFile
->FileName
);
1008 gBS
->FreePool (PrivateFile
);
1010 gBS
->RestoreTPL (OldTpl
);
1017 UnixSimpleFileSystemDelete (
1022 Routine Description:
1024 Close and delete a file.
1028 This - Pointer to a returned opened file handle.
1032 EFI_SUCCESS - The file handle was closed and deleted.
1034 EFI_WARN_DELETE_FAILURE - The handle was closed but could not be deleted.
1037 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1040 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1044 return EFI_INVALID_PARAMETER
;
1047 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1049 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1051 Status
= EFI_WARN_DELETE_FAILURE
;
1053 if (PrivateFile
->IsDirectoryPath
) {
1054 if (PrivateFile
->Dir
!= NULL
) {
1055 PrivateFile
->UnixThunk
->CloseDir (PrivateFile
->Dir
);
1056 PrivateFile
->Dir
= NULL
;
1059 if (PrivateFile
->UnixThunk
->RmDir (PrivateFile
->FileName
) == 0) {
1060 Status
= EFI_SUCCESS
;
1063 PrivateFile
->UnixThunk
->Close (PrivateFile
->fd
);
1064 PrivateFile
->fd
= -1;
1066 if (!PrivateFile
->IsOpenedByRead
) {
1067 if (!PrivateFile
->UnixThunk
->UnLink (PrivateFile
->FileName
)) {
1068 Status
= EFI_SUCCESS
;
1073 gBS
->FreePool (PrivateFile
->FileName
);
1074 gBS
->FreePool (PrivateFile
);
1076 gBS
->RestoreTPL (OldTpl
);
1082 UnixSystemTimeToEfiTime (
1083 EFI_UNIX_THUNK_PROTOCOL
*UnixThunk
,
1084 IN
time_t SystemTime
,
1089 Routine Description:
1091 TODO: Add function description
1095 SystemTime - TODO: add argument description
1096 TimeZone - TODO: add argument description
1097 Time - TODO: add argument description
1101 TODO: add return values
1106 tm
= UnixThunk
->GmTime (&SystemTime
);
1107 Time
->Year
= tm
->tm_year
;
1108 Time
->Month
= tm
->tm_mon
;
1109 Time
->Day
= tm
->tm_mday
;
1110 Time
->Hour
= tm
->tm_hour
;
1111 Time
->Minute
= tm
->tm_min
;
1112 Time
->Second
= tm
->tm_sec
;
1113 Time
->Nanosecond
= 0;
1115 Time
->TimeZone
= UnixThunk
->GetTimeZone ();
1117 if (UnixThunk
->GetDayLight ()) {
1118 Time
->Daylight
= EFI_TIME_ADJUST_DAYLIGHT
;
1123 UnixSimpleFileSystemFileInfo (
1124 UNIX_EFI_FILE_PRIVATE
*PrivateFile
,
1126 IN OUT UINTN
*BufferSize
,
1131 Routine Description:
1133 TODO: Add function description
1137 PrivateFile - TODO: add argument description
1138 BufferSize - TODO: add argument description
1139 Buffer - TODO: add argument description
1143 TODO: add return values
1151 EFI_FILE_INFO
*Info
;
1152 CHAR8
*RealFileName
;
1154 CHAR16
*BufferFileName
;
1157 if (FileName
!= NULL
) {
1158 RealFileName
= FileName
;
1160 else if (PrivateFile
->IsRootDirectory
) {
1163 RealFileName
= PrivateFile
->FileName
;
1166 TempPointer
= RealFileName
;
1167 while (*TempPointer
) {
1168 if (*TempPointer
== '/') {
1169 RealFileName
= TempPointer
+ 1;
1175 Size
= SIZE_OF_EFI_FILE_INFO
;
1176 NameSize
= AsciiStrSize (RealFileName
) * 2;
1177 ResultSize
= Size
+ NameSize
;
1179 if (*BufferSize
< ResultSize
) {
1180 *BufferSize
= ResultSize
;
1181 return EFI_BUFFER_TOO_SMALL
;
1183 if (PrivateFile
->UnixThunk
->Stat (
1184 FileName
== NULL
? PrivateFile
->FileName
: FileName
,
1186 return EFI_DEVICE_ERROR
;
1188 Status
= EFI_SUCCESS
;
1191 ZeroMem (Info
, ResultSize
);
1193 Info
->Size
= ResultSize
;
1194 Info
->FileSize
= buf
.st_size
;
1195 Info
->PhysicalSize
= MultU64x32 (buf
.st_blocks
, buf
.st_blksize
);
1197 UnixSystemTimeToEfiTime (PrivateFile
->UnixThunk
, buf
.st_ctime
, &Info
->CreateTime
);
1198 UnixSystemTimeToEfiTime (PrivateFile
->UnixThunk
, buf
.st_atime
, &Info
->LastAccessTime
);
1199 UnixSystemTimeToEfiTime (PrivateFile
->UnixThunk
, buf
.st_mtime
, &Info
->ModificationTime
);
1201 if (!(buf
.st_mode
& S_IWUSR
)) {
1202 Info
->Attribute
|= EFI_FILE_READ_ONLY
;
1205 if (S_ISDIR(buf
.st_mode
)) {
1206 Info
->Attribute
|= EFI_FILE_DIRECTORY
;
1210 BufferFileName
= (CHAR16
*)((CHAR8
*) Buffer
+ Size
);
1211 while (*RealFileName
)
1212 *BufferFileName
++ = *RealFileName
++;
1213 *BufferFileName
= 0;
1215 *BufferSize
= ResultSize
;
1221 UnixSimpleFileSystemRead (
1223 IN OUT UINTN
*BufferSize
,
1228 Routine Description:
1230 Read data from a file.
1234 This - Pointer to a returned open file handle.
1236 BufferSize - On input, the size of the Buffer. On output, the number of bytes stored in the Buffer.
1238 Buffer - Pointer to the first byte of the read Buffer.
1242 EFI_SUCCESS - The data was read.
1244 EFI_NO_MEDIA - The device has no media.
1246 EFI_DEVICE_ERROR - The device reported an error.
1248 EFI_VOLUME_CORRUPTED - The file system structures are corrupted.
1250 EFI_BUFFER_TOO_SMALL - The supplied buffer size was too small to store the current directory entry.
1251 *BufferSize has been updated with the size needed to complete the request.
1254 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1256 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1262 CHAR8
*FullFileName
;
1265 if (This
== NULL
|| BufferSize
== NULL
|| Buffer
== NULL
) {
1266 return EFI_INVALID_PARAMETER
;
1269 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1271 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1273 if (!PrivateFile
->IsDirectoryPath
) {
1275 if (PrivateFile
->fd
< 0) {
1276 Status
= EFI_DEVICE_ERROR
;
1280 Res
= PrivateFile
->UnixThunk
->Read (
1285 Status
= EFI_DEVICE_ERROR
;
1289 Status
= EFI_SUCCESS
;
1294 // Read on a directory.
1296 if (PrivateFile
->Dir
== NULL
) {
1297 Status
= EFI_DEVICE_ERROR
;
1301 if (PrivateFile
->Dirent
== NULL
) {
1302 PrivateFile
->Dirent
= PrivateFile
->UnixThunk
->ReadDir (PrivateFile
->Dir
);
1303 if (PrivateFile
->Dirent
== NULL
) {
1305 Status
= EFI_SUCCESS
;
1310 Size
= SIZE_OF_EFI_FILE_INFO
;
1311 NameSize
= AsciiStrLen (PrivateFile
->Dirent
->d_name
) + 1;
1312 ResultSize
= Size
+ 2 * NameSize
;
1314 if (*BufferSize
< ResultSize
) {
1315 *BufferSize
= ResultSize
;
1316 Status
= EFI_BUFFER_TOO_SMALL
;
1319 Status
= EFI_SUCCESS
;
1321 *BufferSize
= ResultSize
;
1323 Status
= gBS
->AllocatePool (
1324 EfiBootServicesData
,
1325 AsciiStrLen(PrivateFile
->FileName
) + 1 + NameSize
,
1326 (VOID
**)&FullFileName
1329 if (EFI_ERROR (Status
)) {
1333 AsciiStrCpy(FullFileName
, PrivateFile
->FileName
);
1334 AsciiStrCat(FullFileName
, "/");
1335 AsciiStrCat(FullFileName
, PrivateFile
->Dirent
->d_name
);
1336 Status
= UnixSimpleFileSystemFileInfo (PrivateFile
,
1340 gBS
->FreePool (FullFileName
);
1342 PrivateFile
->Dirent
= NULL
;
1345 gBS
->RestoreTPL (OldTpl
);
1352 UnixSimpleFileSystemWrite (
1354 IN OUT UINTN
*BufferSize
,
1359 Routine Description:
1361 Write data to a file.
1365 This - Pointer to an opened file handle.
1367 BufferSize - On input, the number of bytes in the Buffer to write to the file. On output, the number of bytes
1368 of data written to the file.
1370 Buffer - Pointer to the first by of data in the buffer to write to the file.
1374 EFI_SUCCESS - The data was written to the file.
1376 EFI_UNSUPPORTED - Writes to an open directory are not supported.
1378 EFI_NO_MEDIA - The device has no media.
1380 EFI_DEVICE_ERROR - The device reported an error.
1382 EFI_VOLUME_CORRUPTED - The file system structures are corrupt.
1384 EFI_WRITE_PROTECTED - The file, directory, volume, or device is write protected.
1386 EFI_ACCESS_DENIED - The file was opened read-only.
1388 EFI_VOLUME_FULL - The volume is full.
1391 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1393 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1398 if (This
== NULL
|| BufferSize
== NULL
|| Buffer
== NULL
) {
1399 return EFI_INVALID_PARAMETER
;
1402 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1404 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1406 if (PrivateFile
->fd
< 0) {
1407 return EFI_DEVICE_ERROR
;
1410 if (PrivateFile
->IsDirectoryPath
) {
1411 return EFI_UNSUPPORTED
;
1414 if (PrivateFile
->IsOpenedByRead
) {
1415 return EFI_ACCESS_DENIED
;
1418 Res
= PrivateFile
->UnixThunk
->Write (
1422 if (Res
== (UINTN
)-1) {
1423 Status
= EFI_DEVICE_ERROR
;
1427 Status
= EFI_SUCCESS
;
1430 gBS
->RestoreTPL (OldTpl
);
1434 // bugbug: need to access unix error reporting
1440 UnixSimpleFileSystemSetPosition (
1446 Routine Description:
1448 Set a file's current position.
1452 This - Pointer to an opened file handle.
1454 Position - The byte position from the start of the file to set.
1458 EFI_SUCCESS - The file position has been changed.
1460 EFI_UNSUPPORTED - The seek request for non-zero is not supported for directories.
1463 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1466 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1471 return EFI_INVALID_PARAMETER
;
1474 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1476 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1478 if (PrivateFile
->IsDirectoryPath
) {
1479 if (Position
!= 0) {
1480 Status
= EFI_UNSUPPORTED
;
1484 if (PrivateFile
->Dir
== NULL
) {
1485 Status
= EFI_DEVICE_ERROR
;
1488 PrivateFile
->UnixThunk
->RewindDir (PrivateFile
->Dir
);
1489 Status
= EFI_SUCCESS
;
1492 if (Position
== (UINT64
) -1) {
1493 Pos
= PrivateFile
->UnixThunk
->Lseek (PrivateFile
->fd
, 0, SEEK_END
);
1495 Pos
= PrivateFile
->UnixThunk
->Lseek (PrivateFile
->fd
, Position
, SEEK_SET
);
1497 Status
= (Pos
== (UINT64
) -1) ? EFI_DEVICE_ERROR
: EFI_SUCCESS
;
1501 gBS
->RestoreTPL (OldTpl
);
1507 UnixSimpleFileSystemGetPosition (
1509 OUT UINT64
*Position
1513 Routine Description:
1515 Get a file's current position.
1519 This - Pointer to an opened file handle.
1521 Position - Pointer to storage for the current position.
1525 EFI_SUCCESS - The file position has been reported.
1527 EFI_UNSUPPORTED - Not valid for directories.
1530 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1533 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1536 if (This
== NULL
|| Position
== NULL
) {
1537 return EFI_INVALID_PARAMETER
;
1540 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1542 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1544 if (PrivateFile
->IsDirectoryPath
) {
1545 Status
= EFI_UNSUPPORTED
;
1547 *Position
= PrivateFile
->UnixThunk
->Lseek (PrivateFile
->fd
, 0, SEEK_CUR
);
1548 Status
= (*Position
== (UINT64
) -1) ? EFI_DEVICE_ERROR
: EFI_SUCCESS
;
1551 gBS
->RestoreTPL (OldTpl
);
1557 UnixSimpleFileSystemGetInfo (
1559 IN EFI_GUID
*InformationType
,
1560 IN OUT UINTN
*BufferSize
,
1565 Routine Description:
1567 Return information about a file or volume.
1571 This - Pointer to an opened file handle.
1573 InformationType - GUID describing the type of information to be returned.
1575 BufferSize - On input, the size of the information buffer. On output, the number of bytes written to the
1578 Buffer - Pointer to the first byte of the information buffer.
1582 EFI_SUCCESS - The requested information has been written into the buffer.
1584 EFI_UNSUPPORTED - The InformationType is not known.
1586 EFI_NO_MEDIA - The device has no media.
1588 EFI_DEVICE_ERROR - The device reported an error.
1590 EFI_VOLUME_CORRUPTED - The file system structures are corrupt.
1592 EFI_BUFFER_TOO_SMALL - The buffer size was too small to contain the requested information. The buffer size has
1593 been updated with the size needed to complete the requested operation.
1596 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1599 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1600 EFI_FILE_SYSTEM_INFO
*FileSystemInfoBuffer
;
1602 UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
*PrivateRoot
;
1606 if (This
== NULL
|| InformationType
== NULL
|| BufferSize
== NULL
) {
1607 return EFI_INVALID_PARAMETER
;
1610 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1612 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1613 PrivateRoot
= UNIX_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (PrivateFile
->SimpleFileSystem
);
1615 Status
= EFI_UNSUPPORTED
;
1617 if (CompareGuid (InformationType
, &gEfiFileInfoGuid
)) {
1618 Status
= UnixSimpleFileSystemFileInfo (PrivateFile
, NULL
, BufferSize
, Buffer
);
1619 } else if (CompareGuid (InformationType
, &gEfiFileSystemInfoGuid
)) {
1620 if (*BufferSize
< SIZE_OF_EFI_FILE_SYSTEM_INFO
+ StrSize (PrivateRoot
->VolumeLabel
)) {
1621 *BufferSize
= SIZE_OF_EFI_FILE_SYSTEM_INFO
+ StrSize (PrivateRoot
->VolumeLabel
);
1622 Status
= EFI_BUFFER_TOO_SMALL
;
1626 UnixStatus
= PrivateFile
->UnixThunk
->StatFs (PrivateFile
->FileName
, &buf
);
1627 if (UnixStatus
< 0) {
1628 Status
= EFI_DEVICE_ERROR
;
1632 FileSystemInfoBuffer
= (EFI_FILE_SYSTEM_INFO
*) Buffer
;
1633 FileSystemInfoBuffer
->Size
= SIZE_OF_EFI_FILE_SYSTEM_INFO
+ StrSize (PrivateRoot
->VolumeLabel
);
1634 FileSystemInfoBuffer
->ReadOnly
= FALSE
;
1639 FileSystemInfoBuffer
->VolumeSize
= MultU64x32 (buf
.f_blocks
, buf
.f_bsize
);
1640 FileSystemInfoBuffer
->FreeSpace
= MultU64x32 (buf
.f_bavail
, buf
.f_bsize
);
1641 FileSystemInfoBuffer
->BlockSize
= buf
.f_bsize
;
1644 StrCpy ((CHAR16
*) FileSystemInfoBuffer
->VolumeLabel
, PrivateRoot
->VolumeLabel
);
1645 *BufferSize
= SIZE_OF_EFI_FILE_SYSTEM_INFO
+ StrSize (PrivateRoot
->VolumeLabel
);
1646 Status
= EFI_SUCCESS
;
1647 } else if (CompareGuid (InformationType
, &gEfiFileSystemVolumeLabelInfoIdGuid
)) {
1648 if (*BufferSize
< StrSize (PrivateRoot
->VolumeLabel
)) {
1649 *BufferSize
= StrSize (PrivateRoot
->VolumeLabel
);
1650 Status
= EFI_BUFFER_TOO_SMALL
;
1654 StrCpy ((CHAR16
*) Buffer
, PrivateRoot
->VolumeLabel
);
1655 *BufferSize
= StrSize (PrivateRoot
->VolumeLabel
);
1656 Status
= EFI_SUCCESS
;
1660 gBS
->RestoreTPL (OldTpl
);
1666 UnixSimpleFileSystemSetInfo (
1668 IN EFI_GUID
*InformationType
,
1669 IN UINTN BufferSize
,
1674 Routine Description:
1676 Set information about a file or volume.
1680 This - Pointer to an opened file handle.
1682 InformationType - GUID identifying the type of information to set.
1684 BufferSize - Number of bytes of data in the information buffer.
1686 Buffer - Pointer to the first byte of data in the information buffer.
1690 EFI_SUCCESS - The file or volume information has been updated.
1692 EFI_UNSUPPORTED - The information identifier is not recognised.
1694 EFI_NO_MEDIA - The device has no media.
1696 EFI_DEVICE_ERROR - The device reported an error.
1698 EFI_VOLUME_CORRUPTED - The file system structures are corrupt.
1700 EFI_WRITE_PROTECTED - The file, directory, volume, or device is write protected.
1702 EFI_ACCESS_DENIED - The file was opened read-only.
1704 EFI_VOLUME_FULL - The volume is full.
1706 EFI_BAD_BUFFER_SIZE - The buffer size is smaller than the type indicated by InformationType.
1709 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1710 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
1712 UNIX_SIMPLE_FILE_SYSTEM_PRIVATE
*PrivateRoot
;
1713 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
1714 EFI_FILE_INFO
*OldFileInfo
;
1715 EFI_FILE_INFO
*NewFileInfo
;
1720 struct stat OldAttr
;
1724 BOOLEAN AttrChangeFlag
;
1725 BOOLEAN NameChangeFlag
;
1726 BOOLEAN SizeChangeFlag
;
1727 BOOLEAN TimeChangeFlag
;
1728 struct tm NewLastAccessSystemTime
;
1729 struct tm NewLastWriteSystemTime
;
1730 EFI_FILE_SYSTEM_INFO
*NewFileSystemInfo
;
1731 CHAR8
*AsciiFilePtr
;
1732 CHAR16
*UnicodeFilePtr
;
1736 // Check for invalid parameters.
1738 if (This
== NULL
|| InformationType
== NULL
|| BufferSize
== 0 || Buffer
== NULL
) {
1739 return EFI_INVALID_PARAMETER
;
1742 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1745 // Initialise locals.
1747 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
1748 PrivateRoot
= UNIX_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (PrivateFile
->SimpleFileSystem
);
1750 Status
= EFI_UNSUPPORTED
;
1751 OldFileInfo
= NewFileInfo
= NULL
;
1752 OldFileName
= NewFileName
= NULL
;
1753 AttrChangeFlag
= NameChangeFlag
= SizeChangeFlag
= TimeChangeFlag
= FALSE
;
1756 // Set file system information.
1758 if (CompareGuid (InformationType
, &gEfiFileSystemInfoGuid
)) {
1759 if (BufferSize
< SIZE_OF_EFI_FILE_SYSTEM_INFO
+ StrSize (PrivateRoot
->VolumeLabel
)) {
1760 Status
= EFI_BAD_BUFFER_SIZE
;
1764 NewFileSystemInfo
= (EFI_FILE_SYSTEM_INFO
*) Buffer
;
1766 gBS
->FreePool (PrivateRoot
->VolumeLabel
);
1768 PrivateRoot
->VolumeLabel
= NULL
;
1769 Status
= gBS
->AllocatePool (
1770 EfiBootServicesData
,
1771 StrSize (NewFileSystemInfo
->VolumeLabel
),
1772 (VOID
**)&PrivateRoot
->VolumeLabel
1775 if (EFI_ERROR (Status
)) {
1779 StrCpy (PrivateRoot
->VolumeLabel
, NewFileSystemInfo
->VolumeLabel
);
1781 Status
= EFI_SUCCESS
;
1786 // Set volume label information.
1788 if (CompareGuid (InformationType
, &gEfiFileSystemVolumeLabelInfoIdGuid
)) {
1789 if (BufferSize
< StrSize (PrivateRoot
->VolumeLabel
)) {
1790 Status
= EFI_BAD_BUFFER_SIZE
;
1794 StrCpy (PrivateRoot
->VolumeLabel
, (CHAR16
*) Buffer
);
1796 Status
= EFI_SUCCESS
;
1800 if (!CompareGuid (InformationType
, &gEfiFileInfoGuid
)) {
1801 Status
= EFI_UNSUPPORTED
;
1805 if (BufferSize
< SIZE_OF_EFI_FILE_INFO
) {
1806 Status
= EFI_BAD_BUFFER_SIZE
;
1811 // Set file/directory information.
1815 // Check for invalid set file information parameters.
1817 NewFileInfo
= (EFI_FILE_INFO
*) Buffer
;
1819 if (NewFileInfo
->Size
<= sizeof (EFI_FILE_INFO
) ||
1820 (NewFileInfo
->Attribute
&~(EFI_FILE_VALID_ATTR
)) ||
1821 (sizeof (UINTN
) == 4 && NewFileInfo
->Size
> 0xFFFFFFFF)
1823 Status
= EFI_INVALID_PARAMETER
;
1828 // bugbug: - This is not safe. We need something like EfiStrMaxSize()
1829 // that would have an additional parameter that would be the size
1830 // of the string array just in case there are no NULL characters in
1831 // the string array.
1834 // Get current file information so we can determine what kind
1835 // of change request this is.
1838 Status
= UnixSimpleFileSystemFileInfo (PrivateFile
, NULL
, &OldInfoSize
, NULL
);
1840 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
1841 Status
= EFI_DEVICE_ERROR
;
1845 Status
= gBS
->AllocatePool (EfiBootServicesData
, OldInfoSize
,
1846 (VOID
**)&OldFileInfo
);
1848 if (EFI_ERROR (Status
)) {
1852 Status
= UnixSimpleFileSystemFileInfo (PrivateFile
, NULL
, &OldInfoSize
, OldFileInfo
);
1854 if (EFI_ERROR (Status
)) {
1858 Status
= gBS
->AllocatePool (
1859 EfiBootServicesData
,
1860 AsciiStrSize (PrivateFile
->FileName
),
1861 (VOID
**)&OldFileName
1864 if (EFI_ERROR (Status
)) {
1868 AsciiStrCpy (OldFileName
, PrivateFile
->FileName
);
1871 // Make full pathname from new filename and rootpath.
1873 if (NewFileInfo
->FileName
[0] == '\\') {
1874 Status
= gBS
->AllocatePool (
1875 EfiBootServicesData
,
1876 AsciiStrLen (PrivateRoot
->FilePath
) + 1 + StrLen (NewFileInfo
->FileName
) + 1,
1877 (VOID
**)&NewFileName
1880 if (EFI_ERROR (Status
)) {
1884 AsciiStrCpy (NewFileName
, PrivateRoot
->FilePath
);
1885 AsciiFilePtr
= NewFileName
+ AsciiStrLen(NewFileName
);
1886 UnicodeFilePtr
= NewFileInfo
->FileName
+ 1;
1887 *AsciiFilePtr
++ ='/';
1889 Status
= gBS
->AllocatePool (
1890 EfiBootServicesData
,
1891 AsciiStrLen (PrivateFile
->FileName
) + 1 + StrLen (NewFileInfo
->FileName
) + 1,
1892 (VOID
**)&NewFileName
1895 if (EFI_ERROR (Status
)) {
1899 AsciiStrCpy (NewFileName
, PrivateRoot
->FilePath
);
1900 AsciiFilePtr
= NewFileName
+ AsciiStrLen(NewFileName
);
1901 while (AsciiFilePtr
> NewFileName
&& AsciiFilePtr
[-1] != '/') {
1904 UnicodeFilePtr
= NewFileInfo
->FileName
;
1906 // Convert to ascii.
1907 while (*UnicodeFilePtr
) {
1908 *AsciiFilePtr
++ = *UnicodeFilePtr
++;
1914 // Is there an attribute change request?
1916 if (NewFileInfo
->Attribute
!= OldFileInfo
->Attribute
) {
1917 if ((NewFileInfo
->Attribute
& EFI_FILE_DIRECTORY
) != (OldFileInfo
->Attribute
& EFI_FILE_DIRECTORY
)) {
1918 Status
= EFI_INVALID_PARAMETER
;
1922 AttrChangeFlag
= TRUE
;
1926 // Is there a name change request?
1927 // bugbug: - Need EfiStrCaseCmp()
1929 if (StrCmp (NewFileInfo
->FileName
, OldFileInfo
->FileName
)) {
1930 NameChangeFlag
= TRUE
;
1934 // Is there a size change request?
1936 if (NewFileInfo
->FileSize
!= OldFileInfo
->FileSize
) {
1937 SizeChangeFlag
= TRUE
;
1941 // Is there a time stamp change request?
1943 if (!IsZero (&NewFileInfo
->CreateTime
, sizeof (EFI_TIME
)) &&
1944 CompareMem (&NewFileInfo
->CreateTime
, &OldFileInfo
->CreateTime
, sizeof (EFI_TIME
))
1946 TimeChangeFlag
= TRUE
;
1947 } else if (!IsZero (&NewFileInfo
->LastAccessTime
, sizeof (EFI_TIME
)) &&
1948 CompareMem (&NewFileInfo
->LastAccessTime
, &OldFileInfo
->LastAccessTime
, sizeof (EFI_TIME
))
1950 TimeChangeFlag
= TRUE
;
1951 } else if (!IsZero (&NewFileInfo
->ModificationTime
, sizeof (EFI_TIME
)) &&
1952 CompareMem (&NewFileInfo
->ModificationTime
, &OldFileInfo
->ModificationTime
, sizeof (EFI_TIME
))
1954 TimeChangeFlag
= TRUE
;
1958 // All done if there are no change requests being made.
1960 if (!(AttrChangeFlag
|| NameChangeFlag
|| SizeChangeFlag
|| TimeChangeFlag
)) {
1961 Status
= EFI_SUCCESS
;
1966 // Set file or directory information.
1968 if (PrivateFile
->UnixThunk
->Stat (OldFileName
, &OldAttr
) != 0) {
1969 Status
= EFI_DEVICE_ERROR
;
1976 if (NameChangeFlag
) {
1978 // Close the handles first
1980 if (PrivateFile
->IsOpenedByRead
) {
1981 Status
= EFI_ACCESS_DENIED
;
1985 for (CharPointer
= NewFileName
; *CharPointer
!= 0 && *CharPointer
!= L
'/'; CharPointer
++) {
1988 if (*CharPointer
!= 0) {
1989 Status
= EFI_ACCESS_DENIED
;
1993 UnixStatus
= PrivateFile
->UnixThunk
->Rename (OldFileName
, NewFileName
);
1995 if (UnixStatus
== 0) {
1999 gBS
->FreePool (PrivateFile
->FileName
);
2001 Status
= gBS
->AllocatePool (
2002 EfiBootServicesData
,
2003 AsciiStrSize (NewFileName
),
2004 (VOID
**)&PrivateFile
->FileName
2007 if (EFI_ERROR (Status
)) {
2011 AsciiStrCpy (PrivateFile
->FileName
, NewFileName
);
2013 Status
= EFI_DEVICE_ERROR
;
2021 if (SizeChangeFlag
) {
2022 if (PrivateFile
->IsDirectoryPath
) {
2023 Status
= EFI_UNSUPPORTED
;
2027 if (PrivateFile
->IsOpenedByRead
|| OldFileInfo
->Attribute
& EFI_FILE_READ_ONLY
) {
2028 Status
= EFI_ACCESS_DENIED
;
2032 if (PrivateFile
->UnixThunk
->FTruncate (PrivateFile
->fd
, NewFileInfo
->FileSize
) != 0) {
2033 Status
= EFI_DEVICE_ERROR
;
2042 if (TimeChangeFlag
) {
2043 struct utimbuf utime
;
2045 NewLastAccessSystemTime
.tm_year
= NewFileInfo
->LastAccessTime
.Year
;
2046 NewLastAccessSystemTime
.tm_mon
= NewFileInfo
->LastAccessTime
.Month
;
2047 NewLastAccessSystemTime
.tm_mday
= NewFileInfo
->LastAccessTime
.Day
;
2048 NewLastAccessSystemTime
.tm_hour
= NewFileInfo
->LastAccessTime
.Hour
;
2049 NewLastAccessSystemTime
.tm_min
= NewFileInfo
->LastAccessTime
.Minute
;
2050 NewLastAccessSystemTime
.tm_sec
= NewFileInfo
->LastAccessTime
.Second
;
2051 NewLastAccessSystemTime
.tm_isdst
= 0;
2053 utime
.actime
= PrivateFile
->UnixThunk
->MkTime (&NewLastAccessSystemTime
);
2055 NewLastWriteSystemTime
.tm_year
= NewFileInfo
->ModificationTime
.Year
;
2056 NewLastWriteSystemTime
.tm_mon
= NewFileInfo
->ModificationTime
.Month
;
2057 NewLastWriteSystemTime
.tm_mday
= NewFileInfo
->ModificationTime
.Day
;
2058 NewLastWriteSystemTime
.tm_hour
= NewFileInfo
->ModificationTime
.Hour
;
2059 NewLastWriteSystemTime
.tm_min
= NewFileInfo
->ModificationTime
.Minute
;
2060 NewLastWriteSystemTime
.tm_sec
= NewFileInfo
->ModificationTime
.Second
;
2061 NewLastWriteSystemTime
.tm_isdst
= 0;
2063 utime
.modtime
= PrivateFile
->UnixThunk
->MkTime (&NewLastWriteSystemTime
);
2065 if (utime
.actime
== (time_t)-1 || utime
.modtime
== (time_t)-1) {
2069 if (PrivateFile
->UnixThunk
->UTime (PrivateFile
->FileName
, &utime
) == -1) {
2075 // No matter about AttrChangeFlag, Attribute must be set.
2076 // Because operation before may cause attribute change.
2078 NewAttr
= OldAttr
.st_mode
;
2080 if (NewFileInfo
->Attribute
& EFI_FILE_READ_ONLY
) {
2081 NewAttr
&= ~(S_IRUSR
| S_IRGRP
| S_IROTH
);
2086 UnixStatus
= PrivateFile
->UnixThunk
->Chmod (NewFileName
, NewAttr
);
2088 if (UnixStatus
!= 0) {
2089 Status
= EFI_DEVICE_ERROR
;
2093 if (OldFileInfo
!= NULL
) {
2094 gBS
->FreePool (OldFileInfo
);
2097 if (OldFileName
!= NULL
) {
2098 gBS
->FreePool (OldFileName
);
2101 if (NewFileName
!= NULL
) {
2102 gBS
->FreePool (NewFileName
);
2105 gBS
->RestoreTPL (OldTpl
);
2112 UnixSimpleFileSystemFlush (
2117 Routine Description:
2119 Flush all modified data to the media.
2123 This - Pointer to an opened file handle.
2127 EFI_SUCCESS - The data has been flushed.
2129 EFI_NO_MEDIA - The device has no media.
2131 EFI_DEVICE_ERROR - The device reported an error.
2133 EFI_VOLUME_CORRUPTED - The file system structures have been corrupted.
2135 EFI_WRITE_PROTECTED - The file, directory, volume, or device is write protected.
2137 EFI_ACCESS_DENIED - The file was opened read-only.
2139 EFI_VOLUME_FULL - The volume is full.
2142 // TODO: EFI_INVALID_PARAMETER - add return value to function comment
2144 UNIX_EFI_FILE_PRIVATE
*PrivateFile
;
2149 return EFI_INVALID_PARAMETER
;
2152 Status
= EFI_SUCCESS
;
2153 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
2155 PrivateFile
= UNIX_EFI_FILE_PRIVATE_DATA_FROM_THIS (This
);
2158 if (PrivateFile
->IsDirectoryPath
) {
2162 if (PrivateFile
->IsOpenedByRead
) {
2163 Status
= EFI_ACCESS_DENIED
;
2167 if (PrivateFile
->fd
< 0) {
2168 Status
= EFI_DEVICE_ERROR
;
2172 PrivateFile
->UnixThunk
->FSync (PrivateFile
->fd
) == 0 ? EFI_SUCCESS
: EFI_DEVICE_ERROR
;
2175 gBS
->RestoreTPL (OldTpl
);
2180 // bugbug: - Use Unix error reporting.