1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2020 Bootlin
5 * Author: Joao Marcos Costa <joaomarcos.costa@bootlin.com>
8 #include <asm/unaligned.h>
15 #include "sqfs_decompressor.h"
16 #include "sqfs_filesystem.h"
17 #include "sqfs_utils.h"
19 int sqfs_inode_size(struct squashfs_base_inode *inode, u32 blk_size)
21 switch (get_unaligned_le16(&inode->inode_type)) {
23 return sizeof(struct squashfs_dir_inode);
26 struct squashfs_reg_inode *reg =
27 (struct squashfs_reg_inode *)inode;
28 u32 fragment = get_unaligned_le32(®->fragment);
29 u32 file_size = get_unaligned_le32(®->file_size);
30 unsigned int blk_list_size;
32 if (SQFS_IS_FRAGMENTED(fragment))
33 blk_list_size = file_size / blk_size;
35 blk_list_size = DIV_ROUND_UP(file_size, blk_size);
37 return sizeof(*reg) + blk_list_size * sizeof(u32);
40 case SQFS_LDIR_TYPE: {
41 struct squashfs_ldir_inode *ldir =
42 (struct squashfs_ldir_inode *)inode;
43 u16 i_count = get_unaligned_le16(&ldir->i_count);
44 unsigned int index_list_size = 0, l = 0;
45 struct squashfs_directory_index *di;
52 while (l < i_count + 1) {
53 sz = get_unaligned_le32(&di->size) + 1;
54 index_list_size += sz;
55 di = (void *)di + sizeof(*di) + sz;
59 return sizeof(*ldir) + index_list_size +
60 (i_count + 1) * SQFS_DIR_INDEX_BASE_LENGTH;
63 case SQFS_LREG_TYPE: {
64 struct squashfs_lreg_inode *lreg =
65 (struct squashfs_lreg_inode *)inode;
66 u32 fragment = get_unaligned_le32(&lreg->fragment);
67 u64 file_size = get_unaligned_le64(&lreg->file_size);
68 unsigned int blk_list_size;
70 if (fragment == 0xFFFFFFFF)
71 blk_list_size = DIV_ROUND_UP(file_size, blk_size);
73 blk_list_size = file_size / blk_size;
75 return sizeof(*lreg) + blk_list_size * sizeof(u32);
78 case SQFS_SYMLINK_TYPE:
79 case SQFS_LSYMLINK_TYPE: {
80 struct squashfs_symlink_inode *symlink =
81 (struct squashfs_symlink_inode *)inode;
83 return sizeof(*symlink) +
84 get_unaligned_le32(&symlink->symlink_size);
87 case SQFS_BLKDEV_TYPE:
88 case SQFS_CHRDEV_TYPE:
89 return sizeof(struct squashfs_dev_inode);
90 case SQFS_LBLKDEV_TYPE:
91 case SQFS_LCHRDEV_TYPE:
92 return sizeof(struct squashfs_ldev_inode);
94 case SQFS_SOCKET_TYPE:
95 return sizeof(struct squashfs_ipc_inode);
97 case SQFS_LSOCKET_TYPE:
98 return sizeof(struct squashfs_lipc_inode);
100 printf("Error while searching inode: unknown type.\n");
106 * Given the uncompressed inode table, the inode to be found and the number of
107 * inodes in the table, return inode position in case of success.
109 void *sqfs_find_inode(void *inode_table, int inode_number, __le32 inode_count,
112 struct squashfs_base_inode *base;
113 unsigned int offset = 0, k;
117 printf("%s: Invalid pointer to inode table.\n", __func__);
121 for (k = 0; k < le32_to_cpu(inode_count); k++) {
122 base = inode_table + offset;
123 if (get_unaligned_le32(&base->inode_number) == inode_number)
124 return inode_table + offset;
126 sz = sqfs_inode_size(base, le32_to_cpu(block_size));
133 printf("Inode not found.\n");
138 int sqfs_read_metablock(unsigned char *file_mapping, int offset,
139 bool *compressed, u32 *data_size)
141 const unsigned char *data;
144 data = file_mapping + offset;
145 header = get_unaligned((u16 *)data);
146 if (!header || !data)
149 *compressed = SQFS_COMPRESSED_METADATA(header);
150 *data_size = SQFS_METADATA_SIZE(header);
152 if (*data_size > SQFS_METADATA_BLOCK_SIZE) {
153 printf("Invalid metatada block size: %d bytes.\n", *data_size);