LXR uboot/fs/squashfs/sqfs

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) 2020 Bootlin
   4 *
   5 * Author: Joao Marcos Costa <joaomarcos.costa@bootlin.com>
   6 */
   7
   8#include <asm/unaligned.h>
   9#include <compiler.h>
  10#include <errno.h>
  11#include <stdint.h>
  12#include <stdio.h>
  13#include <stdlib.h>
  14#include <string.h>
  15
  16#include "sqfs_decompressor.h"
  17#include "sqfs_filesystem.h"
  18#include "sqfs_utils.h"
  19
  20int sqfs_inode_size(struct squashfs_base_inode *inode, u32 blk_size)
  21{
  22        switch (get_unaligned_le16(&inode->inode_type)) {
  23        case SQFS_DIR_TYPE:
  24                return sizeof(struct squashfs_dir_inode);
  25
  26        case SQFS_REG_TYPE: {
  27                struct squashfs_reg_inode *reg =
  28                        (struct squashfs_reg_inode *)inode;
  29                u32 fragment = get_unaligned_le32(&reg->fragment);
  30                u32 file_size = get_unaligned_le32(&reg->file_size);
  31                unsigned int blk_list_size;
  32
  33                if (SQFS_IS_FRAGMENTED(fragment))
  34                        blk_list_size = file_size / blk_size;
  35                else
  36                        blk_list_size = DIV_ROUND_UP(file_size, blk_size);
  37
  38                return sizeof(*reg) + blk_list_size * sizeof(u32);
  39        }
  40
  41        case SQFS_LDIR_TYPE: {
  42                struct squashfs_ldir_inode *ldir =
  43                        (struct squashfs_ldir_inode *)inode;
  44                u16 i_count = get_unaligned_le16(&ldir->i_count);
  45                unsigned int index_list_size = 0, l = 0;
  46                struct squashfs_directory_index *di;
  47                u32 sz;
  48
  49                if (i_count == 0)
  50                        return sizeof(*ldir);
  51
  52                di = ldir->index;
  53                while (l < i_count) {
  54                        sz = get_unaligned_le32(&di->size) + 1;
  55                        index_list_size += sz;
  56                        di = (void *)di + sizeof(*di) + sz;
  57                        l++;
  58                }
  59
  60                return sizeof(*ldir) + index_list_size +
  61                        i_count * SQFS_DIR_INDEX_BASE_LENGTH;
  62        }
  63
  64        case SQFS_LREG_TYPE: {
  65                struct squashfs_lreg_inode *lreg =
  66                        (struct squashfs_lreg_inode *)inode;
  67                u32 fragment = get_unaligned_le32(&lreg->fragment);
  68                u64 file_size = get_unaligned_le64(&lreg->file_size);
  69                unsigned int blk_list_size;
  70
  71                if (fragment == 0xFFFFFFFF)
  72                        blk_list_size = DIV_ROUND_UP(file_size, blk_size);
  73                else
  74                        blk_list_size = file_size / blk_size;
  75
  76                return sizeof(*lreg) + blk_list_size * sizeof(u32);
  77        }
  78
  79        case SQFS_SYMLINK_TYPE:
  80        case SQFS_LSYMLINK_TYPE: {
  81                struct squashfs_symlink_inode *symlink =
  82                        (struct squashfs_symlink_inode *)inode;
  83
  84                return sizeof(*symlink) +
  85                        get_unaligned_le32(&symlink->symlink_size);
  86        }
  87
  88        case SQFS_BLKDEV_TYPE:
  89        case SQFS_CHRDEV_TYPE:
  90                return sizeof(struct squashfs_dev_inode);
  91        case SQFS_LBLKDEV_TYPE:
  92        case SQFS_LCHRDEV_TYPE:
  93                return sizeof(struct squashfs_ldev_inode);
  94        case SQFS_FIFO_TYPE:
  95        case SQFS_SOCKET_TYPE:
  96                return sizeof(struct squashfs_ipc_inode);
  97        case SQFS_LFIFO_TYPE:
  98        case SQFS_LSOCKET_TYPE:
  99                return sizeof(struct squashfs_lipc_inode);
 100        default:
 101                printf("Error while searching inode: unknown type.\n");
 102                return -EINVAL;
 103        }
 104}
 105
 106/*
 107 * Given the uncompressed inode table, the inode to be found and the number of
 108 * inodes in the table, return inode position in case of success.
 109 */
 110void *sqfs_find_inode(void *inode_table, int inode_number, __le32 inode_count,
 111                      __le32 block_size)
 112{
 113        struct squashfs_base_inode *base;
 114        unsigned int offset = 0, k;
 115        int sz;
 116
 117        if (!inode_table) {
 118                printf("%s: Invalid pointer to inode table.\n", __func__);
 119                return NULL;
 120        }
 121
 122        for (k = 0; k < le32_to_cpu(inode_count); k++) {
 123                base = inode_table + offset;
 124                if (get_unaligned_le32(&base->inode_number) == inode_number)
 125                        return inode_table + offset;
 126
 127                sz = sqfs_inode_size(base, le32_to_cpu(block_size));
 128                if (sz < 0)
 129                        return NULL;
 130
 131                offset += sz;
 132        }
 133
 134        printf("Inode not found.\n");
 135
 136        return NULL;
 137}
 138
 139int sqfs_read_metablock(unsigned char *file_mapping, int offset,
 140                        bool *compressed, u32 *data_size)
 141{
 142        const unsigned char *data;
 143        u16 header;
 144
 145        if (!file_mapping)
 146                return -EFAULT;
 147        data = file_mapping + offset;
 148
 149        header = get_unaligned((u16 *)data);
 150        if (!header)
 151                return -EINVAL;
 152
 153        *compressed = SQFS_COMPRESSED_METADATA(header);
 154        *data_size = SQFS_METADATA_SIZE(header);
 155
 156        if (*data_size > SQFS_METADATA_BLOCK_SIZE) {
 157                printf("Invalid metatada block size: %d bytes.\n", *data_size);
 158                return -EINVAL;
 159        }
 160
 161        return 0;
 162}
 163