You've already forked slimbootloader
mirror of
https://github.com/Dasharo/slimbootloader.git
synced 2026-03-06 15:26:20 -08:00
James Gutbub
bc8f743c53
Currently there is some limitation with mounting an EXT4 partition to retrieve a file for booting when the partition was not properly umounted during the previous usage (ex. powering off an OS without using 'poweroff' command, unplugging power, etc.). There is no recovery support in the Ext23Lib but as a temporary solution we can ignore the recovery bit to avoid boot issues when the recovery bit is flipped due to unexpected power loss. Signed-off-by: James Gutbub <james.gutbub@intel.com>
672 lines
21 KiB
C
672 lines
21 KiB
C
/** @file
|
|
|
|
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
Copyright (c) 1982, 1986, 1989, 1993
|
|
The Regents of the University of California. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
3. Neither the name of the University nor the names of its contributors
|
|
may be used to endorse or promote products derived from this software
|
|
without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
|
|
@file fs.h 8.10 (Berkeley) 10/27/94
|
|
Modified for ext2fs by Manuel Bouyer.
|
|
|
|
Copyright (c) 1997 Manuel Bouyer.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
@file fs.h 8.10 (Berkeley) 10/27/94
|
|
Modified for ext2fs by Manuel Bouyer.
|
|
**/
|
|
|
|
#ifndef _UFS_EXT2FS_EXT2FS_H_
|
|
#define _UFS_EXT2FS_EXT2FS_H_
|
|
|
|
#include <PiPei.h>
|
|
#include <Ppi/BlockIo.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/PartitionLib.h>
|
|
#include "Ext2FsDiNode.h"
|
|
#include "Ext2FsDir.h"
|
|
#include "LibsaFsStand.h"
|
|
/**
|
|
Each disk drive contains some number of file systems.
|
|
A file system consists of a number of cylinder groups.
|
|
Each cylinder group has inodes and data.
|
|
|
|
A file system is described by its super-block, which in turn
|
|
describes the cylinder groups. The super-block is critical
|
|
data and is replicated in each cylinder group to protect against
|
|
catastrophic loss. This is done at `newfs' time and the critical
|
|
super-block data does not change, so the copies need not be
|
|
referenced further unless disaster strikes.
|
|
|
|
The first boot and super blocks are given in absolute disk addresses.
|
|
The byte-offset forms are preferred, as they don't imply a sector size.
|
|
**/
|
|
#define BBSIZE 1024
|
|
#define SBSIZE 1024
|
|
#define BBOFF ((OFFSET)(0))
|
|
#define SBOFF ((OFFSET)(BBOFF + BBSIZE))
|
|
#define BBLOCK ((DADDRESS)(0))
|
|
#define SBLOCK ((DADDRESS)(BBLOCK + BBSIZE / DEV_BSIZE))
|
|
|
|
#define BDEV_BLOCKSIZE 512
|
|
|
|
#undef EXT2FS_DEBUG
|
|
|
|
#undef LIBSA_FS_SINGLECOMPONENT
|
|
#define LIBSA_FS_SINGLE_DEVICE
|
|
#define LIBSA_FS_SINGLE_FILESYSTEM
|
|
#define LIBSA_NO_FS_SYMLINK
|
|
#define LIBSA_NO_TWIDDLE
|
|
#undef LIBSA_ENABLE_LS_OP
|
|
#define LIBSA_NO_FS_WRITE
|
|
|
|
//
|
|
// An (open) file:
|
|
//
|
|
typedef struct {
|
|
OPEN_FILE Openfile;
|
|
} _FILE;
|
|
|
|
/**
|
|
Addresses stored in inodes are capable of addressing blocks
|
|
XXX
|
|
|
|
MINBSIZE is the smallest allowable block size.
|
|
MINBSIZE must be big enough to hold a cylinder group block,
|
|
thus changes to (struct cg) must keep its size within MINBSIZE.
|
|
Note that super blocks are always of size SBSIZE,
|
|
and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
|
|
**/
|
|
#define LOG_MINBSIZE 10
|
|
#define MINBSIZE (1 << LOG_MINBSIZE)
|
|
|
|
/**
|
|
The path name on which the file system is mounted is maintained
|
|
in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
|
|
the super block for this name.
|
|
**/
|
|
#define MAXMNTLEN 512
|
|
|
|
/**
|
|
MINFREE gives the minimum acceptable percentage of file system
|
|
blocks which may be free. If the freelist drops below this level
|
|
only the superuser may continue to allocate blocks. This may
|
|
be set to 0 if no reserve of free blocks is deemed necessary,
|
|
however throughput drops by fifty percent if the file system
|
|
is run at between 95% and 100% full; thus the minimum default
|
|
value of fs_minfree is 5%. However, to get good clustering
|
|
performance, 10% is a better choice. hence we use 10% as our
|
|
default value. With 10% free space, fragmentation is not a
|
|
problem, so we choose to optimize for time.
|
|
**/
|
|
#define MINFREE 5
|
|
|
|
//
|
|
// Super block for an ext2fs file system.
|
|
//
|
|
typedef struct {
|
|
UINT32 Ext2FsINodeCount; // Inode count
|
|
UINT32 Ext2FsBlockCount; // blocks count
|
|
UINT32 Ext2FsRsvdBlockCount; // reserved blocks count
|
|
UINT32 Ext2FsFreeBlockCount; // free blocks count
|
|
UINT32 Ext2FsFreeINodeCount; // free inodes count
|
|
UINT32 Ext2FsFirstDataBlock; // first data block
|
|
UINT32 Ext2FsLogBlockSize; // block size = 1024*(2^Ext2FsLogBlockSize)
|
|
UINT32 Ext2FsFragmentSize; // fragment size
|
|
UINT32 Ext2FsBlocksPerGroup; // blocks per group
|
|
UINT32 Ext2FsFragsPerGroup; // frags per group
|
|
UINT32 Ext2FsINodesPerGroup; // inodes per group
|
|
UINT32 Ext2FsMountTime; // mount time
|
|
UINT32 Ext2FsWriteTime; // write time
|
|
UINT16 Ext2FsMountCount; // mount count
|
|
UINT16 Ext2FsMaxMountCount; // max mount count
|
|
UINT16 Ext2FsMagic; // magic number
|
|
UINT16 Ext2FsState; // file system state
|
|
UINT16 Ext2FsBehavior; // behavior on errors
|
|
UINT16 Ext2FsMinorRev; // minor revision level
|
|
UINT32 Ext2FsLastFsck; // time of last fsck
|
|
UINT32 Ext2FsFsckInterval; // max time between fscks
|
|
UINT32 Ext2FsCreator; // creator OS
|
|
UINT32 Ext2FsRev; // revision level
|
|
UINT16 Ext2FsRsvdUid; // default uid for reserved blocks
|
|
UINT16 Ext2FsRsvdGid; // default gid for reserved blocks
|
|
//
|
|
// EXT2_DYNAMIC_REV superblocks
|
|
//
|
|
UINT32 Ext2FsFirstInode; /* first non-reserved inode */
|
|
UINT16 Ext2FsInodeSize; /* size of inode structure */
|
|
UINT16 Ext2FsBlockGrpNum; /* block grp number of this sblk*/
|
|
UINT32 Ext2FsFeaturesCompat; /* compatible feature set */
|
|
UINT32 Ext2FsFeaturesIncompat; /* incompatible feature set */
|
|
UINT32 Ext2FsFeaturesROCompat; /* RO-compatible feature set */
|
|
UINT8 Ext2FsUuid[16]; /* 128-bit uuid for volume */
|
|
CHAR8 Ext2FsVolumeName[16]; /* volume name */
|
|
CHAR8 Ext2FsFSMnt[64]; /* name mounted on */
|
|
UINT32 Ext2FsAlgorithm; /* For compression */
|
|
UINT8 Ext2FsPreAlloc; /* # of blocks to preallocate */
|
|
UINT8 Ext2FsDirPreAlloc; /* # of blocks to preallocate for dir */
|
|
UINT16 Ext2FsRsvdGDBlock; /* # of reserved gd blocks for resize */
|
|
UINT32 Rsvd2[204];
|
|
} EXT2FS;
|
|
|
|
//
|
|
// Ext2 file system block group descriptor
|
|
//
|
|
typedef struct {
|
|
UINT32 Ext2BGDBlockBitmap; /* blocks bitmap block */
|
|
UINT32 Ext2BGDInodeBitmap; /* inodes bitmap block */
|
|
UINT32 Ext2BGDInodeTables; /* inodes table block */
|
|
UINT16 Ext2BGDFreeBlocks; /* number of free blocks */
|
|
UINT16 Ext2BGDFreeInodes; /* number of free inodes */
|
|
UINT16 Ext2BGDNumDir; /* number of directories */
|
|
UINT16 Rsvd;
|
|
UINT32 Rsvd2[3];
|
|
} EXT2GD;
|
|
|
|
//
|
|
// In-memory data for ext2fs
|
|
//
|
|
typedef struct {
|
|
EXT2FS Ext2Fs;
|
|
UINT8 Ext2FsFSMnt[MAXMNTLEN]; // name mounted on
|
|
CHAR8 Ext2FsReadOnly; // mounted read-only flag
|
|
CHAR8 Ext2FsModified; // super block modified flag
|
|
INT32 Ext2FsBlockSize; // block size
|
|
INT32 Ext2FsLogicalBlock; // ``lblkno'' calc of logical blkno
|
|
INT32 Ext2FsBlockOffset; // ``blkoff'' calc of blk offsets
|
|
INT64 Ext2FsQuadBlockOffset; // ~fs_bmask - for use with quad size
|
|
INT32 Ext2FsFsbtobd; // FSBTODB and DBTOFSB shift constant
|
|
INT32 Ext2FsNumCylinder; // number of cylinder groups
|
|
INT32 Ext2FsNumGrpDesBlock; // number of group descriptor block
|
|
INT32 Ext2FsInodesPerBlock; // number of inodes per block
|
|
INT32 Ext2FsInodesTablePerGrp; // number of inode table per group
|
|
EXT2GD *Ext2FsGrpDes; // group descripors
|
|
} M_EXT2FS;
|
|
|
|
|
|
|
|
//
|
|
// Filesystem identification
|
|
//
|
|
#define E2FS_MAGIC 0xef53 /* the ext2fs magic number */
|
|
#define E2FS_REV0 0 /* GOOD_OLD revision */
|
|
#define E2FS_REV1 1 /* Support compat/incompat features */
|
|
//
|
|
// Compatible/incompatible features
|
|
//
|
|
#define EXT2F_COMPAT_PREALLOC 0x0001
|
|
#define EXT2F_COMPAT_HASJOURNAL 0x0004
|
|
#define EXT2F_COMPAT_RESIZE 0x0010
|
|
|
|
#define EXT2F_ROCOMPAT_SPARSESUPER 0x0001
|
|
#define EXT2F_ROCOMPAT_LARGEFILE 0x0002
|
|
#define EXT2F_ROCOMPAT_BTREE_DIR 0x0004
|
|
|
|
#define EXT2F_INCOMPAT_COMP 0x0001
|
|
#define EXT2F_INCOMPAT_FTYPE 0x0002
|
|
|
|
//
|
|
// TODO: We need to enable support for
|
|
// EXT FS recovery handling at some
|
|
// point to ensure that we don't
|
|
// encounter a real file error.
|
|
//
|
|
#define EXT2F_INCOMPAT_RECOVER 0x0004
|
|
|
|
#define EXT2F_INCOMPAT_EXTENTS 0x0040
|
|
#define EXT2F_INCOMPAT_FLEX_BG 0x0200
|
|
|
|
/**
|
|
Features supported in this implementation
|
|
|
|
We support the following REV1 features:
|
|
- EXT2F_ROCOMPAT_SPARSESUPER
|
|
superblock backups stored only in cg_has_sb(bno) groups
|
|
- EXT2F_ROCOMPAT_LARGEFILE
|
|
use e2di_dacl in EXTFS_DINODE to store
|
|
upper 32bit of size for >2GB files
|
|
- EXT2F_INCOMPAT_FTYPE
|
|
store file type to e2d_type in EXT2FS_direct
|
|
(on REV0 e2d_namlen is UINT16 and no e2d_type, like ffs)
|
|
**/
|
|
#define EXT2F_COMPAT_SUPP 0x0000
|
|
#define EXT2F_ROCOMPAT_SUPP (EXT2F_ROCOMPAT_SPARSESUPER \
|
|
| EXT2F_ROCOMPAT_LARGEFILE)
|
|
#define EXT2F_INCOMPAT_SUPP (EXT2F_INCOMPAT_FTYPE \
|
|
| EXT2F_INCOMPAT_RECOVER \
|
|
| EXT2F_INCOMPAT_EXTENTS \
|
|
| EXT2F_INCOMPAT_FLEX_BG)
|
|
|
|
//
|
|
// Definitions of behavior on errors
|
|
//
|
|
#define E2FS_BEH_CONTINUE 1 /* continue operation */
|
|
#define E2FS_BEH_READONLY 2 /* remount fs read only */
|
|
#define E2FS_BEH_PANIC 3 /* cause panic */
|
|
#define E2FS_BEH_DEFAULT E2FS_BEH_CONTINUE
|
|
|
|
//
|
|
// OS identification
|
|
//
|
|
#define E2FS_OS_LINUX 0
|
|
#define E2FS_OS_HURD 1
|
|
#define E2FS_OS_MASIX 2
|
|
#define E2FS_OS_FREEBSD 3
|
|
#define E2FS_OS_LITES 4
|
|
|
|
//
|
|
// Filesystem clean flags
|
|
//
|
|
#define E2FS_ISCLEAN 0x01
|
|
#define E2FS_ERRORS 0x02
|
|
|
|
/**
|
|
The cache size (IND_CACHE_SZ) must be smaller or equal the number of pointers
|
|
in the indirect blocks: NINDIR = Ext2FsBlockSize / sizeof(UINT32).
|
|
For ext2fs minimal block size is 1kB and block pointer size is 4 (UINT32)
|
|
so LN2_IND_CACHE_SZ <= 8 (cache size IND_CACHE_SZ=2^8=256)
|
|
Optimal for file system speed is the biggest cache size possible.
|
|
**/
|
|
#define LN2_IND_CACHE_SZ 8
|
|
#define IND_CACHE_SZ (1 << LN2_IND_CACHE_SZ)
|
|
#define IND_CACHE_MASK (IND_CACHE_SZ - 1)
|
|
|
|
#define INDPTR INT32
|
|
|
|
typedef UINT32 INODE32;
|
|
|
|
//
|
|
// In-core open file.
|
|
//
|
|
typedef struct {
|
|
OFFSET SeekPtr; // seek pointer
|
|
M_EXT2FS *SuperBlockPtr; // pointer to super-block
|
|
EXTFS_DINODE DiskInode; // copy of on-disk inode
|
|
UINT32 NiShift; // for blocks in indirect block
|
|
INDPTR InodeCacheBlock;
|
|
INDPTR InodeCache[IND_CACHE_SZ];
|
|
CHAR8 *Buffer; // buffer for data block
|
|
UINT32 BufferSize; // size of data block
|
|
DADDRESS BufferBlockNum; // block number of data block
|
|
} FILE;
|
|
|
|
|
|
/**
|
|
EXT2FS metadatas are stored in little-endian byte order. These macros
|
|
helps reading theses metadatas
|
|
**/
|
|
|
|
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
#define H2FS16(x) (x)
|
|
#define H2FS32(x) (x)
|
|
#define H2FS64(x) (x)
|
|
#define FS2H16(x) (x)
|
|
#define FS2H32(x) (x)
|
|
#define FS2H64(x) (x)
|
|
#define E2FS_SBLOAD(old, new) CopyMem((new), (old), SBSIZE);
|
|
#define E2FS_CGLOAD(old, new, size) CopyMem((new), (old), (size));
|
|
#define E2FS_SBSAVE(old, new) CopyMem((new), (old), SBSIZE);
|
|
#define E2FS_CGSAVE(old, new, size) CopyMem((new), (old), (size));
|
|
#else
|
|
/**
|
|
Byte swap functions for big endian machines.
|
|
(Ext2Fs is always little endian)
|
|
|
|
XXX: We should use src/sys/ufs/Ext2Fs/ext2fs_bswap.c
|
|
|
|
These functions are only needed if native byte order is not big endian
|
|
|
|
@param Old pointer to old filesystem field
|
|
@param New pointer to new filesystem field
|
|
**/
|
|
VOID
|
|
E2fsSBByteSwap (
|
|
EXT2FS *Old,
|
|
EXT2FS *New
|
|
);
|
|
|
|
/**
|
|
Byte swap functions for big endian machines.
|
|
(Ext2Fs is always little endian)
|
|
|
|
XXX: We should use src/sys/ufs/Ext2Fs/ext2fs_bswap.c
|
|
|
|
These functions are only needed if native byte order is not big endian
|
|
|
|
@param Old pointer to old filesystem field
|
|
@param New pointer to new filesystem field
|
|
@param Size Size to swap
|
|
**/
|
|
VOID
|
|
E2fsCGByteSwap (
|
|
EXT2GD *Old,
|
|
EXT2GD *New,
|
|
INT32 Size
|
|
);
|
|
|
|
#define H2FS16(x) bswap16(x)
|
|
#define H2FS32(x) bswap32(x)
|
|
#define H2FS64(x) bswap64(x)
|
|
#define FS2H16(x) bswap16(x)
|
|
#define FS2H32(x) bswap32(x)
|
|
#define FS2H64(x) bswap64(x)
|
|
#define E2FS_SBLOAD(old, new) E2fsSBByteSwap((old), (new))
|
|
#define E2FS_CGLOAD(old, new, size) E2fsCGByteSwap((old), (new), (size));
|
|
#define E2FS_SBSAVE(old, new) E2fsSBByteSwap((old), (new))
|
|
#define E2FS_CGSAVE(old, new, size) E2fsCGByteSwap((old), (new), (size));
|
|
#endif
|
|
|
|
/**
|
|
Turn file system block numbers into disk block addresses.
|
|
This maps file system blocks to device size blocks.
|
|
**/
|
|
#define FSBTODB(fs, b) ((b) << (fs)->Ext2FsFsbtobd)
|
|
#define DBTOFSB(fs, b) ((b) >> (fs)->Ext2FsFsbtobd)
|
|
|
|
/**
|
|
Macros for handling inode numbers:
|
|
inode number to file system block offset.
|
|
inode number to cylinder group number.
|
|
inode number to file system block address.
|
|
**/
|
|
#define INOTOCG(fs, x) (((x) - 1) / (fs)->Ext2Fs.Ext2FsINodesPerGroup)
|
|
#define INODETOFSBA(fs, x) \
|
|
((fs)->Ext2FsGrpDes[INOTOCG((fs), (x))].Ext2BGDInodeTables + \
|
|
(((x) - 1) % (fs)->Ext2Fs.Ext2FsINodesPerGroup) / (fs)->Ext2FsInodesPerBlock)
|
|
#define INODETOFSBO(fs, x) (((x) - 1) % (fs)->Ext2FsInodesPerBlock)
|
|
|
|
/**
|
|
Give cylinder group number for a file system block.
|
|
Give cylinder group block number for a file system block.
|
|
**/
|
|
#define DTOG(fs, d) (((d) - (fs)->Ext2Fs.Ext2FsFirstDataBlock) / (fs)->Ext2Fs.Ext2FsFragsPerGroup)
|
|
#define DTOGD(fs, d) \
|
|
(((d) - (fs)->Ext2Fs.Ext2FsFirstDataBlock) % (fs)->Ext2Fs.Ext2FsFragsPerGroup)
|
|
|
|
/**
|
|
The following macros optimize certain frequently calculated
|
|
quantities by using shifts and masks in place of divisions
|
|
modulos and multiplications.
|
|
**/
|
|
#define BLOCKOFFSET(fs, loc) /* calculates (loc % fs->Ext2FsBlockSize) */ \
|
|
((loc) & (fs)->Ext2FsQuadBlockOffset)
|
|
#define LBLKTOSIZE(fs, blk) /* calculates (blk * fs->Ext2FsBlockSize) */ \
|
|
((blk) << (fs)->Ext2FsLogicalBlock)
|
|
#define LBLKNO(fs, loc) /* calculates (loc / fs->Ext2FsBlockSize) */ \
|
|
((loc) >> (fs)->Ext2FsLogicalBlock)
|
|
#define BLKROUNDUP(fs, size) /* calculates roundup(size, fs->Ext2FsBlockSize) */ \
|
|
(((size) + (fs)->Ext2FsQuadBlockOffset) & (fs)->Ext2FsBlockOffset)
|
|
#define FRAGROUNDUP(fs, size) /* calculates roundup(size, fs->Ext2FsBlockSize) */ \
|
|
(((size) + (fs)->Ext2FsQuadBlockOffset) & (fs)->Ext2FsBlockOffset)
|
|
//
|
|
// Determine the number of available frags given a
|
|
// percentage to hold in reserve.
|
|
//
|
|
#define FREESPACE(fs) \
|
|
((fs)->Ext2Fs.Ext2FsFreeBlockCount - (fs)->Ext2Fs.Ext2FsRsvdBlockCount)
|
|
|
|
//
|
|
// Number of indirects in a file system block.
|
|
//
|
|
#define NINDIR(fs) ((fs)->Ext2FsBlockSize / sizeof(UINT32))
|
|
|
|
typedef
|
|
EFI_STATUS
|
|
( *MEDIA_READ_BLOCKS) (
|
|
IN UINTN DeviceIndex,
|
|
IN EFI_PEI_LBA StartLBA,
|
|
IN UINTN BufferSize,
|
|
OUT VOID *Buffer
|
|
);
|
|
|
|
typedef struct {
|
|
UINTN Signature;
|
|
UINT64 StartBlock;
|
|
UINT64 LastBlock;
|
|
UINT32 BlockSize;
|
|
UINT8 PhysicalDevNo;
|
|
} PEI_EXT_PRIVATE_DATA;
|
|
|
|
|
|
/**
|
|
Gives the info of device block config.
|
|
|
|
@param DevData Device privete data.
|
|
@param ReadWrite Read write
|
|
@param BlockNum Block number to start
|
|
@param Size Size to read block.
|
|
@param Buf Buffer to read the block data.
|
|
@param RSize
|
|
|
|
@retval EFI_SUCCESS The function completed successfully.
|
|
@retval !EFI_SUCCESS Something error while read FILE.
|
|
**/
|
|
INT32
|
|
BDevStrategy (
|
|
VOID *DevData,
|
|
INT32 ReadWrite,
|
|
DADDRESS BlockNum,
|
|
UINT32 Size,
|
|
VOID *Buf,
|
|
UINT32 *RSize
|
|
);
|
|
#define DEV_STRATEGY(d) BDevStrategy
|
|
|
|
/**
|
|
Open struct file.
|
|
|
|
@param Path path to locate the file
|
|
@param File The struct having the device and file info
|
|
|
|
@retval 0 if Group descriptor read is success
|
|
@retval other if error.
|
|
**/
|
|
INT32
|
|
Ext2fsOpen (
|
|
CHAR8 *Path,
|
|
OPEN_FILE *File
|
|
);
|
|
|
|
/**
|
|
Close the file.
|
|
@param File File to be closed.
|
|
|
|
@retval 0 if Group descriptor read is success
|
|
**/
|
|
INT32
|
|
Ext2fsClose (
|
|
OPEN_FILE *File
|
|
);
|
|
|
|
|
|
/**
|
|
Copy a portion of a FILE into kernel memory.
|
|
Cross block boundaries when necessary
|
|
@param File
|
|
@param Start
|
|
@param Size
|
|
@param ResId
|
|
**/
|
|
INT32
|
|
Ext2fsRead (
|
|
OPEN_FILE *File,
|
|
VOID *Start,
|
|
UINT32 Size,
|
|
UINT32 *ResId
|
|
);
|
|
|
|
/**
|
|
Update the mode and size from descriptor to stat Block.
|
|
contains that block.
|
|
@param File pointer to an file private data.
|
|
@param StatBlock pointer to File information (stats).
|
|
@retval 0 if success
|
|
**/
|
|
INT32
|
|
Ext2fsStat (
|
|
OPEN_FILE *File,
|
|
STAT *StatBlock
|
|
);
|
|
|
|
#if defined(LIBSA_ENABLE_LS_OP)
|
|
/**
|
|
Update the mode and size from descriptor to stat Block.
|
|
contains that block.
|
|
@param File pointer to an file private data
|
|
@param Pattern pointer to Pattern
|
|
**/
|
|
VOID
|
|
Ext2fsLs (
|
|
OPEN_FILE *File,
|
|
const CHAR8 *Pattern
|
|
);
|
|
#endif
|
|
|
|
/**
|
|
|
|
Determine the disk block(s) that contains data for FILE <File>,
|
|
starting at Offset <FilePosition> and extending for up to <Len> bytes.
|
|
@param File Pointer to an file private data.
|
|
@param FilePosition offset address of the file position.
|
|
@param Len Number of bytes
|
|
@param NBlocks Number of consecutive blocks
|
|
|
|
@retval First disk block, number of consecutive blocks thru *<nblock>.
|
|
**/
|
|
INT32
|
|
Ext2fsDiskBlocks (
|
|
OPEN_FILE *File,
|
|
UINT32 FilePosition,
|
|
UINT32 Len,
|
|
UINT32 *NBlocks
|
|
);
|
|
|
|
/**
|
|
Given an offset in a FILE, find the disk block number that
|
|
contains that block.
|
|
@param OpenFile pointer to an Open file.
|
|
@param Stat Block to find the file.
|
|
@param Name Pointer to the disk which contains block.
|
|
@param NamLen
|
|
@retval 0 if success
|
|
@retval other if error.
|
|
**/
|
|
INT32
|
|
Ext2fsLookUpFile (
|
|
OPEN_FILE *OpenFile,
|
|
STAT *Stat,
|
|
CHAR8 *Name,
|
|
UINT32 NamLen
|
|
);
|
|
|
|
/**
|
|
Updates the seek ptr of file based on seek point.
|
|
@param File pointer to an Open file.
|
|
@param Offset Offset to update the seekptr.
|
|
@param Where Seek point where it needs to be update.
|
|
|
|
**/
|
|
OFFSET
|
|
Ext2fsSeek (
|
|
OPEN_FILE *File,
|
|
OFFSET Offset,
|
|
INT32 Where
|
|
);
|
|
|
|
/**
|
|
Read Superblock of the file.
|
|
@param File File for which super block needs to be read.
|
|
@param FileSystem Fs on which super block is computed.
|
|
|
|
@retval 0 if superblock compute is success
|
|
@retval other if error.
|
|
**/
|
|
INT32
|
|
ReadSBlock (
|
|
OPEN_FILE *File,
|
|
M_EXT2FS *FileSystem
|
|
);
|
|
|
|
/**
|
|
Read group descriptor of the file.
|
|
@param File File for which group descriptor needs to be read.
|
|
@param FileSystem Fs on which super block is computed.
|
|
|
|
@retval 0 if Group descriptor read is success
|
|
@retval other if error.
|
|
**/
|
|
INT32
|
|
ReadGDBlock (
|
|
OPEN_FILE *File,
|
|
M_EXT2FS *FileSystem
|
|
);
|
|
|
|
/**
|
|
Gets the size of the file from descriptor.
|
|
|
|
@param File File to be closed.
|
|
@retval size of the file from descriptor.
|
|
**/
|
|
UINT32
|
|
Ext2fsFileSize (
|
|
OPEN_FILE *File
|
|
);
|
|
|
|
#ifdef EXT2FS_DEBUG
|
|
/**
|
|
Dump the file system super block info.
|
|
|
|
@param FileSystem pointer to filesystem.
|
|
**/
|
|
VOID
|
|
DumpSBlock (
|
|
M_EXT2FS *FileSystem
|
|
);
|
|
#endif
|
|
|
|
#endif // !_UFS_EXT2FS_EXT2FS_H_
|