#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
$(call add-clean-step, rm -f $(PRODUCT_OUT)/system.img $(PRODUCT_OUT)/userdata.img)
+$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/EXECUTABLES/taskstats_intermediates)
# ************************************************
# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
# ************************************************
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := make_ext4fs_main.c
+LOCAL_SRC_FILES := make_ext4fs_main.c canned_fs_config.c
LOCAL_MODULE := make_ext4fs
LOCAL_STATIC_LIBRARIES += \
libext4_utils_host \
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := make_ext4fs_main.c
+LOCAL_SRC_FILES := make_ext4fs_main.c canned_fs_config.c
LOCAL_MODULE := make_ext4fs
LOCAL_SHARED_LIBRARIES := \
libext4_utils \
#include <stdio.h>
#include <stdlib.h>
-struct region_list {
- struct region *first;
- struct region *last;
- struct region *iter;
- u32 partial_iter;
-};
-
-struct block_allocation {
- struct region_list list;
- struct region_list oob_list;
-};
-
struct region {
u32 block;
u32 len;
alloc->list.partial_iter = 0;
alloc->oob_list.iter = NULL;
alloc->oob_list.partial_iter = 0;
+ alloc->filename = NULL;
+ alloc->next = NULL;
return alloc;
}
{
for (; reg; reg = reg->next) {
printf("%p: Blocks %d-%d (%d)\n", reg,
- reg->bg * info.blocks_per_group + reg->block,
- reg->bg * info.blocks_per_group + reg->block + reg->len - 1,
- reg->len);
+ reg->block, reg->block + reg->len - 1, reg->len)
}
}
}
#endif
+void print_blocks(FILE* f, struct block_allocation *alloc)
+{
+ struct region *reg;
+ for (reg = alloc->list.first; reg; reg = reg->next) {
+ if (reg->len == 1) {
+ fprintf(f, " %d", reg->block);
+ } else {
+ fprintf(f, " %d-%d", reg->block, reg->block + reg->len - 1);
+ }
+ }
+ fputc('\n', f);
+}
+
void append_region(struct block_allocation *alloc,
u32 block, u32 len, int bg_num)
{
#include "ext4_utils.h"
-struct block_allocation;
+struct region;
+
+struct region_list {
+ struct region *first;
+ struct region *last;
+ struct region *iter;
+ u32 partial_iter;
+};
+
+struct block_allocation {
+ struct region_list list;
+ struct region_list oob_list;
+ char* filename;
+ struct block_allocation* next;
+};
+
void block_allocator_init();
void block_allocator_free();
u32 block, u32 len, int bg);
struct block_allocation *create_allocation();
int append_oob_allocation(struct block_allocation *alloc, u32 len);
+void print_blocks(FILE* f, struct block_allocation *alloc);
#endif
--- /dev/null
+/*
+ * Copyright (C) 2014 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 <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+
+#include "private/android_filesystem_config.h"
+
+#include "canned_fs_config.h"
+
+typedef struct {
+ const char* path;
+ unsigned uid;
+ unsigned gid;
+ unsigned mode;
+ uint64_t capabilities;
+} Path;
+
+static Path* canned_data = NULL;
+static int canned_alloc = 0;
+static int canned_used = 0;
+
+static int path_compare(const void* a, const void* b) {
+ return strcmp(((Path*)a)->path, ((Path*)b)->path);
+}
+
+int load_canned_fs_config(const char* fn) {
+ FILE* f = fopen(fn, "r");
+ if (f == NULL) {
+ fprintf(stderr, "failed to open %s: %s\n", fn, strerror(errno));
+ return -1;
+ }
+
+ char line[PATH_MAX + 200];
+ while (fgets(line, sizeof(line), f)) {
+ while (canned_used >= canned_alloc) {
+ canned_alloc = (canned_alloc+1) * 2;
+ canned_data = (Path*) realloc(canned_data, canned_alloc * sizeof(Path));
+ }
+ Path* p = canned_data + canned_used;
+ p->path = strdup(strtok(line, " "));
+ p->uid = atoi(strtok(NULL, " "));
+ p->gid = atoi(strtok(NULL, " "));
+ p->mode = strtol(strtok(NULL, " "), NULL, 8); // mode is in octal
+ p->capabilities = 0;
+
+ char* token = NULL;
+ do {
+ token = strtok(NULL, " ");
+ if (token && strncmp(token, "capabilities=", 13) == 0) {
+ p->capabilities = strtoll(token+13, NULL, 0);
+ break;
+ }
+ } while (token);
+
+ canned_used++;
+ }
+
+ fclose(f);
+
+ qsort(canned_data, canned_used, sizeof(Path), path_compare);
+ printf("loaded %d fs_config entries\n", canned_used);
+
+ return 0;
+}
+
+void canned_fs_config(const char* path, int dir,
+ unsigned* uid, unsigned* gid, unsigned* mode, uint64_t* capabilities) {
+ Path key;
+ key.path = path+1; // canned paths lack the leading '/'
+ Path* p = (Path*) bsearch(&key, canned_data, canned_used, sizeof(Path), path_compare);
+ if (p == NULL) {
+ fprintf(stderr, "failed to find [%s] in canned fs_config\n", path);
+ exit(1);
+ }
+ *uid = p->uid;
+ *gid = p->gid;
+ *mode = p->mode;
+ *capabilities = p->capabilities;
+
+#if 0
+ // for debugging, run the built-in fs_config and compare the results.
+
+ unsigned c_uid, c_gid, c_mode;
+ uint64_t c_capabilities;
+ fs_config(path, dir, &c_uid, &c_gid, &c_mode, &c_capabilities);
+
+ if (c_uid != *uid) printf("%s uid %d %d\n", path, *uid, c_uid);
+ if (c_gid != *gid) printf("%s gid %d %d\n", path, *gid, c_gid);
+ if (c_mode != *mode) printf("%s mode 0%o 0%o\n", path, *mode, c_mode);
+ if (c_capabilities != *capabilities) printf("%s capabilities %llx %llx\n", path, *capabilities, c_capabilities);
+#endif
+}
--- /dev/null
+/*
+ * Copyright (C) 2014 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 _CANNED_FS_CONFIG_H
+#define _CANNED_FS_CONFIG_H
+
+#include <inttypes.h>
+
+int load_canned_fs_config(const char* fn);
+void canned_fs_config(const char* path, int dir,
+ unsigned* uid, unsigned* gid, unsigned* mode, uint64_t* capabilities);
+
+#endif
#define S_IFLNK 0 /* used by make_link, not needed under mingw */
#endif
+static struct block_allocation* saved_allocation_head = NULL;
+
+struct block_allocation* get_saved_allocation_chain() {
+ return saved_allocation_head;
+}
+
static u32 dentry_size(u32 entries, struct dentry *dentries)
{
u32 len = 24;
unsigned int dentry_len;
for (i = 0; i < entries; i++) {
- dentry_len = 8 + ALIGN(strlen(dentries[i].filename), 4);
+ dentry_len = 8 + EXT4_ALIGN(strlen(dentries[i].filename), 4);
if (len % info.block_size + dentry_len > info.block_size)
len += info.block_size - (len % info.block_size);
len += dentry_len;
u8 file_type)
{
u8 name_len = strlen(name);
- u16 rec_len = 8 + ALIGN(name_len, 4);
+ u16 rec_len = 8 + EXT4_ALIGN(name_len, 4);
struct ext4_dir_entry_2 *dentry;
u32 start_block = *offset / info.block_size;
return EXT4_ALLOCATE_FAILED;
}
- if (len > 0)
- inode_allocate_file_extents(inode, len, filename);
+ if (len > 0) {
+ struct block_allocation* alloc = inode_allocate_file_extents(inode, len, filename);
+ if (alloc) {
+ alloc->filename = strdup(filename);
+ alloc->next = saved_allocation_head;
+ saved_allocation_head = alloc;
+ }
+ }
inode->i_mode = S_IFREG;
inode->i_links_count = 1;
return xattr_add(inode_num, EXT4_XATTR_INDEX_SECURITY,
XATTR_CAPS_SUFFIX, &cap_data, sizeof(cap_data));
}
-
int inode_set_permissions(u32 inode_num, u16 mode, u16 uid, u16 gid, u32 mtime);
int inode_set_selinux(u32 inode_num, const char *secon);
int inode_set_capabilities(u32 inode_num, uint64_t capabilities);
+struct block_allocation* get_saved_allocation_chain();
+
#endif
#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
-#include <inttypes.h>
#include <libgen.h>
#include <unistd.h>
fprintf(stderr, " -S don't use sparse output format\n");
}
-static int read_ext(int fd)
-{
- off64_t ret;
- struct ext4_super_block sb;
-
- ret = lseek64(fd, 1024, SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to superblock");
-
- ret = read(fd, &sb, sizeof(sb));
- if (ret < 0)
- critical_error_errno("failed to read superblock");
- if (ret != sizeof(sb))
- critical_error("failed to read all of superblock");
-
- ext4_parse_sb_info(&sb);
-
- ret = lseek64(fd, info.len, SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to end of input image");
-
- ret = lseek64(fd, info.block_size * (aux_info.first_data_block + 1), SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to block group descriptors");
-
- ret = read(fd, aux_info.bg_desc, info.block_size * aux_info.bg_desc_blocks);
- if (ret < 0)
- critical_error_errno("failed to read block group descriptors");
- if (ret != (int)info.block_size * (int)aux_info.bg_desc_blocks)
- critical_error("failed to read all of block group descriptors");
-
- if (verbose) {
- printf("Found 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(" Label: %s\n", info.label);
- printf(" Blocks: %"PRIu64"\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);
- printf(" Used %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);
- }
-
- return 0;
-}
-
-static int bitmap_get_bit(u8 *bitmap, u32 bit)
-{
- if (bitmap[bit / 8] & 1 << (bit % 8))
- return 1;
-
- return 0;
-}
-
static int build_sparse_ext(int fd, const char *filename)
{
unsigned int i;
if (infd < 0)
critical_error_errno("failed to open input image");
- read_ext(infd);
+ read_ext(infd, verbose);
ext4_sparse_file = sparse_file_new(info.block_size, info.len);
#define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
#define EXT4_INODE_SIZE(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? EXT4_GOOD_OLD_INODE_SIZE : (s)->s_inode_size)
#define EXT4_FIRST_INO(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? EXT4_GOOD_OLD_FIRST_INO : (s)->s_first_ino)
-#define EXT4_BLOCK_ALIGN(size, blkbits) ALIGN((size), (1 << (blkbits)))
+#define EXT4_BLOCK_ALIGN(size, blkbits) EXT4_ALIGN((size), (1 << (blkbits)))
struct ext4_group_desc
{
#include <sparse/sparse.h>
#include <fcntl.h>
+#include <inttypes.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stddef.h>
return (a == b) ? 1 : 0;
}
+int bitmap_get_bit(u8 *bitmap, u32 bit)
+{
+ if (bitmap[bit / 8] & (1 << (bit % 8)))
+ return 1;
+
+ return 0;
+}
+
+void bitmap_clear_bit(u8 *bitmap, u32 bit)
+{
+ bitmap[bit / 8] &= ~(1 << (bit % 8));
+
+ return;
+}
+
/* Returns 1 if the bg contains a backup superblock. On filesystems with
the sparse_super feature, only block groups 0, 1, and powers of 3, 5,
and 7 have backup superblocks. Otherwise, all block groups have backup
return 0;
}
+/* Function to read the primary superblock */
+void read_sb(int fd, struct ext4_super_block *sb)
+{
+ off64_t ret;
+
+ ret = lseek64(fd, 1024, SEEK_SET);
+ if (ret < 0)
+ critical_error_errno("failed to seek to superblock");
+
+ ret = read(fd, sb, sizeof(*sb));
+ if (ret < 0)
+ critical_error_errno("failed to read superblock");
+ if (ret != sizeof(*sb))
+ critical_error("failed to read all of superblock");
+}
+
+/* Function to write a primary or backup superblock at a given offset */
+void write_sb(int fd, unsigned long long offset, struct ext4_super_block *sb)
+{
+ off64_t ret;
+
+ ret = lseek64(fd, offset, SEEK_SET);
+ if (ret < 0)
+ critical_error_errno("failed to seek to superblock");
+
+ ret = write(fd, sb, sizeof(*sb));
+ if (ret < 0)
+ critical_error_errno("failed to write superblock");
+ if (ret != sizeof(*sb))
+ critical_error("failed to write all of superblock");
+}
+
/* Write the filesystem image to a file */
void write_ext4_image(int fd, int gz, int sparse, int crc)
{
return num;
}
+
+int read_ext(int fd, int verbose)
+{
+ off64_t ret;
+ struct ext4_super_block sb;
+
+ read_sb(fd, &sb);
+
+ ext4_parse_sb_info(&sb);
+
+ ret = lseek64(fd, info.len, SEEK_SET);
+ if (ret < 0)
+ critical_error_errno("failed to seek to end of input image");
+
+ ret = lseek64(fd, info.block_size * (aux_info.first_data_block + 1), SEEK_SET);
+ if (ret < 0)
+ critical_error_errno("failed to seek to block group descriptors");
+
+ ret = read(fd, aux_info.bg_desc, info.block_size * aux_info.bg_desc_blocks);
+ if (ret < 0)
+ critical_error_errno("failed to read block group descriptors");
+ if (ret != (int)info.block_size * (int)aux_info.bg_desc_blocks)
+ critical_error("failed to read all of block group descriptors");
+
+ if (verbose) {
+ printf("Found 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(" Label: %s\n", info.label);
+ printf(" Blocks: %"PRIu64"\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);
+ printf(" Used %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);
+ }
+
+ return 0;
+}
+
#endif
#define DIV_ROUND_UP(x, y) (((x) + (y) - 1)/(y))
-#define ALIGN(x, y) ((y) * DIV_ROUND_UP((x), (y)))
+#define EXT4_ALIGN(x, y) ((y) * DIV_ROUND_UP((x), (y)))
/* XXX */
#define cpu_to_le32(x) (x)
return i - 1;
}
+int bitmap_get_bit(u8 *bitmap, u32 bit);
+void bitmap_clear_bit(u8 *bitmap, u32 bit);
int ext4_bg_has_super_block(int bg);
+void read_sb(int fd, struct ext4_super_block *sb);
+void write_sb(int fd, unsigned long long offset, struct ext4_super_block *sb);
void write_ext4_image(int fd, int gz, int sparse, int crc);
void ext4_create_fs_aux_info(void);
void ext4_free_fs_aux_info(void);
u16 ext4_crc16(u16 crc_in, const void *buf, int size);
typedef void (*fs_config_func_t)(const char *path, int dir, unsigned *uid, unsigned *gid,
- unsigned *mode, uint64_t *capabilities);
+ unsigned *mode, uint64_t *capabilities);
struct selabel_handle;
int make_ext4fs_internal(int fd, const char *directory,
- const char *mountpoint, fs_config_func_t fs_config_func, int gzip,
- int sparse, int crc, int wipe,
- struct selabel_handle *sehnd, int verbose);
+ const char *mountpoint, fs_config_func_t fs_config_func, int gzip,
+ int sparse, int crc, int wipe,
+ struct selabel_handle *sehnd, int verbose, time_t fixed_time,
+ FILE* block_list_file);
+
+int read_ext(int fd, int verbose);
#ifdef __cplusplus
}
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
-#include <inttypes.h>
#include <unistd.h>
#ifndef USE_MINGW
return (group * new_inodes_per_group) + offset + 1;
}
-/* Function to read the primary superblock */
-static void read_sb(int fd, struct ext4_super_block *sb)
-{
- off64_t ret;
-
- ret = lseek64(fd, 1024, SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to superblock");
-
- ret = read(fd, sb, sizeof(*sb));
- if (ret < 0)
- critical_error_errno("failed to read superblock");
- if (ret != sizeof(*sb))
- critical_error("failed to read all of superblock");
-}
-
-/* Function to write a primary or backup superblock at a given offset */
-static void write_sb(int fd, unsigned long long offset, struct ext4_super_block *sb)
-{
- off64_t ret;
-
- if (no_write) {
- return;
- }
-
- ret = lseek64(fd, offset, SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to superblock");
-
- ret = write(fd, sb, sizeof(*sb));
- if (ret < 0)
- critical_error_errno("failed to write superblock");
- if (ret != sizeof(*sb))
- critical_error("failed to write all of superblock");
-}
-
static int get_fs_fixup_state(int fd)
{
unsigned long long magic;
/* we are done, so make the filesystem mountable again */
sb.s_desc_size &= ~1;
}
- write_sb(fd, 1024, &sb);
-
- return 0;
-}
-
-static int read_ext(int fd)
-{
- off64_t ret;
- struct ext4_super_block sb;
-
- read_sb(fd, &sb);
-
- ext4_parse_sb_info(&sb);
-
- 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 (((sb.s_desc_size & ~1) != sizeof(struct ext2_group_desc)) &&
- ((sb.s_desc_size & ~1) != 0))
- critical_error("error: bg_desc_size != sizeof(struct ext2_group_desc)\n");
-
- ret = lseek64(fd, info.len, SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to end of input image");
-
- ret = lseek64(fd, info.block_size * (aux_info.first_data_block + 1), SEEK_SET);
- if (ret < 0)
- critical_error_errno("failed to seek to block group descriptors");
-
- ret = read(fd, aux_info.bg_desc, info.block_size * aux_info.bg_desc_blocks);
- if (ret < 0)
- critical_error_errno("failed to read block group descriptors");
- if (ret != (int)info.block_size * (int)aux_info.bg_desc_blocks)
- critical_error("failed to read all of block group descriptors");
- if (verbose) {
- printf("Found 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(" Label: %s\n", info.label);
- printf(" Blocks: %"PRIu64"\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);
- printf(" Used %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 (!no_write) {
+ write_sb(fd, 1024, &sb);
}
return 0;
return 0;
}
-static int bitmap_get_bit(u8 *bitmap, u32 bit)
-{
- if (bitmap[bit / 8] & (1 << (bit % 8)))
- return 1;
-
- return 0;
-}
-
-static void bitmap_clear_bit(u8 *bitmap, u32 bit)
-{
- bitmap[bit / 8] &= ~(1 << (bit % 8));
-
- return;
-}
-
static void check_inode_bitmap(int fd, unsigned int bg_num)
{
unsigned int inode_bitmap_block_num;
sb.s_desc_size &= ~1;
}
- write_sb(fd, (unsigned long long)i * info.blocks_per_group * info.block_size + sb_offset, &sb);
+ 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 (fd < 0)
critical_error_errno("failed to open filesystem image");
- read_ext(fd);
+ 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");
#endif
/* Compute what the new value of inodes_per_blockgroup will be when we're done */
- new_inodes_per_group=ALIGN(info.inodes_per_group,(info.block_size/info.inode_size));
+ new_inodes_per_group=EXT4_ALIGN(info.inodes_per_group,(info.block_size/info.inode_size));
read_inode(fd, EXT4_ROOT_INO, &root_inode);
/* Allocates enough blocks to hold len bytes, queues them to be written
from a file, and connects them to an inode. */
-void inode_allocate_file_extents(struct ext4_inode *inode, u64 len,
+struct block_allocation* inode_allocate_file_extents(struct ext4_inode *inode, u64 len,
const char *filename)
{
struct block_allocation *alloc;
alloc = do_inode_allocate_extents(inode, len);
if (alloc == NULL) {
error("failed to allocate extents for %"PRIu64" bytes", len);
- return;
+ return NULL;
}
extent_create_backing_file(alloc, len, filename);
-
- free_alloc(alloc);
+ return alloc;
}
/* Allocates enough blocks to hold len bytes and connects them to an inode */
#include "ext4_utils.h"
void inode_allocate_extents(struct ext4_inode *inode, u64 len);
-void inode_allocate_file_extents(struct ext4_inode *inode, u64 len,
- const char *filename);
+struct block_allocation* inode_allocate_file_extents(
+ struct ext4_inode *inode, u64 len, const char *filename);
u8 *inode_allocate_data_extents(struct ext4_inode *inode, u64 len,
u64 backing_len);
void free_extent_blocks();
if the image were mounted at the specified mount point */
static u32 build_directory_structure(const char *full_path, const char *dir_path,
u32 dir_inode, fs_config_func_t fs_config_func,
- struct selabel_handle *sehnd, int verbose)
+ struct selabel_handle *sehnd, int verbose, time_t fixed_time)
{
int entries = 0;
struct dentry *dentries;
dentries[i].size = stat.st_size;
dentries[i].mode = stat.st_mode & (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO);
- dentries[i].mtime = stat.st_mtime;
+ 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
if (ret < 0)
critical_error_errno("asprintf");
entry_inode = build_directory_structure(subdir_full_path,
- subdir_dir_path, inode, fs_config_func, sehnd, verbose);
+ subdir_dir_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) {
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 = ALIGN(inodes, (info.block_size / info.inode_size));
+ 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.
}
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;
- }
+ // 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)
+ const char *mountpoint, struct selabel_handle *sehnd)
{
reset_ext4fs_info();
info.len = len;
- return make_ext4fs_internal(fd, NULL, mountpoint, NULL, 0, 1, 0, 0, sehnd, 0);
+ return make_ext4fs_internal(fd, NULL, mountpoint, NULL, 0, 1, 0, 0, sehnd, 0, -1, NULL);
}
int make_ext4fs(const char *filename, long long len,
- const char *mountpoint, struct selabel_handle *sehnd)
+ const char *mountpoint, struct selabel_handle *sehnd)
{
int fd;
int status;
return EXIT_FAILURE;
}
- status = make_ext4fs_internal(fd, NULL, mountpoint, NULL, 0, 0, 0, 1, sehnd, 0);
+ status = make_ext4fs_internal(fd, NULL, mountpoint, NULL, 0, 0, 0, 1, sehnd, 0, -1, NULL);
close(fd);
return status;
}
int make_ext4fs_internal(int fd, const char *_directory,
- const char *_mountpoint, fs_config_func_t fs_config_func, int gzip,
- int sparse, int crc, int wipe,
- struct selabel_handle *sehnd, int verbose)
+ const char *_mountpoint, fs_config_func_t fs_config_func, int gzip,
+ int sparse, int crc, int wipe,
+ struct selabel_handle *sehnd, int verbose, time_t fixed_time,
+ FILE* block_list_file)
{
u32 root_inode_num;
u16 root_mode;
#else
if (directory)
root_inode_num = build_directory_structure(directory, mountpoint, 0,
- fs_config_func, sehnd, verbose);
+ fs_config_func, sehnd, verbose, fixed_time);
else
root_inode_num = build_default_directory_structure(mountpoint, sehnd);
#endif
ext4_queue_sb();
+ 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;
+ free_alloc(p);
+ p = pn;
+ }
+ }
+
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,
#include "make_ext4fs.h"
#include "ext4_utils.h"
+#include "canned_fs_config.h"
#ifndef USE_MINGW /* O_BINARY is windows-specific flag */
#define O_BINARY 0
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, " [ -L <label> ] [ -f ] [ -a <android mountpoint> ]\n");
- fprintf(stderr, " [ -S file_contexts ]\n");
- fprintf(stderr, " [ -z | -s ] [ -w ] [ -c ] [ -J ] [ -v ]\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, " <filename> [<directory>]\n");
}
const char *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 fd;
int exitcode;
int verbose = 0;
+ time_t fixed_time = -1;
struct selabel_handle *sehnd = NULL;
+ FILE* block_list_file = NULL;
#ifndef USE_MINGW
struct selinux_opt seopts[] = { { SELABEL_OPT_PATH, "" } };
#endif
- while ((opt = getopt(argc, argv, "l:j:b:g:i:I:L:a:S:fwzJsctv")) != -1) {
+ while ((opt = getopt(argc, argv, "l:j:b:g:i:I:L:a:S:T:C:B:fwzJsctv")) != -1) {
switch (opt) {
case 'l':
info.len = parse_num(optarg);
break;
case 'a':
#ifdef ANDROID
- fs_config_func = fs_config;
mountpoint = optarg;
#else
fprintf(stderr, "can't set android permissions - built without android support\n");
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;
default: /* '?' */
usage(argv[0]);
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]);
}
exitcode = make_ext4fs_internal(fd, directory, mountpoint, fs_config_func, gzip,
- sparse, crc, wipe, sehnd, verbose);
+ sparse, crc, wipe, sehnd, verbose, fixed_time, block_list_file);
close(fd);
+ if (block_list_file)
+ fclose(block_list_file);
if (exitcode && strcmp(filename, "-"))
unlink(filename);
return exitcode;
-#!/bin/bash -x
+#!/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 [FILE_CONTEXTS]
+mkuserimg.sh [-s] SRC_DIR OUTPUT_FILE EXT_VARIANT MOUNT_POINT SIZE
+ [-T TIMESTAMP] [-C FS_CONFIG] [-B BLOCK_LIST_FILE] [FILE_CONTEXTS]
EOT
}
-echo "in mkuserimg.sh PATH=$PATH"
-
ENABLE_SPARSE_IMAGE=
if [ "$1" = "-s" ]; then
ENABLE_SPARSE_IMAGE="-s"
shift
fi
-if [ $# -ne 5 -a $# -ne 6 ]; then
+if [ $# -lt 5 ]; then
usage
exit 1
fi
EXT_VARIANT=$3
MOUNT_POINT=$4
SIZE=$5
-FC=$6
+shift; shift; shift; shift; shift
+
+TIMESTAMP=-1
+if [[ "$1" == "-T" ]]; then
+ TIMESTAMP=$2
+ shift; shift
+fi
+
+FS_CONFIG=
+if [[ "$1" == "-C" ]]; then
+ FS_CONFIG=$2
+ shift; shift
+fi
+
+BLOCK_LIST=
+if [[ "$1" == "-B" ]]; then
+ BLOCK_LIST=$2
+ shift; shift
+fi
+
+FC=$1
case $EXT_VARIANT in
ext4) ;;
exit 2
fi
+OPT=""
if [ -n "$FC" ]; then
- FCOPT="-S $FC"
+ 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
-MAKE_EXT4FS_CMD="make_ext4fs $ENABLE_SPARSE_IMAGE $FCOPT -l $SIZE -a $MOUNT_POINT $OUTPUT_FILE $SRC_DIR"
+MAKE_EXT4FS_CMD="make_ext4fs $ENABLE_SPARSE_IMAGE -T $TIMESTAMP $OPT -l $SIZE -a $MOUNT_POINT $OUTPUT_FILE $SRC_DIR"
echo $MAKE_EXT4FS_CMD
$MAKE_EXT4FS_CMD
if [ $? -ne 0 ]; then
endif
include $(CLEAR_VARS)
+LOCAL_MODULE := libf2fs_sparseblock
+LOCAL_SRC_FILES := f2fs_sparseblock.c
+LOCAL_SHARED_LIBRARIES := libcutils
+LOCAL_C_INCLUDES := external/f2fs-tools/include \
+ system/core/include/log
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := f2fs_sparseblock
+LOCAL_SRC_FILES := f2fs_sparseblock.c
+LOCAL_SHARED_LIBRARIES := libcutils
+LOCAL_C_INCLUDES := external/f2fs-tools/include \
+ system/core/include/log
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
LOCAL_MODULE := mkf2fsuserimg.sh
LOCAL_SRC_FILES := mkf2fsuserimg.sh
LOCAL_MODULE_CLASS := EXECUTABLES
--- /dev/null
+#define _LARGEFILE64_SOURCE
+
+#define LOG_TAG "f2fs_sparseblock"
+
+
+#include <cutils/log.h>
+#include <fcntl.h>
+#include <f2fs_fs.h>
+#include <linux/types.h>
+#include <sys/stat.h>
+#include "f2fs_sparseblock.h"
+
+
+#define D_DISP_u32(ptr, member) \
+ do { \
+ SLOGD("%-30s" "\t\t[0x%#08x : %u]\n", \
+ #member, le32_to_cpu((ptr)->member), le32_to_cpu((ptr)->member) ); \
+ } while (0);
+
+#define D_DISP_u64(ptr, member) \
+ do { \
+ SLOGD("%-30s" "\t\t[0x%#016llx : %llu]\n", \
+ #member, le64_to_cpu((ptr)->member), le64_to_cpu((ptr)->member) ); \
+ } while (0);
+
+#define segno_in_journal(sum, i) (sum->sit_j.entries[i].segno)
+
+#define sit_in_journal(sum, i) (sum->sit_j.entries[i].se)
+
+static void dbg_print_raw_sb_info(struct f2fs_super_block *sb)
+{
+ SLOGD("\n");
+ SLOGD("+--------------------------------------------------------+\n");
+ SLOGD("| Super block |\n");
+ SLOGD("+--------------------------------------------------------+\n");
+
+ D_DISP_u32(sb, magic);
+ D_DISP_u32(sb, major_ver);
+ D_DISP_u32(sb, minor_ver);
+ D_DISP_u32(sb, log_sectorsize);
+ D_DISP_u32(sb, log_sectors_per_block);
+
+ D_DISP_u32(sb, log_blocksize);
+ D_DISP_u32(sb, log_blocks_per_seg);
+ D_DISP_u32(sb, segs_per_sec);
+ D_DISP_u32(sb, secs_per_zone);
+ D_DISP_u32(sb, checksum_offset);
+ D_DISP_u64(sb, block_count);
+
+ D_DISP_u32(sb, section_count);
+ D_DISP_u32(sb, segment_count);
+ D_DISP_u32(sb, segment_count_ckpt);
+ D_DISP_u32(sb, segment_count_sit);
+ D_DISP_u32(sb, segment_count_nat);
+
+ D_DISP_u32(sb, segment_count_ssa);
+ D_DISP_u32(sb, segment_count_main);
+ D_DISP_u32(sb, segment0_blkaddr);
+
+ D_DISP_u32(sb, cp_blkaddr);
+ D_DISP_u32(sb, sit_blkaddr);
+ D_DISP_u32(sb, nat_blkaddr);
+ D_DISP_u32(sb, ssa_blkaddr);
+ D_DISP_u32(sb, main_blkaddr);
+
+ D_DISP_u32(sb, root_ino);
+ D_DISP_u32(sb, node_ino);
+ D_DISP_u32(sb, meta_ino);
+ D_DISP_u32(sb, cp_payload);
+ SLOGD("\n");
+}
+static void dbg_print_raw_ckpt_struct(struct f2fs_checkpoint *cp)
+{
+ SLOGD("\n");
+ SLOGD("+--------------------------------------------------------+\n");
+ SLOGD("| Checkpoint |\n");
+ SLOGD("+--------------------------------------------------------+\n");
+
+ D_DISP_u64(cp, checkpoint_ver);
+ D_DISP_u64(cp, user_block_count);
+ D_DISP_u64(cp, valid_block_count);
+ D_DISP_u32(cp, rsvd_segment_count);
+ D_DISP_u32(cp, overprov_segment_count);
+ D_DISP_u32(cp, free_segment_count);
+
+ D_DISP_u32(cp, alloc_type[CURSEG_HOT_NODE]);
+ D_DISP_u32(cp, alloc_type[CURSEG_WARM_NODE]);
+ D_DISP_u32(cp, alloc_type[CURSEG_COLD_NODE]);
+ D_DISP_u32(cp, cur_node_segno[0]);
+ D_DISP_u32(cp, cur_node_segno[1]);
+ D_DISP_u32(cp, cur_node_segno[2]);
+
+ D_DISP_u32(cp, cur_node_blkoff[0]);
+ D_DISP_u32(cp, cur_node_blkoff[1]);
+ D_DISP_u32(cp, cur_node_blkoff[2]);
+
+
+ D_DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]);
+ D_DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]);
+ D_DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]);
+ D_DISP_u32(cp, cur_data_segno[0]);
+ D_DISP_u32(cp, cur_data_segno[1]);
+ D_DISP_u32(cp, cur_data_segno[2]);
+
+ D_DISP_u32(cp, cur_data_blkoff[0]);
+ D_DISP_u32(cp, cur_data_blkoff[1]);
+ D_DISP_u32(cp, cur_data_blkoff[2]);
+
+ D_DISP_u32(cp, ckpt_flags);
+ D_DISP_u32(cp, cp_pack_total_block_count);
+ D_DISP_u32(cp, cp_pack_start_sum);
+ D_DISP_u32(cp, valid_node_count);
+ D_DISP_u32(cp, valid_inode_count);
+ D_DISP_u32(cp, next_free_nid);
+ D_DISP_u32(cp, sit_ver_bitmap_bytesize);
+ D_DISP_u32(cp, nat_ver_bitmap_bytesize);
+ D_DISP_u32(cp, checksum_offset);
+ D_DISP_u64(cp, elapsed_time);
+
+ D_DISP_u32(cp, sit_nat_version_bitmap[0]);
+ SLOGD("\n\n");
+}
+
+static void dbg_print_info_struct(struct f2fs_info *info)
+{
+ SLOGD("\n");
+ SLOGD("+--------------------------------------------------------+\n");
+ SLOGD("| F2FS_INFO |\n");
+ SLOGD("+--------------------------------------------------------+\n");
+ SLOGD("blocks_per_segment: %"PRIu64, info->blocks_per_segment);
+ SLOGD("block_size: %d", info->block_size);
+ SLOGD("sit_bmp loc: %p", info->sit_bmp);
+ SLOGD("sit_bmp_size: %d", info->sit_bmp_size);
+ SLOGD("blocks_per_sit: %"PRIu64, info->blocks_per_sit);
+ SLOGD("sit_blocks loc: %p", info->sit_blocks);
+ SLOGD("sit_sums loc: %p", info->sit_sums);
+ SLOGD("sit_sums num: %d", le16_to_cpu(info->sit_sums->n_sits));
+ unsigned int i;
+ for(i = 0; i < (le16_to_cpu(info->sit_sums->n_sits)); i++) {
+ SLOGD("entry %d in journal entries is for segment %d",i, le32_to_cpu(segno_in_journal(info->sit_sums, i)));
+ }
+
+ SLOGD("cp_blkaddr: %"PRIu64, info->cp_blkaddr);
+ SLOGD("cp_valid_cp_blkaddr: %"PRIu64, info->cp_valid_cp_blkaddr);
+ SLOGD("sit_blkaddr: %"PRIu64, info->sit_blkaddr);
+ SLOGD("nat_blkaddr: %"PRIu64, info->nat_blkaddr);
+ SLOGD("ssa_blkaddr: %"PRIu64, info->ssa_blkaddr);
+ SLOGD("main_blkaddr: %"PRIu64, info->main_blkaddr);
+ SLOGD("total_user_used: %"PRIu64, info->total_user_used);
+ SLOGD("total_blocks: %"PRIu64, info->total_blocks);
+ SLOGD("\n\n");
+}
+
+
+/* read blocks */
+static int read_structure(int fd, unsigned long long start, void *buf, ssize_t len)
+{
+ off64_t ret;
+
+ ret = lseek64(fd, start, SEEK_SET);
+ if (ret < 0) {
+ SLOGE("failed to seek\n");
+ return ret;
+ }
+
+ ret = read(fd, buf, len);
+ if (ret < 0) {
+ SLOGE("failed to read\n");
+ return ret;
+ }
+ if (ret != len) {
+ SLOGE("failed to read all\n");
+ return -1;
+ }
+ return 0;
+}
+
+static int read_structure_blk(int fd, unsigned long long start_blk, void *buf, size_t len)
+{
+ return read_structure(fd, F2FS_BLKSIZE*start_blk, buf, F2FS_BLKSIZE * len);
+}
+
+static int read_f2fs_sb(int fd, struct f2fs_super_block *sb)
+{
+ int rc;
+ rc = read_structure(fd, F2FS_SUPER_OFFSET, sb, sizeof(*sb));
+ if (le32_to_cpu(sb->magic) != F2FS_SUPER_MAGIC) {
+ SLOGE("Not a valid F2FS super block. Magic:%#08x != %#08x",
+ le32_to_cpu(sb->magic), F2FS_SUPER_MAGIC);
+ return -1;
+ }
+ return 0;
+}
+
+unsigned int get_f2fs_filesystem_size_sec(char *dev)
+{
+ int fd;
+ if ((fd = open(dev, O_RDONLY)) < 0) {
+ SLOGE("Cannot open device to get filesystem size ");
+ return 0;
+ }
+ struct f2fs_super_block sb;
+ if(read_f2fs_sb(fd, &sb))
+ return 0;
+ return (unsigned int)(le64_to_cpu(sb.block_count)*F2FS_BLKSIZE/DEFAULT_SECTOR_SIZE);
+}
+
+static struct f2fs_checkpoint *validate_checkpoint(block_t cp_addr,
+ unsigned long long *version, int fd)
+{
+ unsigned char *cp_block_1, *cp_block_2;
+ struct f2fs_checkpoint *cp_block, *cp_ret;
+ u64 cp1_version = 0, cp2_version = 0;
+
+ cp_block_1 = malloc(F2FS_BLKSIZE);
+ if (!cp_block_1)
+ return NULL;
+
+ /* Read the 1st cp block in this CP pack */
+ if (read_structure_blk(fd, cp_addr, cp_block_1, 1))
+ goto invalid_cp1;
+
+ /* get the version number */
+ cp_block = (struct f2fs_checkpoint *)cp_block_1;
+
+ cp1_version = le64_to_cpu(cp_block->checkpoint_ver);
+
+ cp_block_2 = malloc(F2FS_BLKSIZE);
+ if (!cp_block_2) {
+ goto invalid_cp1;
+ }
+ /* Read the 2nd cp block in this CP pack */
+ cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
+ if (read_structure_blk(fd, cp_addr, cp_block_2, 1)) {
+ goto invalid_cp2;
+ }
+
+ cp_block = (struct f2fs_checkpoint *)cp_block_2;
+
+ cp2_version = le64_to_cpu(cp_block->checkpoint_ver);
+
+ if (cp2_version == cp1_version) {
+ *version = cp2_version;
+ free(cp_block_2);
+ return (struct f2fs_checkpoint *)cp_block_1;
+ }
+
+ /* There must be something wrong with this checkpoint */
+invalid_cp2:
+ free(cp_block_2);
+invalid_cp1:
+ free(cp_block_1);
+ return NULL;
+}
+
+int get_valid_checkpoint_info(int fd, struct f2fs_super_block *sb, struct f2fs_checkpoint **cp, struct f2fs_info *info)
+{
+ struct f2fs_checkpoint *cp_block;
+
+ struct f2fs_checkpoint *cp1, *cp2, *cur_cp;
+ int cur_cp_no;
+ unsigned long blk_size;// = 1<<le32_to_cpu(info->sb->log_blocksize);
+ unsigned long long cp1_version = 0, cp2_version = 0;
+ unsigned long long cp1_start_blk_no;
+ unsigned long long cp2_start_blk_no;
+ u32 bmp_size;
+
+ blk_size = 1U<<le32_to_cpu(sb->log_blocksize);
+
+ /*
+ * Find valid cp by reading both packs and finding most recent one.
+ */
+ cp1_start_blk_no = le32_to_cpu(sb->cp_blkaddr);
+ cp1 = validate_checkpoint(cp1_start_blk_no, &cp1_version, fd);
+
+ /* The second checkpoint pack should start at the next segment */
+ cp2_start_blk_no = cp1_start_blk_no + (1 << le32_to_cpu(sb->log_blocks_per_seg));
+ cp2 = validate_checkpoint(cp2_start_blk_no, &cp2_version, fd);
+
+ if (cp1 && cp2) {
+ if (ver_after(cp2_version, cp1_version)) {
+ cur_cp = cp2;
+ info->cp_valid_cp_blkaddr = cp2_start_blk_no;
+ free(cp1);
+ } else {
+ cur_cp = cp1;
+ info->cp_valid_cp_blkaddr = cp1_start_blk_no;
+ free(cp2);
+ }
+ } else if (cp1) {
+ cur_cp = cp1;
+ info->cp_valid_cp_blkaddr = cp1_start_blk_no;
+ } else if (cp2) {
+ cur_cp = cp2;
+ info->cp_valid_cp_blkaddr = cp2_start_blk_no;
+ } else {
+ goto fail_no_cp;
+ }
+
+ *cp = cur_cp;
+
+ return 0;
+
+fail_no_cp:
+ SLOGE("Valid Checkpoint not found!!");
+ return -EINVAL;
+}
+
+static int gather_sit_info(int fd, struct f2fs_info *info)
+{
+ u64 num_segments = (info->total_blocks - info->main_blkaddr
+ + info->blocks_per_segment - 1) / info->blocks_per_segment;
+ u64 num_sit_blocks = (num_segments + SIT_ENTRY_PER_BLOCK - 1) / SIT_ENTRY_PER_BLOCK;
+ u64 sit_block;
+
+ info->sit_blocks = malloc(num_sit_blocks * sizeof(struct f2fs_sit_block));
+ if (!info->sit_blocks)
+ return -1;
+
+ for(sit_block = 0; sit_block<num_sit_blocks; sit_block++) {
+ off64_t address = info->sit_blkaddr + sit_block;
+
+ if (f2fs_test_bit(sit_block, info->sit_bmp))
+ address += info->blocks_per_sit;
+
+ SLOGD("Reading cache block starting at block %"PRIu64, address);
+ if (read_structure(fd, address * F2FS_BLKSIZE, &info->sit_blocks[sit_block], sizeof(struct f2fs_sit_block))) {
+ SLOGE("Could not read sit block at block %"PRIu64, address);
+ free(info->sit_blocks);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static inline int is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
+{
+ unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
+ return !!(ckpt_flags & f);
+}
+
+static inline u64 sum_blk_addr(struct f2fs_checkpoint *cp, struct f2fs_info *info, int base, int type)
+{
+ return info->cp_valid_cp_blkaddr + le32_to_cpu(cp->cp_pack_total_block_count)
+ - (base + 1) + type;
+}
+
+static int get_sit_summary(int fd, struct f2fs_info *info, struct f2fs_checkpoint *cp)
+{
+ char buffer[F2FS_BLKSIZE];
+
+ info->sit_sums = calloc(1, sizeof(struct f2fs_summary_block));
+ if (!info->sit_sums)
+ return -1;
+
+ /* CURSEG_COLD_DATA where the journaled SIT entries are. */
+ if (is_set_ckpt_flags(cp, CP_COMPACT_SUM_FLAG)) {
+ if (read_structure_blk(fd, info->cp_valid_cp_blkaddr + le32_to_cpu(cp->cp_pack_start_sum), buffer, 1))
+ return -1;
+ memcpy(&info->sit_sums->n_sits, &buffer[SUM_JOURNAL_SIZE], SUM_JOURNAL_SIZE);
+ } else {
+ u64 blk_addr;
+ if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG))
+ blk_addr = sum_blk_addr(cp, info, NR_CURSEG_TYPE, CURSEG_COLD_DATA);
+ else
+ blk_addr = sum_blk_addr(cp, info, NR_CURSEG_DATA_TYPE, CURSEG_COLD_DATA);
+
+ if (read_structure_blk(fd, blk_addr, buffer, 1))
+ return -1;
+
+ memcpy(info->sit_sums, buffer, sizeof(struct f2fs_summary_block));
+ }
+ return 0;
+}
+
+struct f2fs_info *generate_f2fs_info(int fd)
+{
+ struct f2fs_super_block *sb = NULL;
+ struct f2fs_checkpoint *cp = NULL;
+ struct f2fs_info *info;
+
+ info = calloc(1, sizeof(*info));
+ if (!info) {
+ SLOGE("Out of memory!");
+ return NULL;
+ }
+
+ sb = malloc(sizeof(*sb));
+ if(!sb) {
+ SLOGE("Out of memory!");
+ free(info);
+ return NULL;
+ }
+ if (read_f2fs_sb(fd, sb)) {
+ SLOGE("Failed to read superblock");
+ free(info);
+ free(sb);
+ return NULL;
+ }
+ dbg_print_raw_sb_info(sb);
+
+ info->cp_blkaddr = le32_to_cpu(sb->cp_blkaddr);
+ info->sit_blkaddr = le32_to_cpu(sb->sit_blkaddr);
+ info->nat_blkaddr = le32_to_cpu(sb->nat_blkaddr);
+ info->ssa_blkaddr = le32_to_cpu(sb->ssa_blkaddr);
+ info->main_blkaddr = le32_to_cpu(sb->main_blkaddr);
+ info->block_size = F2FS_BLKSIZE;
+ info->total_blocks = sb->block_count;
+ info->blocks_per_sit = (le32_to_cpu(sb->segment_count_sit) >> 1) << le32_to_cpu(sb->log_blocks_per_seg);
+ info->blocks_per_segment = 1U << le32_to_cpu(sb->log_blocks_per_seg);
+
+ if (get_valid_checkpoint_info(fd, sb, &cp, info))
+ goto error;
+ dbg_print_raw_ckpt_struct(cp);
+
+ info->total_user_used = le32_to_cpu(cp->valid_block_count);
+
+ u32 bmp_size = le32_to_cpu(cp->sit_ver_bitmap_bytesize);
+
+ /* get sit validity bitmap */
+ info->sit_bmp = malloc(bmp_size);
+ if(!info->sit_bmp) {
+ SLOGE("Out of memory!");
+ goto error;
+ }
+
+ info->sit_bmp_size = bmp_size;
+ if (read_structure(fd, info->cp_valid_cp_blkaddr * F2FS_BLKSIZE
+ + offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap),
+ info->sit_bmp, bmp_size)) {
+ SLOGE("Error getting SIT validity bitmap");
+ goto error;
+ }
+
+ if (gather_sit_info(fd , info)) {
+ SLOGE("Error getting SIT information");
+ goto error;
+ }
+ if (get_sit_summary(fd, info, cp)) {
+ SLOGE("Error getting SIT entries in summary area");
+ goto error;
+ }
+ dbg_print_info_struct(info);
+ return info;
+error:
+ free(sb);
+ free(cp);
+ free_f2fs_info(info);
+ return NULL;
+}
+
+void free_f2fs_info(struct f2fs_info *info)
+{
+ if (info) {
+ free(info->sit_blocks);
+ info->sit_blocks = NULL;
+
+ free(info->sit_bmp);
+ info->sit_bmp = NULL;
+
+ free(info->sit_sums);
+ info->sit_sums = NULL;
+ }
+ free(info);
+}
+
+u64 get_num_blocks_used(struct f2fs_info *info)
+{
+ return info->main_blkaddr + info->total_user_used;
+}
+
+int f2fs_test_bit(unsigned int nr, const char *p)
+{
+ int mask;
+ char *addr = (char *)p;
+
+ addr += (nr >> 3);
+ mask = 1 << (7 - (nr & 0x07));
+ return (mask & *addr) != 0;
+}
+
+int run_on_used_blocks(u64 startblock, struct f2fs_info *info, int (*func)(u64 pos, void *data), void *data) {
+ struct f2fs_sit_block sit_block_cache;
+ struct f2fs_sit_entry * sit_entry;
+ u64 sit_block_num_cur = 0, segnum = 0, block_offset;
+ u64 block;
+ unsigned int used, found, started = 0, i;
+
+ for (block=startblock; block<info->total_blocks; block++) {
+ /* TODO: Save only relevant portions of metadata */
+ if (block < info->main_blkaddr) {
+ if (func(block, data)) {
+ SLOGI("func error");
+ return -1;
+ }
+ } else {
+ /* Main Section */
+ segnum = (block - info->main_blkaddr)/info->blocks_per_segment;
+
+ /* check the SIT entries in the journal */
+ found = 0;
+ for(i = 0; i < le16_to_cpu(info->sit_sums->n_sits); i++) {
+ if (le32_to_cpu(segno_in_journal(info->sit_sums, i)) == segnum) {
+ sit_entry = &sit_in_journal(info->sit_sums, i);
+ found = 1;
+ break;
+ }
+ }
+
+ /* get SIT entry from SIT section */
+ if (!found) {
+ sit_block_num_cur = segnum/SIT_ENTRY_PER_BLOCK;
+ sit_entry = &info->sit_blocks[sit_block_num_cur].entries[segnum % SIT_ENTRY_PER_BLOCK];
+ }
+
+ block_offset = (block - info->main_blkaddr) % info->blocks_per_segment;
+
+ used = f2fs_test_bit(block_offset, (char *)sit_entry->valid_map);
+ if(used)
+ if (func(block, data))
+ return -1;
+ }
+ }
+ return 0;
+}
+
+struct privdata
+{
+ int count;
+ int infd;
+ int outfd;
+ char* buf;
+ char *zbuf;
+ int done;
+ struct f2fs_info *info;
+};
+
+
+/*
+ * This is a simple test program. It performs a block to block copy of a
+ * filesystem, replacing blocks identified as unused with 0's.
+ */
+
+int copy_used(u64 pos, void *data)
+{
+ struct privdata *d = data;
+ char *buf;
+ int pdone = (pos*100)/d->info->total_blocks;
+ if (pdone > d->done) {
+ d->done = pdone;
+ printf("Done with %d percent\n", d->done);
+ }
+
+ d->count++;
+ buf = d->buf;
+ if(read_structure_blk(d->infd, (unsigned long long)pos, d->buf, 1)) {
+ printf("Error reading!!!\n");
+ return -1;
+ }
+
+ off64_t ret;
+ ret = lseek64(d->outfd, pos*F2FS_BLKSIZE, SEEK_SET);
+ if (ret < 0) {
+ SLOGE("failed to seek\n");
+ return ret;
+ }
+
+ ret = write(d->outfd, d->buf, F2FS_BLKSIZE);
+ if (ret < 0) {
+ SLOGE("failed to write\n");
+ return ret;
+ }
+ if (ret != F2FS_BLKSIZE) {
+ SLOGE("failed to read all\n");
+ return -1;
+ }
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ if (argc != 3)
+ printf("Usage: %s fs_file_in fs_file_out\n", argv[0]);
+ char *in = argv[1];
+ char *out = argv[2];
+ int infd, outfd;
+
+ if ((infd = open(in, O_RDONLY)) < 0) {
+ SLOGE("Cannot open device");
+ return 0;
+ }
+ if ((outfd = open(out, O_WRONLY|O_CREAT, S_IRUSR | S_IWUSR)) < 0) {
+ SLOGE("Cannot open output");
+ return 0;
+ }
+
+ struct privdata d;
+ d.infd = infd;
+ d.outfd = outfd;
+ d.count = 0;
+ struct f2fs_info *info = generate_f2fs_info(infd);
+ if (!info) {
+ printf("Failed to generate info!");
+ return -1;
+ }
+ char *buf = malloc(F2FS_BLKSIZE);
+ char *zbuf = calloc(1, F2FS_BLKSIZE);
+ d.buf = buf;
+ d.zbuf = zbuf;
+ d.done = 0;
+ d.info = info;
+ int expected_count = get_num_blocks_used(info);
+ run_on_used_blocks(0, info, ©_used, &d);
+ printf("Copied %d blocks. Expected to copy %d\n", d.count, expected_count);
+ ftruncate64(outfd, info->total_blocks * F2FS_BLKSIZE);
+ free_f2fs_info(info);
+ free(buf);
+ free(zbuf);
+ close(infd);
+ close(outfd);
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright (C) 2014 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 F2FS_UTILS_F2F2_UTILS_H_
+#define F2FS_UTILS_F2F2_UTILS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+
+
+#define ver_after(a, b) (typecheck(unsigned long long, a) && \
+ typecheck(unsigned long long, b) && \
+ ((long long)((a) - (b)) > 0))
+
+#define ver_equal(a, b) (typecheck(unsigned long long, a) && \
+ typecheck(unsigned long long, b) && \
+ ((long long)((a) - (b)) == 0))
+
+struct f2fs_sit_block;
+struct f2fs_summary_block;
+
+struct f2fs_info {
+ u_int64_t blocks_per_segment;
+ u_int32_t block_size;
+
+ char *sit_bmp;
+ u_int32_t sit_bmp_size;
+ u_int64_t blocks_per_sit;
+ struct f2fs_sit_block *sit_blocks;
+ struct f2fs_summary_block *sit_sums;
+
+ u_int64_t cp_blkaddr;
+ u_int64_t cp_valid_cp_blkaddr;
+
+ u_int64_t sit_blkaddr;
+
+ u_int64_t nat_blkaddr;
+
+ u_int64_t ssa_blkaddr;
+
+ u_int64_t main_blkaddr;
+
+ u_int64_t total_user_used;
+ u_int64_t total_blocks;
+};
+
+u64 get_num_blocks_used(struct f2fs_info *info);
+struct f2fs_info *generate_f2fs_info(int fd);
+void free_f2fs_info(struct f2fs_info *info);
+unsigned int get_f2fs_filesystem_size_sec(char *dev);
+int run_on_used_blocks(u64 startblock, struct f2fs_info *info, int (*func)(u64 pos, void *data), void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // F2FS_UTILS_F2F2_UTILS_H_
continue;
}
for (j = 0; j < map_len; j++) {
- error = pm_kernel_flags(ker, pagemap[j], &flags);
+ error = pm_kernel_flags(ker, PM_PAGEMAP_PFN(pagemap[j]), &flags);
if (error) {
fprintf(stderr, "warning: could not read flags for pfn at address 0x%016" PRIx64 "\n",
pagemap[i]);
kp->pages = tmp;
kp->size += GROWTH_FACTOR;
}
- rc = pm_kernel_count(ker, pagemap[j], &kp->pages[kp->len].count);
+ rc = pm_kernel_count(ker, PM_PAGEMAP_PFN(pagemap[j]), &kp->pages[kp->len].count);
if (rc) {
fprintf(stderr, "error reading page count\n");
free(pagemap);
--- /dev/null
+# Copyright (C) 2014 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := puncture_fs.c
+
+LOCAL_C_INCLUDES += system/core/logwrapper/include
+
+LOCAL_SHARED_LIBRARIES := libc liblog liblogwrap
+
+LOCAL_MODULE := puncture_fs
+
+LOCAL_MODULE_TAGS := debug
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+
+include $(BUILD_EXECUTABLE)
--- /dev/null
+/*
+ * Copyright (C) 2014 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 <assert.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <logwrap/logwrap.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <utils/Log.h>
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+#define MAX_IO_WRITE_CHUNK_SIZE 0x100000
+
+#ifndef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+typedef unsigned long u64;
+
+static void usage(const char * const progname) {
+ fprintf(stderr,
+ "Usage: %s [-s <seed>] -h <hole size in bytes> -t <total hole size in bytes> "
+ "path\n",
+ progname);
+}
+
+static u64 get_free_space(const char * const path) {
+ struct statvfs s;
+
+ if (statvfs(path, &s) < 0) {
+ fprintf(stderr, "\nerrno: %d. Failed to get free disk space on %s\n",
+ errno, path);
+ return 0;
+ } else {
+ return (u64)s.f_bsize * (u64)s.f_bfree;
+ }
+}
+
+static u64 get_random_num(const u64 start, const u64 end) {
+ if (end - start <= 0)
+ return start;
+ assert(RAND_MAX >= 0x7FFFFFFF);
+ if ((end - start) > 0x7FFFFFFF)
+ return start + (((u64)random() << 31) | (u64)random()) % (end - start);
+ return start + (random() % (end - start));
+}
+
+static char get_random_char() {
+ return 'A' + random() % ('Z' - 'A');
+}
+
+static bool create_unique_file(const char * const dir_path, const u64 size,
+ const u64 id, char * const base,
+ const u64 base_length) {
+ u64 length = 0;
+ int fd;
+ char file_path[FILENAME_MAX];
+ bool ret = true;
+
+ base[random() % min(base_length, size)] = get_random_char();
+
+ sprintf(file_path, "%s/file_%lu", dir_path, id);
+ fd = open(file_path, O_WRONLY | O_CREAT | O_SYNC, 0777);
+ if (fd < 0) {
+ // We suppress ENOSPC erros as that is common as we approach the
+ // last few MBs of the fs as we don't account for the size of the newly
+ // added meta data after the initial free space computation.
+ if (errno != 28) {
+ fprintf(stderr, "\nerrno: %d. Failed to create %s\n", errno, file_path);
+ }
+ return false;
+ }
+ while (length + base_length < size) {
+ if (write(fd, base, base_length) < 0) {
+ if (errno != 28) {
+ fprintf(stderr, "\nerrno: %d. Failed to write %lu bytes to %s\n",
+ errno, base_length, file_path);
+ }
+ ret = false;
+ goto done;
+ }
+ length += base_length;
+ }
+ if (write(fd, base, size - length) < 0) {
+ if (errno != 28) {
+ fprintf(stderr, "\nerrno: %d. Failed to write last %lu bytes to %s\n",
+ errno, size - length, file_path);
+ }
+ ret = false;
+ goto done;
+ }
+done:
+ if (close(fd) < 0) {
+ fprintf(stderr, "\nFailed to close %s\n", file_path);
+ ret = false;
+ }
+ return ret;
+}
+
+static bool create_unique_dir(char *dir, const char * const root_path) {
+ char random_string[15];
+ int i;
+
+ for (i = 0; i < 14; ++i) {
+ random_string[i] = get_random_char();
+ }
+ random_string[14] = '\0';
+
+ sprintf(dir, "%s/%s", root_path, random_string);
+
+ if (mkdir(dir, 0777) < 0) {
+ fprintf(stderr, "\nerrno: %d. Failed to create %s\n", errno, dir);
+ return false;
+ }
+ return true;
+}
+
+static bool puncture_fs (const char * const path, const u64 total_size,
+ const u64 hole_size, const u64 total_hole_size) {
+ u64 increments = (hole_size * total_size) / total_hole_size;
+ u64 hole_max;
+ u64 starting_max = 0;
+ u64 ending_max = increments;
+ char stay_dir[FILENAME_MAX], delete_dir[FILENAME_MAX];
+ char *rm_bin_argv[] = { "/system/bin/rm", "-rf", ""};
+ u64 file_id = 1;
+ char *base_file_data;
+ u64 i = 0;
+
+ if (!create_unique_dir(stay_dir, path) ||
+ !create_unique_dir(delete_dir, path)) {
+ return false;
+ }
+
+ base_file_data = (char*) malloc(MAX_IO_WRITE_CHUNK_SIZE);
+ for (i = 0; i < MAX_IO_WRITE_CHUNK_SIZE; ++i) {
+ base_file_data[i] = get_random_char();
+ }
+ fprintf(stderr, "\n");
+ while (ending_max <= total_size) {
+ fprintf(stderr, "\rSTAGE 1/2: %d%% Complete",
+ (int) (100.0 * starting_max / total_size));
+ hole_max = get_random_num(starting_max, ending_max);
+
+ create_unique_file(stay_dir,
+ hole_max - starting_max,
+ file_id++,
+ base_file_data,
+ MAX_IO_WRITE_CHUNK_SIZE);
+ create_unique_file(delete_dir,
+ hole_size,
+ file_id++,
+ base_file_data,
+ MAX_IO_WRITE_CHUNK_SIZE);
+
+ starting_max = hole_max + hole_size;
+ ending_max += increments;
+ }
+ create_unique_file(stay_dir,
+ (ending_max - increments - starting_max),
+ file_id++,
+ base_file_data,
+ MAX_IO_WRITE_CHUNK_SIZE);
+ fprintf(stderr, "\rSTAGE 1/2: 100%% Complete\n");
+ fprintf(stderr, "\rSTAGE 2/2: 0%% Complete");
+ free(base_file_data);
+ rm_bin_argv[2] = delete_dir;
+ if (android_fork_execvp_ext(ARRAY_SIZE(rm_bin_argv), rm_bin_argv,
+ NULL, 1, LOG_KLOG, 0, NULL) < 0) {
+ fprintf(stderr, "\nFailed to delete %s\n", rm_bin_argv[2]);
+ return false;
+ }
+ fprintf(stderr, "\rSTAGE 2/2: 100%% Complete\n");
+ return true;
+}
+
+int main (const int argc, char ** const argv) {
+ int opt;
+ int mandatory_opt;
+ char *path = NULL;
+ int seed = time(NULL);
+
+ u64 total_size = 0;
+ u64 hole_size = 0;
+ u64 total_hole_size = 0;
+
+ mandatory_opt = 2;
+ while ((opt = getopt(argc, argv, "s:h:t:")) != -1) {
+ switch(opt) {
+ case 's':
+ seed = atoi(optarg);
+ break;
+ case 'h':
+ hole_size = atoll(optarg);
+ mandatory_opt--;
+ break;
+ case 't':
+ total_hole_size = atoll(optarg);
+ mandatory_opt--;
+ break;
+ default:
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ }
+ if (mandatory_opt) {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ if (optind >= argc) {
+ fprintf(stderr, "\nExpected path name after options.\n");
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ path = argv[optind++];
+
+ if (optind < argc) {
+ fprintf(stderr, "\nUnexpected argument: %s\n", argv[optind]);
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+
+ srandom(seed);
+ fprintf(stderr, "\nRandom seed is: %d\n", seed);
+
+ total_size = get_free_space(path);
+ if (!total_size) {
+ exit(EXIT_FAILURE);
+ }
+ if (total_size < total_hole_size || total_hole_size < hole_size) {
+ fprintf(stderr, "\nInvalid sizes: total available size should be "
+ "larger than total hole size which is larger than "
+ "hole size\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (!puncture_fs(path, total_size, hole_size, total_hole_size)) {
+ exit(EXIT_FAILURE);
+ }
+ return 0;
+}
static int parse_field(mapinfo* mi, const char* line) {
char field[64];
- int size;
-
- if (sscanf(line, "%63s %d kB", field, &size) != 2) {
- return -1;
- }
+ int len;
- if (!strcmp(field, "Size:")) {
- mi->size = size;
- } else if (!strcmp(field, "Rss:")) {
- mi->rss = size;
- } else if (!strcmp(field, "Pss:")) {
- mi->pss = size;
- } else if (!strcmp(field, "Shared_Clean:")) {
- mi->shared_clean = size;
- } else if (!strcmp(field, "Shared_Dirty:")) {
- mi->shared_dirty = size;
- } else if (!strcmp(field, "Private_Clean:")) {
- mi->private_clean = size;
- } else if (!strcmp(field, "Private_Dirty:")) {
- mi->private_dirty = size;
+ if (sscanf(line, "%63s %n", field, &len) == 1
+ && *field && field[strlen(field) - 1] == ':') {
+ int size;
+ if (sscanf(line + len, "%d kB", &size) == 1) {
+ if (!strcmp(field, "Size:")) {
+ mi->size = size;
+ } else if (!strcmp(field, "Rss:")) {
+ mi->rss = size;
+ } else if (!strcmp(field, "Pss:")) {
+ mi->pss = size;
+ } else if (!strcmp(field, "Shared_Clean:")) {
+ mi->shared_clean = size;
+ } else if (!strcmp(field, "Shared_Dirty:")) {
+ mi->shared_dirty = size;
+ } else if (!strcmp(field, "Private_Clean:")) {
+ mi->private_clean = size;
+ } else if (!strcmp(field, "Private_Dirty:")) {
+ mi->private_dirty = size;
+ }
+ }
+ return 0;
}
-
- return 0;
+ return -1;
}
static int order_before(const mapinfo *a, const mapinfo *b, int sort_by_address) {
--- /dev/null
+# Copyright 2013 The Android Open Source Project
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+ taskstats.c
+
+LOCAL_SHARED_LIBRARIES := \
+ libnl
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE:= taskstats
+
+include $(BUILD_EXECUTABLE)
--- /dev/null
+
+ Copyright (c) 2005-2008, 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.
+
+ 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.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
--- /dev/null
+/*
+ * Copyright (C) 2013 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.
+ */
+
+/*
+ * Linux task stats reporting tool. Queries and prints out the kernel's
+ * taskstats structure for a given process or thread group id. See
+ * https://www.kernel.org/doc/Documentation/accounting/ for more information
+ * about the reported fields.
+ */
+
+#include <errno.h>
+#include <getopt.h>
+#include <netlink/attr.h>
+#include <netlink/genl/genl.h>
+#include <netlink/handlers.h>
+#include <netlink/msg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/cdefs.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <linux/taskstats.h>
+
+struct TaskStatistics {
+ int pid;
+ int tgid;
+ struct taskstats stats;
+};
+
+int send_command(struct nl_sock* netlink_socket, uint16_t nlmsg_type,
+ uint32_t nlmsg_pid, uint8_t genl_cmd, uint16_t nla_type,
+ void* nla_data, int nla_len) {
+ struct nl_msg* message = nlmsg_alloc();
+ int seq = 0;
+ int version = 1;
+ int header_length = 0;
+ int flags = NLM_F_REQUEST;
+ genlmsg_put(message, nlmsg_pid, seq, nlmsg_type, header_length, flags,
+ genl_cmd, version);
+ nla_put(message, nla_type, nla_len, nla_data);
+
+ /* Override the header flags since we don't want NLM_F_ACK. */
+ struct nlmsghdr* header = nlmsg_hdr(message);
+ header->nlmsg_flags = flags;
+
+ int result = nl_send(netlink_socket, message);
+ nlmsg_free(message);
+ return result;
+}
+
+int print_receive_error(struct sockaddr_nl* address __unused,
+ struct nlmsgerr* error, void* arg __unused) {
+ fprintf(stderr, "Netlink receive error: %s\n", strerror(-error->error));
+ return NL_STOP;
+}
+
+int parse_family_id(struct nl_msg* msg, void* arg) {
+ struct genlmsghdr* gnlh = (struct genlmsghdr*)nlmsg_data(nlmsg_hdr(msg));
+ struct nlattr* attr = genlmsg_attrdata(gnlh, 0);
+ int remaining = genlmsg_attrlen(gnlh, 0);
+
+ do {
+ if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
+ *((int*)arg) = nla_get_u16(attr);
+ return NL_STOP;
+ }
+ } while ((attr = nla_next(attr, &remaining)));
+ return NL_OK;
+}
+
+int get_family_id(struct nl_sock* netlink_socket, const char* name) {
+ if (send_command(netlink_socket, GENL_ID_CTRL, getpid(),
+ CTRL_CMD_GETFAMILY,
+ CTRL_ATTR_FAMILY_NAME,
+ (void*)name, strlen(name) + 1) < 0) {
+ return 0;
+ }
+
+ int family_id = 0;
+ struct nl_cb* callbacks = nl_cb_get(nl_cb_alloc(NL_CB_VALID));
+ nl_cb_set(callbacks, NL_CB_VALID, NL_CB_DEFAULT, &parse_family_id,
+ &family_id);
+ nl_cb_err(callbacks, NL_CB_DEFAULT, &print_receive_error, NULL);
+
+ if (nl_recvmsgs(netlink_socket, callbacks) < 0) {
+ return 0;
+ }
+ nl_cb_put(callbacks);
+ return family_id;
+}
+
+void parse_aggregate_task_stats(struct nlattr* attr, int attr_size,
+ struct TaskStatistics* stats) {
+ do {
+ switch (attr->nla_type) {
+ case TASKSTATS_TYPE_PID:
+ stats->pid = nla_get_u32(attr);
+ break;
+ case TASKSTATS_TYPE_TGID:
+ stats->tgid = nla_get_u32(attr);
+ break;
+ case TASKSTATS_TYPE_STATS:
+ nla_memcpy(&stats->stats, attr, sizeof(stats->stats));
+ break;
+ default:
+ break;
+ }
+ } while ((attr = nla_next(attr, &attr_size)));
+}
+
+int parse_task_stats(struct nl_msg* msg, void* arg) {
+ struct TaskStatistics* stats = (struct TaskStatistics*)arg;
+ struct genlmsghdr* gnlh = (struct genlmsghdr*)nlmsg_data(nlmsg_hdr(msg));
+ struct nlattr* attr = genlmsg_attrdata(gnlh, 0);
+ int remaining = genlmsg_attrlen(gnlh, 0);
+
+ do {
+ switch (attr->nla_type) {
+ case TASKSTATS_TYPE_AGGR_PID:
+ case TASKSTATS_TYPE_AGGR_TGID:
+ parse_aggregate_task_stats(nla_data(attr), nla_len(attr),
+ stats);
+ break;
+ default:
+ break;
+ }
+ } while ((attr = nla_next(attr, &remaining)));
+ return NL_STOP;
+}
+
+int query_task_stats(struct nl_sock* netlink_socket, int family_id,
+ int command_type, int parameter,
+ struct TaskStatistics* stats) {
+ memset(stats, 0, sizeof(*stats));
+ int result = send_command(netlink_socket, family_id, getpid(),
+ TASKSTATS_CMD_GET, command_type, ¶meter,
+ sizeof(parameter));
+ if (result < 0) {
+ return result;
+ }
+
+ struct nl_cb* callbacks = nl_cb_get(nl_cb_alloc(NL_CB_VALID));
+ nl_cb_set(callbacks, NL_CB_VALID, NL_CB_DEFAULT, &parse_task_stats, stats);
+ nl_cb_err(callbacks, NL_CB_DEFAULT, &print_receive_error, &family_id);
+
+ result = nl_recvmsgs(netlink_socket, callbacks);
+ if (result < 0) {
+ return result;
+ }
+ nl_cb_put(callbacks);
+ return stats->pid || stats->tgid;
+}
+
+double average_ms(unsigned long long total, unsigned long long count) {
+ if (!count) {
+ return 0;
+ }
+ return ((double)total) / count / 1e6;
+}
+
+unsigned long long average_ns(unsigned long long total,
+ unsigned long long count) {
+ if (!count) {
+ return 0;
+ }
+ return total / count;
+}
+
+void print_task_stats(const struct TaskStatistics* stats,
+ int human_readable) {
+ const struct taskstats* s = &stats->stats;
+ printf("Basic task statistics\n");
+ printf("---------------------\n");
+ printf("%-25s%d\n", "Stats version:", s->version);
+ printf("%-25s%d\n", "Exit code:", s->ac_exitcode);
+ printf("%-25s0x%x\n", "Flags:", s->ac_flag);
+ printf("%-25s%d\n", "Nice value:", s->ac_nice);
+ printf("%-25s%s\n", "Command name:", s->ac_comm);
+ printf("%-25s%d\n", "Scheduling discipline:", s->ac_sched);
+ printf("%-25s%d\n", "UID:", s->ac_uid);
+ printf("%-25s%d\n", "GID:", s->ac_gid);
+ printf("%-25s%d\n", "PID:", s->ac_pid);
+ printf("%-25s%d\n", "PPID:", s->ac_ppid);
+
+ if (human_readable) {
+ time_t begin_time = s->ac_btime;
+ printf("%-25s%s", "Begin time:", ctime(&begin_time));
+ } else {
+ printf("%-25s%d sec\n", "Begin time:", s->ac_btime);
+ }
+ printf("%-25s%llu usec\n", "Elapsed time:", s->ac_etime);
+ printf("%-25s%llu usec\n", "User CPU time:", s->ac_utime);
+ printf("%-25s%llu\n", "Minor page faults:", s->ac_minflt);
+ printf("%-25s%llu\n", "Major page faults:", s->ac_majflt);
+ printf("%-25s%llu usec\n", "Scaled user time:", s->ac_utimescaled);
+ printf("%-25s%llu usec\n", "Scaled system time:", s->ac_stimescaled);
+
+ printf("\nDelay accounting\n");
+ printf("----------------\n");
+ printf(" %15s%15s%15s%15s%15s%15s\n",
+ "Count",
+ human_readable ? "Delay (ms)" : "Delay (ns)",
+ "Average delay",
+ "Real delay",
+ "Scaled real",
+ "Virtual delay");
+
+ if (!human_readable) {
+ printf("CPU %15llu%15llu%15llu%15llu%15llu%15llu\n",
+ s->cpu_count,
+ s->cpu_delay_total,
+ average_ns(s->cpu_delay_total, s->cpu_count),
+ s->cpu_run_real_total,
+ s->cpu_scaled_run_real_total,
+ s->cpu_run_virtual_total);
+ printf("IO %15llu%15llu%15llu\n",
+ s->blkio_count,
+ s->blkio_delay_total,
+ average_ns(s->blkio_delay_total, s->blkio_count));
+ printf("Swap %15llu%15llu%15llu\n",
+ s->swapin_count,
+ s->swapin_delay_total,
+ average_ns(s->swapin_delay_total, s->swapin_count));
+ printf("Reclaim%15llu%15llu%15llu\n",
+ s->freepages_count,
+ s->freepages_delay_total,
+ average_ns(s->freepages_delay_total, s->freepages_count));
+ } else {
+ const double ms_per_ns = 1e6;
+ printf("CPU %15llu%15.3f%15.3f%15.3f%15.3f%15.3f\n",
+ s->cpu_count,
+ s->cpu_delay_total / ms_per_ns,
+ average_ms(s->cpu_delay_total, s->cpu_count),
+ s->cpu_run_real_total / ms_per_ns,
+ s->cpu_scaled_run_real_total / ms_per_ns,
+ s->cpu_run_virtual_total / ms_per_ns);
+ printf("IO %15llu%15.3f%15.3f\n",
+ s->blkio_count,
+ s->blkio_delay_total / ms_per_ns,
+ average_ms(s->blkio_delay_total, s->blkio_count));
+ printf("Swap %15llu%15.3f%15.3f\n",
+ s->swapin_count,
+ s->swapin_delay_total / ms_per_ns,
+ average_ms(s->swapin_delay_total, s->swapin_count));
+ printf("Reclaim%15llu%15.3f%15.3f\n",
+ s->freepages_count,
+ s->freepages_delay_total / ms_per_ns,
+ average_ms(s->freepages_delay_total, s->freepages_count));
+ }
+
+ printf("\nExtended accounting fields\n");
+ printf("--------------------------\n");
+ if (human_readable && s->ac_stime) {
+ printf("%-25s%.3f MB\n", "Average RSS usage:",
+ (double)s->coremem / s->ac_stime);
+ printf("%-25s%.3f MB\n", "Average VM usage:",
+ (double)s->virtmem / s->ac_stime);
+ } else {
+ printf("%-25s%llu MB\n", "Accumulated RSS usage:", s->coremem);
+ printf("%-25s%llu MB\n", "Accumulated VM usage:", s->virtmem);
+ }
+ printf("%-25s%llu KB\n", "RSS high water mark:", s->hiwater_rss);
+ printf("%-25s%llu KB\n", "VM high water mark:", s->hiwater_vm);
+ printf("%-25s%llu\n", "IO bytes read:", s->read_char);
+ printf("%-25s%llu\n", "IO bytes written:", s->write_char);
+ printf("%-25s%llu\n", "IO read syscalls:", s->read_syscalls);
+ printf("%-25s%llu\n", "IO write syscalls:", s->write_syscalls);
+
+ printf("\nPer-task/thread statistics\n");
+ printf("--------------------------\n");
+ printf("%-25s%llu\n", "Voluntary switches:", s->nvcsw);
+ printf("%-25s%llu\n", "Involuntary switches:", s->nivcsw);
+}
+
+void print_usage() {
+ printf("Linux task stats reporting tool\n"
+ "\n"
+ "Usage: taskstats [options]\n"
+ "\n"
+ "Options:\n"
+ " --help This text\n"
+ " --pid PID Print stats for the process id PID\n"
+ " --tgid TGID Print stats for the thread group id TGID\n"
+ " --raw Print raw numbers instead of human readable units\n"
+ "\n"
+ "Either PID or TGID must be specified. For more documentation about "
+ "the reported fields, see\n"
+ "https://www.kernel.org/doc/Documentation/accounting/"
+ "taskstats-struct.txt\n");
+}
+
+int main(int argc, char** argv) {
+ int command_type = 0;
+ int pid = 0;
+ int human_readable = 1;
+
+ const struct option long_options[] = {
+ {"help", no_argument, 0, 0},
+ {"pid", required_argument, 0, 0},
+ {"tgid", required_argument, 0, 0},
+ {"raw", no_argument, 0, 0},
+ {0, 0, 0, 0}
+ };
+
+ while (1) {
+ int option_index;
+ int option_char = getopt_long_only(argc, argv, "", long_options,
+ &option_index);
+ if (option_char == -1) {
+ break;
+ }
+ switch (option_index) {
+ case 0:
+ print_usage();
+ return EXIT_SUCCESS;
+ case 1:
+ command_type = TASKSTATS_CMD_ATTR_PID;
+ pid = atoi(optarg);
+ break;
+ case 2:
+ command_type = TASKSTATS_CMD_ATTR_TGID;
+ pid = atoi(optarg);
+ break;
+ case 3:
+ human_readable = 0;
+ break;
+ default:
+ break;
+ };
+ }
+
+ if (!pid) {
+ printf("Either PID or TGID must be specified\n");
+ return EXIT_FAILURE;
+ }
+
+ struct nl_sock* netlink_socket = nl_socket_alloc();
+ if (!netlink_socket || genl_connect(netlink_socket) < 0) {
+ perror("Unable to open netlink socket (are you root?)");
+ goto error;
+ }
+
+ int family_id = get_family_id(netlink_socket, TASKSTATS_GENL_NAME);
+ if (!family_id) {
+ perror("Unable to determine taskstats family id "
+ "(does your kernel support taskstats?)");
+ goto error;
+ }
+ struct TaskStatistics stats;
+ if (query_task_stats(netlink_socket, family_id, command_type, pid,
+ &stats) < 0) {
+ perror("Failed to query taskstats");
+ goto error;
+ }
+ print_task_stats(&stats, human_readable);
+
+ nl_socket_free(netlink_socket);
+ return EXIT_SUCCESS;
+
+error:
+ if (netlink_socket) {
+ nl_socket_free(netlink_socket);
+ }
+ return EXIT_FAILURE;
+}
--- /dev/null
+#
+# Copyright (C) 2013 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 $(call all-subdir-makefiles)
--- /dev/null
+#
+# Copyright (C) 2013 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE_TAGS := tests
+LOCAL_MODULE := pcmtest
+LOCAL_SRC_FILES := pcmtest.cpp
+LOCAL_SHARED_LIBRARIES += libcutils libutils liblog libtinyalsa
+LOCAL_STATIC_LIBRARIES += libtestUtil
+LOCAL_C_INCLUDES += system/extras/tests/include external/tinyalsa/include
+
+include $(BUILD_NATIVE_TEST)
--- /dev/null
+/*
+ * Copyright (C) 2013 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 requied 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 <assert.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <gtest/gtest.h>
+#include <linux/ioctl.h>
+#define __force
+#define __bitwise
+#define __user
+#include <sound/asound.h>
+#include <sys/types.h>
+#include <tinyalsa/asoundlib.h>
+
+#define LOG_TAG "pcmtest"
+#include <utils/Log.h>
+#include <testUtil.h>
+
+#define PCM_PREFIX "pcm"
+#define MIXER_PREFIX "control"
+#define TIMER_PREFIX "timer"
+
+const char kSoundDir[] = "/dev/snd";
+
+typedef struct PCM_NODE {
+ unsigned int card;
+ unsigned int device;
+ unsigned int flags;
+} pcm_node_t;
+
+static pcm_node_t *pcmnodes;
+
+static unsigned int pcms;
+static unsigned int cards;
+static unsigned int mixers;
+static unsigned int timers;
+
+int getPcmNodes(void)
+{
+ DIR *d;
+ struct dirent *de;
+ unsigned int pcount = 0;
+
+ d = opendir(kSoundDir);
+ if (d == 0)
+ return 0;
+ while ((de = readdir(d)) != NULL) {
+ if (de->d_name[0] == '.')
+ continue;
+ if (strstr(de->d_name, PCM_PREFIX))
+ pcount++;
+ }
+ closedir(d);
+ return pcount;
+}
+
+int getSndDev(unsigned int pcmdevs)
+{
+ DIR *d;
+ struct dirent *de;
+ unsigned int prevcard = -1;
+
+ d = opendir(kSoundDir);
+ if (d == 0)
+ return -ENXIO;
+ pcmnodes = (pcm_node_t *)malloc(pcmdevs * sizeof(pcm_node_t));
+ if (!pcmnodes)
+ return -ENOMEM;
+ pcms = 0;
+ while ((de = readdir(d)) != NULL) {
+ if (de->d_name[0] == '.')
+ continue;
+ /* printf("%s\n", de->d_name); */
+ if (strstr(de->d_name, PCM_PREFIX)) {
+ char flags;
+
+ EXPECT_LE(pcms, pcmdevs) << "Too many PCMs";
+ if (pcms >= pcmdevs)
+ continue;
+ sscanf(de->d_name, PCM_PREFIX "C%uD%u", &(pcmnodes[pcms].card),
+ &(pcmnodes[pcms].device));
+ flags = de->d_name[strlen(de->d_name)-1];
+ if (flags == 'c') {
+ pcmnodes[pcms].flags = PCM_IN;
+ } else if(flags == 'p') {
+ pcmnodes[pcms].flags = PCM_OUT;
+ } else {
+ pcmnodes[pcms].flags = -1;
+ testPrintI("Unknown PCM type = %c", flags);
+ }
+ if (prevcard != pcmnodes[pcms].card)
+ cards++;
+ prevcard = pcmnodes[pcms].card;
+ pcms++;
+ continue;
+ }
+ if (strstr(de->d_name, MIXER_PREFIX)) {
+ unsigned int mixer = -1;
+ sscanf(de->d_name, MIXER_PREFIX "C%u", &mixer);
+ mixers++;
+ continue;
+ }
+ if (strstr(de->d_name, TIMER_PREFIX)) {
+ timers++;
+ continue;
+ }
+ }
+ closedir(d);
+ return 0;
+}
+
+int getPcmParams(unsigned int i)
+{
+ struct pcm_params *params;
+ unsigned int min;
+ unsigned int max;
+
+ params = pcm_params_get(pcmnodes[i].card, pcmnodes[i].device,
+ pcmnodes[i].flags);
+ if (params == NULL)
+ return -ENODEV;
+
+ min = pcm_params_get_min(params, PCM_PARAM_RATE);
+ max = pcm_params_get_max(params, PCM_PARAM_RATE);
+ EXPECT_LE(min, max);
+ /* printf(" Rate:\tmin=%uHz\tmax=%uHz\n", min, max); */
+ min = pcm_params_get_min(params, PCM_PARAM_CHANNELS);
+ max = pcm_params_get_max(params, PCM_PARAM_CHANNELS);
+ EXPECT_LE(min, max);
+ /* printf(" Channels:\tmin=%u\t\tmax=%u\n", min, max); */
+ min = pcm_params_get_min(params, PCM_PARAM_SAMPLE_BITS);
+ max = pcm_params_get_max(params, PCM_PARAM_SAMPLE_BITS);
+ EXPECT_LE(min, max);
+ /* printf(" Sample bits:\tmin=%u\t\tmax=%u\n", min, max); */
+ min = pcm_params_get_min(params, PCM_PARAM_PERIOD_SIZE);
+ max = pcm_params_get_max(params, PCM_PARAM_PERIOD_SIZE);
+ EXPECT_LE(min, max);
+ /* printf(" Period size:\tmin=%u\t\tmax=%u\n", min, max); */
+ min = pcm_params_get_min(params, PCM_PARAM_PERIODS);
+ max = pcm_params_get_max(params, PCM_PARAM_PERIODS);
+ EXPECT_LE(min, max);
+ /* printf("Period count:\tmin=%u\t\tmax=%u\n", min, max); */
+
+ pcm_params_free(params);
+ return 0;
+}
+
+TEST(pcmtest, CheckAudioDir) {
+ pcms = getPcmNodes();
+ ASSERT_GT(pcms, 0);
+}
+
+TEST(pcmtest, GetSoundDevs) {
+ int err = getSndDev(pcms);
+ testPrintI(" DEVICES = PCMS:%u CARDS:%u MIXERS:%u TIMERS:%u",
+ pcms, cards, mixers, timers);
+ ASSERT_EQ(0, err);
+}
+
+TEST(pcmtest, CheckPcmSanity0) {
+ ASSERT_NE(0, pcms);
+}
+
+TEST(pcmtest, CheckPcmSanity1) {
+ EXPECT_NE(1, pcms % 2);
+}
+
+TEST(pcmtests, CheckMixerSanity) {
+ ASSERT_NE(0, mixers);
+ ASSERT_EQ(mixers, cards);
+}
+
+TEST(pcmtest, CheckTimesSanity0) {
+ ASSERT_NE(0, timers);
+}
+
+TEST(pcmtest, CheckTimesSanity1) {
+ EXPECT_EQ(1, timers);
+}
+
+TEST(pcmtest, CheckPcmDevices) {
+ for (unsigned int i = 0; i < pcms; i++) {
+ EXPECT_EQ(0, getPcmParams(i));
+ }
+ free(pcmnodes);
+}
+
+TEST(pcmtest, CheckMixerDevices) {
+ struct mixer *mixer;
+ for (unsigned int i = 0; i < mixers; i++) {
+ mixer = mixer_open(i);
+ EXPECT_TRUE(mixer != NULL);
+ if (mixer)
+ mixer_close(mixer);
+ }
+}
+
+TEST(pcmtest, CheckTimer) {
+ int ver = 0;
+ int fd = open("/dev/snd/timer", O_RDWR | O_NONBLOCK);
+ ASSERT_GE(fd, 0);
+ int ret = ioctl(fd, SNDRV_TIMER_IOCTL_PVERSION, &ver);
+ EXPECT_EQ(0, ret);
+ testPrintI(" Timer Version = 0x%x", ver);
+ close(fd);
+}
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
-LOCAL_SRC_FILES:= corrupt_gdt_free_blocks.c
-LOCAL_MODULE:= corrupt_gdt_free_blocks
-LOCAL_MODULE_TAGS := debug
-LOCAL_C_INCLUDES += system/extras/ext4_utils
-
-include $(BUILD_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= set_ext4_err_bit.c
-LOCAL_MODULE:= set_ext4_err_bit
-LOCAL_MODULE_TAGS := debug
-
-include $(BUILD_EXECUTABLE)
-
-
-include $(CLEAR_VARS)
-
LOCAL_SRC_FILES:= rand_emmc_perf.c
-LOCAL_MODULE:= rand_emmc_perf
+LOCAL_MODULE:= rand_emmc_perf
LOCAL_MODULE_TAGS := optional
LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_STATIC_LIBRARIES := libm libc
+++ /dev/null
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "ext4.h"
-#include "ext4_utils.h"
-
-#define SB_OFFSET 1024
-
-int main(int argc, char *argv[])
-{
- char me[] = "corrupt_gdt_free_blocks";
- int fd;
- int block_size;
- int num_bgs;
- int i;
- struct ext4_super_block sb;
- struct ext2_group_desc gd;
-
- if (argc != 2) {
- fprintf(stderr, "%s: Usage: %s <ext4_block_device>\n", me, me);
- exit(1);
- }
-
- fd = open(argv[1], O_RDWR);
-
- if (fd < 0) {
- fprintf(stderr, "%s: Cannot open block device %s\n", me, argv[1]);
- exit(1);
- }
-
- if (lseek(fd, SB_OFFSET, SEEK_SET) == -1) {
- fprintf(stderr, "%s: Cannot lseek to superblock to read\n", me);
- exit(1);
- }
-
- if (read(fd, &sb, sizeof(sb)) != sizeof(sb)) {
- fprintf(stderr, "%s: Cannot read superblock\n", me);
- exit(1);
- }
-
- if (sb.s_magic != 0xEF53) {
- fprintf(stderr, "%s: invalid superblock magic\n", me);
- exit(1);
- }
-
- /* Make sure the block size is 2K or 4K */
- if ((sb.s_log_block_size != 1) && (sb.s_log_block_size != 2)) {
- fprintf(stderr, "%s: block size not 2K or 4K\n", me);
- exit(1);
- }
-
- block_size = 1 << (10 + sb.s_log_block_size);
- num_bgs = DIV_ROUND_UP(sb.s_blocks_count_lo, sb.s_blocks_per_group);
-
- if (sb.s_desc_size != sizeof(struct ext2_group_desc)) {
- fprintf(stderr, "%s: Can't handle block group descriptor size of %d\n",
- me, sb.s_desc_size);
- exit(1);
- }
-
- /* read first block group descriptor, decrement free block count, and
- * write it back out
- */
- if (lseek(fd, block_size, SEEK_SET) == -1) {
- fprintf(stderr, "%s: Cannot lseek to block group descriptor table to read\n", me);
- exit(1);
- }
-
- /* Read in block group descriptors till we read one that has at least one free block */
-
- for (i=0; i < num_bgs; i++) {
- if (read(fd, &gd, sizeof(gd)) != sizeof(gd)) {
- fprintf(stderr, "%s: Cannot read group descriptor %d\n", me, i);
- exit(1);
- }
- if (gd.bg_free_blocks_count) {
- break;
- }
- }
-
- gd.bg_free_blocks_count--;
-
- if (lseek(fd, -sizeof(gd), SEEK_CUR) == -1) {
- fprintf(stderr, "%s: Cannot lseek to block group descriptor table to write\n", me);
- exit(1);
- }
-
- if (write(fd, &gd, sizeof(gd)) != sizeof(gd)) {
- fprintf(stderr, "%s: Cannot write modified group descriptor\n", me);
- exit(1);
- }
-
- close(fd);
-
- return 0;
-}
-
+++ /dev/null
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define SB_OFFSET 1024
-#define SB_SIZE 1024
-#define EXT4_MAGIC_OFFSET 0x38
-#define EXT4_STATE_OFFSET 0x3A
-
-int main(int argc, char *argv[])
-{
- int fd;
- char me[] = "set_ext4_err_bit";
- unsigned char sb[1024];
-
- if (argc != 2) {
- fprintf(stderr, "%s: Usage: %s <ext4_block_device>\n", me, me);
- exit(1);
- }
-
- fd = open(argv[1], O_RDWR);
-
- if (fd < 0) {
- fprintf(stderr, "%s: Cannot open block device %s\n", me, argv[1]);
- exit(1);
- }
-
- if (lseek(fd, SB_OFFSET, SEEK_SET) == -1) {
- fprintf(stderr, "%s: Cannot lseek to superblock to read\n", me);
- exit(1);
- }
-
- if (read(fd, sb, SB_SIZE) != SB_SIZE) {
- fprintf(stderr, "%s: Cannot read superblock\n", me);
- exit(1);
- }
-
- if ((sb[EXT4_MAGIC_OFFSET] != 0x53) || (sb[EXT4_MAGIC_OFFSET+1] != 0xEF)) {
- fprintf(stderr, "%s: invalid superblock magic\n", me);
- exit(1);
- }
-
- /* Set the errors detected bit */
- sb[EXT4_STATE_OFFSET] |= 0x2;
-
- if (lseek(fd, SB_OFFSET, SEEK_SET) == -1) {
- fprintf(stderr, "%s: Cannot lseek to superblock to write\n", me);
- exit(1);
- }
-
- if (write(fd, sb, SB_SIZE) != SB_SIZE) {
- fprintf(stderr, "%s: Cannot write superblock\n", me);
- exit(1);
- }
-
- close(fd);
-
- return 0;
-}
-
LOCAL_SRC_FILES := $(LOCAL_MODULE)
include $(BUILD_PREBUILT)
+
+####
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_MODULE := recovery_test
+
+LOCAL_SRC_FILES := recovery_test.cpp
+
+LOCAL_SHARED_LIBRARIES += libcutils libutils liblog liblogwrap
+
+LOCAL_STATIC_LIBRARIES += libtestUtil libfs_mgr
+
+LOCAL_C_INCLUDES += system/extras/tests/include \
+ system/core/fs_mgr/include \
+ system/extras/ext4_utils \
+ system/core/logwrapper/include
+
+include $(BUILD_NATIVE_TEST)
--- /dev/null
+/*
+ * Copyright (C) 2014 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 requied 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.
+ *
+ */
+
+/*
+ * These file system recovery tests ensure the ability to recover from
+ * filesystem crashes in key blocks (e.g. superblock).
+ */
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fs_mgr.h>
+#include <gtest/gtest.h>
+#include <logwrap/logwrap.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "cutils/properties.h"
+#include "ext4.h"
+#include "ext4_utils.h"
+
+#define LOG_TAG "fsRecoveryTest"
+#include <utils/Log.h>
+#include <testUtil.h>
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#define FSTAB_PREFIX "/fstab."
+#define SB_OFFSET 1024
+#define UMOUNT_BIN "/system/bin/umount"
+#define VDC_BIN "/system/bin/vdc"
+
+enum Fs_Type { FS_UNKNOWN, FS_EXT4, FS_F2FS };
+
+namespace android {
+
+class DataFileVerifier {
+ public:
+ DataFileVerifier(const char* file_name) {
+ strncpy(test_file_, file_name, FILENAME_MAX);
+ }
+
+ void verify_write() {
+ int write_fd = open(test_file_, O_CREAT | O_WRONLY, 0666);
+ ASSERT_TRUE(write_fd);
+ ASSERT_EQ(write(write_fd, "TEST", 4), 4);
+ close(write_fd);
+ }
+
+ void verify_read() {
+ char read_buff[4];
+ int read_fd = open(test_file_, O_RDONLY);
+ ASSERT_TRUE(read_fd);
+ ASSERT_EQ(read(read_fd, read_buff, sizeof(read_buff)), 4);
+ ASSERT_FALSE(strncmp(read_buff, "TEST", 4));
+ close(read_fd);
+ }
+
+ ~DataFileVerifier() {
+ unlink(test_file_);
+ }
+
+ private:
+ char test_file_[FILENAME_MAX];
+};
+
+namespace ext4 {
+bool getSuperBlock(const int blk_fd, struct ext4_super_block* sb) {
+ if (lseek(blk_fd, SB_OFFSET, SEEK_SET) == -1) {
+ testPrintE("Cannot lseek to ext4 superblock to read");
+ return false;
+ }
+
+ if (read(blk_fd, sb, sizeof(*sb)) != sizeof(*sb)) {
+ testPrintE("Cannot read ext4 superblock");
+ return false;
+ }
+
+ if (sb->s_magic != 0xEF53) {
+ testPrintE("Invalid ext4 superblock magic");
+ return false;
+ }
+
+ return true;
+}
+
+bool setSbErrorBit(const int blk_fd) {
+ // Read super block.
+ struct ext4_super_block sb;
+ if (!getSuperBlock(blk_fd, &sb)) {
+ return false;
+ }
+
+ // Check that the detected errors bit is not set.
+ if (sb.s_state & 0x2) {
+ testPrintE("Ext4 superblock already corrupted");
+ return false;
+ }
+
+ // Set the detected errors bit.
+ sb.s_state |= 0x2;
+
+ // Write superblock.
+ if (lseek(blk_fd, SB_OFFSET, SEEK_SET) == -1) {
+ testPrintE("Cannot lseek to superblock to write\n");
+ return false;
+ }
+
+ if (write(blk_fd, &sb, sizeof(sb)) != sizeof(sb)) {
+ testPrintE("Cannot write superblock\n");
+ return false;
+ }
+
+ return true;
+}
+
+bool corruptGdtFreeBlock(const int blk_fd) {
+ // Read super block.
+ struct ext4_super_block sb;
+ if (!getSuperBlock(blk_fd, &sb)) {
+ return false;
+ }
+ // Make sure the block size is 2K or 4K.
+ if ((sb.s_log_block_size != 1) && (sb.s_log_block_size != 2)) {
+ testPrintE("Ext4 block size not 2K or 4K\n");
+ return false;
+ }
+ int block_size = 1 << (10 + sb.s_log_block_size);
+ int num_bgs = DIV_ROUND_UP(sb.s_blocks_count_lo, sb.s_blocks_per_group);
+
+ if (sb.s_desc_size != sizeof(struct ext2_group_desc)) {
+ testPrintE("Can't handle ext4 block group descriptor size of %d",
+ sb.s_desc_size);
+ return false;
+ }
+
+ // Read first block group descriptor, decrement free block count, and
+ // write it back out.
+ if (lseek(blk_fd, block_size, SEEK_SET) == -1) {
+ testPrintE("Cannot lseek to ext4 block group descriptor table to read");
+ return false;
+ }
+
+ // Read in block group descriptors till we read one that has at least one free
+ // block.
+ struct ext2_group_desc gd;
+ for (int i = 0; i < num_bgs; i++) {
+ if (read(blk_fd, &gd, sizeof(gd)) != sizeof(gd)) {
+ testPrintE("Cannot read ext4 group descriptor %d", i);
+ return false;
+ }
+ if (gd.bg_free_blocks_count) {
+ break;
+ }
+ }
+
+ gd.bg_free_blocks_count--;
+
+ if (lseek(blk_fd, -sizeof(gd), SEEK_CUR) == -1) {
+ testPrintE("Cannot lseek to ext4 block group descriptor table to write");
+ return false;
+ }
+
+ if (write(blk_fd, &gd, sizeof(gd)) != sizeof(gd)) {
+ testPrintE("Cannot write modified ext4 group descriptor");
+ return false;
+ }
+ return true;
+}
+
+} // namespace ext4
+
+class FsRecoveryTest : public ::testing::Test {
+ protected:
+ FsRecoveryTest() : fs_type(FS_UNKNOWN), blk_fd_(-1) {}
+
+ bool setCacheInfoFromFstab() {
+ fs_type = FS_UNKNOWN;
+ char propbuf[PROPERTY_VALUE_MAX];
+ property_get("ro.hardware", propbuf, "");
+ char fstab_filename[PROPERTY_VALUE_MAX + sizeof(FSTAB_PREFIX)];
+ snprintf(fstab_filename, sizeof(fstab_filename), FSTAB_PREFIX"%s", propbuf);
+
+ struct fstab *fstab = fs_mgr_read_fstab(fstab_filename);
+ if (!fstab) {
+ testPrintE("failed to open %s\n", fstab_filename);
+ } else {
+ // Loop through entries looking for cache.
+ for (int i = 0; i < fstab->num_entries; ++i) {
+ if (!strcmp(fstab->recs[i].mount_point, "/cache")) {
+ strcpy(blk_path_, fstab->recs[i].blk_device);
+ if (!strcmp(fstab->recs[i].fs_type, "ext4")) {
+ fs_type = FS_EXT4;
+ break;
+ } else if (!strcmp(fstab->recs[i].fs_type, "f2fs")) {
+ fs_type = FS_F2FS;
+ break;
+ }
+ }
+ }
+ fs_mgr_free_fstab(fstab);
+ }
+ return fs_type != FS_UNKNOWN;
+ }
+
+ bool unmountCache() {
+ char *umount_argv[] = {
+ UMOUNT_BIN,
+ "/cache"
+ };
+ int status;
+ return android_fork_execvp_ext(ARRAY_SIZE(umount_argv), umount_argv,
+ NULL, true, LOG_KLOG, false, NULL) >= 0;
+ }
+
+ bool mountAll() {
+ char *mountall_argv[] = {
+ VDC_BIN,
+ "storage",
+ "mountall"
+ };
+ int status;
+ return android_fork_execvp_ext(ARRAY_SIZE(mountall_argv), mountall_argv,
+ NULL, true, LOG_KLOG, false, NULL) >= 0;
+ }
+
+ int getCacheBlkFd() {
+ if (blk_fd_ == -1) {
+ blk_fd_ = open(blk_path_, O_RDWR);
+ }
+ return blk_fd_;
+ }
+
+ void closeCacheBlkFd() {
+ if (blk_fd_ > -1) {
+ close(blk_fd_);
+ }
+ blk_fd_ = -1;
+ }
+
+ void assertCacheHealthy() {
+ const char* test_file = "/cache/FsRecoveryTestGarbage.txt";
+ DataFileVerifier file_verify(test_file);
+ file_verify.verify_write();
+ file_verify.verify_read();
+ }
+
+ virtual void SetUp() {
+ assertCacheHealthy();
+ ASSERT_TRUE(setCacheInfoFromFstab());
+ }
+
+ virtual void TearDown() {
+ // Ensure /cache partition is accessible, mounted and healthy for other
+ // tests.
+ closeCacheBlkFd();
+ ASSERT_TRUE(mountAll());
+ assertCacheHealthy();
+ }
+
+ Fs_Type fs_type;
+
+ private:
+ char blk_path_[FILENAME_MAX];
+ int blk_fd_;
+};
+
+TEST_F(FsRecoveryTest, EXT4_CorruptGdt) {
+ if (fs_type != FS_EXT4) {
+ return;
+ }
+ // Setup test file in /cache.
+ const char* test_file = "/cache/CorruptGdtGarbage.txt";
+ DataFileVerifier file_verify(test_file);
+ file_verify.verify_write();
+ // Unmount and corrupt /cache gdt.
+ ASSERT_TRUE(unmountCache());
+ ASSERT_TRUE(ext4::corruptGdtFreeBlock(getCacheBlkFd()));
+ closeCacheBlkFd();
+ ASSERT_TRUE(mountAll());
+
+ // Verify results.
+ file_verify.verify_read();
+}
+
+TEST_F(FsRecoveryTest, EXT4_SetErrorBit) {
+ if (fs_type != FS_EXT4) {
+ return;
+ }
+ // Setup test file in /cache.
+ const char* test_file = "/cache/ErrorBitGarbagetxt";
+ DataFileVerifier file_verify(test_file);
+ file_verify.verify_write();
+
+ // Unmount and set /cache super block error bit.
+ ASSERT_TRUE(unmountCache());
+ ASSERT_TRUE(ext4::setSbErrorBit(getCacheBlkFd()));
+ closeCacheBlkFd();
+ ASSERT_TRUE(mountAll());
+
+ // Verify results.
+ file_verify.verify_read();
+ struct ext4_super_block sb;
+ ASSERT_TRUE(ext4::getSuperBlock(getCacheBlkFd(), &sb));
+ // Verify e2fsck has recovered the error bit of sb.
+ ASSERT_FALSE(sb.s_state & 0x2);
+}
+} // namespace android
--- /dev/null
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := suspend_stress.cpp
+LOCAL_MODULE := suspend_stress
+LOCAL_CFLAGS := -Wall -Werror
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+LOCAL_STATIC_LIBRARIES := libc libcutils
+include $(BUILD_EXECUTABLE)
--- /dev/null
+/*
+ * Copyright (C) 2014 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 <getopt.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+
+#include <cutils/klog.h>
+
+#define NSEC_PER_SEC (1000*1000*1000)
+#define MSEC_PER_SEC 1000
+#define NSEC_PER_MSEC (NSEC_PER_SEC/MSEC_PER_SEC)
+
+long long timediff_ns(const struct timespec *a, const struct timespec *b) {
+ return ((long long)(a->tv_sec - b->tv_sec)) * NSEC_PER_SEC +
+ (a->tv_nsec - b->tv_nsec);
+}
+
+void usage(void)
+{
+ printf("usage: suspend_stress [ <options> ]\n"
+ "options:\n"
+ " -a,--abort abort test on late alarm\n"
+ " -c,--count=<count> number of times to suspend (default infinite)\n"
+ " -t,--time=<seconds> time to suspend for (default 5)\n"
+ );
+}
+
+int main(int argc, char **argv)
+{
+ int alarm_time = 5;
+ int count = -1;
+ bool abort_on_failure = false;
+
+ while (1) {
+ const static struct option long_options[] = {
+ {"abort", no_argument, 0, 'a'},
+ {"count", required_argument, 0, 'c'},
+ {"time", required_argument, 0, 't'},
+ };
+ int c = getopt_long(argc, argv, "ac:t:", long_options, NULL);
+ if (c < 0) {
+ break;
+ }
+
+ switch (c) {
+ case 'a':
+ abort_on_failure = true;
+ break;
+ case 'c':
+ count = strtoul(optarg, NULL, 0);
+ break;
+ case 't':
+ alarm_time = strtoul(optarg, NULL, 0);
+ break;
+ case '?':
+ usage();
+ exit(EXIT_FAILURE);
+ default:
+ abort();
+ }
+ }
+
+ klog_init();
+ klog_set_level(KLOG_INFO_LEVEL);
+
+ if (optind < argc) {
+ fprintf(stderr, "Unexpected argument: %s\n", argv[optind]);
+ usage();
+ exit(EXIT_FAILURE);
+ }
+
+ int fd = timerfd_create(CLOCK_BOOTTIME_ALARM, 0);
+ if (fd < 0) {
+ perror("timerfd_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ struct itimerspec delay = itimerspec();
+ delay.it_value.tv_sec = alarm_time;
+ int i = 0;
+
+ int epoll_fd = epoll_create(1);
+ if (epoll_fd < 0) {
+ perror("epoll_create failed");
+ exit(EXIT_FAILURE);
+ }
+
+ struct epoll_event ev = epoll_event();
+ ev.events = EPOLLIN | EPOLLWAKEUP;
+ int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
+ if (ret < 0) {
+ perror("epoll_ctl failed");
+ exit(EXIT_FAILURE);
+ }
+
+ while (count != 0) {
+ struct timespec expected_time;
+ struct timespec actual_time;
+ uint64_t fired = 0;
+
+ ret = timerfd_settime(fd, 0, &delay, NULL);
+ if (ret < 0) {
+ perror("timerfd_settime failed");
+ exit(EXIT_FAILURE);
+ }
+
+ ret = clock_gettime(CLOCK_BOOTTIME, &expected_time);
+ if (ret < 0) {
+ perror("failed to get time");
+ exit(EXIT_FAILURE);
+ }
+ expected_time.tv_sec += alarm_time;
+
+ ret = 0;
+ while (ret != 1) {
+ struct epoll_event out_ev;
+ ret = epoll_wait(epoll_fd, &out_ev, 1, -1);
+ if (ret < 0 && errno != EINTR) {
+ perror("epoll_wait failed");
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ ssize_t bytes = read(fd, &fired, sizeof(fired));
+ if (bytes < 0) {
+ perror("read from timer fd failed");
+ exit(EXIT_FAILURE);
+ } else if (bytes < (ssize_t)sizeof(fired)) {
+ fprintf(stderr, "unexpected read from timer fd: %zd\n", bytes);
+ }
+
+ if (fired != 1) {
+ fprintf(stderr, "unexpected timer fd fired count: %" PRIu64 "\n", fired);
+ }
+
+ ret = clock_gettime(CLOCK_BOOTTIME, &actual_time);
+ if (ret < 0) {
+ perror("failed to get time");
+ exit(EXIT_FAILURE);
+ }
+
+ long long diff = timediff_ns(&actual_time, &expected_time);
+ if (llabs(diff) > NSEC_PER_SEC) {
+ fprintf(stderr, "alarm arrived %lld.%03lld seconds %s\n",
+ llabs(diff) / NSEC_PER_SEC,
+ (llabs(diff) / NSEC_PER_MSEC) % MSEC_PER_SEC,
+ diff > 0 ? "late" : "early");
+ KLOG_ERROR("suspend_stress", "alarm arrived %lld.%03lld seconds %s\n",
+ llabs(diff) / NSEC_PER_SEC,
+ (llabs(diff) / NSEC_PER_MSEC) % MSEC_PER_SEC,
+ diff > 0 ? "late" : "early");
+ if (abort_on_failure) {
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ time_t t = time(NULL);
+ i += fired;
+ printf("timer fired: %d at boottime %lld.%.3ld, %s", i,
+ (long long)actual_time.tv_sec,
+ actual_time.tv_nsec / NSEC_PER_MSEC,
+ ctime(&t));
+
+ KLOG_INFO("suspend_stress", "timer fired: %d at boottime %lld.%.3ld, %s", i,
+ (long long)actual_time.tv_sec,
+ actual_time.tv_nsec / NSEC_PER_MSEC,
+ ctime(&t));
+
+ if (count > 0)
+ count--;
+ }
+ return 0;
+}
--- /dev/null
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := generate_verity_key
+LOCAL_SRC_FILES := generate_verity_key.c
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_MODULE_TAGS := optional
+LOCAL_SHARED_LIBRARIES := libcrypto-host
+LOCAL_C_INCLUDES += external/openssl/include
+include $(BUILD_HOST_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := VeritySigner.java Utils.java
+LOCAL_MODULE := VeritySigner
+LOCAL_JAR_MANIFEST := VeritySigner.mf
+LOCAL_MODULE_TAGS := optional
+LOCAL_STATIC_JAVA_LIBRARIES := bouncycastle-host
+include $(BUILD_HOST_JAVA_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := BootSignature.java VeritySigner.java Utils.java
+LOCAL_MODULE := BootSignature
+LOCAL_JAR_MANIFEST := BootSignature.mf
+LOCAL_MODULE_TAGS := optional
+LOCAL_STATIC_JAVA_LIBRARIES := bouncycastle-host
+include $(BUILD_HOST_JAVA_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := BootSignature.java KeystoreSigner.java Utils.java
+LOCAL_MODULE := BootKeystoreSigner
+LOCAL_JAR_MANIFEST := KeystoreSigner.mf
+LOCAL_MODULE_TAGS := optional
+LOCAL_STATIC_JAVA_LIBRARIES := bouncycastle-host
+include $(BUILD_HOST_JAVA_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := verity_signer
+LOCAL_MODULE := verity_signer
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_REQUIRED_MODULES := VeritySigner
+include $(BUILD_PREBUILT)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := boot_signer
+LOCAL_MODULE := boot_signer
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_REQUIRED_MODULES := BootSignature
+include $(BUILD_PREBUILT)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := keystore_signer
+LOCAL_MODULE := keystore_signer
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_REQUIRED_MODULES := KeystoreSigner
+include $(BUILD_PREBUILT)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := build_verity_metadata.py
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_SRC_FILES := build_verity_metadata.py
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_PREBUILT)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := build_verity_tree
+LOCAL_SRC_FILES := build_verity_tree.cpp
+LOCAL_MODULE_TAGS := optional
+LOCAL_STATIC_LIBRARIES := libsparse_host libz
+LOCAL_SHARED_LIBRARIES := libcrypto-host
+LOCAL_C_INCLUDES := external/openssl/include
+LOCAL_CFLAGS += -Wall -Werror
+include $(BUILD_HOST_EXECUTABLE)
--- /dev/null
+/*
+ * Copyright (C) 2014 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.
+ */
+
+package com.android.verity;
+
+import java.io.IOException;
+import java.security.PrivateKey;
+import java.util.Arrays;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERPrintableString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.util.ASN1Dump;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+
+/**
+ * AndroidVerifiedBootSignature DEFINITIONS ::=
+ * BEGIN
+ * FormatVersion ::= INTEGER
+ * AlgorithmIdentifier ::= SEQUENCE {
+ * algorithm OBJECT IDENTIFIER,
+ * parameters ANY DEFINED BY algorithm OPTIONAL
+ * }
+ * AuthenticatedAttributes ::= SEQUENCE {
+ * target CHARACTER STRING,
+ * length INTEGER
+ * }
+ * Signature ::= OCTET STRING
+ * END
+ */
+
+public class BootSignature extends ASN1Object
+{
+ private ASN1Integer formatVersion;
+ private AlgorithmIdentifier algorithmIdentifier;
+ private DERPrintableString target;
+ private ASN1Integer length;
+ private DEROctetString signature;
+
+ public BootSignature(String target, int length) {
+ this.formatVersion = new ASN1Integer(0);
+ this.target = new DERPrintableString(target);
+ this.length = new ASN1Integer(length);
+ this.algorithmIdentifier = new AlgorithmIdentifier(
+ PKCSObjectIdentifiers.sha256WithRSAEncryption);
+ }
+
+ public ASN1Object getAuthenticatedAttributes() {
+ ASN1EncodableVector attrs = new ASN1EncodableVector();
+ attrs.add(target);
+ attrs.add(length);
+ return new DERSequence(attrs);
+ }
+
+ public byte[] getEncodedAuthenticatedAttributes() throws IOException {
+ return getAuthenticatedAttributes().getEncoded();
+ }
+
+ public void setSignature(byte[] sig) {
+ signature = new DEROctetString(sig);
+ }
+
+ public byte[] generateSignableImage(byte[] image) throws IOException {
+ byte[] attrs = getEncodedAuthenticatedAttributes();
+ byte[] signable = Arrays.copyOf(image, image.length + attrs.length);
+ for (int i=0; i < attrs.length; i++) {
+ signable[i+image.length] = attrs[i];
+ }
+ return signable;
+ }
+
+ public byte[] sign(byte[] image, PrivateKey key) throws Exception {
+ byte[] signable = generateSignableImage(image);
+ byte[] signature = Utils.sign(key, signable);
+ byte[] signed = Arrays.copyOf(image, image.length + signature.length);
+ for (int i=0; i < signature.length; i++) {
+ signed[i+image.length] = signature[i];
+ }
+ return signed;
+ }
+
+ public ASN1Primitive toASN1Primitive() {
+ ASN1EncodableVector v = new ASN1EncodableVector();
+ v.add(formatVersion);
+ v.add(algorithmIdentifier);
+ v.add(getAuthenticatedAttributes());
+ v.add(signature);
+ return new DERSequence(v);
+ }
+
+ public static void doSignature( String target,
+ String imagePath,
+ String keyPath,
+ String outPath) throws Exception {
+ byte[] image = Utils.read(imagePath);
+ BootSignature bootsig = new BootSignature(target, image.length);
+ PrivateKey key = Utils.loadPEMPrivateKeyFromFile(keyPath);
+ byte[] signature = bootsig.sign(image, key);
+ Utils.write(signature, outPath);
+ }
+
+ // java -cp ../../../out/host/common/obj/JAVA_LIBRARIES/AndroidVerifiedBootSigner_intermediates/classes/ com.android.verity.AndroidVerifiedBootSigner boot ../../../out/target/product/flounder/boot.img ../../../build/target/product/security/verity_private_dev_key /tmp/boot.img.signed
+ public static void main(String[] args) throws Exception {
+ doSignature(args[0], args[1], args[2], args[3]);
+ }
+}
\ No newline at end of file
--- /dev/null
+Main-Class: com.android.verity.BootSignature
--- /dev/null
+/*
+ * Copyright (C) 2014 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.
+ */
+
+package com.android.verity;
+
+import java.io.IOException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.Signature;
+import org.bouncycastle.asn1.ASN1Encodable;
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Integer;
+import org.bouncycastle.asn1.ASN1Object;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.DEROctetString;
+import org.bouncycastle.asn1.DERPrintableString;
+import org.bouncycastle.asn1.DERSequence;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.asn1.pkcs.RSAPublicKey;
+import org.bouncycastle.asn1.util.ASN1Dump;
+import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
+
+/**
+ * AndroidVerifiedBootKeystore DEFINITIONS ::=
+ * BEGIN
+ * FormatVersion ::= INTEGER
+ * KeyBag ::= SEQUENCE {
+ * Key ::= SEQUENCE {
+ * AlgorithmIdentifier ::= SEQUENCE {
+ * algorithm OBJECT IDENTIFIER,
+ * parameters ANY DEFINED BY algorithm OPTIONAL
+ * }
+ * KeyMaterial ::= RSAPublicKey
+ * }
+ * }
+ * Signature ::= AndroidVerifiedBootSignature
+ * END
+ */
+
+class BootKey extends ASN1Object
+{
+ private AlgorithmIdentifier algorithmIdentifier;
+ private RSAPublicKey keyMaterial;
+
+ public BootKey(PublicKey key) throws Exception {
+ java.security.interfaces.RSAPublicKey k =
+ (java.security.interfaces.RSAPublicKey) key;
+ this.keyMaterial = new RSAPublicKey(
+ k.getModulus(),
+ k.getPublicExponent());
+ this.algorithmIdentifier = new AlgorithmIdentifier(
+ PKCSObjectIdentifiers.sha256WithRSAEncryption);
+ }
+
+ public ASN1Primitive toASN1Primitive() {
+ ASN1EncodableVector v = new ASN1EncodableVector();
+ v.add(algorithmIdentifier);
+ v.add(keyMaterial);
+ return new DERSequence(v);
+ }
+
+ public void dump() throws Exception {
+ System.out.println(ASN1Dump.dumpAsString(toASN1Primitive()));
+ }
+}
+
+class BootKeystore extends ASN1Object
+{
+ private ASN1Integer formatVersion;
+ private ASN1EncodableVector keyBag;
+ private BootSignature signature;
+
+ public BootKeystore() {
+ this.formatVersion = new ASN1Integer(0);
+ this.keyBag = new ASN1EncodableVector();
+ }
+
+ public void addPublicKey(byte[] der) throws Exception {
+ PublicKey pubkey = Utils.loadDERPublicKey(der);
+ BootKey k = new BootKey(pubkey);
+ keyBag.add(k);
+ }
+
+ public byte[] getInnerKeystore() throws Exception {
+ ASN1EncodableVector v = new ASN1EncodableVector();
+ v.add(formatVersion);
+ v.add(new DERSequence(keyBag));
+ return new DERSequence(v).getEncoded();
+ }
+
+ public ASN1Primitive toASN1Primitive() {
+ ASN1EncodableVector v = new ASN1EncodableVector();
+ v.add(formatVersion);
+ v.add(new DERSequence(keyBag));
+ v.add(signature);
+ return new DERSequence(v);
+ }
+
+ public void sign(PrivateKey privateKey) throws Exception {
+ byte[] innerKeystore = getInnerKeystore();
+ byte[] rawSignature = Utils.sign(privateKey, innerKeystore);
+ signature = new BootSignature("keystore", innerKeystore.length);
+ signature.setSignature(rawSignature);
+ }
+
+ public void dump() throws Exception {
+ System.out.println(ASN1Dump.dumpAsString(toASN1Primitive()));
+ }
+
+ // USAGE:
+ // AndroidVerifiedBootKeystoreSigner <privkeyFile> <outfile> <pubkeyFile0> ... <pubkeyFileN-1>
+ // EG:
+ // java -cp ../../../out/host/common/obj/JAVA_LIBRARIES/AndroidVerifiedBootKeystoreSigner_intermediates/classes/ com.android.verity.AndroidVerifiedBootKeystoreSigner ../../../build/target/product/security/verity_private_dev_key /tmp/keystore.out /tmp/k
+ public static void main(String[] args) throws Exception {
+ String privkeyFname = args[0];
+ String outfileFname = args[1];
+ BootKeystore ks = new BootKeystore();
+ for (int i=2; i < args.length; i++) {
+ ks.addPublicKey(Utils.read(args[i]));
+ }
+ ks.sign(Utils.loadPEMPrivateKeyFromFile(privkeyFname));
+ Utils.write(ks.getEncoded(), outfileFname);
+ }
+}
\ No newline at end of file
--- /dev/null
+Main-Class: com.android.verity.KeystoreSigner
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (C) 2014 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.
+ */
+
+package com.android.verity;
+
+import java.lang.reflect.Constructor;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.KeyFactory;
+import java.security.Provider;
+import java.security.Security;
+import java.security.Signature;
+import java.security.spec.X509EncodedKeySpec;
+import java.security.spec.PKCS8EncodedKeySpec;
+
+import org.bouncycastle.util.encoders.Base64;
+
+public class Utils {
+
+ private static void loadProviderIfNecessary(String providerClassName) {
+ if (providerClassName == null) {
+ return;
+ }
+
+ final Class<?> klass;
+ try {
+ final ClassLoader sysLoader = ClassLoader.getSystemClassLoader();
+ if (sysLoader != null) {
+ klass = sysLoader.loadClass(providerClassName);
+ } else {
+ klass = Class.forName(providerClassName);
+ }
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ System.exit(1);
+ return;
+ }
+
+ Constructor<?> constructor = null;
+ for (Constructor<?> c : klass.getConstructors()) {
+ if (c.getParameterTypes().length == 0) {
+ constructor = c;
+ break;
+ }
+ }
+ if (constructor == null) {
+ System.err.println("No zero-arg constructor found for " + providerClassName);
+ System.exit(1);
+ return;
+ }
+
+ final Object o;
+ try {
+ o = constructor.newInstance();
+ } catch (Exception e) {
+ e.printStackTrace();
+ System.exit(1);
+ return;
+ }
+ if (!(o instanceof Provider)) {
+ System.err.println("Not a Provider class: " + providerClassName);
+ System.exit(1);
+ }
+
+ Security.insertProviderAt((Provider) o, 1);
+ }
+
+ static byte[] pemToDer(String pem) throws Exception {
+ pem = pem.replaceAll("^-.*", "");
+ String base64_der = pem.replaceAll("-.*$", "");
+ return Base64.decode(base64_der);
+ }
+
+ static PrivateKey loadDERPrivateKey(byte[] der) throws Exception {
+ PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(der);
+ KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+ return (PrivateKey) keyFactory.generatePrivate(keySpec);
+ }
+
+ static PrivateKey loadPEMPrivateKey(byte[] pem) throws Exception {
+ byte[] der = pemToDer(new String(pem));
+ return loadDERPrivateKey(der);
+ }
+
+ static PrivateKey loadPEMPrivateKeyFromFile(String keyFname) throws Exception {
+ return loadPEMPrivateKey(read(keyFname));
+ }
+
+ static PrivateKey loadDERPrivateKeyFromFile(String keyFname) throws Exception {
+ return loadDERPrivateKey(read(keyFname));
+ }
+
+ static PublicKey loadDERPublicKey(byte[] der) throws Exception {
+ X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(der);
+ KeyFactory factory = KeyFactory.getInstance("RSA");
+ return factory.generatePublic(publicKeySpec);
+ }
+
+ static PublicKey loadPEMPublicKey(byte[] pem) throws Exception {
+ byte[] der = pemToDer(new String(pem));
+ X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(der);
+ KeyFactory factory = KeyFactory.getInstance("RSA");
+ return factory.generatePublic(publicKeySpec);
+ }
+
+ static PublicKey loadPEMPublicKeyFromFile(String keyFname) throws Exception {
+ return loadPEMPublicKey(read(keyFname));
+ }
+
+ static PublicKey loadDERPublicKeyFromFile(String keyFname) throws Exception {
+ return loadDERPublicKey(read(keyFname));
+ }
+
+ static byte[] sign(PrivateKey privateKey, byte[] input) throws Exception {
+ Signature signer = Signature.getInstance("SHA1withRSA");
+ signer.initSign(privateKey);
+ signer.update(input);
+ return signer.sign();
+ }
+
+ static byte[] read(String fname) throws Exception {
+ long offset = 0;
+ File f = new File(fname);
+ long length = f.length();
+ byte[] image = new byte[(int)length];
+ FileInputStream fis = new FileInputStream(f);
+ while (offset < length) {
+ offset += fis.read(image, (int)offset, (int)(length - offset));
+ }
+ fis.close();
+ return image;
+ }
+
+ static void write(byte[] data, String fname) throws Exception{
+ FileOutputStream out = new FileOutputStream(fname);
+ out.write(data);
+ out.close();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (C) 2013 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.
+ */
+
+package com.android.verity;
+
+import java.security.PrivateKey;
+
+public class VeritySigner {
+
+ // USAGE:
+ // VeritySigner <contentfile> <key.pem> <sigfile>
+ // To verify that this has correct output:
+ // openssl rsautl -raw -inkey <key.pem> -encrypt -in <sigfile> > /tmp/dump
+ public static void main(String[] args) throws Exception {
+ byte[] content = Utils.read(args[0]);
+ PrivateKey privateKey = Utils.loadPEMPrivateKey(Utils.read(args[1]));
+ byte[] signature = Utils.sign(privateKey, content);
+ Utils.write(signature, args[2]);
+ }
+}
--- /dev/null
+Main-Class: com.android.verity.VeritySigner
--- /dev/null
+#! /bin/sh
+
+# Start-up script for BootSigner
+
+BOOTSIGNER_HOME=`dirname "$0"`
+BOOTSIGNER_HOME=`dirname "$BOOTSIGNER_HOME"`
+
+java -Xmx512M -jar "$BOOTSIGNER_HOME"/framework/BootSignature.jar "$@"
\ No newline at end of file
--- /dev/null
+#! /usr/bin/env python
+
+import os
+import sys
+import struct
+import tempfile
+import commands
+
+VERSION = 0
+MAGIC_NUMBER = 0xb001b001
+BLOCK_SIZE = 4096
+METADATA_SIZE = BLOCK_SIZE * 8
+
+def run(cmd):
+ status, output = commands.getstatusoutput(cmd)
+ print output
+ if status:
+ exit(-1)
+
+def get_verity_metadata_size(data_size):
+ return METADATA_SIZE
+
+def build_metadata_block(verity_table, signature):
+ table_len = len(verity_table)
+ block = struct.pack("II256sI", MAGIC_NUMBER, VERSION, signature, table_len)
+ block += verity_table
+ block = block.ljust(METADATA_SIZE, '\x00')
+ return block
+
+def sign_verity_table(table, signer_path, key_path):
+ with tempfile.NamedTemporaryFile(suffix='.table') as table_file:
+ with tempfile.NamedTemporaryFile(suffix='.sig') as signature_file:
+ table_file.write(table)
+ table_file.flush()
+ cmd = " ".join((signer_path, table_file.name, key_path, signature_file.name))
+ print cmd
+ run(cmd)
+ return signature_file.read()
+
+def build_verity_table(block_device, data_blocks, root_hash, salt):
+ table = "1 %s %s %s %s %s %s sha256 %s %s"
+ table %= ( block_device,
+ block_device,
+ BLOCK_SIZE,
+ BLOCK_SIZE,
+ data_blocks,
+ data_blocks + (METADATA_SIZE / BLOCK_SIZE),
+ root_hash,
+ salt)
+ return table
+
+def build_verity_metadata(data_blocks, metadata_image, root_hash,
+ salt, block_device, signer_path, signing_key):
+ # build the verity table
+ verity_table = build_verity_table(block_device, data_blocks, root_hash, salt)
+ # build the verity table signature
+ signature = sign_verity_table(verity_table, signer_path, signing_key)
+ # build the metadata block
+ metadata_block = build_metadata_block(verity_table, signature)
+ # write it to the outfile
+ with open(metadata_image, "wb") as f:
+ f.write(metadata_block)
+
+if __name__ == "__main__":
+ if len(sys.argv) == 3 and sys.argv[1] == "-s":
+ print get_verity_metadata_size(int(sys.argv[2]))
+ elif len(sys.argv) == 8:
+ data_image_blocks = int(sys.argv[1]) / 4096
+ metadata_image = sys.argv[2]
+ root_hash = sys.argv[3]
+ salt = sys.argv[4]
+ block_device = sys.argv[5]
+ signer_path = sys.argv[6]
+ signing_key = sys.argv[7]
+ build_verity_metadata(data_image_blocks, metadata_image, root_hash,
+ salt, block_device, signer_path, signing_key)
+ else:
+ exit(-1)
--- /dev/null
+#include <openssl/evp.h>
+#include <sparse/sparse.h>
+
+#undef NDEBUG
+
+#include <assert.h>
+#include <errno.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+struct sparse_hash_ctx {
+ unsigned char *hashes;
+ const unsigned char *salt;
+ uint64_t salt_size;
+ uint64_t hash_size;
+ uint64_t block_size;
+ const unsigned char *zero_block_hash;
+ const EVP_MD *md;
+};
+
+#define div_round_up(x,y) (((x) + (y) - 1)/(y))
+
+#define round_up(x,y) (div_round_up(x,y)*(y))
+
+#define FATAL(x...) { \
+ fprintf(stderr, x); \
+ exit(1); \
+}
+
+size_t verity_tree_blocks(uint64_t data_size, size_t block_size, size_t hash_size,
+ int level)
+{
+ size_t level_blocks = div_round_up(data_size, block_size);
+ int hashes_per_block = div_round_up(block_size, hash_size);
+
+ do {
+ level_blocks = div_round_up(level_blocks, hashes_per_block);
+ } while (level--);
+
+ return level_blocks;
+}
+
+int hash_block(const EVP_MD *md,
+ const unsigned char *block, size_t len,
+ const unsigned char *salt, size_t salt_len,
+ unsigned char *out, size_t *out_size)
+{
+ EVP_MD_CTX *mdctx;
+ unsigned int s;
+ int ret = 1;
+
+ mdctx = EVP_MD_CTX_create();
+ assert(mdctx);
+ ret &= EVP_DigestInit_ex(mdctx, md, NULL);
+ ret &= EVP_DigestUpdate(mdctx, salt, salt_len);
+ ret &= EVP_DigestUpdate(mdctx, block, len);
+ ret &= EVP_DigestFinal_ex(mdctx, out, &s);
+ EVP_MD_CTX_destroy(mdctx);
+ assert(ret == 1);
+ if (out_size) {
+ *out_size = s;
+ }
+ return 0;
+}
+
+int hash_blocks(const EVP_MD *md,
+ const unsigned char *in, size_t in_size,
+ unsigned char *out, size_t *out_size,
+ const unsigned char *salt, size_t salt_size,
+ size_t block_size)
+{
+ size_t s;
+ *out_size = 0;
+ for (size_t i = 0; i < in_size; i += block_size) {
+ hash_block(md, in + i, block_size, salt, salt_size, out, &s);
+ out += s;
+ *out_size += s;
+ }
+
+ return 0;
+}
+
+int hash_chunk(void *priv, const void *data, int len)
+{
+ struct sparse_hash_ctx *ctx = (struct sparse_hash_ctx *)priv;
+ assert(len % ctx->block_size == 0);
+ if (data) {
+ size_t s;
+ hash_blocks(ctx->md, (const unsigned char *)data, len,
+ ctx->hashes, &s,
+ ctx->salt, ctx->salt_size, ctx->block_size);
+ ctx->hashes += s;
+ } else {
+ for (size_t i = 0; i < (size_t)len; i += ctx->block_size) {
+ memcpy(ctx->hashes, ctx->zero_block_hash, ctx->hash_size);
+ ctx->hashes += ctx->hash_size;
+ }
+ }
+ return 0;
+}
+
+void usage(void)
+{
+ printf("usage: build_verity_tree [ <options> ] -s <size> | <data> <verity>\n"
+ "options:\n"
+ " -a,--salt-str=<string> set salt to <string>\n"
+ " -A,--salt-hex=<hex digits> set salt to <hex digits>\n"
+ " -h show this help\n"
+ " -s,--verity-size=<data size> print the size of the verity tree\n"
+ " -S treat <data image> as a sparse file\n"
+ );
+}
+
+int main(int argc, char **argv)
+{
+ char *data_filename;
+ char *verity_filename;
+ unsigned char *salt = NULL;
+ size_t salt_size = 0;
+ bool sparse = false;
+ size_t block_size = 4096;
+ size_t calculate_size = 0;
+
+ while (1) {
+ const static struct option long_options[] = {
+ {"salt-str", required_argument, 0, 'a'},
+ {"salt-hex", required_argument, 0, 'A'},
+ {"help", no_argument, 0, 'h'},
+ {"sparse", no_argument, 0, 'S'},
+ {"verity-size", required_argument, 0, 's'},
+ };
+ int c = getopt_long(argc, argv, "a:A:hSs:", long_options, NULL);
+ if (c < 0) {
+ break;
+ }
+
+ switch (c) {
+ case 'a':
+ salt_size = strlen(optarg);
+ salt = new unsigned char[salt_size]();
+ if (salt == NULL) {
+ FATAL("failed to allocate memory for salt\n");
+ }
+ memcpy(salt, optarg, salt_size);
+ break;
+ case 'A': {
+ BIGNUM *bn = NULL;
+ if(!BN_hex2bn(&bn, optarg)) {
+ FATAL("failed to convert salt from hex\n");
+ }
+ salt_size = BN_num_bytes(bn);
+ salt = new unsigned char[salt_size]();
+ if (salt == NULL) {
+ FATAL("failed to allocate memory for salt\n");
+ }
+ if((size_t)BN_bn2bin(bn, salt) != salt_size) {
+ FATAL("failed to convert salt to bytes\n");
+ }
+ }
+ break;
+ case 'h':
+ usage();
+ return 1;
+ case 'S':
+ sparse = true;
+ break;
+ case 's':
+ calculate_size = strtoul(optarg, NULL, 0);
+ break;
+ case '?':
+ usage();
+ return 1;
+ default:
+ abort();
+ }
+ }
+
+ argc -= optind;
+ argv += optind;
+
+ const EVP_MD *md = EVP_sha256();
+ if (!md) {
+ FATAL("failed to get digest\n");
+ }
+
+ size_t hash_size = EVP_MD_size(md);
+ assert(hash_size * 2 < block_size);
+
+ if (!salt || !salt_size) {
+ salt_size = hash_size;
+ salt = new unsigned char[salt_size];
+ if (salt == NULL) {
+ FATAL("failed to allocate memory for salt\n");
+ }
+
+ int random_fd = open("/dev/urandom", O_RDONLY);
+ if (random_fd < 0) {
+ FATAL("failed to open /dev/urandom\n");
+ }
+
+ ssize_t ret = read(random_fd, salt, salt_size);
+ if (ret != (ssize_t)salt_size) {
+ FATAL("failed to read %zu bytes from /dev/urandom: %zd %d\n", salt_size, ret, errno);
+ }
+ close(random_fd);
+ }
+
+ if (calculate_size) {
+ if (argc != 0) {
+ usage();
+ return 1;
+ }
+ size_t verity_blocks = 0;
+ size_t level_blocks;
+ int levels = 0;
+ do {
+ level_blocks = verity_tree_blocks(calculate_size, block_size, hash_size, levels);
+ levels++;
+ verity_blocks += level_blocks;
+ } while (level_blocks > 1);
+
+ printf("%zu\n", verity_blocks * block_size);
+ return 0;
+ }
+
+ if (argc != 2) {
+ usage();
+ return 1;
+ }
+
+ data_filename = argv[0];
+ verity_filename = argv[1];
+
+ int fd = open(data_filename, O_RDONLY);
+ if (fd < 0) {
+ FATAL("failed to open %s\n", data_filename);
+ }
+
+ struct sparse_file *file;
+ if (sparse) {
+ file = sparse_file_import(fd, false, false);
+ } else {
+ file = sparse_file_import_auto(fd, false);
+ }
+
+ if (!file) {
+ FATAL("failed to read file %s\n", data_filename);
+ }
+
+ int64_t len = sparse_file_len(file, false, false);
+ if (len % block_size != 0) {
+ FATAL("file size %" PRIu64 " is not a multiple of %zu bytes\n",
+ len, block_size);
+ }
+
+ int levels = 0;
+ size_t verity_blocks = 0;
+ size_t level_blocks;
+
+ do {
+ level_blocks = verity_tree_blocks(len, block_size, hash_size, levels);
+ levels++;
+ verity_blocks += level_blocks;
+ } while (level_blocks > 1);
+
+ unsigned char *verity_tree = new unsigned char[verity_blocks * block_size]();
+ unsigned char **verity_tree_levels = new unsigned char *[levels + 1]();
+ size_t *verity_tree_level_blocks = new size_t[levels]();
+ if (verity_tree == NULL || verity_tree_levels == NULL || verity_tree_level_blocks == NULL) {
+ FATAL("failed to allocate memory for verity tree\n");
+ }
+
+ unsigned char *ptr = verity_tree;
+ for (int i = levels - 1; i >= 0; i--) {
+ verity_tree_levels[i] = ptr;
+ verity_tree_level_blocks[i] = verity_tree_blocks(len, block_size, hash_size, i);
+ ptr += verity_tree_level_blocks[i] * block_size;
+ }
+ assert(ptr == verity_tree + verity_blocks * block_size);
+ assert(verity_tree_level_blocks[levels - 1] == 1);
+
+ unsigned char zero_block_hash[hash_size];
+ unsigned char zero_block[block_size];
+ memset(zero_block, 0, block_size);
+ hash_block(md, zero_block, block_size, salt, salt_size, zero_block_hash, NULL);
+
+ unsigned char root_hash[hash_size];
+ verity_tree_levels[levels] = root_hash;
+
+ struct sparse_hash_ctx ctx;
+ ctx.hashes = verity_tree_levels[0];
+ ctx.salt = salt;
+ ctx.salt_size = salt_size;
+ ctx.hash_size = hash_size;
+ ctx.block_size = block_size;
+ ctx.zero_block_hash = zero_block_hash;
+ ctx.md = md;
+
+ sparse_file_callback(file, false, false, hash_chunk, &ctx);
+
+ sparse_file_destroy(file);
+ close(fd);
+
+ for (int i = 0; i < levels; i++) {
+ size_t out_size;
+ hash_blocks(md,
+ verity_tree_levels[i], verity_tree_level_blocks[i] * block_size,
+ verity_tree_levels[i + 1], &out_size,
+ salt, salt_size, block_size);
+ if (i < levels - 1) {
+ assert(div_round_up(out_size, block_size) == verity_tree_level_blocks[i + 1]);
+ } else {
+ assert(out_size == hash_size);
+ }
+ }
+
+ for (size_t i = 0; i < hash_size; i++) {
+ printf("%02x", root_hash[i]);
+ }
+ printf(" ");
+ for (size_t i = 0; i < salt_size; i++) {
+ printf("%02x", salt[i]);
+ }
+ printf("\n");
+
+ fd = open(verity_filename, O_WRONLY|O_CREAT, 0666);
+ if (fd < 0) {
+ FATAL("failed to open output file '%s'\n", verity_filename);
+ }
+ write(fd, verity_tree, verity_blocks * block_size);
+ close(fd);
+
+ delete[] verity_tree_levels;
+ delete[] verity_tree_level_blocks;
+ delete[] verity_tree;
+ delete[] salt;
+}
--- /dev/null
+/*
+ * Copyright (C) 2013 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 <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+/* HACK: we need the RSAPublicKey struct
+ * but RSA_verify conflits with openssl */
+#define RSA_verify RSA_verify_mincrypt
+#include "mincrypt/rsa.h"
+#undef RSA_verify
+
+#include <openssl/evp.h>
+#include <openssl/objects.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/sha.h>
+
+// Convert OpenSSL RSA private key to android pre-computed RSAPublicKey format.
+// Lifted from secure adb's mincrypt key generation.
+static int convert_to_mincrypt_format(RSA *rsa, RSAPublicKey *pkey)
+{
+ int ret = -1;
+ unsigned int i;
+
+ if (RSA_size(rsa) != RSANUMBYTES)
+ goto out;
+
+ BN_CTX* ctx = BN_CTX_new();
+ BIGNUM* r32 = BN_new();
+ BIGNUM* rr = BN_new();
+ BIGNUM* r = BN_new();
+ BIGNUM* rem = BN_new();
+ BIGNUM* n = BN_new();
+ BIGNUM* n0inv = BN_new();
+
+ BN_set_bit(r32, 32);
+ BN_copy(n, rsa->n);
+ BN_set_bit(r, RSANUMWORDS * 32);
+ BN_mod_sqr(rr, r, n, ctx);
+ BN_div(NULL, rem, n, r32, ctx);
+ BN_mod_inverse(n0inv, rem, r32, ctx);
+
+ pkey->len = RSANUMWORDS;
+ pkey->n0inv = 0 - BN_get_word(n0inv);
+ for (i = 0; i < RSANUMWORDS; i++) {
+ BN_div(rr, rem, rr, r32, ctx);
+ pkey->rr[i] = BN_get_word(rem);
+ BN_div(n, rem, n, r32, ctx);
+ pkey->n[i] = BN_get_word(rem);
+ }
+ pkey->exponent = BN_get_word(rsa->e);
+
+ ret = 0;
+
+ BN_free(n0inv);
+ BN_free(n);
+ BN_free(rem);
+ BN_free(r);
+ BN_free(rr);
+ BN_free(r32);
+ BN_CTX_free(ctx);
+
+out:
+ return ret;
+}
+
+static int write_public_keyfile(RSA *private_key, const char *private_key_path)
+{
+ RSAPublicKey pkey;
+ BIO *bfile = NULL;
+ char *path = NULL;
+ int ret = -1;
+
+ if (asprintf(&path, "%s.pub", private_key_path) < 0)
+ goto out;
+
+ if (convert_to_mincrypt_format(private_key, &pkey) < 0)
+ goto out;
+
+ bfile = BIO_new_file(path, "w");
+ if (!bfile)
+ goto out;
+
+ BIO_write(bfile, &pkey, sizeof(pkey));
+ BIO_flush(bfile);
+
+ ret = 0;
+out:
+ BIO_free_all(bfile);
+ free(path);
+ return ret;
+}
+
+static int generate_key(const char *file)
+{
+ int ret = -1;
+ FILE *f = NULL;
+ RSA* rsa = RSA_new();
+ BIGNUM* exponent = BN_new();
+ EVP_PKEY* pkey = EVP_PKEY_new();
+
+ if (!pkey || !exponent || !rsa) {
+ printf("Failed to allocate key\n");
+ goto out;
+ }
+
+ BN_set_word(exponent, RSA_F4);
+ RSA_generate_key_ex(rsa, 2048, exponent, NULL);
+ EVP_PKEY_set1_RSA(pkey, rsa);
+
+ f = fopen(file, "w");
+ if (!f) {
+ printf("Failed to open '%s'\n", file);
+ goto out;
+ }
+
+ if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) {
+ printf("Failed to write key\n");
+ goto out;
+ }
+
+ if (write_public_keyfile(rsa, file) < 0) {
+ printf("Failed to write public key\n");
+ goto out;
+ }
+
+ ret = 0;
+
+out:
+ if (f)
+ fclose(f);
+ EVP_PKEY_free(pkey);
+ RSA_free(rsa);
+ BN_free(exponent);
+ return ret;
+}
+
+static void usage(){
+ printf("Usage: generate_verity_key <path-to-key>");
+}
+
+int main(int argc, char *argv[]) {
+ if (argc != 2) {
+ usage();
+ exit(-1);
+ }
+ return generate_key(argv[1]);
+}
\ No newline at end of file
--- /dev/null
+#! /bin/sh
+
+# Start-up script for KeystoreSigner
+
+KEYSTORESIGNER_HOME=`dirname "$0"`
+KEYSTORESIGNER_HOME=`dirname "$KEYSTORESIGNER_HOME"`
+
+java -Xmx512M -jar "$KEYSTORESIGNER_HOME"/framework/KeystoreSigner.jar "$@"
\ No newline at end of file
--- /dev/null
+#! /bin/sh
+
+# Start-up script for VeritySigner
+
+VERITYSIGNER_HOME=`dirname "$0"`
+VERITYSIGNER_HOME=`dirname "$VERITYSIGNER_HOME"`
+
+java -Xmx512M -jar "$VERITYSIGNER_HOME"/framework/VeritySigner.jar "$@"
\ No newline at end of file
OSDN Git Service
