i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

xfs: Style cleanup, no functional change

Browse Source 
Change-Id: I698dbaa6f51c185eaaac2e0b058b1c6ce994218e
Reviewed-on: https://review.haiku-os.org/c/haiku/+/10536
Reviewed-by: Adrien Destugues <[email protected]>
This commit is contained in:
Mohamed Mahrous
2026-05-07 10:03:31 +00:00
committed by Adrien Destugues
parent ead5f1bdfc
commit 9de308df97
11 changed files with 79 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/xfs/BPlusTree.cpp
+3 -3
View File
@@ -839,9 +839,9 @@ TreeDirectory::Lookup(const char* name, size_t length, xfs_ino_t* ino)
uint32 uint32
LongBlock::ExpectedMagic(int8 WhichDirectory, Inode* inode) LongBlock::ExpectedMagic(int8 whichDirectory, Inode* inode)
{ {
if(inode->Version() == 3) if (inode->Version() == 3)
return XFS_BMAP_CRC_MAGIC; return XFS_BMAP_CRC_MAGIC;
else else
return XFS_BMAP_MAGIC; return XFS_BMAP_MAGIC;
@@ -852,4 +852,4 @@ uint32
LongBlock::CRCOffset() LongBlock::CRCOffset()
{ {
return offsetof(LongBlock, bb_crc); return offsetof(LongBlock, bb_crc);
} }
src/add-ons/kernel/file_systems/xfs/Inode.cpp
+16 -19
View File
@@ -158,17 +158,17 @@ Inode::VerifyForkoff() const
if (!fNode->di_forkoff) if (!fNode->di_forkoff)
return true; return true;
switch(Format()) { switch (Format()) {
case XFS_DINODE_FMT_DEV: case XFS_DINODE_FMT_DEV:
if (fNode->di_forkoff != (ROUNDUP(sizeof(uint32), 8) >> 3)) if (fNode->di_forkoff != (ROUNDUP(sizeof(uint32), 8) >> 3))
return false; return false;
break; break;
case XFS_DINODE_FMT_LOCAL: case XFS_DINODE_FMT_LOCAL:
case XFS_DINODE_FMT_EXTENTS: case XFS_DINODE_FMT_EXTENTS:
case XFS_DINODE_FMT_BTREE: case XFS_DINODE_FMT_BTREE:
if (fNode->di_forkoff >= (LITINO(fVolume) >> 3)) if (fNode->di_forkoff >= (LITINO(fVolume) >> 3))
return false; return false;
break; break;
default: default:
return false; return false;
} }
@@ -180,7 +180,7 @@ Inode::VerifyForkoff() const
bool bool
Inode::VerifyInode() const Inode::VerifyInode() const
{ {
if(fNode->di_magic != INODE_MAGIC) { if (fNode->di_magic != INODE_MAGIC) {
ERROR("Bad inode magic number"); ERROR("Bad inode magic number");
return false; return false;
} }
@@ -194,28 +194,28 @@ Inode::VerifyInode() const
// verify version 3 inodes first // verify version 3 inodes first
if (Version() == 3) { if (Version() == 3) {
if(!HAS_V3INODES(fVolume)) { if (!HAS_V3INODES(fVolume)) {
ERROR("xfs v4 doesn't have v3 inodes"); ERROR("xfs v4 doesn't have v3 inodes");
return false; return false;
} }
if(!xfs_verify_cksum(fBuffer, fVolume->InodeSize(), INODE_CRC_OFF)) { if (!xfs_verify_cksum(fBuffer, fVolume->InodeSize(), INODE_CRC_OFF)) {
ERROR("Inode is corrupted"); ERROR("Inode is corrupted");
return false; return false;
} }
if(fNode->di_ino != fId) { if (fNode->di_ino != fId) {
ERROR("Incorrect inode number"); ERROR("Incorrect inode number");
return false; return false;
} }
if(!fVolume->UuidEquals(fNode->di_uuid)) { if (!fVolume->UuidEquals(fNode->di_uuid)) {
ERROR("UUID is incorrect"); ERROR("UUID is incorrect");
return false; return false;
} }
} }
if(fNode->di_size & (1ULL << 63)) { if ((fNode->di_size & (1ULL << 63)) != 0) {
ERROR("Invalid EOF of inode"); ERROR("Invalid EOF of inode");
return false; return false;
} }
@@ -225,7 +225,7 @@ Inode::VerifyInode() const
return false; return false;
} }
if(!VerifyForkoff()) { if (!VerifyForkoff()) {
ERROR("Invalid inode fork offset"); ERROR("Invalid inode fork offset");
return false; return false;
} }
@@ -396,10 +396,8 @@ Inode::MaxRecordsPossibleInTreeRoot()
size_t lengthOfDataFork; size_t lengthOfDataFork;
if (ForkOffset() != 0) if (ForkOffset() != 0)
lengthOfDataFork = ForkOffset() << 3; lengthOfDataFork = ForkOffset() << 3;
else if(ForkOffset() == 0) { else if (ForkOffset() == 0)
lengthOfDataFork = GetVolume()->InodeSize() lengthOfDataFork = GetVolume()->InodeSize() - CoreInodeSize();
- CoreInodeSize();
}
lengthOfDataFork -= sizeof(BlockInDataFork); lengthOfDataFork -= sizeof(BlockInDataFork);
return lengthOfDataFork / (XFS_KEY_SIZE + XFS_PTR_SIZE); return lengthOfDataFork / (XFS_KEY_SIZE + XFS_PTR_SIZE);
@@ -645,11 +643,10 @@ Inode::ReadAt(off_t pos, uint8* buffer, size_t* length)
is not possible we will read file of remaining bytes. is not possible we will read file of remaining bytes.
This meathod will change when we will add file cache for xfs. This meathod will change when we will add file cache for xfs.
*/ */
if(lengthLeftInFile >= 4096) { if (lengthLeftInFile >= 4096)
*length = 4096; *length = 4096;
} else { else
*length = lengthLeftInFile; *length = lengthLeftInFile;
}
// We could be almost at the end of the file // We could be almost at the end of the file
if (lengthLeftInFile <= lengthLeftInBlock) if (lengthLeftInFile <= lengthLeftInBlock)
@@ -708,7 +705,7 @@ Inode::GetFromDisk()
TRACE("AgNumber: (%" B_PRIu32 "), AgRelativeIno: (%" B_PRIu32 ")," TRACE("AgNumber: (%" B_PRIu32 "), AgRelativeIno: (%" B_PRIu32 "),"
"AgRelativeBlockNum: (%" B_PRIu32 "),Offset: (%" B_PRId64 ")," "AgRelativeBlockNum: (%" B_PRIu32 "),Offset: (%" B_PRId64 "),"
"len: (%" B_PRIu32 ")\n", agNo,agRelativeInodeNo, agBlock, offset, len); "len: (%" B_PRIu32 ")\n", agNo, agRelativeInodeNo, agBlock, offset, len);
if (agNo > fVolume->AgCount()) { if (agNo > fVolume->AgCount()) {
ERROR("Inode::GetFromDisk : AG Number more than number of AGs"); ERROR("Inode::GetFromDisk : AG Number more than number of AGs");
@@ -727,7 +724,7 @@ Inode::GetFromDisk()
return B_IO_ERROR; return B_IO_ERROR;
} }
if(fVolume->IsVersion5()) if (fVolume->IsVersion5())
memcpy(fNode, fBuffer, sizeof(Inode::Dinode)); memcpy(fNode, fBuffer, sizeof(Inode::Dinode));
else else
memcpy(fNode, fBuffer, INODE_CRC_OFF); memcpy(fNode, fBuffer, INODE_CRC_OFF);
src/add-ons/kernel/file_systems/xfs/LeafAttribute.cpp
+4 -4
View File
@@ -147,7 +147,7 @@ LeafAttribute::Stat(attr_cookie* cookie, struct stat& stat)
// check if this attribute exists // check if this attribute exists
status = Lookup(fName, &namelength); status = Lookup(fName, &namelength);
if(status != B_OK) if (status != B_OK)
return status; return status;
// We have valid attribute entry to stat // We have valid attribute entry to stat
@@ -170,7 +170,7 @@ LeafAttribute::Read(attr_cookie* cookie, off_t pos, uint8* buffer, size_t* lengt
{ {
TRACE("LeafAttribute::Read\n"); TRACE("LeafAttribute::Read\n");
if(pos < 0) if (pos < 0)
return B_BAD_VALUE; return B_BAD_VALUE;
fName = cookie->name; fName = cookie->name;
@@ -237,7 +237,7 @@ LeafAttribute::GetNext(char* name, size_t* nameLength)
{ {
TRACE("LeafAttribute::GetNext\n"); TRACE("LeafAttribute::GetNext\n");
AttrLeafHeader* header = AttrLeafHeader::Create(fInode,fLeafBuffer); AttrLeafHeader* header = AttrLeafHeader::Create(fInode, fLeafBuffer);
AttrLeafEntry* firstEntry = (AttrLeafEntry*)(fLeafBuffer + AttrLeafHeader::Size(fInode)); AttrLeafEntry* firstEntry = (AttrLeafEntry*)(fLeafBuffer + AttrLeafHeader::Size(fInode));
int totalEntries = header->Count(); int totalEntries = header->Count();
@@ -283,7 +283,7 @@ LeafAttribute::Lookup(const char* name, size_t* nameLength)
uint32 hashValueOfRequest = hashfunction(name, *nameLength); uint32 hashValueOfRequest = hashfunction(name, *nameLength);
TRACE("Hashval:(%" B_PRIu32 ")\n", hashValueOfRequest); TRACE("Hashval:(%" B_PRIu32 ")\n", hashValueOfRequest);
AttrLeafHeader* header = AttrLeafHeader::Create(fInode,fLeafBuffer); AttrLeafHeader* header = AttrLeafHeader::Create(fInode, fLeafBuffer);
AttrLeafEntry* entry = (AttrLeafEntry*)(fLeafBuffer + AttrLeafHeader::Size(fInode)); AttrLeafEntry* entry = (AttrLeafEntry*)(fLeafBuffer + AttrLeafHeader::Size(fInode));
int numberOfLeafEntries = header->Count(); int numberOfLeafEntries = header->Count();
src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp
+1 -1
View File
@@ -214,7 +214,7 @@ LeafDirectory::SearchAndFillDataMap(uint64 blockNo)
{ {
int len = fInode->DataExtentsCount(); int len = fInode->DataExtentsCount();
for(int i = 0; i < len - 1; i++) { for (int i = 0; i < len - 1; i++) {
FillMapEntry(i, fDataMap); FillMapEntry(i, fDataMap);
if (fDataMap->br_startoff <= blockNo if (fDataMap->br_startoff <= blockNo
&& (blockNo <= fDataMap->br_startoff + fDataMap->br_blockcount - 1)) && (blockNo <= fDataMap->br_startoff + fDataMap->br_blockcount - 1))
src/add-ons/kernel/file_systems/xfs/Node.cpp
+4 -5
View File
@@ -139,7 +139,7 @@ NodeDirectory::FillBuffer(int type, char* blockBuffer, int howManyBlocksFurthur)
if (type == DATA) { if (type == DATA) {
fDataBuffer = blockBuffer; fDataBuffer = blockBuffer;
ExtentDataHeader* header = ExtentDataHeader::Create(fInode, fDataBuffer); ExtentDataHeader* header = ExtentDataHeader::Create(fInode, fDataBuffer);
if(header == NULL) if (header == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
if (!VerifyHeader<ExtentDataHeader>(header, fDataBuffer, fInode, if (!VerifyHeader<ExtentDataHeader>(header, fDataBuffer, fInode,
howManyBlocksFurthur, fDataMap, XFS_NODE)) { howManyBlocksFurthur, fDataMap, XFS_NODE)) {
@@ -379,7 +379,7 @@ NodeDirectory::Lookup(const char* name, size_t length, xfs_ino_t* ino)
/* Leaf now has the nodes. */ /* Leaf now has the nodes. */
uint32 rightMapOffset; uint32 rightMapOffset;
status = FindHashInNode(hashValueOfRequest, &rightMapOffset); status = FindHashInNode(hashValueOfRequest, &rightMapOffset);
if(status != B_OK) if (status != B_OK)
return status; return status;
if (rightMapOffset == 1) { if (rightMapOffset == 1) {
@@ -389,8 +389,7 @@ NodeDirectory::Lookup(const char* name, size_t length, xfs_ino_t* ino)
TRACE("rightMapOffset:(%" B_PRIu32 ")\n", rightMapOffset); TRACE("rightMapOffset:(%" B_PRIu32 ")\n", rightMapOffset);
for(int i = fFirstLeafMapIndex; i < fInode->DataExtentsCount(); i++) for (int i = fFirstLeafMapIndex; i < fInode->DataExtentsCount(); i++) {
{
FillMapEntry(i, fLeafMap); FillMapEntry(i, fLeafMap);
fCurLeafMapNumber = 2; fCurLeafMapNumber = 2;
status = FillBuffer(LEAF, fLeafBuffer, status = FillBuffer(LEAF, fLeafBuffer,
@@ -399,7 +398,7 @@ NodeDirectory::Lookup(const char* name, size_t length, xfs_ino_t* ino)
return status; return status;
fCurLeafBufferNumber = 2; fCurLeafBufferNumber = 2;
ExtentLeafHeader* leafHeader = ExtentLeafHeader::Create(fInode, fLeafBuffer); ExtentLeafHeader* leafHeader = ExtentLeafHeader::Create(fInode, fLeafBuffer);
if(leafHeader == NULL) if (leafHeader == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
ExtentLeafEntry* leafEntry = ExtentLeafEntry* leafEntry =
(ExtentLeafEntry*)(void*)(fLeafBuffer + ExtentLeafHeader::Size(fInode)); (ExtentLeafEntry*)(void*)(fLeafBuffer + ExtentLeafHeader::Size(fInode));
src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp
+4 -4
View File
@@ -59,7 +59,7 @@ NodeAttribute::Init()
if (status != B_OK) if (status != B_OK)
return status; return status;
NodeHeader* header = NodeHeader::Create(fInode,fNodeBuffer); NodeHeader* header = NodeHeader::Create(fInode, fNodeBuffer);
if (header == NULL) if (header == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
@@ -171,7 +171,7 @@ NodeAttribute::Stat(attr_cookie* cookie, struct stat& stat)
// check if this attribute exists // check if this attribute exists
status = Lookup(fName, &namelength); status = Lookup(fName, &namelength);
if(status != B_OK) if (status != B_OK)
return status; return status;
// We have valid attribute entry to stat // We have valid attribute entry to stat
@@ -355,7 +355,7 @@ NodeAttribute::Lookup(const char* name, size_t* nameLength)
xfs_fsblock_t block = _LogicalToFileSystemBlock(logicalBlock); xfs_fsblock_t block = _LogicalToFileSystemBlock(logicalBlock);
_FillBuffer(fLeafBuffer, block); _FillBuffer(fLeafBuffer, block);
AttrLeafHeader* header = AttrLeafHeader::Create(fInode,fLeafBuffer); AttrLeafHeader* header = AttrLeafHeader::Create(fInode, fLeafBuffer);
AttrLeafEntry* entry = (AttrLeafEntry*)(fLeafBuffer + AttrLeafHeader::Size(fInode)); AttrLeafEntry* entry = (AttrLeafEntry*)(fLeafBuffer + AttrLeafHeader::Size(fInode));
int numberOfLeafEntries = header->Count(); int numberOfLeafEntries = header->Count();
@@ -397,4 +397,4 @@ NodeAttribute::Lookup(const char* name, size_t* nameLength)
} }
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
src/add-ons/kernel/file_systems/xfs/ShortAttribute.cpp
+1 -1
View File
@@ -102,7 +102,7 @@ ShortAttribute::Read(attr_cookie* cookie, off_t pos, uint8* buffer, size_t* leng
status_t status = Lookup(fName, &namelength); status_t status = Lookup(fName, &namelength);
if(status != B_OK) if (status != B_OK)
return status; return status;
if (pos + *length > fEntry->valuelen) if (pos + *length > fEntry->valuelen)
src/add-ons/kernel/file_systems/xfs/VerifyHeader.h
+3 -2
View File
@@ -35,7 +35,7 @@ bool VerifyHeader(T* header, char* buffer, Inode* inode,
} }
// For Block header we pass NULL // For Block header we pass NULL
if(map != NULL) { if (map != NULL) {
uint64 actualBlockToRead = inode->FileSystemBlockToAddr(map->br_startblock uint64 actualBlockToRead = inode->FileSystemBlockToAddr(map->br_startblock
+ howManyBlocksFurther) / XFS_MIN_BLOCKSIZE; + howManyBlocksFurther) / XFS_MIN_BLOCKSIZE;
@@ -58,4 +58,5 @@ bool VerifyHeader(T* header, char* buffer, Inode* inode,
return true; return true;
} }
#endif
#endif
src/add-ons/kernel/file_systems/xfs/Volume.cpp
+4 -5
View File
@@ -43,7 +43,7 @@ Volume::Identify(int fd, XfsSuperBlock *superBlock)
//Create a buffer of 512 bytes for Crc verification //Create a buffer of 512 bytes for Crc verification
char buf[512]; char buf[512];
if(read_pos(fd, 0, buf, 512) != 512) if (read_pos(fd, 0, buf, 512) != 512)
return B_IO_ERROR; return B_IO_ERROR;
memcpy(superBlock, buf, sizeof(XfsSuperBlock)); memcpy(superBlock, buf, sizeof(XfsSuperBlock));
@@ -56,11 +56,10 @@ Volume::Identify(int fd, XfsSuperBlock *superBlock)
TRACE("Superblock Crc: (%" B_PRIu32 ")\n", superBlock->Crc()); TRACE("Superblock Crc: (%" B_PRIu32 ")\n", superBlock->Crc());
if(!xfs_verify_cksum(buf, 512, XfsSuperBlock::Offset_crc())) { if (!xfs_verify_cksum(buf, 512, XfsSuperBlock::Offset_crc())) {
ERROR("Filesystem is corrupted"); ERROR("Filesystem is corrupted");
return B_BAD_VALUE; return B_BAD_VALUE;
} }
} }
superBlock->SwapEndian(); superBlock->SwapEndian();
src/add-ons/kernel/file_systems/xfs/kernel_interface.cpp
+13 -15
View File
@@ -123,7 +123,7 @@ xfs_read_fs_info(fs_volume *_volume, struct fs_info *info)
strlcpy(info->volume_name, volume->Name(), sizeof(info->volume_name)); strlcpy(info->volume_name, volume->Name(), sizeof(info->volume_name));
// Filesystem name // Filesystem name
if(volume->IsVersion5()) if (volume->IsVersion5())
strlcpy(info->fsh_name, "xfs V5", sizeof(info->fsh_name)); strlcpy(info->fsh_name, "xfs V5", sizeof(info->fsh_name));
else else
strlcpy(info->fsh_name, "xfs V4", sizeof(info->fsh_name)); strlcpy(info->fsh_name, "xfs V4", sizeof(info->fsh_name));
@@ -268,7 +268,7 @@ xfs_read_stat(fs_volume *_volume, fs_vnode *_node, struct stat *stat)
inode->GetChangeTime(stat->st_ctim); inode->GetChangeTime(stat->st_ctim);
// Only version 3 Inodes has creation time // Only version 3 Inodes has creation time
if(inode->Version() == 3) if (inode->Version() == 3)
inode->GetCreationTime(stat->st_crtim); inode->GetCreationTime(stat->st_crtim);
else else
inode->GetChangeTime(stat->st_crtim); inode->GetChangeTime(stat->st_crtim);
@@ -311,7 +311,7 @@ xfs_open(fs_volume * /*_volume*/, fs_vnode *_node, int openMode,
static status_t static status_t
xfs_read(fs_volume *_volume, fs_vnode *_node, void *_cookie, off_t pos, xfs_read(fs_volume* _volume, fs_vnode* _node, void* _cookie, off_t pos,
void *buffer, size_t *_length) void *buffer, size_t *_length)
{ {
TRACE("Inode::ReadAt: pos:(%ld), *length:(%ld)\n", pos, *_length); TRACE("Inode::ReadAt: pos:(%ld), *length:(%ld)\n", pos, *_length);
@@ -327,14 +327,14 @@ xfs_read(fs_volume *_volume, fs_vnode *_node, void *_cookie, off_t pos,
static status_t static status_t
xfs_close(fs_volume *_volume, fs_vnode *_node, void *_cookie) xfs_close(fs_volume* _volume, fs_vnode* _node, void* _cookie)
{ {
return B_OK; return B_OK;
} }
static status_t static status_t
xfs_free_cookie(fs_volume *_volume, fs_vnode *_node, void *_cookie) xfs_free_cookie(fs_volume* _volume, fs_vnode* _node, void* _cookie)
{ {
TRACE("XFS_FREE_COOKIE:\n"); TRACE("XFS_FREE_COOKIE:\n");
file_cookie* cookie = (file_cookie*)_cookie; file_cookie* cookie = (file_cookie*)_cookie;
@@ -350,7 +350,7 @@ xfs_free_cookie(fs_volume *_volume, fs_vnode *_node, void *_cookie)
static status_t static status_t
xfs_access(fs_volume *_volume, fs_vnode *_node, int accessMode) xfs_access(fs_volume* _volume, fs_vnode* _node, int accessMode)
{ {
Inode* inode = (Inode*)_node->private_node; Inode* inode = (Inode*)_node->private_node;
return inode->CheckPermissions(accessMode); return inode->CheckPermissions(accessMode);
@@ -358,8 +358,7 @@ xfs_access(fs_volume *_volume, fs_vnode *_node, int accessMode)
static status_t static status_t
xfs_read_link(fs_volume *_volume, fs_vnode *_node, char *buffer, xfs_read_link(fs_volume *_volume, fs_vnode *_node, char *buffer, size_t* _bufferSize)
size_t *_bufferSize)
{ {
TRACE("XFS_READ_SYMLINK\n"); TRACE("XFS_READ_SYMLINK\n");
@@ -377,7 +376,7 @@ xfs_read_link(fs_volume *_volume, fs_vnode *_node, char *buffer,
status_t status_t
xfs_unlink(fs_volume *_volume, fs_vnode *_directory, const char *name) xfs_unlink(fs_volume* _volume, fs_vnode* _directory, const char* name)
{ {
return B_NOT_SUPPORTED; return B_NOT_SUPPORTED;
} }
@@ -387,22 +386,21 @@ xfs_unlink(fs_volume *_volume, fs_vnode *_directory, const char *name)
static status_t static status_t
xfs_create_dir(fs_volume *_volume, fs_vnode *_directory, const char *name, xfs_create_dir(fs_volume* _volume, fs_vnode* _directory, const char* name, int mode)
int mode)
{ {
return B_NOT_SUPPORTED; return B_NOT_SUPPORTED;
} }
static status_t static status_t
xfs_remove_dir(fs_volume *_volume, fs_vnode *_directory, const char *name) xfs_remove_dir(fs_volume* _volume, fs_vnode* _directory, const char* name)
{ {
return B_NOT_SUPPORTED; return B_NOT_SUPPORTED;
} }
static status_t static status_t
xfs_open_dir(fs_volume * /*_volume*/, fs_vnode *_node, void **_cookie) xfs_open_dir(fs_volume* /*_volume*/, fs_vnode* _node, void** _cookie)
{ {
Inode* inode = (Inode*)_node->private_node; Inode* inode = (Inode*)_node->private_node;
TRACE("XFS_OPEN_DIR: (%ld)\n", inode->ID()); TRACE("XFS_OPEN_DIR: (%ld)\n", inode->ID());
@@ -424,8 +422,8 @@ xfs_open_dir(fs_volume * /*_volume*/, fs_vnode *_node, void **_cookie)
static status_t static status_t
xfs_read_dir(fs_volume *_volume, fs_vnode *_node, void *_cookie, xfs_read_dir(fs_volume *_volume, fs_vnode *_node, void *_cookie, struct dirent* buffer,
struct dirent *buffer, size_t bufferSize, uint32 *_num) size_t bufferSize, uint32* _num)
{ {
TRACE("XFS_READ_DIR\n"); TRACE("XFS_READ_DIR\n");
DirectoryIterator* iterator = (DirectoryIterator*)_cookie; DirectoryIterator* iterator = (DirectoryIterator*)_cookie;
src/add-ons/kernel/file_systems/xfs/xfs.cpp
+26 -30
View File
@@ -56,19 +56,19 @@ bool
XfsSuperBlock::IsValidFeatureMask() const XfsSuperBlock::IsValidFeatureMask() const
{ {
// Version 5 superblock feature mask validation // Version 5 superblock feature mask validation
if(sb_features_compat & XFS_SB_FEAT_COMPAT_UNKNOWN) { if (sb_features_compat & XFS_SB_FEAT_COMPAT_UNKNOWN) {
ERROR("Superblock has unknown compatible features enabled"); ERROR("Superblock has unknown compatible features enabled");
ERROR("Use more recent kernal"); ERROR("Use more recent kernal");
} }
// We cannot have write support if this is set // We cannot have write support if this is set
if(sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_UNKNOWN) { if (sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_UNKNOWN) {
ERROR("Superblock has unknown read-only compatible features enabled"); ERROR("Superblock has unknown read-only compatible features enabled");
ERROR("Filesystem is read-only"); ERROR("Filesystem is read-only");
} }
// check for incompatible features // check for incompatible features
if(sb_features_incompat & XFS_SB_FEAT_INCOMPAT_UNKNOWN) { if (sb_features_incompat & XFS_SB_FEAT_INCOMPAT_UNKNOWN) {
ERROR("Superblock has unknown incompatible features enabled"); ERROR("Superblock has unknown incompatible features enabled");
return false; return false;
} }
@@ -92,14 +92,12 @@ XfsSuperBlock::IsValid() const
} }
// Checking correct version of filesystem // Checking correct version of filesystem
if(!(IsValidVersion())) { if (!(IsValidVersion()))
return false; return false;
}
if ((Version() & XFS_SB_VERSION_NUMBITS) == 4) { if ((Version() & XFS_SB_VERSION_NUMBITS) == 4) {
if(sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD | if (sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD | XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD)) {
XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD)) {
ERROR("V4 Superblock has XFS_{P|G}QUOTA_{ENFD|CHKD} bits"); ERROR("V4 Superblock has XFS_{P|G}QUOTA_{ENFD|CHKD} bits");
return false; return false;
} }
@@ -107,9 +105,8 @@ XfsSuperBlock::IsValid() const
return true; return true;
} }
if(!(IsValidFeatureMask())) { if (!(IsValidFeatureMask()))
return false; return false;
}
// For V5 // For V5
if (XFS_MIN_CRC_BLOCKSIZE > sb_blocksize) { if (XFS_MIN_CRC_BLOCKSIZE > sb_blocksize) {
@@ -130,23 +127,23 @@ XfsSuperBlock::IsValid() const
*/ */
// Sanity Checking // Sanity Checking
if(sb_agcount <= 0 if (sb_agcount <= 0
|| sb_sectsize < XFS_MIN_SECTORSIZE || sb_sectsize < XFS_MIN_SECTORSIZE
|| sb_sectsize > XFS_MAX_SECTORSIZE || sb_sectsize > XFS_MAX_SECTORSIZE
|| sb_sectlog < XFS_MIN_SECTORSIZE_LOG || sb_sectlog < XFS_MIN_SECTORSIZE_LOG
|| sb_sectlog > XFS_MAX_SECTORSIZE_LOG || sb_sectlog > XFS_MAX_SECTORSIZE_LOG
|| sb_sectsize != (1 << sb_sectlog) || sb_sectsize != (1 << sb_sectlog)
|| sb_blocksize < XFS_MIN_BLOCKSIZE || sb_blocksize < XFS_MIN_BLOCKSIZE
|| sb_blocksize > XFS_MAX_BLOCKSIZE || sb_blocksize > XFS_MAX_BLOCKSIZE
|| sb_blocklog < XFS_MIN_BLOCKSIZE_LOG || sb_blocklog < XFS_MIN_BLOCKSIZE_LOG
|| sb_blocklog > XFS_MAX_BLOCKSIZE_LOG || sb_blocklog > XFS_MAX_BLOCKSIZE_LOG
|| sb_blocksize != (uint32)(1 << sb_blocklog) || sb_blocksize != (uint32)(1 << sb_blocklog)
|| sb_dirblklog + sb_blocklog > XFS_MAX_BLOCKSIZE_LOG || sb_dirblklog + sb_blocklog > XFS_MAX_BLOCKSIZE_LOG
|| sb_inodesize < INODE_MIN_SIZE || sb_inodesize < INODE_MIN_SIZE
|| sb_inodesize > INODE_MAX_SIZE || sb_inodesize > INODE_MAX_SIZE
|| sb_inodelog < INODE_MINSIZE_LOG || sb_inodelog < INODE_MINSIZE_LOG
|| sb_inodelog > INODE_MAXSIZE_LOG || sb_inodelog > INODE_MAXSIZE_LOG
|| sb_inodesize != (1 << sb_inodelog)) { || sb_inodesize != (1 << sb_inodelog)) {
ERROR("Sanity checking failed"); ERROR("Sanity checking failed");
return false; return false;
@@ -321,11 +318,10 @@ XfsSuperBlock::MagicNum() const
bool bool
XfsSuperBlock::UuidEquals(const uuid_t& u1) XfsSuperBlock::UuidEquals(const uuid_t& u1)
{ {
if((sb_features_incompat & XFS_SB_FEAT_INCOMPAT_META_UUID) != 0) { if ((sb_features_incompat & XFS_SB_FEAT_INCOMPAT_META_UUID) != 0)
return memcmp(&u1, &sb_meta_uuid, sizeof(uuid_t)) == 0; return memcmp(&u1, &sb_meta_uuid, sizeof(uuid_t)) == 0;
} else { else
return memcmp(&u1, &sb_uuid, sizeof(uuid_t)) == 0; return memcmp(&u1, &sb_uuid, sizeof(uuid_t)) == 0;
}
return false; return false;
} }