#include "libbb.h"
#include <linux/fs.h>
#include <linux/ext2_fs.h>
-#include "volume_id/volume_id_internal.h"
#define ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT 0
#define ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX 1
#define STORE_LE(field, value) \
do { \
if (sizeof(field) == 4) \
- field = cpu_to_le32(value); \
+ field = SWAP_LE32(value); \
else if (sizeof(field) == 2) \
- field = cpu_to_le16(value); \
+ field = SWAP_LE16(value); \
else if (sizeof(field) == 1) \
field = (value); \
else \
} while (0)
#define FETCH_LE32(field) \
- (sizeof(field) == 4 ? cpu_to_le32(field) : BUG_wrong_field_size())
+ (sizeof(field) == 4 ? SWAP_LE32(field) : BUG_wrong_field_size())
// All fields are little-endian
struct ext2_dir {
// only for directories, which never need i_size_high).
//
// Standard mke2fs creates a filesystem with 256-byte inodes if it is
-// bigger than 0.5GB. So far, we do not do this.
+// bigger than 0.5GB.
// Standard mke2fs 1.41.9:
// Usage: mke2fs [-c|-l filename] [-b block-size] [-f fragment-size]
-// [-i bytes-per-inode] [-I inode-size] [-J journal-options]
-// [-G meta group size] [-N number-of-inodes]
-// [-m reserved-blocks-percentage] [-o creator-os]
-// [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
-// [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
-// [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
+// [-i bytes-per-inode] [-I inode-size] [-J journal-options]
+// [-G meta group size] [-N number-of-inodes]
+// [-m reserved-blocks-percentage] [-o creator-os]
+// [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
+// [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
+// [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
//
// Options not commented below are taken but silently ignored:
enum {
OPT_b = 1 << 2, // block size, in bytes
OPT_f = 1 << 3,
OPT_i = 1 << 4, // bytes per inode
- OPT_I = 1 << 5,
+ OPT_I = 1 << 5, // custom inode size, in bytes
OPT_J = 1 << 6,
OPT_G = 1 << 7,
OPT_N = 1 << 8,
unsigned i, pos, n;
unsigned bs, bpi;
unsigned blocksize, blocksize_log2;
+ unsigned inodesize, user_inodesize;
unsigned reserved_percent = 5;
unsigned long long kilobytes;
uint32_t nblocks, nblocks_full;
uint32_t inode_table_blocks;
uint32_t lost_and_found_blocks;
time_t timestamp;
- unsigned opts;
const char *label = "";
struct stat st;
struct ext2_super_block *sb; // superblock
struct ext2_dir *dir;
uint8_t *buf;
- opt_complementary = "-1:b+:m+:i+";
- opts = getopt32(argv, "cl:b:f:i:I:J:G:N:m:o:g:L:M:O:r:E:T:U:jnqvFS",
- NULL, &bs, NULL, &bpi, NULL, NULL, NULL, NULL,
- &reserved_percent, NULL, NULL, &label, NULL, NULL, NULL, NULL, NULL, NULL);
+ // using global "option_mask32" instead of local "opts":
+ // we are register starved here
+ opt_complementary = "-1:b+:i+:I+:m+";
+ /*opts =*/ getopt32(argv, "cl:b:f:i:I:J:G:N:m:o:g:L:M:O:r:E:T:U:jnqvFS",
+ /*lbfi:*/ NULL, &bs, NULL, &bpi,
+ /*IJGN:*/ &user_inodesize, NULL, NULL, NULL,
+ /*mogL:*/ &reserved_percent, NULL, NULL, &label,
+ /*MOrE:*/ NULL, NULL, NULL, NULL,
+ /*TU:*/ NULL, NULL);
argv += optind; // argv[0] -- device
- // check the device is a block device
+ // open the device, check the device is a block device
xmove_fd(xopen(argv[0], O_WRONLY), fd);
fstat(fd, &st);
- if (!S_ISBLK(st.st_mode) && !(opts & OPT_F))
- bb_error_msg_and_die("not a block device");
+ if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_F))
+ bb_error_msg_and_die("%s: not a block device", argv[0]);
// check if it is mounted
// N.B. what if we format a file? find_mount_point will return false negative since
- // it is loop block device which mounted!
+ // it is loop block device which is mounted!
if (find_mount_point(argv[0], 0))
bb_error_msg_and_die("can't format mounted filesystem");
- // open the device, get size in kbytes
- if (argv[1]) {
- kilobytes = xatoull(argv[1]);
- // seek past end fails on block devices but works on files
- if (lseek(fd, kilobytes * 1024 - 1, SEEK_SET) != (off_t)-1) {
- xwrite(fd, "", 1); // file grows if needed
- }
- //else {
- // bb_error_msg("warning, block device is smaller");
- //}
- } else {
- kilobytes = (uoff_t)xlseek(fd, 0, SEEK_END) / 1024;
- }
+ // get size in kbytes
+ kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
bytes_per_inode = 16384;
if (kilobytes < 512*1024)
bytes_per_inode = 4096;
if (kilobytes < 3*1024)
bytes_per_inode = 8192;
- if (opts & OPT_i)
+ if (option_mask32 & OPT_i)
bytes_per_inode = bpi;
- // Determine block size
+ // Determine block size and inode size
// block size is a multiple of 1024
+ // inode size is a multiple of 128
blocksize = 1024;
- if (kilobytes >= 512*1024) // mke2fs 1.41.9 compat
+ inodesize = sizeof(struct ext2_inode); // 128
+ if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
blocksize = 4096;
+ inodesize = 256;
+ }
if (EXT2_MAX_BLOCK_SIZE > 4096) {
// kilobytes >> 22 == size in 4gigabyte chunks.
// if size >= 16k gigs, blocksize must be increased.
while ((kilobytes >> 22) >= blocksize)
blocksize *= 2;
}
- if (opts & OPT_b)
+ if (option_mask32 & OPT_b)
blocksize = bs;
if (blocksize < EXT2_MIN_BLOCK_SIZE
|| blocksize > EXT2_MAX_BLOCK_SIZE
) {
bb_error_msg_and_die("blocksize %u is bad", blocksize);
}
+ // Do we have custom inode size?
+ if (option_mask32 & OPT_I) {
+ if (user_inodesize < sizeof(*inode)
+ || user_inodesize > blocksize
+ || (user_inodesize & (user_inodesize - 1)) // not power of 2
+ ) {
+ bb_error_msg("-%c is bad", 'I');
+ } else {
+ inodesize = user_inodesize;
+ }
+ }
+
if ((int32_t)bytes_per_inode < blocksize)
bb_error_msg_and_die("-%c is bad", 'i');
// number of bits in one block, i.e. 8*blocksize
nreserved = (uint64_t)nblocks * reserved_percent / 100;
// N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
- nblocks_full = nblocks;
+ nblocks_full = nblocks;
// If last block group is too small, nblocks may be decreased in order
// to discard it, and control returns here to recalculate some
if (inodes_per_group > blocks_per_group)
inodes_per_group = blocks_per_group;
// adjust inodes per group so they completely fill the inode table blocks in the descriptor
-//incompatibility on images >= 0.5GB:
-//difference in sizeof(*inode) sometimes
-//results in slightly bigger inodes_per_group here
-//compared to standard mke2fs:
- inodes_per_group = (div_roundup(inodes_per_group * sizeof(*inode), blocksize) * blocksize) / sizeof(*inode);
+ inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
// make sure the number of inodes per group is a multiple of 8
inodes_per_group &= ~7;
- inode_table_blocks = div_roundup(inodes_per_group * sizeof(*inode), blocksize);
+ inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
// to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
// and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
, inodes_per_group * ngroups, nblocks
, nreserved, reserved_percent
, first_block
- , group_desc_blocks * (blocksize / sizeof(*gd)) * blocks_per_group
+ , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
, ngroups
, blocks_per_group, blocks_per_group
, inodes_per_group
}
bb_putchar('\n');
- if (opts & OPT_n) {
+ if (option_mask32 & OPT_n) {
if (ENABLE_FEATURE_CLEAN_UP)
close(fd);
return EXIT_SUCCESS;
// fill the superblock
sb = xzalloc(1024);
- STORE_LE(sb->s_rev_level, 1); // revision 1 filesystem
+ STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
-//incompatibility:
-//on images > 0.5GB, standard mke2fs uses 256 byte inodes.
-//we always use 128 byte ones:
- STORE_LE(sb->s_inode_size, sizeof(*inode));
+ STORE_LE(sb->s_inode_size, inodesize);
+ // set "Required extra isize" and "Desired extra isize" fields to 28
+ if (inodesize != sizeof(*inode))
+ STORE_LE(sb->s_reserved[21], 0x001C001C);
STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
// dump root dir inode
STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
- PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * sizeof(*inode),
- buf, sizeof(*inode));
+ PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
+ buf, inodesize);
// dump lost+found dir inode
STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
for (i = 0; i < lost_and_found_blocks; ++i)
STORE_LE(inode->i_block[i], i + n); // use next block
//bb_info_msg("LAST BLOCK USED[%u]", i + n);
- PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * sizeof(*inode),
- buf, sizeof(*inode));
+ PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
+ buf, inodesize);
// dump directories
memset(buf, 0, blocksize);
projects / oweals / busybox.git / blobdiff