1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Squashfs - a compressed read only filesystem for Linux 4 * 5 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 6 * Phillip Lougher <phillip@squashfs.org.uk> 7 * 8 * inode.c 9 */ 10 11 /* 12 * This file implements code to create and read inodes from disk. 13 * 14 * Inodes in Squashfs are identified by a 48-bit inode which encodes the 15 * location of the compressed metadata block containing the inode, and the byte 16 * offset into that block where the inode is placed (<block, offset>). 17 * 18 * To maximise compression there are different inodes for each file type 19 * (regular file, directory, device, etc.), the inode contents and length 20 * varying with the type. 21 * 22 * To further maximise compression, two types of regular file inode and 23 * directory inode are defined: inodes optimised for frequently occurring 24 * regular files and directories, and extended types where extra 25 * information has to be stored. 26 */ 27 28 #include <linux/fs.h> 29 #include <linux/vfs.h> 30 #include <linux/xattr.h> 31 #include <linux/pagemap.h> 32 33 #include "squashfs_fs.h" 34 #include "squashfs_fs_sb.h" 35 #include "squashfs_fs_i.h" 36 #include "squashfs.h" 37 #include "xattr.h" 38 39 /* 40 * Initialise VFS inode with the base inode information common to all 41 * Squashfs inode types. Sqsh_ino contains the unswapped base inode 42 * off disk. 43 */ 44 static int squashfs_new_inode(struct super_block *sb, struct inode *inode, 45 struct squashfs_base_inode *sqsh_ino) 46 { 47 uid_t i_uid; 48 gid_t i_gid; 49 int err; 50 51 err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->uid), &i_uid); 52 if (err) 53 return err; 54 55 err = squashfs_get_id(sb, le16_to_cpu(sqsh_ino->guid), &i_gid); 56 if (err) 57 return err; 58 59 i_uid_write(inode, i_uid); 60 i_gid_write(inode, i_gid); 61 inode->i_ino = le32_to_cpu(sqsh_ino->inode_number); 62 inode->i_mtime.tv_sec = le32_to_cpu(sqsh_ino->mtime); 63 inode->i_atime.tv_sec = inode->i_mtime.tv_sec; 64 inode->i_ctime.tv_sec = inode->i_mtime.tv_sec; 65 inode->i_mode = le16_to_cpu(sqsh_ino->mode); 66 inode->i_size = 0; 67 68 return err; 69 } 70 71 72 struct inode *squashfs_iget(struct super_block *sb, long long ino, 73 unsigned int ino_number) 74 { 75 struct inode *inode = iget_locked(sb, ino_number); 76 int err; 77 78 TRACE("Entered squashfs_iget\n"); 79 80 if (!inode) 81 return ERR_PTR(-ENOMEM); 82 if (!(inode->i_state & I_NEW)) 83 return inode; 84 85 err = squashfs_read_inode(inode, ino); 86 if (err) { 87 iget_failed(inode); 88 return ERR_PTR(err); 89 } 90 91 unlock_new_inode(inode); 92 return inode; 93 } 94 95 96 /* 97 * Initialise VFS inode by reading inode from inode table (compressed 98 * metadata). The format and amount of data read depends on type. 99 */ 100 int squashfs_read_inode(struct inode *inode, long long ino) 101 { 102 struct super_block *sb = inode->i_sb; 103 struct squashfs_sb_info *msblk = sb->s_fs_info; 104 u64 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table; 105 int err, type, offset = SQUASHFS_INODE_OFFSET(ino); 106 union squashfs_inode squashfs_ino; 107 struct squashfs_base_inode *sqshb_ino = &squashfs_ino.base; 108 int xattr_id = SQUASHFS_INVALID_XATTR; 109 110 TRACE("Entered squashfs_read_inode\n"); 111 112 /* 113 * Read inode base common to all inode types. 114 */ 115 err = squashfs_read_metadata(sb, sqshb_ino, &block, 116 &offset, sizeof(*sqshb_ino)); 117 if (err < 0) 118 goto failed_read; 119 120 err = squashfs_new_inode(sb, inode, sqshb_ino); 121 if (err) 122 goto failed_read; 123 124 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table; 125 offset = SQUASHFS_INODE_OFFSET(ino); 126 127 type = le16_to_cpu(sqshb_ino->inode_type); 128 switch (type) { 129 case SQUASHFS_REG_TYPE: { 130 unsigned int frag_offset, frag; 131 int frag_size; 132 u64 frag_blk; 133 struct squashfs_reg_inode *sqsh_ino = &squashfs_ino.reg; 134 135 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 136 sizeof(*sqsh_ino)); 137 if (err < 0) 138 goto failed_read; 139 140 frag = le32_to_cpu(sqsh_ino->fragment); 141 if (frag != SQUASHFS_INVALID_FRAG) { 142 frag_offset = le32_to_cpu(sqsh_ino->offset); 143 frag_size = squashfs_frag_lookup(sb, frag, &frag_blk); 144 if (frag_size < 0) { 145 err = frag_size; 146 goto failed_read; 147 } 148 } else { 149 frag_blk = SQUASHFS_INVALID_BLK; 150 frag_size = 0; 151 frag_offset = 0; 152 } 153 154 set_nlink(inode, 1); 155 inode->i_size = le32_to_cpu(sqsh_ino->file_size); 156 inode->i_fop = &generic_ro_fops; 157 inode->i_mode |= S_IFREG; 158 inode->i_blocks = ((inode->i_size - 1) >> 9) + 1; 159 squashfs_i(inode)->fragment_block = frag_blk; 160 squashfs_i(inode)->fragment_size = frag_size; 161 squashfs_i(inode)->fragment_offset = frag_offset; 162 squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block); 163 squashfs_i(inode)->block_list_start = block; 164 squashfs_i(inode)->offset = offset; 165 inode->i_data.a_ops = &squashfs_aops; 166 167 TRACE("File inode %x:%x, start_block %llx, block_list_start " 168 "%llx, offset %x\n", SQUASHFS_INODE_BLK(ino), 169 offset, squashfs_i(inode)->start, block, offset); 170 break; 171 } 172 case SQUASHFS_LREG_TYPE: { 173 unsigned int frag_offset, frag; 174 int frag_size; 175 u64 frag_blk; 176 struct squashfs_lreg_inode *sqsh_ino = &squashfs_ino.lreg; 177 178 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 179 sizeof(*sqsh_ino)); 180 if (err < 0) 181 goto failed_read; 182 183 frag = le32_to_cpu(sqsh_ino->fragment); 184 if (frag != SQUASHFS_INVALID_FRAG) { 185 frag_offset = le32_to_cpu(sqsh_ino->offset); 186 frag_size = squashfs_frag_lookup(sb, frag, &frag_blk); 187 if (frag_size < 0) { 188 err = frag_size; 189 goto failed_read; 190 } 191 } else { 192 frag_blk = SQUASHFS_INVALID_BLK; 193 frag_size = 0; 194 frag_offset = 0; 195 } 196 197 xattr_id = le32_to_cpu(sqsh_ino->xattr); 198 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 199 inode->i_size = le64_to_cpu(sqsh_ino->file_size); 200 inode->i_op = &squashfs_inode_ops; 201 inode->i_fop = &generic_ro_fops; 202 inode->i_mode |= S_IFREG; 203 inode->i_blocks = (inode->i_size - 204 le64_to_cpu(sqsh_ino->sparse) + 511) >> 9; 205 206 squashfs_i(inode)->fragment_block = frag_blk; 207 squashfs_i(inode)->fragment_size = frag_size; 208 squashfs_i(inode)->fragment_offset = frag_offset; 209 squashfs_i(inode)->start = le64_to_cpu(sqsh_ino->start_block); 210 squashfs_i(inode)->block_list_start = block; 211 squashfs_i(inode)->offset = offset; 212 inode->i_data.a_ops = &squashfs_aops; 213 214 TRACE("File inode %x:%x, start_block %llx, block_list_start " 215 "%llx, offset %x\n", SQUASHFS_INODE_BLK(ino), 216 offset, squashfs_i(inode)->start, block, offset); 217 break; 218 } 219 case SQUASHFS_DIR_TYPE: { 220 struct squashfs_dir_inode *sqsh_ino = &squashfs_ino.dir; 221 222 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 223 sizeof(*sqsh_ino)); 224 if (err < 0) 225 goto failed_read; 226 227 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 228 inode->i_size = le16_to_cpu(sqsh_ino->file_size); 229 inode->i_op = &squashfs_dir_inode_ops; 230 inode->i_fop = &squashfs_dir_ops; 231 inode->i_mode |= S_IFDIR; 232 squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block); 233 squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset); 234 squashfs_i(inode)->dir_idx_cnt = 0; 235 squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode); 236 237 TRACE("Directory inode %x:%x, start_block %llx, offset %x\n", 238 SQUASHFS_INODE_BLK(ino), offset, 239 squashfs_i(inode)->start, 240 le16_to_cpu(sqsh_ino->offset)); 241 break; 242 } 243 case SQUASHFS_LDIR_TYPE: { 244 struct squashfs_ldir_inode *sqsh_ino = &squashfs_ino.ldir; 245 246 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 247 sizeof(*sqsh_ino)); 248 if (err < 0) 249 goto failed_read; 250 251 xattr_id = le32_to_cpu(sqsh_ino->xattr); 252 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 253 inode->i_size = le32_to_cpu(sqsh_ino->file_size); 254 inode->i_op = &squashfs_dir_inode_ops; 255 inode->i_fop = &squashfs_dir_ops; 256 inode->i_mode |= S_IFDIR; 257 squashfs_i(inode)->start = le32_to_cpu(sqsh_ino->start_block); 258 squashfs_i(inode)->offset = le16_to_cpu(sqsh_ino->offset); 259 squashfs_i(inode)->dir_idx_start = block; 260 squashfs_i(inode)->dir_idx_offset = offset; 261 squashfs_i(inode)->dir_idx_cnt = le16_to_cpu(sqsh_ino->i_count); 262 squashfs_i(inode)->parent = le32_to_cpu(sqsh_ino->parent_inode); 263 264 TRACE("Long directory inode %x:%x, start_block %llx, offset " 265 "%x\n", SQUASHFS_INODE_BLK(ino), offset, 266 squashfs_i(inode)->start, 267 le16_to_cpu(sqsh_ino->offset)); 268 break; 269 } 270 case SQUASHFS_SYMLINK_TYPE: 271 case SQUASHFS_LSYMLINK_TYPE: { 272 struct squashfs_symlink_inode *sqsh_ino = &squashfs_ino.symlink; 273 274 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 275 sizeof(*sqsh_ino)); 276 if (err < 0) 277 goto failed_read; 278 279 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 280 inode->i_size = le32_to_cpu(sqsh_ino->symlink_size); 281 inode->i_op = &squashfs_symlink_inode_ops; 282 inode_nohighmem(inode); 283 inode->i_data.a_ops = &squashfs_symlink_aops; 284 inode->i_mode |= S_IFLNK; 285 squashfs_i(inode)->start = block; 286 squashfs_i(inode)->offset = offset; 287 288 if (type == SQUASHFS_LSYMLINK_TYPE) { 289 __le32 xattr; 290 291 err = squashfs_read_metadata(sb, NULL, &block, 292 &offset, inode->i_size); 293 if (err < 0) 294 goto failed_read; 295 err = squashfs_read_metadata(sb, &xattr, &block, 296 &offset, sizeof(xattr)); 297 if (err < 0) 298 goto failed_read; 299 xattr_id = le32_to_cpu(xattr); 300 } 301 302 TRACE("Symbolic link inode %x:%x, start_block %llx, offset " 303 "%x\n", SQUASHFS_INODE_BLK(ino), offset, 304 block, offset); 305 break; 306 } 307 case SQUASHFS_BLKDEV_TYPE: 308 case SQUASHFS_CHRDEV_TYPE: { 309 struct squashfs_dev_inode *sqsh_ino = &squashfs_ino.dev; 310 unsigned int rdev; 311 312 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 313 sizeof(*sqsh_ino)); 314 if (err < 0) 315 goto failed_read; 316 317 if (type == SQUASHFS_CHRDEV_TYPE) 318 inode->i_mode |= S_IFCHR; 319 else 320 inode->i_mode |= S_IFBLK; 321 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 322 rdev = le32_to_cpu(sqsh_ino->rdev); 323 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev)); 324 325 TRACE("Device inode %x:%x, rdev %x\n", 326 SQUASHFS_INODE_BLK(ino), offset, rdev); 327 break; 328 } 329 case SQUASHFS_LBLKDEV_TYPE: 330 case SQUASHFS_LCHRDEV_TYPE: { 331 struct squashfs_ldev_inode *sqsh_ino = &squashfs_ino.ldev; 332 unsigned int rdev; 333 334 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 335 sizeof(*sqsh_ino)); 336 if (err < 0) 337 goto failed_read; 338 339 if (type == SQUASHFS_LCHRDEV_TYPE) 340 inode->i_mode |= S_IFCHR; 341 else 342 inode->i_mode |= S_IFBLK; 343 xattr_id = le32_to_cpu(sqsh_ino->xattr); 344 inode->i_op = &squashfs_inode_ops; 345 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 346 rdev = le32_to_cpu(sqsh_ino->rdev); 347 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev)); 348 349 TRACE("Device inode %x:%x, rdev %x\n", 350 SQUASHFS_INODE_BLK(ino), offset, rdev); 351 break; 352 } 353 case SQUASHFS_FIFO_TYPE: 354 case SQUASHFS_SOCKET_TYPE: { 355 struct squashfs_ipc_inode *sqsh_ino = &squashfs_ino.ipc; 356 357 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 358 sizeof(*sqsh_ino)); 359 if (err < 0) 360 goto failed_read; 361 362 if (type == SQUASHFS_FIFO_TYPE) 363 inode->i_mode |= S_IFIFO; 364 else 365 inode->i_mode |= S_IFSOCK; 366 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 367 init_special_inode(inode, inode->i_mode, 0); 368 break; 369 } 370 case SQUASHFS_LFIFO_TYPE: 371 case SQUASHFS_LSOCKET_TYPE: { 372 struct squashfs_lipc_inode *sqsh_ino = &squashfs_ino.lipc; 373 374 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, 375 sizeof(*sqsh_ino)); 376 if (err < 0) 377 goto failed_read; 378 379 if (type == SQUASHFS_LFIFO_TYPE) 380 inode->i_mode |= S_IFIFO; 381 else 382 inode->i_mode |= S_IFSOCK; 383 xattr_id = le32_to_cpu(sqsh_ino->xattr); 384 inode->i_op = &squashfs_inode_ops; 385 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 386 init_special_inode(inode, inode->i_mode, 0); 387 break; 388 } 389 default: 390 ERROR("Unknown inode type %d in squashfs_iget!\n", type); 391 return -EINVAL; 392 } 393 394 if (xattr_id != SQUASHFS_INVALID_XATTR && msblk->xattr_id_table) { 395 err = squashfs_xattr_lookup(sb, xattr_id, 396 &squashfs_i(inode)->xattr_count, 397 &squashfs_i(inode)->xattr_size, 398 &squashfs_i(inode)->xattr); 399 if (err < 0) 400 goto failed_read; 401 inode->i_blocks += ((squashfs_i(inode)->xattr_size - 1) >> 9) 402 + 1; 403 } else 404 squashfs_i(inode)->xattr_count = 0; 405 406 return 0; 407 408 failed_read: 409 ERROR("Unable to read inode 0x%llx\n", ino); 410 return err; 411 } 412 413 414 const struct inode_operations squashfs_inode_ops = { 415 .listxattr = squashfs_listxattr 416 }; 417 418