1 /* 2 * Compressed rom filesystem for Linux. 3 * 4 * Copyright (C) 1999 Linus Torvalds. 5 * 6 * This file is released under the GPL. 7 */ 8 9 /* 10 * These are the VFS interfaces to the compressed rom filesystem. 11 * The actual compression is based on zlib, see the other files. 12 */ 13 14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 16 #include <linux/module.h> 17 #include <linux/fs.h> 18 #include <linux/file.h> 19 #include <linux/pagemap.h> 20 #include <linux/pfn_t.h> 21 #include <linux/ramfs.h> 22 #include <linux/init.h> 23 #include <linux/string.h> 24 #include <linux/blkdev.h> 25 #include <linux/mtd/mtd.h> 26 #include <linux/mtd/super.h> 27 #include <linux/fs_context.h> 28 #include <linux/slab.h> 29 #include <linux/vfs.h> 30 #include <linux/mutex.h> 31 #include <uapi/linux/cramfs_fs.h> 32 #include <linux/uaccess.h> 33 34 #include "internal.h" 35 36 /* 37 * cramfs super-block data in memory 38 */ 39 struct cramfs_sb_info { 40 unsigned long magic; 41 unsigned long size; 42 unsigned long blocks; 43 unsigned long files; 44 unsigned long flags; 45 void *linear_virt_addr; 46 resource_size_t linear_phys_addr; 47 size_t mtd_point_size; 48 }; 49 50 static inline struct cramfs_sb_info *CRAMFS_SB(struct super_block *sb) 51 { 52 return sb->s_fs_info; 53 } 54 55 static const struct super_operations cramfs_ops; 56 static const struct inode_operations cramfs_dir_inode_operations; 57 static const struct file_operations cramfs_directory_operations; 58 static const struct file_operations cramfs_physmem_fops; 59 static const struct address_space_operations cramfs_aops; 60 61 static DEFINE_MUTEX(read_mutex); 62 63 64 /* These macros may change in future, to provide better st_ino semantics. */ 65 #define OFFSET(x) ((x)->i_ino) 66 67 static unsigned long cramino(const struct cramfs_inode *cino, unsigned int offset) 68 { 69 if (!cino->offset) 70 return offset + 1; 71 if (!cino->size) 72 return offset + 1; 73 74 /* 75 * The file mode test fixes buggy mkcramfs implementations where 76 * cramfs_inode->offset is set to a non zero value for entries 77 * which did not contain data, like devices node and fifos. 78 */ 79 switch (cino->mode & S_IFMT) { 80 case S_IFREG: 81 case S_IFDIR: 82 case S_IFLNK: 83 return cino->offset << 2; 84 default: 85 break; 86 } 87 return offset + 1; 88 } 89 90 static struct inode *get_cramfs_inode(struct super_block *sb, 91 const struct cramfs_inode *cramfs_inode, unsigned int offset) 92 { 93 struct inode *inode; 94 static struct timespec64 zerotime; 95 96 inode = iget_locked(sb, cramino(cramfs_inode, offset)); 97 if (!inode) 98 return ERR_PTR(-ENOMEM); 99 if (!(inode->i_state & I_NEW)) 100 return inode; 101 102 switch (cramfs_inode->mode & S_IFMT) { 103 case S_IFREG: 104 inode->i_fop = &generic_ro_fops; 105 inode->i_data.a_ops = &cramfs_aops; 106 if (IS_ENABLED(CONFIG_CRAMFS_MTD) && 107 CRAMFS_SB(sb)->flags & CRAMFS_FLAG_EXT_BLOCK_POINTERS && 108 CRAMFS_SB(sb)->linear_phys_addr) 109 inode->i_fop = &cramfs_physmem_fops; 110 break; 111 case S_IFDIR: 112 inode->i_op = &cramfs_dir_inode_operations; 113 inode->i_fop = &cramfs_directory_operations; 114 break; 115 case S_IFLNK: 116 inode->i_op = &page_symlink_inode_operations; 117 inode_nohighmem(inode); 118 inode->i_data.a_ops = &cramfs_aops; 119 break; 120 default: 121 init_special_inode(inode, cramfs_inode->mode, 122 old_decode_dev(cramfs_inode->size)); 123 } 124 125 inode->i_mode = cramfs_inode->mode; 126 i_uid_write(inode, cramfs_inode->uid); 127 i_gid_write(inode, cramfs_inode->gid); 128 129 /* if the lower 2 bits are zero, the inode contains data */ 130 if (!(inode->i_ino & 3)) { 131 inode->i_size = cramfs_inode->size; 132 inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1; 133 } 134 135 /* Struct copy intentional */ 136 inode->i_mtime = inode->i_atime = inode_set_ctime_to_ts(inode, 137 zerotime); 138 /* inode->i_nlink is left 1 - arguably wrong for directories, 139 but it's the best we can do without reading the directory 140 contents. 1 yields the right result in GNU find, even 141 without -noleaf option. */ 142 143 unlock_new_inode(inode); 144 145 return inode; 146 } 147 148 /* 149 * We have our own block cache: don't fill up the buffer cache 150 * with the rom-image, because the way the filesystem is set 151 * up the accesses should be fairly regular and cached in the 152 * page cache and dentry tree anyway.. 153 * 154 * This also acts as a way to guarantee contiguous areas of up to 155 * BLKS_PER_BUF*PAGE_SIZE, so that the caller doesn't need to 156 * worry about end-of-buffer issues even when decompressing a full 157 * page cache. 158 * 159 * Note: This is all optimized away at compile time when 160 * CONFIG_CRAMFS_BLOCKDEV=n. 161 */ 162 #define READ_BUFFERS (2) 163 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */ 164 #define NEXT_BUFFER(_ix) ((_ix) ^ 1) 165 166 /* 167 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed" 168 * data that takes up more space than the original and with unlucky 169 * alignment. 170 */ 171 #define BLKS_PER_BUF_SHIFT (2) 172 #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT) 173 #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_SIZE) 174 175 static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE]; 176 static unsigned buffer_blocknr[READ_BUFFERS]; 177 static struct super_block *buffer_dev[READ_BUFFERS]; 178 static int next_buffer; 179 180 /* 181 * Populate our block cache and return a pointer to it. 182 */ 183 static void *cramfs_blkdev_read(struct super_block *sb, unsigned int offset, 184 unsigned int len) 185 { 186 struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; 187 struct file_ra_state ra = {}; 188 struct page *pages[BLKS_PER_BUF]; 189 unsigned i, blocknr, buffer; 190 unsigned long devsize; 191 char *data; 192 193 if (!len) 194 return NULL; 195 blocknr = offset >> PAGE_SHIFT; 196 offset &= PAGE_SIZE - 1; 197 198 /* Check if an existing buffer already has the data.. */ 199 for (i = 0; i < READ_BUFFERS; i++) { 200 unsigned int blk_offset; 201 202 if (buffer_dev[i] != sb) 203 continue; 204 if (blocknr < buffer_blocknr[i]) 205 continue; 206 blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_SHIFT; 207 blk_offset += offset; 208 if (blk_offset > BUFFER_SIZE || 209 blk_offset + len > BUFFER_SIZE) 210 continue; 211 return read_buffers[i] + blk_offset; 212 } 213 214 devsize = bdev_nr_bytes(sb->s_bdev) >> PAGE_SHIFT; 215 216 /* Ok, read in BLKS_PER_BUF pages completely first. */ 217 file_ra_state_init(&ra, mapping); 218 page_cache_sync_readahead(mapping, &ra, NULL, blocknr, BLKS_PER_BUF); 219 220 for (i = 0; i < BLKS_PER_BUF; i++) { 221 struct page *page = NULL; 222 223 if (blocknr + i < devsize) { 224 page = read_mapping_page(mapping, blocknr + i, NULL); 225 /* synchronous error? */ 226 if (IS_ERR(page)) 227 page = NULL; 228 } 229 pages[i] = page; 230 } 231 232 buffer = next_buffer; 233 next_buffer = NEXT_BUFFER(buffer); 234 buffer_blocknr[buffer] = blocknr; 235 buffer_dev[buffer] = sb; 236 237 data = read_buffers[buffer]; 238 for (i = 0; i < BLKS_PER_BUF; i++) { 239 struct page *page = pages[i]; 240 241 if (page) { 242 memcpy_from_page(data, page, 0, PAGE_SIZE); 243 put_page(page); 244 } else 245 memset(data, 0, PAGE_SIZE); 246 data += PAGE_SIZE; 247 } 248 return read_buffers[buffer] + offset; 249 } 250 251 /* 252 * Return a pointer to the linearly addressed cramfs image in memory. 253 */ 254 static void *cramfs_direct_read(struct super_block *sb, unsigned int offset, 255 unsigned int len) 256 { 257 struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 258 259 if (!len) 260 return NULL; 261 if (len > sbi->size || offset > sbi->size - len) 262 return page_address(ZERO_PAGE(0)); 263 return sbi->linear_virt_addr + offset; 264 } 265 266 /* 267 * Returns a pointer to a buffer containing at least LEN bytes of 268 * filesystem starting at byte offset OFFSET into the filesystem. 269 */ 270 static void *cramfs_read(struct super_block *sb, unsigned int offset, 271 unsigned int len) 272 { 273 struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 274 275 if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sbi->linear_virt_addr) 276 return cramfs_direct_read(sb, offset, len); 277 else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) 278 return cramfs_blkdev_read(sb, offset, len); 279 else 280 return NULL; 281 } 282 283 /* 284 * For a mapping to be possible, we need a range of uncompressed and 285 * contiguous blocks. Return the offset for the first block and number of 286 * valid blocks for which that is true, or zero otherwise. 287 */ 288 static u32 cramfs_get_block_range(struct inode *inode, u32 pgoff, u32 *pages) 289 { 290 struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb); 291 int i; 292 u32 *blockptrs, first_block_addr; 293 294 /* 295 * We can dereference memory directly here as this code may be 296 * reached only when there is a direct filesystem image mapping 297 * available in memory. 298 */ 299 blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode) + pgoff * 4); 300 first_block_addr = blockptrs[0] & ~CRAMFS_BLK_FLAGS; 301 i = 0; 302 do { 303 u32 block_off = i * (PAGE_SIZE >> CRAMFS_BLK_DIRECT_PTR_SHIFT); 304 u32 expect = (first_block_addr + block_off) | 305 CRAMFS_BLK_FLAG_DIRECT_PTR | 306 CRAMFS_BLK_FLAG_UNCOMPRESSED; 307 if (blockptrs[i] != expect) { 308 pr_debug("range: block %d/%d got %#x expects %#x\n", 309 pgoff+i, pgoff + *pages - 1, 310 blockptrs[i], expect); 311 if (i == 0) 312 return 0; 313 break; 314 } 315 } while (++i < *pages); 316 317 *pages = i; 318 return first_block_addr << CRAMFS_BLK_DIRECT_PTR_SHIFT; 319 } 320 321 #ifdef CONFIG_MMU 322 323 /* 324 * Return true if the last page of a file in the filesystem image contains 325 * some other data that doesn't belong to that file. It is assumed that the 326 * last block is CRAMFS_BLK_FLAG_DIRECT_PTR | CRAMFS_BLK_FLAG_UNCOMPRESSED 327 * (verified by cramfs_get_block_range() and directly accessible in memory. 328 */ 329 static bool cramfs_last_page_is_shared(struct inode *inode) 330 { 331 struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb); 332 u32 partial, last_page, blockaddr, *blockptrs; 333 char *tail_data; 334 335 partial = offset_in_page(inode->i_size); 336 if (!partial) 337 return false; 338 last_page = inode->i_size >> PAGE_SHIFT; 339 blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode)); 340 blockaddr = blockptrs[last_page] & ~CRAMFS_BLK_FLAGS; 341 blockaddr <<= CRAMFS_BLK_DIRECT_PTR_SHIFT; 342 tail_data = sbi->linear_virt_addr + blockaddr + partial; 343 return memchr_inv(tail_data, 0, PAGE_SIZE - partial) ? true : false; 344 } 345 346 static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma) 347 { 348 struct inode *inode = file_inode(file); 349 struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb); 350 unsigned int pages, max_pages, offset; 351 unsigned long address, pgoff = vma->vm_pgoff; 352 char *bailout_reason; 353 int ret; 354 355 ret = generic_file_readonly_mmap(file, vma); 356 if (ret) 357 return ret; 358 359 /* 360 * Now try to pre-populate ptes for this vma with a direct 361 * mapping avoiding memory allocation when possible. 362 */ 363 364 /* Could COW work here? */ 365 bailout_reason = "vma is writable"; 366 if (vma->vm_flags & VM_WRITE) 367 goto bailout; 368 369 max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; 370 bailout_reason = "beyond file limit"; 371 if (pgoff >= max_pages) 372 goto bailout; 373 pages = min(vma_pages(vma), max_pages - pgoff); 374 375 offset = cramfs_get_block_range(inode, pgoff, &pages); 376 bailout_reason = "unsuitable block layout"; 377 if (!offset) 378 goto bailout; 379 address = sbi->linear_phys_addr + offset; 380 bailout_reason = "data is not page aligned"; 381 if (!PAGE_ALIGNED(address)) 382 goto bailout; 383 384 /* Don't map the last page if it contains some other data */ 385 if (pgoff + pages == max_pages && cramfs_last_page_is_shared(inode)) { 386 pr_debug("mmap: %pD: last page is shared\n", file); 387 pages--; 388 } 389 390 if (!pages) { 391 bailout_reason = "no suitable block remaining"; 392 goto bailout; 393 } 394 395 if (pages == vma_pages(vma)) { 396 /* 397 * The entire vma is mappable. remap_pfn_range() will 398 * make it distinguishable from a non-direct mapping 399 * in /proc/<pid>/maps by substituting the file offset 400 * with the actual physical address. 401 */ 402 ret = remap_pfn_range(vma, vma->vm_start, address >> PAGE_SHIFT, 403 pages * PAGE_SIZE, vma->vm_page_prot); 404 } else { 405 /* 406 * Let's create a mixed map if we can't map it all. 407 * The normal paging machinery will take care of the 408 * unpopulated ptes via cramfs_read_folio(). 409 */ 410 int i; 411 vm_flags_set(vma, VM_MIXEDMAP); 412 for (i = 0; i < pages && !ret; i++) { 413 vm_fault_t vmf; 414 unsigned long off = i * PAGE_SIZE; 415 pfn_t pfn = phys_to_pfn_t(address + off, PFN_DEV); 416 vmf = vmf_insert_mixed(vma, vma->vm_start + off, pfn); 417 if (vmf & VM_FAULT_ERROR) 418 ret = vm_fault_to_errno(vmf, 0); 419 } 420 } 421 422 if (!ret) 423 pr_debug("mapped %pD[%lu] at 0x%08lx (%u/%lu pages) " 424 "to vma 0x%08lx, page_prot 0x%llx\n", file, 425 pgoff, address, pages, vma_pages(vma), vma->vm_start, 426 (unsigned long long)pgprot_val(vma->vm_page_prot)); 427 return ret; 428 429 bailout: 430 pr_debug("%pD[%lu]: direct mmap impossible: %s\n", 431 file, pgoff, bailout_reason); 432 /* Didn't manage any direct map, but normal paging is still possible */ 433 return 0; 434 } 435 436 #else /* CONFIG_MMU */ 437 438 static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma) 439 { 440 return is_nommu_shared_mapping(vma->vm_flags) ? 0 : -ENOSYS; 441 } 442 443 static unsigned long cramfs_physmem_get_unmapped_area(struct file *file, 444 unsigned long addr, unsigned long len, 445 unsigned long pgoff, unsigned long flags) 446 { 447 struct inode *inode = file_inode(file); 448 struct super_block *sb = inode->i_sb; 449 struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 450 unsigned int pages, block_pages, max_pages, offset; 451 452 pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; 453 max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; 454 if (pgoff >= max_pages || pages > max_pages - pgoff) 455 return -EINVAL; 456 block_pages = pages; 457 offset = cramfs_get_block_range(inode, pgoff, &block_pages); 458 if (!offset || block_pages != pages) 459 return -ENOSYS; 460 addr = sbi->linear_phys_addr + offset; 461 pr_debug("get_unmapped for %pD ofs %#lx siz %lu at 0x%08lx\n", 462 file, pgoff*PAGE_SIZE, len, addr); 463 return addr; 464 } 465 466 static unsigned int cramfs_physmem_mmap_capabilities(struct file *file) 467 { 468 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | 469 NOMMU_MAP_READ | NOMMU_MAP_EXEC; 470 } 471 472 #endif /* CONFIG_MMU */ 473 474 static const struct file_operations cramfs_physmem_fops = { 475 .llseek = generic_file_llseek, 476 .read_iter = generic_file_read_iter, 477 .splice_read = filemap_splice_read, 478 .mmap = cramfs_physmem_mmap, 479 #ifndef CONFIG_MMU 480 .get_unmapped_area = cramfs_physmem_get_unmapped_area, 481 .mmap_capabilities = cramfs_physmem_mmap_capabilities, 482 #endif 483 }; 484 485 static void cramfs_kill_sb(struct super_block *sb) 486 { 487 struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 488 489 generic_shutdown_super(sb); 490 491 if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sb->s_mtd) { 492 if (sbi && sbi->mtd_point_size) 493 mtd_unpoint(sb->s_mtd, 0, sbi->mtd_point_size); 494 put_mtd_device(sb->s_mtd); 495 sb->s_mtd = NULL; 496 } else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV) && sb->s_bdev) { 497 sync_blockdev(sb->s_bdev); 498 bdev_release(sb->s_bdev_handle); 499 } 500 kfree(sbi); 501 } 502 503 static int cramfs_reconfigure(struct fs_context *fc) 504 { 505 sync_filesystem(fc->root->d_sb); 506 fc->sb_flags |= SB_RDONLY; 507 return 0; 508 } 509 510 static int cramfs_read_super(struct super_block *sb, struct fs_context *fc, 511 struct cramfs_super *super) 512 { 513 struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 514 unsigned long root_offset; 515 bool silent = fc->sb_flags & SB_SILENT; 516 517 /* We don't know the real size yet */ 518 sbi->size = PAGE_SIZE; 519 520 /* Read the first block and get the superblock from it */ 521 mutex_lock(&read_mutex); 522 memcpy(super, cramfs_read(sb, 0, sizeof(*super)), sizeof(*super)); 523 mutex_unlock(&read_mutex); 524 525 /* Do sanity checks on the superblock */ 526 if (super->magic != CRAMFS_MAGIC) { 527 /* check for wrong endianness */ 528 if (super->magic == CRAMFS_MAGIC_WEND) { 529 if (!silent) 530 errorfc(fc, "wrong endianness"); 531 return -EINVAL; 532 } 533 534 /* check at 512 byte offset */ 535 mutex_lock(&read_mutex); 536 memcpy(super, 537 cramfs_read(sb, 512, sizeof(*super)), 538 sizeof(*super)); 539 mutex_unlock(&read_mutex); 540 if (super->magic != CRAMFS_MAGIC) { 541 if (super->magic == CRAMFS_MAGIC_WEND && !silent) 542 errorfc(fc, "wrong endianness"); 543 else if (!silent) 544 errorfc(fc, "wrong magic"); 545 return -EINVAL; 546 } 547 } 548 549 /* get feature flags first */ 550 if (super->flags & ~CRAMFS_SUPPORTED_FLAGS) { 551 errorfc(fc, "unsupported filesystem features"); 552 return -EINVAL; 553 } 554 555 /* Check that the root inode is in a sane state */ 556 if (!S_ISDIR(super->root.mode)) { 557 errorfc(fc, "root is not a directory"); 558 return -EINVAL; 559 } 560 /* correct strange, hard-coded permissions of mkcramfs */ 561 super->root.mode |= 0555; 562 563 root_offset = super->root.offset << 2; 564 if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) { 565 sbi->size = super->size; 566 sbi->blocks = super->fsid.blocks; 567 sbi->files = super->fsid.files; 568 } else { 569 sbi->size = 1<<28; 570 sbi->blocks = 0; 571 sbi->files = 0; 572 } 573 sbi->magic = super->magic; 574 sbi->flags = super->flags; 575 if (root_offset == 0) 576 infofc(fc, "empty filesystem"); 577 else if (!(super->flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) && 578 ((root_offset != sizeof(struct cramfs_super)) && 579 (root_offset != 512 + sizeof(struct cramfs_super)))) 580 { 581 errorfc(fc, "bad root offset %lu", root_offset); 582 return -EINVAL; 583 } 584 585 return 0; 586 } 587 588 static int cramfs_finalize_super(struct super_block *sb, 589 struct cramfs_inode *cramfs_root) 590 { 591 struct inode *root; 592 593 /* Set it all up.. */ 594 sb->s_flags |= SB_RDONLY; 595 sb->s_time_min = 0; 596 sb->s_time_max = 0; 597 sb->s_op = &cramfs_ops; 598 root = get_cramfs_inode(sb, cramfs_root, 0); 599 if (IS_ERR(root)) 600 return PTR_ERR(root); 601 sb->s_root = d_make_root(root); 602 if (!sb->s_root) 603 return -ENOMEM; 604 return 0; 605 } 606 607 static int cramfs_blkdev_fill_super(struct super_block *sb, struct fs_context *fc) 608 { 609 struct cramfs_sb_info *sbi; 610 struct cramfs_super super; 611 int i, err; 612 613 sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL); 614 if (!sbi) 615 return -ENOMEM; 616 sb->s_fs_info = sbi; 617 618 /* Invalidate the read buffers on mount: think disk change.. */ 619 for (i = 0; i < READ_BUFFERS; i++) 620 buffer_blocknr[i] = -1; 621 622 err = cramfs_read_super(sb, fc, &super); 623 if (err) 624 return err; 625 return cramfs_finalize_super(sb, &super.root); 626 } 627 628 static int cramfs_mtd_fill_super(struct super_block *sb, struct fs_context *fc) 629 { 630 struct cramfs_sb_info *sbi; 631 struct cramfs_super super; 632 int err; 633 634 sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL); 635 if (!sbi) 636 return -ENOMEM; 637 sb->s_fs_info = sbi; 638 639 /* Map only one page for now. Will remap it when fs size is known. */ 640 err = mtd_point(sb->s_mtd, 0, PAGE_SIZE, &sbi->mtd_point_size, 641 &sbi->linear_virt_addr, &sbi->linear_phys_addr); 642 if (err || sbi->mtd_point_size != PAGE_SIZE) { 643 pr_err("unable to get direct memory access to mtd:%s\n", 644 sb->s_mtd->name); 645 return err ? : -ENODATA; 646 } 647 648 pr_info("checking physical address %pap for linear cramfs image\n", 649 &sbi->linear_phys_addr); 650 err = cramfs_read_super(sb, fc, &super); 651 if (err) 652 return err; 653 654 /* Remap the whole filesystem now */ 655 pr_info("linear cramfs image on mtd:%s appears to be %lu KB in size\n", 656 sb->s_mtd->name, sbi->size/1024); 657 mtd_unpoint(sb->s_mtd, 0, PAGE_SIZE); 658 err = mtd_point(sb->s_mtd, 0, sbi->size, &sbi->mtd_point_size, 659 &sbi->linear_virt_addr, &sbi->linear_phys_addr); 660 if (err || sbi->mtd_point_size != sbi->size) { 661 pr_err("unable to get direct memory access to mtd:%s\n", 662 sb->s_mtd->name); 663 return err ? : -ENODATA; 664 } 665 666 return cramfs_finalize_super(sb, &super.root); 667 } 668 669 static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf) 670 { 671 struct super_block *sb = dentry->d_sb; 672 u64 id = 0; 673 674 if (sb->s_bdev) 675 id = huge_encode_dev(sb->s_bdev->bd_dev); 676 else if (sb->s_dev) 677 id = huge_encode_dev(sb->s_dev); 678 679 buf->f_type = CRAMFS_MAGIC; 680 buf->f_bsize = PAGE_SIZE; 681 buf->f_blocks = CRAMFS_SB(sb)->blocks; 682 buf->f_bfree = 0; 683 buf->f_bavail = 0; 684 buf->f_files = CRAMFS_SB(sb)->files; 685 buf->f_ffree = 0; 686 buf->f_fsid = u64_to_fsid(id); 687 buf->f_namelen = CRAMFS_MAXPATHLEN; 688 return 0; 689 } 690 691 /* 692 * Read a cramfs directory entry. 693 */ 694 static int cramfs_readdir(struct file *file, struct dir_context *ctx) 695 { 696 struct inode *inode = file_inode(file); 697 struct super_block *sb = inode->i_sb; 698 char *buf; 699 unsigned int offset; 700 701 /* Offset within the thing. */ 702 if (ctx->pos >= inode->i_size) 703 return 0; 704 offset = ctx->pos; 705 /* Directory entries are always 4-byte aligned */ 706 if (offset & 3) 707 return -EINVAL; 708 709 buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL); 710 if (!buf) 711 return -ENOMEM; 712 713 while (offset < inode->i_size) { 714 struct cramfs_inode *de; 715 unsigned long nextoffset; 716 char *name; 717 ino_t ino; 718 umode_t mode; 719 int namelen; 720 721 mutex_lock(&read_mutex); 722 de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN); 723 name = (char *)(de+1); 724 725 /* 726 * Namelengths on disk are shifted by two 727 * and the name padded out to 4-byte boundaries 728 * with zeroes. 729 */ 730 namelen = de->namelen << 2; 731 memcpy(buf, name, namelen); 732 ino = cramino(de, OFFSET(inode) + offset); 733 mode = de->mode; 734 mutex_unlock(&read_mutex); 735 nextoffset = offset + sizeof(*de) + namelen; 736 for (;;) { 737 if (!namelen) { 738 kfree(buf); 739 return -EIO; 740 } 741 if (buf[namelen-1]) 742 break; 743 namelen--; 744 } 745 if (!dir_emit(ctx, buf, namelen, ino, mode >> 12)) 746 break; 747 748 ctx->pos = offset = nextoffset; 749 } 750 kfree(buf); 751 return 0; 752 } 753 754 /* 755 * Lookup and fill in the inode data.. 756 */ 757 static struct dentry *cramfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 758 { 759 unsigned int offset = 0; 760 struct inode *inode = NULL; 761 int sorted; 762 763 mutex_lock(&read_mutex); 764 sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS; 765 while (offset < dir->i_size) { 766 struct cramfs_inode *de; 767 char *name; 768 int namelen, retval; 769 int dir_off = OFFSET(dir) + offset; 770 771 de = cramfs_read(dir->i_sb, dir_off, sizeof(*de)+CRAMFS_MAXPATHLEN); 772 name = (char *)(de+1); 773 774 /* Try to take advantage of sorted directories */ 775 if (sorted && (dentry->d_name.name[0] < name[0])) 776 break; 777 778 namelen = de->namelen << 2; 779 offset += sizeof(*de) + namelen; 780 781 /* Quick check that the name is roughly the right length */ 782 if (((dentry->d_name.len + 3) & ~3) != namelen) 783 continue; 784 785 for (;;) { 786 if (!namelen) { 787 inode = ERR_PTR(-EIO); 788 goto out; 789 } 790 if (name[namelen-1]) 791 break; 792 namelen--; 793 } 794 if (namelen != dentry->d_name.len) 795 continue; 796 retval = memcmp(dentry->d_name.name, name, namelen); 797 if (retval > 0) 798 continue; 799 if (!retval) { 800 inode = get_cramfs_inode(dir->i_sb, de, dir_off); 801 break; 802 } 803 /* else (retval < 0) */ 804 if (sorted) 805 break; 806 } 807 out: 808 mutex_unlock(&read_mutex); 809 return d_splice_alias(inode, dentry); 810 } 811 812 static int cramfs_read_folio(struct file *file, struct folio *folio) 813 { 814 struct page *page = &folio->page; 815 struct inode *inode = page->mapping->host; 816 u32 maxblock; 817 int bytes_filled; 818 void *pgdata; 819 820 maxblock = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; 821 bytes_filled = 0; 822 pgdata = kmap_local_page(page); 823 824 if (page->index < maxblock) { 825 struct super_block *sb = inode->i_sb; 826 u32 blkptr_offset = OFFSET(inode) + page->index * 4; 827 u32 block_ptr, block_start, block_len; 828 bool uncompressed, direct; 829 830 mutex_lock(&read_mutex); 831 block_ptr = *(u32 *) cramfs_read(sb, blkptr_offset, 4); 832 uncompressed = (block_ptr & CRAMFS_BLK_FLAG_UNCOMPRESSED); 833 direct = (block_ptr & CRAMFS_BLK_FLAG_DIRECT_PTR); 834 block_ptr &= ~CRAMFS_BLK_FLAGS; 835 836 if (direct) { 837 /* 838 * The block pointer is an absolute start pointer, 839 * shifted by 2 bits. The size is included in the 840 * first 2 bytes of the data block when compressed, 841 * or PAGE_SIZE otherwise. 842 */ 843 block_start = block_ptr << CRAMFS_BLK_DIRECT_PTR_SHIFT; 844 if (uncompressed) { 845 block_len = PAGE_SIZE; 846 /* if last block: cap to file length */ 847 if (page->index == maxblock - 1) 848 block_len = 849 offset_in_page(inode->i_size); 850 } else { 851 block_len = *(u16 *) 852 cramfs_read(sb, block_start, 2); 853 block_start += 2; 854 } 855 } else { 856 /* 857 * The block pointer indicates one past the end of 858 * the current block (start of next block). If this 859 * is the first block then it starts where the block 860 * pointer table ends, otherwise its start comes 861 * from the previous block's pointer. 862 */ 863 block_start = OFFSET(inode) + maxblock * 4; 864 if (page->index) 865 block_start = *(u32 *) 866 cramfs_read(sb, blkptr_offset - 4, 4); 867 /* Beware... previous ptr might be a direct ptr */ 868 if (unlikely(block_start & CRAMFS_BLK_FLAG_DIRECT_PTR)) { 869 /* See comments on earlier code. */ 870 u32 prev_start = block_start; 871 block_start = prev_start & ~CRAMFS_BLK_FLAGS; 872 block_start <<= CRAMFS_BLK_DIRECT_PTR_SHIFT; 873 if (prev_start & CRAMFS_BLK_FLAG_UNCOMPRESSED) { 874 block_start += PAGE_SIZE; 875 } else { 876 block_len = *(u16 *) 877 cramfs_read(sb, block_start, 2); 878 block_start += 2 + block_len; 879 } 880 } 881 block_start &= ~CRAMFS_BLK_FLAGS; 882 block_len = block_ptr - block_start; 883 } 884 885 if (block_len == 0) 886 ; /* hole */ 887 else if (unlikely(block_len > 2*PAGE_SIZE || 888 (uncompressed && block_len > PAGE_SIZE))) { 889 mutex_unlock(&read_mutex); 890 pr_err("bad data blocksize %u\n", block_len); 891 goto err; 892 } else if (uncompressed) { 893 memcpy(pgdata, 894 cramfs_read(sb, block_start, block_len), 895 block_len); 896 bytes_filled = block_len; 897 } else { 898 bytes_filled = cramfs_uncompress_block(pgdata, 899 PAGE_SIZE, 900 cramfs_read(sb, block_start, block_len), 901 block_len); 902 } 903 mutex_unlock(&read_mutex); 904 if (unlikely(bytes_filled < 0)) 905 goto err; 906 } 907 908 memset(pgdata + bytes_filled, 0, PAGE_SIZE - bytes_filled); 909 flush_dcache_page(page); 910 kunmap_local(pgdata); 911 SetPageUptodate(page); 912 unlock_page(page); 913 return 0; 914 915 err: 916 kunmap_local(pgdata); 917 ClearPageUptodate(page); 918 SetPageError(page); 919 unlock_page(page); 920 return 0; 921 } 922 923 static const struct address_space_operations cramfs_aops = { 924 .read_folio = cramfs_read_folio 925 }; 926 927 /* 928 * Our operations: 929 */ 930 931 /* 932 * A directory can only readdir 933 */ 934 static const struct file_operations cramfs_directory_operations = { 935 .llseek = generic_file_llseek, 936 .read = generic_read_dir, 937 .iterate_shared = cramfs_readdir, 938 }; 939 940 static const struct inode_operations cramfs_dir_inode_operations = { 941 .lookup = cramfs_lookup, 942 }; 943 944 static const struct super_operations cramfs_ops = { 945 .statfs = cramfs_statfs, 946 }; 947 948 static int cramfs_get_tree(struct fs_context *fc) 949 { 950 int ret = -ENOPROTOOPT; 951 952 if (IS_ENABLED(CONFIG_CRAMFS_MTD)) { 953 ret = get_tree_mtd(fc, cramfs_mtd_fill_super); 954 if (!ret) 955 return 0; 956 } 957 if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) 958 ret = get_tree_bdev(fc, cramfs_blkdev_fill_super); 959 return ret; 960 } 961 962 static const struct fs_context_operations cramfs_context_ops = { 963 .get_tree = cramfs_get_tree, 964 .reconfigure = cramfs_reconfigure, 965 }; 966 967 /* 968 * Set up the filesystem mount context. 969 */ 970 static int cramfs_init_fs_context(struct fs_context *fc) 971 { 972 fc->ops = &cramfs_context_ops; 973 return 0; 974 } 975 976 static struct file_system_type cramfs_fs_type = { 977 .owner = THIS_MODULE, 978 .name = "cramfs", 979 .init_fs_context = cramfs_init_fs_context, 980 .kill_sb = cramfs_kill_sb, 981 .fs_flags = FS_REQUIRES_DEV, 982 }; 983 MODULE_ALIAS_FS("cramfs"); 984 985 static int __init init_cramfs_fs(void) 986 { 987 int rv; 988 989 rv = cramfs_uncompress_init(); 990 if (rv < 0) 991 return rv; 992 rv = register_filesystem(&cramfs_fs_type); 993 if (rv < 0) 994 cramfs_uncompress_exit(); 995 return rv; 996 } 997 998 static void __exit exit_cramfs_fs(void) 999 { 1000 cramfs_uncompress_exit(); 1001 unregister_filesystem(&cramfs_fs_type); 1002 } 1003 1004 module_init(init_cramfs_fs) 1005 module_exit(exit_cramfs_fs) 1006 MODULE_LICENSE("GPL"); 1007