Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-05-03 18:23:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

ext4: use kernel names for byte swaps

Browse source 
Instead of __{be,le}{16,32}_to_cpu use {be,le}{16,32}_to_cpu.

Signed-off-by: Michael Walle <michael@walle.cc>
This commit is contained in:
Michael Walle 2016-08-29 10:46:44 +02:00 • committed by Tom Rini
parent 2a0b7a971a
commit 7f101be314
4 changed files with 55 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
fs/ext4/ext4_common.c
View file

@ -1454,7 +1454,7 @@ static int ext4fs_blockgroup
desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group); desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group);
blkno = __le32_to_cpu(data->sblock.first_data_block) + 1 + blkno = le32_to_cpu(data->sblock.first_data_block) + 1 +
group / desc_per_blk; group / desc_per_blk;
blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group); blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group);
@ -1479,14 +1479,14 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode)
/* It is easier to calculate if the first inode is 0. */ /* It is easier to calculate if the first inode is 0. */
ino--; ino--;
status = ext4fs_blockgroup(data, ino / __le32_to_cpu status = ext4fs_blockgroup(data, ino / le32_to_cpu
(sblock->inodes_per_group), &blkgrp); (sblock->inodes_per_group), &blkgrp);
if (status == 0) if (status == 0)
return 0; return 0;
inodes_per_block = EXT2_BLOCK_SIZE(data) / fs->inodesz; inodes_per_block = EXT2_BLOCK_SIZE(data) / fs->inodesz;
blkno = __le32_to_cpu(blkgrp.inode_table_id) + blkno = le32_to_cpu(blkgrp.inode_table_id) +
(ino % __le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block; (ino % le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
blkoff = (ino % inodes_per_block) * fs->inodesz; blkoff = (ino % inodes_per_block) * fs->inodesz;
/* Read the inode. */ /* Read the inode. */
status = ext4fs_devread((lbaint_t)blkno << (LOG2_BLOCK_SIZE(data) - status = ext4fs_devread((lbaint_t)blkno << (LOG2_BLOCK_SIZE(data) -
@ -1559,7 +1559,7 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
/* Direct blocks. */ /* Direct blocks. */
if (fileblock < INDIRECT_BLOCKS) if (fileblock < INDIRECT_BLOCKS)
blknr = __le32_to_cpu(inode->b.blocks.dir_blocks[fileblock]); blknr = le32_to_cpu(inode->b.blocks.dir_blocks[fileblock]);
/* Indirect. */ /* Indirect. */
else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) { else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
@ -1586,10 +1586,10 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
} }
ext4fs_indir1_size = blksz; ext4fs_indir1_size = blksz;
} }
if ((__le32_to_cpu(inode->b.blocks.indir_block) << if ((le32_to_cpu(inode->b.blocks.indir_block) <<
log2_blksz) != ext4fs_indir1_blkno) { log2_blksz) != ext4fs_indir1_blkno) {
status = status =
ext4fs_devread((lbaint_t)__le32_to_cpu ext4fs_devread((lbaint_t)le32_to_cpu
(inode->b.blocks. (inode->b.blocks.
indir_block) << log2_blksz, 0, indir_block) << log2_blksz, 0,
blksz, (char *)ext4fs_indir1_block); blksz, (char *)ext4fs_indir1_block);
@ -1599,10 +1599,10 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
return 0; return 0;
} }
ext4fs_indir1_blkno = ext4fs_indir1_blkno =
__le32_to_cpu(inode->b.blocks. le32_to_cpu(inode->b.blocks.
indir_block) << log2_blksz; indir_block) << log2_blksz;
} }
blknr = __le32_to_cpu(ext4fs_indir1_block blknr = le32_to_cpu(ext4fs_indir1_block
[fileblock - INDIRECT_BLOCKS]); [fileblock - INDIRECT_BLOCKS]);
} }
/* Double indirect. */ /* Double indirect. */
@ -1635,10 +1635,10 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
} }
ext4fs_indir1_size = blksz; ext4fs_indir1_size = blksz;
} }
if ((__le32_to_cpu(inode->b.blocks.double_indir_block) << if ((le32_to_cpu(inode->b.blocks.double_indir_block) <<
log2_blksz) != ext4fs_indir1_blkno) { log2_blksz) != ext4fs_indir1_blkno) {
status = status =
ext4fs_devread((lbaint_t)__le32_to_cpu ext4fs_devread((lbaint_t)le32_to_cpu
(inode->b.blocks. (inode->b.blocks.
double_indir_block) << log2_blksz, double_indir_block) << log2_blksz,
0, blksz, 0, blksz,
@ -1649,7 +1649,7 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
return -1; return -1;
} }
ext4fs_indir1_blkno = ext4fs_indir1_blkno =
__le32_to_cpu(inode->b.blocks.double_indir_block) << le32_to_cpu(inode->b.blocks.double_indir_block) <<
log2_blksz; log2_blksz;
} }
@ -1676,9 +1676,9 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
} }
ext4fs_indir2_size = blksz; ext4fs_indir2_size = blksz;
} }
if ((__le32_to_cpu(ext4fs_indir1_block[rblock / perblock]) << if ((le32_to_cpu(ext4fs_indir1_block[rblock / perblock]) <<
log2_blksz) != ext4fs_indir2_blkno) { log2_blksz) != ext4fs_indir2_blkno) {
status = ext4fs_devread((lbaint_t)__le32_to_cpu status = ext4fs_devread((lbaint_t)le32_to_cpu
(ext4fs_indir1_block (ext4fs_indir1_block
[rblock / [rblock /
perblock]) << log2_blksz, 0, perblock]) << log2_blksz, 0,
@ -1690,12 +1690,12 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
return -1; return -1;
} }
ext4fs_indir2_blkno = ext4fs_indir2_blkno =
__le32_to_cpu(ext4fs_indir1_block[rblock le32_to_cpu(ext4fs_indir1_block[rblock
/ /
perblock]) << perblock]) <<
log2_blksz; log2_blksz;
} }
blknr = __le32_to_cpu(ext4fs_indir2_block[rblock % perblock]); blknr = le32_to_cpu(ext4fs_indir2_block[rblock % perblock]);
} }
/* Tripple indirect. */ /* Tripple indirect. */
else { else {
@ -1727,11 +1727,11 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
} }
ext4fs_indir1_size = blksz; ext4fs_indir1_size = blksz;
} }
if ((__le32_to_cpu(inode->b.blocks.triple_indir_block) << if ((le32_to_cpu(inode->b.blocks.triple_indir_block) <<
log2_blksz) != ext4fs_indir1_blkno) { log2_blksz) != ext4fs_indir1_blkno) {
status = ext4fs_devread status = ext4fs_devread
((lbaint_t) ((lbaint_t)
__le32_to_cpu(inode->b.blocks.triple_indir_block) le32_to_cpu(inode->b.blocks.triple_indir_block)
<< log2_blksz, 0, blksz, << log2_blksz, 0, blksz,
(char *)ext4fs_indir1_block); (char *)ext4fs_indir1_block);
if (status == 0) { if (status == 0) {
@ -1740,7 +1740,7 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
return -1; return -1;
} }
ext4fs_indir1_blkno = ext4fs_indir1_blkno =
__le32_to_cpu(inode->b.blocks.triple_indir_block) << le32_to_cpu(inode->b.blocks.triple_indir_block) <<
log2_blksz; log2_blksz;
} }
@ -1767,11 +1767,11 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
} }
ext4fs_indir2_size = blksz; ext4fs_indir2_size = blksz;
} }
if ((__le32_to_cpu(ext4fs_indir1_block[rblock / if ((le32_to_cpu(ext4fs_indir1_block[rblock /
perblock_parent]) << perblock_parent]) <<
log2_blksz) log2_blksz)
!= ext4fs_indir2_blkno) { != ext4fs_indir2_blkno) {
status = ext4fs_devread((lbaint_t)__le32_to_cpu status = ext4fs_devread((lbaint_t)le32_to_cpu
(ext4fs_indir1_block (ext4fs_indir1_block
[rblock / [rblock /
perblock_parent]) << perblock_parent]) <<
@ -1783,7 +1783,7 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
return -1; return -1;
} }
ext4fs_indir2_blkno = ext4fs_indir2_blkno =
__le32_to_cpu(ext4fs_indir1_block[rblock / le32_to_cpu(ext4fs_indir1_block[rblock /
perblock_parent]) perblock_parent])
<< log2_blksz; << log2_blksz;
} }
@ -1811,12 +1811,12 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
} }
ext4fs_indir3_size = blksz; ext4fs_indir3_size = blksz;
} }
if ((__le32_to_cpu(ext4fs_indir2_block[rblock if ((le32_to_cpu(ext4fs_indir2_block[rblock
/ /
perblock_child]) << perblock_child]) <<
log2_blksz) != ext4fs_indir3_blkno) { log2_blksz) != ext4fs_indir3_blkno) {
status = status =
ext4fs_devread((lbaint_t)__le32_to_cpu ext4fs_devread((lbaint_t)le32_to_cpu
(ext4fs_indir2_block (ext4fs_indir2_block
[(rblock / perblock_child) [(rblock / perblock_child)
% (blksz / 4)]) << log2_blksz, 0, % (blksz / 4)]) << log2_blksz, 0,
@ -1827,14 +1827,14 @@ long int read_allocated_block(struct ext2_inode *inode, int fileblock)
return -1; return -1;
} }
ext4fs_indir3_blkno = ext4fs_indir3_blkno =
__le32_to_cpu(ext4fs_indir2_block[(rblock / le32_to_cpu(ext4fs_indir2_block[(rblock /
perblock_child) % perblock_child) %
(blksz / (blksz /
4)]) << 4)]) <<
log2_blksz; log2_blksz;
} }
blknr = __le32_to_cpu(ext4fs_indir3_block blknr = le32_to_cpu(ext4fs_indir3_block
[rblock % perblock_child]); [rblock % perblock_child]);
} }
debug("read_allocated_block %ld\n", blknr); debug("read_allocated_block %ld\n", blknr);
@ -1907,7 +1907,7 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
return 0; return 0;
} }
/* Search the file. */ /* Search the file. */
while (fpos < __le32_to_cpu(diro->inode.size)) { while (fpos < le32_to_cpu(diro->inode.size)) {
struct ext2_dirent dirent; struct ext2_dirent dirent;
status = ext4fs_read_file(diro, fpos, status = ext4fs_read_file(diro, fpos,
@ -1939,7 +1939,7 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
return 0; return 0;
fdiro->data = diro->data; fdiro->data = diro->data;
fdiro->ino = __le32_to_cpu(dirent.inode); fdiro->ino = le32_to_cpu(dirent.inode);
filename[dirent.namelen] = '\0'; filename[dirent.namelen] = '\0';
@ -1954,7 +1954,7 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
type = FILETYPE_REG; type = FILETYPE_REG;
} else { } else {
status = ext4fs_read_inode(diro->data, status = ext4fs_read_inode(diro->data,
__le32_to_cpu le32_to_cpu
(dirent.inode), (dirent.inode),
&fdiro->inode); &fdiro->inode);
if (status == 0) { if (status == 0) {
@ -1963,15 +1963,15 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
} }
fdiro->inode_read = 1; fdiro->inode_read = 1;
if ((__le16_to_cpu(fdiro->inode.mode) & if ((le16_to_cpu(fdiro->inode.mode) &
FILETYPE_INO_MASK) == FILETYPE_INO_MASK) ==
FILETYPE_INO_DIRECTORY) { FILETYPE_INO_DIRECTORY) {
type = FILETYPE_DIRECTORY; type = FILETYPE_DIRECTORY;
} else if ((__le16_to_cpu(fdiro->inode.mode) } else if ((le16_to_cpu(fdiro->inode.mode)
& FILETYPE_INO_MASK) == & FILETYPE_INO_MASK) ==
FILETYPE_INO_SYMLINK) { FILETYPE_INO_SYMLINK) {
type = FILETYPE_SYMLINK; type = FILETYPE_SYMLINK;
} else if ((__le16_to_cpu(fdiro->inode.mode) } else if ((le16_to_cpu(fdiro->inode.mode)
& FILETYPE_INO_MASK) == & FILETYPE_INO_MASK) ==
FILETYPE_INO_REG) { FILETYPE_INO_REG) {
type = FILETYPE_REG; type = FILETYPE_REG;
@ -1990,7 +1990,7 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
} else { } else {
if (fdiro->inode_read == 0) { if (fdiro->inode_read == 0) {
status = ext4fs_read_inode(diro->data, status = ext4fs_read_inode(diro->data,
__le32_to_cpu( le32_to_cpu(
dirent.inode), dirent.inode),
&fdiro->inode); &fdiro->inode);
if (status == 0) { if (status == 0) {
@ -2014,12 +2014,12 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
break; break;
} }
printf("%10u %s\n", printf("%10u %s\n",
__le32_to_cpu(fdiro->inode.size), le32_to_cpu(fdiro->inode.size),
filename); filename);
} }
free(fdiro); free(fdiro);
} }
fpos += __le16_to_cpu(dirent.direntlen); fpos += le16_to_cpu(dirent.direntlen);
} }
return 0; return 0;
} }
@ -2036,23 +2036,23 @@ static char *ext4fs_read_symlink(struct ext2fs_node *node)
if (status == 0) if (status == 0)
return 0; return 0;
} }
symlink = zalloc(__le32_to_cpu(diro->inode.size) + 1); symlink = zalloc(le32_to_cpu(diro->inode.size) + 1);
if (!symlink) if (!symlink)
return 0; return 0;
if (__le32_to_cpu(diro->inode.size) < sizeof(diro->inode.b.symlink)) { if (le32_to_cpu(diro->inode.size) < sizeof(diro->inode.b.symlink)) {
strncpy(symlink, diro->inode.b.symlink, strncpy(symlink, diro->inode.b.symlink,
__le32_to_cpu(diro->inode.size)); le32_to_cpu(diro->inode.size));
} else { } else {
status = ext4fs_read_file(diro, 0, status = ext4fs_read_file(diro, 0,
__le32_to_cpu(diro->inode.size), le32_to_cpu(diro->inode.size),
symlink, &actread); symlink, &actread);
if ((status < 0) || (actread == 0)) { if ((status < 0) || (actread == 0)) {
free(symlink); free(symlink);
return 0; return 0;
} }
} }
symlink[__le32_to_cpu(diro->inode.size)] = '\0'; symlink[le32_to_cpu(diro->inode.size)] = '\0';
return symlink; return symlink;
} }
@ -2200,7 +2200,7 @@ int ext4fs_open(const char *filename, loff_t *len)
if (status == 0) if (status == 0)
goto fail; goto fail;
} }
*len = __le32_to_cpu(fdiro->inode.size); *len = le32_to_cpu(fdiro->inode.size);
ext4fs_file = fdiro; ext4fs_file = fdiro;
return 0; return 0;
@ -2226,7 +2226,7 @@ int ext4fs_mount(unsigned part_length)
goto fail; goto fail;
/* Make sure this is an ext2 filesystem. */ /* Make sure this is an ext2 filesystem. */
if (__le16_to_cpu(data->sblock.magic) != EXT2_MAGIC) if (le16_to_cpu(data->sblock.magic) != EXT2_MAGIC)
goto fail; goto fail;
/* /*
@ -2239,13 +2239,13 @@ int ext4fs_mount(unsigned part_length)
goto fail; goto fail;
} }
if (__le32_to_cpu(data->sblock.revision_level == 0)) if (le32_to_cpu(data->sblock.revision_level == 0))
fs->inodesz = 128; fs->inodesz = 128;
else else
fs->inodesz = __le16_to_cpu(data->sblock.inode_size); fs->inodesz = le16_to_cpu(data->sblock.inode_size);
debug("EXT2 rev %d, inode_size %d\n", debug("EXT2 rev %d, inode_size %d\n",
__le32_to_cpu(data->sblock.revision_level), fs->inodesz); le32_to_cpu(data->sblock.revision_level), fs->inodesz);
data->diropen.data = data; data->diropen.data = data;
data->diropen.ino = 2; data->diropen.ino = 2;

14
fs/ext4/ext4_write.c
View file

@ -520,8 +520,8 @@ static int ext4fs_delete_file(int inodeno)
/* get the block no */ /* get the block no */
inodeno--; inodeno--;
blkno = __le32_to_cpu(bgd[ibmap_idx].inode_table_id) + blkno = le32_to_cpu(bgd[ibmap_idx].inode_table_id) +
(inodeno % __le32_to_cpu(inode_per_grp)) / inodes_per_block; (inodeno % le32_to_cpu(inode_per_grp)) / inodes_per_block;
/* get the offset of the inode */ /* get the offset of the inode */
blkoff = ((inodeno) % inodes_per_block) * fs->inodesz; blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
@ -744,7 +744,7 @@ static int ext4fs_write_file(struct ext2_inode *file_inode,
{ {
int i; int i;
int blockcnt; int blockcnt;
unsigned int filesize = __le32_to_cpu(file_inode->size); unsigned int filesize = le32_to_cpu(file_inode->size);
struct ext_filesystem *fs = get_fs(); struct ext_filesystem *fs = get_fs();
int log2blksz = fs->dev_desc->log2blksz; int log2blksz = fs->dev_desc->log2blksz;
int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz; int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
@ -909,8 +909,8 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
goto fail; goto fail;
ibmap_idx = inodeno / ext4fs_root->sblock.inodes_per_group; ibmap_idx = inodeno / ext4fs_root->sblock.inodes_per_group;
inodeno--; inodeno--;
itable_blkno = __le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) + itable_blkno = le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
(inodeno % __le32_to_cpu(sblock->inodes_per_group)) / (inodeno % le32_to_cpu(sblock->inodes_per_group)) /
inodes_per_block; inodes_per_block;
blkoff = (inodeno % inodes_per_block) * fs->inodesz; blkoff = (inodeno % inodes_per_block) * fs->inodesz;
ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz, ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
@ -928,9 +928,9 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
} }
ibmap_idx = parent_inodeno / ext4fs_root->sblock.inodes_per_group; ibmap_idx = parent_inodeno / ext4fs_root->sblock.inodes_per_group;
parent_inodeno--; parent_inodeno--;
parent_itable_blkno = __le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) + parent_itable_blkno = le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
(parent_inodeno % (parent_inodeno %
__le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block; le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz; blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
if (parent_itable_blkno != itable_blkno) { if (parent_itable_blkno != itable_blkno) {
memset(temp_ptr, '\0', fs->blksz); memset(temp_ptr, '\0', fs->blksz);

2
fs/ext4/ext4fs.c
View file

@ -55,7 +55,7 @@ int ext4fs_read_file(struct ext2fs_node *node, loff_t pos,
int log2blksz = fs->dev_desc->log2blksz; int log2blksz = fs->dev_desc->log2blksz;
int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz; int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz;
int blocksize = (1 << (log2_fs_blocksize + log2blksz)); int blocksize = (1 << (log2_fs_blocksize + log2blksz));
unsigned int filesize = __le32_to_cpu(node->inode.size); unsigned int filesize = le32_to_cpu(node->inode.size);
lbaint_t previous_block_number = -1; lbaint_t previous_block_number = -1;
lbaint_t delayed_start = 0; lbaint_t delayed_start = 0;
lbaint_t delayed_extent = 0; lbaint_t delayed_extent = 0;

4
include/ext_common.h
View file

@ -49,10 +49,10 @@
#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data)) #define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data))
/* Log2 size of ext2 block in bytes. */ /* Log2 size of ext2 block in bytes. */
#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu \ #define LOG2_BLOCK_SIZE(data) (le32_to_cpu \
(data->sblock.log2_block_size) \ (data->sblock.log2_block_size) \
+ EXT2_MIN_BLOCK_LOG_SIZE) + EXT2_MIN_BLOCK_LOG_SIZE)
#define INODE_SIZE_FILESYSTEM(data) (__le32_to_cpu \ #define INODE_SIZE_FILESYSTEM(data) (le32_to_cpu \
(data->sblock.inode_size)) (data->sblock.inode_size))
#define EXT2_FT_DIR 2 #define EXT2_FT_DIR 2