Page Menu
Home
FreeBSD
Search
Configure Global Search
Log In
Files
F98051823
D24685.diff
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Flag For Later
Award Token
Size
110 KB
Referenced Files
None
Subscribers
None
D24685.diff
View Options
Index: head/sys/fs/ext2fs/ext2_alloc.c
===================================================================
--- head/sys/fs/ext2fs/ext2_alloc.c
+++ head/sys/fs/ext2fs/ext2_alloc.c
@@ -397,7 +397,7 @@
ump = pip->i_ump;
EXT2_LOCK(ump);
- if (fs->e2fs->e2fs_ficount == 0)
+ if (fs->e2fs_ficount == 0)
goto noinodes;
/*
* If it is a directory then obtain a cylinder group based on
@@ -413,7 +413,7 @@
if (fs->e2fs_contigdirs[cg] > 0)
fs->e2fs_contigdirs[cg]--;
}
- ipref = cg * fs->e2fs->e2fs_ipg + 1;
+ ipref = cg * fs->e2fs_ipg + 1;
ino = (ino_t)ext2_hashalloc(pip, cg, (long)ipref, mode, ext2_nodealloccg);
if (ino == 0)
goto noinodes;
@@ -501,87 +501,87 @@
e2fs_gd_get_b_bitmap(struct ext2_gd *gd)
{
- return (((uint64_t)(gd->ext4bgd_b_bitmap_hi) << 32) |
- gd->ext2bgd_b_bitmap);
+ return (((uint64_t)(le32toh(gd->ext4bgd_b_bitmap_hi)) << 32) |
+ le32toh(gd->ext2bgd_b_bitmap));
}
uint64_t
e2fs_gd_get_i_bitmap(struct ext2_gd *gd)
{
- return (((uint64_t)(gd->ext4bgd_i_bitmap_hi) << 32) |
- gd->ext2bgd_i_bitmap);
+ return (((uint64_t)(le32toh(gd->ext4bgd_i_bitmap_hi)) << 32) |
+ le32toh(gd->ext2bgd_i_bitmap));
}
uint64_t
e2fs_gd_get_i_tables(struct ext2_gd *gd)
{
- return (((uint64_t)(gd->ext4bgd_i_tables_hi) << 32) |
- gd->ext2bgd_i_tables);
+ return (((uint64_t)(le32toh(gd->ext4bgd_i_tables_hi)) << 32) |
+ le32toh(gd->ext2bgd_i_tables));
}
static uint32_t
e2fs_gd_get_nbfree(struct ext2_gd *gd)
{
- return (((uint32_t)(gd->ext4bgd_nbfree_hi) << 16) |
- gd->ext2bgd_nbfree);
+ return (((uint32_t)(le16toh(gd->ext4bgd_nbfree_hi)) << 16) |
+ le16toh(gd->ext2bgd_nbfree));
}
static void
e2fs_gd_set_nbfree(struct ext2_gd *gd, uint32_t val)
{
- gd->ext2bgd_nbfree = val & 0xffff;
- gd->ext4bgd_nbfree_hi = val >> 16;
+ gd->ext2bgd_nbfree = htole16(val & 0xffff);
+ gd->ext4bgd_nbfree_hi = htole16(val >> 16);
}
static uint32_t
e2fs_gd_get_nifree(struct ext2_gd *gd)
{
- return (((uint32_t)(gd->ext4bgd_nifree_hi) << 16) |
- gd->ext2bgd_nifree);
+ return (((uint32_t)(le16toh(gd->ext4bgd_nifree_hi)) << 16) |
+ le16toh(gd->ext2bgd_nifree));
}
static void
e2fs_gd_set_nifree(struct ext2_gd *gd, uint32_t val)
{
- gd->ext2bgd_nifree = val & 0xffff;
- gd->ext4bgd_nifree_hi = val >> 16;
+ gd->ext2bgd_nifree = htole16(val & 0xffff);
+ gd->ext4bgd_nifree_hi = htole16(val >> 16);
}
uint32_t
e2fs_gd_get_ndirs(struct ext2_gd *gd)
{
- return (((uint32_t)(gd->ext4bgd_ndirs_hi) << 16) |
- gd->ext2bgd_ndirs);
+ return (((uint32_t)(le16toh(gd->ext4bgd_ndirs_hi)) << 16) |
+ le16toh(gd->ext2bgd_ndirs));
}
static void
e2fs_gd_set_ndirs(struct ext2_gd *gd, uint32_t val)
{
- gd->ext2bgd_ndirs = val & 0xffff;
- gd->ext4bgd_ndirs_hi = val >> 16;
+ gd->ext2bgd_ndirs = htole16(val & 0xffff);
+ gd->ext4bgd_ndirs_hi = htole16(val >> 16);
}
static uint32_t
e2fs_gd_get_i_unused(struct ext2_gd *gd)
{
- return (((uint32_t)(gd->ext4bgd_i_unused_hi) << 16) |
- gd->ext4bgd_i_unused);
+ return ((uint32_t)(le16toh(gd->ext4bgd_i_unused_hi) << 16) |
+ le16toh(gd->ext4bgd_i_unused));
}
static void
e2fs_gd_set_i_unused(struct ext2_gd *gd, uint32_t val)
{
- gd->ext4bgd_i_unused = val & 0xffff;
- gd->ext4bgd_i_unused_hi = val >> 16;
+ gd->ext4bgd_i_unused = htole16(val & 0xffff);
+ gd->ext4bgd_i_unused_hi = htole16(val >> 16);
}
/*
@@ -612,7 +612,7 @@
mtx_assert(EXT2_MTX(pip->i_ump), MA_OWNED);
fs = pip->i_e2fs;
- avgifree = fs->e2fs->e2fs_ficount / fs->e2fs_gcount;
+ avgifree = fs->e2fs_ficount / fs->e2fs_gcount;
avgbfree = fs->e2fs_fbcount / fs->e2fs_gcount;
avgndir = fs->e2fs_total_dir / fs->e2fs_gcount;
@@ -653,7 +653,8 @@
minbfree = 1;
cgsize = fs->e2fs_fsize * fs->e2fs_fpg;
dirsize = AVGDIRSIZE;
- curdirsize = avgndir ? (cgsize - avgbfree * fs->e2fs_bsize) / avgndir : 0;
+ curdirsize = avgndir ?
+ (cgsize - avgbfree * fs->e2fs_bsize) / avgndir : 0;
if (dirsize < curdirsize)
dirsize = curdirsize;
maxcontigdirs = min((avgbfree * fs->e2fs_bsize) / dirsize, 255);
@@ -731,7 +732,7 @@
if (bap)
for (tmp = indx - 1; tmp >= 0; tmp--)
if (bap[tmp])
- return bap[tmp];
+ return (le32toh(bap[tmp]));
/*
* Else lets fall back to the blocknr or, if there is none, follow
@@ -739,7 +740,7 @@
*/
return (blocknr ? blocknr :
(e2fs_daddr_t)(ip->i_block_group *
- EXT2_BLOCKS_PER_GROUP(fs)) + fs->e2fs->e2fs_first_dblock);
+ EXT2_BLOCKS_PER_GROUP(fs)) + le32toh(fs->e2fs->e2fs_first_dblock));
}
/*
@@ -802,7 +803,7 @@
return (0);
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG))
- return (fs->e2fs->e3fs_first_meta_bg);
+ return (le32toh(fs->e2fs->e3fs_first_meta_bg));
return ((fs->e2fs_gcount + EXT2_DESCS_PER_BLOCK(fs) - 1) /
EXT2_DESCS_PER_BLOCK(fs));
@@ -829,7 +830,7 @@
{
unsigned long first_meta_bg, metagroup;
- first_meta_bg = fs->e2fs->e3fs_first_meta_bg;
+ first_meta_bg = le32toh(fs->e2fs->e3fs_first_meta_bg);
metagroup = cg / EXT2_DESCS_PER_BLOCK(fs);
if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||
@@ -847,10 +848,11 @@
number = ext2_cg_has_sb(fs, cg);
if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||
- cg < fs->e2fs->e3fs_first_meta_bg * EXT2_DESCS_PER_BLOCK(fs)) {
+ cg < le32toh(fs->e2fs->e3fs_first_meta_bg) *
+ EXT2_DESCS_PER_BLOCK(fs)) {
if (number) {
number += ext2_cg_number_gdb(fs, cg);
- number += fs->e2fs->e2fs_reserved_ngdb;
+ number += le16toh(fs->e2fs->e2fs_reserved_ngdb);
}
} else {
number += ext2_cg_number_gdb(fs, cg);
@@ -877,7 +879,8 @@
ext2_get_group_number(struct m_ext2fs *fs, e4fs_daddr_t block)
{
- return ((block - fs->e2fs->e2fs_first_dblock) / fs->e2fs_bsize);
+ return ((block - le32toh(fs->e2fs->e2fs_first_dblock)) /
+ fs->e2fs_bsize);
}
static int
@@ -893,7 +896,7 @@
int bit, bit_max, inodes_per_block;
uint64_t start, tmp;
- if (!(fs->e2fs_gd[cg].ext4bgd_flags & EXT2_BG_BLOCK_UNINIT))
+ if (!(le16toh(fs->e2fs_gd[cg].ext4bgd_flags) & EXT2_BG_BLOCK_UNINIT))
return (0);
memset(bp->b_data, 0, fs->e2fs_bsize);
@@ -905,7 +908,8 @@
for (bit = 0; bit < bit_max; bit++)
setbit(bp->b_data, bit);
- start = (uint64_t)cg * fs->e2fs->e2fs_bpg + fs->e2fs->e2fs_first_dblock;
+ start = (uint64_t)cg * fs->e2fs_bpg +
+ le32toh(fs->e2fs->e2fs_first_dblock);
/* Set bits for block and inode bitmaps, and inode table. */
tmp = e2fs_gd_get_b_bitmap(&fs->e2fs_gd[cg]);
@@ -921,7 +925,7 @@
tmp = e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]);
inodes_per_block = fs->e2fs_bsize/EXT2_INODE_SIZE(fs);
while( tmp < e2fs_gd_get_i_tables(&fs->e2fs_gd[cg]) +
- fs->e2fs->e2fs_ipg / inodes_per_block ) {
+ fs->e2fs_ipg / inodes_per_block ) {
if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||
ext2_block_in_group(fs, tmp, cg))
setbit(bp->b_data, tmp - start);
@@ -933,11 +937,12 @@
* the blocksize * 8 ( which is the size of bitmap ), set rest
* of the block bitmap to 1
*/
- ext2_mark_bitmap_end(fs->e2fs->e2fs_bpg, fs->e2fs_bsize * 8,
+ ext2_mark_bitmap_end(fs->e2fs_bpg, fs->e2fs_bsize * 8,
bp->b_data);
/* Clean the flag */
- fs->e2fs_gd[cg].ext4bgd_flags &= ~EXT2_BG_BLOCK_UNINIT;
+ fs->e2fs_gd[cg].ext4bgd_flags = htole16(le16toh(
+ fs->e2fs_gd[cg].ext4bgd_flags) & ~EXT2_BG_BLOCK_UNINIT);
return (0);
}
@@ -951,8 +956,8 @@
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG)) {
/*
- * It is not possible to check block bitmap in case of this feature,
- * because the inode and block bitmaps and inode table
+ * It is not possible to check block bitmap in case of this
+ * feature, because the inode and block bitmaps and inode table
* blocks may not be in the group at all.
* So, skip check in this case.
*/
@@ -961,8 +966,8 @@
gd = &fs->e2fs_gd[cg];
max_bit = fs->e2fs_fpg;
- group_first_block = ((uint64_t)cg) * fs->e2fs->e2fs_fpg +
- fs->e2fs->e2fs_first_dblock;
+ group_first_block = ((uint64_t)cg) * fs->e2fs_fpg +
+ le32toh(fs->e2fs->e2fs_first_dblock);
/* Check block bitmap block number */
offset = e2fs_gd_get_b_bitmap(gd) - group_first_block;
@@ -1036,8 +1041,8 @@
goto fail;
/*
- * Check, that another thread did not not allocate the last block in this
- * group while we were waiting for the buffer.
+ * Check, that another thread did not not allocate the last block in
+ * this group while we were waiting for the buffer.
*/
if (e2fs_gd_get_nbfree(&fs->e2fs_gd[cg]) == 0)
goto fail;
@@ -1066,7 +1071,7 @@
start = dtogd(fs, bpref) / NBBY;
else
start = 0;
- end = howmany(fs->e2fs->e2fs_fpg, NBBY) - start;
+ end = howmany(fs->e2fs_fpg, NBBY) - start;
retry:
runlen = 0;
runstart = 0;
@@ -1135,7 +1140,8 @@
EXT2_UNLOCK(ump);
ext2_gd_b_bitmap_csum_set(fs, cg, bp);
bdwrite(bp);
- return (((uint64_t)cg) * fs->e2fs->e2fs_fpg + fs->e2fs->e2fs_first_dblock + bno);
+ return (((uint64_t)cg) * fs->e2fs_fpg +
+ le32toh(fs->e2fs->e2fs_first_dblock) + bno);
fail:
brelse(bp);
@@ -1203,7 +1209,7 @@
bpref = dtogd(fs, bpref);
loc = bpref / NBBY;
bit = 1 << (bpref % NBBY);
- for (run = 0, got = bpref; got < fs->e2fs->e2fs_fpg; got++) {
+ for (run = 0, got = bpref; got < fs->e2fs_fpg; got++) {
if ((bbp[loc] & bit) != 0)
run = 0;
else {
@@ -1219,7 +1225,7 @@
}
}
- if (got >= fs->e2fs->e2fs_fpg)
+ if (got >= fs->e2fs_fpg)
goto fail_lock;
/* Allocate the cluster that we found. */
@@ -1228,7 +1234,7 @@
panic("ext2_clusteralloc: map mismatch");
bno = got - run + 1;
- if (bno >= fs->e2fs->e2fs_fpg)
+ if (bno >= fs->e2fs_fpg)
panic("ext2_clusteralloc: allocated out of group");
EXT2_LOCK(ump);
@@ -1243,7 +1249,8 @@
EXT2_UNLOCK(ump);
bdwrite(bp);
- return (cg * fs->e2fs->e2fs_fpg + fs->e2fs->e2fs_first_dblock + bno);
+ return (cg * fs->e2fs_fpg + le32toh(fs->e2fs->e2fs_first_dblock)
+ + bno);
fail_lock:
EXT2_LOCK(ump);
@@ -1261,13 +1268,13 @@
fs = ip->i_e2fs;
- if (fs->e2fs_gd[cg].ext4bgd_flags & EXT2_BG_INODE_ZEROED)
+ if (le16toh(fs->e2fs_gd[cg].ext4bgd_flags) & EXT2_BG_INODE_ZEROED)
return (0);
- all_blks = fs->e2fs->e2fs_inode_size * fs->e2fs->e2fs_ipg /
+ all_blks = le16toh(fs->e2fs->e2fs_inode_size) * fs->e2fs_ipg /
fs->e2fs_bsize;
- used_blks = howmany(fs->e2fs->e2fs_ipg -
+ used_blks = howmany(fs->e2fs_ipg -
e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]),
fs->e2fs_bsize / EXT2_INODE_SIZE(fs));
@@ -1282,7 +1289,8 @@
bawrite(bp);
}
- fs->e2fs_gd[cg].ext4bgd_flags |= EXT2_BG_INODE_ZEROED;
+ fs->e2fs_gd[cg].ext4bgd_flags = htole16(le16toh(
+ fs->e2fs_gd[cg].ext4bgd_flags) | EXT2_BG_INODE_ZEROED);
return (0);
}
@@ -1329,12 +1337,15 @@
}
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||
EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
- if (fs->e2fs_gd[cg].ext4bgd_flags & EXT2_BG_INODE_UNINIT) {
+ if (le16toh(fs->e2fs_gd[cg].ext4bgd_flags) &
+ EXT2_BG_INODE_UNINIT) {
ibytes = fs->e2fs_ipg / 8;
memset(bp->b_data, 0, ibytes - 1);
ext2_fix_bitmap_tail(bp->b_data, ibytes,
fs->e2fs_bsize - 1);
- fs->e2fs_gd[cg].ext4bgd_flags &= ~EXT2_BG_INODE_UNINIT;
+ fs->e2fs_gd[cg].ext4bgd_flags = htole16(le16toh(
+ fs->e2fs_gd[cg].ext4bgd_flags) &
+ ~EXT2_BG_INODE_UNINIT);
}
ext2_gd_i_bitmap_csum_set(fs, cg, bp);
error = ext2_zero_inode_table(ip, cg);
@@ -1361,20 +1372,21 @@
}
ibp = (char *)bp->b_data;
if (ipref) {
- ipref %= fs->e2fs->e2fs_ipg;
+ ipref %= fs->e2fs_ipg;
if (isclr(ibp, ipref))
goto gotit;
}
start = ipref / NBBY;
- len = howmany(fs->e2fs->e2fs_ipg - ipref, NBBY);
+ len = howmany(fs->e2fs_ipg - ipref, NBBY);
loc = memcchr(&ibp[start], 0xff, len);
if (loc == NULL) {
len = start + 1;
start = 0;
loc = memcchr(&ibp[start], 0xff, len);
if (loc == NULL) {
- SDT_PROBE3(ext2fs, , alloc, ext2_nodealloccg_bmap_corrupted,
- cg, ipref, fs->e2fs_fsmnt);
+ SDT_PROBE3(ext2fs, , alloc,
+ ext2_nodealloccg_bmap_corrupted, cg, ipref,
+ fs->e2fs_fsmnt);
brelse(bp);
EXT2_LOCK(ump);
return (0);
@@ -1388,12 +1400,12 @@
e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) - 1);
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||
EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
- ifree = fs->e2fs->e2fs_ipg - e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]);
+ ifree = fs->e2fs_ipg - e2fs_gd_get_i_unused(&fs->e2fs_gd[cg]);
if (ipref + 1 > ifree)
e2fs_gd_set_i_unused(&fs->e2fs_gd[cg],
- fs->e2fs->e2fs_ipg - (ipref + 1));
+ fs->e2fs_ipg - (ipref + 1));
}
- fs->e2fs->e2fs_ficount--;
+ fs->e2fs_ficount--;
fs->e2fs_fmod = 1;
if ((mode & IFMT) == IFDIR) {
e2fs_gd_set_ndirs(&fs->e2fs_gd[cg],
@@ -1423,7 +1435,8 @@
ump = ip->i_ump;
cg = dtog(fs, bno);
if (bno >= fs->e2fs_bcount) {
- SDT_PROBE2(ext2fs, , alloc, ext2_blkfree_bad_block, ip->i_number, bno);
+ SDT_PROBE2(ext2fs, , alloc, ext2_blkfree_bad_block,
+ ip->i_number, bno);
return;
}
error = bread(ip->i_devvp,
@@ -1479,7 +1492,7 @@
return (0);
}
ibp = (char *)bp->b_data;
- ino = (ino - 1) % fs->e2fs->e2fs_ipg;
+ ino = (ino - 1) % fs->e2fs_ipg;
if (isclr(ibp, ino)) {
SDT_PROBE2(ext2fs, , alloc, ext2_vfree_doublefree,
fs->e2fs_fsmnt, ino);
@@ -1488,7 +1501,7 @@
}
clrbit(ibp, ino);
EXT2_LOCK(ump);
- fs->e2fs->e2fs_ficount++;
+ fs->e2fs_ficount++;
e2fs_gd_set_nifree(&fs->e2fs_gd[cg],
e2fs_gd_get_nifree(&fs->e2fs_gd[cg]) + 1);
if ((mode & IFMT) == IFDIR) {
@@ -1523,15 +1536,15 @@
start = dtogd(fs, bpref) / NBBY;
else
start = 0;
- len = howmany(fs->e2fs->e2fs_fpg, NBBY) - start;
+ len = howmany(fs->e2fs_fpg, NBBY) - start;
loc = memcchr(&bbp[start], 0xff, len);
if (loc == NULL) {
len = start + 1;
start = 0;
loc = memcchr(&bbp[start], 0xff, len);
if (loc == NULL) {
- panic("ext2_mapsearch: map corrupted: start=%d, len=%d, fs=%s",
- start, len, fs->e2fs_fsmnt);
+ panic("ext2_mapsearch: map corrupted: start=%d, len=%d,"
+ "fs=%s", start, len, fs->e2fs_fsmnt);
/* NOTREACHED */
}
}
@@ -1547,8 +1560,8 @@
return (1);
if (EXT2_HAS_COMPAT_FEATURE(fs, EXT2F_COMPAT_SPARSESUPER2)) {
- if (cg == fs->e2fs->e4fs_backup_bgs[0] ||
- cg == fs->e2fs->e4fs_backup_bgs[1])
+ if (cg == le32toh(fs->e2fs->e4fs_backup_bgs[0]) ||
+ cg == le32toh(fs->e2fs->e4fs_backup_bgs[1]))
return (1);
return (0);
}
Index: head/sys/fs/ext2fs/ext2_balloc.c
===================================================================
--- head/sys/fs/ext2fs/ext2_balloc.c
+++ head/sys/fs/ext2fs/ext2_balloc.c
@@ -40,6 +40,7 @@
#include <sys/param.h>
#include <sys/systm.h>
+#include <sys/endian.h>
#include <sys/bio.h>
#include <sys/buf.h>
#include <sys/limits.h>
@@ -220,7 +221,7 @@
return (error);
}
bap = (e2fs_daddr_t *)bp->b_data;
- nb = bap[indirs[i].in_off];
+ nb = le32toh(bap[indirs[i].in_off]);
if (i == num)
break;
i += 1;
@@ -252,7 +253,7 @@
brelse(bp);
return (error);
}
- bap[indirs[i - 1].in_off] = nb;
+ bap[indirs[i - 1].in_off] = htole32(nb);
/*
* If required, write synchronously, otherwise use
* delayed write.
@@ -284,7 +285,7 @@
nbp->b_blkno = fsbtodb(fs, nb);
if (flags & BA_CLRBUF)
vfs_bio_clrbuf(nbp);
- bap[indirs[i].in_off] = nb;
+ bap[indirs[i].in_off] = htole32(nb);
/*
* If required, write synchronously, otherwise use
* delayed write.
Index: head/sys/fs/ext2fs/ext2_bmap.c
===================================================================
--- head/sys/fs/ext2fs/ext2_bmap.c
+++ head/sys/fs/ext2fs/ext2_bmap.c
@@ -41,6 +41,7 @@
#include <sys/systm.h>
#include <sys/bio.h>
#include <sys/buf.h>
+#include <sys/endian.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/mount.h>
@@ -108,7 +109,7 @@
ump = VFSTOEXT2(mp);
lbn = bn;
ehp = (struct ext4_extent_header *)ip->i_data;
- depth = ehp->eh_depth;
+ depth = le16toh(ehp->eh_depth);
bsize = EXT2_BLOCK_SIZE(ump->um_e2fs);
*bnp = -1;
@@ -125,22 +126,26 @@
ep = path[depth].ep_ext;
if(ep) {
- if (lbn < ep->e_blk) {
+ if (lbn < le32toh(ep->e_blk)) {
if (runp != NULL) {
- *runp = min(maxrun, ep->e_blk - lbn - 1);
+ *runp = min(maxrun, le32toh(ep->e_blk) - lbn - 1);
}
- } else if (ep->e_blk <= lbn && lbn < ep->e_blk + ep->e_len) {
- *bnp = fsbtodb(fs, lbn - ep->e_blk +
- (ep->e_start_lo | (daddr_t)ep->e_start_hi << 32));
+ } else if (le32toh(ep->e_blk) <= lbn &&
+ lbn < le32toh(ep->e_blk) + le16toh(ep->e_len)) {
+ *bnp = fsbtodb(fs, lbn - le32toh(ep->e_blk) +
+ (le32toh(ep->e_start_lo) |
+ (daddr_t)le16toh(ep->e_start_hi) << 32));
if (runp != NULL) {
*runp = min(maxrun,
- ep->e_len - (lbn - ep->e_blk) - 1);
+ le16toh(ep->e_len) -
+ (lbn - le32toh(ep->e_blk)) - 1);
}
if (runb != NULL)
- *runb = min(maxrun, lbn - ep->e_blk);
+ *runb = min(maxrun, lbn - le32toh(ep->e_blk));
} else {
if (runb != NULL)
- *runb = min(maxrun, ep->e_blk + lbn - ep->e_len);
+ *runb = min(maxrun, le32toh(ep->e_blk) + lbn -
+ le16toh(ep->e_len));
}
}
@@ -283,7 +288,7 @@
if (error != 0)
return (error);
- daddr = ((e2fs_daddr_t *)bp->b_data)[ap->in_off];
+ daddr = le32toh(((e2fs_daddr_t *)bp->b_data)[ap->in_off]);
if (num == 1 && daddr && runp) {
for (bn = ap->in_off + 1;
bn < MNINDIR(ump) && *runp < maxrun &&
@@ -395,7 +400,7 @@
*/
off = ap->in_off;
do {
- daddr = ((e2fs_daddr_t *)bp->b_data)[off];
+ daddr = le32toh(((e2fs_daddr_t *)bp->b_data)[off]);
} while (daddr == 0 && ++off < MNINDIR(ump));
nextbn += off * lbn_count(ump, num - 1);
Index: head/sys/fs/ext2fs/ext2_csum.c
===================================================================
--- head/sys/fs/ext2fs/ext2_csum.c
+++ head/sys/fs/ext2fs/ext2_csum.c
@@ -77,7 +77,7 @@
{
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_CSUM_SEED))
- fs->e2fs_csum_seed = fs->e2fs->e4fs_chksum_seed;
+ fs->e2fs_csum_seed = le32toh(fs->e2fs->e4fs_chksum_seed);
else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
fs->e2fs_csum_seed = calculate_crc32c(~0, fs->e2fs->e2fs_uuid,
sizeof(fs->e2fs->e2fs_uuid));
@@ -95,13 +95,14 @@
"WARNING: mount of %s denied due bad sb csum type\n", fs->e2fs_fsmnt);
return (EINVAL);
}
- if (fs->e2fs->e4fs_sbchksum !=
+ if (le32toh(fs->e2fs->e4fs_sbchksum) !=
calculate_crc32c(~0, (const char *)fs->e2fs,
offsetof(struct ext2fs, e4fs_sbchksum))) {
printf(
"WARNING: mount of %s denied due bad sb csum=0x%x, expected=0x%x - run fsck\n",
- fs->e2fs_fsmnt, fs->e2fs->e4fs_sbchksum, calculate_crc32c(~0,
- (const char *)fs->e2fs, offsetof(struct ext2fs, e4fs_sbchksum)));
+ fs->e2fs_fsmnt, le32toh(fs->e2fs->e4fs_sbchksum),
+ calculate_crc32c(~0, (const char *)fs->e2fs,
+ offsetof(struct ext2fs, e4fs_sbchksum)));
return (EINVAL);
}
@@ -112,8 +113,9 @@
ext2_sb_csum_set(struct m_ext2fs *fs)
{
- fs->e2fs->e4fs_sbchksum = calculate_crc32c(~0, (const char *)fs->e2fs,
- offsetof(struct ext2fs, e4fs_sbchksum));
+ fs->e2fs->e4fs_sbchksum =
+ htole32(calculate_crc32c(~0, (const char *)fs->e2fs,
+ offsetof(struct ext2fs, e4fs_sbchksum)));
}
static uint32_t
@@ -121,18 +123,22 @@
struct ext2fs_extattr_header *header)
{
struct m_ext2fs *fs;
- uint32_t crc, old_crc;
+ uint32_t crc, dummy_crc = 0;
+ uint64_t facl_bn = htole64(facl);
+ int offset = offsetof(struct ext2fs_extattr_header, h_checksum);
fs = ip->i_e2fs;
- old_crc = header->h_checksum;
+ crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&facl_bn,
+ sizeof(facl_bn));
+ crc = calculate_crc32c(crc, (uint8_t *)header, offset);
+ crc = calculate_crc32c(crc, (uint8_t *)&dummy_crc,
+ sizeof(dummy_crc));
+ offset += sizeof(dummy_crc);
+ crc = calculate_crc32c(crc, (uint8_t *)header + offset,
+ fs->e2fs_bsize - offset);
- header->h_checksum = 0;
- crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&facl, sizeof(facl));
- crc = calculate_crc32c(crc, (uint8_t *)header, fs->e2fs_bsize);
- header->h_checksum = old_crc;
-
- return (crc);
+ return (htole32(crc));
}
int
@@ -167,7 +173,7 @@
ext2_init_dirent_tail(struct ext2fs_direct_tail *tp)
{
memset(tp, 0, sizeof(struct ext2fs_direct_tail));
- tp->e2dt_rec_len = sizeof(struct ext2fs_direct_tail);
+ tp->e2dt_rec_len = le16toh(sizeof(struct ext2fs_direct_tail));
tp->e2dt_reserved_ft = EXT2_FT_DIR_CSUM;
}
@@ -184,7 +190,7 @@
tp = (struct ext2fs_direct_tail *)ep;
if (tp->e2dt_reserved_zero1 == 0 &&
- tp->e2dt_rec_len == sizeof(struct ext2fs_direct_tail) &&
+ le16toh(tp->e2dt_rec_len) == sizeof(struct ext2fs_direct_tail) &&
tp->e2dt_reserved_zero2 == 0 &&
tp->e2dt_reserved_ft == EXT2_FT_DIR_CSUM)
return (1);
@@ -201,13 +207,13 @@
dep = ep;
top = EXT2_DIRENT_TAIL(ep, ip->i_e2fs->e2fs_bsize);
- rec_len = dep->e2d_reclen;
+ rec_len = le16toh(dep->e2d_reclen);
while (rec_len && !(rec_len & 0x3)) {
dep = (struct ext2fs_direct_2 *)(((char *)dep) + rec_len);
if ((void *)dep >= top)
break;
- rec_len = dep->e2d_reclen;
+ rec_len = le16toh(dep->e2d_reclen);
}
if (dep != top)
@@ -230,8 +236,8 @@
buf = (char *)ep;
- inum = ip->i_number;
- gen = ip->i_gen;
+ inum = htole32(ip->i_number);
+ gen = htole32(ip->i_gen);
crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));
crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen));
crc = calculate_crc32c(crc, (uint8_t *)buf, size);
@@ -250,7 +256,7 @@
return (0);
calculated = ext2_dirent_csum(ip, ep, (char *)tp - (char *)ep);
- if (calculated != tp->e2dt_checksum)
+ if (calculated != le32toh(tp->e2dt_checksum))
return (EIO);
return (0);
@@ -263,11 +269,11 @@
struct ext2fs_htree_root_info *root;
int count_offset;
- if (ep->e2d_reclen == EXT2_BLOCK_SIZE(ip->i_e2fs))
+ if (le16toh(ep->e2d_reclen) == EXT2_BLOCK_SIZE(ip->i_e2fs))
count_offset = 8;
- else if (ep->e2d_reclen == 12) {
+ else if (le16toh(ep->e2d_reclen) == 12) {
dp = (struct ext2fs_direct_2 *)(((char *)ep) + 12);
- if (dp->e2d_reclen != EXT2_BLOCK_SIZE(ip->i_e2fs) - 12)
+ if (le16toh(dp->e2d_reclen) != EXT2_BLOCK_SIZE(ip->i_e2fs) - 12)
return (NULL);
root = (struct ext2fs_htree_root_info *)(((char *)dp + 12));
@@ -302,15 +308,15 @@
old_csum = tp->ht_checksum;
tp->ht_checksum = 0;
- inum = ip->i_number;
- gen = ip->i_gen;
+ inum = htole32(ip->i_number);
+ gen = htole32(ip->i_gen);
crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));
crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen));
crc = calculate_crc32c(crc, (uint8_t *)buf, size);
crc = calculate_crc32c(crc, (uint8_t *)tp, sizeof(struct ext2fs_htree_tail));
tp->ht_checksum = old_csum;
- return (crc);
+ return htole32(crc);
}
int
@@ -325,8 +331,8 @@
if (cp == NULL)
return (0);
- limit = cp->h_entries_max;
- count = cp->h_entries_num;
+ limit = le16toh(cp->h_entries_max);
+ count = le16toh(cp->h_entries_num);
if (count_offset + (limit * sizeof(struct ext2fs_htree_entry)) >
ip->i_e2fs->e2fs_bsize - sizeof(struct ext2fs_htree_tail))
return (EIO);
@@ -381,7 +387,7 @@
return;
tp->e2dt_checksum =
- ext2_dirent_csum(ip, ep, (char *)tp - (char *)ep);
+ htole32(ext2_dirent_csum(ip, ep, (char *)tp - (char *)ep));
}
void
@@ -401,8 +407,8 @@
if (cp == NULL)
return;
- limit = cp->h_entries_max;
- count = cp->h_entries_num;
+ limit = le16toh(cp->h_entries_max);
+ count = le16toh(cp->h_entries_num);
if (count_offset + (limit * sizeof(struct ext2fs_htree_entry)) >
ip->i_e2fs->e2fs_bsize - sizeof(struct ext2fs_htree_tail))
return;
@@ -423,8 +429,8 @@
size = EXT4_EXTENT_TAIL_OFFSET(ehp) +
offsetof(struct ext4_extent_tail, et_checksum);
- inum = ip->i_number;
- gen = ip->i_gen;
+ inum = htole32(ip->i_number);
+ gen = htole32(ip->i_gen);
crc = calculate_crc32c(fs->e2fs_csum_seed, (uint8_t *)&inum, sizeof(inum));
crc = calculate_crc32c(crc, (uint8_t *)&gen, sizeof(gen));
crc = calculate_crc32c(crc, (uint8_t *)ehp, size);
@@ -449,7 +455,7 @@
etp = (struct ext4_extent_tail *)(((char *)ehp) +
EXT4_EXTENT_TAIL_OFFSET(ehp));
- provided = etp->et_checksum;
+ provided = le32toh(etp->et_checksum);
calculated = ext2_extent_blk_csum(ip, ehp);
if (provided != calculated) {
@@ -476,8 +482,8 @@
etp = (struct ext4_extent_tail *)(((char *)data) +
EXT4_EXTENT_TAIL_OFFSET(ehp));
- etp->et_checksum = ext2_extent_blk_csum(ip,
- (struct ext4_extent_header *)data);
+ etp->et_checksum = htole32(ext2_extent_blk_csum(ip,
+ (struct ext4_extent_header *)data));
}
int
@@ -488,11 +494,12 @@
if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
return (0);
- provided = fs->e2fs_gd[cg].ext4bgd_i_bmap_csum;
+ provided = le16toh(fs->e2fs_gd[cg].ext4bgd_i_bmap_csum);
calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data,
- fs->e2fs->e2fs_ipg / 8);
- if (fs->e2fs->e3fs_desc_size >= EXT2_BG_INODE_BITMAP_CSUM_HI_END) {
- hi = fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi;
+ fs->e2fs_ipg / 8);
+ if (le16toh(fs->e2fs->e3fs_desc_size) >=
+ EXT2_BG_INODE_BITMAP_CSUM_HI_END) {
+ hi = le16toh(fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi);
provided |= (hi << 16);
} else
calculated &= 0xFFFF;
@@ -514,10 +521,10 @@
return;
csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data,
- fs->e2fs->e2fs_ipg / 8);
- fs->e2fs_gd[cg].ext4bgd_i_bmap_csum = csum & 0xFFFF;
- if (fs->e2fs->e3fs_desc_size >= EXT2_BG_INODE_BITMAP_CSUM_HI_END)
- fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi = csum >> 16;
+ fs->e2fs_ipg / 8);
+ fs->e2fs_gd[cg].ext4bgd_i_bmap_csum = htole16(csum & 0xFFFF);
+ if (le16toh(fs->e2fs->e3fs_desc_size) >= EXT2_BG_INODE_BITMAP_CSUM_HI_END)
+ fs->e2fs_gd[cg].ext4bgd_i_bmap_csum_hi = htole16(csum >> 16);
}
int
@@ -529,10 +536,11 @@
return (0);
size = fs->e2fs_fpg / 8;
- provided = fs->e2fs_gd[cg].ext4bgd_b_bmap_csum;
+ provided = le16toh(fs->e2fs_gd[cg].ext4bgd_b_bmap_csum);
calculated = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size);
- if (fs->e2fs->e3fs_desc_size >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION) {
- hi = fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi;
+ if (le16toh(fs->e2fs->e3fs_desc_size) >=
+ EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION) {
+ hi = le16toh(fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi);
provided |= (hi << 16);
} else
calculated &= 0xFFFF;
@@ -555,9 +563,9 @@
size = fs->e2fs_fpg / 8;
csum = calculate_crc32c(fs->e2fs_csum_seed, bp->b_data, size);
- fs->e2fs_gd[cg].ext4bgd_b_bmap_csum = csum & 0xFFFF;
- if (fs->e2fs->e3fs_desc_size >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)
- fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi = csum >> 16;
+ fs->e2fs_gd[cg].ext4bgd_b_bmap_csum = htole16(csum & 0xFFFF);
+ if (le16toh(fs->e2fs->e3fs_desc_size) >= EXT2_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)
+ fs->e2fs_gd[cg].ext4bgd_b_bmap_csum_hi = htole16(csum >> 16);
}
static uint32_t
@@ -571,10 +579,10 @@
fs = ip->i_e2fs;
offset = offsetof(struct ext2fs_dinode, e2di_chksum_lo);
csum_size = sizeof(dummy_csum);
- inum = ip->i_number;
+ inum = htole32(ip->i_number);
crc = calculate_crc32c(fs->e2fs_csum_seed,
(uint8_t *)&inum, sizeof(inum));
- gen = ip->i_gen;
+ gen = htole32(ip->i_gen);
inode_csum_seed = calculate_crc32c(crc,
(uint8_t *)&gen, sizeof(gen));
@@ -590,7 +598,8 @@
E2FS_REV0_INODE_SIZE, offset - E2FS_REV0_INODE_SIZE);
if ((EXT2_INODE_SIZE(ip->i_e2fs) > E2FS_REV0_INODE_SIZE &&
- ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END)) {
+ le16toh(ei->e2di_extra_isize) >=
+ EXT2_INODE_CSUM_HI_EXTRA_END)) {
crc = calculate_crc32c(crc, (uint8_t *)&dummy_csum,
csum_size);
offset += csum_size;
@@ -615,12 +624,12 @@
if (!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
return (0);
- provided = ei->e2di_chksum_lo;
+ provided = le16toh(ei->e2di_chksum_lo);
calculated = ext2_ei_csum(ip, ei);
if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE &&
- ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END)) {
- hi = ei->e2di_chksum_hi;
+ le16toh(ei->e2di_extra_isize) >= EXT2_INODE_CSUM_HI_EXTRA_END)) {
+ hi = le16toh(ei->e2di_chksum_hi);
provided |= hi << 16;
} else
calculated &= 0xFFFF;
@@ -655,10 +664,10 @@
crc = ext2_ei_csum(ip, ei);
- ei->e2di_chksum_lo = crc & 0xFFFF;
+ ei->e2di_chksum_lo = htole16(crc & 0xFFFF);
if ((EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE &&
- ei->e2di_extra_isize >= EXT2_INODE_CSUM_HI_EXTRA_END))
- ei->e2di_chksum_hi = crc >> 16;
+ le16toh(ei->e2di_extra_isize) >= EXT2_INODE_CSUM_HI_EXTRA_END))
+ ei->e2di_chksum_hi = htole16(crc >> 16);
}
static uint16_t
@@ -716,6 +725,8 @@
offset = offsetof(struct ext2_gd, ext4bgd_csum);
+ block_group = htole32(block_group);
+
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
csum32 = calculate_crc32c(fs->e2fs_csum_seed,
(uint8_t *)&block_group, sizeof(block_group));
@@ -724,12 +735,12 @@
csum32 = calculate_crc32c(csum32, (uint8_t *)&dummy_csum,
sizeof(dummy_csum));
offset += sizeof(dummy_csum);
- if (offset < fs->e2fs->e3fs_desc_size)
+ if (offset < le16toh(fs->e2fs->e3fs_desc_size))
csum32 = calculate_crc32c(csum32, (uint8_t *)gd + offset,
- fs->e2fs->e3fs_desc_size - offset);
+ le16toh(fs->e2fs->e3fs_desc_size) - offset);
crc = csum32 & 0xFFFF;
- return (crc);
+ return (htole16(crc));
} else if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM)) {
crc = ext2_crc16(~0, fs->e2fs->e2fs_uuid,
sizeof(fs->e2fs->e2fs_uuid));
@@ -738,10 +749,10 @@
crc = ext2_crc16(crc, (uint8_t *)gd, offset);
offset += sizeof(gd->ext4bgd_csum); /* skip checksum */
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&
- offset < fs->e2fs->e3fs_desc_size)
+ offset < le16toh(fs->e2fs->e3fs_desc_size))
crc = ext2_crc16(crc, (uint8_t *)gd + offset,
- fs->e2fs->e3fs_desc_size - offset);
- return (crc);
+ le16toh(fs->e2fs->e3fs_desc_size) - offset);
+ return (htole16(crc));
}
return (0);
@@ -774,6 +785,5 @@
unsigned int i;
for (i = 0; i < fs->e2fs_gcount; i++)
- fs->e2fs_gd[i].ext4bgd_csum =
- ext2_gd_csum(fs, i, &fs->e2fs_gd[i]);
+ fs->e2fs_gd[i].ext4bgd_csum = ext2_gd_csum(fs, i, &fs->e2fs_gd[i]);
}
Index: head/sys/fs/ext2fs/ext2_extattr.c
===================================================================
--- head/sys/fs/ext2fs/ext2_extattr.c
+++ head/sys/fs/ext2fs/ext2_extattr.c
@@ -216,9 +216,9 @@
/* Check attributes magic value */
header = (struct ext2fs_extattr_dinode_header *)((char *)dinode +
- E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize);
+ E2FS_REV0_INODE_SIZE + le16toh(dinode->e2di_extra_isize));
- if (header->h_magic != EXTATTR_MAGIC) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC) {
brelse(bp);
return (0);
}
@@ -285,7 +285,8 @@
/* Check attributes magic value */
header = EXT2_HDR(bp);
- if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC ||
+ le32toh(header->h_blocks) != 1) {
brelse(bp);
return (EINVAL);
}
@@ -356,9 +357,9 @@
/* Check attributes magic value */
header = (struct ext2fs_extattr_dinode_header *)((char *)dinode +
- E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize);
+ E2FS_REV0_INODE_SIZE + le16toh(dinode->e2di_extra_isize));
- if (header->h_magic != EXTATTR_MAGIC) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC) {
brelse(bp);
return (ENOATTR);
}
@@ -387,11 +388,12 @@
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
if (size != NULL)
- *size += entry->e_value_size;
+ *size += le32toh(entry->e_value_size);
if (uio != NULL)
error = uiomove(((char *)EXT2_IFIRST(header)) +
- entry->e_value_offs, entry->e_value_size, uio);
+ le16toh(entry->e_value_offs),
+ le32toh(entry->e_value_size), uio);
brelse(bp);
return (error);
@@ -425,7 +427,8 @@
/* Check attributes magic value */
header = EXT2_HDR(bp);
- if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC ||
+ le32toh(header->h_blocks) != 1) {
brelse(bp);
return (EINVAL);
}
@@ -453,11 +456,12 @@
if (strlen(name) == name_len &&
0 == strncmp(attr_name, name, name_len)) {
if (size != NULL)
- *size += entry->e_value_size;
+ *size += le32toh(entry->e_value_size);
if (uio != NULL)
- error = uiomove(bp->b_data + entry->e_value_offs,
- entry->e_value_size, uio);
+ error = uiomove(bp->b_data +
+ le16toh(entry->e_value_offs),
+ le32toh(entry->e_value_size), uio);
brelse(bp);
return (error);
@@ -480,8 +484,9 @@
min_offs = end - off;
next = first_entry;
while (!EXT2_IS_LAST_ENTRY(next)) {
- if (min_offs > next->e_value_offs && next->e_value_offs > 0)
- min_offs = next->e_value_offs;
+ if (min_offs > le16toh(next->e_value_offs) &&
+ le16toh(next->e_value_offs) > 0)
+ min_offs = le16toh(next->e_value_offs);
next = EXT2_EXTATTR_NEXT(next);
}
@@ -489,22 +494,22 @@
if (entry->e_value_size == 0)
return (min_offs);
- memmove(off + min_offs + EXT2_EXTATTR_SIZE(entry->e_value_size),
- off + min_offs, entry->e_value_offs - min_offs);
+ memmove(off + min_offs + EXT2_EXTATTR_SIZE(le32toh(entry->e_value_size)),
+ off + min_offs, le16toh(entry->e_value_offs) - min_offs);
/* Adjust all value offsets */
next = first_entry;
while (!EXT2_IS_LAST_ENTRY(next))
{
- if (next->e_value_offs > 0 &&
- next->e_value_offs < entry->e_value_offs)
- next->e_value_offs +=
- EXT2_EXTATTR_SIZE(entry->e_value_size);
+ if (le16toh(next->e_value_offs) > 0 &&
+ le16toh(next->e_value_offs) < le16toh(entry->e_value_offs))
+ next->e_value_offs = htole16(le16toh(next->e_value_offs) +
+ EXT2_EXTATTR_SIZE(le32toh(entry->e_value_size)));
next = EXT2_EXTATTR_NEXT(next);
}
- min_offs += EXT2_EXTATTR_SIZE(entry->e_value_size);
+ min_offs += EXT2_EXTATTR_SIZE(le32toh(entry->e_value_size));
return (min_offs);
}
@@ -557,9 +562,9 @@
/* Check attributes magic value */
header = (struct ext2fs_extattr_dinode_header *)((char *)dinode +
- E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize);
+ E2FS_REV0_INODE_SIZE + le16toh(dinode->e2di_extra_isize));
- if (header->h_magic != EXTATTR_MAGIC) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC) {
brelse(bp);
return (ENOATTR);
}
@@ -635,7 +640,8 @@
sbp = *bpp;
header = EXT2_HDR(sbp);
- if (header->h_magic != EXTATTR_MAGIC || header->h_refcount == 1)
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC ||
+ le32toh(header->h_refcount) == 1)
return (EINVAL);
facl = ext2_alloc_meta(ip);
@@ -649,14 +655,14 @@
}
memcpy(cbp->b_data, sbp->b_data, fs->e2fs_bsize);
- header->h_refcount--;
+ header->h_refcount = htole32(le32toh(header->h_refcount) - 1);
bwrite(sbp);
ip->i_facl = facl;
ext2_update(ip->i_vnode, 1);
header = EXT2_HDR(cbp);
- header->h_refcount = 1;
+ header->h_refcount = htole32(1);
*bpp = cbp;
@@ -684,7 +690,8 @@
/* Check attributes magic value */
header = EXT2_HDR(bp);
- if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC ||
+ le32toh(header->h_blocks) != 1) {
brelse(bp);
return (EINVAL);
}
@@ -695,7 +702,7 @@
return (error);
}
- if (header->h_refcount > 1) {
+ if (le32toh(header->h_refcount) > 1) {
error = ext2_extattr_block_clone(ip, &bp);
if (error) {
brelse(bp);
@@ -774,10 +781,10 @@
entry->e_name_len = name_len;
entry->e_name_index = ext2_extattr_attrnamespace_to_linux(attrnamespace, name);
- entry->e_value_offs = offs;
+ entry->e_value_offs = htole16(offs);
entry->e_value_block = 0;
- entry->e_value_size = size;
- entry->e_hash = hash;
+ entry->e_value_size = htole32(size);
+ entry->e_hash = htole32(hash);
memcpy(entry->e_name, name, name_len);
return (entry);
@@ -811,7 +818,7 @@
entry = EXT2_EXTATTR_NEXT(entry)) {
if (entry != exist_entry)
size += EXT2_EXTATTR_LEN(entry->e_name_len) +
- EXT2_EXTATTR_SIZE(entry->e_value_size);
+ EXT2_EXTATTR_SIZE(le32toh(entry->e_value_size));
else
size += EXT2_EXTATTR_LEN(entry->e_name_len) +
EXT2_EXTATTR_SIZE(new_size);
@@ -830,14 +837,15 @@
min_offs = ext2_extattr_delete_value(off, first_entry, entry, end);
- entry->e_value_size = uio->uio_resid;
- if (entry->e_value_size)
- entry->e_value_offs = min_offs -
- EXT2_EXTATTR_SIZE(uio->uio_resid);
+ entry->e_value_size = htole32(uio->uio_resid);
+ if (le32toh(entry->e_value_size))
+ entry->e_value_offs = htole16(min_offs -
+ EXT2_EXTATTR_SIZE(uio->uio_resid));
else
entry->e_value_offs = 0;
- uiomove(off + entry->e_value_offs, entry->e_value_size, uio);
+ uiomove(off + le16toh(entry->e_value_offs),
+ le32toh(entry->e_value_size), uio);
}
static struct ext2fs_extattr_entry *
@@ -854,8 +862,9 @@
min_offs = end - off;
entry = first_entry;
while (!EXT2_IS_LAST_ENTRY(entry)) {
- if (min_offs > entry->e_value_offs && entry->e_value_offs > 0)
- min_offs = entry->e_value_offs;
+ if (min_offs > le16toh(entry->e_value_offs) &&
+ le16toh(entry->e_value_offs) > 0)
+ min_offs = le16toh(entry->e_value_offs);
entry = EXT2_EXTATTR_NEXT(entry);
}
@@ -883,11 +892,12 @@
free_entry(new_entry);
new_entry = entry;
- if (new_entry->e_value_size > 0)
- new_entry->e_value_offs = min_offs -
- EXT2_EXTATTR_SIZE(new_entry->e_value_size);
+ if (le32toh(new_entry->e_value_size) > 0)
+ new_entry->e_value_offs = htole16(min_offs -
+ EXT2_EXTATTR_SIZE(le32toh(new_entry->e_value_size)));
- uiomove(off + new_entry->e_value_offs, new_entry->e_value_size, uio);
+ uiomove(off + le16toh(new_entry->e_value_offs),
+ le32toh(new_entry->e_value_size), uio);
return (new_entry);
}
@@ -920,9 +930,9 @@
/* Check attributes magic value */
header = (struct ext2fs_extattr_dinode_header *)((char *)dinode +
- E2FS_REV0_INODE_SIZE + dinode->e2di_extra_isize);
+ E2FS_REV0_INODE_SIZE + le16toh(dinode->e2di_extra_isize));
- if (header->h_magic != EXTATTR_MAGIC) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC) {
brelse(bp);
return (ENOSPC);
}
@@ -955,7 +965,7 @@
}
max_size = EXT2_INODE_SIZE(fs) - E2FS_REV0_INODE_SIZE -
- dinode->e2di_extra_isize;
+ le16toh(dinode->e2di_extra_isize);
if (!EXT2_IS_LAST_ENTRY(entry)) {
size = ext2_extattr_get_size(EXT2_IFIRST(header), entry,
@@ -1013,16 +1023,17 @@
}
if (entry->e_value_block == 0 && entry->e_value_size != 0) {
- uint32_t *value = (uint32_t *)((char *)header + entry->e_value_offs);
- for (n = (entry->e_value_size +
+ uint32_t *value = (uint32_t *)((char *)header +
+ le16toh(entry->e_value_offs));
+ for (n = (le32toh(entry->e_value_size) +
EXT2_EXTATTR_ROUND) >> EXT2_EXTATTR_PAD_BITS; n; n--) {
hash = (hash << EXT2_EXTATTR_VALUE_HASH_SHIFT) ^
(hash >> (8*sizeof(hash) - EXT2_EXTATTR_VALUE_HASH_SHIFT)) ^
- (*value++);
+ le32toh(*value++);
}
}
- entry->e_hash = hash;
+ entry->e_hash = htole32(hash);
}
static void
@@ -1036,7 +1047,7 @@
here = EXT2_ENTRY(header+1);
while (!EXT2_IS_LAST_ENTRY(here)) {
- if (!here->e_hash) {
+ if (here->e_hash == 0) {
/* Block is not shared if an entry's hash value == 0 */
hash = 0;
break;
@@ -1044,12 +1055,12 @@
hash = (hash << EXT2_EXTATTR_BLOCK_HASH_SHIFT) ^
(hash >> (8*sizeof(hash) - EXT2_EXTATTR_BLOCK_HASH_SHIFT)) ^
- here->e_hash;
+ le32toh(here->e_hash);
here = EXT2_EXTATTR_NEXT(here);
}
- header->h_hash = hash;
+ header->h_hash = htole32(hash);
}
int
@@ -1076,7 +1087,8 @@
/* Check attributes magic value */
header = EXT2_HDR(bp);
- if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC ||
+ le32toh(header->h_blocks) != 1) {
brelse(bp);
return (EINVAL);
}
@@ -1087,7 +1099,7 @@
return (error);
}
- if (header->h_refcount > 1) {
+ if (le32toh(header->h_refcount) > 1) {
error = ext2_extattr_block_clone(ip, &bp);
if (error) {
brelse(bp);
@@ -1178,9 +1190,9 @@
}
header = EXT2_HDR(bp);
- header->h_magic = EXTATTR_MAGIC;
- header->h_refcount = 1;
- header->h_blocks = 1;
+ header->h_magic = htole32(EXTATTR_MAGIC);
+ header->h_refcount = htole32(1);
+ header->h_blocks = htole32(1);
header->h_hash = 0;
memset(header->h_reserved, 0, sizeof(header->h_reserved));
memcpy(bp->b_data, header, sizeof(struct ext2fs_extattr_header));
@@ -1222,7 +1234,8 @@
/* Check attributes magic value */
header = EXT2_HDR(bp);
- if (header->h_magic != EXTATTR_MAGIC || header->h_blocks != 1) {
+ if (le32toh(header->h_magic) != EXTATTR_MAGIC ||
+ le32toh(header->h_blocks) != 1) {
brelse(bp);
return (EINVAL);
}
@@ -1234,8 +1247,8 @@
return (error);
}
- if (header->h_refcount > 1) {
- header->h_refcount--;
+ if (le32toh(header->h_refcount) > 1) {
+ header->h_refcount = htole32(le32toh(header->h_refcount) - 1);
bwrite(bp);
} else {
ext2_blkfree(ip, ip->i_facl, ip->i_e2fs->e2fs_bsize);
Index: head/sys/fs/ext2fs/ext2_extents.h
===================================================================
--- head/sys/fs/ext2fs/ext2_extents.h
+++ head/sys/fs/ext2fs/ext2_extents.h
@@ -108,14 +108,14 @@
sizeof(struct ext4_extent_header)))
#define EXT_FIRST_INDEX(hdr) ((struct ext4_extent_index *)(((char *)(hdr)) + \
sizeof(struct ext4_extent_header)))
-#define EXT_LAST_EXTENT(hdr) (EXT_FIRST_EXTENT((hdr)) + (hdr)->eh_ecount - 1)
-#define EXT_LAST_INDEX(hdr) (EXT_FIRST_INDEX((hdr)) + (hdr)->eh_ecount - 1)
+#define EXT_LAST_EXTENT(hdr) (EXT_FIRST_EXTENT((hdr)) + le16toh((hdr)->eh_ecount) - 1)
+#define EXT_LAST_INDEX(hdr) (EXT_FIRST_INDEX((hdr)) + le16toh((hdr)->eh_ecount) - 1)
#define EXT4_EXTENT_TAIL_OFFSET(hdr) (sizeof(struct ext4_extent_header) + \
- (sizeof(struct ext4_extent) * (hdr)->eh_max))
+ (sizeof(struct ext4_extent) * le16toh((hdr)->eh_max)))
#define EXT_HAS_FREE_INDEX(path) \
- ((path)->ep_header->eh_ecount < (path)->ep_header->eh_max)
-#define EXT_MAX_EXTENT(hdr) (EXT_FIRST_EXTENT(hdr) + ((hdr)->eh_max) - 1)
-#define EXT_MAX_INDEX(hdr) (EXT_FIRST_INDEX((hdr)) + (hdr)->eh_max - 1)
+ (le16toh((path)->ep_header->eh_ecount) < le16toh((path)->ep_header->eh_max))
+#define EXT_MAX_EXTENT(hdr) (EXT_FIRST_EXTENT(hdr) + le16toh((hdr)->eh_max) - 1)
+#define EXT_MAX_INDEX(hdr) (EXT_FIRST_INDEX((hdr)) + le16toh((hdr)->eh_max) - 1)
struct inode;
struct m_ext2fs;
Index: head/sys/fs/ext2fs/ext2_extents.c
===================================================================
--- head/sys/fs/ext2fs/ext2_extents.c
+++ head/sys/fs/ext2fs/ext2_extents.c
@@ -36,6 +36,7 @@
#include <sys/vnode.h>
#include <sys/bio.h>
#include <sys/buf.h>
+#include <sys/endian.h>
#include <sys/conf.h>
#include <sys/sdt.h>
#include <sys/stat.h>
@@ -63,8 +64,8 @@
{
printf(" ext %p => (blk %u len %u start %ju)\n",
- ep, ep->e_blk, ep->e_len,
- (uint64_t)ep->e_start_hi << 32 | ep->e_start_lo);
+ ep, le32toh(ep->e_blk), le16toh(ep->e_len),
+ (uint64_t)le16toh(ep->e_start_hi) << 32 | le32toh(ep->e_start_lo));
}
static void ext4_ext_print_header(struct inode *ip, struct ext4_extent_header *ehp);
@@ -79,14 +80,15 @@
fs = ip->i_e2fs;
printf(" index %p => (blk %u pblk %ju)\n",
- ex, ex->ei_blk, (uint64_t)ex->ei_leaf_hi << 32 | ex->ei_leaf_lo);
+ ex, le32toh(ex->ei_blk), (uint64_t)le16toh(ex->ei_leaf_hi) << 32 |
+ le32toh(ex->ei_leaf_lo));
if(!do_walk)
return;
if ((error = bread(ip->i_devvp,
- fsbtodb(fs, ((uint64_t)ex->ei_leaf_hi << 32 | ex->ei_leaf_lo)),
- (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
+ fsbtodb(fs, ((uint64_t)le16toh(ex->ei_leaf_hi) << 32 |
+ le32toh(ex->ei_leaf_lo))), (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
brelse(bp);
return;
}
@@ -103,10 +105,10 @@
int i;
printf("header %p => (magic 0x%x entries %d max %d depth %d gen %d)\n",
- ehp, ehp->eh_magic, ehp->eh_ecount, ehp->eh_max, ehp->eh_depth,
- ehp->eh_gen);
+ ehp, le16toh(ehp->eh_magic), le16toh(ehp->eh_ecount),
+ le16toh(ehp->eh_max), le16toh(ehp->eh_depth), le32toh(ehp->eh_gen));
- for (i = 0; i < ehp->eh_ecount; i++)
+ for (i = 0; i < le16toh(ehp->eh_ecount); i++)
if (ehp->eh_depth != 0)
ext4_ext_print_index(ip,
(struct ext4_extent_index *)(ehp + 1 + i), 1);
@@ -168,7 +170,7 @@
struct ext4_extent_header *ehp;
ehp = (struct ext4_extent_header *)ip->i_data;
- return (ehp->eh_depth);
+ return (le16toh(ehp->eh_depth));
}
static inline e4fs_daddr_t
@@ -176,8 +178,8 @@
{
e4fs_daddr_t blk;
- blk = index->ei_leaf_lo;
- blk |= (e4fs_daddr_t)index->ei_leaf_hi << 32;
+ blk = le32toh(index->ei_leaf_lo);
+ blk |= (e4fs_daddr_t)le16toh(index->ei_leaf_hi) << 32;
return (blk);
}
@@ -186,8 +188,8 @@
ext4_index_store_pblock(struct ext4_extent_index *index, e4fs_daddr_t pb)
{
- index->ei_leaf_lo = pb & 0xffffffff;
- index->ei_leaf_hi = (pb >> 32) & 0xffff;
+ index->ei_leaf_lo = htole32(pb & 0xffffffff);
+ index->ei_leaf_hi = htole16((pb >> 32) & 0xffff);
}
@@ -196,8 +198,8 @@
{
e4fs_daddr_t blk;
- blk = extent->e_start_lo;
- blk |= (e4fs_daddr_t)extent->e_start_hi << 32;
+ blk = le32toh(extent->e_start_lo);
+ blk |= (e4fs_daddr_t)le16toh(extent->e_start_hi) << 32;
return (blk);
}
@@ -206,8 +208,8 @@
ext4_ext_store_pblock(struct ext4_extent *ex, e4fs_daddr_t pb)
{
- ex->e_start_lo = pb & 0xffffffff;
- ex->e_start_hi = (pb >> 32) & 0xffff;
+ ex->e_start_lo = htole32(pb & 0xffffffff);
+ ex->e_start_hi = htole16((pb >> 32) & 0xffff);
}
int
@@ -221,10 +223,10 @@
return (ret);
if (lbn >= ecp->ec_blk && lbn < ecp->ec_blk + ecp->ec_len) {
- ep->e_blk = ecp->ec_blk;
- ep->e_start_lo = ecp->ec_start & 0xffffffff;
- ep->e_start_hi = ecp->ec_start >> 32 & 0xffff;
- ep->e_len = ecp->ec_len;
+ ep->e_blk = htole32(ecp->ec_blk);
+ ep->e_start_lo = htole32(ecp->ec_start & 0xffffffff);
+ ep->e_start_hi = htole16(ecp->ec_start >> 32 & 0xffff);
+ ep->e_len = htole16(ecp->ec_len);
ret = ecp->ec_type;
}
return (ret);
@@ -238,7 +240,7 @@
fs = ip->i_e2fs;
- if (eh->eh_magic != EXT4_EXT_MAGIC) {
+ if (le16toh(eh->eh_magic) != EXT4_EXT_MAGIC) {
error_msg = "header: invalid magic";
goto corrupted;
}
@@ -246,7 +248,7 @@
error_msg = "header: invalid eh_max";
goto corrupted;
}
- if (eh->eh_ecount > eh->eh_max) {
+ if (le16toh(eh->eh_ecount) > le16toh(eh->eh_max)) {
error_msg = "header: invalid eh_entries";
goto corrupted;
}
@@ -266,14 +268,15 @@
eh = path->ep_header;
- KASSERT(eh->eh_ecount <= eh->eh_max && eh->eh_ecount > 0,
+ KASSERT(le16toh(eh->eh_ecount) <= le16toh(eh->eh_max) &&
+ le16toh(eh->eh_ecount) > 0,
("ext4_ext_binsearch_index: bad args"));
l = EXT_FIRST_INDEX(eh) + 1;
- r = EXT_FIRST_INDEX(eh) + eh->eh_ecount - 1;
+ r = EXT_FIRST_INDEX(eh) + le16toh(eh->eh_ecount) - 1;
while (l <= r) {
m = l + (r - l) / 2;
- if (blk < m->ei_blk)
+ if (blk < le32toh(m->ei_blk))
r = m - 1;
else
l = m + 1;
@@ -290,18 +293,18 @@
eh = path->ep_header;
- KASSERT(eh->eh_ecount <= eh->eh_max,
+ KASSERT(le16toh(eh->eh_ecount) <= le16toh(eh->eh_max),
("ext4_ext_binsearch_ext: bad args"));
if (eh->eh_ecount == 0)
return;
l = EXT_FIRST_EXTENT(eh) + 1;
- r = EXT_FIRST_EXTENT(eh) + eh->eh_ecount - 1;
+ r = EXT_FIRST_EXTENT(eh) + le16toh(eh->eh_ecount) - 1;
while (l <= r) {
m = l + (r - l) / 2;
- if (blk < m->e_blk)
+ if (blk < le32toh(m->e_blk))
r = m - 1;
else
l = m + 1;
@@ -513,8 +516,8 @@
memset(ip->i_data, 0, EXT2_NDADDR + EXT2_NIADDR);
ehp = (struct ext4_extent_header *)ip->i_data;
- ehp->eh_magic = EXT4_EXT_MAGIC;
- ehp->eh_max = ext4_ext_space_root(ip);
+ ehp->eh_magic = htole16(EXT4_EXT_MAGIC);
+ ehp->eh_max = htole16(ext4_ext_space_root(ip));
ip->i_ext_cache.ec_type = EXT4_EXT_CACHE_NO;
ip->i_flag |= IN_CHANGE | IN_UPDATE;
ext2_update(ip->i_vnode, 1);
@@ -549,7 +552,7 @@
ex = path[depth].ep_ext;
if (ex) {
e4fs_daddr_t pblk = ext4_ext_extent_pblock(ex);
- e2fs_daddr_t blk = ex->e_blk;
+ e2fs_daddr_t blk = le32toh(ex->e_blk);
if (block > blk)
return (pblk + (block - blk));
@@ -564,7 +567,7 @@
/* Use inode's group. */
bg_start = (ip->i_block_group * EXT2_BLOCKS_PER_GROUP(ip->i_e2fs)) +
- fs->e2fs->e2fs_first_dblock;
+ le32toh(fs->e2fs->e2fs_first_dblock);
return (bg_start + block);
}
@@ -574,13 +577,13 @@
struct ext4_extent *ex2)
{
- if (ex1->e_blk + ex1->e_len != ex2->e_blk)
+ if (le32toh(ex1->e_blk) + le16toh(ex1->e_len) != le32toh(ex2->e_blk))
return (0);
- if (ex1->e_len + ex2->e_len > EXT4_MAX_LEN)
+ if (le16toh(ex1->e_len) + le16toh(ex2->e_len) > EXT4_MAX_LEN)
return (0);
- if (ext4_ext_extent_pblock(ex1) + ex1->e_len ==
+ if (ext4_ext_extent_pblock(ex1) + le16toh(ex1->e_len) ==
ext4_ext_extent_pblock(ex2))
return (1);
@@ -602,7 +605,7 @@
while (depth >= 0) {
if (path[depth].ep_index !=
EXT_LAST_INDEX(path[depth].ep_header))
- return (path[depth].ep_index[1].ei_blk);
+ return (le32toh(path[depth].ep_index[1].ei_blk));
depth--;
}
@@ -650,19 +653,20 @@
fs = ip->i_e2fs;
- if (lblk == path->ep_index->ei_blk) {
+ if (lblk == le32toh(path->ep_index->ei_blk)) {
SDT_PROBE2(ext2fs, , trace, extents, 1,
"lblk == index blk => extent corrupted");
return (EIO);
}
- if (path->ep_header->eh_ecount >= path->ep_header->eh_max) {
+ if (le16toh(path->ep_header->eh_ecount) >=
+ le16toh(path->ep_header->eh_max)) {
SDT_PROBE2(ext2fs, , trace, extents, 1,
"ecout > maxcount => extent corrupted");
return (EIO);
}
- if (lblk > path->ep_index->ei_blk) {
+ if (lblk > le32toh(path->ep_index->ei_blk)) {
/* Insert after. */
idx = path->ep_index + 1;
} else {
@@ -680,9 +684,10 @@
return (EIO);
}
- idx->ei_blk = lblk;
+ idx->ei_blk = htole32(lblk);
ext4_index_store_pblock(idx, blk);
- path->ep_header->eh_ecount++;
+ path->ep_header->eh_ecount =
+ htole16(le16toh(path->ep_header->eh_ecount) + 1);
return (ext4_ext_dirty(ip, path));
}
@@ -750,9 +755,9 @@
}
if (path[depth].ep_ext != EXT_MAX_EXTENT(path[depth].ep_header))
- border = path[depth].ep_ext[1].e_blk;
+ border = le32toh(path[depth].ep_ext[1].e_blk);
else
- border = newext->e_blk;
+ border = le32toh(newext->e_blk);
/* Allocate new blocks. */
ablks = malloc(sizeof(e4fs_daddr_t) * depth,
@@ -775,12 +780,13 @@
neh = ext4_ext_block_header(bp->b_data);
neh->eh_ecount = 0;
- neh->eh_max = ext4_ext_space_block(ip);
- neh->eh_magic = EXT4_EXT_MAGIC;
+ neh->eh_max = le16toh(ext4_ext_space_block(ip));
+ neh->eh_magic = le16toh(EXT4_EXT_MAGIC);
neh->eh_depth = 0;
ex = EXT_FIRST_EXTENT(neh);
- if (path[depth].ep_header->eh_ecount != path[depth].ep_header->eh_max) {
+ if (le16toh(path[depth].ep_header->eh_ecount) !=
+ le16toh(path[depth].ep_header->eh_max)) {
SDT_PROBE2(ext2fs, , trace, extents, 1,
"extents count out of range => extent corrupted");
error = EIO;
@@ -797,7 +803,7 @@
if (m) {
memmove(ex, path[depth].ep_ext - m,
sizeof(struct ext4_extent) * m);
- neh->eh_ecount = neh->eh_ecount + m;
+ neh->eh_ecount = htole16(le16toh(neh->eh_ecount) + m);
}
ext2_extent_blk_csum_set(ip, bp->b_data);
@@ -807,7 +813,7 @@
/* Fix old leaf. */
if (m) {
path[depth].ep_header->eh_ecount =
- path[depth].ep_header->eh_ecount - m;
+ htole16(le16toh(path[depth].ep_header->eh_ecount) - m);
ext4_ext_dirty(ip, path + depth);
}
@@ -827,12 +833,12 @@
}
neh = (struct ext4_extent_header *)bp->b_data;
- neh->eh_ecount = 1;
- neh->eh_magic = EXT4_EXT_MAGIC;
- neh->eh_max = ext4_ext_space_block_index(ip);
- neh->eh_depth = depth - i;
+ neh->eh_ecount = htole16(1);
+ neh->eh_magic = htole16(EXT4_EXT_MAGIC);
+ neh->eh_max = htole16(ext4_ext_space_block_index(ip));
+ neh->eh_depth = htole16(depth - i);
fidx = EXT_FIRST_INDEX(neh);
- fidx->ei_blk = border;
+ fidx->ei_blk = htole32(border);
ext4_index_store_pblock(fidx, oldblk);
m = 0;
@@ -844,7 +850,7 @@
if (m) {
memmove(++fidx, path[i].ep_index - m,
sizeof(struct ext4_extent_index) * m);
- neh->eh_ecount = neh->eh_ecount + m;
+ neh->eh_ecount = htole16(le16toh(neh->eh_ecount) + m);
}
ext2_extent_blk_csum_set(ip, bp->b_data);
@@ -854,7 +860,7 @@
/* Fix old index. */
if (m) {
path[i].ep_header->eh_ecount =
- path[i].ep_header->eh_ecount - m;
+ htole16(le16toh(path[i].ep_header->eh_ecount) - m);
ext4_ext_dirty(ip, path + i);
}
@@ -907,12 +913,12 @@
/* Set size of new block */
neh = ext4_ext_block_header(bp->b_data);
- neh->eh_magic = EXT4_EXT_MAGIC;
+ neh->eh_magic = htole16(EXT4_EXT_MAGIC);
if (ext4_ext_inode_depth(ip))
- neh->eh_max = ext4_ext_space_block_index(ip);
+ neh->eh_max = htole16(ext4_ext_space_block_index(ip));
else
- neh->eh_max = ext4_ext_space_block(ip);
+ neh->eh_max = htole16(ext4_ext_space_block(ip));
ext2_extent_blk_csum_set(ip, bp->b_data);
error = bwrite(bp);
@@ -921,15 +927,15 @@
bp = NULL;
- curpath->ep_header->eh_magic = EXT4_EXT_MAGIC;
- curpath->ep_header->eh_max = ext4_ext_space_root(ip);
- curpath->ep_header->eh_ecount = 1;
+ curpath->ep_header->eh_magic = htole16(EXT4_EXT_MAGIC);
+ curpath->ep_header->eh_max = htole16(ext4_ext_space_root(ip));
+ curpath->ep_header->eh_ecount = htole16(1);
curpath->ep_index = EXT_FIRST_INDEX(curpath->ep_header);
curpath->ep_index->ei_blk = EXT_FIRST_EXTENT(path[0].ep_header)->e_blk;
ext4_index_store_pblock(curpath->ep_index, newblk);
neh = ext4_ext_inode_header(ip);
- neh->eh_depth = path->ep_depth + 1;
+ neh->eh_depth = htole16(path->ep_depth + 1);
ext4_ext_dirty(ip, curpath);
out:
brelse(bp);
@@ -965,7 +971,7 @@
/* Refill path. */
ext4_ext_drop_refs(path);
- error = ext4_ext_find_extent(ip, newext->e_blk, &path);
+ error = ext4_ext_find_extent(ip, le32toh(newext->e_blk), &path);
if (error)
goto out;
} else {
@@ -976,14 +982,14 @@
/* Refill path. */
ext4_ext_drop_refs(path);
- error = ext4_ext_find_extent(ip, newext->e_blk, &path);
+ error = ext4_ext_find_extent(ip, le32toh(newext->e_blk), &path);
if (error)
goto out;
/* Check and split tree if required. */
depth = ext4_ext_inode_depth(ip);
- if (path[depth].ep_header->eh_ecount ==
- path[depth].ep_header->eh_max)
+ if (le16toh(path[depth].ep_header->eh_ecount) ==
+ le16toh(path[depth].ep_header->eh_max))
goto repeat;
}
@@ -1014,15 +1020,15 @@
return (0);
k = depth - 1;
- border = path[depth].ep_ext->e_blk;
- path[k].ep_index->ei_blk = border;
+ border = le32toh(path[depth].ep_ext->e_blk);
+ path[k].ep_index->ei_blk = htole32(border);
ext4_ext_dirty(ip, path + k);
while (k--) {
/* Change all left-side indexes. */
if (path[k+1].ep_index != EXT_FIRST_INDEX(path[k+1].ep_header))
break;
- path[k].ep_index->ei_blk = border;
+ path[k].ep_index->ei_blk = htole32(border);
ext4_ext_dirty(ip, path + k);
}
@@ -1042,12 +1048,12 @@
ex = path[depth].ep_ext;
npath = NULL;
- if (newext->e_len == 0 || path[depth].ep_header == NULL)
+ if (htole16(newext->e_len) == 0 || path[depth].ep_header == NULL)
return (EINVAL);
/* Insert block into found extent. */
if (ex && ext4_can_extents_be_merged(ex, newext)) {
- ex->e_len = ex->e_len + newext->e_len;
+ ex->e_len = htole16(le16toh(ex->e_len) + le16toh(newext->e_len));
eh = path[depth].ep_header;
nearex = ex;
goto merge;
@@ -1056,13 +1062,14 @@
repeat:
depth = ext4_ext_inode_depth(ip);
eh = path[depth].ep_header;
- if (eh->eh_ecount < eh->eh_max)
+ if (le16toh(eh->eh_ecount) < le16toh(eh->eh_max))
goto has_space;
/* Try next leaf */
nex = EXT_LAST_EXTENT(eh);
next = ext4_ext_next_leaf_block(ip, path);
- if (newext->e_blk > nex->e_blk && next != EXT4_MAX_BLOCKS) {
+ if (le32toh(newext->e_blk) > le32toh(nex->e_blk) && next !=
+ EXT4_MAX_BLOCKS) {
KASSERT(npath == NULL,
("ext4_ext_insert_extent: bad path"));
@@ -1076,7 +1083,7 @@
}
eh = npath[depth].ep_header;
- if (eh->eh_ecount < eh->eh_max) {
+ if (le16toh(eh->eh_ecount) < le16toh(eh->eh_max)) {
path = npath;
goto repeat;
}
@@ -1098,7 +1105,7 @@
if (!nearex) {
/* Create new extent in the leaf. */
path[depth].ep_ext = EXT_FIRST_EXTENT(eh);
- } else if (newext->e_blk > nearex->e_blk) {
+ } else if (le32toh(newext->e_blk) > le32toh(nearex->e_blk)) {
if (nearex != EXT_LAST_EXTENT(eh)) {
len = EXT_MAX_EXTENT(eh) - nearex;
len = (len - 1) * sizeof(struct ext4_extent);
@@ -1113,7 +1120,7 @@
path[depth].ep_ext = nearex;
}
- eh->eh_ecount = eh->eh_ecount + 1;
+ eh->eh_ecount = htole16(le16toh(eh->eh_ecount) + 1);
nearex = path[depth].ep_ext;
nearex->e_blk = newext->e_blk;
nearex->e_start_lo = newext->e_start_lo;
@@ -1127,15 +1134,16 @@
break;
/* Merge with next extent. */
- nearex->e_len = nearex->e_len + nearex[1].e_len;
+ nearex->e_len = htole16(le16toh(nearex->e_len) +
+ le16toh(nearex[1].e_len));
if (nearex + 1 < EXT_LAST_EXTENT(eh)) {
len = (EXT_LAST_EXTENT(eh) - nearex - 1) *
sizeof(struct ext4_extent);
memmove(nearex + 1, nearex + 2, len);
}
- eh->eh_ecount = eh->eh_ecount - 1;
- KASSERT(eh->eh_ecount != 0,
+ eh->eh_ecount = htole16(le16toh(eh->eh_ecount) - 1);
+ KASSERT(le16toh(eh->eh_ecount) != 0,
("ext4_ext_insert_extent: bad ecount"));
}
@@ -1208,9 +1216,9 @@
if ((bpref = ext4_ext_in_cache(ip, iblk, &newex))) {
if (bpref == EXT4_EXT_CACHE_IN) {
/* Block is already allocated. */
- newblk = iblk - newex.e_blk +
+ newblk = iblk - le32toh(newex.e_blk) +
ext4_ext_extent_pblock(&newex);
- allocated = newex.e_len - (iblk - newex.e_blk);
+ allocated = le16toh(newex.e_len) - (iblk - le32toh(newex.e_blk));
goto out;
} else {
error = EIO;
@@ -1230,8 +1238,8 @@
}
if ((ex = path[depth].ep_ext)) {
- uint64_t lblk = ex->e_blk;
- uint16_t e_len = ex->e_len;
+ uint64_t lblk = le32toh(ex->e_blk);
+ uint16_t e_len = le16toh(ex->e_len);
e4fs_daddr_t e_start = ext4_ext_extent_pblock(ex);
if (e_len > EXT4_MAX_LEN)
@@ -1259,9 +1267,9 @@
goto out2;
/* Try to insert new extent into found leaf and return. */
- newex.e_blk = iblk;
+ newex.e_blk = htole32(iblk);
ext4_ext_store_pblock(&newex, newblk);
- newex.e_len = allocated;
+ newex.e_len = htole16(allocated);
error = ext4_ext_insert_extent(ip, path, &newex);
if (error)
goto out2;
@@ -1302,8 +1310,8 @@
ext4_ext_get_actual_len(struct ext4_extent *ext)
{
- return (ext->e_len <= EXT_INIT_MAX_LEN ?
- ext->e_len : (ext->e_len - EXT_INIT_MAX_LEN));
+ return (le16toh(ext->e_len) <= EXT_INIT_MAX_LEN ?
+ le16toh(ext->e_len) : (le16toh(ext->e_len) - EXT_INIT_MAX_LEN));
}
static inline struct ext4_extent_header *
@@ -1319,10 +1327,10 @@
{
unsigned long num, start;
- if (from >= ex->e_blk &&
- to == ex->e_blk + ext4_ext_get_actual_len(ex) - 1) {
+ if (from >= le32toh(ex->e_blk) &&
+ to == le32toh(ex->e_blk) + ext4_ext_get_actual_len(ex) - 1) {
/* Tail cleanup. */
- num = ex->e_blk + ext4_ext_get_actual_len(ex) - from;
+ num = le32toh(ex->e_blk) + ext4_ext_get_actual_len(ex) - from;
start = ext4_ext_extent_pblock(ex) +
ext4_ext_get_actual_len(ex) - num;
ext4_ext_blkfree(ip, start, num, 0);
@@ -1341,7 +1349,8 @@
leaf = ext4_ext_index_pblock(path->ep_index);
KASSERT(path->ep_header->eh_ecount != 0,
("ext4_ext_rm_index: bad ecount"));
- path->ep_header->eh_ecount--;
+ path->ep_header->eh_ecount =
+ htole16(le16toh(path->ep_header->eh_ecount) - 1);
ext4_ext_dirty(ip, path);
ext4_ext_blkfree(ip, leaf, 1, 0);
return (0);
@@ -1375,7 +1384,7 @@
}
ex = EXT_LAST_EXTENT(eh);
- ex_blk = ex->e_blk;
+ ex_blk = le32toh(ex->e_blk);
ex_len = ext4_ext_get_actual_len(ex);
error = 0;
@@ -1410,27 +1419,28 @@
if (num == 0) {
ext4_ext_store_pblock(ex, 0);
- eh->eh_ecount--;
+ eh->eh_ecount = htole16(le16toh(eh->eh_ecount) - 1);
}
- ex->e_blk = block;
- ex->e_len = num;
+ ex->e_blk = htole32(block);
+ ex->e_len = htole16(num);
ext4_ext_dirty(ip, path + depth);
ex--;
- ex_blk = ex->e_blk;
+ ex_blk = htole32(ex->e_blk);
ex_len = ext4_ext_get_actual_len(ex);
};
- if (correct_index && eh->eh_ecount)
+ if (correct_index && le16toh(eh->eh_ecount))
error = ext4_ext_correct_indexes(ip, path);
/*
* If this leaf is free, we should
* remove it from index block above.
*/
- if (error == 0 && eh->eh_ecount == 0 && path[depth].ep_data != NULL)
+ if (error == 0 && eh->eh_ecount == 0 &&
+ path[depth].ep_data != NULL)
error = ext4_ext_rm_index(ip, path + depth);
out:
@@ -1454,7 +1464,7 @@
}
eh = ext4_ext_block_header(bp->b_data);
- if (eh->eh_depth != depth) {
+ if (le16toh(eh->eh_depth) != depth) {
SDT_PROBE2(ext2fs, , trace, extents, 1,
"unexpected eh_depth");
goto err;
@@ -1482,7 +1492,7 @@
if (path->ep_index < EXT_FIRST_INDEX(path->ep_header))
return (0);
- if (path->ep_header->eh_ecount == path->index_count)
+ if (le16toh(path->ep_header->eh_ecount) == path->index_count)
return (0);
return (1);
@@ -1533,7 +1543,8 @@
if (!path[i].ep_index) {
/* This level hasn't touched yet. */
path[i].ep_index = EXT_LAST_INDEX(path[i].ep_header);
- path[i].index_count = path[i].ep_header->eh_ecount + 1;
+ path[i].index_count =
+ le16toh(path[i].ep_header->eh_ecount) + 1;
} else {
/* We've already was here, see at next index. */
path[i].ep_index--;
@@ -1552,7 +1563,8 @@
ext4_ext_fill_path_bdata(&path[i+1], bp,
ext4_ext_index_pblock(path[i].ep_index));
brelse(bp);
- path[i].index_count = path[i].ep_header->eh_ecount;
+ path[i].index_count =
+ le16toh(path[i].ep_header->eh_ecount);
i++;
} else {
if (path[i].ep_header->eh_ecount == 0 && i > 0) {
@@ -1570,7 +1582,7 @@
* Truncate the tree to zero.
*/
ext4_ext_header(ip)->eh_depth = 0;
- ext4_ext_header(ip)->eh_max = ext4_ext_space_root(ip);
+ ext4_ext_header(ip)->eh_max = htole16(ext4_ext_space_root(ip));
ext4_ext_dirty(ip, path);
}
Index: head/sys/fs/ext2fs/ext2_htree.c
===================================================================
--- head/sys/fs/ext2fs/ext2_htree.c
+++ head/sys/fs/ext2fs/ext2_htree.c
@@ -157,49 +157,49 @@
static uint32_t
ext2_htree_get_block(struct ext2fs_htree_entry *ep)
{
- return (ep->h_blk & 0x00FFFFFF);
+ return (le32toh(ep->h_blk) & 0x00FFFFFF);
}
static void
ext2_htree_set_block(struct ext2fs_htree_entry *ep, uint32_t blk)
{
- ep->h_blk = blk;
+ ep->h_blk = htole32(blk);
}
static uint16_t
ext2_htree_get_count(struct ext2fs_htree_entry *ep)
{
- return (((struct ext2fs_htree_count *)(ep))->h_entries_num);
+ return (le16toh(((struct ext2fs_htree_count *)(ep))->h_entries_num));
}
static void
ext2_htree_set_count(struct ext2fs_htree_entry *ep, uint16_t cnt)
{
- ((struct ext2fs_htree_count *)(ep))->h_entries_num = cnt;
+ ((struct ext2fs_htree_count *)(ep))->h_entries_num = htole16(cnt);
}
static uint32_t
ext2_htree_get_hash(struct ext2fs_htree_entry *ep)
{
- return (ep->h_hash);
+ return (le32toh(ep->h_hash));
}
static uint16_t
ext2_htree_get_limit(struct ext2fs_htree_entry *ep)
{
- return (((struct ext2fs_htree_count *)(ep))->h_entries_max);
+ return (le16toh(((struct ext2fs_htree_count *)(ep))->h_entries_max));
}
static void
ext2_htree_set_hash(struct ext2fs_htree_entry *ep, uint32_t hash)
{
- ep->h_hash = hash;
+ ep->h_hash = htole32(hash);
}
static void
ext2_htree_set_limit(struct ext2fs_htree_entry *ep, uint16_t limit)
{
- ((struct ext2fs_htree_count *)(ep))->h_entries_max = limit;
+ ((struct ext2fs_htree_count *)(ep))->h_entries_max = htole16(limit);
}
static void
@@ -246,6 +246,14 @@
return (space / sizeof(struct ext2fs_htree_entry));
}
+static void
+ext2_get_hash_seed(struct ext2fs* es, uint32_t* seed)
+{
+
+ for (int i = 0; i < 4; i++)
+ seed[i] = le32toh(es->e3fs_hash_seed[i]);
+}
+
static int
ext2_htree_find_leaf(struct inode *ip, const char *name, int namelen,
uint32_t *hash, uint8_t *hash_ver,
@@ -260,6 +268,7 @@
struct ext2fs_htree_lookup_level *level_info;
uint32_t hash_major = 0, hash_minor = 0;
uint32_t levels, cnt;
+ uint32_t hash_seed[4];
uint8_t hash_version;
if (name == NULL || info == NULL)
@@ -285,7 +294,8 @@
hash_version += m_fs->e2fs_uhash;
*hash_ver = hash_version;
- ext2_htree_hash(name, namelen, fs->e3fs_hash_seed,
+ ext2_get_hash_seed(fs, hash_seed);
+ ext2_htree_hash(name, namelen, hash_seed,
hash_version, &hash_major, &hash_minor);
*hash = hash_major;
@@ -494,9 +504,9 @@
entry1 = (const struct ext2fs_htree_sort_entry *)e1;
entry2 = (const struct ext2fs_htree_sort_entry *)e2;
- if (entry1->h_hash < entry2->h_hash)
+ if (le32toh(entry1->h_hash) < le32toh(entry2->h_hash))
return (-1);
- if (entry1->h_hash > entry2->h_hash)
+ if (le32toh(entry1->h_hash) > le32toh(entry2->h_hash))
return (1);
return (0);
}
@@ -512,9 +522,10 @@
uint16_t entry_len;
entry_len = EXT2_DIR_REC_LEN(last_entry->e2d_namlen);
- last_entry->e2d_reclen = entry_len;
+ last_entry->e2d_reclen = htole16(entry_len);
last_entry = (struct ext2fs_direct_2 *)((char *)last_entry + entry_len);
- new_entry->e2d_reclen = block + blksize - (char *)last_entry - csum_size;
+ new_entry->e2d_reclen = htole16(block + blksize - (char *)last_entry -
+ csum_size);
memcpy(last_entry, new_entry, EXT2_DIR_REC_LEN(new_entry->e2d_namlen));
}
@@ -556,17 +567,18 @@
* Fill in directory entry sort descriptors.
*/
while ((char *)ep < block1 + blksize - csum_size) {
- if (ep->e2d_ino && ep->e2d_namlen) {
+ if (le32toh(ep->e2d_ino) && ep->e2d_namlen) {
entry_cnt++;
sort_info--;
sort_info->h_size = ep->e2d_reclen;
- sort_info->h_offset = (char *)ep - block1;
+ sort_info->h_offset = htole16((char *)ep - block1);
ext2_htree_hash(ep->e2d_name, ep->e2d_namlen,
hash_seed, hash_version,
&sort_info->h_hash, NULL);
+ sort_info->h_hash = htole32(sort_info->h_hash);
}
ep = (struct ext2fs_direct_2 *)
- ((char *)ep + ep->e2d_reclen);
+ ((char *)ep + le16toh(ep->e2d_reclen));
}
/*
@@ -579,17 +591,17 @@
* Count the number of entries to move to directory block 2.
*/
for (i = entry_cnt - 1; i >= 0; i--) {
- if (sort_info[i].h_size + size > blksize / 2)
+ if (le16toh(sort_info[i].h_size) + size > blksize / 2)
break;
- size += sort_info[i].h_size;
+ size += le16toh(sort_info[i].h_size);
}
- *split_hash = sort_info[i + 1].h_hash;
+ *split_hash = le32toh(sort_info[i + 1].h_hash);
/*
* Set collision bit.
*/
- if (*split_hash == sort_info[i].h_hash)
+ if (*split_hash == le32toh(sort_info[i].h_hash))
*split_hash += 1;
/*
@@ -597,10 +609,11 @@
*/
for (k = i + 1; k < entry_cnt; k++) {
ep = (struct ext2fs_direct_2 *)((char *)block1 +
- sort_info[k].h_offset);
+ le16toh(sort_info[k].h_offset));
entry_len = EXT2_DIR_REC_LEN(ep->e2d_namlen);
memcpy(dest, ep, entry_len);
- ((struct ext2fs_direct_2 *)dest)->e2d_reclen = entry_len;
+ ((struct ext2fs_direct_2 *)dest)->e2d_reclen =
+ htole16(entry_len);
/* Mark directory entry as unused. */
ep->e2d_ino = 0;
dest += entry_len;
@@ -612,13 +625,13 @@
entry_len = 0;
for (offset = 0; offset < blksize - csum_size; ) {
ep = (struct ext2fs_direct_2 *)(block1 + offset);
- offset += ep->e2d_reclen;
- if (ep->e2d_ino) {
+ offset += le16toh(ep->e2d_reclen);
+ if (le32toh(ep->e2d_ino)) {
last = (struct ext2fs_direct_2 *)
((char *)last + entry_len);
entry_len = EXT2_DIR_REC_LEN(ep->e2d_namlen);
memcpy((void *)last, (void *)ep, entry_len);
- last->e2d_reclen = entry_len;
+ last->e2d_reclen = htole16(entry_len);
}
}
@@ -628,14 +641,15 @@
(struct ext2fs_direct_2 *)dest, entry, csum_size);
/* Adjust length field of last entry of block 1. */
- last->e2d_reclen = block1 + blksize - (char *)last - csum_size;
+ last->e2d_reclen = htole16(block1 + blksize - (char *)last -
+ csum_size);
} else {
/* Add entry to block 1. */
ext2_append_entry(block1, blksize, last, entry, csum_size);
/* Adjust length field of last entry of block 2. */
((struct ext2fs_direct_2 *)dest)->e2d_reclen =
- block2 + blksize - dest - csum_size;
+ htole16(block2 + blksize - dest - csum_size);
}
if (csum_size) {
@@ -661,6 +675,7 @@
struct ext2fs_htree_root *root;
struct ext2fs_htree_lookup_info info;
uint32_t blksize, dirlen, split_hash;
+ uint32_t hash_seed[4];
uint8_t hash_version;
char *buf1 = NULL;
char *buf2 = NULL;
@@ -679,21 +694,22 @@
root = (struct ext2fs_htree_root *)bp->b_data;
dotdot = (struct ext2fs_direct_2 *)((char *)&(root->h_dotdot));
- ep = (struct ext2fs_direct_2 *)((char *)dotdot + dotdot->e2d_reclen);
+ ep = (struct ext2fs_direct_2 *)((char *)dotdot +
+ le16toh(dotdot->e2d_reclen));
dirlen = (char *)root + blksize - (char *)ep;
memcpy(buf1, ep, dirlen);
ep = (struct ext2fs_direct_2 *)buf1;
while ((char *)ep < buf1 + dirlen)
ep = (struct ext2fs_direct_2 *)
- ((char *)ep + ep->e2d_reclen);
- ep->e2d_reclen = buf1 + blksize - (char *)ep;
+ ((char *)ep + le16toh(ep->e2d_reclen));
+ ep->e2d_reclen = htole16(buf1 + blksize - (char *)ep);
dp->i_flag |= IN_E3INDEX;
/*
* Initialize index root.
*/
- dotdot->e2d_reclen = blksize - EXT2_DIR_REC_LEN(1);
+ dotdot->e2d_reclen = htole16(blksize - EXT2_DIR_REC_LEN(1));
memset(&root->h_info, 0, sizeof(root->h_info));
root->h_info.h_hash_version = fs->e3fs_def_hash_version;
root->h_info.h_info_len = sizeof(root->h_info);
@@ -710,7 +726,8 @@
hash_version = root->h_info.h_hash_version;
if (hash_version <= EXT2_HTREE_TEA)
hash_version += m_fs->e2fs_uhash;
- ext2_htree_split_dirblock(dp, buf1, buf2, blksize, fs->e3fs_hash_seed,
+ ext2_get_hash_seed(fs, hash_seed);
+ ext2_htree_split_dirblock(dp, buf1, buf2, blksize, hash_seed,
hash_version, &split_hash, new_entry);
ext2_htree_insert_entry(&info, split_hash, 2);
@@ -771,6 +788,7 @@
uint32_t dirhash, split_hash;
uint32_t blksize, blknum;
uint64_t cursize, dirsize;
+ uint32_t hash_seed[4];
uint8_t hash_version;
char *newdirblock = NULL;
char *newidxblock = NULL;
@@ -804,7 +822,7 @@
dst_node = (struct ext2fs_htree_node *)newidxblock;
memset(&dst_node->h_fake_dirent, 0,
sizeof(dst_node->h_fake_dirent));
- dst_node->h_fake_dirent.e2d_reclen = blksize;
+ dst_node->h_fake_dirent.e2d_reclen = htole16(blksize);
cursize = roundup(ip->i_size, blksize);
dirsize = cursize + blksize;
@@ -899,8 +917,9 @@
/* Split target directory block */
newdirblock = malloc(blksize, M_TEMP, M_WAITOK | M_ZERO);
+ ext2_get_hash_seed(fs, hash_seed);
ext2_htree_split_dirblock(ip, (char *)bp->b_data, newdirblock, blksize,
- fs->e3fs_hash_seed, hash_version, &split_hash, entry);
+ hash_seed, hash_version, &split_hash, entry);
cursize = roundup(ip->i_size, blksize);
dirsize = cursize + blksize;
blknum = dirsize / blksize - 1;
Index: head/sys/fs/ext2fs/ext2_inode.c
===================================================================
--- head/sys/fs/ext2fs/ext2_inode.c
+++ head/sys/fs/ext2fs/ext2_inode.c
@@ -43,6 +43,7 @@
#include <sys/mount.h>
#include <sys/bio.h>
#include <sys/buf.h>
+#include <sys/endian.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/rwlock.h>
@@ -188,7 +189,7 @@
*/
for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
i--, nlbn += factor) {
- nb = bap[i];
+ nb = le32toh(bap[i]);
if (nb == 0)
continue;
if (level > SINGLE) {
@@ -206,7 +207,7 @@
*/
if (level > SINGLE && lastbn >= 0) {
last = lastbn % factor;
- nb = bap[i];
+ nb = le32toh(bap[i]);
if (nb != 0) {
if ((error = ext2_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
last, level - 1, &blkcount)) != 0)
Index: head/sys/fs/ext2fs/ext2_inode_cnv.c
===================================================================
--- head/sys/fs/ext2fs/ext2_inode_cnv.c
+++ head/sys/fs/ext2fs/ext2_inode_cnv.c
@@ -49,9 +49,6 @@
*/
SDT_PROBE_DEFINE2(ext2fs, , trace, inode_cnv, "int", "char*");
-#define XTIME_TO_NSEC(x) ((x & EXT3_NSEC_MASK) >> 2)
-#define NSEC_TO_XTIME(t) (le32toh(t << 2) & EXT3_NSEC_MASK)
-
#ifdef EXT2FS_PRINT_EXTENTS
void
ext2_print_inode(struct inode *in)
@@ -79,11 +76,14 @@
printf("Extents:\n");
ehp = (struct ext4_extent_header *)in->i_db;
printf("Header (magic 0x%x entries %d max %d depth %d gen %d)\n",
- ehp->eh_magic, ehp->eh_ecount, ehp->eh_max, ehp->eh_depth,
- ehp->eh_gen);
+ le16toh(ehp->eh_magic), le16toh(ehp->eh_ecount),
+ le16toh(ehp->eh_max), le16toh(ehp->eh_depth),
+ le32toh(ehp->eh_gen));
ep = (struct ext4_extent *)(char *)(ehp + 1);
- printf("Index (blk %d len %d start_lo %d start_hi %d)\n", ep->e_blk,
- ep->e_len, ep->e_start_lo, ep->e_start_hi);
+ printf("Index (blk %d len %d start_lo %d start_hi %d)\n",
+ le32toh(ep->e_blk),
+ le16toh(ep->e_len), le32toh(ep->e_start_lo),
+ le16toh(ep->e_start_hi));
printf("\n");
} else {
printf("BLOCKS:");
@@ -94,31 +94,38 @@
}
#endif /* EXT2FS_PRINT_EXTENTS */
+
+#define XTIME_TO_NSEC(x) ((le32toh(x) & EXT3_NSEC_MASK) >> 2)
+
/*
- * raw ext2 inode to inode
+ * raw ext2 inode LE to host inode conversion
*/
int
ext2_ei2i(struct ext2fs_dinode *ei, struct inode *ip)
{
struct m_ext2fs *fs = ip->i_e2fs;
+ uint32_t ei_flags_host;
+ uint16_t ei_extra_isize_le;
+ int i;
if ((ip->i_number < EXT2_FIRST_INO(fs) && ip->i_number != EXT2_ROOTINO) ||
(ip->i_number < EXT2_ROOTINO) ||
- (ip->i_number > fs->e2fs->e2fs_icount)) {
+ (ip->i_number > le32toh(fs->e2fs->e2fs_icount))) {
SDT_PROBE2(ext2fs, , trace, inode_cnv, 1, "bad inode number");
return (EINVAL);
}
- if (ip->i_number == EXT2_ROOTINO && ei->e2di_nlink == 0) {
+ ip->i_nlink = le16toh(ei->e2di_nlink);
+ if (ip->i_number == EXT2_ROOTINO && ip->i_nlink == 0) {
SDT_PROBE2(ext2fs, , trace, inode_cnv, 1, "root inode unallocated");
return (EINVAL);
}
- ip->i_nlink = ei->e2di_nlink;
/* Check extra inode size */
+ ei_extra_isize_le = le16toh(ei->e2di_extra_isize);
if (EXT2_INODE_SIZE(fs) > E2FS_REV0_INODE_SIZE) {
- if (E2FS_REV0_INODE_SIZE + ei->e2di_extra_isize >
- EXT2_INODE_SIZE(fs) || (ei->e2di_extra_isize & 3)) {
+ if (E2FS_REV0_INODE_SIZE + ei_extra_isize_le >
+ EXT2_INODE_SIZE(fs) || (ei_extra_isize_le & 3)) {
SDT_PROBE2(ext2fs, , trace, inode_cnv, 1,
"bad extra inode size");
return (EINVAL);
@@ -131,103 +138,124 @@
* setting i_mode to zero - why ? I can see that this might lead to
* problems in an undelete.
*/
- ip->i_mode = ei->e2di_nlink ? ei->e2di_mode : 0;
- ip->i_size = ei->e2di_size;
+ ip->i_mode = ip->i_nlink ? le16toh(ei->e2di_mode) : 0;
+ ip->i_size = le32toh(ei->e2di_size);
if (S_ISREG(ip->i_mode))
- ip->i_size |= ((u_int64_t)ei->e2di_size_high) << 32;
- ip->i_atime = ei->e2di_atime;
- ip->i_mtime = ei->e2di_mtime;
- ip->i_ctime = ei->e2di_ctime;
+ ip->i_size |= (uint64_t)le32toh(ei->e2di_size_high) << 32;
+ ip->i_atime = le32toh(ei->e2di_atime);
+ ip->i_mtime = le32toh(ei->e2di_mtime);
+ ip->i_ctime = le32toh(ei->e2di_ctime);
if (E2DI_HAS_XTIME(ip)) {
- ip->i_atimensec = XTIME_TO_NSEC(ei->e2di_atime_extra);
- ip->i_mtimensec = XTIME_TO_NSEC(ei->e2di_mtime_extra);
- ip->i_ctimensec = XTIME_TO_NSEC(ei->e2di_ctime_extra);
- ip->i_birthtime = ei->e2di_crtime;
- ip->i_birthnsec = XTIME_TO_NSEC(ei->e2di_crtime_extra);
+ ip->i_atimensec = XTIME_TO_NSEC(le32toh(ei->e2di_atime_extra));
+ ip->i_mtimensec = XTIME_TO_NSEC(le32toh(ei->e2di_mtime_extra));
+ ip->i_ctimensec = XTIME_TO_NSEC(le32toh(ei->e2di_ctime_extra));
+ ip->i_birthtime = le32toh(ei->e2di_crtime);
+ ip->i_birthnsec = XTIME_TO_NSEC(le32toh(ei->e2di_crtime_extra));
}
ip->i_flags = 0;
- ip->i_flags |= (ei->e2di_flags & EXT2_APPEND) ? SF_APPEND : 0;
- ip->i_flags |= (ei->e2di_flags & EXT2_IMMUTABLE) ? SF_IMMUTABLE : 0;
- ip->i_flags |= (ei->e2di_flags & EXT2_NODUMP) ? UF_NODUMP : 0;
- ip->i_flag |= (ei->e2di_flags & EXT3_INDEX) ? IN_E3INDEX : 0;
- ip->i_flag |= (ei->e2di_flags & EXT4_EXTENTS) ? IN_E4EXTENTS : 0;
- ip->i_blocks = ei->e2di_nblock;
- ip->i_facl = ei->e2di_facl;
+ ei_flags_host = le32toh(ei->e2di_flags);
+ ip->i_flags |= (ei_flags_host & EXT2_APPEND) ? SF_APPEND : 0;
+ ip->i_flags |= (ei_flags_host & EXT2_IMMUTABLE) ? SF_IMMUTABLE : 0;
+ ip->i_flags |= (ei_flags_host & EXT2_NODUMP) ? UF_NODUMP : 0;
+ ip->i_flag |= (ei_flags_host & EXT3_INDEX) ? IN_E3INDEX : 0;
+ ip->i_flag |= (ei_flags_host & EXT4_EXTENTS) ? IN_E4EXTENTS : 0;
+ ip->i_blocks = le32toh(ei->e2di_nblock);
+ ip->i_facl = le32toh(ei->e2di_facl);
if (E2DI_HAS_HUGE_FILE(ip)) {
- ip->i_blocks |= (uint64_t)ei->e2di_nblock_high << 32;
- ip->i_facl |= (uint64_t)ei->e2di_facl_high << 32;
- if (ei->e2di_flags & EXT4_HUGE_FILE)
+ ip->i_blocks |= (uint64_t)le16toh(ei->e2di_nblock_high) << 32;
+ ip->i_facl |= (uint64_t)le16toh(ei->e2di_facl_high) << 32;
+ if (ei_flags_host & EXT4_HUGE_FILE)
ip->i_blocks = fsbtodb(ip->i_e2fs, ip->i_blocks);
}
- ip->i_gen = ei->e2di_gen;
- ip->i_uid = ei->e2di_uid;
- ip->i_gid = ei->e2di_gid;
- ip->i_uid |= (uint32_t)ei->e2di_uid_high << 16;
- ip->i_gid |= (uint32_t)ei->e2di_gid_high << 16;
+ ip->i_gen = le32toh(ei->e2di_gen);
+ ip->i_uid = le16toh(ei->e2di_uid);
+ ip->i_gid = le16toh(ei->e2di_gid);
+ ip->i_uid |= (uint32_t)le16toh(ei->e2di_uid_high) << 16;
+ ip->i_gid |= (uint32_t)le16toh(ei->e2di_gid_high) << 16;
- memcpy(ip->i_data, ei->e2di_blocks, sizeof(ei->e2di_blocks));
+ if ((ip->i_flag & IN_E4EXTENTS)) {
+ memcpy(ip->i_data, ei->e2di_blocks, sizeof(ei->e2di_blocks));
+ } else {
+ for (i = 0; i < EXT2_NDADDR; i++)
+ ip->i_db[i] = le32toh(ei->e2di_blocks[i]);
+ for (i = 0; i < EXT2_NIADDR; i++)
+ ip->i_ib[i] = le32toh(ei->e2di_blocks[EXT2_NDIR_BLOCKS + i]);
+ }
/* Verify inode csum. */
return (ext2_ei_csum_verify(ip, ei));
}
+#define NSEC_TO_XTIME(t) (htole32((t << 2) & EXT3_NSEC_MASK))
+
/*
- * inode to raw ext2 inode
+ * inode to raw ext2 LE inode conversion
*/
int
ext2_i2ei(struct inode *ip, struct ext2fs_dinode *ei)
{
struct m_ext2fs *fs;
+ int i;
fs = ip->i_e2fs;
- ei->e2di_mode = ip->i_mode;
- ei->e2di_nlink = ip->i_nlink;
+ ei->e2di_mode = htole16(ip->i_mode);
+ ei->e2di_nlink = htole16(ip->i_nlink);
+ ei->e2di_size = htole32(ip->i_size);
+ if (S_ISREG(ip->i_mode))
+ ei->e2di_size_high = htole32(ip->i_size >> 32);
+ ei->e2di_atime = htole32(ip->i_atime);
+ ei->e2di_mtime = htole32(ip->i_mtime);
+ ei->e2di_ctime = htole32(ip->i_ctime);
/*
* Godmar thinks: if dtime is nonzero, ext2 says this inode has been
* deleted, this would correspond to a zero link count
*/
- ei->e2di_dtime = ei->e2di_nlink ? 0 : ip->i_mtime;
- ei->e2di_size = ip->i_size;
- if (S_ISREG(ip->i_mode))
- ei->e2di_size_high = ip->i_size >> 32;
- ei->e2di_atime = ip->i_atime;
- ei->e2di_mtime = ip->i_mtime;
- ei->e2di_ctime = ip->i_ctime;
+ ei->e2di_dtime = htole32(le16toh(ei->e2di_nlink) ? 0 :
+ le32toh(ei->e2di_mtime));
if (E2DI_HAS_XTIME(ip)) {
- ei->e2di_ctime_extra = NSEC_TO_XTIME(ip->i_ctimensec);
- ei->e2di_mtime_extra = NSEC_TO_XTIME(ip->i_mtimensec);
- ei->e2di_atime_extra = NSEC_TO_XTIME(ip->i_atimensec);
- ei->e2di_crtime = ip->i_birthtime;
- ei->e2di_crtime_extra = NSEC_TO_XTIME(ip->i_birthnsec);
+ ei->e2di_ctime_extra = htole32(NSEC_TO_XTIME(ip->i_ctimensec));
+ ei->e2di_mtime_extra = htole32(NSEC_TO_XTIME(ip->i_mtimensec));
+ ei->e2di_atime_extra = htole32(NSEC_TO_XTIME(ip->i_atimensec));
+ ei->e2di_crtime = htole32(ip->i_birthtime);
+ ei->e2di_crtime_extra = htole32(NSEC_TO_XTIME(ip->i_birthnsec));
}
+ /* Keep these in host endian for a while since they change a lot */
ei->e2di_flags = 0;
- ei->e2di_flags |= (ip->i_flags & SF_APPEND) ? EXT2_APPEND : 0;
- ei->e2di_flags |= (ip->i_flags & SF_IMMUTABLE) ? EXT2_IMMUTABLE : 0;
- ei->e2di_flags |= (ip->i_flags & UF_NODUMP) ? EXT2_NODUMP : 0;
- ei->e2di_flags |= (ip->i_flag & IN_E3INDEX) ? EXT3_INDEX : 0;
- ei->e2di_flags |= (ip->i_flag & IN_E4EXTENTS) ? EXT4_EXTENTS : 0;
+ ei->e2di_flags |= htole32((ip->i_flags & SF_APPEND) ? EXT2_APPEND : 0);
+ ei->e2di_flags |= htole32((ip->i_flags & SF_IMMUTABLE) ? EXT2_IMMUTABLE : 0);
+ ei->e2di_flags |= htole32((ip->i_flags & UF_NODUMP) ? EXT2_NODUMP : 0);
+ ei->e2di_flags |= htole32((ip->i_flag & IN_E3INDEX) ? EXT3_INDEX : 0);
+ ei->e2di_flags |= htole32((ip->i_flag & IN_E4EXTENTS) ? EXT4_EXTENTS : 0);
if (ip->i_blocks > ~0U &&
!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE)) {
SDT_PROBE2(ext2fs, , trace, inode_cnv, 1, "i_blocks value is out of range");
return (EIO);
}
if (ip->i_blocks <= 0xffffffffffffULL) {
- ei->e2di_nblock = ip->i_blocks & 0xffffffff;
- ei->e2di_nblock_high = ip->i_blocks >> 32 & 0xffff;
+ ei->e2di_nblock = htole32(ip->i_blocks & 0xffffffff);
+ ei->e2di_nblock_high = htole16(ip->i_blocks >> 32 & 0xffff);
} else {
- ei->e2di_flags |= EXT4_HUGE_FILE;
- ei->e2di_nblock = dbtofsb(fs, ip->i_blocks);
- ei->e2di_nblock_high = dbtofsb(fs, ip->i_blocks) >> 32 & 0xffff;
+ ei->e2di_flags |= htole32(EXT4_HUGE_FILE);
+ ei->e2di_nblock = htole32(dbtofsb(fs, ip->i_blocks));
+ ei->e2di_nblock_high = htole16(dbtofsb(fs, ip->i_blocks) >> 32 & 0xffff);
}
- ei->e2di_facl = ip->i_facl & 0xffffffff;
- ei->e2di_facl_high = ip->i_facl >> 32 & 0xffff;
- ei->e2di_gen = ip->i_gen;
- ei->e2di_uid = ip->i_uid & 0xffff;
- ei->e2di_uid_high = ip->i_uid >> 16 & 0xffff;
- ei->e2di_gid = ip->i_gid & 0xffff;
- ei->e2di_gid_high = ip->i_gid >> 16 & 0xffff;
- memcpy(ei->e2di_blocks, ip->i_data, sizeof(ei->e2di_blocks));
+ ei->e2di_facl = htole32(ip->i_facl & 0xffffffff);
+ ei->e2di_facl_high = htole16(ip->i_facl >> 32 & 0xffff);
+ ei->e2di_gen = htole32(ip->i_gen);
+ ei->e2di_uid = htole16(ip->i_uid & 0xffff);
+ ei->e2di_uid_high = htole16(ip->i_uid >> 16 & 0xffff);
+ ei->e2di_gid = htole16(ip->i_gid & 0xffff);
+ ei->e2di_gid_high = htole16(ip->i_gid >> 16 & 0xffff);
+
+ if ((ip->i_flag & IN_E4EXTENTS)) {
+ memcpy(ei->e2di_blocks, ip->i_data, sizeof(ei->e2di_blocks));
+ } else {
+ for (i = 0; i < EXT2_NDADDR; i++)
+ ei->e2di_blocks[i] = htole32(ip->i_db[i]);
+ for (i = 0; i < EXT2_NIADDR; i++)
+ ei->e2di_blocks[EXT2_NDIR_BLOCKS + i] = htole32(ip->i_ib[i]);
+ }
/* Set inode csum. */
ext2_ei_csum_set(ip, ei);
Index: head/sys/fs/ext2fs/ext2_lookup.c
===================================================================
--- head/sys/fs/ext2fs/ext2_lookup.c
+++ head/sys/fs/ext2fs/ext2_lookup.c
@@ -203,8 +203,8 @@
dp = (struct ext2fs_direct_2 *)&bp->b_data[skipcnt];
edp = (struct ext2fs_direct_2 *)&bp->b_data[readcnt];
while (error == 0 && uio->uio_resid > 0 && dp < edp) {
- if (dp->e2d_reclen <= offsetof(struct ext2fs_direct_2,
- e2d_namlen) || (caddr_t)dp + dp->e2d_reclen >
+ if (le16toh(dp->e2d_reclen) <= offsetof(struct ext2fs_direct_2,
+ e2d_namlen) || (caddr_t)dp + le16toh(dp->e2d_reclen) >
(caddr_t)edp) {
error = EIO;
break;
@@ -228,17 +228,17 @@
dstdp.d_namlen = dp->e2d_namlen;
dstdp.d_type = FTTODT(dp->e2d_type);
if (offsetof(struct ext2fs_direct_2, e2d_namlen) +
- dstdp.d_namlen > dp->e2d_reclen) {
+ dstdp.d_namlen > le16toh(dp->e2d_reclen)) {
error = EIO;
break;
}
- if (offset < startoffset || dp->e2d_ino == 0)
+ if (offset < startoffset || le32toh(dp->e2d_ino) == 0)
goto nextentry;
- dstdp.d_fileno = dp->e2d_ino;
+ dstdp.d_fileno = le32toh(dp->e2d_ino);
dstdp.d_reclen = GENERIC_DIRSIZ(&dstdp);
bcopy(dp->e2d_name, dstdp.d_name, dstdp.d_namlen);
/* NOTE: d_off is the offset of the *next* entry. */
- dstdp.d_off = offset + dp->e2d_reclen;
+ dstdp.d_off = offset + le16toh(dp->e2d_reclen);
dirent_terminate(&dstdp);
if (dstdp.d_reclen > uio->uio_resid) {
if (uio->uio_resid == startresid)
@@ -254,14 +254,14 @@
if (cookies != NULL) {
KASSERT(ncookies > 0,
("ext2_readdir: cookies buffer too small"));
- *cookies = offset + dp->e2d_reclen;
+ *cookies = offset + le16toh(dp->e2d_reclen);
cookies++;
ncookies--;
}
nextentry:
- offset += dp->e2d_reclen;
+ offset += le16toh(dp->e2d_reclen);
dp = (struct ext2fs_direct_2 *)((caddr_t)dp +
- dp->e2d_reclen);
+ le16toh(dp->e2d_reclen));
}
bqrelse(bp);
uio->uio_offset = offset;
@@ -464,7 +464,7 @@
ep = (struct ext2fs_direct_2 *)((char *)bp->b_data +
(entryoffsetinblock & bmask));
foundentry:
- ino = ep->e2d_ino;
+ ino = le32toh(ep->e2d_ino);
goto found;
}
}
@@ -546,8 +546,8 @@
* Check that directory length properly reflects presence
* of this entry.
*/
- if (entryoffsetinblock + EXT2_DIR_REC_LEN(ep->e2d_namlen)
- > dp->i_size) {
+ if (entryoffsetinblock + EXT2_DIR_REC_LEN(ep->e2d_namlen) >
+ dp->i_size) {
ext2_dirbad(dp, i_offset, "i_size too small");
dp->i_size = entryoffsetinblock + EXT2_DIR_REC_LEN(ep->e2d_namlen);
dp->i_flag |= IN_CHANGE | IN_UPDATE;
@@ -740,7 +740,7 @@
* directory. Complete checks can be run by setting
* "vfs.e2fs.dirchk" to be true.
*/
- if (ep->e2d_reclen == 0 ||
+ if (le16toh(ep->e2d_reclen) == 0 ||
(dirchk && ext2_dirbadentry(vdp, ep, offset))) {
int i;
@@ -758,7 +758,7 @@
* compaction is viable.
*/
if (ssp->slotstatus != FOUND) {
- int size = ep->e2d_reclen;
+ int size = le16toh(ep->e2d_reclen);
if (ep->e2d_ino != 0)
size -= EXT2_DIR_REC_LEN(ep->e2d_namlen);
@@ -768,7 +768,7 @@
if (size >= ssp->slotneeded) {
ssp->slotstatus = FOUND;
ssp->slotoffset = *offp;
- ssp->slotsize = ep->e2d_reclen;
+ ssp->slotsize = le16toh(ep->e2d_reclen);
} else if (ssp->slotstatus == NONE) {
ssp->slotfreespace += size;
if (ssp->slotoffset == -1)
@@ -776,7 +776,7 @@
if (ssp->slotfreespace >= ssp->slotneeded) {
ssp->slotstatus = COMPACT;
ssp->slotsize = *offp +
- ep->e2d_reclen -
+ le16toh(ep->e2d_reclen) -
ssp->slotoffset;
}
}
@@ -785,7 +785,7 @@
/*
* Check for a name match.
*/
- if (ep->e2d_ino) {
+ if (ep->e2d_ino != 0) {
namlen = ep->e2d_namlen;
if (namlen == namelen &&
!bcmp(name, ep->e2d_name, (unsigned)namlen)) {
@@ -799,10 +799,10 @@
}
}
*prevoffp = *offp;
- *offp += ep->e2d_reclen;
- offset += ep->e2d_reclen;
+ *offp += le16toh(ep->e2d_reclen);
+ offset += le16toh(ep->e2d_reclen);
*entryoffsetinblockp = offset;
- if (ep->e2d_ino)
+ if (ep->e2d_ino != 0)
*endusefulp = *offp;
/*
* Get pointer to the next entry.
@@ -847,13 +847,13 @@
char *error_msg = NULL;
- if (de->e2d_reclen < EXT2_DIR_REC_LEN(1))
+ if (le16toh(de->e2d_reclen) < EXT2_DIR_REC_LEN(1))
error_msg = "rec_len is smaller than minimal";
- else if (de->e2d_reclen % 4 != 0)
+ else if (le16toh(de->e2d_reclen) % 4 != 0)
error_msg = "rec_len % 4 != 0";
- else if (de->e2d_reclen < EXT2_DIR_REC_LEN(de->e2d_namlen))
+ else if (le16toh(de->e2d_reclen) < EXT2_DIR_REC_LEN(de->e2d_namlen))
error_msg = "reclen is too small for name_len";
- else if (entryoffsetinblock + de->e2d_reclen > DIRBLKSIZ)
+ else if (entryoffsetinblock + le16toh(de->e2d_reclen)> DIRBLKSIZ)
error_msg = "directory entry across blocks";
/* else LATER
if (de->inode > dir->i_sb->u.ext2_sb.s_es->s_inodes_count)
@@ -863,9 +863,10 @@
if (error_msg != NULL) {
SDT_PROBE5(ext2fs, , trace, ext2_dirbadentry_error,
error_msg, entryoffsetinblock,
- de->e2d_ino, de->e2d_reclen, de->e2d_namlen);
+ le32toh(de->e2d_ino), le16toh(de->e2d_reclen),
+ de->e2d_namlen);
}
- return error_msg == NULL ? 0 : 1;
+ return (error_msg == NULL ? 0 : 1);
}
/*
@@ -890,7 +891,8 @@
if (EXT2_HAS_RO_COMPAT_FEATURE(dp->i_e2fs,
EXT2F_ROCOMPAT_METADATA_CKSUM)) {
- entry->e2d_reclen = dirblksize - sizeof(struct ext2fs_direct_tail);
+ entry->e2d_reclen = htole16(dirblksize -
+ sizeof(struct ext2fs_direct_tail));
buf = malloc(dirblksize, M_TEMP, M_WAITOK);
if (!buf) {
error = ENOMEM;
@@ -905,7 +907,7 @@
aiov.iov_len = auio.uio_resid;
aiov.iov_base = (caddr_t)buf;
} else {
- entry->e2d_reclen = dirblksize;
+ entry->e2d_reclen = htole16(dirblksize);
auio.uio_offset = dp->i_offset;
auio.uio_resid = EXT2_DIR_REC_LEN(entry->e2d_namlen);
aiov.iov_len = auio.uio_resid;
@@ -952,13 +954,14 @@
panic("ext2_direnter: missing name");
#endif
dp = VTOI(dvp);
- newdir.e2d_ino = ip->i_number;
- newdir.e2d_namlen = cnp->cn_namelen;
+ newdir.e2d_ino = htole32(ip->i_number);
if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs,
- EXT2F_INCOMPAT_FTYPE))
+ EXT2F_INCOMPAT_FTYPE)) {
+ newdir.e2d_namlen = cnp->cn_namelen;
newdir.e2d_type = DTTOFT(IFTODT(ip->i_mode));
- else
- newdir.e2d_type = EXT2_FT_UNKNOWN;
+ } else
+ newdir.e2d_namlen = htole16(cnp->cn_namelen);
+
bcopy(cnp->cn_nameptr, newdir.e2d_name, (unsigned)cnp->cn_namelen + 1);
if (ext2_htree_has_idx(dp)) {
@@ -1048,20 +1051,20 @@
newentrysize = EXT2_DIR_REC_LEN(entry->e2d_namlen);
ep = (struct ext2fs_direct_2 *)dirbuf;
dsize = EXT2_DIR_REC_LEN(ep->e2d_namlen);
- spacefree = ep->e2d_reclen - dsize;
- for (loc = ep->e2d_reclen; loc < dp->i_count; ) {
+ spacefree = le16toh(ep->e2d_reclen) - dsize;
+ for (loc = le16toh(ep->e2d_reclen); loc < dp->i_count; ) {
nep = (struct ext2fs_direct_2 *)(dirbuf + loc);
- if (ep->e2d_ino) {
+ if (le32toh(ep->e2d_ino)) {
/* trim the existing slot */
- ep->e2d_reclen = dsize;
+ ep->e2d_reclen = htole16(dsize);
ep = (struct ext2fs_direct_2 *)((char *)ep + dsize);
} else {
/* overwrite; nothing there; header is ours */
spacefree += dsize;
}
dsize = EXT2_DIR_REC_LEN(nep->e2d_namlen);
- spacefree += nep->e2d_reclen - dsize;
- loc += nep->e2d_reclen;
+ spacefree += le16toh(nep->e2d_reclen) - dsize;
+ loc += le16toh(nep->e2d_reclen);
bcopy((caddr_t)nep, (caddr_t)ep, dsize);
}
/*
@@ -1071,12 +1074,12 @@
if (ep->e2d_ino == 0) {
if (spacefree + dsize < newentrysize)
panic("ext2_direnter: compact1");
- entry->e2d_reclen = spacefree + dsize;
+ entry->e2d_reclen = htole16(spacefree + dsize);
} else {
if (spacefree < newentrysize)
panic("ext2_direnter: compact2");
- entry->e2d_reclen = spacefree;
- ep->e2d_reclen = dsize;
+ entry->e2d_reclen = htole16(spacefree);
+ ep->e2d_reclen = htole16(dsize);
ep = (struct ext2fs_direct_2 *)((char *)ep + dsize);
}
bcopy((caddr_t)entry, (caddr_t)ep, (u_int)newentrysize);
@@ -1137,7 +1140,8 @@
if (dp->i_count == 0)
rep = ep;
else
- rep = (struct ext2fs_direct_2 *)((char *)ep + ep->e2d_reclen);
+ rep = (struct ext2fs_direct_2 *)((char *)ep +
+ le16toh(ep->e2d_reclen));
ep->e2d_reclen += rep->e2d_reclen;
ext2_dirent_csum_set(dp, (struct ext2fs_direct_2 *)bp->b_data);
if (DOINGASYNC(dvp) && dp->i_count != 0)
@@ -1164,7 +1168,7 @@
if ((error = ext2_blkatoff(vdp, (off_t)dp->i_offset, (char **)&ep,
&bp)) != 0)
return (error);
- ep->e2d_ino = ip->i_number;
+ ep->e2d_ino = htole32(ip->i_number);
if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs,
EXT2F_INCOMPAT_FTYPE))
ep->e2d_type = DTTOFT(IFTODT(ip->i_mode));
@@ -1195,7 +1199,7 @@
ssize_t count;
#define MINDIRSIZ (sizeof(struct dirtemplate) / 2)
- for (off = 0; off < ip->i_size; off += dp->e2d_reclen) {
+ for (off = 0; off < ip->i_size; off += le16toh(dp->e2d_reclen)) {
error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ,
off, UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK, cred,
NOCRED, &count, (struct thread *)0);
@@ -1224,7 +1228,7 @@
*/
if (namlen == 1)
continue;
- if (dp->e2d_name[1] == '.' && dp->e2d_ino == parentino)
+ if (dp->e2d_name[1] == '.' && le32toh(dp->e2d_ino) == parentino)
continue;
return (0);
}
@@ -1271,14 +1275,14 @@
error = ENOTDIR;
break;
}
- if (dirbuf.dotdot_ino == source->i_number) {
+ if (le32toh(dirbuf.dotdot_ino) == source->i_number) {
error = EINVAL;
break;
}
- if (dirbuf.dotdot_ino == EXT2_ROOTINO)
+ if (le32toh(dirbuf.dotdot_ino) == EXT2_ROOTINO)
break;
vput(vp);
- if ((error = VFS_VGET(vp->v_mount, dirbuf.dotdot_ino,
+ if ((error = VFS_VGET(vp->v_mount, le32toh(dirbuf.dotdot_ino),
LK_EXCLUSIVE, &vp)) != 0) {
vp = NULL;
break;
Index: head/sys/fs/ext2fs/ext2_subr.c
===================================================================
--- head/sys/fs/ext2fs/ext2_subr.c
+++ head/sys/fs/ext2fs/ext2_subr.c
@@ -114,7 +114,7 @@
bit = 1;
loc = 0;
- for (i = 0; i < fs->e2fs->e2fs_fpg; i++) {
+ for (i = 0; i < fs->e2fs_fpg; i++) {
if ((bbp[loc] & bit) == 0)
run++;
else if (run != 0) {
@@ -144,8 +144,8 @@
/* Find the size of the cluster going forward. */
start = bno + 1;
end = start + fs->e2fs_contigsumsize;
- if (end > fs->e2fs->e2fs_fpg)
- end = fs->e2fs->e2fs_fpg;
+ if (end > fs->e2fs_fpg)
+ end = fs->e2fs_fpg;
loc = start / NBBY;
bit = 1 << (start % NBBY);
for (i = start; i < end; i++) {
Index: head/sys/fs/ext2fs/ext2_vfsops.c
===================================================================
--- head/sys/fs/ext2fs/ext2_vfsops.c
+++ head/sys/fs/ext2fs/ext2_vfsops.c
@@ -169,7 +169,9 @@
error = ext2_flushfiles(mp, flags, td);
if (error == 0 && fs->e2fs_wasvalid &&
ext2_cgupdate(ump, MNT_WAIT) == 0) {
- fs->e2fs->e2fs_state |= E2FS_ISCLEAN;
+ fs->e2fs->e2fs_state =
+ htole16((le16toh(fs->e2fs->e2fs_state) |
+ E2FS_ISCLEAN));
ext2_sbupdate(ump, MNT_WAIT);
}
fs->e2fs_ronly = 1;
@@ -207,8 +209,8 @@
if (error)
return (error);
- if ((fs->e2fs->e2fs_state & E2FS_ISCLEAN) == 0 ||
- (fs->e2fs->e2fs_state & E2FS_ERRORS)) {
+ if ((le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN) == 0 ||
+ (le16toh(fs->e2fs->e2fs_state) & E2FS_ERRORS)) {
if (mp->mnt_flag & MNT_FORCE) {
printf(
"WARNING: %s was not properly dismounted\n", fs->e2fs_fsmnt);
@@ -219,7 +221,8 @@
return (EPERM);
}
}
- fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN;
+ fs->e2fs->e2fs_state =
+ htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN);
(void)ext2_cgupdate(ump, MNT_WAIT);
fs->e2fs_ronly = 0;
MNT_ILOCK(mp);
@@ -297,13 +300,13 @@
{
uint32_t i, mask;
- if (es->e2fs_magic != E2FS_MAGIC) {
+ if (le16toh(es->e2fs_magic) != E2FS_MAGIC) {
printf("ext2fs: %s: wrong magic number %#x (expected %#x)\n",
- devtoname(dev), es->e2fs_magic, E2FS_MAGIC);
+ devtoname(dev), le16toh(es->e2fs_magic), E2FS_MAGIC);
return (1);
}
- if (es->e2fs_rev > E2FS_REV0) {
- mask = es->e2fs_features_incompat & ~(EXT2F_INCOMPAT_SUPP);
+ if (le32toh(es->e2fs_rev) > E2FS_REV0) {
+ mask = le32toh(es->e2fs_features_incompat) & ~(EXT2F_INCOMPAT_SUPP);
if (mask) {
printf("WARNING: mount of %s denied due to "
"unsupported optional features:\n", devtoname(dev));
@@ -315,7 +318,7 @@
printf("\n");
return (1);
}
- mask = es->e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP;
+ mask = le32toh(es->e2fs_features_rocompat) & ~EXT2F_ROCOMPAT_SUPP;
if (!ronly && mask) {
printf("WARNING: R/W mount of %s denied due to "
"unsupported optional features:\n", devtoname(dev));
@@ -344,7 +347,7 @@
logical_sb = fs->e2fs_bsize > SBSIZE ? 0 : 1;
if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||
- number < fs->e2fs->e3fs_first_meta_bg)
+ number < le32toh(fs->e2fs->e3fs_first_meta_bg))
return (logical_sb + number + 1);
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT))
@@ -358,7 +361,7 @@
has_super = 1;
return (has_super + cg * (e4fs_daddr_t)EXT2_BLOCKS_PER_GROUP(fs) +
- fs->e2fs->e2fs_first_dblock);
+ le32toh(fs->e2fs->e2fs_first_dblock));
}
static int
@@ -371,7 +374,7 @@
struct ext2_gd *gd;
unsigned int i, cg_count;
- first_block = fs->e2fs->e2fs_first_dblock;
+ first_block = le32toh(fs->e2fs->e2fs_first_dblock);
last_cg_block = ext2_cg_number_gdb(fs, 0);
cg_count = fs->e2fs_gcount;
@@ -387,7 +390,7 @@
}
if ((cg_count == fs->e2fs_gcount) &&
- !(gd->ext4bgd_flags & EXT2_BG_INODE_ZEROED))
+ !(le16toh(gd->ext4bgd_flags) & EXT2_BG_INODE_ZEROED))
cg_count = i;
b_bitmap = e2fs_gd_get_b_bitmap(gd);
@@ -484,26 +487,26 @@
}
/* Check for block size = 1K|2K|4K */
- if (es->e2fs_log_bsize > 2) {
+ if (le32toh(es->e2fs_log_bsize) > 2) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"bad block size");
return (EINVAL);
}
- fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + es->e2fs_log_bsize;
+ fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + le32toh(es->e2fs_log_bsize);
fs->e2fs_bsize = 1U << fs->e2fs_bshift;
- fs->e2fs_fsbtodb = es->e2fs_log_bsize + 1;
+ fs->e2fs_fsbtodb = le32toh(es->e2fs_log_bsize) + 1;
fs->e2fs_qbmask = fs->e2fs_bsize - 1;
/* Check for fragment size */
- if (es->e2fs_log_fsize >
+ if (le32toh(es->e2fs_log_fsize) >
(EXT2_MAX_FRAG_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE)) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"invalid log cluster size");
return (EINVAL);
}
- fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << es->e2fs_log_fsize;
+ fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << le32toh(es->e2fs_log_fsize);
if (fs->e2fs_fsize != fs->e2fs_bsize) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"fragment size != block size");
@@ -513,21 +516,21 @@
fs->e2fs_fpb = fs->e2fs_bsize / fs->e2fs_fsize;
/* Check reserved gdt blocks for future filesystem expansion */
- if (es->e2fs_reserved_ngdb > (fs->e2fs_bsize / 4)) {
+ if (le16toh(es->e2fs_reserved_ngdb) > (fs->e2fs_bsize / 4)) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"number of reserved GDT blocks too large");
return (EINVAL);
}
- if (es->e2fs_rev == E2FS_REV0) {
+ if (le32toh(es->e2fs_rev) == E2FS_REV0) {
fs->e2fs_isize = E2FS_REV0_INODE_SIZE;
} else {
- fs->e2fs_isize = es->e2fs_inode_size;
+ fs->e2fs_isize = le16toh(es->e2fs_inode_size);
/*
* Check first ino.
*/
- if (es->e2fs_first_ino < EXT2_FIRSTINO) {
+ if (le32toh(es->e2fs_first_ino) < EXT2_FIRSTINO) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"invalid first ino");
return (EINVAL);
@@ -547,14 +550,14 @@
/* Check group descriptors */
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&
- es->e3fs_desc_size != E2FS_64BIT_GD_SIZE) {
+ le16toh(es->e3fs_desc_size) != E2FS_64BIT_GD_SIZE) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"unsupported 64bit descriptor size");
return (EINVAL);
}
- fs->e2fs_bpg = es->e2fs_bpg;
- fs->e2fs_fpg = es->e2fs_fpg;
+ fs->e2fs_bpg = le32toh(es->e2fs_bpg);
+ fs->e2fs_fpg = le32toh(es->e2fs_fpg);
if (fs->e2fs_bpg == 0 || fs->e2fs_fpg == 0) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"zero blocks/fragments per group");
@@ -579,7 +582,7 @@
return (EINVAL);
}
- fs->e2fs_ipg = es->e2fs_ipg;
+ fs->e2fs_ipg = le32toh(es->e2fs_ipg);
if (fs->e2fs_ipg < fs->e2fs_ipb || fs->e2fs_ipg > fs->e2fs_bsize * 8) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"invalid inodes per group");
@@ -588,13 +591,13 @@
fs->e2fs_itpg = fs->e2fs_ipg / fs->e2fs_ipb;
- fs->e2fs_bcount = es->e2fs_bcount;
- fs->e2fs_rbcount = es->e2fs_rbcount;
- fs->e2fs_fbcount = es->e2fs_fbcount;
+ fs->e2fs_bcount = le32toh(es->e2fs_bcount);
+ fs->e2fs_rbcount = le32toh(es->e2fs_rbcount);
+ fs->e2fs_fbcount = le32toh(es->e2fs_fbcount);
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
- fs->e2fs_bcount |= (uint64_t)(es->e4fs_bcount_hi) << 32;
- fs->e2fs_rbcount |= (uint64_t)(es->e4fs_rbcount_hi) << 32;
- fs->e2fs_fbcount |= (uint64_t)(es->e4fs_fbcount_hi) << 32;
+ fs->e2fs_bcount |= (uint64_t)(le32toh(es->e4fs_bcount_hi)) << 32;
+ fs->e2fs_rbcount |= (uint64_t)(le32toh(es->e4fs_rbcount_hi)) << 32;
+ fs->e2fs_fbcount |= (uint64_t)(le32toh(es->e4fs_fbcount_hi)) << 32;
}
if (fs->e2fs_rbcount > fs->e2fs_bcount ||
fs->e2fs_fbcount > fs->e2fs_bcount) {
@@ -602,14 +605,22 @@
"invalid block count");
return (EINVAL);
}
- if (es->e2fs_first_dblock >= fs->e2fs_bcount) {
+
+ fs->e2fs_ficount = le32toh(es->e2fs_ficount);
+ if (fs->e2fs_ficount > le32toh(es->e2fs_icount)) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
+ "invalid number of free inodes");
+ return (EINVAL);
+ }
+
+ if (le32toh(es->e2fs_first_dblock) >= fs->e2fs_bcount) {
+ SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"first data block out of range");
return (EINVAL);
}
- fs->e2fs_gcount = howmany(fs->e2fs_bcount - es->e2fs_first_dblock,
- EXT2_BLOCKS_PER_GROUP(fs));
+ fs->e2fs_gcount = howmany(fs->e2fs_bcount -
+ le32toh(es->e2fs_first_dblock), EXT2_BLOCKS_PER_GROUP(fs));
if (fs->e2fs_gcount > ((uint64_t)1 << 32) - EXT2_DESCS_PER_BLOCK(fs)) {
SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
"groups count too large");
@@ -685,7 +696,7 @@
for (i = 0; i < fs->e2fs_gcount; i++)
fs->e2fs_total_dir += e2fs_gd_get_ndirs(&fs->e2fs_gd[i]);
- if (es->e2fs_rev == E2FS_REV0 ||
+ if (le32toh(es->e2fs_rev) == E2FS_REV0 ||
!EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_LARGEFILE))
fs->e2fs_maxfilesize = 0x7fffffff;
else {
@@ -693,14 +704,14 @@
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE))
fs->e2fs_maxfilesize = 0x7fffffffffffffff;
}
- if (es->e4fs_flags & E2FS_UNSIGNED_HASH) {
+ if (le32toh(es->e4fs_flags) & E2FS_UNSIGNED_HASH) {
fs->e2fs_uhash = 3;
- } else if ((es->e4fs_flags & E2FS_SIGNED_HASH) == 0) {
+ } else if ((le32toh(es->e4fs_flags) & E2FS_SIGNED_HASH) == 0) {
#ifdef __CHAR_UNSIGNED__
- es->e4fs_flags |= E2FS_UNSIGNED_HASH;
+ es->e4fs_flags = htole32(le32toh(es->e4fs_flags) | E2FS_UNSIGNED_HASH);
fs->e2fs_uhash = 3;
#else
- es->e4fs_flags |= E2FS_SIGNED_HASH;
+ es->e4fs_flags = htole32(le32toh(es->e4fs_flags) | E2FS_SIGNED_HASH);
#endif
}
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
@@ -879,8 +890,8 @@
error = EINVAL; /* XXX needs translation */
goto out;
}
- if ((es->e2fs_state & E2FS_ISCLEAN) == 0 ||
- (es->e2fs_state & E2FS_ERRORS)) {
+ if ((le16toh(es->e2fs_state) & E2FS_ISCLEAN) == 0 ||
+ (le16toh(es->e2fs_state) & E2FS_ERRORS)) {
if (ronly || (mp->mnt_flag & MNT_FORCE)) {
printf(
"WARNING: Filesystem was not properly dismounted\n");
@@ -939,10 +950,11 @@
* If the fs is not mounted read-only, make sure the super block is
* always written back on a sync().
*/
- fs->e2fs_wasvalid = fs->e2fs->e2fs_state & E2FS_ISCLEAN ? 1 : 0;
+ fs->e2fs_wasvalid = le16toh(fs->e2fs->e2fs_state) & E2FS_ISCLEAN ? 1 : 0;
if (ronly == 0) {
- fs->e2fs_fmod = 1; /* mark it modified */
- fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN; /* set fs invalid */
+ fs->e2fs_fmod = 1; /* mark it modified and set fs invalid */
+ fs->e2fs->e2fs_state =
+ htole16(le16toh(fs->e2fs->e2fs_state) & ~E2FS_ISCLEAN);
}
mp->mnt_data = ump;
mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
@@ -962,7 +974,7 @@
* ufs_bmap w/o changse!
*/
ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs);
- ump->um_bptrtodb = fs->e2fs->e2fs_log_bsize + 1;
+ ump->um_bptrtodb = le32toh(fs->e2fs->e2fs_log_bsize) + 1;
ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs);
if (ronly == 0)
ext2_sbupdate(ump, MNT_WAIT);
@@ -1018,7 +1030,8 @@
ronly = fs->e2fs_ronly;
if (ronly == 0 && ext2_cgupdate(ump, MNT_WAIT) == 0) {
if (fs->e2fs_wasvalid)
- fs->e2fs->e2fs_state |= E2FS_ISCLEAN;
+ fs->e2fs->e2fs_state =
+ htole16(le16toh(fs->e2fs->e2fs_state) | E2FS_ISCLEAN);
ext2_sbupdate(ump, MNT_WAIT);
}
@@ -1068,7 +1081,7 @@
ump = VFSTOEXT2(mp);
fs = ump->um_e2fs;
- if (fs->e2fs->e2fs_magic != E2FS_MAGIC)
+ if (le16toh(fs->e2fs->e2fs_magic) != E2FS_MAGIC)
panic("ext2_statfs");
/*
@@ -1078,10 +1091,10 @@
1 /* block bitmap */ +
1 /* inode bitmap */ +
fs->e2fs_itpg;
- overhead = fs->e2fs->e2fs_first_dblock +
+ overhead = le32toh(fs->e2fs->e2fs_first_dblock) +
fs->e2fs_gcount * overhead_per_group;
- if (fs->e2fs->e2fs_rev > E2FS_REV0 &&
- fs->e2fs->e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
+ if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&
+ le32toh(fs->e2fs->e2fs_features_rocompat) & EXT2F_ROCOMPAT_SPARSESUPER) {
for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) {
if (ext2_cg_has_sb(fs, i))
ngroups++;
@@ -1090,9 +1103,9 @@
ngroups = fs->e2fs_gcount;
}
ngdb = fs->e2fs_gdbcount;
- if (fs->e2fs->e2fs_rev > E2FS_REV0 &&
- fs->e2fs->e2fs_features_compat & EXT2F_COMPAT_RESIZE)
- ngdb += fs->e2fs->e2fs_reserved_ngdb;
+ if (le32toh(fs->e2fs->e2fs_rev) > E2FS_REV0 &&
+ le32toh(fs->e2fs->e2fs_features_compat) & EXT2F_COMPAT_RESIZE)
+ ngdb += le16toh(fs->e2fs->e2fs_reserved_ngdb);
overhead += ngroups * (1 /* superblock */ + ngdb);
sbp->f_bsize = EXT2_FRAG_SIZE(fs);
@@ -1100,8 +1113,8 @@
sbp->f_blocks = fs->e2fs_bcount - overhead;
sbp->f_bfree = fs->e2fs_fbcount;
sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount;
- sbp->f_files = fs->e2fs->e2fs_icount;
- sbp->f_ffree = fs->e2fs->e2fs_ficount;
+ sbp->f_files = le32toh(fs->e2fs->e2fs_icount);
+ sbp->f_ffree = fs->e2fs_ficount;
return (0);
}
@@ -1174,7 +1187,7 @@
*/
if (fs->e2fs_fmod != 0) {
fs->e2fs_fmod = 0;
- fs->e2fs->e2fs_wtime = time_second;
+ fs->e2fs->e2fs_wtime = htole32(time_second);
if ((error = ext2_cgupdate(ump, waitfor)) != 0)
allerror = error;
}
@@ -1317,7 +1330,7 @@
ufhp = (struct ufid *)fhp;
fs = VFSTOEXT2(mp)->um_e2fs;
if (ufhp->ufid_ino < EXT2_ROOTINO ||
- ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs->e2fs_ipg)
+ ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs_ipg)
return (ESTALE);
error = VFS_VGET(mp, ufhp->ufid_ino, LK_EXCLUSIVE, &nvp);
@@ -1348,14 +1361,16 @@
struct buf *bp;
int error = 0;
- es->e2fs_bcount = fs->e2fs_bcount & 0xffffffff;
- es->e2fs_rbcount = fs->e2fs_rbcount & 0xffffffff;
- es->e2fs_fbcount = fs->e2fs_fbcount & 0xffffffff;
+ es->e2fs_bcount = htole32(fs->e2fs_bcount & 0xffffffff);
+ es->e2fs_rbcount = htole32(fs->e2fs_rbcount & 0xffffffff);
+ es->e2fs_fbcount = htole32(fs->e2fs_fbcount & 0xffffffff);
if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
- es->e4fs_bcount_hi = fs->e2fs_bcount >> 32;
- es->e4fs_rbcount_hi = fs->e2fs_rbcount >> 32;
- es->e4fs_fbcount_hi = fs->e2fs_fbcount >> 32;
+ es->e4fs_bcount_hi = htole32(fs->e2fs_bcount >> 32);
+ es->e4fs_rbcount_hi = htole32(fs->e2fs_rbcount >> 32);
+ es->e4fs_fbcount_hi = htole32(fs->e2fs_fbcount >> 32);
}
+
+ es->e2fs_ficount = htole32(fs->e2fs_ficount);
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
ext2_sb_csum_set(fs);
Index: head/sys/fs/ext2fs/ext2_vnops.c
===================================================================
--- head/sys/fs/ext2fs/ext2_vnops.c
+++ head/sys/fs/ext2fs/ext2_vnops.c
@@ -209,12 +209,12 @@
* endianness problems.
*/
static struct dirtemplate mastertemplate = {
- 0, 12, 1, EXT2_FT_DIR, ".",
- 0, DIRBLKSIZ - 12, 2, EXT2_FT_DIR, ".."
+ 0, htole16(12), 1, EXT2_FT_DIR, ".",
+ 0, htole16(DIRBLKSIZ - 12), 2, EXT2_FT_DIR, ".."
};
static struct dirtemplate omastertemplate = {
- 0, 12, 1, EXT2_FT_UNKNOWN, ".",
- 0, DIRBLKSIZ - 12, 2, EXT2_FT_UNKNOWN, ".."
+ 0, htole16(12), 1, EXT2_FT_UNKNOWN, ".",
+ 0, htole16(DIRBLKSIZ - 12), 2, EXT2_FT_UNKNOWN, ".."
};
static void
@@ -1094,7 +1094,7 @@
ext2_dirbad(xp, (doff_t)12,
"rename: mangled dir");
} else {
- dirbuf->dotdot_ino = newparent;
+ dirbuf->dotdot_ino = htole32(newparent);
/*
* dirblock 0 could be htree root,
* try both csum update functions.
@@ -1380,15 +1380,15 @@
else
dtp = &omastertemplate;
dirtemplate = *dtp;
- dirtemplate.dot_ino = ip->i_number;
- dirtemplate.dotdot_ino = dp->i_number;
+ dirtemplate.dot_ino = htole32(ip->i_number);
+ dirtemplate.dotdot_ino = htole32(dp->i_number);
/*
* note that in ext2 DIRBLKSIZ == blocksize, not DEV_BSIZE so let's
* just redefine it - for this function only
*/
#undef DIRBLKSIZ
#define DIRBLKSIZ VTOI(dvp)->i_e2fs->e2fs_bsize
- dirtemplate.dotdot_reclen = DIRBLKSIZ - 12;
+ dirtemplate.dotdot_reclen = htole16(DIRBLKSIZ - 12);
buf = malloc(DIRBLKSIZ, M_TEMP, M_WAITOK | M_ZERO);
if (!buf) {
error = ENOMEM;
@@ -1397,7 +1397,9 @@
goto bad;
}
if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
- dirtemplate.dotdot_reclen -= sizeof(struct ext2fs_direct_tail);
+ dirtemplate.dotdot_reclen =
+ htole16(le16toh(dirtemplate.dotdot_reclen) -
+ sizeof(struct ext2fs_direct_tail));
ext2_init_dirent_tail(EXT2_DIRENT_TAIL(buf, DIRBLKSIZ));
}
memcpy(buf, &dirtemplate, sizeof(dirtemplate));
Index: head/sys/fs/ext2fs/ext2fs.h
===================================================================
--- head/sys/fs/ext2fs/ext2fs.h
+++ head/sys/fs/ext2fs/ext2fs.h
@@ -159,6 +159,7 @@
uint64_t e2fs_bcount; /* blocks count */
uint64_t e2fs_rbcount; /* reserved blocks count */
uint64_t e2fs_fbcount; /* free blocks count */
+ uint32_t e2fs_ficount; /* free inodes count */
uint32_t e2fs_bsize; /* Block size */
uint32_t e2fs_bshift; /* calc of logical block no */
uint32_t e2fs_bpg; /* Number of blocks per group */
@@ -344,11 +345,11 @@
* Feature set definitions
*/
#define EXT2_HAS_COMPAT_FEATURE(sb,mask) \
- ( EXT2_SB(sb)->e2fs->e2fs_features_compat & htole32(mask) )
+ ( le32toh(EXT2_SB(sb)->e2fs->e2fs_features_compat) & mask)
#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask) \
- ( EXT2_SB(sb)->e2fs->e2fs_features_rocompat & htole32(mask) )
+ ( le32toh(EXT2_SB(sb)->e2fs->e2fs_features_rocompat) & mask)
#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask) \
- ( EXT2_SB(sb)->e2fs->e2fs_features_incompat & htole32(mask) )
+ ( le32toh(EXT2_SB(sb)->e2fs->e2fs_features_incompat) & mask)
/*
* File clean flags
@@ -418,15 +419,14 @@
* Macro-instructions used to manage group descriptors
*/
#define EXT2_BLOCKS_PER_GROUP(s) (EXT2_SB(s)->e2fs_bpg)
-#define EXT2_DESCS_PER_BLOCK(s) (EXT2_HAS_INCOMPAT_FEATURE((s), \
- EXT2F_INCOMPAT_64BIT) ? ((s)->e2fs_bsize / sizeof(struct ext2_gd)) : \
- ((s)->e2fs_bsize / E2FS_REV0_GD_SIZE))
+#define EXT2_DESCS_PER_BLOCK(s) (EXT2_HAS_INCOMPAT_FEATURE((s), \
+ EXT2F_INCOMPAT_64BIT) ? ((s)->e2fs_bsize / sizeof(struct ext2_gd)) : \
+ ((s)->e2fs_bsize / E2FS_REV0_GD_SIZE))
/*
* Macro-instructions used to manage inodes
*/
-#define EXT2_FIRST_INO(s) ((EXT2_SB(s)->e2fs->e2fs_rev == E2FS_REV0) ? \
- EXT2_FIRSTINO : \
- EXT2_SB(s)->e2fs->e2fs_first_ino)
+#define EXT2_FIRST_INO(s) (le32toh((EXT2_SB(s)->e2fs->e2fs_rev) == \
+ E2FS_REV0) ? EXT2_FIRSTINO : le32toh(EXT2_SB(s)->e2fs->e2fs_first_ino))
#endif /* !_FS_EXT2FS_EXT2FS_H_ */
Index: head/sys/fs/ext2fs/fs.h
===================================================================
--- head/sys/fs/ext2fs/fs.h
+++ head/sys/fs/ext2fs/fs.h
@@ -108,8 +108,8 @@
/* get block containing inode from its number x */
#define ino_to_fsba(fs, x) \
- (e2fs_gd_get_i_tables(&(fs)->e2fs_gd[ino_to_cg((fs), (x))]) + \
- (((x) - 1) % (fs)->e2fs->e2fs_ipg) / (fs)->e2fs_ipb)
+ (e2fs_gd_get_i_tables(&(fs)->e2fs_gd[ino_to_cg((fs), (x))]) + \
+ (((x) - 1) % (fs)->e2fs_ipg) / (fs)->e2fs_ipb)
/* get offset for inode in block */
#define ino_to_fsbo(fs, x) ((x-1) % (fs->e2fs_ipb))
@@ -118,10 +118,10 @@
* 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->e2fs->e2fs_first_dblock) / \
- EXT2_BLOCKS_PER_GROUP(fs))
-#define dtogd(fs, d) (((d) - fs->e2fs->e2fs_first_dblock) % \
- EXT2_BLOCKS_PER_GROUP(fs))
+#define dtog(fs, d) (((d) - le32toh(fs->e2fs->e2fs_first_dblock)) / \
+ EXT2_BLOCKS_PER_GROUP(fs))
+#define dtogd(fs, d) (((d) - le32toh(fs->e2fs->e2fs_first_dblock)) % \
+ EXT2_BLOCKS_PER_GROUP(fs))
/*
* The following macros optimize certain frequently calculated
File Metadata
Details
Attached
Mime Type
text/plain
Expires
Thu, Oct 3, 4:28 AM (22 h, 3 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
13421653
Default Alt Text
D24685.diff (110 KB)
Attached To
Mode
D24685: ext2fs: initial support for byteswapping (was https://reviews.freebsd.org/D23259)
Attached
Detach File
Event Timeline
Log In to Comment