ext4_utils: delete make_ext4fs relavant code and script
make_ext4fs has been replaced with mke2fs.
Bug: 64395169
Change-Id: Iad3a8346ca211e4d5a5ab7046c2bdd199292a867
Merged-In: Iad3a8346ca211e4d5a5ab7046c2bdd199292a867
(cherry picked from commit 7c2d21b4c28360f5e058e1632d87028f6b43e90a)
Test: m native-host-cross with clang (added during cherry-pick to
get past repo upload hook).
diff --git a/ext4_utils/Android.bp b/ext4_utils/Android.bp
index ea60212..bdf380e 100644
--- a/ext4_utils/Android.bp
+++ b/ext4_utils/Android.bp
@@ -6,8 +6,6 @@
host_supported: true,
recovery_available: true,
srcs: [
- "make_ext4fs.c",
- "ext4fixup.c",
"ext4_utils.c",
"allocate.c",
"contents.c",
diff --git a/ext4_utils/Android.mk b/ext4_utils/Android.mk
index a970158..ff36a25 100644
--- a/ext4_utils/Android.mk
+++ b/ext4_utils/Android.mk
@@ -7,25 +7,6 @@
#
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := make_ext4fs_main.c
-LOCAL_MODULE := make_ext4fs
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include
-LOCAL_SHARED_LIBRARIES += libcutils
-LOCAL_STATIC_LIBRARIES += \
- libext4_utils \
- libsparse \
- libz
-LOCAL_LDLIBS_windows += -lws2_32
-LOCAL_SHARED_LIBRARIES_darwin += libselinux
-LOCAL_SHARED_LIBRARIES_linux += libselinux
-LOCAL_CFLAGS_darwin := -DHOST
-LOCAL_CFLAGS_linux := -DHOST
-LOCAL_CFLAGS += -Wall -Werror
-include $(BUILD_HOST_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
LOCAL_SRC_FILES := blk_alloc_to_base_fs.c
LOCAL_MODULE := blk_alloc_to_base_fs
LOCAL_SHARED_LIBRARIES := libcutils
@@ -41,62 +22,6 @@
ifneq ($(HOST_OS),windows)
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := make_ext4fs_main.c
-LOCAL_MODULE := make_ext4fs
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/include
-LOCAL_SHARED_LIBRARIES := \
- libcutils \
- libext2_uuid \
- libext4_utils \
- libselinux \
- libz
-LOCAL_CFLAGS := -DREAL_UUID -Wall -Werror
-include $(BUILD_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := setup_fs.c
-LOCAL_MODULE := setup_fs
-LOCAL_SHARED_LIBRARIES += libcutils
-LOCAL_CFLAGS := -Wall -Werror
-include $(BUILD_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := ext4fixup_main.c
-LOCAL_CFLAGS := -Wall -Werror
-LOCAL_MODULE := ext4fixup
-LOCAL_SHARED_LIBRARIES += \
- libext4_utils \
- libsparse \
- libz
-include $(BUILD_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := ext4fixup_main.c
-LOCAL_CFLAGS := -Wall -Werror
-LOCAL_MODULE := ext4fixup
-LOCAL_STATIC_LIBRARIES += \
- libext4_utils \
- libsparse \
- libz
-include $(BUILD_HOST_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := mkuserimg.sh
-LOCAL_SRC_FILES := mkuserimg.sh
-LOCAL_MODULE_CLASS := EXECUTABLES
-# We don't need any additional suffix.
-LOCAL_MODULE_SUFFIX :=
-LOCAL_BUILT_MODULE_STEM := $(notdir $(LOCAL_SRC_FILES))
-LOCAL_IS_HOST_MODULE := true
-include $(BUILD_PREBUILT)
-
-
-include $(CLEAR_VARS)
LOCAL_MODULE := mkuserimg_mke2fs.sh
LOCAL_SRC_FILES := mkuserimg_mke2fs.sh
LOCAL_MODULE_CLASS := EXECUTABLES
diff --git a/ext4_utils/contents.c b/ext4_utils/contents.c
index a2cd3b8..73810f3 100644
--- a/ext4_utils/contents.c
+++ b/ext4_utils/contents.c
@@ -22,7 +22,6 @@
#include "allocate.h"
#include "ext4_utils/ext4_utils.h"
-#include "ext4_utils/make_ext4fs.h"
#include "extent.h"
#include "indirect.h"
diff --git a/ext4_utils/ext4fixup.c b/ext4_utils/ext4fixup.c
deleted file mode 100644
index 508e8bd..0000000
--- a/ext4_utils/ext4fixup.c
+++ /dev/null
@@ -1,817 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ext4fixup.h"
-
-#ifndef _LARGEFILE64_SOURCE
-#define _LARGEFILE64_SOURCE 1
-#endif
-
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <sparse/sparse.h>
-
-#include "allocate.h"
-#include "ext4_utils/ext4_extents.h"
-#include "ext4_utils/ext4_utils.h"
-#include "ext4_utils/make_ext4fs.h"
-
-#ifndef _WIN32
-#include <sys/mman.h>
-#endif
-
-#if defined(__APPLE__) && defined(__MACH__)
-#define lseek64 lseek
-#define off64_t off_t
-#endif
-
-/* The inode block count for a file/directory is in units of 512 byte blocks,
- * _NOT_ the filesystem block size!
- */
-#define INODE_BLOCK_SIZE 512
-
-#define MAX_EXT4_BLOCK_SIZE 4096
-
-/* The two modes the recurse_dir() can be in */
-#define SANITY_CHECK_PASS 1
-#define MARK_INODE_NUMS 2
-#define UPDATE_INODE_NUMS 3
-
-/* Magic numbers to indicate what state the update process is in */
-#define MAGIC_STATE_MARKING_INUMS 0x7000151515565512ll
-#define MAGIC_STATE_UPDATING_INUMS 0x6121131211735123ll
-#define MAGIC_STATE_UPDATING_SB 0x15e1715151558477ll
-
-/* Internal state variables corresponding to the magic numbers */
-#define STATE_UNSET 0
-#define STATE_MARKING_INUMS 1
-#define STATE_UPDATING_INUMS 2
-#define STATE_UPDATING_SB 3
-
-/* Used for automated testing of this programs ability to stop and be restarted wthout error */
-static int bail_phase = 0;
-static int bail_loc = 0;
-static int bail_count = 0;
-static int count = 0;
-
-/* global flags */
-static int verbose = 0;
-static int no_write = 0;
-
-static int new_inodes_per_group = 0;
-
-static int no_write_fixup_state = 0;
-
-static int compute_new_inum(unsigned int old_inum)
-{
- unsigned int group, offset;
-
- group = (old_inum - 1) / info.inodes_per_group;
- offset = (old_inum -1) % info.inodes_per_group;
-
- return (group * new_inodes_per_group) + offset + 1;
-}
-
-static int get_fs_fixup_state(int fd)
-{
- unsigned long long magic;
- int ret, len;
-
- if (no_write) {
- return no_write_fixup_state;
- }
-
- lseek64(fd, 0, SEEK_SET);
- len = read(fd, &magic, sizeof(magic));
- if (len != sizeof(magic)) {
- critical_error("cannot read fixup_state\n");
- }
-
- switch (magic) {
- case MAGIC_STATE_MARKING_INUMS:
- ret = STATE_MARKING_INUMS;
- break;
- case MAGIC_STATE_UPDATING_INUMS:
- ret = STATE_UPDATING_INUMS;
- break;
- case MAGIC_STATE_UPDATING_SB:
- ret = STATE_UPDATING_SB;
- break;
- default:
- ret = STATE_UNSET;
- }
- return ret;
-}
-
-static int set_fs_fixup_state(int fd, int state)
-{
- unsigned long long magic;
- struct ext4_super_block sb;
- int len;
-
- if (no_write) {
- no_write_fixup_state = state;
- return 0;
- }
-
- switch (state) {
- case STATE_MARKING_INUMS:
- magic = MAGIC_STATE_MARKING_INUMS;
- break;
- case STATE_UPDATING_INUMS:
- magic = MAGIC_STATE_UPDATING_INUMS;
- break;
- case STATE_UPDATING_SB:
- magic = MAGIC_STATE_UPDATING_SB;
- break;
- case STATE_UNSET:
- default:
- magic = 0ll;
- break;
- }
-
- lseek64(fd, 0, SEEK_SET);
- len = write(fd, &magic, sizeof(magic));
- if (len != sizeof(magic)) {
- critical_error("cannot write fixup_state\n");
- }
-
- read_sb(fd, &sb);
- if (magic) {
- /* If we are in the process of updating the filesystem, make it unmountable */
- sb.s_desc_size |= 1;
- } else {
- /* we are done, so make the filesystem mountable again */
- sb.s_desc_size &= ~1;
- }
-
- if (!no_write) {
- write_sb(fd, 1024, &sb);
- }
-
- return 0;
-}
-
-static int read_inode(int fd, unsigned int inum, struct ext4_inode *inode)
-{
- unsigned int bg_num, bg_offset;
- off64_t inode_offset;
- int len;
-
- bg_num = (inum-1) / info.inodes_per_group;
- bg_offset = (inum-1) % info.inodes_per_group;
-
- inode_offset = ((unsigned long long)aux_info.bg_desc[bg_num].bg_inode_table * info.block_size) +
- (bg_offset * info.inode_size);
-
- if (lseek64(fd, inode_offset, SEEK_SET) < 0) {
- critical_error_errno("failed to seek to inode %d\n", inum);
- }
-
- len=read(fd, inode, sizeof(*inode));
- if (len != sizeof(*inode)) {
- critical_error_errno("failed to read inode %d\n", inum);
- }
-
- return 0;
-}
-
-static int read_block(int fd, unsigned long long block_num, void *block)
-{
- off64_t off;
- unsigned int len;
-
- off = block_num * info.block_size;
-
- if (lseek64(fd, off, SEEK_SET) , 0) {
- critical_error_errno("failed to seek to block %lld\n", block_num);
- }
-
- len=read(fd, block, info.block_size);
- if (len != info.block_size) {
- critical_error_errno("failed to read block %lld\n", block_num);
- }
-
- return 0;
-}
-
-static int write_block(int fd, unsigned long long block_num, void *block)
-{
- off64_t off;
- unsigned int len;
-
- if (no_write) {
- return 0;
- }
-
- off = block_num * info.block_size;
-
- if (lseek64(fd, off, SEEK_SET) < 0) {
- critical_error_errno("failed to seek to block %lld\n", block_num);
- }
-
- len=write(fd, block, info.block_size);
- if (len != info.block_size) {
- critical_error_errno("failed to write block %lld\n", block_num);
- }
-
- return 0;
-}
-
-static void check_inode_bitmap(int fd, unsigned int bg_num)
-{
- unsigned int inode_bitmap_block_num;
- unsigned char block[MAX_EXT4_BLOCK_SIZE];
- int i, bitmap_updated = 0;
-
- /* Using the bg_num, aux_info.bg_desc[], info.inodes_per_group and
- * new_inodes_per_group, retrieve the inode bitmap, and make sure
- * the bits between the old and new size are clear
- */
- inode_bitmap_block_num = aux_info.bg_desc[bg_num].bg_inode_bitmap;
-
- read_block(fd, inode_bitmap_block_num, block);
-
- for (i = info.inodes_per_group; i < new_inodes_per_group; i++) {
- if (bitmap_get_bit(block, i)) {
- bitmap_clear_bit(block, i);
- bitmap_updated = 1;
- }
- }
-
- if (bitmap_updated) {
- if (verbose) {
- printf("Warning: updated inode bitmap for block group %d\n", bg_num);
- }
- write_block(fd, inode_bitmap_block_num, block);
- }
-
- return;
-}
-
-/* Update the superblock and bgdesc of the specified block group */
-static int update_superblocks_and_bg_desc(int fd, int state)
-{
- off64_t ret;
- struct ext4_super_block sb;
- unsigned int num_block_groups, total_new_inodes;
- unsigned int i;
-
-
- read_sb(fd, &sb);
-
- /* Compute how many more inodes are now available */
- num_block_groups = DIV_ROUND_UP(aux_info.len_blocks, info.blocks_per_group);
- total_new_inodes = num_block_groups * (new_inodes_per_group - sb.s_inodes_per_group);
-
- if (verbose) {
- printf("created %d additional inodes\n", total_new_inodes);
- }
-
- /* Update the free inodes count in each block group descriptor */
- for (i = 0; i < num_block_groups; i++) {
- if (state == STATE_UPDATING_SB) {
- aux_info.bg_desc[i].bg_free_inodes_count += (new_inodes_per_group - sb.s_inodes_per_group);
- }
- check_inode_bitmap(fd, i);
- }
-
- /* First some sanity checks */
- if ((sb.s_inodes_count + total_new_inodes) != (new_inodes_per_group * num_block_groups)) {
- critical_error("Failed sanity check on new inode count\n");
- }
- if (new_inodes_per_group % (info.block_size/info.inode_size)) {
- critical_error("Failed sanity check on new inode per group alignment\n");
- }
-
- /* Update the free inodes count in the superblock */
- sb.s_inodes_count += total_new_inodes;
- sb.s_free_inodes_count += total_new_inodes;
- sb.s_inodes_per_group = new_inodes_per_group;
-
- for (i = 0; i < aux_info.groups; i++) {
- if (ext4_bg_has_super_block(i)) {
- unsigned int sb_offset;
-
- if (i == 0) {
- /* The first superblock is offset by 1K to leave room for boot sectors */
- sb_offset = 1024;
- } else {
- sb_offset = 0;
- }
-
- sb.s_block_group_nr = i;
- /* Don't write out the backup superblocks with the bit set in the s_desc_size
- * which prevents the filesystem from mounting. The bit for the primary
- * superblock will be cleared on the final call to set_fs_fixup_state() */
- if (i != 0) {
- sb.s_desc_size &= ~1;
- }
-
- if (!no_write) {
- write_sb(fd,
- (unsigned long long)i
- * info.blocks_per_group * info.block_size
- + sb_offset,
- &sb);
- }
-
- ret = lseek64(fd, ((unsigned long long)i * info.blocks_per_group * info.block_size) +
- (info.block_size * (aux_info.first_data_block + 1)), SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to block group descriptors");
-
- if (!no_write) {
- ret = write(fd, aux_info.bg_desc, info.block_size * aux_info.bg_desc_blocks);
- if (ret < 0)
- critical_error_errno("failed to write block group descriptors");
- if (ret != (int)info.block_size * (int)aux_info.bg_desc_blocks)
- critical_error("failed to write all of block group descriptors");
- }
- }
- if ((bail_phase == 4) && ((unsigned int)bail_count == i)) {
- critical_error("bailing at phase 4\n");
- }
- }
-
- return 0;
-}
-
-
-static int get_direct_blocks(struct ext4_inode *inode, unsigned long long *block_list,
- unsigned int *count)
-{
- unsigned int i = 0;
- unsigned int ret = 0;
- unsigned int sectors_per_block;
-
- sectors_per_block = info.block_size / INODE_BLOCK_SIZE;
- while ((i < (inode->i_blocks_lo / sectors_per_block)) && (i < EXT4_NDIR_BLOCKS)) {
- block_list[i] = inode->i_block[i];
- i++;
- }
-
- *count += i;
-
- if ((inode->i_blocks_lo / sectors_per_block) > EXT4_NDIR_BLOCKS) {
- ret = 1;
- }
-
- return ret;
-}
-
-static int get_indirect_blocks(int fd, struct ext4_inode *inode,
- unsigned long long *block_list, unsigned int *count)
-{
- unsigned int i;
- unsigned int *indirect_block;
- unsigned int sectors_per_block;
-
- sectors_per_block = info.block_size / INODE_BLOCK_SIZE;
-
- indirect_block = (unsigned int *)malloc(info.block_size);
- if (indirect_block == 0) {
- critical_error("failed to allocate memory for indirect_block\n");
- }
-
- read_block(fd, inode->i_block[EXT4_NDIR_BLOCKS], indirect_block);
-
- for(i = 0; i < (inode->i_blocks_lo / sectors_per_block - EXT4_NDIR_BLOCKS); i++) {
- block_list[EXT4_NDIR_BLOCKS+i] = indirect_block[i];
- }
-
- *count += i;
-
- free(indirect_block);
-
- return 0;
-}
-
-static int get_block_list_indirect(int fd, struct ext4_inode *inode, unsigned long long *block_list)
-{
- unsigned int count=0;
-
- if (get_direct_blocks(inode, block_list, &count)) {
- get_indirect_blocks(fd, inode, block_list, &count);
- }
-
- return count;
-}
-
-static int get_extent_ents(struct ext4_extent_header *ext_hdr, unsigned long long *block_list)
-{
- int i, j;
- struct ext4_extent *extent;
- off64_t fs_block_num;
-
- if (ext_hdr->eh_depth != 0) {
- critical_error("get_extent_ents called with eh_depth != 0\n");
- }
-
- /* The extent entries immediately follow the header, so add 1 to the pointer
- * and cast it to an extent pointer.
- */
- extent = (struct ext4_extent *)(ext_hdr + 1);
-
- for (i = 0; i < ext_hdr->eh_entries; i++) {
- fs_block_num = ((off64_t)extent->ee_start_hi << 32) | extent->ee_start_lo;
- for (j = 0; j < extent->ee_len; j++) {
- block_list[extent->ee_block+j] = fs_block_num+j;
- }
- extent++;
- }
-
- return 0;
-}
-
-static int get_extent_idx(int fd, struct ext4_extent_header *ext_hdr, unsigned long long *block_list)
-{
- int i;
- struct ext4_extent_idx *extent_idx;
- struct ext4_extent_header *tmp_ext_hdr;
- off64_t fs_block_num;
- unsigned char block[MAX_EXT4_BLOCK_SIZE];
-
- /* Sanity check */
- if (ext_hdr->eh_depth == 0) {
- critical_error("get_extent_idx called with eh_depth == 0\n");
- }
-
- /* The extent entries immediately follow the header, so add 1 to the pointer
- * and cast it to an extent pointer.
- */
- extent_idx = (struct ext4_extent_idx *)(ext_hdr + 1);
-
- for (i = 0; i < ext_hdr->eh_entries; i++) {
- fs_block_num = ((off64_t)extent_idx->ei_leaf_hi << 32) | extent_idx->ei_leaf_lo;
- read_block(fd, fs_block_num, block);
- tmp_ext_hdr = (struct ext4_extent_header *)block;
-
- if (tmp_ext_hdr->eh_depth == 0) {
- get_extent_ents(tmp_ext_hdr, block_list); /* leaf node, fill in block_list */
- } else {
- get_extent_idx(fd, tmp_ext_hdr, block_list); /* recurse down the tree */
- }
- }
-
- return 0;
-}
-
-static int get_block_list_extents(int fd, struct ext4_inode *inode, unsigned long long *block_list)
-{
- struct ext4_extent_header *extent_hdr;
-
- extent_hdr = (struct ext4_extent_header *)inode->i_block;
-
- if (extent_hdr->eh_magic != EXT4_EXT_MAGIC) {
- critical_error("extent header has unexpected magic value 0x%4.4x\n",
- extent_hdr->eh_magic);
- }
-
- if (extent_hdr->eh_depth == 0) {
- get_extent_ents((struct ext4_extent_header *)inode->i_block, block_list);
- return 0;
- }
-
- get_extent_idx(fd, (struct ext4_extent_header *)inode->i_block, block_list);
-
- return 0;
-}
-
-static int is_entry_dir(int fd, struct ext4_dir_entry_2 *dirp, int pass)
-{
- struct ext4_inode inode;
- int ret = 0;
-
- if (dirp->file_type == EXT4_FT_DIR) {
- ret = 1;
- } else if (dirp->file_type == EXT4_FT_UNKNOWN) {
- /* Somebody was too lazy to fill in the dir entry,
- * so we have to go fetch it from the inode. Grrr.
- */
- /* if UPDATE_INODE_NUMS pass and the inode high bit is not
- * set return false so we don't recurse down the tree that is
- * already updated. Otherwise, fetch inode, and return answer.
- */
- if ((pass == UPDATE_INODE_NUMS) && !(dirp->inode & 0x80000000)) {
- ret = 0;
- } else {
- read_inode(fd, (dirp->inode & 0x7fffffff), &inode);
- if (S_ISDIR(inode.i_mode)) {
- ret = 1;
- }
- }
- }
-
- return ret;
-}
-
-static int recurse_dir(int fd, struct ext4_inode *inode, char *dirbuf, int dirsize, int mode)
-{
- unsigned long long *block_list;
- unsigned int num_blocks;
- struct ext4_dir_entry_2 *dirp, *prev_dirp = 0;
- char name[256];
- unsigned int i, leftover_space, is_dir;
- struct ext4_inode tmp_inode;
- int tmp_dirsize;
- char *tmp_dirbuf;
-
- switch (mode) {
- case SANITY_CHECK_PASS:
- case MARK_INODE_NUMS:
- case UPDATE_INODE_NUMS:
- break;
- default:
- critical_error("recurse_dir() called witn unknown mode!\n");
- }
-
- if (dirsize % info.block_size) {
- critical_error("dirsize %d not a multiple of block_size %d. This is unexpected!\n",
- dirsize, info.block_size);
- }
-
- num_blocks = dirsize / info.block_size;
-
- block_list = malloc((num_blocks + 1) * sizeof(*block_list));
- if (block_list == 0) {
- critical_error("failed to allocate memory for block_list\n");
- }
-
- if (inode->i_flags & EXT4_EXTENTS_FL) {
- get_block_list_extents(fd, inode, block_list);
- } else {
- /* A directory that requires doubly or triply indirect blocks in huge indeed,
- * and will almost certainly not exist, especially since make_ext4fs only creates
- * directories with extents, and the kernel will too, but check to make sure the
- * directory is not that big and give an error if so. Our limit is 12 direct blocks,
- * plus block_size/4 singly indirect blocks, which for a filesystem with 4K blocks
- * is a directory 1036 blocks long, or 4,243,456 bytes long! Assuming an average
- * filename length of 20 (which I think is generous) thats 20 + 8 bytes overhead
- * per entry, or 151,552 entries in the directory!
- */
- if (num_blocks > (info.block_size / 4 + EXT4_NDIR_BLOCKS)) {
- critical_error("Non-extent based directory is too big!\n");
- }
- get_block_list_indirect(fd, inode, block_list);
- }
-
- /* Read in all the blocks for this directory */
- for (i = 0; i < num_blocks; i++) {
- read_block(fd, block_list[i], dirbuf + (i * info.block_size));
- }
-
- dirp = (struct ext4_dir_entry_2 *)dirbuf;
- while (dirp < (struct ext4_dir_entry_2 *)(dirbuf + dirsize)) {
- count++;
- leftover_space = (char *)(dirbuf + dirsize) - (char *)dirp;
- if (((mode == SANITY_CHECK_PASS) || (mode == UPDATE_INODE_NUMS)) &&
- (leftover_space <= 8) && prev_dirp) {
- /* This is a bug in an older version of make_ext4fs, where it
- * didn't properly include the rest of the block in rec_len.
- * Update rec_len on the previous entry to include the rest of
- * the block and exit the loop.
- */
- if (verbose) {
- printf("fixing up short rec_len for diretory entry for %s\n", name);
- }
- prev_dirp->rec_len += leftover_space;
- break;
- }
-
- if (dirp->inode == 0) {
- /* This is the last entry in the directory */
- break;
- }
-
- strncpy(name, dirp->name, dirp->name_len);
- name[dirp->name_len]='\0';
-
- /* Only recurse on pass UPDATE_INODE_NUMS if the high bit is set.
- * Otherwise, this inode entry has already been updated
- * and we'll do the wrong thing. Also don't recurse on . or ..,
- * and certainly not on non-directories!
- */
- /* Hrm, looks like filesystems made by fastboot on stingray set the file_type
- * flag, but the lost+found directory has the type set to Unknown, which
- * seems to imply I need to read the inode and get it.
- */
- is_dir = is_entry_dir(fd, dirp, mode);
- if ( is_dir && (strcmp(name, ".") && strcmp(name, "..")) &&
- ((mode == SANITY_CHECK_PASS) || (mode == MARK_INODE_NUMS) ||
- ((mode == UPDATE_INODE_NUMS) && (dirp->inode & 0x80000000))) ) {
- /* A directory! Recurse! */
- read_inode(fd, dirp->inode & 0x7fffffff, &tmp_inode);
-
- if (!S_ISDIR(tmp_inode.i_mode)) {
- critical_error("inode %d for name %s does not point to a directory\n",
- dirp->inode & 0x7fffffff, name);
- }
- if (verbose) {
- printf("inode %d %s use extents\n", dirp->inode & 0x7fffffff,
- (tmp_inode.i_flags & EXT4_EXTENTS_FL) ? "does" : "does not");
- }
-
- tmp_dirsize = tmp_inode.i_blocks_lo * INODE_BLOCK_SIZE;
- if (verbose) {
- printf("dir size = %d bytes\n", tmp_dirsize);
- }
-
- tmp_dirbuf = malloc(tmp_dirsize);
- if (tmp_dirbuf == 0) {
- critical_error("failed to allocate memory for tmp_dirbuf\n");
- }
-
- recurse_dir(fd, &tmp_inode, tmp_dirbuf, tmp_dirsize, mode);
-
- free(tmp_dirbuf);
- }
-
- if (verbose) {
- if (is_dir) {
- printf("Directory %s\n", name);
- } else {
- printf("Non-directory %s\n", name);
- }
- }
-
- /* Process entry based on current mode. Either set high bit or change inode number */
- if (mode == MARK_INODE_NUMS) {
- dirp->inode |= 0x80000000;
- } else if (mode == UPDATE_INODE_NUMS) {
- if (dirp->inode & 0x80000000) {
- dirp->inode = compute_new_inum(dirp->inode & 0x7fffffff);
- }
- }
-
- if ((bail_phase == mode) && (bail_loc == 1) && (bail_count == count)) {
- critical_error("Bailing at phase %d, loc 1 and count %d\n", mode, count);
- }
-
- /* Point dirp at the next entry */
- prev_dirp = dirp;
- dirp = (struct ext4_dir_entry_2*)((char *)dirp + dirp->rec_len);
- }
-
- /* Write out all the blocks for this directory */
- for (i = 0; i < num_blocks; i++) {
- write_block(fd, block_list[i], dirbuf + (i * info.block_size));
- if ((bail_phase == mode) && (bail_loc == 2) && (bail_count <= count)) {
- critical_error("Bailing at phase %d, loc 2 and count %d\n", mode, count);
- }
- }
-
- free(block_list);
-
- return 0;
-}
-
-int ext4fixup(char *fsdev)
-{
- return ext4fixup_internal(fsdev, 0, 0, 0, 0, 0);
-}
-
-int ext4fixup_internal(char *fsdev, int v_flag, int n_flag,
- int stop_phase, int stop_loc, int stop_count)
-{
- int fd;
- struct ext4_inode root_inode;
- unsigned int dirsize;
- char *dirbuf;
-
- if (setjmp(setjmp_env))
- return EXIT_FAILURE; /* Handle a call to longjmp() */
-
- verbose = v_flag;
- no_write = n_flag;
-
- bail_phase = stop_phase;
- bail_loc = stop_loc;
- bail_count = stop_count;
-
- fd = open(fsdev, O_RDWR);
-
- if (fd < 0)
- critical_error_errno("failed to open filesystem image");
-
- read_ext(fd, verbose);
-
- if (info.feat_incompat & EXT4_FEATURE_INCOMPAT_RECOVER) {
- critical_error("Filesystem needs recovery first, mount and unmount to do that\n");
- }
-
- /* Clear the low bit which is set while this tool is in progress.
- * If the tool crashes, it will still be set when we restart.
- * The low bit is set to make the filesystem unmountable while
- * it is being fixed up. Also allow 0, which means the old ext2
- * size is in use.
- */
- if (((aux_info.sb->s_desc_size & ~1) != sizeof(struct ext2_group_desc)) &&
- ((aux_info.sb->s_desc_size & ~1) != 0))
- critical_error("error: bg_desc_size != sizeof(struct ext2_group_desc)\n");
-
- if ((info.feat_incompat & EXT4_FEATURE_INCOMPAT_FILETYPE) == 0) {
- critical_error("Expected filesystem to have filetype flag set\n");
- }
-
-#if 0 // If we have to fix the directory rec_len issue, we can't use this check
- /* Check to see if the inodes/group is copacetic */
- if (info.inodes_per_blockgroup % (info.block_size/info.inode_size) == 0) {
- /* This filesystem has either already been updated, or was
- * made correctly.
- */
- if (verbose) {
- printf("%s: filesystem correct, no work to do\n", me);
- }
- exit(0);
- }
-#endif
-
- /* Compute what the new value of inodes_per_blockgroup will be when we're done */
- new_inodes_per_group=EXT4_ALIGN(info.inodes_per_group,(info.block_size/info.inode_size));
-
- read_inode(fd, EXT4_ROOT_INO, &root_inode);
-
- if (!S_ISDIR(root_inode.i_mode)) {
- critical_error("root inode %d does not point to a directory\n", EXT4_ROOT_INO);
- }
- if (verbose) {
- printf("inode %d %s use extents\n", EXT4_ROOT_INO,
- (root_inode.i_flags & EXT4_EXTENTS_FL) ? "does" : "does not");
- }
-
- dirsize = root_inode.i_blocks_lo * INODE_BLOCK_SIZE;
- if (verbose) {
- printf("root dir size = %d bytes\n", dirsize);
- }
-
- dirbuf = malloc(dirsize);
- if (dirbuf == 0) {
- critical_error("failed to allocate memory for dirbuf\n");
- }
-
- /* Perform a sanity check pass first, try to catch any errors that will occur
- * before we actually change anything, so we don't leave a filesystem in a
- * corrupted, unrecoverable state. Set no_write, make it quiet, and do a recurse
- * pass and a update_superblock pass. Set flags back to requested state when done.
- * Only perform sanity check if the state is unset. If the state is _NOT_ unset,
- * then the tool has already been run and interrupted, and it presumably ran and
- * passed sanity checked before it got interrupted. It is _NOT_ safe to run sanity
- * check if state is unset because it assumes inodes are to be computed using the
- * old inodes/group, but some inode numbers may be updated to the new number.
- */
- if (get_fs_fixup_state(fd) == STATE_UNSET) {
- verbose = 0;
- no_write = 1;
- recurse_dir(fd, &root_inode, dirbuf, dirsize, SANITY_CHECK_PASS);
- update_superblocks_and_bg_desc(fd, STATE_UNSET);
- verbose = v_flag;
- no_write = n_flag;
-
- set_fs_fixup_state(fd, STATE_MARKING_INUMS);
- }
-
- if (get_fs_fixup_state(fd) == STATE_MARKING_INUMS) {
- count = 0; /* Reset debugging counter */
- if (!recurse_dir(fd, &root_inode, dirbuf, dirsize, MARK_INODE_NUMS)) {
- set_fs_fixup_state(fd, STATE_UPDATING_INUMS);
- }
- }
-
- if (get_fs_fixup_state(fd) == STATE_UPDATING_INUMS) {
- count = 0; /* Reset debugging counter */
- if (!recurse_dir(fd, &root_inode, dirbuf, dirsize, UPDATE_INODE_NUMS)) {
- set_fs_fixup_state(fd, STATE_UPDATING_SB);
- }
- }
-
- if (get_fs_fixup_state(fd) == STATE_UPDATING_SB) {
- /* set the new inodes/blockgroup number,
- * and sets the state back to 0.
- */
- if (!update_superblocks_and_bg_desc(fd, STATE_UPDATING_SB)) {
- set_fs_fixup_state(fd, STATE_UNSET);
- }
- }
-
- close(fd);
- free(dirbuf);
-
- return 0;
-}
diff --git a/ext4_utils/ext4fixup.h b/ext4_utils/ext4fixup.h
deleted file mode 100644
index 6ea2113..0000000
--- a/ext4_utils/ext4fixup.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-int ext4fixup(char *fsdev);
-int ext4fixup_internal(char *fsdev, int v_flag, int n_flag,
- int stop_phase, int stop_loc, int stop_count);
-
diff --git a/ext4_utils/ext4fixup_main.c b/ext4_utils/ext4fixup_main.c
deleted file mode 100644
index f4428cb..0000000
--- a/ext4_utils/ext4fixup_main.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <libgen.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "ext4fixup.h"
-
-static void usage(char *me)
-{
- fprintf(stderr, "%s: usage: %s [-vn] <image or block device>\n", me, me);
-}
-
-int main(int argc, char **argv)
-{
- int opt;
- int verbose = 0;
- int no_write = 0;
- char *fsdev;
- char *me;
- int stop_phase = 0, stop_loc = 0, stop_count = 0;
-
- me = basename(argv[0]);
-
- while ((opt = getopt(argc, argv, "vnd:")) != -1) {
- switch (opt) {
- case 'v':
- verbose = 1;
- break;
- case 'n':
- no_write = 1;
- break;
- case 'd':
- sscanf(optarg, "%d,%d,%d", &stop_phase, &stop_loc, &stop_count);
- break;
- }
- }
-
- if (optind >= argc) {
- fprintf(stderr, "expected image or block device after options\n");
- usage(me);
- exit(EXIT_FAILURE);
- }
-
- fsdev = argv[optind++];
-
- if (optind < argc) {
- fprintf(stderr, "Unexpected argument: %s\n", argv[optind]);
- usage(me);
- exit(EXIT_FAILURE);
- }
-
- return ext4fixup_internal(fsdev, verbose, no_write, stop_phase, stop_loc, stop_count);
-}
diff --git a/ext4_utils/include/ext4_utils/ext4_utils.h b/ext4_utils/include/ext4_utils/ext4_utils.h
index 17a8056..12d2c0c 100644
--- a/ext4_utils/include/ext4_utils/ext4_utils.h
+++ b/ext4_utils/include/ext4_utils/ext4_utils.h
@@ -162,14 +162,6 @@
typedef void (*fs_config_func_t)(const char *path, int dir, const char *target_out_path,
unsigned *uid, unsigned *gid, unsigned *mode, uint64_t *capabilities);
-struct selabel_handle;
-
-int make_ext4fs_internal(int fd, const char *directory, const char *_target_out_directory,
- const char *mountpoint, fs_config_func_t fs_config_func, int gzip,
- int sparse, int crc, int wipe, int real_uuid,
- struct selabel_handle *sehnd, int verbose, time_t fixed_time,
- FILE* block_list_file, FILE* base_alloc_file_in, FILE* base_alloc_file_out);
-
int read_ext(int fd, int verbose);
#ifdef __cplusplus
diff --git a/ext4_utils/include/ext4_utils/make_ext4fs.h b/ext4_utils/include/ext4_utils/make_ext4fs.h
deleted file mode 100644
index 44e9481..0000000
--- a/ext4_utils/include/ext4_utils/make_ext4fs.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _MAKE_EXT4FS_H_
-#define _MAKE_EXT4FS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct selabel_handle;
-
-int make_ext4fs(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd);
-int make_ext4fs_directory_align(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory, unsigned eraseblk,
- unsigned logicalblk);
-int make_ext4fs_directory(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory);
-int make_ext4fs_sparse_fd(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd);
-int make_ext4fs_sparse_fd_directory(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory);
-int make_ext4fs_sparse_fd_align(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- unsigned eraseblk, unsigned logicalblk);
-int make_ext4fs_sparse_fd_directory_align(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory, unsigned eraseblk, unsigned logicalblk);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/ext4_utils/make_ext4fs.c b/ext4_utils/make_ext4fs.c
deleted file mode 100644
index cadf55c..0000000
--- a/ext4_utils/make_ext4fs.c
+++ /dev/null
@@ -1,931 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ext4_utils/make_ext4fs.h"
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <assert.h>
-#include <dirent.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <libgen.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <sparse/sparse.h>
-
-#include "allocate.h"
-#include "contents.h"
-#include "ext4_utils/ext4_utils.h"
-#include "ext4_utils/wipe.h"
-
-#ifdef _WIN32
-
-#include <winsock2.h>
-
-/* These match the Linux definitions of these flags.
- L_xx is defined to avoid conflicting with the win32 versions.
-*/
-#undef S_IRWXU
-#undef S_IRGRP
-#undef S_IWGRP
-#undef S_IXGRP
-#undef S_IRWXG
-#undef S_IROTH
-#undef S_IWOTH
-#undef S_IXOTH
-#undef S_IRWXO
-#undef S_ISUID
-#undef S_ISGID
-#undef S_ISVTX
-
-#define L_S_IRUSR 00400
-#define L_S_IWUSR 00200
-#define L_S_IXUSR 00100
-#define S_IRWXU (L_S_IRUSR | L_S_IWUSR | L_S_IXUSR)
-#define S_IRGRP 00040
-#define S_IWGRP 00020
-#define S_IXGRP 00010
-#define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
-#define S_IROTH 00004
-#define S_IWOTH 00002
-#define S_IXOTH 00001
-#define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
-#define S_ISUID 0004000
-#define S_ISGID 0002000
-#define S_ISVTX 0001000
-
-#else
-
-#include <selinux/selinux.h>
-#include <selinux/label.h>
-
-#define O_BINARY 0
-
-#endif
-
-#undef MAX_PATH
-#define MAX_PATH 4096
-#define MAX_BLK_MAPPING_STR 1000
-
-const int blk_file_major_ver = 1;
-const int blk_file_minor_ver = 0;
-const char *blk_file_header_fmt = "Base EXT4 version %d.%d";
-
-/* TODO: Not implemented:
- Allocating blocks in the same block group as the file inode
- Hash or binary tree directories
- Special files: sockets, devices, fifos
- */
-
-static int filter_dot(const struct dirent *d)
-{
- return (strcmp(d->d_name, "..") && strcmp(d->d_name, "."));
-}
-
-static u32 build_default_directory_structure(const char *dir_path,
- struct selabel_handle *sehnd)
-{
- u32 inode;
- u32 root_inode;
- struct dentry dentries = {
- .filename = "lost+found",
- .file_type = EXT4_FT_DIR,
- .mode = S_IRWXU,
- .uid = 0,
- .gid = 0,
- .mtime = 0,
- };
- root_inode = make_directory(0, 1, &dentries, 1);
- inode = make_directory(root_inode, 0, NULL, 0);
- *dentries.inode = inode;
- inode_set_permissions(inode, dentries.mode,
- dentries.uid, dentries.gid, dentries.mtime);
-
-#ifndef _WIN32
- if (sehnd) {
- char *path = NULL;
- char *secontext = NULL;
-
- asprintf(&path, "%slost+found", dir_path);
- if (selabel_lookup(sehnd, &secontext, path, S_IFDIR) < 0) {
- error("cannot lookup security context for %s", path);
- } else {
- inode_set_selinux(inode, secontext);
- freecon(secontext);
- }
- free(path);
- }
-#endif
-
- return root_inode;
-}
-
-#ifndef _WIN32
-/* Read a local directory and create the same tree in the generated filesystem.
- Calls itself recursively with each directory in the given directory.
- full_path is an absolute or relative path, with a trailing slash, to the
- directory on disk that should be copied, or NULL if this is a directory
- that does not exist on disk (e.g. lost+found).
- dir_path is an absolute path, with trailing slash, to the same directory
- if the image were mounted at the specified mount point */
-static u32 build_directory_structure(const char *full_path, const char *dir_path, const char *target_out_path,
- u32 dir_inode, fs_config_func_t fs_config_func,
- struct selabel_handle *sehnd, int verbose, time_t fixed_time)
-{
- int entries = 0;
- struct dentry *dentries;
- struct dirent **namelist = NULL;
- struct stat stat;
- int ret;
- int i, j;
- u32 inode;
- u32 entry_inode;
- u32 dirs = 0;
- bool needs_lost_and_found = false;
-
- if (full_path) {
- entries = scandir(full_path, &namelist, filter_dot, (void*)alphasort);
- if (entries < 0) {
-#ifdef __GLIBC__
- /* The scandir function implemented in glibc has a bug that makes it
- erroneously fail with ENOMEM under certain circumstances.
- As a workaround we can retry the scandir call with the same arguments.
- GLIBC BZ: https://sourceware.org/bugzilla/show_bug.cgi?id=17804 */
- if (errno == ENOMEM)
- entries = scandir(full_path, &namelist, filter_dot, (void*)alphasort);
-#endif
- if (entries < 0) {
- error_errno("scandir");
- return EXT4_ALLOCATE_FAILED;
- }
- }
- }
-
- if (dir_inode == 0) {
- /* root directory, check if lost+found already exists */
- for (i = 0; i < entries; i++)
- if (strcmp(namelist[i]->d_name, "lost+found") == 0)
- break;
- if (i == entries)
- needs_lost_and_found = true;
- }
-
- dentries = calloc(entries, sizeof(struct dentry));
- if (dentries == NULL)
- critical_error_errno("malloc");
-
- for (i = j = 0; i < entries; i++, j++) {
- dentries[i].filename = strdup(namelist[j]->d_name);
- if (dentries[i].filename == NULL)
- critical_error_errno("strdup");
-
- asprintf(&dentries[i].path, "%s%s", dir_path, namelist[j]->d_name);
- asprintf(&dentries[i].full_path, "%s%s", full_path, namelist[j]->d_name);
-
- free(namelist[j]);
-
- ret = lstat(dentries[i].full_path, &stat);
- if (ret < 0) {
- error_errno("lstat");
- free(dentries[i].filename);
- i--;
- continue;
- }
-
- dentries[i].size = stat.st_size;
- dentries[i].mode = stat.st_mode & (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO);
- if (fixed_time == -1) {
- dentries[i].mtime = stat.st_mtime;
- } else {
- dentries[i].mtime = fixed_time;
- }
- uint64_t capabilities;
- if (fs_config_func != NULL) {
-#ifdef ANDROID
- unsigned int mode = 0;
- unsigned int uid = 0;
- unsigned int gid = 0;
- int dir = S_ISDIR(stat.st_mode);
- fs_config_func(dentries[i].path, dir, target_out_path, &uid, &gid, &mode, &capabilities);
- dentries[i].mode = mode;
- dentries[i].uid = uid;
- dentries[i].gid = gid;
- dentries[i].capabilities = capabilities;
-#else
- error("can't set android permissions - built without android support");
-#endif
- }
-#ifndef _WIN32
- if (sehnd) {
- if (selabel_lookup(sehnd, &dentries[i].secon, dentries[i].path, stat.st_mode) < 0) {
- error("cannot lookup security context for %s", dentries[i].path);
- }
-
- if (dentries[i].secon && verbose)
- printf("Labeling %s as %s\n", dentries[i].path, dentries[i].secon);
- }
-#endif
-
- if (S_ISREG(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_REG_FILE;
- } else if (S_ISDIR(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_DIR;
- dirs++;
- } else if (S_ISCHR(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_CHRDEV;
- } else if (S_ISBLK(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_BLKDEV;
- } else if (S_ISFIFO(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_FIFO;
- } else if (S_ISSOCK(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_SOCK;
- } else if (S_ISLNK(stat.st_mode)) {
- dentries[i].file_type = EXT4_FT_SYMLINK;
- dentries[i].link = calloc(info.block_size, 1);
- readlink(dentries[i].full_path, dentries[i].link, info.block_size - 1);
- } else {
- error("unknown file type on %s", dentries[i].path);
- free(dentries[i].filename);
- i--;
- }
- }
- entries -= j - i;
- free(namelist);
-
- if (needs_lost_and_found) {
- /* insert a lost+found directory at the beginning of the dentries */
- struct dentry *tmp = calloc(entries + 1, sizeof(struct dentry));
- memset(tmp, 0, sizeof(struct dentry));
- memcpy(tmp + 1, dentries, entries * sizeof(struct dentry));
- dentries = tmp;
-
- dentries[0].filename = strdup("lost+found");
- asprintf(&dentries[0].path, "%slost+found", dir_path);
- dentries[0].full_path = NULL;
- dentries[0].size = 0;
- dentries[0].mode = S_IRWXU;
- dentries[0].file_type = EXT4_FT_DIR;
- dentries[0].uid = 0;
- dentries[0].gid = 0;
- if (sehnd) {
- if (selabel_lookup(sehnd, &dentries[0].secon, dentries[0].path, dentries[0].mode) < 0)
- error("cannot lookup security context for %s", dentries[0].path);
- }
- entries++;
- dirs++;
- }
-
- inode = make_directory(dir_inode, entries, dentries, dirs);
-
- for (i = 0; i < entries; i++) {
- if (dentries[i].file_type == EXT4_FT_REG_FILE) {
- entry_inode = make_file(dentries[i].full_path, dentries[i].size);
- } else if (dentries[i].file_type == EXT4_FT_DIR) {
- char *subdir_full_path = NULL;
- char *subdir_dir_path;
- if (dentries[i].full_path) {
- ret = asprintf(&subdir_full_path, "%s/", dentries[i].full_path);
- if (ret < 0)
- critical_error_errno("asprintf");
- }
- ret = asprintf(&subdir_dir_path, "%s/", dentries[i].path);
- if (ret < 0)
- critical_error_errno("asprintf");
- entry_inode = build_directory_structure(subdir_full_path, subdir_dir_path, target_out_path,
- inode, fs_config_func, sehnd, verbose, fixed_time);
- free(subdir_full_path);
- free(subdir_dir_path);
- } else if (dentries[i].file_type == EXT4_FT_SYMLINK) {
- entry_inode = make_link(dentries[i].link);
- } else {
- error("unknown file type on %s", dentries[i].path);
- entry_inode = 0;
- }
- *dentries[i].inode = entry_inode;
-
- ret = inode_set_permissions(entry_inode, dentries[i].mode,
- dentries[i].uid, dentries[i].gid,
- dentries[i].mtime);
- if (ret)
- error("failed to set permissions on %s\n", dentries[i].path);
-
- /*
- * It's important to call inode_set_selinux() before
- * inode_set_capabilities(). Extended attributes need to
- * be stored sorted order, and we guarantee this by making
- * the calls in the proper order.
- * Please see xattr_assert_sane() in contents.c
- */
- ret = inode_set_selinux(entry_inode, dentries[i].secon);
- if (ret)
- error("failed to set SELinux context on %s\n", dentries[i].path);
- ret = inode_set_capabilities(entry_inode, dentries[i].capabilities);
- if (ret)
- error("failed to set capability on %s\n", dentries[i].path);
-
- free(dentries[i].path);
- free(dentries[i].full_path);
- free(dentries[i].link);
- free((void *)dentries[i].filename);
- free(dentries[i].secon);
- }
-
- free(dentries);
- return inode;
-}
-#endif
-
-static u32 compute_block_size()
-{
- return 4096;
-}
-
-static u32 compute_journal_blocks()
-{
- u32 journal_blocks = DIV_ROUND_UP(info.len, info.block_size) / 64;
- if (journal_blocks < 1024)
- journal_blocks = 1024;
- if (journal_blocks > 32768)
- journal_blocks = 32768;
- return journal_blocks;
-}
-
-static u32 compute_blocks_per_group()
-{
- return info.block_size * 8;
-}
-
-static u32 compute_inodes()
-{
- return DIV_ROUND_UP(info.len, info.block_size) / 4;
-}
-
-static u32 compute_inodes_per_group()
-{
- u32 blocks = DIV_ROUND_UP(info.len, info.block_size);
- u32 block_groups = DIV_ROUND_UP(blocks, info.blocks_per_group);
- u32 inodes = DIV_ROUND_UP(info.inodes, block_groups);
- inodes = EXT4_ALIGN(inodes, (info.block_size / info.inode_size));
-
- /* After properly rounding up the number of inodes/group,
- * make sure to update the total inodes field in the info struct.
- */
- info.inodes = inodes * block_groups;
-
- return inodes;
-}
-
-static u32 compute_bg_desc_reserve_blocks()
-{
- u32 blocks = DIV_ROUND_UP(info.len, info.block_size);
- u32 block_groups = DIV_ROUND_UP(blocks, info.blocks_per_group);
- u32 bg_desc_blocks = DIV_ROUND_UP(block_groups * sizeof(struct ext2_group_desc),
- info.block_size);
-
- u32 bg_desc_reserve_blocks =
- DIV_ROUND_UP(block_groups * 1024 * sizeof(struct ext2_group_desc),
- info.block_size) - bg_desc_blocks;
-
- if (bg_desc_reserve_blocks > info.block_size / sizeof(u32))
- bg_desc_reserve_blocks = info.block_size / sizeof(u32);
-
- return bg_desc_reserve_blocks;
-}
-
-void reset_ext4fs_info() {
- // Reset all the global data structures used by make_ext4fs so it
- // can be called again.
- memset(&info, 0, sizeof(info));
- memset(&aux_info, 0, sizeof(aux_info));
-
- if (ext4_sparse_file) {
- sparse_file_destroy(ext4_sparse_file);
- ext4_sparse_file = NULL;
- }
-}
-
-int make_ext4fs_sparse_fd(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd)
-{
- return make_ext4fs_sparse_fd_align(fd, len, mountpoint, sehnd, 0, 0);
-}
-
-int make_ext4fs_sparse_fd_align(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- unsigned eraseblk, unsigned logicalblk)
-{
- return make_ext4fs_sparse_fd_directory_align(fd, len, mountpoint, sehnd, NULL,
- eraseblk, logicalblk);
-}
-
-int make_ext4fs_sparse_fd_directory(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory)
-{
- return make_ext4fs_sparse_fd_directory_align(fd, len, mountpoint, sehnd, directory, 0, 0);
-}
-
-int make_ext4fs_sparse_fd_directory_align(int fd, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory, unsigned eraseblk, unsigned logicalblk)
-{
- reset_ext4fs_info();
- info.len = len;
- info.flash_erase_block_size = eraseblk;
- info.flash_logical_block_size = logicalblk;
-
- return make_ext4fs_internal(fd, directory, NULL, mountpoint, NULL,
- 0, 1, 0, 0, 0,
- sehnd, 0, -1, NULL, NULL, NULL);
-}
-
-int make_ext4fs(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd)
-{
- return make_ext4fs_directory(filename, len, mountpoint, sehnd, NULL);
-}
-
-int make_ext4fs_directory(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory)
-{
- return make_ext4fs_directory_align(filename, len, mountpoint, sehnd, directory, 0, 0);
-}
-
-int make_ext4fs_directory_align(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd,
- const char *directory, unsigned eraseblk,
- unsigned logicalblk)
-{
- int fd;
- int status;
-
- reset_ext4fs_info();
- info.len = len;
- info.flash_erase_block_size = eraseblk;
- info.flash_logical_block_size = logicalblk;
-
- fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
- if (fd < 0) {
- error_errno("open");
- return EXIT_FAILURE;
- }
-
- status = make_ext4fs_internal(fd, directory, NULL, mountpoint, NULL,
- 0, 0, 0, 1, 0,
- sehnd, 0, -1, NULL, NULL, NULL);
- close(fd);
-
- return status;
-}
-
-/* return a newly-malloc'd string that is a copy of str. The new string
- is guaranteed to have a trailing slash. If absolute is true, the new string
- is also guaranteed to have a leading slash.
-*/
-static char *canonicalize_slashes(const char *str, bool absolute)
-{
- char *ret;
- int len = strlen(str);
- int newlen = len;
- char *ptr;
-
- if (len == 0) {
- if (absolute)
- return strdup("/");
- else
- return strdup("");
- }
-
- if (str[0] != '/' && absolute) {
- newlen++;
- }
- if (str[len - 1] != '/') {
- newlen++;
- }
- ret = malloc(newlen + 1);
- if (!ret) {
- critical_error("malloc");
- }
-
- ptr = ret;
- if (str[0] != '/' && absolute) {
- *ptr++ = '/';
- }
-
- strcpy(ptr, str);
- ptr += len;
-
- if (str[len - 1] != '/') {
- *ptr++ = '/';
- }
-
- if (ptr != ret + newlen) {
- critical_error("assertion failed\n");
- }
-
- *ptr = '\0';
-
- return ret;
-}
-
-static char *canonicalize_abs_slashes(const char *str)
-{
- return canonicalize_slashes(str, true);
-}
-
-static char *canonicalize_rel_slashes(const char *str)
-{
- return canonicalize_slashes(str, false);
-}
-
-static int compare_chunks(const void* chunk1, const void* chunk2) {
- struct region* c1 = (struct region*) chunk1;
- struct region* c2 = (struct region*) chunk2;
- return c1->block - c2->block;
-}
-
-static int get_block_group(u32 block) {
- unsigned int i, group = 0;
-
- for(i = 0; i < aux_info.groups; i++) {
- if (block >= aux_info.bgs[i].first_block)
- group = i;
- else
- break;
- }
- return group;
-}
-
-static void extract_base_fs_allocations(const char *directory, const char *mountpoint,
- FILE* base_alloc_file_in) {
-#define err_msg "base file badly formatted"
-#ifndef _WIN32
- // FORMAT Version 1.0: filename blk_mapping
- const char *base_alloc_file_in_format = "%s %s";
- const int base_file_format_param_count = 2;
-
- char stored_file_name[MAX_PATH], real_file_name[MAX_PATH], file_map[MAX_BLK_MAPPING_STR];
- struct block_allocation *fs_alloc;
- struct block_group_info *bgs = aux_info.bgs;
- int major_version = 0, minor_version = 0;
- unsigned int i;
- char *base_file_line = NULL;
- size_t base_file_line_len = 0;
-
- printf("[v%d.%d] Generating an Incremental EXT4 image\n",
- blk_file_major_ver, blk_file_minor_ver);
- if (base_fs_allocations == NULL)
- base_fs_allocations = create_allocation();
- fs_alloc = base_fs_allocations;
-
- fscanf(base_alloc_file_in, blk_file_header_fmt, &major_version, &minor_version);
- if (major_version == 0) {
- critical_error("Invalid base file");
- }
-
- if (major_version != blk_file_major_ver) {
- critical_error("Incompatible base file: version required is %d.X",
- blk_file_major_ver);
- }
-
- if (minor_version < blk_file_minor_ver) {
- critical_error("Incompatible base file: version required is %d.%d or above",
- blk_file_major_ver, blk_file_minor_ver);
- }
-
- while (getline(&base_file_line, &base_file_line_len, base_alloc_file_in) != -1) {
- if (sscanf(base_file_line, base_alloc_file_in_format, &stored_file_name, &file_map)
- != base_file_format_param_count) {
- continue;
- }
- if (strlen(stored_file_name) < strlen(mountpoint)) {
- continue;
- }
- snprintf(real_file_name, MAX_PATH, "%s%s", directory, stored_file_name + strlen(mountpoint));
- if (!access(real_file_name, R_OK)) {
- char *block_range, *end_string;
- int real_file_fd;
- int start_block, end_block;
- u32 block_file_size;
- u32 real_file_block_size;
- struct stat buf;
-
- if (lstat(real_file_name, &buf) == -1)
- critical_error(err_msg);
-
- if (!S_ISREG(buf.st_mode))
- continue;
-
- real_file_fd = open(real_file_name, O_RDONLY);
- if (real_file_fd == -1) {
- critical_error(err_msg);
- }
- real_file_block_size = get_file_size(real_file_fd);
- close(real_file_fd);
- real_file_block_size = DIV_ROUND_UP(real_file_block_size, info.block_size);
- fs_alloc->filename = strdup(real_file_name);
- block_range = strtok_r(file_map, ",", &end_string);
- while (block_range && real_file_block_size) {
- int block_group;
- char *range, *end_token = NULL;
- range = strtok_r(block_range, "-", &end_token);
- if (!range) {
- critical_error(err_msg);
- }
- start_block = parse_num(range);
- range = strtok_r(NULL, "-", &end_token);
- if (!range) {
- end_block = start_block;
- } else {
- end_block = parse_num(range);
- }
- // Assummption is that allocations are within the same block group
- block_group = get_block_group(start_block);
- if (block_group != get_block_group(end_block)) {
- critical_error("base file allocation's end block is in a different "
- "block group than start block. did you change fs params?");
- }
- block_range = strtok_r(NULL, ",", &end_string);
- int bg_first_block = bgs[block_group].first_block;
- int min_bg_bound = bgs[block_group].chunks[0].block + bgs[block_group].chunks[0].len;
- int max_bg_bound = bgs[block_group].chunks[bgs[block_group].chunk_count - 1].block;
-
- if (min_bg_bound >= start_block - bg_first_block ||
- max_bg_bound <= end_block - bg_first_block) {
- continue;
- }
- block_file_size = end_block - start_block + 1;
- if (block_file_size > real_file_block_size) {
- block_file_size = real_file_block_size;
- }
- append_region(fs_alloc, start_block, block_file_size, block_group);
- reserve_bg_chunk(block_group, start_block - bgs[block_group].first_block, block_file_size);
- real_file_block_size -= block_file_size;
- }
- if (reserve_blocks_for_allocation(fs_alloc) < 0)
- critical_error("failed to reserve base fs allocation");
- fs_alloc->next = create_allocation();
- fs_alloc = fs_alloc->next;
- }
- }
-
- for (i = 0; i < aux_info.groups; i++) {
- qsort(bgs[i].chunks, bgs[i].chunk_count, sizeof(struct region), compare_chunks);
- }
-
- free(base_file_line);
-
-#else
- return;
-#endif
-#undef err_msg
-}
-
-void generate_base_alloc_file_out(FILE* base_alloc_file_out, char* dir, char* mountpoint,
- struct block_allocation* p)
-{
- size_t dirlen = dir ? strlen(dir) : 0;
- fprintf(base_alloc_file_out, blk_file_header_fmt, blk_file_major_ver, blk_file_minor_ver);
- fputc('\n', base_alloc_file_out);
- while (p) {
- if (dir && strncmp(p->filename, dir, dirlen) == 0) {
- // substitute mountpoint for the leading directory in the filename, in the output file
- fprintf(base_alloc_file_out, "%s%s", mountpoint, p->filename + dirlen);
- } else {
- fprintf(base_alloc_file_out, "%s", p->filename);
- }
- print_blocks(base_alloc_file_out, p, ',');
- struct block_allocation* pn = p->next;
- p = pn;
- }
-}
-
-int make_ext4fs_internal(int fd, const char *_directory, const char *_target_out_directory,
- const char *_mountpoint, fs_config_func_t fs_config_func, int gzip,
- int sparse, int crc, int wipe, int real_uuid,
- struct selabel_handle *sehnd, int verbose, time_t fixed_time,
- FILE* block_list_file, FILE* base_alloc_file_in, FILE* base_alloc_file_out)
-{
- u32 root_inode_num;
- u16 root_mode;
- char *mountpoint;
- char *directory = NULL;
- char *target_out_directory = NULL;
- struct block_allocation* p;
-
- if (setjmp(setjmp_env))
- return EXIT_FAILURE; /* Handle a call to longjmp() */
-
- info.block_device = is_block_device_fd(fd);
-
- if (info.block_device && (sparse || gzip || crc)) {
- fprintf(stderr, "No sparse/gzip/crc allowed for block device\n");
- return EXIT_FAILURE;
- }
-
- if (_mountpoint == NULL) {
- mountpoint = strdup("");
- } else {
- mountpoint = canonicalize_abs_slashes(_mountpoint);
- }
-
- if (_directory) {
- directory = canonicalize_rel_slashes(_directory);
- }
-
- if (_target_out_directory) {
- target_out_directory = canonicalize_rel_slashes(_target_out_directory);
- }
-
- if (info.len <= 0)
- info.len = get_file_size(fd);
-
- if (info.block_size <= 0)
- info.block_size = compute_block_size();
-
- /* Round down the filesystem length to be a multiple of the block size */
- info.len &= ~((u64)info.block_size - 1);
-
- if (info.len <= 0) {
- fprintf(stderr, "filesystem size too small\n");
- free(mountpoint);
- return EXIT_FAILURE;
- }
-
- if (info.journal_blocks == 0)
- info.journal_blocks = compute_journal_blocks();
-
- if (info.no_journal == 0)
- info.feat_compat = EXT4_FEATURE_COMPAT_HAS_JOURNAL;
- else
- info.journal_blocks = 0;
-
- if (info.blocks_per_group <= 0)
- info.blocks_per_group = compute_blocks_per_group();
-
- if (info.inodes <= 0)
- info.inodes = compute_inodes();
-
- if (info.inode_size <= 0)
- info.inode_size = 256;
-
- if (info.label == NULL)
- info.label = "";
-
- info.inodes_per_group = compute_inodes_per_group();
-
- info.feat_compat |=
- EXT4_FEATURE_COMPAT_RESIZE_INODE |
- EXT4_FEATURE_COMPAT_EXT_ATTR;
-
- info.feat_ro_compat |=
- EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER |
- EXT4_FEATURE_RO_COMPAT_LARGE_FILE |
- EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
-
- info.feat_incompat |=
- EXT4_FEATURE_INCOMPAT_EXTENTS |
- EXT4_FEATURE_INCOMPAT_FILETYPE;
-
-
- info.bg_desc_reserve_blocks = compute_bg_desc_reserve_blocks();
-
- printf("Creating filesystem with parameters:\n");
- printf(" Size: %"PRIu64"\n", info.len);
- printf(" Block size: %d\n", info.block_size);
- printf(" Blocks per group: %d\n", info.blocks_per_group);
- printf(" Inodes per group: %d\n", info.inodes_per_group);
- printf(" Inode size: %d\n", info.inode_size);
- printf(" Journal blocks: %d\n", info.journal_blocks);
- printf(" Label: %s\n", info.label);
-
- ext4_create_fs_aux_info();
-
- printf(" Blocks: %"PRIext4u64"\n", aux_info.len_blocks);
- printf(" Block groups: %d\n", aux_info.groups);
- printf(" Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
-
- ext4_sparse_file = sparse_file_new(info.block_size, info.len);
-
- block_allocator_init();
-
- ext4_fill_in_sb(real_uuid);
-
- if (base_alloc_file_in) {
- extract_base_fs_allocations(directory, mountpoint, base_alloc_file_in);
- }
- if (reserve_inodes(0, 10) == EXT4_ALLOCATE_FAILED)
- error("failed to reserve first 10 inodes");
-
- if (info.feat_compat & EXT4_FEATURE_COMPAT_HAS_JOURNAL)
- ext4_create_journal_inode();
-
- if (info.feat_compat & EXT4_FEATURE_COMPAT_RESIZE_INODE)
- ext4_create_resize_inode();
-
-#ifdef _WIN32
- // Windows needs only 'create an empty fs image' functionality
- assert(!directory);
- root_inode_num = build_default_directory_structure(mountpoint, sehnd);
-#else
- if (directory)
- root_inode_num = build_directory_structure(directory, mountpoint, target_out_directory, 0,
- fs_config_func, sehnd, verbose, fixed_time);
- else
- root_inode_num = build_default_directory_structure(mountpoint, sehnd);
-#endif
-
- root_mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
- inode_set_permissions(root_inode_num, root_mode, 0, 0, 0);
-
-#ifndef _WIN32
- if (sehnd) {
- char *secontext = NULL;
-
- if (selabel_lookup(sehnd, &secontext, mountpoint, S_IFDIR) < 0) {
- error("cannot lookup security context for %s", mountpoint);
- }
- if (secontext) {
- if (verbose) {
- printf("Labeling %s as %s\n", mountpoint, secontext);
- }
- inode_set_selinux(root_inode_num, secontext);
- }
- freecon(secontext);
- }
-#endif
-
- ext4_update_free();
-
- // TODO: Consider migrating the OTA tools to the new base alloc file format
- // used for generating incremental images (see go/incremental-ext4)
- if (block_list_file) {
- size_t dirlen = directory ? strlen(directory) : 0;
- struct block_allocation* p = get_saved_allocation_chain();
- while (p) {
- if (directory && strncmp(p->filename, directory, dirlen) == 0) {
- // substitute mountpoint for the leading directory in the filename, in the output file
- fprintf(block_list_file, "%s%s", mountpoint, p->filename + dirlen);
- } else {
- fprintf(block_list_file, "%s", p->filename);
- }
- print_blocks(block_list_file, p, ' ');
- struct block_allocation* pn = p->next;
- p = pn;
- }
- }
-
- if (base_alloc_file_out) {
- struct block_allocation* p = get_saved_allocation_chain();
- generate_base_alloc_file_out(base_alloc_file_out, directory, mountpoint, p);
- }
-
- printf("Created filesystem with %d/%d inodes and %d/%d blocks\n",
- aux_info.sb->s_inodes_count - aux_info.sb->s_free_inodes_count,
- aux_info.sb->s_inodes_count,
- aux_info.sb->s_blocks_count_lo - aux_info.sb->s_free_blocks_count_lo,
- aux_info.sb->s_blocks_count_lo);
-
- if (wipe && WIPE_IS_SUPPORTED) {
- wipe_block_device(fd, info.len);
- }
-
- write_ext4_image(fd, gzip, sparse, crc);
-
- sparse_file_destroy(ext4_sparse_file);
- ext4_sparse_file = NULL;
-
- p = get_saved_allocation_chain();
- while (p) {
- struct block_allocation* pn = p->next;
- free_alloc(p);
- p = pn;
- }
-
- free(mountpoint);
- free(directory);
-
- return 0;
-}
diff --git a/ext4_utils/make_ext4fs_main.c b/ext4_utils/make_ext4fs_main.c
deleted file mode 100644
index 77930cd..0000000
--- a/ext4_utils/make_ext4fs_main.c
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <fcntl.h>
-#include <libgen.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#if defined(__linux__)
-#include <linux/fs.h>
-#elif defined(__APPLE__) && defined(__MACH__)
-#include <sys/disk.h>
-#endif
-
-#ifdef ANDROID
-#include <private/android_filesystem_config.h>
-#include <private/canned_fs_config.h>
-#endif
-
-#ifndef _WIN32
-#include <selinux/selinux.h>
-#include <selinux/label.h>
-#if !defined(HOST)
-#include <selinux/android.h>
-#endif
-#else
-struct selabel_handle;
-#endif
-
-#include "ext4_utils/ext4_utils.h"
-#include "ext4_utils/make_ext4fs.h"
-
-#ifndef _WIN32 /* O_BINARY is windows-specific flag */
-#define O_BINARY 0
-#endif
-
-extern struct fs_info info;
-
-
-static void usage(char *path)
-{
- fprintf(stderr, "%s [ -l <len> ] [ -j <journal size> ] [ -b <block_size> ]\n", basename(path));
- fprintf(stderr, " [ -g <blocks per group> ] [ -i <inodes> ] [ -I <inode size> ]\n");
- fprintf(stderr, " [ -e <flash erase block size> ] [ -o <flash logical block size> ]\n");
- fprintf(stderr, " [ -L <label> ] [ -f ] [ -a <android mountpoint> ] [ -u ]\n");
- fprintf(stderr, " [ -S file_contexts ] [ -C fs_config ] [ -T timestamp ]\n");
- fprintf(stderr, " [ -z | -s ] [ -w ] [ -c ] [ -J ] [ -v ] [ -B <block_list_file> ]\n");
- fprintf(stderr, " [ -d <base_alloc_file_in> ] [ -D <base_alloc_file_out> ]\n");
- fprintf(stderr, " <filename> [[<directory>] <target_out_directory>]\n");
-}
-
-int main(int argc, char **argv)
-{
- int opt;
- const char *filename = NULL;
- const char *directory = NULL;
- const char *target_out_directory = NULL;
- char *mountpoint = NULL;
- fs_config_func_t fs_config_func = NULL;
- const char *fs_config_file = NULL;
- int gzip = 0;
- int sparse = 0;
- int crc = 0;
- int wipe = 0;
- int real_uuid = 0;
- int fd;
- int exitcode;
- int verbose = 0;
- time_t fixed_time = -1;
- struct selabel_handle *sehnd = NULL;
- FILE* block_list_file = NULL;
- FILE* base_alloc_file_in = NULL;
- FILE* base_alloc_file_out = NULL;
-#ifndef _WIN32
- struct selinux_opt seopts[] = { { SELABEL_OPT_PATH, "" } };
-#endif
-
- while ((opt = getopt(argc, argv, "l:j:b:g:i:I:e:o:L:a:S:T:C:B:d:D:fwzJsctvu")) != -1) {
- switch (opt) {
- case 'l':
- info.len = parse_num(optarg);
- break;
- case 'j':
- info.journal_blocks = parse_num(optarg);
- break;
- case 'b':
- info.block_size = parse_num(optarg);
- break;
- case 'g':
- info.blocks_per_group = parse_num(optarg);
- break;
- case 'i':
- info.inodes = parse_num(optarg);
- break;
- case 'I':
- info.inode_size = parse_num(optarg);
- break;
- case 'e':
- info.flash_erase_block_size = parse_num(optarg);
- break;
- case 'o':
- info.flash_logical_block_size = parse_num(optarg);
- break;
- case 'L':
- info.label = optarg;
- break;
- case 'f':
- force = 1;
- break;
- case 'a':
-#ifdef ANDROID
- mountpoint = optarg;
-#else
- fprintf(stderr, "can't set android permissions - built without android support\n");
- usage(argv[0]);
- exit(EXIT_FAILURE);
-#endif
- break;
- case 'w':
- wipe = 1;
- break;
- case 'u':
- real_uuid = 1;
- break;
- case 'z':
- gzip = 1;
- break;
- case 'J':
- info.no_journal = 1;
- break;
- case 'c':
- crc = 1;
- break;
- case 's':
- sparse = 1;
- break;
- case 't':
- fprintf(stderr, "Warning: -t (initialize inode tables) is deprecated\n");
- break;
- case 'S':
-#ifndef _WIN32
- seopts[0].value = optarg;
- sehnd = selabel_open(SELABEL_CTX_FILE, seopts, 1);
- if (!sehnd) {
- perror(optarg);
- exit(EXIT_FAILURE);
- }
-#endif
- break;
- case 'v':
- verbose = 1;
- break;
- case 'T':
- fixed_time = strtoll(optarg, NULL, 0);
- break;
- case 'C':
- fs_config_file = optarg;
- break;
- case 'B':
- block_list_file = fopen(optarg, "w");
- if (block_list_file == NULL) {
- fprintf(stderr, "failed to open block_list_file: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
- }
- break;
- case 'd':
- base_alloc_file_in = fopen(optarg, "r");
- if (base_alloc_file_in == NULL) {
- fprintf(stderr, "failed to open base_alloc_file_in: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
- }
- break;
- case 'D':
- base_alloc_file_out = fopen(optarg, "w");
- if (base_alloc_file_out == NULL) {
- fprintf(stderr, "failed to open base_alloc_file_out: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
- }
- break;
- default: /* '?' */
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
- }
-
-#if !defined(HOST)
- // Use only if -S option not requested
- if (!sehnd && mountpoint) {
- sehnd = selinux_android_file_context_handle();
-
- if (!sehnd) {
- perror(optarg);
- exit(EXIT_FAILURE);
- }
- }
-#endif
-
- if (fs_config_file) {
- if (load_canned_fs_config(fs_config_file) < 0) {
- fprintf(stderr, "failed to load %s\n", fs_config_file);
- exit(EXIT_FAILURE);
- }
- fs_config_func = canned_fs_config;
- } else if (mountpoint) {
- fs_config_func = fs_config;
- }
-
- if (wipe && sparse) {
- fprintf(stderr, "Cannot specifiy both wipe and sparse\n");
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
-
- if (wipe && gzip) {
- fprintf(stderr, "Cannot specifiy both wipe and gzip\n");
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
-
- if (optind >= argc) {
- fprintf(stderr, "Expected filename after options\n");
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
-
- filename = argv[optind++];
-
- if (optind < argc)
- directory = argv[optind++];
-
- if (optind < argc)
- target_out_directory = argv[optind++];
-
- if (optind < argc) {
- fprintf(stderr, "Unexpected argument: %s\n", argv[optind]);
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
-
- if (strcmp(filename, "-")) {
- fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
- if (fd < 0) {
- perror("open");
- return EXIT_FAILURE;
- }
- } else {
- fd = STDOUT_FILENO;
- }
-
- exitcode = make_ext4fs_internal(fd, directory, target_out_directory, mountpoint, fs_config_func, gzip,
- sparse, crc, wipe, real_uuid, sehnd, verbose, fixed_time,
- block_list_file, base_alloc_file_in, base_alloc_file_out);
- close(fd);
- if (block_list_file)
- fclose(block_list_file);
- if (base_alloc_file_out)
- fclose(base_alloc_file_out);
- if (base_alloc_file_in)
- fclose(base_alloc_file_in);
- if (exitcode && strcmp(filename, "-"))
- unlink(filename);
- return exitcode;
-}
diff --git a/ext4_utils/mkuserimg.sh b/ext4_utils/mkuserimg.sh
deleted file mode 100755
index 06c68d4..0000000
--- a/ext4_utils/mkuserimg.sh
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/bin/bash
-#
-# To call this script, make sure make_ext4fs is somewhere in PATH
-
-function usage() {
-cat<<EOT
-Usage:
-mkuserimg.sh [-s] SRC_DIR OUTPUT_FILE EXT_VARIANT MOUNT_POINT SIZE [-j <journal_size>]
- [-T TIMESTAMP] [-C FS_CONFIG] [-D PRODUCT_OUT] [-B BLOCK_LIST_FILE]
- [-d BASE_ALLOC_FILE_IN ] [-A BASE_ALLOC_FILE_OUT ] [-L LABEL]
- [-i INODES ] [-e ERASE_BLOCK_SIZE] [-o FLASH_BLOCK_SIZE] [FILE_CONTEXTS]
-EOT
-}
-
-ENABLE_SPARSE_IMAGE=
-if [ "$1" = "-s" ]; then
- ENABLE_SPARSE_IMAGE="-s"
- shift
-fi
-
-if [ $# -lt 5 ]; then
- usage
- exit 1
-fi
-
-SRC_DIR=$1
-if [ ! -d $SRC_DIR ]; then
- echo "Can not find directory $SRC_DIR!"
- exit 2
-fi
-
-OUTPUT_FILE=$2
-EXT_VARIANT=$3
-MOUNT_POINT=$4
-SIZE=$5
-shift; shift; shift; shift; shift
-
-JOURNAL_FLAGS=
-if [ "$1" = "-j" ]; then
- if [ "$2" = "0" ]; then
- JOURNAL_FLAGS="-J"
- else
- JOURNAL_FLAGS="-j $2"
- fi
- shift; shift
-fi
-
-TIMESTAMP=-1
-if [[ "$1" == "-T" ]]; then
- TIMESTAMP=$2
- shift; shift
-fi
-
-FS_CONFIG=
-if [[ "$1" == "-C" ]]; then
- FS_CONFIG=$2
- shift; shift
-fi
-
-PRODUCT_OUT=
-if [[ "$1" == "-D" ]]; then
- PRODUCT_OUT=$2
- shift; shift
-fi
-
-BLOCK_LIST=
-if [[ "$1" == "-B" ]]; then
- BLOCK_LIST=$2
- shift; shift
-fi
-
-BASE_ALLOC_FILE_IN=
-if [[ "$1" == "-d" ]]; then
- BASE_ALLOC_FILE_IN=$2
- shift; shift
-fi
-
-BASE_ALLOC_FILE_OUT=
-if [[ "$1" == "-A" ]]; then
- BASE_ALLOC_FILE_OUT=$2
- shift; shift
-fi
-
-LABEL=
-if [[ "$1" == "-L" ]]; then
- LABEL=$2
- shift; shift
-fi
-
-INODES=
-if [[ "$1" == "-i" ]]; then
- INODES=$2
- shift; shift
-fi
-
-ERASE_SIZE=
-if [[ "$1" == "-e" ]]; then
- ERASE_SIZE=$2
- shift; shift
-fi
-
-FLASH_BLOCK_SIZE=
-if [[ "$1" == "-o" ]]; then
- FLASH_BLOCK_SIZE=$2
- shift; shift
-fi
-FC=$1
-
-case $EXT_VARIANT in
- ext4) ;;
- *) echo "Only ext4 is supported!"; exit 3 ;;
-esac
-
-if [ -z $MOUNT_POINT ]; then
- echo "Mount point is required"
- exit 2
-fi
-
-if [ -z $SIZE ]; then
- echo "Need size of filesystem"
- exit 2
-fi
-
-OPT=""
-if [ -n "$FC" ]; then
- OPT="$OPT -S $FC"
-fi
-if [ -n "$FS_CONFIG" ]; then
- OPT="$OPT -C $FS_CONFIG"
-fi
-if [ -n "$BLOCK_LIST" ]; then
- OPT="$OPT -B $BLOCK_LIST"
-fi
-if [ -n "$BASE_ALLOC_FILE_IN" ]; then
- OPT="$OPT -d $BASE_ALLOC_FILE_IN"
-fi
-if [ -n "$BASE_ALLOC_FILE_OUT" ]; then
- OPT="$OPT -D $BASE_ALLOC_FILE_OUT"
-fi
-if [ -n "$LABEL" ]; then
- OPT="$OPT -L $LABEL"
-fi
-if [ -n "$INODES" ]; then
- OPT="$OPT -i $INODES"
-fi
-if [ -n "$ERASE_SIZE" ]; then
- OPT="$OPT -e $ERASE_SIZE"
-fi
-if [ -n "$FLASH_BLOCK_SIZE" ]; then
- OPT="$OPT -o $FLASH_BLOCK_SIZE"
-fi
-
-MAKE_EXT4FS_CMD="make_ext4fs $ENABLE_SPARSE_IMAGE -T $TIMESTAMP $OPT -l $SIZE $JOURNAL_FLAGS -a $MOUNT_POINT $OUTPUT_FILE $SRC_DIR $PRODUCT_OUT"
-echo $MAKE_EXT4FS_CMD
-$MAKE_EXT4FS_CMD
-if [ $? -ne 0 ]; then
- exit 4
-fi
diff --git a/ext4_utils/setup_fs.c b/ext4_utils/setup_fs.c
deleted file mode 100644
index 802412d..0000000
--- a/ext4_utils/setup_fs.c
+++ /dev/null
@@ -1,86 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/reboot.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#include <cutils/android_reboot.h>
-#include <cutils/partition_utils.h>
-
-const char *mkfs = "/system/bin/make_ext4fs";
-
-int setup_fs(const char *blockdev)
-{
- char buf[256], path[128];
- pid_t child;
- int status, n;
- pid_t pid;
-
- /* we might be looking at an indirect reference */
- n = readlink(blockdev, path, sizeof(path) - 1);
- if (n > 0) {
- path[n] = 0;
- if (!memcmp(path, "/dev/block/", 11))
- blockdev = path + 11;
- }
-
- if (strchr(blockdev,'/')) {
- fprintf(stderr,"not a block device name: %s\n", blockdev);
- return 0;
- }
-
- snprintf(buf, sizeof(buf), "/sys/fs/ext4/%s", blockdev);
- if (access(buf, F_OK) == 0) {
- fprintf(stderr,"device %s already has a filesystem\n", blockdev);
- return 0;
- }
- snprintf(buf, sizeof(buf), "/dev/block/%s", blockdev);
-
- if (!partition_wiped(buf)) {
- fprintf(stderr,"device %s not wiped, probably encrypted, not wiping\n", blockdev);
- return 0;
- }
-
- fprintf(stderr,"+++\n");
-
- child = fork();
- if (child < 0) {
- fprintf(stderr,"error: setup_fs: fork failed\n");
- return 0;
- }
- if (child == 0) {
- execl(mkfs, mkfs, buf, NULL);
- exit(-1);
- }
-
- while ((pid=waitpid(-1, &status, 0)) != child) {
- if (pid == -1) {
- fprintf(stderr, "error: setup_fs: waitpid failed!\n");
- return 1;
- }
- }
-
- fprintf(stderr,"---\n");
- return 1;
-}
-
-
-int main(int argc, char **argv)
-{
- int need_reboot = 0;
-
- while (argc > 1) {
- if (strlen(argv[1]) < 128)
- need_reboot |= setup_fs(argv[1]);
- argv++;
- argc--;
- }
-
- if (need_reboot) {
- fprintf(stderr,"REBOOT!\n");
- android_reboot(ANDROID_RB_RESTART, 0, 0);
- exit(-1);
- }
- return 0;
-}
diff --git a/ext4_utils/test_ext4fixup b/ext4_utils/test_ext4fixup
deleted file mode 100755
index a920a59..0000000
--- a/ext4_utils/test_ext4fixup
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/bin/bash
-
-typeset -i I ITERATIONS PHASE LOC COUNT MAXCOUNT
-
-ME=`basename $0`
-
-if [ "$#" -ne 3 ]
-then
- echo "$ME: Usage: $ME <iterations> <maxcount> <filesystem_image>" >&2
- exit 1;
-fi
-
-ITERATIONS="$1"
-MAXCOUNT="$2"
-ORIG_FS_IMAGE="$3"
-FIXED_FS_IMAGE="/tmp/fixedfsimage.$$"
-NEW_FS_IMAGE="/tmp/newfsimage.$$"
-
-if [ ! -f "$ORIG_FS_IMAGE" ]
-then
- echo "$ME: Filesystem image $NEW_FS_IMAGE does not exist" >&2
- exit 1
-fi
-
-trap "rm -f $NEW_FS_IMAGE $FIXED_FS_IMAGE" 0 1 2 3 15
-
-rm -f "$NEW_FS_IMAGE" "$FIXED_FS_IMAGE"
-
-# Create the fixed image to compare against
-cp "$ORIG_FS_IMAGE" "$FIXED_FS_IMAGE"
-ext4fixup "$FIXED_FS_IMAGE"
-
-if [ "$?" -ne 0 ]
-then
- echo "$ME: ext4fixup failed!\n"
- exit 1
-fi
-
-I=0
-while [ "$I" -lt "$ITERATIONS" ]
-do
- # There is also a phase 4, which is writing out the updated superblocks and
- # block group descriptors. Test the with a separate script.
- let PHASE="$RANDOM"%3 # 0 to 2
- let PHASE++ # 1 to 3
- let LOC="$RANDOM"%2 # 0 to 1
- let LOC++ # 1 to 2
- let COUNT="$RANDOM"%"$MAXCOUNT"
-
- # Make a copy of the original image to fixup
- cp "$ORIG_FS_IMAGE" "$NEW_FS_IMAGE"
-
- # Run the fixup tool, but die partway through to see if we can recover
- ext4fixup -d "$PHASE,$LOC,$COUNT" "$NEW_FS_IMAGE" 2>/dev/null
-
- # run it again without -d to have it finish the job
- ext4fixup "$NEW_FS_IMAGE"
-
- if cmp "$FIXED_FS_IMAGE" "$NEW_FS_IMAGE"
- then
- :
- else
- echo "$ME: test failed with parameters $PHASE, $LOC, $COUNT"
- exit 1
- fi
-
- rm -f "$NEW_FS_IMAGE"
-
- let I++
-done
-