fs/squashfs/sqfs_filesystem.h

   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 #ifndef SQFS_FILESYSTEM_H
   9 #define SQFS_FILESYSTEM_H
  10
  11 #include <asm/unaligned.h>
  12 #include <fs.h>
  13 #include <part.h>
  14 #include <stdint.h>
  15
  16 #define SQFS_UNCOMPRESSED_DATA 0x0002
  17 #define SQFS_MAGIC_NUMBER 0x73717368
  18 /* The three first members of squashfs_dir_index make a total of 12 bytes */
  19 #define SQFS_DIR_INDEX_BASE_LENGTH 12
  20 /* size of metadata (inode and directory) blocks */
  21 #define SQFS_METADATA_BLOCK_SIZE 8192
  22 /* Max. number of fragment entries in a metadata block is 512 */
  23 #define SQFS_MAX_ENTRIES 512
  24 /* Metadata blocks start by a 2-byte length header */
  25 #define SQFS_HEADER_SIZE 2
  26 #define SQFS_LREG_INODE_MIN_SIZE 56
  27 #define SQFS_DIR_HEADER_SIZE 12
  28 #define SQFS_MISC_ENTRY_TYPE -1
  29 #define SQFS_EMPTY_FILE_SIZE 3
  30 #define SQFS_STOP_READDIR 1
  31 #define SQFS_EMPTY_DIR -1
  32 /*
  33  * A directory entry object has a fixed length of 8 bytes, corresponding to its
  34  * first four members, plus the size of the entry name, which is equal to
  35  * 'entry_name' + 1 bytes.
  36  */
  37 #define SQFS_ENTRY_BASE_LENGTH 8
  38 /* Inode types */
  39 #define SQFS_DIR_TYPE 1
  40 #define SQFS_REG_TYPE 2
  41 #define SQFS_SYMLINK_TYPE 3
  42 #define SQFS_BLKDEV_TYPE 4
  43 #define SQFS_CHRDEV_TYPE 5
  44 #define SQFS_FIFO_TYPE 6
  45 #define SQFS_SOCKET_TYPE 7
  46 #define SQFS_LDIR_TYPE 8
  47 #define SQFS_LREG_TYPE 9
  48 #define SQFS_LSYMLINK_TYPE 10
  49 #define SQFS_LBLKDEV_TYPE 11
  50 #define SQFS_LCHRDEV_TYPE 12
  51 #define SQFS_LFIFO_TYPE 13
  52 #define SQFS_LSOCKET_TYPE 14
  53
  54 struct squashfs_super_block {
  55         __le32 s_magic;
  56         __le32 inodes;
  57         __le32 mkfs_time;
  58         __le32 block_size;
  59         __le32 fragments;
  60         __le16 compression;
  61         __le16 block_log;
  62         __le16 flags;
  63         __le16 no_ids;
  64         __le16 s_major;
  65         __le16 s_minor;
  66         __le64 root_inode;
  67         __le64 bytes_used;
  68         __le64 id_table_start;
  69         __le64 xattr_id_table_start;
  70         __le64 inode_table_start;
  71         __le64 directory_table_start;
  72         __le64 fragment_table_start;
  73         __le64 export_table_start;
  74 };
  75
  76 struct squashfs_ctxt {
  77         struct disk_partition cur_part_info;
  78         struct blk_desc *cur_dev;
  79         struct squashfs_super_block *sblk;
  80 };
  81
  82 struct squashfs_directory_index {
  83         u32 index;
  84         u32 start;
  85         u32 size;
  86         char name[0];
  87 };
  88
  89 struct squashfs_base_inode {
  90         __le16 inode_type;
  91         __le16 mode;
  92         __le16 uid;
  93         __le16 guid;
  94         __le32 mtime;
  95         __le32 inode_number;
  96 };
  97
  98 struct squashfs_ipc_inode {
  99         __le16 inode_type;
 100         __le16 mode;
 101         __le16 uid;
 102         __le16 guid;
 103         __le32 mtime;
 104         __le32 inode_number;
 105         __le32 nlink;
 106 };
 107
 108 struct squashfs_lipc_inode {
 109         __le16 inode_type;
 110         __le16 mode;
 111         __le16 uid;
 112         __le16 guid;
 113         __le32 mtime;
 114         __le32 inode_number;
 115         __le32 nlink;
 116         __le32 xattr;
 117 };
 118
 119 struct squashfs_dev_inode {
 120         __le16 inode_type;
 121         __le16 mode;
 122         __le16 uid;
 123         __le16 guid;
 124         __le32 mtime;
 125         __le32 inode_number;
 126         __le32 nlink;
 127         __le32 rdev;
 128 };
 129
 130 struct squashfs_ldev_inode {
 131         __le16 inode_type;
 132         __le16 mode;
 133         __le16 uid;
 134         __le16 guid;
 135         __le32 mtime;
 136         __le32 inode_number;
 137         __le32 nlink;
 138         __le32 rdev;
 139         __le32 xattr;
 140 };
 141
 142 struct squashfs_symlink_inode {
 143         __le16 inode_type;
 144         __le16 mode;
 145         __le16 uid;
 146         __le16 guid;
 147         __le32 mtime;
 148         __le32 inode_number;
 149         __le32 nlink;
 150         __le32 symlink_size;
 151         char symlink[0];
 152 };
 153
 154 struct squashfs_reg_inode {
 155         __le16 inode_type;
 156         __le16 mode;
 157         __le16 uid;
 158         __le16 guid;
 159         __le32 mtime;
 160         __le32 inode_number;
 161         __le32 start_block;
 162         __le32 fragment;
 163         __le32 offset;
 164         __le32 file_size;
 165         __le32 block_list[0];
 166 };
 167
 168 struct squashfs_lreg_inode {
 169         __le16 inode_type;
 170         __le16 mode;
 171         __le16 uid;
 172         __le16 guid;
 173         __le32 mtime;
 174         __le32 inode_number;
 175         __le64 start_block;
 176         __le64 file_size;
 177         __le64 sparse;
 178         __le32 nlink;
 179         __le32 fragment;
 180         __le32 offset;
 181         __le32 xattr;
 182         __le32 block_list[0];
 183 };
 184
 185 struct squashfs_dir_inode {
 186         __le16 inode_type;
 187         __le16 mode;
 188         __le16 uid;
 189         __le16 guid;
 190         __le32 mtime;
 191         __le32 inode_number;
 192         __le32 start_block;
 193         __le32 nlink;
 194         __le16 file_size;
 195         __le16 offset;
 196         __le32 parent_inode;
 197 };
 198
 199 struct squashfs_ldir_inode {
 200         __le16 inode_type;
 201         __le16 mode;
 202         __le16 uid;
 203         __le16 guid;
 204         __le32 mtime;
 205         __le32 inode_number;
 206         __le32 nlink;
 207         __le32 file_size;
 208         __le32 start_block;
 209         __le32 parent_inode;
 210         __le16 i_count;
 211         __le16 offset;
 212         __le32 xattr;
 213         struct squashfs_directory_index index[0];
 214 };
 215
 216 union squashfs_inode {
 217         struct squashfs_base_inode *base;
 218         struct squashfs_dev_inode *dev;
 219         struct squashfs_ldev_inode *ldev;
 220         struct squashfs_symlink_inode *symlink;
 221         struct squashfs_reg_inode *reg;
 222         struct squashfs_lreg_inode *lreg;
 223         struct squashfs_dir_inode *dir;
 224         struct squashfs_ldir_inode *ldir;
 225         struct squashfs_ipc_inode *ipc;
 226         struct squashfs_lipc_inode *lipc;
 227 };
 228
 229 struct squashfs_directory_entry {
 230         u16 offset;
 231         u16 inode_offset;
 232         u16 type;
 233         u16 name_size;
 234         char name[0];
 235 };
 236
 237 struct squashfs_directory_header {
 238         u32 count;
 239         u32 start;
 240         u32 inode_number;
 241 };
 242
 243 struct squashfs_fragment_block_entry {
 244         u64 start;
 245         u32 size;
 246         u32 _unused;
 247 };
 248
 249 struct squashfs_dir_stream {
 250         struct fs_dir_stream fs_dirs;
 251         struct fs_dirent dentp;
 252         /*
 253          * 'size' is the uncompressed size of the entire listing, including
 254          * headers. 'entry_count' is the number of entries following a
 255          * specific header. Both variables are decremented in sqfs_readdir() so
 256          * the function knows when the end of the directory is reached.
 257          */
 258         size_t size;
 259         int entry_count;
 260         /* SquashFS structures */
 261         struct squashfs_directory_header *dir_header;
 262         struct squashfs_directory_entry *entry;
 263         /*
 264          * 'table' points to a position into the directory table. Both 'table'
 265          * and 'inode' are defined for the first time in sqfs_opendir().
 266          * 'table's value changes in sqfs_readdir().
 267          */
 268         unsigned char *table;
 269         union squashfs_inode i;
 270         struct squashfs_dir_inode i_dir;
 271         struct squashfs_ldir_inode i_ldir;
 272         /*
 273          * References to the tables' beginnings. They are assigned in
 274          * sqfs_opendir() and freed in sqfs_closedir().
 275          */
 276         unsigned char *inode_table;
 277         unsigned char *dir_table;
 278 };
 279
 280 struct squashfs_file_info {
 281         /* File size in bytes (uncompressed) */
 282         size_t size;
 283         /* Reference to list of data blocks's sizes */
 284         u32 *blk_sizes;
 285         /* Offset into the fragment block */
 286         u32 offset;
 287         /* Offset in which the data blocks begin */
 288         u64 start;
 289         /* Is file fragmented? */
 290         bool frag;
 291         /* Compressed fragment */
 292         bool comp;
 293 };
 294
 295 void *sqfs_find_inode(void *inode_table, int inode_number, __le32 inode_count,
 296                       __le32 block_size);
 297
 298 int sqfs_dir_offset(void *dir_i, u32 *m_list, int m_count);
 299
 300 int sqfs_read_metablock(unsigned char *file_mapping, int offset,
 301                         bool *compressed, u32 *data_size);
 302
 303 bool sqfs_is_empty_dir(void *dir_i);
 304
 305 bool sqfs_is_dir(u16 type);
 306
 307 #endif /* SQFS_FILESYSTEM_H */