From 407a2baae5622b05f1e9c4137448a973fd648736 Mon Sep 17 00:00:00 2001 From: David Oberhollenzer Date: Wed, 4 Sep 2019 18:02:44 +0200 Subject: Split fstree inode serialization, move independend part to libsquashfs.so This commit adds a function to libsquashfs.so for writing generic inodes to a meta writer and another function to libsqfshelper.a that turns a tree node to an inode. That way, the tree serialization code can be expressed in terms of those functions and a bulk of the independend code can be moved over to libsquashfs.so Signed-off-by: David Oberhollenzer --- lib/sqfshelper/serialize_fstree.c | 62 ++++++- lib/sqfshelper/tree_node_to_inode.c | 228 +++++++++++++++++++++++++ lib/sqfshelper/write_inode.c | 328 ------------------------------------ 3 files changed, 287 insertions(+), 331 deletions(-) create mode 100644 lib/sqfshelper/tree_node_to_inode.c delete mode 100644 lib/sqfshelper/write_inode.c (limited to 'lib/sqfshelper') diff --git a/lib/sqfshelper/serialize_fstree.c b/lib/sqfshelper/serialize_fstree.c index 53e2236..f8f3913 100644 --- a/lib/sqfshelper/serialize_fstree.c +++ b/lib/sqfshelper/serialize_fstree.c @@ -11,17 +11,46 @@ #include "util.h" #include +#include #include +static int write_dir_entries(sqfs_dir_writer_t *dirw, tree_node_t *node) +{ + tree_node_t *it; + uint64_t ref; + int ret; + + if (sqfs_dir_writer_begin(dirw)) + return -1; + + for (it = node->data.dir->children; it != NULL; it = it->next) { + ret = sqfs_dir_writer_add_entry(dirw, it->name, it->inode_num, + it->inode_ref, it->mode); + if (ret) + return -1; + } + + if (sqfs_dir_writer_end(dirw)) + return -1; + + ref = sqfs_dir_writer_get_dir_reference(dirw); + + node->data.dir->size = sqfs_dir_writer_get_size(dirw); + node->data.dir->start_block = ref >> 16; + node->data.dir->block_offset = ref & 0xFFFF; + return 0; +} + int sqfs_serialize_fstree(int outfd, sqfs_super_t *super, fstree_t *fs, compressor_t *cmp, id_table_t *idtbl) { + sqfs_inode_generic_t *inode; sqfs_dir_writer_t *dirwr; meta_writer_t *im, *dm; + size_t i, count; uint32_t offset; uint64_t block; int ret = -1; - size_t i; im = meta_writer_create(outfd, cmp, false); if (im == NULL) @@ -36,10 +65,37 @@ int sqfs_serialize_fstree(int outfd, sqfs_super_t *super, fstree_t *fs, goto out_dm; for (i = 2; i < fs->inode_tbl_size; ++i) { - if (meta_writer_write_inode(fs, idtbl, im, dirwr, - fs->inode_table[i])) { + if (S_ISDIR(fs->inode_table[i]->mode)) { + if (write_dir_entries(dirwr, fs->inode_table[i])) + goto out; + } + + inode = tree_node_to_inode(fs, idtbl, fs->inode_table[i], + &count); + if (inode == NULL) + goto out; + + if (inode->base.type == SQFS_INODE_EXT_DIR) { + inode->data.dir_ext.inodex_count = + sqfs_dir_writer_get_index_size(dirwr); + } + + meta_writer_get_position(im, &block, &offset); + fs->inode_table[i]->inode_ref = (block << 16) | offset; + + if (meta_writer_write_inode(im, inode, count)) { + free(inode); goto out; } + + if (inode->base.type == SQFS_INODE_EXT_DIR) { + if (sqfs_dir_writer_write_index(dirwr, im)) { + free(inode); + goto out; + } + } + + free(inode); } if (meta_writer_flush(im)) diff --git a/lib/sqfshelper/tree_node_to_inode.c b/lib/sqfshelper/tree_node_to_inode.c new file mode 100644 index 0000000..21e30dd --- /dev/null +++ b/lib/sqfshelper/tree_node_to_inode.c @@ -0,0 +1,228 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +/* + * write_inode.c + * + * Copyright (C) 2019 David Oberhollenzer + */ +#include "config.h" + +#include "highlevel.h" +#include "sqfs/inode.h" +#include "sqfs/dir.h" +#include "util.h" + +#include +#include +#include +#include + +static size_t hard_link_count(tree_node_t *n) +{ + size_t count; + + if (S_ISDIR(n->mode)) { + count = 2; + + for (n = n->data.dir->children; n != NULL; n = n->next) + ++count; + + return count; + } + + return 1; +} + +static int get_type(tree_node_t *node) +{ + switch (node->mode & S_IFMT) { + case S_IFSOCK: + if (node->xattr != NULL) + return SQFS_INODE_EXT_SOCKET; + return SQFS_INODE_SOCKET; + case S_IFIFO: + if (node->xattr != NULL) + return SQFS_INODE_EXT_FIFO; + return SQFS_INODE_FIFO; + case S_IFLNK: + if (node->xattr != NULL) + return SQFS_INODE_EXT_SLINK; + return SQFS_INODE_SLINK; + case S_IFBLK: + if (node->xattr != NULL) + return SQFS_INODE_EXT_BDEV; + return SQFS_INODE_BDEV; + case S_IFCHR: + if (node->xattr != NULL) + return SQFS_INODE_EXT_CDEV; + return SQFS_INODE_CDEV; + case S_IFREG: { + file_info_t *fi = node->data.file; + + if (node->xattr != NULL || fi->sparse > 0) + return SQFS_INODE_EXT_FILE; + + if (fi->startblock > 0xFFFFFFFFUL || fi->size > 0xFFFFFFFFUL) + return SQFS_INODE_EXT_FILE; + + return SQFS_INODE_FILE; + } + case S_IFDIR: { + dir_info_t *di = node->data.dir; + + if (node->xattr != NULL) + return SQFS_INODE_EXT_DIR; + + if (di->start_block > 0xFFFFFFFFUL || di->size > 0xFFFF) + return SQFS_INODE_EXT_DIR; + + return SQFS_INODE_DIR; + } + } + assert(0); +} + +sqfs_inode_generic_t *tree_node_to_inode(fstree_t *fs, id_table_t *idtbl, + tree_node_t *node, + size_t *file_num_blocks) +{ + size_t i, extra = 0, block_count = 0; + sqfs_inode_generic_t *inode; + uint16_t uid_idx, gid_idx; + uint32_t xattr = 0xFFFFFFFF; + file_info_t *fi = NULL; + + if (S_ISLNK(node->mode)) { + extra = strlen(node->data.slink_target); + } else if (S_ISREG(node->mode)) { + fi = node->data.file; + + block_count = fi->size / fs->block_size; + + if ((fi->size % fs->block_size) != 0 && + !(fi->flags & FILE_FLAG_HAS_FRAGMENT)) { + ++block_count; + } + + extra = block_count * sizeof(uint32_t); + } + + inode = alloc_flex(sizeof(*inode), 1, extra); + if (inode == NULL) { + perror("creating inode from file system tree node"); + return NULL; + } + + if (S_ISLNK(node->mode)) { + inode->slink_target = (char *)inode->extra; + + memcpy(inode->extra, node->data.slink_target, extra); + } else if (S_ISREG(node->mode)) { + inode->block_sizes = (uint32_t *)inode->extra; + + for (i = 0; i < block_count; ++i) { + inode->block_sizes[i] = + node->data.file->blocks[i].size; + } + } + + if (id_table_id_to_index(idtbl, node->uid, &uid_idx)) + goto fail; + + if (id_table_id_to_index(idtbl, node->gid, &gid_idx)) + goto fail; + + if (node->xattr != NULL) + xattr = node->xattr->index; + + inode->base.type = get_type(node); + inode->base.mode = node->mode; + inode->base.uid_idx = uid_idx; + inode->base.gid_idx = gid_idx; + inode->base.mod_time = node->mod_time; + inode->base.inode_number = node->inode_num; + + switch (inode->base.type) { + case SQFS_INODE_FIFO: + case SQFS_INODE_SOCKET: + inode->data.ipc.nlink = hard_link_count(node); + break; + case SQFS_INODE_EXT_FIFO: + case SQFS_INODE_EXT_SOCKET: + inode->data.ipc_ext.nlink = hard_link_count(node); + inode->data.ipc_ext.xattr_idx = xattr; + break; + case SQFS_INODE_SLINK: + inode->data.slink.nlink = hard_link_count(node); + inode->data.slink.target_size = extra; + break; + case SQFS_INODE_EXT_SLINK: + inode->data.slink_ext.nlink = hard_link_count(node); + inode->data.slink_ext.target_size = extra; + inode->data.slink_ext.xattr_idx = xattr; + break; + case SQFS_INODE_BDEV: + case SQFS_INODE_CDEV: + inode->data.dev.nlink = hard_link_count(node); + inode->data.dev.devno = node->data.devno; + break; + case SQFS_INODE_EXT_BDEV: + case SQFS_INODE_EXT_CDEV: + inode->data.dev_ext.nlink = hard_link_count(node); + inode->data.dev_ext.devno = node->data.devno; + inode->data.dev_ext.xattr_idx = xattr; + break; + case SQFS_INODE_FILE: + inode->data.file.blocks_start = fi->startblock; + inode->data.file.fragment_index = 0xFFFFFFFF; + inode->data.file.fragment_offset = 0xFFFFFFFF; + inode->data.file.file_size = fi->size; + + if ((fi->size % fs->block_size) != 0 && + (fi->flags & FILE_FLAG_HAS_FRAGMENT)) { + inode->data.file.fragment_index = fi->fragment; + inode->data.file.fragment_offset = fi->fragment_offset; + } + break; + case SQFS_INODE_EXT_FILE: + inode->data.file_ext.blocks_start = fi->startblock; + inode->data.file_ext.file_size = fi->size; + inode->data.file_ext.sparse = fi->sparse; + inode->data.file_ext.nlink = hard_link_count(node); + inode->data.file_ext.fragment_idx = 0xFFFFFFFF; + inode->data.file_ext.fragment_offset = 0xFFFFFFFF; + inode->data.file_ext.xattr_idx = xattr; + + if ((fi->size % fs->block_size) != 0 && + (fi->flags & FILE_FLAG_HAS_FRAGMENT)) { + inode->data.file_ext.fragment_idx = fi->fragment; + inode->data.file_ext.fragment_offset = + fi->fragment_offset; + } + break; + case SQFS_INODE_DIR: + inode->data.dir.start_block = node->data.dir->start_block; + inode->data.dir.nlink = hard_link_count(node); + inode->data.dir.size = node->data.dir->size; + inode->data.dir.offset = node->data.dir->block_offset; + inode->data.dir.parent_inode = node->parent ? + node->parent->inode_num : 1; + break; + case SQFS_INODE_EXT_DIR: + inode->data.dir_ext.nlink = hard_link_count(node); + inode->data.dir_ext.size = node->data.dir->size; + inode->data.dir_ext.start_block = node->data.dir->start_block; + inode->data.dir_ext.parent_inode = node->parent ? + node->parent->inode_num : 1; + inode->data.dir_ext.offset = node->data.dir->block_offset; + inode->data.dir_ext.xattr_idx = xattr; + break; + default: + goto fail; + } + + *file_num_blocks = block_count; + return inode; +fail: + free(inode); + return NULL; +} diff --git a/lib/sqfshelper/write_inode.c b/lib/sqfshelper/write_inode.c deleted file mode 100644 index d9dfe53..0000000 --- a/lib/sqfshelper/write_inode.c +++ /dev/null @@ -1,328 +0,0 @@ -/* SPDX-License-Identifier: GPL-3.0-or-later */ -/* - * write_inode.c - * - * Copyright (C) 2019 David Oberhollenzer - */ -#include "config.h" - -#include "highlevel.h" -#include "sqfs/inode.h" -#include "sqfs/dir.h" -#include "util.h" - -#include -#include -#include -#include - -static size_t hard_link_count(tree_node_t *n) -{ - size_t count; - - if (S_ISDIR(n->mode)) { - count = 2; - - for (n = n->data.dir->children; n != NULL; n = n->next) - ++count; - - return count; - } - - return 1; -} - -static int get_type(tree_node_t *node) -{ - switch (node->mode & S_IFMT) { - case S_IFSOCK: - if (node->xattr != NULL) - return SQFS_INODE_EXT_SOCKET; - return SQFS_INODE_SOCKET; - case S_IFIFO: - if (node->xattr != NULL) - return SQFS_INODE_EXT_FIFO; - return SQFS_INODE_FIFO; - case S_IFLNK: - if (node->xattr != NULL) - return SQFS_INODE_EXT_SLINK; - return SQFS_INODE_SLINK; - case S_IFBLK: - if (node->xattr != NULL) - return SQFS_INODE_EXT_BDEV; - return SQFS_INODE_BDEV; - case S_IFCHR: - if (node->xattr != NULL) - return SQFS_INODE_EXT_CDEV; - return SQFS_INODE_CDEV; - case S_IFREG: { - file_info_t *fi = node->data.file; - - if (node->xattr != NULL || fi->sparse > 0) - return SQFS_INODE_EXT_FILE; - - if (fi->startblock > 0xFFFFFFFFUL || fi->size > 0xFFFFFFFFUL) - return SQFS_INODE_EXT_FILE; - - if (hard_link_count(node) > 1) - return SQFS_INODE_EXT_FILE; - - return SQFS_INODE_FILE; - } - case S_IFDIR: { - dir_info_t *di = node->data.dir; - - if (node->xattr != NULL) - return SQFS_INODE_EXT_DIR; - - if (di->start_block > 0xFFFFFFFFUL || di->size > 0xFFFF) - return SQFS_INODE_EXT_DIR; - - return SQFS_INODE_DIR; - } - } - assert(0); -} - -static int write_file_blocks(fstree_t *fs, file_info_t *fi, meta_writer_t *im) -{ - uint64_t i, count = fi->size / fs->block_size; - uint32_t bs; - - if ((fi->size % fs->block_size) != 0 && - !(fi->flags & FILE_FLAG_HAS_FRAGMENT)) { - ++count; - } - - for (i = 0; i < count; ++i) { - bs = htole32(fi->blocks[i].size); - - if (meta_writer_append(im, &bs, sizeof(bs))) - return -1; - } - return 0; -} - -static int write_dir_entries(sqfs_dir_writer_t *dirw, tree_node_t *node) -{ - tree_node_t *it; - uint64_t ref; - int ret; - - if (sqfs_dir_writer_begin(dirw)) - return -1; - - for (it = node->data.dir->children; it != NULL; it = it->next) { - ret = sqfs_dir_writer_add_entry(dirw, it->name, it->inode_num, - it->inode_ref, it->mode); - if (ret) - return -1; - } - - if (sqfs_dir_writer_end(dirw)) - return -1; - - ref = sqfs_dir_writer_get_dir_reference(dirw); - - node->data.dir->size = sqfs_dir_writer_get_size(dirw); - node->data.dir->start_block = ref >> 16; - node->data.dir->block_offset = ref & 0xFFFF; - return 0; -} - -int meta_writer_write_inode(fstree_t *fs, id_table_t *idtbl, meta_writer_t *im, - sqfs_dir_writer_t *dirw, tree_node_t *node) -{ - uint16_t uid_idx, gid_idx; - sqfs_inode_t base; - uint32_t offset; - uint64_t block; - - if (id_table_id_to_index(idtbl, node->uid, &uid_idx)) - return -1; - - if (id_table_id_to_index(idtbl, node->gid, &gid_idx)) - return -1; - - meta_writer_get_position(im, &block, &offset); - node->inode_ref = (block << 16) | offset; - - if (S_ISDIR(node->mode)) { - if (write_dir_entries(dirw, node)) - return -1; - } - - base.type = htole16(get_type(node)); - base.mode = htole16(node->mode); - base.uid_idx = htole16(uid_idx); - base.gid_idx = htole16(gid_idx); - base.mod_time = htole32(node->mod_time); - base.inode_number = htole32(node->inode_num); - - if (meta_writer_append(im, &base, sizeof(base))) - return -1; - - switch (le16toh(base.type)) { - case SQFS_INODE_FIFO: - case SQFS_INODE_SOCKET: { - sqfs_inode_ipc_t ipc = { - .nlink = htole32(hard_link_count(node)), - }; - - return meta_writer_append(im, &ipc, sizeof(ipc)); - } - case SQFS_INODE_EXT_FIFO: - case SQFS_INODE_EXT_SOCKET: { - sqfs_inode_ipc_ext_t ipc = { - .nlink = htole32(hard_link_count(node)), - .xattr_idx = htole32(0xFFFFFFFF), - }; - - if (node->xattr != NULL) - ipc.xattr_idx = htole32(node->xattr->index); - - return meta_writer_append(im, &ipc, sizeof(ipc)); - } - case SQFS_INODE_SLINK: { - sqfs_inode_slink_t slink = { - .nlink = htole32(hard_link_count(node)), - .target_size = htole32(strlen(node->data.slink_target)), - }; - - if (meta_writer_append(im, &slink, sizeof(slink))) - return -1; - if (meta_writer_append(im, node->data.slink_target, - le32toh(slink.target_size))) { - return -1; - } - break; - } - case SQFS_INODE_EXT_SLINK: { - sqfs_inode_slink_t slink = { - .nlink = htole32(hard_link_count(node)), - .target_size = htole32(strlen(node->data.slink_target)), - }; - uint32_t xattr = htole32(0xFFFFFFFF); - - if (node->xattr != NULL) - xattr = htole32(node->xattr->index); - - if (meta_writer_append(im, &slink, sizeof(slink))) - return -1; - if (meta_writer_append(im, node->data.slink_target, - le32toh(slink.target_size))) { - return -1; - } - if (meta_writer_append(im, &xattr, sizeof(xattr))) - return -1; - break; - } - case SQFS_INODE_BDEV: - case SQFS_INODE_CDEV: { - sqfs_inode_dev_t dev = { - .nlink = htole32(hard_link_count(node)), - .devno = htole32(node->data.devno), - }; - - return meta_writer_append(im, &dev, sizeof(dev)); - } - case SQFS_INODE_EXT_BDEV: - case SQFS_INODE_EXT_CDEV: { - sqfs_inode_dev_ext_t dev = { - .nlink = htole32(hard_link_count(node)), - .devno = htole32(node->data.devno), - .xattr_idx = htole32(0xFFFFFFFF), - }; - - if (node->xattr != NULL) - dev.xattr_idx = htole32(node->xattr->index); - - return meta_writer_append(im, &dev, sizeof(dev)); - } - case SQFS_INODE_EXT_FILE: { - file_info_t *fi = node->data.file; - sqfs_inode_file_ext_t ext = { - .blocks_start = htole64(fi->startblock), - .file_size = htole64(fi->size), - .sparse = htole64(fi->sparse), - .nlink = htole32(hard_link_count(node)), - .fragment_idx = htole32(0xFFFFFFFF), - .fragment_offset = htole32(0xFFFFFFFF), - .xattr_idx = htole32(0xFFFFFFFF), - }; - - if ((fi->size % fs->block_size) != 0) { - ext.fragment_idx = htole32(fi->fragment); - ext.fragment_offset = htole32(fi->fragment_offset); - } - - if (node->xattr != NULL) - ext.xattr_idx = htole32(node->xattr->index); - - if (meta_writer_append(im, &ext, sizeof(ext))) - return -1; - return write_file_blocks(fs, fi, im); - } - case SQFS_INODE_FILE: { - file_info_t *fi = node->data.file; - sqfs_inode_file_t reg = { - .blocks_start = htole32(fi->startblock), - .fragment_index = htole32(0xFFFFFFFF), - .fragment_offset = htole32(0xFFFFFFFF), - .file_size = htole32(fi->size), - }; - - if ((fi->size % fs->block_size) != 0) { - reg.fragment_index = htole32(fi->fragment); - reg.fragment_offset = htole32(fi->fragment_offset); - } - - if (meta_writer_append(im, ®, sizeof(reg))) - return -1; - return write_file_blocks(fs, fi, im); - } - case SQFS_INODE_DIR: { - sqfs_inode_dir_t dir = { - .start_block = htole32(node->data.dir->start_block), - .nlink = htole32(hard_link_count(node)), - .size = htole16(node->data.dir->size), - .offset = htole16(node->data.dir->block_offset), - .parent_inode = node->parent ? - htole32(node->parent->inode_num) : htole32(1), - }; - - return meta_writer_append(im, &dir, sizeof(dir)); - } - case SQFS_INODE_EXT_DIR: { - size_t idx_size; - sqfs_inode_dir_ext_t ext = { - .nlink = htole32(hard_link_count(node)), - .size = htole32(node->data.dir->size), - .start_block = htole32(node->data.dir->start_block), - .parent_inode = node->parent ? - htole32(node->parent->inode_num) : htole32(1), - .inodex_count = htole32(0), - .offset = htole16(node->data.dir->block_offset), - .xattr_idx = htole32(0xFFFFFFFF), - }; - - if (node->xattr != NULL) - ext.xattr_idx = htole32(node->xattr->index); - - idx_size = sqfs_dir_writer_get_index_size(dirw); - - if (idx_size > 0) - ext.inodex_count = htole32(idx_size - 1); - - if (meta_writer_append(im, &ext, sizeof(ext))) - return -1; - - if (sqfs_dir_writer_write_index(dirw, im)) - return -1; - break; - } - default: - assert(0); - } - return 0; -} -- cgit v1.2.3