EFI_STATUS EFIAPI fsw_efi_DriverBinding_Stop(IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer)
{
EFI_STATUS Status;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;
FSW_VOLUME_DATA *Volume;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(SimpleFileSystemProtocol),
(VOID **) &FileSystem,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": protocol opened with %r\n"), Status));
if (!EFI_ERROR(Status)) {
Volume = FSW_VOLUME_FROM_VOL_INTERFACE(FileSystem);
fsw_efi_DetachVolume(Volume);
}
Status = BS->CloseProtocol(ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
This->DriverBindingHandle,
ControllerHandle);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS fsw_efi_dir_read(IN FSW_FILE_DATA *File,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer)
{
EFI_STATUS Status;
FSW_VOLUME_DATA *Volume = (FSW_VOLUME_DATA *)File->shand.dnode->vol->host_data;
struct fsw_dnode *dno;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ "...\n")));
// read the next entry
Status = fsw_efi_map_status(fsw_dnode_dir_read(&File->shand, &dno),
Volume);
if (Status == EFI_NOT_FOUND) {
// end of directory
*BufferSize = 0;
FSW_MSG_DEBUG((FSW_MSGSTR("... no more entries\n")));
return EFI_SUCCESS;
}
if (EFI_ERROR(Status))
return Status;
// get info into buffer
Status = fsw_efi_dnode_fill_FileInfo(Volume, dno, BufferSize, Buffer);
fsw_dnode_release(dno);
return Status;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_Flush(IN EFI_FILE *This)
{
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
// this driver is read-only
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with Write Protected\n")));
return EFI_WRITE_PROTECTED;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_Write(IN EFI_FILE *This,
IN OUT UINTN *BufferSize,
IN VOID *Buffer)
{
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
// this driver is read-only
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with Write Protected\n")));
return EFI_WRITE_PROTECTED;
}
EFI_STATUS fsw_efi_dnode_to_FileHandle(IN struct fsw_dnode *dno,
OUT EFI_FILE **NewFileHandle)
{
EFI_STATUS Status;
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
// make sure the dnode has complete info
Status = fsw_efi_map_status(fsw_dnode_fill(dno), (FSW_VOLUME_DATA *)dno->vol->host_data);
if (EFI_ERROR(Status)) {
goto Done;
}
// check type
if (dno->type != FSW_DNODE_TYPE_FILE && dno->type != FSW_DNODE_TYPE_DIR) {
Status = EFI_UNSUPPORTED;
goto Done;
}
// allocate file structure
File = AllocateZeroPool(sizeof(FSW_FILE_DATA));
File->Signature = FSW_FILE_DATA_SIGNATURE;
if (dno->type == FSW_DNODE_TYPE_FILE)
File->Type = FSW_EFI_FILE_TYPE_FILE;
else if (dno->type == FSW_DNODE_TYPE_DIR)
File->Type = FSW_EFI_FILE_TYPE_DIR;
// open shandle
Status = fsw_efi_map_status(fsw_shandle_open(dno, &File->shand),
(FSW_VOLUME_DATA *)dno->vol->host_data);
if (EFI_ERROR(Status)) {
FreePool(File);
goto Done;
}
// populate the file handle
File->FileHandle.Revision = EFI_FILE_HANDLE_REVISION;
File->FileHandle.Open = fsw_efi_FileHandle_Open;
File->FileHandle.Close = fsw_efi_FileHandle_Close;
File->FileHandle.Delete = fsw_efi_FileHandle_Delete;
File->FileHandle.Read = fsw_efi_FileHandle_Read;
File->FileHandle.Write = fsw_efi_FileHandle_Write;
File->FileHandle.GetPosition = fsw_efi_FileHandle_GetPosition;
File->FileHandle.SetPosition = fsw_efi_FileHandle_SetPosition;
File->FileHandle.GetInfo = fsw_efi_FileHandle_GetInfo;
File->FileHandle.SetInfo = fsw_efi_FileHandle_SetInfo;
File->FileHandle.Flush = fsw_efi_FileHandle_Flush;
*NewFileHandle = &File->FileHandle;
Status = EFI_SUCCESS;
Done:
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS fsw_efi_dnode_fill_FileInfo(IN FSW_VOLUME_DATA *Volume,
IN struct fsw_dnode *dno,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer)
{
EFI_STATUS Status;
EFI_FILE_INFO *FileInfo;
UINTN RequiredSize;
struct fsw_dnode_stat sb;
// make sure the dnode has complete info
Status = fsw_efi_map_status(fsw_dnode_fill(dno), Volume);
if (EFI_ERROR(Status))
return Status;
// TODO: check/assert that the dno's name is in UTF16
// check buffer size
RequiredSize = SIZE_OF_EFI_FILE_INFO + fsw_efi_strsize(&dno->name);
if (*BufferSize < RequiredSize) {
// TODO: wind back the directory in this case
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": ... BUFFER TOO SMALL\n")));
*BufferSize = RequiredSize;
return EFI_BUFFER_TOO_SMALL;
}
// fill structure
ZeroMem(Buffer, RequiredSize);
FileInfo = (EFI_FILE_INFO *)Buffer;
FileInfo->Size = RequiredSize;
FileInfo->FileSize = dno->size;
FileInfo->Attribute = 0;
if (dno->type == FSW_DNODE_TYPE_DIR)
FileInfo->Attribute |= EFI_FILE_DIRECTORY;
fsw_efi_strcpy(FileInfo->FileName, &dno->name);
// get the missing info from the fs driver
ZeroMem(&sb, sizeof(struct fsw_dnode_stat));
sb.store_time_posix = fsw_efi_store_time_posix;
sb.store_attr_posix = fsw_efi_store_attr_posix;
sb.host_data = FileInfo;
Status = fsw_efi_map_status(fsw_dnode_stat(dno, &sb), Volume);
if (EFI_ERROR(Status))
return Status;
FileInfo->PhysicalSize = sb.used_bytes;
// prepare for return
*BufferSize = RequiredSize;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": ... returning `%s'\n"), FileInfo->FileName));
return EFI_SUCCESS;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_Close(IN EFI_FILE *This)
{
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
File = FSW_FILE_FROM_FILE_HANDLE(This);
fsw_shandle_close(&File->shand);
FreePool(File);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with Success\n")));
return EFI_SUCCESS;
}
EFI_STATUS EFIAPI fsw_efi_FileSystem_OpenVolume(IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
OUT EFI_FILE **Root)
{
EFI_STATUS Status;
FSW_VOLUME_DATA *Volume = FSW_VOLUME_FROM_VOL_INTERFACE(This);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = fsw_efi_dnode_to_FileHandle(Volume->vol->root, Root);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_Delete(IN EFI_FILE *This)
{
EFI_STATUS Status;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = This->Close(This);
if (Status == EFI_SUCCESS) {
// this driver is read-only
Status = EFI_WARN_DELETE_FAILURE;
}
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_GetInfo(IN EFI_FILE *This,
IN EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer)
{
EFI_STATUS Status;
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter for %g\n"), InformationType));
File = FSW_FILE_FROM_FILE_HANDLE(This);
Status = fsw_efi_dnode_getinfo(File, InformationType, BufferSize, Buffer);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_GetPosition(IN EFI_FILE *This,
OUT UINT64 *Position)
{
EFI_STATUS Status;
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = EFI_UNSUPPORTED;
File = FSW_FILE_FROM_FILE_HANDLE(This);
if (File->Type == FSW_EFI_FILE_TYPE_FILE)
Status = fsw_efi_file_getpos(File, Position);
// not defined for directories
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS fsw_efi_file_read(IN FSW_FILE_DATA *File,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer)
{
EFI_STATUS Status;
fsw_u32 buffer_size;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter to read %d bytes\n"), *BufferSize));
buffer_size = (fsw_u32)(*BufferSize);
Status = fsw_efi_map_status(fsw_shandle_read(&File->shand, &buffer_size, Buffer),
(FSW_VOLUME_DATA *)File->shand.dnode->vol->host_data);
*BufferSize = buffer_size;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_SetPosition(IN EFI_FILE *This,
IN UINT64 Position)
{
EFI_STATUS Status;
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = EFI_UNSUPPORTED;
File = FSW_FILE_FROM_FILE_HANDLE(This);
if (File->Type == FSW_EFI_FILE_TYPE_FILE)
Status = fsw_efi_file_setpos(File, Position);
else if (File->Type == FSW_EFI_FILE_TYPE_DIR)
Status = fsw_efi_dir_setpos(File, Position);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
fsw_status_t fsw_efi_read_block(struct fsw_volume *vol, fsw_u32 phys_bno, void *buffer)
{
EFI_STATUS Status;
FSW_VOLUME_DATA *Volume = (FSW_VOLUME_DATA *)vol->host_data;
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_efi_read_block: %d (%d)\n"), phys_bno, vol->phys_blocksize));
// read from disk
Status = Volume->DiskIo->ReadDisk(Volume->DiskIo, Volume->MediaId,
(UINT64)phys_bno * vol->phys_blocksize,
vol->phys_blocksize,
buffer);
Volume->LastIOStatus = Status;
if (EFI_ERROR(Status)) {
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": ReadDisk() returned %r\n"), Status));
return FSW_IO_ERROR;
}
return FSW_SUCCESS;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_Read(IN EFI_FILE *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer)
{
EFI_STATUS Status;
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = EFI_UNSUPPORTED;
File = FSW_FILE_FROM_FILE_HANDLE(This);
if (File->Type == FSW_EFI_FILE_TYPE_FILE)
Status = fsw_efi_file_read(File, BufferSize, Buffer);
else if (File->Type == FSW_EFI_FILE_TYPE_DIR)
Status = fsw_efi_dir_read(File, BufferSize, Buffer);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
EFI_STATUS EFIAPI fsw_efi_FileHandle_Open(IN EFI_FILE *This,
OUT EFI_FILE **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes)
{
EFI_STATUS Status;
FSW_FILE_DATA *File;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
Status = EFI_UNSUPPORTED;
File = FSW_FILE_FROM_FILE_HANDLE(This);
if (File->Type == FSW_EFI_FILE_TYPE_DIR)
Status = fsw_efi_dir_open(File, NewHandle, FileName, OpenMode, Attributes);
// not supported for regular files
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
static fsw_status_t fsw_ext2_dnode_fill(struct fsw_ext2_volume *vol, struct fsw_ext2_dnode *dno)
{
fsw_status_t status;
fsw_u32 groupno, ino_in_group, ino_bno, ino_index;
fsw_u8 *buffer;
if (dno->raw)
return FSW_SUCCESS;
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_ext2_dnode_fill: inode %d\n"), dno->g.dnode_id));
// read the inode block
groupno = (fsw_u32) (dno->g.dnode_id - 1) / vol->sb->s_inodes_per_group;
ino_in_group = (fsw_u32) (dno->g.dnode_id - 1) % vol->sb->s_inodes_per_group;
ino_bno = vol->inotab_bno[groupno] +
ino_in_group / (vol->g.phys_blocksize / vol->inode_size);
ino_index = ino_in_group % (vol->g.phys_blocksize / vol->inode_size);
status = fsw_block_get(vol, ino_bno, 2, (void **)&buffer);
if (status)
return status;
// keep our inode around
status = fsw_memdup((void **)&dno->raw, buffer + ino_index * vol->inode_size, vol->inode_size);
fsw_block_release(vol, ino_bno, buffer);
if (status)
return status;
// get info from the inode
dno->g.size = dno->raw->i_size;
// TODO: check docs for 64-bit sized files
if (S_ISREG(dno->raw->i_mode))
dno->g.type = FSW_DNODE_TYPE_FILE;
else if (S_ISDIR(dno->raw->i_mode))
dno->g.type = FSW_DNODE_TYPE_DIR;
else if (S_ISLNK(dno->raw->i_mode))
dno->g.type = FSW_DNODE_TYPE_SYMLINK;
else
dno->g.type = FSW_DNODE_TYPE_SPECIAL;
return FSW_SUCCESS;
}
EFI_STATUS fsw_efi_dir_open(IN FSW_FILE_DATA *File,
OUT EFI_FILE **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes)
{
EFI_STATUS Status;
FSW_VOLUME_DATA *Volume = (FSW_VOLUME_DATA *)File->shand.dnode->vol->host_data;
struct fsw_dnode *dno;
struct fsw_dnode *target_dno;
struct fsw_string lookup_path;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": `%s'\n"), FileName));
if (OpenMode != EFI_FILE_MODE_READ)
return EFI_WRITE_PROTECTED;
lookup_path.type = FSW_STRING_TYPE_UTF16;
lookup_path.len = (int)StrLen(FileName);
lookup_path.size = lookup_path.len * sizeof(fsw_u16);
lookup_path.data = FileName;
// resolve the path (symlinks along the way are automatically resolved)
Status = fsw_efi_map_status(fsw_dnode_lookup_path(File->shand.dnode, &lookup_path, '\\', &dno),
Volume);
if (EFI_ERROR(Status))
return Status;
// if the final node is a symlink, also resolve it
Status = fsw_efi_map_status(fsw_dnode_resolve(dno, &target_dno),
Volume);
fsw_dnode_release(dno);
if (EFI_ERROR(Status))
return Status;
dno = target_dno;
// make a new EFI handle for the target dnode
Status = fsw_efi_dnode_to_FileHandle(dno, NewHandle);
fsw_dnode_release(dno);
return Status;
}
fsw_status_t fsw_dnode_lookup_path(struct fsw_dnode *dno,
struct fsw_string *lookup_path, char separator,
struct fsw_dnode **child_dno_out)
{
fsw_status_t status;
struct fsw_volume *vol = dno->vol;
struct fsw_dnode *child_dno = NULL;
struct fsw_string lookup_name;
struct fsw_string remaining_path;
int root_if_empty;
remaining_path = *lookup_path;
fsw_dnode_retain(dno);
// loop over the path
for (root_if_empty = 1; fsw_strlen(&remaining_path) > 0; root_if_empty = 0) {
// parse next path component
fsw_strsplit(&lookup_name, &remaining_path, separator);
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_dnode_lookup_path: split into %d '%s' and %d '%s'\n"),
lookup_name.len, lookup_name.data,
remaining_path.len, remaining_path.data));
if (fsw_strlen(&lookup_name) == 0) { // empty path component
if (root_if_empty)
child_dno = vol->root;
else
child_dno = dno;
fsw_dnode_retain(child_dno);
} else {
// do an actual directory lookup
// ensure we have full information
status = fsw_dnode_fill(dno);
if (status)
goto errorexit;
// resolve symlink if necessary
if (dno->type == FSW_DNODE_TYPE_SYMLINK) {
status = fsw_dnode_resolve(dno, &child_dno);
if (status)
goto errorexit;
// symlink target becomes the new dno
fsw_dnode_release(dno);
dno = child_dno; // is already retained
child_dno = NULL;
// ensure we have full information
status = fsw_dnode_fill(dno);
if (status)
goto errorexit;
}
// make sure we operate on a directory
if (dno->type != FSW_DNODE_TYPE_DIR) {
return FSW_UNSUPPORTED;
goto errorexit;
}
// check special paths
if (fsw_streq_cstr(&lookup_name, ".")) { // self directory
child_dno = dno;
fsw_dnode_retain(child_dno);
} else if (fsw_streq_cstr(&lookup_name, "..")) { // parent directory
if (dno->parent == NULL) {
// We cannot go up from the root directory. Caution: Certain apps like the EFI shell
// rely on this behaviour!
status = FSW_NOT_FOUND;
goto errorexit;
}
child_dno = dno->parent;
fsw_dnode_retain(child_dno);
} else {
// do an actual lookup
status = vol->fstype_table->dir_lookup(vol, dno, &lookup_name, &child_dno);
if (status)
goto errorexit;
}
}
// child_dno becomes the new dno
fsw_dnode_release(dno);
dno = child_dno; // is already retained
child_dno = NULL;
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_dnode_lookup_path: now at inode %d\n"), dno->dnode_id));
}
*child_dno_out = dno;
return FSW_SUCCESS;
errorexit:
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_dnode_lookup_path: leaving with error %d\n"), status));
fsw_dnode_release(dno);
if (child_dno != NULL)
fsw_dnode_release(child_dno);
return status;
}
EFI_STATUS fsw_efi_dnode_getinfo(IN FSW_FILE_DATA *File,
IN EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer)
{
EFI_STATUS Status;
FSW_VOLUME_DATA *Volume;
EFI_FILE_SYSTEM_INFO *FSInfo;
UINTN RequiredSize;
struct fsw_volume_stat vsb;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter for %g\n"), InformationType));
Volume = (FSW_VOLUME_DATA *)File->shand.dnode->vol->host_data;
if (CompareGuid(InformationType, &GUID_NAME(FileInfo))) {
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": FILE_INFO\n")));
Status = fsw_efi_dnode_fill_FileInfo(Volume, File->shand.dnode, BufferSize, Buffer);
} else if (CompareGuid(InformationType, &GUID_NAME(FileSystemInfo))) {
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": FILE_SYSTEM_INFO\n")));
// check buffer size
RequiredSize = fsw_efi_strsize(&Volume->vol->label) + SIZE_OF_EFI_FILE_SYSTEM_INFO;
if (*BufferSize < RequiredSize) {
*BufferSize = RequiredSize;
Status = EFI_BUFFER_TOO_SMALL;
goto Done;
}
// fill structure
FSInfo = (EFI_FILE_SYSTEM_INFO *)Buffer;
FSInfo->Size = RequiredSize;
FSInfo->ReadOnly = TRUE;
FSInfo->BlockSize = Volume->vol->log_blocksize;
fsw_efi_strcpy(FSInfo->VolumeLabel, &Volume->vol->label);
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": Volume Label [%s]\n"), FSInfo->VolumeLabel));
// get the missing info from the fs driver
ZeroMem(&vsb, sizeof(struct fsw_volume_stat));
Status = fsw_efi_map_status(fsw_volume_stat(Volume->vol, &vsb), Volume);
if (EFI_ERROR(Status)) {
goto Done;
}
FSInfo->VolumeSize = vsb.total_bytes;
FSInfo->FreeSpace = vsb.free_bytes;
// prepare for return
*BufferSize = RequiredSize;
Status = EFI_SUCCESS;
} else if (CompareGuid(InformationType, &GUID_NAME(FileSystemVolumeLabelInfoId))) {
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": FILE_SYSTEM_VOLUME_LABEL\n")));
// check buffer size
RequiredSize = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO + fsw_efi_strsize(&Volume->vol->label);
if (*BufferSize < RequiredSize) {
*BufferSize = RequiredSize;
Status = EFI_BUFFER_TOO_SMALL;
goto Done;
}
// copy volume label
fsw_efi_strcpy(((EFI_FILE_SYSTEM_VOLUME_LABEL_INFO *)Buffer)->VolumeLabel, &Volume->vol->label);
// prepare for return
*BufferSize = RequiredSize;
Status = EFI_SUCCESS;
} else {
Status = EFI_UNSUPPORTED;
}
Done:
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
static fsw_status_t fsw_iso9660_volume_mount(struct fsw_iso9660_volume *vol)
{
fsw_status_t status;
void *buffer;
fsw_u32 blockno;
struct iso9660_volume_descriptor *voldesc;
struct iso9660_primary_volume_descriptor *pvoldesc;
fsw_u32 voldesc_type;
int i;
struct fsw_string s;
struct iso9660_dirrec rootdir;
int sua_pos;
char *sig;
int skip;
struct fsw_rock_ridge_susp_entry *entry;
// read through the Volume Descriptor Set
fsw_set_blocksize(vol, ISO9660_BLOCKSIZE, ISO9660_BLOCKSIZE);
blockno = ISO9660_SUPERBLOCK_BLOCKNO;
do {
status = fsw_block_get(vol, blockno, 0, &buffer);
if (status)
return status;
voldesc = (struct iso9660_volume_descriptor *)buffer;
voldesc_type = voldesc->volume_descriptor_type;
if (fsw_memeq(voldesc->standard_identifier, "CD001", 5)) {
// descriptor follows ISO 9660 standard
if (voldesc_type == 1 && voldesc->volume_descriptor_version == 1) {
// suitable Primary Volume Descriptor found
if (vol->primary_voldesc) {
fsw_free(vol->primary_voldesc);
vol->primary_voldesc = NULL;
}
status = fsw_memdup((void **)&vol->primary_voldesc, voldesc, ISO9660_BLOCKSIZE);
}
} else if (!fsw_memeq(voldesc->standard_identifier, "CD", 2)) {
// completely alien standard identifier, stop reading
voldesc_type = 255;
}
fsw_block_release(vol, blockno, buffer);
blockno++;
} while (!status && voldesc_type != 255);
if (status)
return status;
// get information from Primary Volume Descriptor
if (vol->primary_voldesc == NULL)
return FSW_UNSUPPORTED;
pvoldesc = vol->primary_voldesc;
if (ISOINT(pvoldesc->logical_block_size) != 2048)
return FSW_UNSUPPORTED;
// get volume name
for (i = 32; i > 0; i--)
if (pvoldesc->volume_identifier[i-1] != ' ')
break;
s.type = FSW_STRING_TYPE_ISO88591;
s.size = s.len = i;
s.data = pvoldesc->volume_identifier;
status = fsw_strdup_coerce(&vol->g.label, vol->g.host_string_type, &s);
if (status)
return status;
// setup the root dnode
status = fsw_dnode_create_root(vol, ISO9660_SUPERBLOCK_BLOCKNO << ISO9660_BLOCKSIZE_BITS, &vol->g.root);
if (status)
return status;
fsw_memcpy(&vol->g.root->dirrec, &pvoldesc->root_directory, sizeof(struct iso9660_dirrec));
if ( pvoldesc->escape[0] == 0x25
&& pvoldesc->escape[1] == 0x2f
&& ( pvoldesc->escape[2] == 0x40
|| pvoldesc->escape[2] == 0x43
|| pvoldesc->escape[2] == 0x45))
{
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: success (joliet!!!)\n")));
vol->fJoliet = 1;
}
fsw_memcpy(&rootdir, &pvoldesc->root_directory, sizeof(rootdir));
sua_pos = (sizeof(struct iso9660_dirrec)) + rootdir.file_identifier_length + (rootdir.file_identifier_length % 2) - 2;
//int sua_size = rootdir.dirrec_length - rootdir.file_identifier_length;
//FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: success (SUA(pos:%x, sz:%d)!!!)\n"), sua_pos, sua_size));
#if 1
status = fsw_block_get(vol, ISOINT(rootdir.extent_location), 0, &buffer);
sig = (char *)buffer + sua_pos;
skip = 0;
entry = (struct fsw_rock_ridge_susp_entry *)sig;
if ( entry->sig[0] == 'S'
&& entry->sig[1] == 'P')
{
struct fsw_rock_ridge_susp_sp *sp = (struct fsw_rock_ridge_susp_sp *)entry;
if (sp->magic[0] == 0xbe && sp->magic[1] == 0xef)
{
vol->fRockRidge = 1;
} else {
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: SP magic isn't valid\n")));
}
skip = sp->skip;
}
#endif
// release volume descriptors
fsw_free(vol->primary_voldesc);
vol->primary_voldesc = NULL;
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_iso9660_volume_mount: success\n")));
return FSW_SUCCESS;
}
EFI_STATUS EFIAPI fsw_efi_DriverBinding_Start(IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath)
{
EFI_STATUS Status;
EFI_STATUS Status2;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
EFI_DISK_IO_PROTOCOL *DiskIo;
BOOLEAN LockedByMe;
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": enter\n")));
LockedByMe = FALSE;
Status = fsw_efi_AcquireLockOrFail();
if (!EFI_ERROR(Status)) {
LockedByMe = TRUE;
}
// open consumed protocols
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(BlockIoProtocol),
(VOID **) &BlockIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL); // NOTE: we only want to look at the MediaId
if (EFI_ERROR(Status)) {
goto Exit;
}
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
(VOID **) &DiskIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER);
if (EFI_ERROR(Status)) {
goto Exit;
}
Status = fsw_efi_AttachVolume(ControllerHandle, DiskIo, BlockIo);
// on errors, close the opened protocols
if (EFI_ERROR(Status)) {
Status2 = gBS->OpenProtocol (
ControllerHandle,
&PROTO_NAME(SimpleFileSystemProtocol),
NULL,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_TEST_PROTOCOL
);
if (EFI_ERROR (Status2)) {
BS->CloseProtocol (
ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
This->DriverBindingHandle,
ControllerHandle
);
}
}
Exit:
if (LockedByMe) {
fsw_efi_ReleaseLock();
}
FSW_MSG_DEBUG((FSW_MSGSTR(__FUNCTION__ ": leaving with %r\n"), Status));
return Status;
}
static fsw_status_t fsw_ext2_volume_mount(struct fsw_ext2_volume *vol)
{
fsw_status_t status;
void *buffer;
fsw_u32 blocksize;
fsw_u32 groupcnt, groupno, gdesc_per_block, gdesc_bno, gdesc_index;
struct ext2_group_desc *gdesc;
int i;
struct fsw_string s;
// allocate memory to keep the superblock around
status = fsw_alloc(sizeof(struct ext2_super_block), &vol->sb);
if (status)
return status;
// read the superblock into its buffer
fsw_set_blocksize(vol, EXT2_SUPERBLOCK_BLOCKSIZE, EXT2_SUPERBLOCK_BLOCKSIZE);
status = fsw_block_get(vol, EXT2_SUPERBLOCK_BLOCKNO, 0, &buffer);
if (status)
return status;
fsw_memcpy(vol->sb, buffer, sizeof(struct ext2_super_block));
fsw_block_release(vol, EXT2_SUPERBLOCK_BLOCKNO, buffer);
// check the superblock
if (vol->sb->s_magic != EXT2_SUPER_MAGIC)
return FSW_UNSUPPORTED;
if (vol->sb->s_rev_level != EXT2_GOOD_OLD_REV &&
vol->sb->s_rev_level != EXT2_DYNAMIC_REV)
return FSW_UNSUPPORTED;
if (vol->sb->s_rev_level == EXT2_DYNAMIC_REV &&
(vol->sb->s_feature_incompat & ~(EXT2_FEATURE_INCOMPAT_FILETYPE | EXT3_FEATURE_INCOMPAT_RECOVER)))
return FSW_UNSUPPORTED;
/*
if (vol->sb->s_rev_level == EXT2_DYNAMIC_REV &&
(vol->sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER))
Print(L"Ext2 WARNING: This ext3 file system needs recovery, trying to use it anyway.\n");
*/
// set real blocksize
blocksize = EXT2_BLOCK_SIZE(vol->sb);
fsw_set_blocksize(vol, blocksize, blocksize);
// get other info from superblock
vol->ind_bcnt = EXT2_ADDR_PER_BLOCK(vol->sb);
vol->dind_bcnt = vol->ind_bcnt * vol->ind_bcnt;
vol->inode_size = EXT2_INODE_SIZE(vol->sb);
for (i = 0; i < 16; i++)
if (vol->sb->s_volume_name[i] == 0)
break;
s.type = FSW_STRING_TYPE_ISO88591;
s.size = s.len = i;
s.data = vol->sb->s_volume_name;
status = fsw_strdup_coerce(&vol->g.label, vol->g.host_string_type, &s);
if (status)
return status;
// read the group descriptors to get inode table offsets
groupcnt = ((vol->sb->s_inodes_count - 2) / vol->sb->s_inodes_per_group) + 1;
gdesc_per_block = (vol->g.phys_blocksize / sizeof(struct ext2_group_desc));
status = fsw_alloc(sizeof(fsw_u32) * groupcnt, &vol->inotab_bno);
if (status)
return status;
for (groupno = 0; groupno < groupcnt; groupno++) {
// get the block group descriptor
gdesc_bno = (vol->sb->s_first_data_block + 1) + groupno / gdesc_per_block;
gdesc_index = groupno % gdesc_per_block;
status = fsw_block_get(vol, gdesc_bno, 1, (void **)&buffer);
if (status)
return status;
gdesc = ((struct ext2_group_desc *)(buffer)) + gdesc_index;
vol->inotab_bno[groupno] = gdesc->bg_inode_table;
fsw_block_release(vol, gdesc_bno, buffer);
}
// setup the root dnode
status = fsw_dnode_create_root(vol, EXT2_ROOT_INO, &vol->g.root);
if (status)
return status;
FSW_MSG_DEBUG((FSW_MSGSTR("fsw_ext2_volume_mount: success, blocksize %d\n"), blocksize));
return FSW_SUCCESS;
}
