Etienne Brateau, le dim. 23 janv. 2022 05:17:06 +0100, a ecrit:
> In ext2 data are stored in little endian to ensure portability. So
> enforce little endian when manipulating these bytes.
Applied, thanks!
I have spotted and fixed a few missing bits, it's probably worth another
review round.
> ---
> ext2fs/balloc.c | 130 ++++++++++++++++++++++++---------------------
> ext2fs/dir.c | 61 ++++++++++-----------
> ext2fs/ext2_fs.h | 36 ++++++-------
> ext2fs/ext2fs.h | 7 +--
> ext2fs/getblk.c | 2 +-
> ext2fs/hyper.c | 42 +++++++--------
> ext2fs/ialloc.c | 73 +++++++++++++-------------
> ext2fs/inode.c | 134 ++++++++++++++++++++++++-----------------------
> ext2fs/xattr.c | 78 ++++++++++++++-------------
> 9 files changed, 292 insertions(+), 271 deletions(-)
>
> diff --git a/ext2fs/balloc.c b/ext2fs/balloc.c
> index 105aaa54..2cd21a0f 100644
> --- a/ext2fs/balloc.c
> +++ b/ext2fs/balloc.c
> @@ -65,8 +65,8 @@ ext2_free_blocks (block_t block, unsigned long count)
>
> pthread_spin_lock (&global_lock);
>
> - if (block < sblock->s_first_data_block ||
> - (block + count) > sblock->s_blocks_count)
> + if (block < le32toh (sblock->s_first_data_block) ||
> + (block + count) > le32toh (sblock->s_blocks_count))
> {
> ext2_error ("freeing blocks not in datazone - "
> "block = %u, count = %lu", block, count);
> @@ -80,29 +80,30 @@ ext2_free_blocks (block_t block, unsigned long count)
> {
> unsigned long int gcount = count;
>
> - block_group = ((block - sblock->s_first_data_block)
> - / sblock->s_blocks_per_group);
> - bit = (block - sblock->s_first_data_block) %
> sblock->s_blocks_per_group;
> + block_group = ((block - le32toh (sblock->s_first_data_block)) /
> + le32toh (sblock->s_blocks_per_group));
> + bit = (block - le32toh (sblock->s_first_data_block)) %
> + le32toh (sblock->s_blocks_per_group);
>
> /*
> * Check to see if we are freeing blocks accross a group
> * boundary
> */
> - if (bit + count > sblock->s_blocks_per_group)
> + if (bit + count > le32toh (sblock->s_blocks_per_group))
> {
> - unsigned long overflow = bit + count - sblock->s_blocks_per_group;
> + unsigned long overflow = bit + count - le32toh
> (sblock->s_blocks_per_group);
> gcount -= overflow;
> ext2_debug ("freeing blocks across group boundary - "
> "block = %u, count = %lu",
> block, count);
> }
> gdp = group_desc (block_group);
> - bh = disk_cache_block_ref (gdp->bg_block_bitmap);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_block_bitmap));
>
> - if (in_range (gdp->bg_block_bitmap, block, gcount) ||
> - in_range (gdp->bg_inode_bitmap, block, gcount) ||
> - in_range (block, gdp->bg_inode_table, itb_per_group) ||
> - in_range (block + gcount - 1, gdp->bg_inode_table, itb_per_group))
> + if (in_range (le32toh (gdp->bg_block_bitmap), block, gcount) ||
> + in_range (le32toh (gdp->bg_inode_bitmap), block, gcount) ||
> + in_range (block, le32toh (gdp->bg_inode_table), itb_per_group) ||
> + in_range (block + gcount - 1, le32toh (gdp->bg_inode_table),
> itb_per_group))
> ext2_panic ("freeing blocks in system zones - "
> "block = %u, count = %lu",
> block, count);
> @@ -113,8 +114,10 @@ ext2_free_blocks (block_t block, unsigned long count)
> ext2_warning ("bit already cleared for block %lu", block + i);
> else
> {
> - gdp->bg_free_blocks_count++;
> - sblock->s_free_blocks_count++;
> + gdp->bg_free_blocks_count =
> + htole16 (le16toh (gdp->bg_free_blocks_count) + 1);
> + sblock->s_free_blocks_count =
> + htole32 (le32toh (sblock->s_free_blocks_count) + 1);
> }
> }
>
> @@ -159,7 +162,7 @@ ext2_new_block (block_t goal,
> pthread_spin_lock (&global_lock);
>
> #ifdef XXX /* Auth check to use reserved blocks */
> - if (sblock->s_free_blocks_count <= sblock->s_r_blocks_count &&
> + if (le32toh (sblock->s_free_blocks_count) <= le32toh
> (sblock->s_r_blocks_count) &&
> (!fsuser () && (sb->u.ext2_sb.s_resuid != current->fsuid) &&
> (sb->u.ext2_sb.s_resgid == 0 ||
> !in_group_p (sb->u.ext2_sb.s_resgid))))
> @@ -176,18 +179,21 @@ repeat:
> /*
> * First, test whether the goal block is free.
> */
> - if (goal < sblock->s_first_data_block || goal >= sblock->s_blocks_count)
> - goal = sblock->s_first_data_block;
> - i = (goal - sblock->s_first_data_block) / sblock->s_blocks_per_group;
> + if (goal < le32toh (sblock->s_first_data_block)
> + || goal >= le32toh (sblock->s_blocks_count))
> + goal = le32toh (sblock->s_first_data_block);
> + i = (goal - le32toh (sblock->s_first_data_block)) /
> + le32toh (sblock->s_blocks_per_group);
> gdp = group_desc (i);
> - if (gdp->bg_free_blocks_count > 0)
> + if (le16toh (gdp->bg_free_blocks_count) > 0)
> {
> - j = ((goal - sblock->s_first_data_block) % sblock->s_blocks_per_group);
> + j = ((goal - le32toh (sblock->s_first_data_block))
> + % le32toh (sblock->s_blocks_per_group));
> #ifdef EXT2FS_DEBUG
> if (j)
> goal_attempts++;
> #endif
> - bh = disk_cache_block_ref (gdp->bg_block_bitmap);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_block_bitmap));
>
> ext2_debug ("goal is at %d:%d", i, j);
>
> @@ -211,7 +217,7 @@ repeat:
> lmap = ((((unsigned long *) bh)[j >> 5]) >>
> ((j & 31) + 1));
>
> - if (j < sblock->s_blocks_per_group - 32)
> + if (j < le32toh (sblock->s_blocks_per_group) - 32)
> lmap |= (((unsigned long *) bh)[(j >> 5) + 1]) <<
> (31 - (j & 31));
> else
> @@ -220,7 +226,7 @@ repeat:
> if (lmap != 0xffffffffl)
> {
> k = ffz (lmap) + 1;
> - if ((j + k) < sblock->s_blocks_per_group)
> + if ((j + k) < le32toh (sblock->s_blocks_per_group))
> {
> j += k;
> goto got_block;
> @@ -240,17 +246,17 @@ repeat:
> * cyclicly search through the rest of the groups.
> */
> p = bh + (j >> 3);
> - r = memscan (p, 0, (sblock->s_blocks_per_group - j + 7) >> 3);
> + r = memscan (p, 0, (le32toh (sblock->s_blocks_per_group) - j + 7) >>
> 3);
> k = (r - bh) << 3;
> - if (k < sblock->s_blocks_per_group)
> + if (k < le32toh (sblock->s_blocks_per_group))
> {
> j = k;
> goto search_back;
> }
> k = find_next_zero_bit ((unsigned long *) bh,
> - sblock->s_blocks_per_group,
> + le32toh (sblock->s_blocks_per_group),
> j);
> - if (k < sblock->s_blocks_per_group)
> + if (k < le32toh (sblock->s_blocks_per_group))
> {
> j = k;
> goto got_block;
> @@ -272,7 +278,7 @@ repeat:
> if (i >= groups_count)
> i = 0;
> gdp = group_desc (i);
> - if (gdp->bg_free_blocks_count > 0)
> + if (le16toh (gdp->bg_free_blocks_count) > 0)
> break;
> }
> if (k >= groups_count)
> @@ -281,15 +287,15 @@ repeat:
> return 0;
> }
> assert_backtrace (bh == NULL);
> - bh = disk_cache_block_ref (gdp->bg_block_bitmap);
> - r = memscan (bh, 0, sblock->s_blocks_per_group >> 3);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_block_bitmap));
> + r = memscan (bh, 0, le32toh (sblock->s_blocks_per_group) >> 3);
> j = (r - bh) << 3;
> - if (j < sblock->s_blocks_per_group)
> + if (j < le32toh (sblock->s_blocks_per_group))
> goto search_back;
> else
> j = find_first_zero_bit ((unsigned long *) bh,
> - sblock->s_blocks_per_group);
> - if (j >= sblock->s_blocks_per_group)
> + le32toh (sblock->s_blocks_per_group));
> + if (j >= le32toh (sblock->s_blocks_per_group))
> {
> disk_cache_block_deref (bh);
> bh = NULL;
> @@ -310,13 +316,14 @@ search_back:
> got_block:
> assert_backtrace (bh != NULL);
>
> - ext2_debug ("using block group %d (%d)", i, gdp->bg_free_blocks_count);
> + ext2_debug ("using block group %d (%d)", i, le16toh
> (gdp->bg_free_blocks_count));
>
> - tmp = j + i * sblock->s_blocks_per_group + sblock->s_first_data_block;
> + tmp = j + i * le32toh (sblock->s_blocks_per_group) +
> + le32toh (sblock->s_first_data_block);
>
> - if (tmp == gdp->bg_block_bitmap ||
> - tmp == gdp->bg_inode_bitmap ||
> - in_range (tmp, gdp->bg_inode_table, itb_per_group))
> + if (tmp == le32toh (gdp->bg_block_bitmap) ||
> + tmp == le32toh (gdp->bg_inode_bitmap) ||
> + in_range (tmp, le32toh (gdp->bg_inode_table), itb_per_group))
> ext2_panic ("allocating block in system zone; block = %u", tmp);
>
> if (set_bit (j, bh))
> @@ -348,7 +355,7 @@ got_block:
> *prealloc_count = 0;
> *prealloc_block = tmp + 1;
> for (k = 1;
> - k < prealloc_goal && (j + k) < sblock->s_blocks_per_group; k++)
> + k < prealloc_goal && (j + k) < le32toh
> (sblock->s_blocks_per_group); k++)
> {
> if (set_bit (j + k, bh))
> break;
> @@ -362,8 +369,10 @@ got_block:
> pthread_spin_unlock (&modified_global_blocks_lock);
> }
> }
> - gdp->bg_free_blocks_count -= *prealloc_count;
> - sblock->s_free_blocks_count -= *prealloc_count;
> + gdp->bg_free_blocks_count = htole16 (le16toh
> (gdp->bg_free_blocks_count) -
> + *prealloc_count);
> + sblock->s_free_blocks_count = htole32 (le32toh
> (sblock->s_free_blocks_count) -
> + *prealloc_count);
> ext2_debug ("preallocated a further %u bits", *prealloc_count);
> }
> #endif
> @@ -373,7 +382,7 @@ got_block:
> record_global_poke (bh);
> bh = NULL;
>
> - if (j >= sblock->s_blocks_count)
> + if (j >= le32toh (sblock->s_blocks_count))
> {
> ext2_error ("block >= blocks count - block_group = %d, block=%d", i,
> j);
> j = 0;
> @@ -383,11 +392,11 @@ got_block:
> ext2_debug ("allocating block %d; goal hits %d of %d",
> j, goal_hits, goal_attempts);
>
> - gdp->bg_free_blocks_count--;
> + gdp->bg_free_blocks_count = htole16 (le16toh (gdp->bg_free_blocks_count) -
> 1);
> disk_cache_block_ref_ptr (gdp);
> record_global_poke (gdp);
>
> - sblock->s_free_blocks_count--;
> + sblock->s_free_blocks_count = htole32 (le32toh
> (sblock->s_free_blocks_count) - 1);
> sblock_dirty = 1;
>
> sync_out:
> @@ -415,28 +424,29 @@ ext2_count_free_blocks ()
> {
> void *bh;
> gdp = group_desc (i);
> - desc_count += gdp->bg_free_blocks_count;
> - bh = disk_cache_block_ref (gdp->bg_block_bitmap);
> + desc_count += le16toh (gdp->bg_free_blocks_count);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_block_bitmap));
> x = count_free (bh, block_size);
> disk_cache_block_deref (bh);
> printf ("group %d: stored = %d, counted = %lu",
> - i, gdp->bg_free_blocks_count, x);
> + i, le16toh (gdp->bg_free_blocks_count), x);
> bitmap_count += x;
> }
> printf ("ext2_count_free_blocks: stored = %u, computed = %lu, %lu",
> - sblock->s_free_blocks_count, desc_count, bitmap_count);
> + le32toh (sblock->s_free_blocks_count),
> + desc_count, bitmap_count);
> pthread_spin_unlock (&global_lock);
> return bitmap_count;
> #else
> - return sblock->s_free_blocks_count;
> + return le32toh (sblock->s_free_blocks_count);
> #endif
> }
>
> static inline int
> block_in_use (block_t block, unsigned char *map)
> {
> - return test_bit ((block - sblock->s_first_data_block) %
> - sblock->s_blocks_per_group, map);
> + return test_bit ((block - le32toh (sblock->s_first_data_block)) %
> + le32toh (sblock->s_blocks_per_group), map);
> }
>
> void
> @@ -478,8 +488,8 @@ ext2_check_blocks_bitmap ()
> }
>
> gdp = group_desc (i);
> - desc_count += gdp->bg_free_blocks_count;
> - bh = disk_cache_block_ref (gdp->bg_block_bitmap);
> + desc_count += le16toh (gdp->bg_free_blocks_count);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_block_bitmap));
>
> if (!EXT2_HAS_RO_COMPAT_FEATURE (sblock,
> EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)
> @@ -494,27 +504,27 @@ ext2_check_blocks_bitmap ()
> j, i);
> }
>
> - if (!block_in_use (gdp->bg_block_bitmap, bh))
> + if (!block_in_use (le32toh (gdp->bg_block_bitmap), bh))
> ext2_error ("block bitmap for group %d is marked free", i);
>
> - if (!block_in_use (gdp->bg_inode_bitmap, bh))
> + if (!block_in_use (le32toh (gdp->bg_inode_bitmap), bh))
> ext2_error ("inode bitmap for group %d is marked free", i);
>
> for (j = 0; j < itb_per_group; j++)
> - if (!block_in_use (gdp->bg_inode_table + j, bh))
> + if (!block_in_use (le32toh (gdp->bg_inode_table) + j, bh))
> ext2_error ("block #%d of the inode table in group %d is marked
> free", j, i);
>
> x = count_free (bh, block_size);
> disk_cache_block_deref (bh);
> - if (gdp->bg_free_blocks_count != x)
> + if (le16toh (gdp->bg_free_blocks_count) != x)
> ext2_error ("wrong free blocks count for group %d,"
> " stored = %d, counted = %lu",
> - i, gdp->bg_free_blocks_count, x);
> + i, le16toh (gdp->bg_free_blocks_count), x);
> bitmap_count += x;
> }
> - if (sblock->s_free_blocks_count != bitmap_count)
> + if (le32toh (sblock->s_free_blocks_count) != bitmap_count)
> ext2_error ("wrong free blocks count in super block,"
> " stored = %lu, counted = %lu",
> - (unsigned long) sblock->s_free_blocks_count, bitmap_count);
> + (unsigned long) le32toh (sblock->s_free_blocks_count),
> bitmap_count);
> pthread_spin_unlock (&global_lock);
> }
> diff --git a/ext2fs/dir.c b/ext2fs/dir.c
> index 7ba08a2e..85d131c3 100644
> --- a/ext2fs/dir.c
> +++ b/ext2fs/dir.c
> @@ -404,15 +404,15 @@ dirscanblock (vm_address_t blockaddr, struct node *dp,
> int idx,
>
> for (currentoff = blockaddr, prevoff = 0;
> currentoff < blockaddr + DIRBLKSIZ;
> - prevoff = currentoff, currentoff += entry->rec_len)
> + prevoff = currentoff, currentoff += le16toh (entry->rec_len))
> {
> entry = (struct ext2_dir_entry_2 *)currentoff;
>
> if (!entry->rec_len
> - || entry->rec_len % EXT2_DIR_PAD
> + || le16toh (entry->rec_len) % EXT2_DIR_PAD
> || entry->name_len > EXT2_NAME_LEN
> - || currentoff + entry->rec_len > blockaddr + DIRBLKSIZ
> - || EXT2_DIR_REC_LEN (entry->name_len) > entry->rec_len
> + || currentoff + le16toh (entry->rec_len) > blockaddr + DIRBLKSIZ
> + || EXT2_DIR_REC_LEN (entry->name_len) > le16toh (entry->rec_len)
> || memchr (entry->name, '\0', entry->name_len))
> {
> ext2_warning ("bad directory entry: inode: %Ld offset: %lu",
> @@ -427,9 +427,9 @@ dirscanblock (vm_address_t blockaddr, struct node *dp,
> int idx,
>
> /* Count how much free space this entry has in it. */
> if (entry->inode == 0)
> - thisfree = entry->rec_len;
> + thisfree = le16toh (entry->rec_len);
> else
> - thisfree = entry->rec_len - EXT2_DIR_REC_LEN (entry->name_len);
> + thisfree = le16toh (entry->rec_len) - EXT2_DIR_REC_LEN
> (entry->name_len);
>
> /* If this isn't at the front of the block, then it will
> have to be copied if we do a compression; count the
> @@ -514,7 +514,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp,
> int idx,
> ds->preventry = (struct ext2_dir_entry_2 *) prevoff;
> }
>
> - *inum = entry->inode;
> + *inum = le32toh (entry->inode);
> return 0;
> }
>
> @@ -551,7 +551,8 @@ diskfs_direnter_hard (struct node *dp, const char *name,
> struct node *np,
> {
> case TAKE:
> /* We are supposed to consume this slot. */
> - assert_backtrace (ds->entry->inode == 0 && ds->entry->rec_len >=
> needed);
> + assert_backtrace (le32toh (ds->entry->inode) == 0
> + && le16toh (ds->entry->rec_len) >= needed);
>
> new = ds->entry;
> break;
> @@ -560,12 +561,12 @@ diskfs_direnter_hard (struct node *dp, const char
> *name, struct node *np,
> /* We are supposed to take the extra space at the end
> of this slot. */
> oldneeded = EXT2_DIR_REC_LEN (ds->entry->name_len);
> - assert_backtrace (ds->entry->rec_len - oldneeded >= needed);
> + assert_backtrace (le16toh (ds->entry->rec_len) - oldneeded >= needed);
>
> new = (struct ext2_dir_entry_2 *) ((vm_address_t) ds->entry +
> oldneeded);
>
> - new->rec_len = ds->entry->rec_len - oldneeded;
> - ds->entry->rec_len = oldneeded;
> + new->rec_len = htole16 (le16toh (ds->entry->rec_len) - oldneeded);
> + ds->entry->rec_len = htole16 (oldneeded);
> break;
>
> case COMPRESS:
> @@ -579,16 +580,16 @@ diskfs_direnter_hard (struct node *dp, const char
> *name, struct node *np,
> {
> struct ext2_dir_entry_2 *from = (struct ext2_dir_entry_2 *)fromoff;
> struct ext2_dir_entry_2 *to = (struct ext2_dir_entry_2 *) tooff;
> - size_t fromreclen = from->rec_len;
> + size_t fromreclen = le16toh (from->rec_len);
>
> - if (from->inode != 0)
> + if (le32toh (from->inode) != 0)
> {
> assert_backtrace (fromoff >= tooff);
>
> memmove (to, from, fromreclen);
> to->rec_len = EXT2_DIR_REC_LEN (to->name_len);
>
> - tooff += to->rec_len;
> + tooff += le16toh (to->rec_len);
> }
> fromoff += fromreclen;
> }
> @@ -597,7 +598,7 @@ diskfs_direnter_hard (struct node *dp, const char *name,
> struct node *np,
> assert_backtrace (totfreed >= needed);
>
> new = (struct ext2_dir_entry_2 *) tooff;
> - new->rec_len = totfreed;
> + new->rec_len = htole16 (totfreed);
> break;
>
> case EXTEND:
> @@ -634,7 +635,7 @@ diskfs_direnter_hard (struct node *dp, const char *name,
> struct node *np,
> dp->dn_stat.st_size = oldsize + DIRBLKSIZ;
> dp->dn_set_ctime = 1;
>
> - new->rec_len = DIRBLKSIZ;
> + new->rec_len = htole16 (DIRBLKSIZ);
> break;
>
> default:
> @@ -645,7 +646,7 @@ diskfs_direnter_hard (struct node *dp, const char *name,
> struct node *np,
> /* NEW points to the directory entry being written, and its
> rec_len field is already filled in. Now fill in the rest. */
>
> - new->inode = np->cache_id;
> + new->inode = htole32 (np->cache_id);
> #if 0
> /* XXX We cannot enable this code because file types can change
> (and conceivably quite often) with translator settings.
> @@ -726,8 +727,8 @@ diskfs_dirremove_hard (struct node *dp, struct dirstat
> *ds)
> else
> {
> assert_backtrace ((vm_address_t) ds->entry - (vm_address_t)
> ds->preventry
> - == ds->preventry->rec_len);
> - ds->preventry->rec_len += ds->entry->rec_len;
> + == le16toh (ds->preventry->rec_len));
> + ds->preventry->rec_len = htole16( le16toh (ds->preventry->rec_len) +
> ds->entry->rec_len);
> }
>
> dp->dn_set_mtime = 1;
> @@ -761,7 +762,7 @@ diskfs_dirrewrite_hard (struct node *dp, struct node *np,
> struct dirstat *ds)
>
> assert_backtrace (!diskfs_readonly);
>
> - ds->entry->inode = np->cache_id;
> + ds->entry->inode = htole32 (np->cache_id);
> dp->dn_set_mtime = 1;
> diskfs_node_disknode (dp)->info.i_flags &= ~EXT2_BTREE_FL;
>
> @@ -796,11 +797,11 @@ diskfs_dirempty (struct node *dp, struct protid *cred)
>
> for (curoff = buf;
> !hit && curoff < buf + dp->dn_stat.st_size;
> - curoff += entry->rec_len)
> + curoff += le16toh (entry->rec_len))
> {
> entry = (struct ext2_dir_entry_2 *) curoff;
>
> - if (entry->inode != 0
> + if (le32toh (entry->inode) != 0
> && (entry->name_len > 2
> || entry->name[0] != '.'
> || (entry->name[1] != '.'
> @@ -853,10 +854,10 @@ count_dirents (struct node *dp, block_t nb, char *buf)
>
> for (offinblk = buf;
> offinblk < buf + DIRBLKSIZ;
> - offinblk += entry->rec_len)
> + offinblk += le16toh (entry->rec_len))
> {
> entry = (struct ext2_dir_entry_2 *) offinblk;
> - if (entry->inode)
> + if (le32toh (entry->inode))
> count++;
> }
>
> @@ -982,7 +983,7 @@ diskfs_get_directs (struct node *dp,
> }
> for (i = 0, bufp = buf;
> i < entry - curentry && bufp - buf < DIRBLKSIZ;
> - bufp += ((struct ext2_dir_entry_2 *)bufp)->rec_len, i++)
> + bufp += le16toh (((struct ext2_dir_entry_2 *)bufp)->rec_len), i++)
> ;
> /* Make sure we didn't run off the end. */
> assert_backtrace (bufp - buf < DIRBLKSIZ);
> @@ -1009,7 +1010,7 @@ diskfs_get_directs (struct node *dp,
>
> entryp = (struct ext2_dir_entry_2 *)bufp;
>
> - if (entryp->inode)
> + if (le32toh (entryp->inode))
> {
> int rec_len;
> int name_len = entryp->name_len;
> @@ -1033,7 +1034,7 @@ diskfs_get_directs (struct node *dp,
> if (datap + rec_len > *data + allocsize)
> break;
>
> - userp->d_fileno = entryp->inode;
> + userp->d_fileno = le32toh (entryp->inode);
> userp->d_reclen = rec_len;
> userp->d_namlen = name_len;
>
> @@ -1066,7 +1067,7 @@ diskfs_get_directs (struct node *dp,
> i++;
> }
>
> - if (entryp->rec_len == 0)
> + if (le16toh (entryp->rec_len) == 0)
> {
> ext2_warning ("zero length directory entry: inode: %Ld offset:
> %zd",
> dp->cache_id,
> @@ -1074,7 +1075,7 @@ diskfs_get_directs (struct node *dp,
> return EIO;
> }
>
> - bufp += entryp->rec_len;
> + bufp += le16toh (entryp->rec_len);
> if (bufp - buf == DIRBLKSIZ)
> {
> blkno++;
> @@ -1084,7 +1085,7 @@ diskfs_get_directs (struct node *dp,
> {
> ext2_warning ("directory entry too long: inode: %Ld offset: %zd",
> dp->cache_id,
> - blkno * DIRBLKSIZ + bufp - buf - entryp->rec_len);
> + blkno * DIRBLKSIZ + bufp - buf - le16toh (entryp->rec_len));
> return EIO;
> }
> }
> diff --git a/ext2fs/ext2_fs.h b/ext2fs/ext2_fs.h
> index d838172a..83eec66b 100644
> --- a/ext2fs/ext2_fs.h
> +++ b/ext2fs/ext2_fs.h
> @@ -65,12 +65,12 @@
> #define EXT2_ACLE_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (struct
> ext2_acl_entry))
> #define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (__u32))
> #define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
> -#define EXT2_INODE_SIZE(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
> - EXT2_GOOD_OLD_INODE_SIZE : \
> - (s)->s_inode_size)
> -#define EXT2_FIRST_INO(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
> - EXT2_GOOD_OLD_FIRST_INO : \
> - (s)->s_first_ino)
> +#define EXT2_INODE_SIZE(s) (((s)->s_rev_level ==
> htole32(EXT2_GOOD_OLD_REV)) ? \
> + le32toh (EXT2_GOOD_OLD_INODE_SIZE) : \
> + le32toh ((s)->s_inode_size))
> +#define EXT2_FIRST_INO(s) (((s)->s_rev_level ==
> htole32(EXT2_GOOD_OLD_REV)) ? \
> + le32toh (EXT2_GOOD_OLD_FIRST_INO) : \
> + (le32toh ((s)->s_first_ino)))
>
> /*
> * Macro-instructions used to manage fragments
> @@ -78,7 +78,7 @@
> #define EXT2_MIN_FRAG_SIZE 1024
> #define EXT2_MAX_FRAG_SIZE 4096
> #define EXT2_MIN_FRAG_LOG_SIZE 10
> -#define EXT2_FRAG_SIZE(s) (EXT2_MIN_FRAG_SIZE <<
> (s)->s_log_frag_size)
> +#define EXT2_FRAG_SIZE(s) (EXT2_MIN_FRAG_SIZE <<
> le32toh((s)->s_log_frag_size))
> #define EXT2_FRAGS_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) /
> EXT2_FRAG_SIZE(s))
>
> /*
> @@ -121,9 +121,9 @@ struct ext2_group_desc
> /*
> * Macro-instructions used to manage group descriptors
> */
> -#define EXT2_BLOCKS_PER_GROUP(s)
> ((s)->s_blocks_per_group)
> +#define EXT2_BLOCKS_PER_GROUP(s) (le32toh
> ((s)->s_blocks_per_group))
> #define EXT2_DESC_PER_BLOCK(s)
> (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group
> -#define EXT2_INODES_PER_GROUP(s) ((s)->s_inodes_per_group
> +#define EXT2_INODES_PER_GROUP(s) (le32toh
> ((s)->s_inodes_per_group))
>
> /*
> * Constants relative to the data blocks
> @@ -417,23 +417,23 @@ struct ext2_super_block {
> */
>
> #define EXT2_HAS_COMPAT_FEATURE(sb,mask) \
> - ( (sb)->s_feature_compat & (mask) )
> + ( (sb)->s_feature_compat & htole32 (mask) )
> #define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask) \
> - ( (sb)->s_feature_ro_compat & (mask) )
> + ( (sb)->s_feature_ro_compat & htole32 (mask) )
> #define EXT2_HAS_INCOMPAT_FEATURE(sb,mask) \
> - ( (sb)->s_feature_incompat & (mask) )
> + ( (sb)->s_feature_incompat & htole32 (mask) )
> #define EXT2_SET_COMPAT_FEATURE(sb,mask) \
> - (sb)->s_feature_compat |= (mask)
> + (sb)->s_feature_compat |= htole32 (mask)
> #define EXT2_SET_RO_COMPAT_FEATURE(sb,mask) \
> - (sb)->s_feature_ro_compat |= (mask)
> + (sb)->s_feature_ro_compat |= htole32 (mask)
> #define EXT2_SET_INCOMPAT_FEATURE(sb,mask) \
> - (sb)->s_feature_incompat |= (mask)
> + (sb)->s_feature_incompat |= htole32 (mask)
> #define EXT2_CLEAR_COMPAT_FEATURE(sb,mask) \
> - (sb)->s_feature_compat &= ~(mask)
> + (sb)->s_feature_compat &= ~htole32 (mask)
> #define EXT2_CLEAR_RO_COMPAT_FEATURE(sb,mask) \
> - (sb)->s_feature_ro_compat &= ~(mask)
> + (sb)->s_feature_ro_compat &= ~htole32 (mask)
> #define EXT2_CLEAR_INCOMPAT_FEATURE(sb,mask) \
> - (sb)->s_feature_incompat &= ~(mask)
> + (sb)->s_feature_incompat &= ~htole32 (mask)
>
> #define EXT2_FEATURE_COMPAT_DIR_PREALLOC 0x0001
> #define EXT2_FEATURE_COMPAT_IMAGIC_INODES 0x0002
> diff --git a/ext2fs/ext2fs.h b/ext2fs/ext2fs.h
> index f8e3ba45..ac45693b 100644
> --- a/ext2fs/ext2fs.h
> +++ b/ext2fs/ext2fs.h
> @@ -32,6 +32,7 @@
> #include <assert-backtrace.h>
> #include <pthread.h>
> #include <sys/mman.h>
> +#include <endian.h>
>
> /* Types used by the ext2 header files. */
> typedef u_int32_t __u32;
> @@ -290,7 +291,7 @@ extern unsigned int block_size;
> extern unsigned int log2_block_size;
>
> /* The number of bits to scale min-blocks to get filesystem blocks. */
> -#define BLOCKSIZE_SCALE (sblock->s_log_block_size)
> +#define BLOCKSIZE_SCALE (le32toh (sblock->s_log_block_size))
>
> /* log2 of the number of device blocks in a filesystem block. */
> extern unsigned log2_dev_blocks_per_fs_block;
> @@ -401,7 +402,7 @@ bptr_offs (void *ptr)
> #define group_desc(num) (&group_desc_image[num])
> extern struct ext2_group_desc *group_desc_image;
>
> -#define inode_group_num(inum) (((inum) - 1) / sblock->s_inodes_per_group)
> +#define inode_group_num(inum) (((inum) - 1) / le32toh
> (sblock->s_inodes_per_group))
>
> /* Forward declarations for the following functions that are usually
> inlined. In case inlining is disabled, or inlining is not
> @@ -415,7 +416,7 @@ extern void _dino_deref (struct ext2_inode *inode);
> EXT2FS_EI struct ext2_inode *
> dino_ref (ino_t inum)
> {
> - unsigned long inodes_per_group = sblock->s_inodes_per_group;
> + unsigned long inodes_per_group = le32toh (sblock->s_inodes_per_group);
> unsigned long bg_num = (inum - 1) / inodes_per_group;
> unsigned long group_inum = (inum - 1) % inodes_per_group;
> struct ext2_group_desc *bg = group_desc (bg_num);
> diff --git a/ext2fs/getblk.c b/ext2fs/getblk.c
> index 10a34f8d..d33e1c53 100644
> --- a/ext2fs/getblk.c
> +++ b/ext2fs/getblk.c
> @@ -152,7 +152,7 @@ inode_getblk (struct node *node, int nr, int create, int
> zero,
> goal =
> (diskfs_node_disknode (node)->info.i_block_group
> * EXT2_BLOCKS_PER_GROUP (sblock))
> - + sblock->s_first_data_block;
> + + le32toh (sblock->s_first_data_block);
> }
>
> *result = ext2_alloc_block (node, goal, zero);
> diff --git a/ext2fs/hyper.c b/ext2fs/hyper.c
> index 6fc95eaf..1bb74e53 100644
> --- a/ext2fs/hyper.c
> +++ b/ext2fs/hyper.c
> @@ -42,7 +42,7 @@ allocate_mod_map (void)
> global blocks are actually modified so the pager can write only them.
> */
> {
> /* One bit per filesystem block. */
> - mod_map_size = sblock->s_blocks_count >> 3;
> + mod_map_size = le32toh (sblock->s_blocks_count) >> 3;
> modified_global_blocks = mmap (0, mod_map_size, PROT_READ|PROT_WRITE,
> MAP_ANON, 0, 0);
> assert_backtrace (modified_global_blocks != (void *) -1);
> @@ -70,15 +70,15 @@ get_hypermetadata (void)
> if (err || read != SBLOCK_SIZE)
> ext2_panic ("Cannot read hypermetadata");
>
> - if (sblock->s_magic != EXT2_SUPER_MAGIC
> + if (sblock->s_magic != htole16 (EXT2_SUPER_MAGIC)
> #ifdef EXT2FS_PRE_02B_COMPAT
> - && sblock->s_magic != EXT2_PRE_02B_MAGIC
> + && sblock->s_magic != htole16 (EXT2_PRE_02B_MAGIC)
> #endif
> )
> ext2_panic ("bad magic number %#x (should be %#x)",
> - sblock->s_magic, EXT2_SUPER_MAGIC);
> + le16toh (sblock->s_magic), EXT2_SUPER_MAGIC);
>
> - log2_block_size = EXT2_MIN_BLOCK_LOG_SIZE + sblock->s_log_block_size;
> + log2_block_size = EXT2_MIN_BLOCK_LOG_SIZE +
> le32toh(sblock->s_log_block_size);
> block_size = 1 << log2_block_size;
>
> if (block_size > EXT2_MAX_BLOCK_SIZE)
> @@ -98,10 +98,10 @@ get_hypermetadata (void)
> ext2_panic ("block size %d isn't a power-of-two multiple of 512!",
> block_size);
>
> - if ((store->size >> log2_block_size) < sblock->s_blocks_count)
> + if ((store->size >> log2_block_size) < le32toh (sblock->s_blocks_count))
> ext2_panic ("disk size (%qd bytes) too small; superblock says we need
> %qd",
> (long long int) store->size,
> - (long long int) sblock->s_blocks_count << log2_block_size);
> + (long long int) le32toh (sblock->s_blocks_count) <<
> log2_block_size);
> if (log2_dev_blocks_per_fs_block != 0
> && (store->size & ((1 << log2_dev_blocks_per_fs_block) - 1)) != 0)
> ext2_warning ("%Ld (%zd byte) device blocks "
> @@ -112,12 +112,12 @@ get_hypermetadata (void)
> /* Set these handy variables. */
> inodes_per_block = block_size / EXT2_INODE_SIZE (sblock);
>
> - frag_size = EXT2_MIN_FRAG_SIZE << sblock->s_log_frag_size;
> + frag_size = EXT2_MIN_FRAG_SIZE << le32toh (sblock->s_log_frag_size);
> if (frag_size == 0)
> ext2_panic ("frag size is zero!");
> frags_per_block = block_size / frag_size;
>
> - if (sblock->s_rev_level > EXT2_GOOD_OLD_REV)
> + if (sblock->s_rev_level > htole32 (EXT2_GOOD_OLD_REV))
> {
> features = EXT2_HAS_INCOMPAT_FEATURE(sblock,
> EXT2_FEATURE_INCOMPAT_UNSUPPORTED);
> if (features)
> @@ -132,21 +132,21 @@ get_hypermetadata (void)
> features);
> diskfs_readonly = 1;
> }
> - if (sblock->s_inode_size != EXT2_GOOD_OLD_INODE_SIZE)
> - ext2_panic ("inode size %d isn't supported", sblock->s_inode_size);
> + if (le16toh (sblock->s_inode_size) != EXT2_GOOD_OLD_INODE_SIZE)
> + ext2_panic ("inode size %d isn't supported", le16toh
> (sblock->s_inode_size));
> }
>
> groups_count =
> - ((sblock->s_blocks_count - sblock->s_first_data_block +
> - sblock->s_blocks_per_group - 1)
> - / sblock->s_blocks_per_group);
> + ((le32toh (sblock->s_blocks_count) - le32toh
> (sblock->s_first_data_block) +
> + le32toh (sblock->s_blocks_per_group) - 1)
> + / le32toh (sblock->s_blocks_per_group));
>
> - itb_per_group = sblock->s_inodes_per_group / inodes_per_block;
> + itb_per_group = le32toh (sblock->s_inodes_per_group) / inodes_per_block;
> desc_per_block = block_size / sizeof (struct ext2_group_desc);
> addr_per_block = block_size / sizeof (block_t);
> db_per_group = (groups_count + desc_per_block - 1) / desc_per_block;
>
> - ext2fs_clean = sblock->s_state & EXT2_VALID_FS;
> + ext2fs_clean = sblock->s_state & htole16 (EXT2_VALID_FS);
> if (! ext2fs_clean)
> {
> ext2_warning ("FILESYSTEM NOT UNMOUNTED CLEANLY; PLEASE fsck");
> @@ -183,16 +183,16 @@ map_hypermetadata (void)
> error_t
> diskfs_set_hypermetadata (int wait, int clean)
> {
> - if (clean && ext2fs_clean && !(sblock->s_state & EXT2_VALID_FS))
> + if (clean && ext2fs_clean && !(sblock->s_state & htole16 (EXT2_VALID_FS)))
> /* The filesystem is clean, so we need to set the clean flag. */
> {
> - sblock->s_state |= EXT2_VALID_FS;
> + sblock->s_state |= htole16 (EXT2_VALID_FS);
> sblock_dirty = 1;
> }
> - else if (!clean && (sblock->s_state & EXT2_VALID_FS))
> + else if (!clean && (sblock->s_state & htole16 (EXT2_VALID_FS)))
> /* The filesystem just became dirty, so clear the clean flag. */
> {
> - sblock->s_state &= ~EXT2_VALID_FS;
> + sblock->s_state &= htole16 (~EXT2_VALID_FS);
> sblock_dirty = 1;
> wait = 1;
> }
> @@ -221,6 +221,6 @@ diskfs_readonly_changed (int readonly)
> mprotect (disk_cache, disk_cache_size,
> PROT_READ | (readonly ? 0 : PROT_WRITE));
>
> - if (!readonly && !(sblock->s_state & EXT2_VALID_FS))
> + if (!readonly && !(sblock->s_state & htole16 (EXT2_VALID_FS)))
> ext2_warning ("UNCLEANED FILESYSTEM NOW WRITABLE");
> }
> diff --git a/ext2fs/ialloc.c b/ext2fs/ialloc.c
> index 46821a1f..73778bee 100644
> --- a/ext2fs/ialloc.c
> +++ b/ext2fs/ialloc.c
> @@ -66,18 +66,18 @@ diskfs_free_node (struct node *np, mode_t old_mode)
>
> pthread_spin_lock (&global_lock);
>
> - if (inum < EXT2_FIRST_INO (sblock) || inum > sblock->s_inodes_count)
> + if (inum < EXT2_FIRST_INO (sblock) || inum > le32toh
> (sblock->s_inodes_count))
> {
> ext2_error ("reserved inode or nonexistent inode: %Ld", inum);
> pthread_spin_unlock (&global_lock);
> return;
> }
>
> - block_group = (inum - 1) / sblock->s_inodes_per_group;
> - bit = (inum - 1) % sblock->s_inodes_per_group;
> + block_group = (inum - 1) / le32toh (sblock->s_inodes_per_group);
> + bit = (inum - 1) % le32toh (sblock->s_inodes_per_group);
>
> gdp = group_desc (block_group);
> - bh = disk_cache_block_ref (gdp->bg_inode_bitmap);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_inode_bitmap));
>
> if (!clear_bit (bit, bh))
> ext2_warning ("bit already cleared for inode %Ld", inum);
> @@ -86,13 +86,13 @@ diskfs_free_node (struct node *np, mode_t old_mode)
> disk_cache_block_ref_ptr (bh);
> record_global_poke (bh);
>
> - gdp->bg_free_inodes_count++;
> + gdp->bg_free_inodes_count = htole32 (le32toh
> (gdp->bg_free_inodes_count) + 1);
> if (S_ISDIR (old_mode))
> - gdp->bg_used_dirs_count--;
> + gdp->bg_used_dirs_count = htole16 (le16toh (gdp->bg_used_dirs_count)
> - 1);
> disk_cache_block_ref_ptr (gdp);
> record_global_poke (gdp);
>
> - sblock->s_free_inodes_count++;
> + sblock->s_free_inodes_count = htole32 (le32toh
> (sblock->s_free_inodes_count) + 1);
> }
>
> disk_cache_block_deref (bh);
> @@ -131,7 +131,7 @@ repeat:
>
> if (S_ISDIR (mode))
> {
> - avefreei = sblock->s_free_inodes_count / groups_count;
> + avefreei = le32toh (sblock->s_free_inodes_count) / groups_count;
>
> /* I am not yet convinced that this next bit is necessary.
> i = inode_group_num(dir_inum);
> @@ -153,11 +153,12 @@ repeat:
> for (j = 0; j < groups_count; j++)
> {
> tmp = group_desc (j);
> - if (tmp->bg_free_inodes_count
> - && tmp->bg_free_inodes_count >= avefreei)
> + if (le16toh (tmp->bg_free_inodes_count)
> + && le16toh (tmp->bg_free_inodes_count) >= avefreei)
> {
> if (!gdp ||
> - (tmp->bg_free_blocks_count >
> gdp->bg_free_blocks_count))
> + (le16toh (tmp->bg_free_blocks_count) >
> + le16toh (gdp->bg_free_blocks_count)))
> {
> i = j;
> gdp = tmp;
> @@ -173,7 +174,7 @@ repeat:
> */
> i = inode_group_num(dir_inum);
> tmp = group_desc (i);
> - if (tmp->bg_free_inodes_count)
> + if (le16toh (tmp->bg_free_inodes_count))
> gdp = tmp;
> else
> {
> @@ -187,7 +188,7 @@ repeat:
> if (i >= groups_count)
> i -= groups_count;
> tmp = group_desc (i);
> - if (tmp->bg_free_inodes_count)
> + if (le16toh (tmp->bg_free_inodes_count))
> {
> gdp = tmp;
> break;
> @@ -205,7 +206,7 @@ repeat:
> if (++i >= groups_count)
> i = 0;
> tmp = group_desc (i);
> - if (tmp->bg_free_inodes_count)
> + if (le16toh (tmp->bg_free_inodes_count))
> {
> gdp = tmp;
> break;
> @@ -220,10 +221,10 @@ repeat:
> return 0;
> }
>
> - bh = disk_cache_block_ref (gdp->bg_inode_bitmap);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_inode_bitmap));
> if ((inum =
> - find_first_zero_bit ((unsigned long *) bh,
> sblock->s_inodes_per_group))
> - < sblock->s_inodes_per_group)
> + find_first_zero_bit ((unsigned long *) bh, le32toh
> (sblock->s_inodes_per_group)))
> + < le32toh (sblock->s_inodes_per_group))
> {
> if (set_bit (inum, bh))
> {
> @@ -239,7 +240,7 @@ repeat:
> {
> disk_cache_block_deref (bh);
> bh = NULL;
> - if (gdp->bg_free_inodes_count != 0)
> + if (le16toh (gdp->bg_free_inodes_count) != 0)
> {
> ext2_error ("free inodes count corrupted in group %d", i);
> inum = 0;
> @@ -248,8 +249,8 @@ repeat:
> goto repeat;
> }
>
> - inum += i * sblock->s_inodes_per_group + 1;
> - if (inum < EXT2_FIRST_INO (sblock) || inum > sblock->s_inodes_count)
> + inum += i * le32toh (sblock->s_inodes_per_group) + 1;
> + if (inum < EXT2_FIRST_INO (sblock) || inum > le32toh
> (sblock->s_inodes_count))
> {
> ext2_error ("reserved inode or inode > inodes count - "
> "block_group = %d,inode=%llu", i, inum);
> @@ -257,13 +258,13 @@ repeat:
> goto sync_out;
> }
>
> - gdp->bg_free_inodes_count--;
> + gdp->bg_free_inodes_count = htole16 (le16toh (gdp->bg_free_inodes_count) -
> 1);
> if (S_ISDIR (mode))
> - gdp->bg_used_dirs_count++;
> + gdp->bg_used_dirs_count = htole16 (le16toh (gdp->bg_used_dirs_count) +
> 1);
> disk_cache_block_ref_ptr (gdp);
> record_global_poke (gdp);
>
> - sblock->s_free_inodes_count--;
> + sblock->s_free_inodes_count = htole32(
> le32toh(sblock->s_free_inodes_count) - 1);
> sblock_dirty = 1;
>
> sync_out:
> @@ -381,20 +382,20 @@ ext2_count_free_inodes ()
> {
> void *bh;
> gdp = group_desc (i);
> - desc_count += gdp->bg_free_inodes_count;
> - bh = disk_cache_block_ref (gdp->bg_inode_bitmap);
> - x = count_free (bh, sblock->s_inodes_per_group / 8);
> + desc_count += le16toh (gdp->bg_free_inodes_count);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_inode_bitmap));
> + x = count_free (bh, le32toh (sblock->s_inodes_per_group) / 8);
> disk_cache_block_deref (bh);
> ext2_debug ("group %d: stored = %d, counted = %lu",
> - i, gdp->bg_free_inodes_count, x);
> + i, le16toh (gdp->bg_free_inodes_count), x);
> bitmap_count += x;
> }
> ext2_debug ("stored = %u, computed = %lu, %lu",
> - sblock->s_free_inodes_count, desc_count, bitmap_count);
> + le32toh (sblock->s_free_inodes_count), desc_count,
> bitmap_count);
> pthread_spin_unlock (&global_lock);
> return desc_count;
> #else
> - return sblock->s_free_inodes_count;
> + return le32toh (sblock->s_free_inodes_count);
> #endif
> }
>
> @@ -416,20 +417,20 @@ ext2_check_inodes_bitmap ()
> {
> void *bh;
> gdp = group_desc (i);
> - desc_count += gdp->bg_free_inodes_count;
> - bh = disk_cache_block_ref (gdp->bg_inode_bitmap);
> - x = count_free (bh, sblock->s_inodes_per_group / 8);
> + desc_count += le16toh (gdp->bg_free_inodes_count);
> + bh = disk_cache_block_ref (le32toh (gdp->bg_inode_bitmap));
> + x = count_free (bh, le32toh (sblock->s_inodes_per_group) / 8);
> disk_cache_block_deref (bh);
> - if (gdp->bg_free_inodes_count != x)
> + if (le16toh (gdp->bg_free_inodes_count) != x)
> ext2_error ("wrong free inodes count in group %d, "
> "stored = %d, counted = %lu",
> - i, gdp->bg_free_inodes_count, x);
> + i, le16toh (gdp->bg_free_inodes_count), x);
> bitmap_count += x;
> }
> - if (sblock->s_free_inodes_count != bitmap_count)
> + if (le32toh (sblock->s_free_inodes_count) != bitmap_count)
> ext2_error ("wrong free inodes count in super block, "
> "stored = %lu, counted = %lu",
> - (unsigned long) sblock->s_free_inodes_count, bitmap_count);
> + (unsigned long) le32toh (sblock->s_free_inodes_count),
> bitmap_count);
>
> pthread_spin_unlock (&global_lock);
> }
> diff --git a/ext2fs/inode.c b/ext2fs/inode.c
> index fe1af528..47d05f47 100644
> --- a/ext2fs/inode.c
> +++ b/ext2fs/inode.c
> @@ -130,45 +130,45 @@ diskfs_user_read_node (struct node *np, struct
> lookup_context *ctx)
> st->st_ino = np->cache_id;
> st->st_blksize = vm_page_size * 2;
>
> - st->st_nlink = di->i_links_count;
> - st->st_size = di->i_size;
> - st->st_gen = di->i_generation;
> + st->st_nlink = le16toh (di->i_links_count);
> + st->st_size = le32toh (di->i_size);
> + st->st_gen = le32toh (di->i_generation);
>
> - st->st_atim.tv_sec = di->i_atime;
> + st->st_atim.tv_sec = le32toh (di->i_atime);
> #ifdef not_yet
> /* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
> #else
> st->st_atim.tv_nsec = 0;
> #endif
> - st->st_mtim.tv_sec = di->i_mtime;
> + st->st_mtim.tv_sec = le32toh (di->i_mtime);
> #ifdef not_yet
> /* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
> #else
> st->st_mtim.tv_nsec = 0;
> #endif
> - st->st_ctim.tv_sec = di->i_ctime;
> + st->st_ctim.tv_sec = le32toh (di->i_ctime);
> #ifdef not_yet
> /* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
> #else
> st->st_ctim.tv_nsec = 0;
> #endif
>
> - st->st_blocks = di->i_blocks;
> + st->st_blocks = le32toh (di->i_blocks);
>
> st->st_flags = 0;
> - if (di->i_flags & EXT2_APPEND_FL)
> + if (di->i_flags & htole32 (EXT2_APPEND_FL))
> st->st_flags |= UF_APPEND;
> - if (di->i_flags & EXT2_NODUMP_FL)
> + if (di->i_flags & htole32 (EXT2_NODUMP_FL))
> st->st_flags |= UF_NODUMP;
> - if (di->i_flags & EXT2_IMMUTABLE_FL)
> + if (di->i_flags & htole32 (EXT2_IMMUTABLE_FL))
> st->st_flags |= UF_IMMUTABLE;
>
> - if (sblock->s_creator_os == EXT2_OS_HURD)
> + if (sblock->s_creator_os == htole32 (EXT2_OS_HURD))
> {
> - st->st_mode = di->i_mode | (di->i_mode_high << 16);
> + st->st_mode = le16toh (di->i_mode) | (le16toh (di->i_mode_high) << 16);
> st->st_mode &= ~S_ITRANS;
>
> - if (di->i_translator)
> + if (le32toh (di->i_translator))
> st->st_mode |= S_IPTRANS;
> else
> {
> @@ -178,41 +178,41 @@ diskfs_user_read_node (struct node *np, struct
> lookup_context *ctx)
> st->st_mode |= S_IPTRANS;
> }
>
> - st->st_uid = di->i_uid | (di->i_uid_high << 16);
> - st->st_gid = di->i_gid | (di->i_gid_high << 16);
> + st->st_uid = le16toh (di->i_uid) | (le16toh (di->i_uid_high) << 16);
> + st->st_gid = le16toh (di->i_gid) | (le16toh (di->i_gid_high) << 16);
>
> - st->st_author = di->i_author;
> + st->st_author = le32toh (di->i_author);
> if (st->st_author == -1)
> st->st_author = st->st_uid;
> }
> else
> {
> - st->st_mode = di->i_mode & ~S_ITRANS;
> - st->st_uid = di->i_uid;
> - st->st_gid = di->i_gid;
> + st->st_mode = le16toh (di->i_mode) & ~S_ITRANS;
> + st->st_uid = le16toh (di->i_uid);
> + st->st_gid = le16toh (di->i_gid);
> st->st_author = st->st_uid;
> np->author_tracks_uid = 1;
> }
>
> /* Setup the ext2fs auxiliary inode info. */
> - info->i_dtime = di->i_dtime;
> - info->i_flags = di->i_flags;
> - info->i_faddr = di->i_faddr;
> + info->i_dtime = le32toh (di->i_dtime);
> + info->i_flags = le32toh (di->i_flags);
> + info->i_faddr = le32toh (di->i_faddr);
> info->i_frag_no = di->i_frag;
> info->i_frag_size = di->i_fsize;
> info->i_osync = 0;
> - info->i_file_acl = di->i_file_acl;
> + info->i_file_acl = le32toh (di->i_file_acl);
> if (S_ISDIR (st->st_mode))
> - info->i_dir_acl = di->i_dir_acl;
> + info->i_dir_acl = le32toh (di->i_dir_acl);
> else
> {
> info->i_dir_acl = 0;
> if (sizeof (off_t) >= 8)
> /* 64bit file size */
> - st->st_size += ((off_t) di->i_size_high) << 32;
> + st->st_size += ((off_t) le32toh (di->i_size_high)) << 32;
> else
> {
> - if (di->i_size_high) /* XXX */
> + if (le32toh (di->i_size_high)) /* XXX */
> {
> dino_deref (di);
> ext2_warning ("cannot handle large file inode %Ld",
> np->cache_id);
> @@ -230,14 +230,18 @@ diskfs_user_read_node (struct node *np, struct
> lookup_context *ctx)
> dn->last_page_partially_writable = 0;
>
> if (S_ISCHR (st->st_mode) || S_ISBLK (st->st_mode))
> - st->st_rdev = di->i_block[0];
> + st->st_rdev = le32toh (di->i_block[0]);
> else
> {
> + /*
> + * NOTE! The in-memory inode i_data array is in little-endian order
> + * even on big-endian machines: we do NOT byteswap the block numbers!
> + */
> memcpy (info->i_data, di->i_block,
> EXT2_N_BLOCKS * sizeof info->i_data[0]);
> st->st_rdev = 0;
> }
> - dn->info_i_translator = di->i_translator;
> + dn->info_i_translator = le32toh (di->i_translator);
>
> dino_deref (di);
> diskfs_end_catch_exception ();
> @@ -280,7 +284,7 @@ diskfs_user_read_node (struct node *np, struct
> lookup_context *ctx)
> static inline error_t
> check_high_bits (struct node *np, long l)
> {
> - if (sblock->s_creator_os == EXT2_OS_HURD)
> + if (sblock->s_creator_os == htole32 (EXT2_OS_HURD))
> return 0;
>
> /* Linux 2.3.42 has a mount-time option (not a bit stored on disk)
> @@ -325,7 +329,7 @@ diskfs_validate_mode_change (struct node *np, mode_t mode)
> error_t
> diskfs_validate_author_change (struct node *np, uid_t author)
> {
> - if (sblock->s_creator_os == EXT2_OS_HURD)
> + if (sblock->s_creator_os == htole32 (EXT2_OS_HURD))
> return 0;
> else
> /* For non-hurd filesystems, the author & owner are the same. */
> @@ -372,7 +376,7 @@ write_node (struct node *np)
>
> di = dino_ref (np->cache_id);
>
> - di->i_generation = st->st_gen;
> + di->i_generation = htole32 (st->st_gen);
>
> /* We happen to know that the stat mode bits are the same
> as the ext2fs mode bits. */
> @@ -380,17 +384,17 @@ write_node (struct node *np)
>
> /* Only the low 16 bits of these fields are standard across all ext2
> implementations. */
> - di->i_mode = st->st_mode & 0xFFFF & ~S_ITRANS;
> - di->i_uid = st->st_uid & 0xFFFF;
> - di->i_gid = st->st_gid & 0xFFFF;
> + di->i_mode = htole16 (st->st_mode & 0xFFFF & ~S_ITRANS);
> + di->i_uid = htole16 (st->st_uid & 0xFFFF);
> + di->i_gid = htole16 (st->st_gid & 0xFFFF);
>
> - if (sblock->s_creator_os == EXT2_OS_HURD)
> + if (sblock->s_creator_os == htole32 (EXT2_OS_HURD))
> /* If this is a hurd-compatible filesystem, write the high bits too.
> */
> {
> - di->i_mode_high = (st->st_mode >> 16) & 0xffff & ~S_ITRANS;
> - di->i_uid_high = st->st_uid >> 16;
> - di->i_gid_high = st->st_gid >> 16;
> - di->i_author = st->st_author;
> + di->i_mode_high = htole16 ((st->st_mode >> 16) & 0xffff &
> ~S_ITRANS);
> + di->i_uid_high = htole16 (st->st_uid >> 16);
> + di->i_gid_high = htole16 (st->st_gid >> 16);
> + di->i_author = htole32 (st->st_author);
> }
> else
> /* No hurd extensions should be turned on. */
> @@ -401,20 +405,20 @@ write_node (struct node *np)
> assert_backtrace (np->author_tracks_uid && st->st_author ==
> st->st_uid);
> }
>
> - di->i_links_count = st->st_nlink;
> + di->i_links_count = htole16 (st->st_nlink);
>
> - di->i_atime = st->st_atim.tv_sec;
> + di->i_atime = htole32(st->st_atim.tv_sec);
> #ifdef not_yet
> /* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
> - di->i_atime.tv_nsec = st->st_atim.tv_nsec;
> + di->i_atime.tv_nsec = htole32 (st->st_atim.tv_nsec);
> #endif
> - di->i_mtime = st->st_mtim.tv_sec;
> + di->i_mtime = htole32 (st->st_mtim.tv_sec);
> #ifdef not_yet
> - di->i_mtime.tv_nsec = st->st_mtim.tv_nsec;
> + di->i_mtime.tv_nsec = htole32 (st->st_mtim.tv_nsec);
> #endif
> - di->i_ctime = st->st_ctim.tv_sec;
> + di->i_ctime = htole32 (st->st_ctim.tv_sec);
> #ifdef not_yet
> - di->i_ctime.tv_nsec = st->st_ctim.tv_nsec;
> + di->i_ctime.tv_nsec = htole32 (st->st_ctim.tv_nsec);
> #endif
>
> /* Convert generic flags in ST->st_flags to ext2-specific flags in DI
> @@ -429,25 +433,25 @@ write_node (struct node *np)
> info->i_flags |= EXT2_NODUMP_FL;
> if (st->st_flags & UF_IMMUTABLE)
> info->i_flags |= EXT2_IMMUTABLE_FL;
> - di->i_flags = info->i_flags;
> + di->i_flags = htole32 (info->i_flags);
>
> if (st->st_mode == 0)
> /* Set dtime non-zero to indicate a deleted file.
> We don't clear i_size, i_blocks, and i_translator in this case,
> to give "undeletion" utilities a chance. */
> - di->i_dtime = di->i_mtime;
> + di->i_dtime = htole32 (di->i_mtime);
> else
> {
> di->i_dtime = 0;
> - di->i_size = st->st_size;
> + di->i_size = htole32 (st->st_size);
> if (sizeof (off_t) >= 8 && !S_ISDIR (st->st_mode))
> /* 64bit file size */
> - di->i_size_high = st->st_size >> 32;
> - di->i_blocks = st->st_blocks;
> + di->i_size_high = htole32 (st->st_size >> 32);
> + di->i_blocks = htole32 (st->st_blocks);
> }
>
> if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
> - di->i_block[0] = st->st_rdev;
> + di->i_block[0] = htole32 (st->st_rdev);
> else
> memcpy (di->i_block, diskfs_node_disknode (np)->info.i_data,
> EXT2_N_BLOCKS * sizeof di->i_block[0]);
> @@ -529,13 +533,13 @@ diskfs_set_statfs (struct statfs *st)
> {
> st->f_type = FSTYPE_EXT2FS;
> st->f_bsize = block_size;
> - st->f_blocks = sblock->s_blocks_count;
> - st->f_bfree = sblock->s_free_blocks_count;
> - st->f_bavail = st->f_bfree - sblock->s_r_blocks_count;
> - if (st->f_bfree < sblock->s_r_blocks_count)
> + st->f_blocks = le32toh (sblock->s_blocks_count);
> + st->f_bfree = le32toh (sblock->s_free_blocks_count);
> + st->f_bavail = st->f_bfree - le32toh (sblock->s_r_blocks_count);
> + if (st->f_bfree < le32toh (sblock->s_r_blocks_count))
> st->f_bavail = 0;
> - st->f_files = sblock->s_inodes_count;
> - st->f_ffree = sblock->s_free_inodes_count;
> + st->f_files = le32toh (sblock->s_inodes_count);
> + st->f_ffree = le32toh (sblock->s_free_inodes_count);
> st->f_fsid = getpid ();
> st->f_namelen = 0;
> st->f_favail = st->f_ffree;
> @@ -553,7 +557,7 @@ diskfs_set_translator (struct node *np, const char *name,
> unsigned namelen,
>
> assert_backtrace (!diskfs_readonly);
>
> - if (sblock->s_creator_os != EXT2_OS_HURD)
> + if (sblock->s_creator_os != htole32 (EXT2_OS_HURD))
> return EOPNOTSUPP;
>
> err = diskfs_catch_exception ();
> @@ -569,7 +573,7 @@ diskfs_set_translator (struct node *np, const char *name,
> unsigned namelen,
> struct ext2_inode *di;
>
> di = dino_ref (np->cache_id);
> - blkno = di->i_translator;
> + blkno = le32toh (di->i_translator);
>
> /* If a legacy translator record found, clear it */
> if (blkno)
> @@ -628,7 +632,7 @@ diskfs_set_translator (struct node *np, const char *name,
> unsigned namelen,
> return ENAMETOOLONG;
>
> di = dino_ref (np->cache_id);
> - blkno = di->i_translator;
> + blkno = le32toh (di->i_translator);
>
> if (namelen && !blkno)
> {
> @@ -648,7 +652,7 @@ diskfs_set_translator (struct node *np, const char *name,
> unsigned namelen,
> blkno =
> ext2_new_block ((diskfs_node_disknode (np)->info.i_block_group
> * EXT2_BLOCKS_PER_GROUP (sblock))
> - + sblock->s_first_data_block,
> + + le32toh (sblock->s_first_data_block),
> 0, 0, 0);
> if (blkno == 0)
> {
> @@ -664,7 +668,7 @@ diskfs_set_translator (struct node *np, const char *name,
> unsigned namelen,
> np->dn_stat.st_mode = newmode;
> }
>
> - di->i_translator = blkno;
> + di->i_translator = htole32 (blkno);
> diskfs_node_disknode (np)->info_i_translator = blkno;
> record_global_poke (di);
>
> @@ -719,7 +723,7 @@ diskfs_get_translator (struct node *np, char **namep,
> unsigned *namelen)
> void *transloc;
> struct ext2_inode *di;
>
> - if (sblock->s_creator_os != EXT2_OS_HURD)
> + if (sblock->s_creator_os != htole32 (EXT2_OS_HURD))
> return EOPNOTSUPP;
>
> err = diskfs_catch_exception ();
> @@ -727,7 +731,7 @@ diskfs_get_translator (struct node *np, char **namep,
> unsigned *namelen)
> return err;
>
> di = dino_ref (np->cache_id);
> - blkno = di->i_translator;
> + blkno = le32toh (di->i_translator);
> dino_deref (di);
>
> /* If an old translator record found, read it firstly */
> diff --git a/ext2fs/xattr.c b/ext2fs/xattr.c
> index 6bb89bec..0c855616 100644
> --- a/ext2fs/xattr.c
> +++ b/ext2fs/xattr.c
> @@ -91,17 +91,17 @@ xattr_entry_hash (struct ext2_xattr_header *header,
>
> if (entry->e_value_block == 0 && entry->e_value_size != 0)
> {
> - __u32 *value = (__u32 *) ((char *) header + entry->e_value_offs);
> - for (n = (entry->e_value_size + EXT2_XATTR_ROUND) >>
> + __u32 *value = (__u32 *) ((char *) header + le16toh
> (entry->e_value_offs));
> + for (n = (le32toh (entry->e_value_size) + EXT2_XATTR_ROUND) >>
> EXT2_XATTR_PAD_BITS; n; n--)
> {
> hash = (hash << VALUE_HASH_SHIFT)
> ^ (hash >> (8 * sizeof (hash) - VALUE_HASH_SHIFT))
> - ^ *value++;
> + ^ le32toh(*value++);
> }
> }
>
> - entry->e_hash = hash;
> + entry->e_hash = htole32 (hash);
>
> }
>
> @@ -136,12 +136,12 @@ xattr_entry_rehash (struct ext2_xattr_header *header,
>
> hash = (hash << BLOCK_HASH_SHIFT)
> ^ (hash >> (8 * sizeof (hash) - BLOCK_HASH_SHIFT))
> - ^ position->e_hash;
> + ^ le32toh (position->e_hash);
>
> position = EXT2_XATTR_ENTRY_NEXT (position);
> }
>
> - header->h_hash = hash;
> + header->h_hash = htole32 (hash);
>
> }
>
> @@ -237,14 +237,14 @@ xattr_entry_get (void *block, struct ext2_xattr_entry
> *entry,
>
> if (value)
> {
> - if (*len < entry->e_value_size)
> + if (*len < le32toh (entry->e_value_size))
> {
> return ERANGE;
> }
> - memcpy (value, block + entry->e_value_offs, entry->e_value_size);
> + memcpy (value, block + le16toh (entry->e_value_offs), le32toh
> (entry->e_value_size));
> }
>
> - *len = entry->e_value_size;
> + *len = le32toh (entry->e_value_size);
> return 0;
>
> }
> @@ -295,13 +295,13 @@ xattr_entry_create (struct ext2_xattr_header *header,
>
> position->e_name_len = name_len;
> position->e_name_index = index;
> - position->e_value_offs = end + rest - value_size;
> + position->e_value_offs = htole16 (end + rest - value_size);
> position->e_value_block = 0;
> - position->e_value_size = len;
> + position->e_value_size = htole32 (len);
> strncpy (position->e_name, name, name_len);
>
> - memcpy ((char *) header + position->e_value_offs, value, len);
> - memset ((char *) header + position->e_value_offs + len, 0,
> + memcpy ((char *) header + le16toh (position->e_value_offs), value, len);
> + memset ((char *) header + le16toh (position->e_value_offs) + len, 0,
> value_size - len);
>
> return 0;
> @@ -325,9 +325,9 @@ xattr_entry_remove (struct ext2_xattr_header *header,
> struct ext2_xattr_entry *entry;
>
> /* Remove the value */
> - size = EXT2_XATTR_ALIGN (position->e_value_size);
> + size = EXT2_XATTR_ALIGN (le32toh (position->e_value_size));
> start = EXT2_XATTR_ENTRY_OFFSET (header, last) + rest;
> - end = position->e_value_offs;
> + end = le16toh (position->e_value_offs);
>
> memmove ((char *) header + start + size, (char *) header + start,
> end - start);
> @@ -337,8 +337,8 @@ xattr_entry_remove (struct ext2_xattr_header *header,
> entry = EXT2_XATTR_ENTRY_FIRST (header);
> while (!EXT2_XATTR_ENTRY_LAST (entry))
> {
> - if (entry->e_value_offs < end)
> - entry->e_value_offs += size;
> + if (le16toh (entry->e_value_offs) < end)
> + entry->e_value_offs = htole16 (le16toh (entry->e_value_offs) + size);
> entry = EXT2_XATTR_ENTRY_NEXT (entry);
> }
>
> @@ -372,7 +372,7 @@ xattr_entry_replace (struct ext2_xattr_header *header,
> size_t old_size;
> size_t new_size;
>
> - old_size = EXT2_XATTR_ALIGN (position->e_value_size);
> + old_size = EXT2_XATTR_ALIGN (le32toh (position->e_value_size));
> new_size = EXT2_XATTR_ALIGN (len);
>
> if (rest < 4 || new_size - old_size > rest - 4)
> @@ -385,7 +385,7 @@ xattr_entry_replace (struct ext2_xattr_header *header,
> struct ext2_xattr_entry *entry;
>
> start = EXT2_XATTR_ENTRY_OFFSET (header, last) + rest;
> - end = position->e_value_offs;
> + end = le16toh (position->e_value_offs);
>
> /* Remove the old value */
> memmove ((char *) header + start + old_size, (char *) header + start,
> @@ -395,19 +395,19 @@ xattr_entry_replace (struct ext2_xattr_header *header,
> entry = EXT2_XATTR_ENTRY_FIRST (header);
> while (!EXT2_XATTR_ENTRY_LAST (entry))
> {
> - if (entry->e_value_offs < end)
> - entry->e_value_offs += old_size;
> + if (le16toh (entry->e_value_offs) < end)
> + entry->e_value_offs = htole16 ( le16toh (entry->e_value_offs) +
> old_size);
> entry = EXT2_XATTR_ENTRY_NEXT (entry);
> }
>
> - position->e_value_offs = start - (new_size - old_size);
> + position->e_value_offs = htole16 (start - (new_size - old_size));
> }
>
> - position->e_value_size = len;
> + position->e_value_size = htole32 (len);
>
> /* Write the new value */
> - memcpy ((char *) header + position->e_value_offs, value, len);
> - memset ((char *) header + position->e_value_offs + len, 0, new_size - len);
> + memcpy ((char *) header + le16toh (position->e_value_offs), value, len);
> + memset ((char *) header + le16toh (position->e_value_offs) + len, 0,
> new_size - len);
>
> return 0;
>
> @@ -450,14 +450,15 @@ ext2_free_xattr_block (struct node *np)
> block = disk_cache_block_ref (blkno);
> header = EXT2_XATTR_HEADER (block);
>
> - if (header->h_magic != EXT2_XATTR_BLOCK_MAGIC || header->h_blocks != 1)
> + if (header->h_magic != htole32 (EXT2_XATTR_BLOCK_MAGIC)
> + || header->h_blocks != htole32 (1))
> {
> ext2_warning ("Invalid extended attribute block.");
> err = EIO;
> goto cleanup;
> }
>
> - if (header->h_refcount == 1)
> + if (le32toh (header->h_refcount) == 1)
> {
> ext2_debug("free block %d", blkno);
>
> @@ -470,9 +471,9 @@ ext2_free_xattr_block (struct node *np)
> }
> else
> {
> - ext2_debug("h_refcount: %d", header->h_refcount);
> + ext2_debug("h_refcount: %d", le32toh (header->h_refcount));
>
> - header->h_refcount--;
> + header->h_refcount = htole32 (le32toh (header->h_refcount) - 1);
> record_global_poke (block);
> }
>
> @@ -535,7 +536,8 @@ ext2_list_xattr (struct node *np, char *buffer, size_t
> *len)
> block = disk_cache_block_ref (blkno);
>
> header = EXT2_XATTR_HEADER (block);
> - if (header->h_magic != EXT2_XATTR_BLOCK_MAGIC || header->h_blocks != 1)
> + if (header->h_magic != htole32 (EXT2_XATTR_BLOCK_MAGIC)
> + || header->h_blocks != htole32 (1))
> {
> ext2_warning ("Invalid extended attribute block.");
> err = EIO;
> @@ -609,7 +611,8 @@ ext2_get_xattr (struct node *np, const char *name, char
> *value, size_t *len)
> dino_deref (ei);
>
> header = EXT2_XATTR_HEADER (block);
> - if (header->h_magic != EXT2_XATTR_BLOCK_MAGIC || header->h_blocks != 1)
> + if (header->h_magic != htole32 (EXT2_XATTR_BLOCK_MAGIC)
> + || header->h_blocks != htole32 (1))
> {
> ext2_warning ("Invalid extended attribute block.");
> err = EIO;
> @@ -699,7 +702,7 @@ ext2_set_xattr (struct node *np, const char *name, const
> char *value,
>
> assert_backtrace (!diskfs_readonly);
>
> - goal = sblock->s_first_data_block + np->dn->info.i_block_group *
> + goal = le32toh (sblock->s_first_data_block) +
> np->dn->info.i_block_group *
> EXT2_BLOCKS_PER_GROUP (sblock);
> blkno = ext2_new_block (goal, 0, 0, 0);
>
> @@ -713,15 +716,16 @@ ext2_set_xattr (struct node *np, const char *name,
> const char *value,
> memset (block, 0, block_size);
>
> header = EXT2_XATTR_HEADER (block);
> - header->h_magic = EXT2_XATTR_BLOCK_MAGIC;
> - header->h_blocks = 1;
> - header->h_refcount = 1;
> + header->h_magic = htole32 (EXT2_XATTR_BLOCK_MAGIC);
> + header->h_blocks = htole32 (1);
> + header->h_refcount = htole32 (1);
> }
> else
> {
> block = disk_cache_block_ref (blkno);
> header = EXT2_XATTR_HEADER (block);
> - if (header->h_magic != EXT2_XATTR_BLOCK_MAGIC || header->h_blocks != 1)
> + if (header->h_magic != htole32 (EXT2_XATTR_BLOCK_MAGIC)
> + || header->h_blocks != htole32 (1))
> {
> ext2_warning ("Invalid extended attribute block.");
> err = EIO;
> @@ -761,7 +765,7 @@ ext2_set_xattr (struct node *np, const char *name, const
> char *value,
> break;
> }
>
> - rest -= EXT2_XATTR_ALIGN (entry->e_value_size);
> + rest -= EXT2_XATTR_ALIGN (le32toh (entry->e_value_size));
> entry = EXT2_XATTR_ENTRY_NEXT (entry);
> }
>
> --
> 2.34.1
>
>
