Add sqfs_decompressor_init() and sqfs_decompressor_cleanup(). These
functions are called respectively in sqfs_probe() and sqfs_close(). For
now, only ZSTD requires an initialization logic. ZSTD support will be
added in a follow-up commit.
Move squashfs_ctxt definition to sqfs_filesystem.h. This structure is
passed to sqfs_decompressor_init() and sqfs_decompressor_cleanup(), so
it can no longer be local to sqfs.c.
Signed-off-by: Joao Marcos Costa <joaomarcos.co...@bootlin.com>
---
Changes in v3:
- Remove memory leak from sqfs_zstd_decompress()
- Rename structure in sqfs.c and remove the 'static' so it can be
exported to sqfs_decompressor.c
Changes in v2:
- This patch was not present in the previous version.
fs/squashfs/sqfs.c | 87 +++++++++++++++++----------------
fs/squashfs/sqfs_decompressor.c | 36 ++++++++++++--
fs/squashfs/sqfs_decompressor.h | 3 ++
fs/squashfs/sqfs_filesystem.h | 9 +++-
4 files changed, 89 insertions(+), 46 deletions(-)
diff --git a/fs/squashfs/sqfs.c b/fs/squashfs/sqfs.c
index 340e5ebdb9..2836b3de8b 100644
--- a/fs/squashfs/sqfs.c
+++ b/fs/squashfs/sqfs.c
@@ -23,22 +23,16 @@
#include "sqfs_filesystem.h"
#include "sqfs_utils.h"
-struct squashfs_ctxt {
- struct disk_partition cur_part_info;
- struct blk_desc *cur_dev;
- struct squashfs_super_block *sblk;
-};
-
-static struct squashfs_ctxt ctxt;
+struct squashfs_ctxt sqfs_ctxt;
static int sqfs_disk_read(__u32 block, __u32 nr_blocks, void *buf)
{
ulong ret;
- if (!ctxt.cur_dev)
+ if (!sqfs_ctxt.cur_dev)
return -1;
- ret = blk_dread(ctxt.cur_dev, ctxt.cur_part_info.start + block,
+ ret = blk_dread(sqfs_ctxt.cur_dev, sqfs_ctxt.cur_part_info.start +
block,
nr_blocks, buf);
if (ret != nr_blocks)
@@ -49,7 +43,7 @@ static int sqfs_disk_read(__u32 block, __u32 nr_blocks, void
*buf)
static int sqfs_read_sblk(struct squashfs_super_block **sblk)
{
- *sblk = malloc_cache_aligned(ctxt.cur_dev->blksz);
+ *sblk = malloc_cache_aligned(sqfs_ctxt.cur_dev->blksz);
if (!*sblk)
return -ENOMEM;
@@ -91,10 +85,10 @@ static int sqfs_calc_n_blks(__le64 start, __le64 end, u64
*offset)
u64 start_, table_size;
table_size = le64_to_cpu(end) - le64_to_cpu(start);
- start_ = le64_to_cpu(start) / ctxt.cur_dev->blksz;
- *offset = le64_to_cpu(start) - (start_ * ctxt.cur_dev->blksz);
+ start_ = le64_to_cpu(start) / sqfs_ctxt.cur_dev->blksz;
+ *offset = le64_to_cpu(start) - (start_ * sqfs_ctxt.cur_dev->blksz);
- return DIV_ROUND_UP(table_size + *offset, ctxt.cur_dev->blksz);
+ return DIV_ROUND_UP(table_size + *offset, sqfs_ctxt.cur_dev->blksz);
}
/*
@@ -107,7 +101,7 @@ static int sqfs_frag_lookup(u32 inode_fragment_index,
u64 start, n_blks, src_len, table_offset, start_block;
unsigned char *metadata_buffer, *metadata, *table;
struct squashfs_fragment_block_entry *entries;
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
unsigned long dest_len;
int block, offset, ret;
u16 header, comp_type;
@@ -118,13 +112,13 @@ static int sqfs_frag_lookup(u32 inode_fragment_index,
return -EINVAL;
start = get_unaligned_le64(&sblk->fragment_table_start) /
- ctxt.cur_dev->blksz;
+ sqfs_ctxt.cur_dev->blksz;
n_blks = sqfs_calc_n_blks(sblk->fragment_table_start,
sblk->export_table_start,
&table_offset);
/* Allocate a proper sized buffer to store the fragment index table */
- table = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+ table = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
if (!table)
return -ENOMEM;
@@ -143,11 +137,11 @@ static int sqfs_frag_lookup(u32 inode_fragment_index,
start_block = get_unaligned_le64(table + table_offset + block *
sizeof(u64));
- start = start_block / ctxt.cur_dev->blksz;
+ start = start_block / sqfs_ctxt.cur_dev->blksz;
n_blks = sqfs_calc_n_blks(cpu_to_le64(start_block),
sblk->fragment_table_start, &table_offset);
- metadata_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+ metadata_buffer = malloc_cache_aligned(n_blks *
sqfs_ctxt.cur_dev->blksz);
if (!metadata_buffer) {
ret = -ENOMEM;
goto free_table;
@@ -434,7 +428,7 @@ static char *sqfs_resolve_symlink(struct
squashfs_symlink_inode *sym,
static int sqfs_search_dir(struct squashfs_dir_stream *dirs, char **token_list,
int token_count, u32 *m_list, int m_count)
{
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
char *path, *target, **sym_tokens, *res, *rem;
int j, ret, new_inode_number, offset;
struct squashfs_symlink_inode *sym;
@@ -633,7 +627,7 @@ static int sqfs_get_metablk_pos(u32 *pos_list, void *table,
u32 offset,
static int sqfs_read_inode_table(unsigned char **inode_table)
{
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
u64 start, n_blks, table_offset, table_size;
int j, ret = 0, metablks_count, comp_type;
unsigned char *src_table, *itb;
@@ -645,12 +639,12 @@ static int sqfs_read_inode_table(unsigned char
**inode_table)
table_size = get_unaligned_le64(&sblk->directory_table_start) -
get_unaligned_le64(&sblk->inode_table_start);
start = get_unaligned_le64(&sblk->inode_table_start) /
- ctxt.cur_dev->blksz;
+ sqfs_ctxt.cur_dev->blksz;
n_blks = sqfs_calc_n_blks(sblk->inode_table_start,
sblk->directory_table_start, &table_offset);
/* Allocate a proper sized buffer (itb) to store the inode table */
- itb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+ itb = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
if (!itb)
return -ENOMEM;
@@ -718,7 +712,7 @@ static int sqfs_read_directory_table(unsigned char
**dir_table, u32 **pos_list)
{
u64 start, n_blks, table_offset, table_size;
int j, ret = 0, metablks_count = -1, comp_type;
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
unsigned char *src_table, *dtb;
u32 src_len, dest_offset = 0;
unsigned long dest_len;
@@ -730,12 +724,12 @@ static int sqfs_read_directory_table(unsigned char
**dir_table, u32 **pos_list)
table_size = get_unaligned_le64(&sblk->fragment_table_start) -
get_unaligned_le64(&sblk->directory_table_start);
start = get_unaligned_le64(&sblk->directory_table_start) /
- ctxt.cur_dev->blksz;
+ sqfs_ctxt.cur_dev->blksz;
n_blks = sqfs_calc_n_blks(sblk->directory_table_start,
sblk->fragment_table_start, &table_offset);
/* Allocate a proper sized buffer (dtb) to store the directory table */
- dtb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+ dtb = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
if (!dtb)
return -ENOMEM;
@@ -891,7 +885,7 @@ free_path:
int sqfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
{
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
struct squashfs_dir_stream *dirs;
struct squashfs_lreg_inode *lreg;
struct squashfs_base_inode *base;
@@ -1007,8 +1001,8 @@ int sqfs_probe(struct blk_desc *fs_dev_desc, struct
disk_partition *fs_partition
struct squashfs_super_block *sblk;
int ret;
- ctxt.cur_dev = fs_dev_desc;
- ctxt.cur_part_info = *fs_partition;
+ sqfs_ctxt.cur_dev = fs_dev_desc;
+ sqfs_ctxt.cur_part_info = *fs_partition;
ret = sqfs_read_sblk(&sblk);
if (ret)
@@ -1017,11 +1011,19 @@ int sqfs_probe(struct blk_desc *fs_dev_desc, struct
disk_partition *fs_partition
/* Make sure it has a valid SquashFS magic number*/
if (get_unaligned_le32(&sblk->s_magic) != SQFS_MAGIC_NUMBER) {
printf("Bad magic number for SquashFS image.\n");
- ctxt.cur_dev = NULL;
+ sqfs_ctxt.cur_dev = NULL;
return -EINVAL;
}
- ctxt.sblk = sblk;
+ sqfs_ctxt.sblk = sblk;
+
+ ret = sqfs_decompressor_init(&sqfs_ctxt);
+
+ if (ret) {
+ sqfs_ctxt.cur_dev = NULL;
+ free(sqfs_ctxt.sblk);
+ return -EINVAL;
+ }
return 0;
}
@@ -1196,7 +1198,7 @@ int sqfs_read(const char *filename, void *buf, loff_t
offset, loff_t len,
char *fragment, *file, *resolved, *data;
u64 start, n_blks, table_size, data_offset, table_offset;
int ret, j, i_number, comp_type, datablk_count = 0;
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
struct squashfs_fragment_block_entry frag_entry;
struct squashfs_file_info finfo = {0};
struct squashfs_symlink_inode *symlink;
@@ -1315,13 +1317,13 @@ int sqfs_read(const char *filename, void *buf, loff_t
offset, loff_t len,
}
for (j = 0; j < datablk_count; j++) {
- start = data_offset / ctxt.cur_dev->blksz;
+ start = data_offset / sqfs_ctxt.cur_dev->blksz;
table_size = SQFS_BLOCK_SIZE(finfo.blk_sizes[j]);
- table_offset = data_offset - (start * ctxt.cur_dev->blksz);
+ table_offset = data_offset - (start * sqfs_ctxt.cur_dev->blksz);
n_blks = DIV_ROUND_UP(table_size + table_offset,
- ctxt.cur_dev->blksz);
+ sqfs_ctxt.cur_dev->blksz);
- data_buffer = malloc_cache_aligned(n_blks *
ctxt.cur_dev->blksz);
+ data_buffer = malloc_cache_aligned(n_blks *
sqfs_ctxt.cur_dev->blksz);
if (!data_buffer) {
ret = -ENOMEM;
@@ -1369,12 +1371,12 @@ int sqfs_read(const char *filename, void *buf, loff_t
offset, loff_t len,
goto free_buffer;
}
- start = frag_entry.start / ctxt.cur_dev->blksz;
+ start = frag_entry.start / sqfs_ctxt.cur_dev->blksz;
table_size = SQFS_BLOCK_SIZE(frag_entry.size);
- table_offset = frag_entry.start - (start * ctxt.cur_dev->blksz);
- n_blks = DIV_ROUND_UP(table_size + table_offset, ctxt.cur_dev->blksz);
+ table_offset = frag_entry.start - (start * sqfs_ctxt.cur_dev->blksz);
+ n_blks = DIV_ROUND_UP(table_size + table_offset,
sqfs_ctxt.cur_dev->blksz);
- fragment = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+ fragment = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
if (!fragment) {
ret = -ENOMEM;
@@ -1435,7 +1437,7 @@ free_paths:
int sqfs_size(const char *filename, loff_t *size)
{
- struct squashfs_super_block *sblk = ctxt.sblk;
+ struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
struct squashfs_symlink_inode *symlink;
struct fs_dir_stream *dirsp = NULL;
struct squashfs_base_inode *base;
@@ -1523,8 +1525,9 @@ free_strings:
void sqfs_close(void)
{
- free(ctxt.sblk);
- ctxt.cur_dev = NULL;
+ free(sqfs_ctxt.sblk);
+ sqfs_ctxt.cur_dev = NULL;
+ sqfs_decompressor_cleanup(&sqfs_ctxt);
}
void sqfs_closedir(struct fs_dir_stream *dirs)
diff --git a/fs/squashfs/sqfs_decompressor.c b/fs/squashfs/sqfs_decompressor.c
index 09ca6cf6d0..577cffd8bb 100644
--- a/fs/squashfs/sqfs_decompressor.c
+++ b/fs/squashfs/sqfs_decompressor.c
@@ -14,9 +14,39 @@
#endif
#include "sqfs_decompressor.h"
-#include "sqfs_filesystem.h"
#include "sqfs_utils.h"
+extern struct squashfs_ctxt sqfs_ctxt;
+
+int sqfs_decompressor_init(struct squashfs_ctxt *ctxt)
+{
+ u16 comp_type = get_unaligned_le16(&ctxt->sblk->compression);
+
+ switch (comp_type) {
+#if IS_ENABLED(CONFIG_ZLIB)
+ case SQFS_COMP_ZLIB:
+ break;
+#endif
+ default:
+ printf("Error: unknown compression type.\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+void sqfs_decompressor_cleanup(struct squashfs_ctxt *ctxt)
+{
+ u16 comp_type = get_unaligned_le16(&ctxt->sblk->compression);
+
+ switch (comp_type) {
+#if IS_ENABLED(CONFIG_ZLIB)
+ case SQFS_COMP_ZLIB:
+ break;
+#endif
+ }
+}
+
#if IS_ENABLED(CONFIG_ZLIB)
static void zlib_decompression_status(int ret)
{
@@ -35,14 +65,14 @@ static void zlib_decompression_status(int ret)
#endif
int sqfs_decompress(u16 comp_type, void *dest, unsigned long *dest_len,
- void *source, u32 lenp)
+ void *source, u32 src_len)
{
int ret = 0;
switch (comp_type) {
#if IS_ENABLED(CONFIG_ZLIB)
case SQFS_COMP_ZLIB:
- ret = uncompress(dest, dest_len, source, lenp);
+ ret = uncompress(dest, dest_len, source, src_len);
if (ret) {
zlib_decompression_status(ret);
return -EINVAL;
diff --git a/fs/squashfs/sqfs_decompressor.h b/fs/squashfs/sqfs_decompressor.h
index 378965dda8..450257e5ce 100644
--- a/fs/squashfs/sqfs_decompressor.h
+++ b/fs/squashfs/sqfs_decompressor.h
@@ -9,6 +9,7 @@
#define SQFS_DECOMPRESSOR_H
#include <stdint.h>
+#include "sqfs_filesystem.h"
#define SQFS_COMP_ZLIB 1
#define SQFS_COMP_LZMA 2
@@ -54,5 +55,7 @@ union squashfs_compression_opts {
int sqfs_decompress(u16 comp_type, void *dest, unsigned long *dest_len,
void *source, u32 lenp);
+int sqfs_decompressor_init(struct squashfs_ctxt *ctxt);
+void sqfs_decompressor_cleanup(struct squashfs_ctxt *ctxt);
#endif /* SQFS_DECOMPRESSOR_H */
diff --git a/fs/squashfs/sqfs_filesystem.h b/fs/squashfs/sqfs_filesystem.h
index d63e3a41ad..ff2b0b1d34 100644
--- a/fs/squashfs/sqfs_filesystem.h
+++ b/fs/squashfs/sqfs_filesystem.h
@@ -9,8 +9,9 @@
#define SQFS_FILESYSTEM_H
#include <asm/unaligned.h>
-#include <stdint.h>
#include <fs.h>
+#include <part.h>
+#include <stdint.h>
#define SQFS_UNCOMPRESSED_DATA 0x0002
#define SQFS_MAGIC_NUMBER 0x73717368
@@ -72,6 +73,12 @@ struct squashfs_super_block {
__le64 export_table_start;
};
+struct squashfs_ctxt {
+ struct disk_partition cur_part_info;
+ struct blk_desc *cur_dev;
+ struct squashfs_super_block *sblk;
+};
+
struct squashfs_directory_index {
u32 index;
u32 start;
--
2.17.1
