11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Compressed rom filesystem for Linux. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1999 Linus Torvalds. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This file is released under the GPL. 71da177e4SLinus Torvalds */ 81da177e4SLinus Torvalds 91da177e4SLinus Torvalds /* 101da177e4SLinus Torvalds * These are the VFS interfaces to the compressed rom filesystem. 111da177e4SLinus Torvalds * The actual compression is based on zlib, see the other files. 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds 144f21e1eaSFabian Frederick #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 154f21e1eaSFabian Frederick 161da177e4SLinus Torvalds #include <linux/module.h> 171da177e4SLinus Torvalds #include <linux/fs.h> 18eddcd976SNicolas Pitre #include <linux/file.h> 191da177e4SLinus Torvalds #include <linux/pagemap.h> 20eddcd976SNicolas Pitre #include <linux/pfn_t.h> 21eddcd976SNicolas Pitre #include <linux/ramfs.h> 221da177e4SLinus Torvalds #include <linux/init.h> 231da177e4SLinus Torvalds #include <linux/string.h> 241da177e4SLinus Torvalds #include <linux/blkdev.h> 2599c18ce5SNicolas Pitre #include <linux/mtd/mtd.h> 2699c18ce5SNicolas Pitre #include <linux/mtd/super.h> 2774f78fc5SDavid Howells #include <linux/fs_context.h> 281da177e4SLinus Torvalds #include <linux/slab.h> 291da177e4SLinus Torvalds #include <linux/vfs.h> 30353ab6e9SIngo Molnar #include <linux/mutex.h> 31f7f4f4ddSAl Viro #include <uapi/linux/cramfs_fs.h> 321508f3ebSFabian Frederick #include <linux/uaccess.h> 331da177e4SLinus Torvalds 34f7f4f4ddSAl Viro #include "internal.h" 35f7f4f4ddSAl Viro 36f7f4f4ddSAl Viro /* 37f7f4f4ddSAl Viro * cramfs super-block data in memory 38f7f4f4ddSAl Viro */ 39f7f4f4ddSAl Viro struct cramfs_sb_info { 40f7f4f4ddSAl Viro unsigned long magic; 41f7f4f4ddSAl Viro unsigned long size; 42f7f4f4ddSAl Viro unsigned long blocks; 43f7f4f4ddSAl Viro unsigned long files; 44f7f4f4ddSAl Viro unsigned long flags; 4599c18ce5SNicolas Pitre void *linear_virt_addr; 4699c18ce5SNicolas Pitre resource_size_t linear_phys_addr; 4799c18ce5SNicolas Pitre size_t mtd_point_size; 48f7f4f4ddSAl Viro }; 49f7f4f4ddSAl Viro 50f7f4f4ddSAl Viro static inline struct cramfs_sb_info *CRAMFS_SB(struct super_block *sb) 51f7f4f4ddSAl Viro { 52f7f4f4ddSAl Viro return sb->s_fs_info; 53f7f4f4ddSAl Viro } 54f7f4f4ddSAl Viro 55ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations cramfs_ops; 56754661f1SArjan van de Ven static const struct inode_operations cramfs_dir_inode_operations; 574b6f5d20SArjan van de Ven static const struct file_operations cramfs_directory_operations; 58eddcd976SNicolas Pitre static const struct file_operations cramfs_physmem_fops; 59f5e54d6eSChristoph Hellwig static const struct address_space_operations cramfs_aops; 601da177e4SLinus Torvalds 61353ab6e9SIngo Molnar static DEFINE_MUTEX(read_mutex); 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds 646f772fe6SStefani Seibold /* These macros may change in future, to provide better st_ino semantics. */ 651da177e4SLinus Torvalds #define OFFSET(x) ((x)->i_ino) 661da177e4SLinus Torvalds 670577d1baSAl Viro static unsigned long cramino(const struct cramfs_inode *cino, unsigned int offset) 681da177e4SLinus Torvalds { 696f772fe6SStefani Seibold if (!cino->offset) 706f772fe6SStefani Seibold return offset + 1; 716f772fe6SStefani Seibold if (!cino->size) 726f772fe6SStefani Seibold return offset + 1; 736f772fe6SStefani Seibold 746f772fe6SStefani Seibold /* 756f772fe6SStefani Seibold * The file mode test fixes buggy mkcramfs implementations where 766f772fe6SStefani Seibold * cramfs_inode->offset is set to a non zero value for entries 776f772fe6SStefani Seibold * which did not contain data, like devices node and fifos. 786f772fe6SStefani Seibold */ 796f772fe6SStefani Seibold switch (cino->mode & S_IFMT) { 806f772fe6SStefani Seibold case S_IFREG: 816f772fe6SStefani Seibold case S_IFDIR: 826f772fe6SStefani Seibold case S_IFLNK: 836f772fe6SStefani Seibold return cino->offset << 2; 846f772fe6SStefani Seibold default: 856f772fe6SStefani Seibold break; 866f772fe6SStefani Seibold } 876f772fe6SStefani Seibold return offset + 1; 886f772fe6SStefani Seibold } 896f772fe6SStefani Seibold 906f772fe6SStefani Seibold static struct inode *get_cramfs_inode(struct super_block *sb, 910577d1baSAl Viro const struct cramfs_inode *cramfs_inode, unsigned int offset) 926f772fe6SStefani Seibold { 936f772fe6SStefani Seibold struct inode *inode; 9495582b00SDeepa Dinamani static struct timespec64 zerotime; 956f772fe6SStefani Seibold 966f772fe6SStefani Seibold inode = iget_locked(sb, cramino(cramfs_inode, offset)); 976f772fe6SStefani Seibold if (!inode) 986f772fe6SStefani Seibold return ERR_PTR(-ENOMEM); 996f772fe6SStefani Seibold if (!(inode->i_state & I_NEW)) 1006f772fe6SStefani Seibold return inode; 1016f772fe6SStefani Seibold 1026f772fe6SStefani Seibold switch (cramfs_inode->mode & S_IFMT) { 1036f772fe6SStefani Seibold case S_IFREG: 1046f772fe6SStefani Seibold inode->i_fop = &generic_ro_fops; 1056f772fe6SStefani Seibold inode->i_data.a_ops = &cramfs_aops; 106eddcd976SNicolas Pitre if (IS_ENABLED(CONFIG_CRAMFS_MTD) && 107eddcd976SNicolas Pitre CRAMFS_SB(sb)->flags & CRAMFS_FLAG_EXT_BLOCK_POINTERS && 108eddcd976SNicolas Pitre CRAMFS_SB(sb)->linear_phys_addr) 109eddcd976SNicolas Pitre inode->i_fop = &cramfs_physmem_fops; 1106f772fe6SStefani Seibold break; 1116f772fe6SStefani Seibold case S_IFDIR: 1126f772fe6SStefani Seibold inode->i_op = &cramfs_dir_inode_operations; 1136f772fe6SStefani Seibold inode->i_fop = &cramfs_directory_operations; 1146f772fe6SStefani Seibold break; 1156f772fe6SStefani Seibold case S_IFLNK: 1166f772fe6SStefani Seibold inode->i_op = &page_symlink_inode_operations; 11721fc61c7SAl Viro inode_nohighmem(inode); 1186f772fe6SStefani Seibold inode->i_data.a_ops = &cramfs_aops; 1196f772fe6SStefani Seibold break; 1206f772fe6SStefani Seibold default: 1216f772fe6SStefani Seibold init_special_inode(inode, cramfs_inode->mode, 1226f772fe6SStefani Seibold old_decode_dev(cramfs_inode->size)); 1236f772fe6SStefani Seibold } 1246f772fe6SStefani Seibold 1251da177e4SLinus Torvalds inode->i_mode = cramfs_inode->mode; 126a7d9cfe9SEric W. Biederman i_uid_write(inode, cramfs_inode->uid); 127a7d9cfe9SEric W. Biederman i_gid_write(inode, cramfs_inode->gid); 1286f772fe6SStefani Seibold 1296f772fe6SStefani Seibold /* if the lower 2 bits are zero, the inode contains data */ 1306f772fe6SStefani Seibold if (!(inode->i_ino & 3)) { 1311da177e4SLinus Torvalds inode->i_size = cramfs_inode->size; 1321da177e4SLinus Torvalds inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1; 1336f772fe6SStefani Seibold } 1346f772fe6SStefani Seibold 1351da177e4SLinus Torvalds /* Struct copy intentional */ 1361da177e4SLinus Torvalds inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime; 1371da177e4SLinus Torvalds /* inode->i_nlink is left 1 - arguably wrong for directories, 1381da177e4SLinus Torvalds but it's the best we can do without reading the directory 1391da177e4SLinus Torvalds contents. 1 yields the right result in GNU find, even 1401da177e4SLinus Torvalds without -noleaf option. */ 1411da177e4SLinus Torvalds 14277b8a75fSAl Viro unlock_new_inode(inode); 1436f772fe6SStefani Seibold 14477b8a75fSAl Viro return inode; 14582d63fc9SAl Viro } 14682d63fc9SAl Viro 1471da177e4SLinus Torvalds /* 1481da177e4SLinus Torvalds * We have our own block cache: don't fill up the buffer cache 1491da177e4SLinus Torvalds * with the rom-image, because the way the filesystem is set 1501da177e4SLinus Torvalds * up the accesses should be fairly regular and cached in the 1511da177e4SLinus Torvalds * page cache and dentry tree anyway.. 1521da177e4SLinus Torvalds * 1531da177e4SLinus Torvalds * This also acts as a way to guarantee contiguous areas of up to 154ea1754a0SKirill A. Shutemov * BLKS_PER_BUF*PAGE_SIZE, so that the caller doesn't need to 1551da177e4SLinus Torvalds * worry about end-of-buffer issues even when decompressing a full 1561da177e4SLinus Torvalds * page cache. 15799c18ce5SNicolas Pitre * 15899c18ce5SNicolas Pitre * Note: This is all optimized away at compile time when 15999c18ce5SNicolas Pitre * CONFIG_CRAMFS_BLOCKDEV=n. 1601da177e4SLinus Torvalds */ 1611da177e4SLinus Torvalds #define READ_BUFFERS (2) 1621da177e4SLinus Torvalds /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */ 1631da177e4SLinus Torvalds #define NEXT_BUFFER(_ix) ((_ix) ^ 1) 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds /* 1661da177e4SLinus Torvalds * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed" 1671da177e4SLinus Torvalds * data that takes up more space than the original and with unlucky 1681da177e4SLinus Torvalds * alignment. 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds #define BLKS_PER_BUF_SHIFT (2) 1711da177e4SLinus Torvalds #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT) 17209cbfeafSKirill A. Shutemov #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_SIZE) 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE]; 1751da177e4SLinus Torvalds static unsigned buffer_blocknr[READ_BUFFERS]; 1761da177e4SLinus Torvalds static struct super_block *buffer_dev[READ_BUFFERS]; 1771da177e4SLinus Torvalds static int next_buffer; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds /* 18099c18ce5SNicolas Pitre * Populate our block cache and return a pointer to it. 1811da177e4SLinus Torvalds */ 18299c18ce5SNicolas Pitre static void *cramfs_blkdev_read(struct super_block *sb, unsigned int offset, 18399c18ce5SNicolas Pitre unsigned int len) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; 1861da177e4SLinus Torvalds struct page *pages[BLKS_PER_BUF]; 1876bbfb077SAndi Drebes unsigned i, blocknr, buffer; 1881da177e4SLinus Torvalds unsigned long devsize; 1891da177e4SLinus Torvalds char *data; 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds if (!len) 1921da177e4SLinus Torvalds return NULL; 19309cbfeafSKirill A. Shutemov blocknr = offset >> PAGE_SHIFT; 19409cbfeafSKirill A. Shutemov offset &= PAGE_SIZE - 1; 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds /* Check if an existing buffer already has the data.. */ 1971da177e4SLinus Torvalds for (i = 0; i < READ_BUFFERS; i++) { 1981da177e4SLinus Torvalds unsigned int blk_offset; 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds if (buffer_dev[i] != sb) 2011da177e4SLinus Torvalds continue; 2021da177e4SLinus Torvalds if (blocknr < buffer_blocknr[i]) 2031da177e4SLinus Torvalds continue; 20409cbfeafSKirill A. Shutemov blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_SHIFT; 2051da177e4SLinus Torvalds blk_offset += offset; 206672ca9ddSNicolas Pitre if (blk_offset > BUFFER_SIZE || 207672ca9ddSNicolas Pitre blk_offset + len > BUFFER_SIZE) 2081da177e4SLinus Torvalds continue; 2091da177e4SLinus Torvalds return read_buffers[i] + blk_offset; 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 21209cbfeafSKirill A. Shutemov devsize = mapping->host->i_size >> PAGE_SHIFT; 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* Ok, read in BLKS_PER_BUF pages completely first. */ 2151da177e4SLinus Torvalds for (i = 0; i < BLKS_PER_BUF; i++) { 2161da177e4SLinus Torvalds struct page *page = NULL; 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds if (blocknr + i < devsize) { 21967f9fd91SSasha Levin page = read_mapping_page(mapping, blocknr + i, NULL); 2201da177e4SLinus Torvalds /* synchronous error? */ 2211da177e4SLinus Torvalds if (IS_ERR(page)) 2221da177e4SLinus Torvalds page = NULL; 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds pages[i] = page; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds for (i = 0; i < BLKS_PER_BUF; i++) { 2281da177e4SLinus Torvalds struct page *page = pages[i]; 22931d92e55SFabian Frederick 2301da177e4SLinus Torvalds if (page) { 2311da177e4SLinus Torvalds wait_on_page_locked(page); 2321da177e4SLinus Torvalds if (!PageUptodate(page)) { 2331da177e4SLinus Torvalds /* asynchronous error */ 23409cbfeafSKirill A. Shutemov put_page(page); 2351da177e4SLinus Torvalds pages[i] = NULL; 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds buffer = next_buffer; 2411da177e4SLinus Torvalds next_buffer = NEXT_BUFFER(buffer); 2421da177e4SLinus Torvalds buffer_blocknr[buffer] = blocknr; 2431da177e4SLinus Torvalds buffer_dev[buffer] = sb; 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds data = read_buffers[buffer]; 2461da177e4SLinus Torvalds for (i = 0; i < BLKS_PER_BUF; i++) { 2471da177e4SLinus Torvalds struct page *page = pages[i]; 24831d92e55SFabian Frederick 2491da177e4SLinus Torvalds if (page) { 25009cbfeafSKirill A. Shutemov memcpy(data, kmap(page), PAGE_SIZE); 2511da177e4SLinus Torvalds kunmap(page); 25209cbfeafSKirill A. Shutemov put_page(page); 2531da177e4SLinus Torvalds } else 25409cbfeafSKirill A. Shutemov memset(data, 0, PAGE_SIZE); 25509cbfeafSKirill A. Shutemov data += PAGE_SIZE; 2561da177e4SLinus Torvalds } 2571da177e4SLinus Torvalds return read_buffers[buffer] + offset; 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds 26099c18ce5SNicolas Pitre /* 26199c18ce5SNicolas Pitre * Return a pointer to the linearly addressed cramfs image in memory. 26299c18ce5SNicolas Pitre */ 26399c18ce5SNicolas Pitre static void *cramfs_direct_read(struct super_block *sb, unsigned int offset, 26499c18ce5SNicolas Pitre unsigned int len) 26599c18ce5SNicolas Pitre { 26699c18ce5SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 26799c18ce5SNicolas Pitre 26899c18ce5SNicolas Pitre if (!len) 26999c18ce5SNicolas Pitre return NULL; 27099c18ce5SNicolas Pitre if (len > sbi->size || offset > sbi->size - len) 27199c18ce5SNicolas Pitre return page_address(ZERO_PAGE(0)); 27299c18ce5SNicolas Pitre return sbi->linear_virt_addr + offset; 27399c18ce5SNicolas Pitre } 27499c18ce5SNicolas Pitre 27599c18ce5SNicolas Pitre /* 27699c18ce5SNicolas Pitre * Returns a pointer to a buffer containing at least LEN bytes of 27799c18ce5SNicolas Pitre * filesystem starting at byte offset OFFSET into the filesystem. 27899c18ce5SNicolas Pitre */ 27999c18ce5SNicolas Pitre static void *cramfs_read(struct super_block *sb, unsigned int offset, 28099c18ce5SNicolas Pitre unsigned int len) 28199c18ce5SNicolas Pitre { 28299c18ce5SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 28399c18ce5SNicolas Pitre 28499c18ce5SNicolas Pitre if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sbi->linear_virt_addr) 28599c18ce5SNicolas Pitre return cramfs_direct_read(sb, offset, len); 28699c18ce5SNicolas Pitre else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) 28799c18ce5SNicolas Pitre return cramfs_blkdev_read(sb, offset, len); 28899c18ce5SNicolas Pitre else 28999c18ce5SNicolas Pitre return NULL; 29099c18ce5SNicolas Pitre } 29199c18ce5SNicolas Pitre 292eddcd976SNicolas Pitre /* 293eddcd976SNicolas Pitre * For a mapping to be possible, we need a range of uncompressed and 294eddcd976SNicolas Pitre * contiguous blocks. Return the offset for the first block and number of 295eddcd976SNicolas Pitre * valid blocks for which that is true, or zero otherwise. 296eddcd976SNicolas Pitre */ 297eddcd976SNicolas Pitre static u32 cramfs_get_block_range(struct inode *inode, u32 pgoff, u32 *pages) 298eddcd976SNicolas Pitre { 299eddcd976SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb); 300eddcd976SNicolas Pitre int i; 301eddcd976SNicolas Pitre u32 *blockptrs, first_block_addr; 302eddcd976SNicolas Pitre 303eddcd976SNicolas Pitre /* 304eddcd976SNicolas Pitre * We can dereference memory directly here as this code may be 305eddcd976SNicolas Pitre * reached only when there is a direct filesystem image mapping 306eddcd976SNicolas Pitre * available in memory. 307eddcd976SNicolas Pitre */ 308eddcd976SNicolas Pitre blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode) + pgoff * 4); 309eddcd976SNicolas Pitre first_block_addr = blockptrs[0] & ~CRAMFS_BLK_FLAGS; 310eddcd976SNicolas Pitre i = 0; 311eddcd976SNicolas Pitre do { 312eddcd976SNicolas Pitre u32 block_off = i * (PAGE_SIZE >> CRAMFS_BLK_DIRECT_PTR_SHIFT); 313eddcd976SNicolas Pitre u32 expect = (first_block_addr + block_off) | 314eddcd976SNicolas Pitre CRAMFS_BLK_FLAG_DIRECT_PTR | 315eddcd976SNicolas Pitre CRAMFS_BLK_FLAG_UNCOMPRESSED; 316eddcd976SNicolas Pitre if (blockptrs[i] != expect) { 317eddcd976SNicolas Pitre pr_debug("range: block %d/%d got %#x expects %#x\n", 318eddcd976SNicolas Pitre pgoff+i, pgoff + *pages - 1, 319eddcd976SNicolas Pitre blockptrs[i], expect); 320eddcd976SNicolas Pitre if (i == 0) 321eddcd976SNicolas Pitre return 0; 322eddcd976SNicolas Pitre break; 323eddcd976SNicolas Pitre } 324eddcd976SNicolas Pitre } while (++i < *pages); 325eddcd976SNicolas Pitre 326eddcd976SNicolas Pitre *pages = i; 327eddcd976SNicolas Pitre return first_block_addr << CRAMFS_BLK_DIRECT_PTR_SHIFT; 328eddcd976SNicolas Pitre } 329eddcd976SNicolas Pitre 330eddcd976SNicolas Pitre #ifdef CONFIG_MMU 331eddcd976SNicolas Pitre 332eddcd976SNicolas Pitre /* 333eddcd976SNicolas Pitre * Return true if the last page of a file in the filesystem image contains 334eddcd976SNicolas Pitre * some other data that doesn't belong to that file. It is assumed that the 335eddcd976SNicolas Pitre * last block is CRAMFS_BLK_FLAG_DIRECT_PTR | CRAMFS_BLK_FLAG_UNCOMPRESSED 336eddcd976SNicolas Pitre * (verified by cramfs_get_block_range() and directly accessible in memory. 337eddcd976SNicolas Pitre */ 338eddcd976SNicolas Pitre static bool cramfs_last_page_is_shared(struct inode *inode) 339eddcd976SNicolas Pitre { 340eddcd976SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb); 341eddcd976SNicolas Pitre u32 partial, last_page, blockaddr, *blockptrs; 342eddcd976SNicolas Pitre char *tail_data; 343eddcd976SNicolas Pitre 344eddcd976SNicolas Pitre partial = offset_in_page(inode->i_size); 345eddcd976SNicolas Pitre if (!partial) 346eddcd976SNicolas Pitre return false; 347eddcd976SNicolas Pitre last_page = inode->i_size >> PAGE_SHIFT; 348eddcd976SNicolas Pitre blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode)); 349eddcd976SNicolas Pitre blockaddr = blockptrs[last_page] & ~CRAMFS_BLK_FLAGS; 350eddcd976SNicolas Pitre blockaddr <<= CRAMFS_BLK_DIRECT_PTR_SHIFT; 351eddcd976SNicolas Pitre tail_data = sbi->linear_virt_addr + blockaddr + partial; 352eddcd976SNicolas Pitre return memchr_inv(tail_data, 0, PAGE_SIZE - partial) ? true : false; 353eddcd976SNicolas Pitre } 354eddcd976SNicolas Pitre 355eddcd976SNicolas Pitre static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma) 356eddcd976SNicolas Pitre { 357eddcd976SNicolas Pitre struct inode *inode = file_inode(file); 358eddcd976SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb); 359eddcd976SNicolas Pitre unsigned int pages, max_pages, offset; 360eddcd976SNicolas Pitre unsigned long address, pgoff = vma->vm_pgoff; 361eddcd976SNicolas Pitre char *bailout_reason; 362eddcd976SNicolas Pitre int ret; 363eddcd976SNicolas Pitre 364eddcd976SNicolas Pitre ret = generic_file_readonly_mmap(file, vma); 365eddcd976SNicolas Pitre if (ret) 366eddcd976SNicolas Pitre return ret; 367eddcd976SNicolas Pitre 368eddcd976SNicolas Pitre /* 369eddcd976SNicolas Pitre * Now try to pre-populate ptes for this vma with a direct 370eddcd976SNicolas Pitre * mapping avoiding memory allocation when possible. 371eddcd976SNicolas Pitre */ 372eddcd976SNicolas Pitre 373eddcd976SNicolas Pitre /* Could COW work here? */ 374eddcd976SNicolas Pitre bailout_reason = "vma is writable"; 375eddcd976SNicolas Pitre if (vma->vm_flags & VM_WRITE) 376eddcd976SNicolas Pitre goto bailout; 377eddcd976SNicolas Pitre 378eddcd976SNicolas Pitre max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; 379eddcd976SNicolas Pitre bailout_reason = "beyond file limit"; 380eddcd976SNicolas Pitre if (pgoff >= max_pages) 381eddcd976SNicolas Pitre goto bailout; 382eddcd976SNicolas Pitre pages = min(vma_pages(vma), max_pages - pgoff); 383eddcd976SNicolas Pitre 384eddcd976SNicolas Pitre offset = cramfs_get_block_range(inode, pgoff, &pages); 385eddcd976SNicolas Pitre bailout_reason = "unsuitable block layout"; 386eddcd976SNicolas Pitre if (!offset) 387eddcd976SNicolas Pitre goto bailout; 388eddcd976SNicolas Pitre address = sbi->linear_phys_addr + offset; 389eddcd976SNicolas Pitre bailout_reason = "data is not page aligned"; 390eddcd976SNicolas Pitre if (!PAGE_ALIGNED(address)) 391eddcd976SNicolas Pitre goto bailout; 392eddcd976SNicolas Pitre 393eddcd976SNicolas Pitre /* Don't map the last page if it contains some other data */ 394eddcd976SNicolas Pitre if (pgoff + pages == max_pages && cramfs_last_page_is_shared(inode)) { 395eddcd976SNicolas Pitre pr_debug("mmap: %s: last page is shared\n", 396eddcd976SNicolas Pitre file_dentry(file)->d_name.name); 397eddcd976SNicolas Pitre pages--; 398eddcd976SNicolas Pitre } 399eddcd976SNicolas Pitre 400eddcd976SNicolas Pitre if (!pages) { 401eddcd976SNicolas Pitre bailout_reason = "no suitable block remaining"; 402eddcd976SNicolas Pitre goto bailout; 403eddcd976SNicolas Pitre } 404eddcd976SNicolas Pitre 405eddcd976SNicolas Pitre if (pages == vma_pages(vma)) { 406eddcd976SNicolas Pitre /* 407eddcd976SNicolas Pitre * The entire vma is mappable. remap_pfn_range() will 408eddcd976SNicolas Pitre * make it distinguishable from a non-direct mapping 409eddcd976SNicolas Pitre * in /proc/<pid>/maps by substituting the file offset 410eddcd976SNicolas Pitre * with the actual physical address. 411eddcd976SNicolas Pitre */ 412eddcd976SNicolas Pitre ret = remap_pfn_range(vma, vma->vm_start, address >> PAGE_SHIFT, 413eddcd976SNicolas Pitre pages * PAGE_SIZE, vma->vm_page_prot); 414eddcd976SNicolas Pitre } else { 415eddcd976SNicolas Pitre /* 416eddcd976SNicolas Pitre * Let's create a mixed map if we can't map it all. 417eddcd976SNicolas Pitre * The normal paging machinery will take care of the 418eddcd976SNicolas Pitre * unpopulated ptes via cramfs_readpage(). 419eddcd976SNicolas Pitre */ 420eddcd976SNicolas Pitre int i; 421eddcd976SNicolas Pitre vma->vm_flags |= VM_MIXEDMAP; 422eddcd976SNicolas Pitre for (i = 0; i < pages && !ret; i++) { 4237f2764cfSNicolas Pitre vm_fault_t vmf; 424eddcd976SNicolas Pitre unsigned long off = i * PAGE_SIZE; 425eddcd976SNicolas Pitre pfn_t pfn = phys_to_pfn_t(address + off, PFN_DEV); 4267f2764cfSNicolas Pitre vmf = vmf_insert_mixed(vma, vma->vm_start + off, pfn); 4277f2764cfSNicolas Pitre if (vmf & VM_FAULT_ERROR) 4287f2764cfSNicolas Pitre ret = vm_fault_to_errno(vmf, 0); 429eddcd976SNicolas Pitre } 430eddcd976SNicolas Pitre } 431eddcd976SNicolas Pitre 432eddcd976SNicolas Pitre if (!ret) 433eddcd976SNicolas Pitre pr_debug("mapped %s[%lu] at 0x%08lx (%u/%lu pages) " 434eddcd976SNicolas Pitre "to vma 0x%08lx, page_prot 0x%llx\n", 435eddcd976SNicolas Pitre file_dentry(file)->d_name.name, pgoff, 436eddcd976SNicolas Pitre address, pages, vma_pages(vma), vma->vm_start, 437eddcd976SNicolas Pitre (unsigned long long)pgprot_val(vma->vm_page_prot)); 438eddcd976SNicolas Pitre return ret; 439eddcd976SNicolas Pitre 440eddcd976SNicolas Pitre bailout: 441eddcd976SNicolas Pitre pr_debug("%s[%lu]: direct mmap impossible: %s\n", 442eddcd976SNicolas Pitre file_dentry(file)->d_name.name, pgoff, bailout_reason); 443eddcd976SNicolas Pitre /* Didn't manage any direct map, but normal paging is still possible */ 444eddcd976SNicolas Pitre return 0; 445eddcd976SNicolas Pitre } 446eddcd976SNicolas Pitre 447eddcd976SNicolas Pitre #else /* CONFIG_MMU */ 448eddcd976SNicolas Pitre 449eddcd976SNicolas Pitre static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma) 450eddcd976SNicolas Pitre { 451eddcd976SNicolas Pitre return vma->vm_flags & (VM_SHARED | VM_MAYSHARE) ? 0 : -ENOSYS; 452eddcd976SNicolas Pitre } 453eddcd976SNicolas Pitre 454eddcd976SNicolas Pitre static unsigned long cramfs_physmem_get_unmapped_area(struct file *file, 455eddcd976SNicolas Pitre unsigned long addr, unsigned long len, 456eddcd976SNicolas Pitre unsigned long pgoff, unsigned long flags) 457eddcd976SNicolas Pitre { 458eddcd976SNicolas Pitre struct inode *inode = file_inode(file); 459eddcd976SNicolas Pitre struct super_block *sb = inode->i_sb; 460eddcd976SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 461eddcd976SNicolas Pitre unsigned int pages, block_pages, max_pages, offset; 462eddcd976SNicolas Pitre 463eddcd976SNicolas Pitre pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; 464eddcd976SNicolas Pitre max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; 465eddcd976SNicolas Pitre if (pgoff >= max_pages || pages > max_pages - pgoff) 466eddcd976SNicolas Pitre return -EINVAL; 467eddcd976SNicolas Pitre block_pages = pages; 468eddcd976SNicolas Pitre offset = cramfs_get_block_range(inode, pgoff, &block_pages); 469eddcd976SNicolas Pitre if (!offset || block_pages != pages) 470eddcd976SNicolas Pitre return -ENOSYS; 471eddcd976SNicolas Pitre addr = sbi->linear_phys_addr + offset; 472eddcd976SNicolas Pitre pr_debug("get_unmapped for %s ofs %#lx siz %lu at 0x%08lx\n", 473eddcd976SNicolas Pitre file_dentry(file)->d_name.name, pgoff*PAGE_SIZE, len, addr); 474eddcd976SNicolas Pitre return addr; 475eddcd976SNicolas Pitre } 476eddcd976SNicolas Pitre 477eddcd976SNicolas Pitre static unsigned int cramfs_physmem_mmap_capabilities(struct file *file) 478eddcd976SNicolas Pitre { 479eddcd976SNicolas Pitre return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | 480eddcd976SNicolas Pitre NOMMU_MAP_READ | NOMMU_MAP_EXEC; 481eddcd976SNicolas Pitre } 482eddcd976SNicolas Pitre 483eddcd976SNicolas Pitre #endif /* CONFIG_MMU */ 484eddcd976SNicolas Pitre 485eddcd976SNicolas Pitre static const struct file_operations cramfs_physmem_fops = { 486eddcd976SNicolas Pitre .llseek = generic_file_llseek, 487eddcd976SNicolas Pitre .read_iter = generic_file_read_iter, 488eddcd976SNicolas Pitre .splice_read = generic_file_splice_read, 489eddcd976SNicolas Pitre .mmap = cramfs_physmem_mmap, 490eddcd976SNicolas Pitre #ifndef CONFIG_MMU 491eddcd976SNicolas Pitre .get_unmapped_area = cramfs_physmem_get_unmapped_area, 492eddcd976SNicolas Pitre .mmap_capabilities = cramfs_physmem_mmap_capabilities, 493eddcd976SNicolas Pitre #endif 494eddcd976SNicolas Pitre }; 495eddcd976SNicolas Pitre 4962309fb8eSAl Viro static void cramfs_kill_sb(struct super_block *sb) 4971da177e4SLinus Torvalds { 498f7f4f4ddSAl Viro struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 49931d92e55SFabian Frederick 50008a8f308SJoe Perches if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sb->s_mtd) { 50199c18ce5SNicolas Pitre if (sbi && sbi->mtd_point_size) 50299c18ce5SNicolas Pitre mtd_unpoint(sb->s_mtd, 0, sbi->mtd_point_size); 50399c18ce5SNicolas Pitre kill_mtd_super(sb); 50499c18ce5SNicolas Pitre } else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV) && sb->s_bdev) { 5052309fb8eSAl Viro kill_block_super(sb); 50699c18ce5SNicolas Pitre } 5072309fb8eSAl Viro kfree(sbi); 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds 51074f78fc5SDavid Howells static int cramfs_reconfigure(struct fs_context *fc) 5111da177e4SLinus Torvalds { 51274f78fc5SDavid Howells sync_filesystem(fc->root->d_sb); 51374f78fc5SDavid Howells fc->sb_flags |= SB_RDONLY; 5141da177e4SLinus Torvalds return 0; 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds 51774f78fc5SDavid Howells static int cramfs_read_super(struct super_block *sb, struct fs_context *fc, 51874f78fc5SDavid Howells struct cramfs_super *super) 5191da177e4SLinus Torvalds { 52099c18ce5SNicolas Pitre struct cramfs_sb_info *sbi = CRAMFS_SB(sb); 5211da177e4SLinus Torvalds unsigned long root_offset; 52274f78fc5SDavid Howells bool silent = fc->sb_flags & SB_SILENT; 5231da177e4SLinus Torvalds 52499c18ce5SNicolas Pitre /* We don't know the real size yet */ 52599c18ce5SNicolas Pitre sbi->size = PAGE_SIZE; 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds /* Read the first block and get the superblock from it */ 52899c18ce5SNicolas Pitre mutex_lock(&read_mutex); 52999c18ce5SNicolas Pitre memcpy(super, cramfs_read(sb, 0, sizeof(*super)), sizeof(*super)); 530353ab6e9SIngo Molnar mutex_unlock(&read_mutex); 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds /* Do sanity checks on the superblock */ 53399c18ce5SNicolas Pitre if (super->magic != CRAMFS_MAGIC) { 5340cc785ecSMasanari Iida /* check for wrong endianness */ 53599c18ce5SNicolas Pitre if (super->magic == CRAMFS_MAGIC_WEND) { 536ac8d35c5SAndi Drebes if (!silent) 537e1ee7d85SAl Viro errorfc(fc, "wrong endianness"); 5382309fb8eSAl Viro return -EINVAL; 539ac8d35c5SAndi Drebes } 540ac8d35c5SAndi Drebes 5411da177e4SLinus Torvalds /* check at 512 byte offset */ 542353ab6e9SIngo Molnar mutex_lock(&read_mutex); 54399c18ce5SNicolas Pitre memcpy(super, 54499c18ce5SNicolas Pitre cramfs_read(sb, 512, sizeof(*super)), 54599c18ce5SNicolas Pitre sizeof(*super)); 546353ab6e9SIngo Molnar mutex_unlock(&read_mutex); 54799c18ce5SNicolas Pitre if (super->magic != CRAMFS_MAGIC) { 54899c18ce5SNicolas Pitre if (super->magic == CRAMFS_MAGIC_WEND && !silent) 549e1ee7d85SAl Viro errorfc(fc, "wrong endianness"); 550ac8d35c5SAndi Drebes else if (!silent) 551e1ee7d85SAl Viro errorfc(fc, "wrong magic"); 5522309fb8eSAl Viro return -EINVAL; 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds /* get feature flags first */ 55799c18ce5SNicolas Pitre if (super->flags & ~CRAMFS_SUPPORTED_FLAGS) { 558e1ee7d85SAl Viro errorfc(fc, "unsupported filesystem features"); 5592309fb8eSAl Viro return -EINVAL; 5601da177e4SLinus Torvalds } 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds /* Check that the root inode is in a sane state */ 56399c18ce5SNicolas Pitre if (!S_ISDIR(super->root.mode)) { 564e1ee7d85SAl Viro errorfc(fc, "root is not a directory"); 5652309fb8eSAl Viro return -EINVAL; 5661da177e4SLinus Torvalds } 5676f772fe6SStefani Seibold /* correct strange, hard-coded permissions of mkcramfs */ 56899c18ce5SNicolas Pitre super->root.mode |= 0555; 5696f772fe6SStefani Seibold 57099c18ce5SNicolas Pitre root_offset = super->root.offset << 2; 57199c18ce5SNicolas Pitre if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) { 57299c18ce5SNicolas Pitre sbi->size = super->size; 57399c18ce5SNicolas Pitre sbi->blocks = super->fsid.blocks; 57499c18ce5SNicolas Pitre sbi->files = super->fsid.files; 5751da177e4SLinus Torvalds } else { 5761da177e4SLinus Torvalds sbi->size = 1<<28; 5771da177e4SLinus Torvalds sbi->blocks = 0; 5781da177e4SLinus Torvalds sbi->files = 0; 5791da177e4SLinus Torvalds } 58099c18ce5SNicolas Pitre sbi->magic = super->magic; 58199c18ce5SNicolas Pitre sbi->flags = super->flags; 5821da177e4SLinus Torvalds if (root_offset == 0) 583e1ee7d85SAl Viro infofc(fc, "empty filesystem"); 58499c18ce5SNicolas Pitre else if (!(super->flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) && 5851da177e4SLinus Torvalds ((root_offset != sizeof(struct cramfs_super)) && 5861da177e4SLinus Torvalds (root_offset != 512 + sizeof(struct cramfs_super)))) 5871da177e4SLinus Torvalds { 588e1ee7d85SAl Viro errorfc(fc, "bad root offset %lu", root_offset); 5892309fb8eSAl Viro return -EINVAL; 5901da177e4SLinus Torvalds } 5911da177e4SLinus Torvalds 59299c18ce5SNicolas Pitre return 0; 59399c18ce5SNicolas Pitre } 59499c18ce5SNicolas Pitre 59599c18ce5SNicolas Pitre static int cramfs_finalize_super(struct super_block *sb, 59699c18ce5SNicolas Pitre struct cramfs_inode *cramfs_root) 59799c18ce5SNicolas Pitre { 59899c18ce5SNicolas Pitre struct inode *root; 59999c18ce5SNicolas Pitre 6001da177e4SLinus Torvalds /* Set it all up.. */ 6011751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 60222b13969SDeepa Dinamani sb->s_time_min = 0; 60322b13969SDeepa Dinamani sb->s_time_max = 0; 6041da177e4SLinus Torvalds sb->s_op = &cramfs_ops; 60599c18ce5SNicolas Pitre root = get_cramfs_inode(sb, cramfs_root, 0); 6060577d1baSAl Viro if (IS_ERR(root)) 6072309fb8eSAl Viro return PTR_ERR(root); 60848fde701SAl Viro sb->s_root = d_make_root(root); 60948fde701SAl Viro if (!sb->s_root) 6102309fb8eSAl Viro return -ENOMEM; 6111da177e4SLinus Torvalds return 0; 6121da177e4SLinus Torvalds } 6131da177e4SLinus Torvalds 61474f78fc5SDavid Howells static int cramfs_blkdev_fill_super(struct super_block *sb, struct fs_context *fc) 61599c18ce5SNicolas Pitre { 61699c18ce5SNicolas Pitre struct cramfs_sb_info *sbi; 61799c18ce5SNicolas Pitre struct cramfs_super super; 61899c18ce5SNicolas Pitre int i, err; 61999c18ce5SNicolas Pitre 62099c18ce5SNicolas Pitre sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL); 62199c18ce5SNicolas Pitre if (!sbi) 62299c18ce5SNicolas Pitre return -ENOMEM; 62399c18ce5SNicolas Pitre sb->s_fs_info = sbi; 62499c18ce5SNicolas Pitre 62599c18ce5SNicolas Pitre /* Invalidate the read buffers on mount: think disk change.. */ 62699c18ce5SNicolas Pitre for (i = 0; i < READ_BUFFERS; i++) 62799c18ce5SNicolas Pitre buffer_blocknr[i] = -1; 62899c18ce5SNicolas Pitre 62974f78fc5SDavid Howells err = cramfs_read_super(sb, fc, &super); 63099c18ce5SNicolas Pitre if (err) 63199c18ce5SNicolas Pitre return err; 63299c18ce5SNicolas Pitre return cramfs_finalize_super(sb, &super.root); 63399c18ce5SNicolas Pitre } 63499c18ce5SNicolas Pitre 63574f78fc5SDavid Howells static int cramfs_mtd_fill_super(struct super_block *sb, struct fs_context *fc) 63699c18ce5SNicolas Pitre { 63799c18ce5SNicolas Pitre struct cramfs_sb_info *sbi; 63899c18ce5SNicolas Pitre struct cramfs_super super; 63999c18ce5SNicolas Pitre int err; 64099c18ce5SNicolas Pitre 64199c18ce5SNicolas Pitre sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL); 64299c18ce5SNicolas Pitre if (!sbi) 64399c18ce5SNicolas Pitre return -ENOMEM; 64499c18ce5SNicolas Pitre sb->s_fs_info = sbi; 64599c18ce5SNicolas Pitre 64699c18ce5SNicolas Pitre /* Map only one page for now. Will remap it when fs size is known. */ 64799c18ce5SNicolas Pitre err = mtd_point(sb->s_mtd, 0, PAGE_SIZE, &sbi->mtd_point_size, 64899c18ce5SNicolas Pitre &sbi->linear_virt_addr, &sbi->linear_phys_addr); 64999c18ce5SNicolas Pitre if (err || sbi->mtd_point_size != PAGE_SIZE) { 65099c18ce5SNicolas Pitre pr_err("unable to get direct memory access to mtd:%s\n", 65199c18ce5SNicolas Pitre sb->s_mtd->name); 65299c18ce5SNicolas Pitre return err ? : -ENODATA; 65399c18ce5SNicolas Pitre } 65499c18ce5SNicolas Pitre 65599c18ce5SNicolas Pitre pr_info("checking physical address %pap for linear cramfs image\n", 65699c18ce5SNicolas Pitre &sbi->linear_phys_addr); 65774f78fc5SDavid Howells err = cramfs_read_super(sb, fc, &super); 65899c18ce5SNicolas Pitre if (err) 65999c18ce5SNicolas Pitre return err; 66099c18ce5SNicolas Pitre 66199c18ce5SNicolas Pitre /* Remap the whole filesystem now */ 66299c18ce5SNicolas Pitre pr_info("linear cramfs image on mtd:%s appears to be %lu KB in size\n", 66399c18ce5SNicolas Pitre sb->s_mtd->name, sbi->size/1024); 66499c18ce5SNicolas Pitre mtd_unpoint(sb->s_mtd, 0, PAGE_SIZE); 66599c18ce5SNicolas Pitre err = mtd_point(sb->s_mtd, 0, sbi->size, &sbi->mtd_point_size, 66699c18ce5SNicolas Pitre &sbi->linear_virt_addr, &sbi->linear_phys_addr); 66799c18ce5SNicolas Pitre if (err || sbi->mtd_point_size != sbi->size) { 66899c18ce5SNicolas Pitre pr_err("unable to get direct memory access to mtd:%s\n", 66999c18ce5SNicolas Pitre sb->s_mtd->name); 67099c18ce5SNicolas Pitre return err ? : -ENODATA; 67199c18ce5SNicolas Pitre } 67299c18ce5SNicolas Pitre 67399c18ce5SNicolas Pitre return cramfs_finalize_super(sb, &super.root); 67499c18ce5SNicolas Pitre } 67599c18ce5SNicolas Pitre 676726c3342SDavid Howells static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf) 6771da177e4SLinus Torvalds { 678726c3342SDavid Howells struct super_block *sb = dentry->d_sb; 67999c18ce5SNicolas Pitre u64 id = 0; 68099c18ce5SNicolas Pitre 68199c18ce5SNicolas Pitre if (sb->s_bdev) 68299c18ce5SNicolas Pitre id = huge_encode_dev(sb->s_bdev->bd_dev); 68399c18ce5SNicolas Pitre else if (sb->s_dev) 68499c18ce5SNicolas Pitre id = huge_encode_dev(sb->s_dev); 685726c3342SDavid Howells 6861da177e4SLinus Torvalds buf->f_type = CRAMFS_MAGIC; 68709cbfeafSKirill A. Shutemov buf->f_bsize = PAGE_SIZE; 6881da177e4SLinus Torvalds buf->f_blocks = CRAMFS_SB(sb)->blocks; 6891da177e4SLinus Torvalds buf->f_bfree = 0; 6901da177e4SLinus Torvalds buf->f_bavail = 0; 6911da177e4SLinus Torvalds buf->f_files = CRAMFS_SB(sb)->files; 6921da177e4SLinus Torvalds buf->f_ffree = 0; 6936d1349c7SAl Viro buf->f_fsid = u64_to_fsid(id); 6941da177e4SLinus Torvalds buf->f_namelen = CRAMFS_MAXPATHLEN; 6951da177e4SLinus Torvalds return 0; 6961da177e4SLinus Torvalds } 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds /* 6991da177e4SLinus Torvalds * Read a cramfs directory entry. 7001da177e4SLinus Torvalds */ 7016f7f231eSAl Viro static int cramfs_readdir(struct file *file, struct dir_context *ctx) 7021da177e4SLinus Torvalds { 7036f7f231eSAl Viro struct inode *inode = file_inode(file); 7041da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 7051da177e4SLinus Torvalds char *buf; 7061da177e4SLinus Torvalds unsigned int offset; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds /* Offset within the thing. */ 7096f7f231eSAl Viro if (ctx->pos >= inode->i_size) 7101da177e4SLinus Torvalds return 0; 7116f7f231eSAl Viro offset = ctx->pos; 7121da177e4SLinus Torvalds /* Directory entries are always 4-byte aligned */ 7131da177e4SLinus Torvalds if (offset & 3) 7141da177e4SLinus Torvalds return -EINVAL; 7151da177e4SLinus Torvalds 7164176ed59SAndi Drebes buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL); 7171da177e4SLinus Torvalds if (!buf) 7181da177e4SLinus Torvalds return -ENOMEM; 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds while (offset < inode->i_size) { 7211da177e4SLinus Torvalds struct cramfs_inode *de; 7221da177e4SLinus Torvalds unsigned long nextoffset; 7231da177e4SLinus Torvalds char *name; 7241da177e4SLinus Torvalds ino_t ino; 725175a4eb7SAl Viro umode_t mode; 7266f7f231eSAl Viro int namelen; 7271da177e4SLinus Torvalds 728353ab6e9SIngo Molnar mutex_lock(&read_mutex); 7294176ed59SAndi Drebes de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN); 7301da177e4SLinus Torvalds name = (char *)(de+1); 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds /* 7331da177e4SLinus Torvalds * Namelengths on disk are shifted by two 7341da177e4SLinus Torvalds * and the name padded out to 4-byte boundaries 7351da177e4SLinus Torvalds * with zeroes. 7361da177e4SLinus Torvalds */ 7371da177e4SLinus Torvalds namelen = de->namelen << 2; 7381da177e4SLinus Torvalds memcpy(buf, name, namelen); 7396f772fe6SStefani Seibold ino = cramino(de, OFFSET(inode) + offset); 7401da177e4SLinus Torvalds mode = de->mode; 741353ab6e9SIngo Molnar mutex_unlock(&read_mutex); 7421da177e4SLinus Torvalds nextoffset = offset + sizeof(*de) + namelen; 7431da177e4SLinus Torvalds for (;;) { 7441da177e4SLinus Torvalds if (!namelen) { 7451da177e4SLinus Torvalds kfree(buf); 7461da177e4SLinus Torvalds return -EIO; 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds if (buf[namelen-1]) 7491da177e4SLinus Torvalds break; 7501da177e4SLinus Torvalds namelen--; 7511da177e4SLinus Torvalds } 7526f7f231eSAl Viro if (!dir_emit(ctx, buf, namelen, ino, mode >> 12)) 7531da177e4SLinus Torvalds break; 7541da177e4SLinus Torvalds 7556f7f231eSAl Viro ctx->pos = offset = nextoffset; 7561da177e4SLinus Torvalds } 7571da177e4SLinus Torvalds kfree(buf); 7581da177e4SLinus Torvalds return 0; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds /* 7621da177e4SLinus Torvalds * Lookup and fill in the inode data.. 7631da177e4SLinus Torvalds */ 76400cd8dd3SAl Viro static struct dentry *cramfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 7651da177e4SLinus Torvalds { 7661da177e4SLinus Torvalds unsigned int offset = 0; 7670577d1baSAl Viro struct inode *inode = NULL; 7681da177e4SLinus Torvalds int sorted; 7691da177e4SLinus Torvalds 770353ab6e9SIngo Molnar mutex_lock(&read_mutex); 7711da177e4SLinus Torvalds sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS; 7721da177e4SLinus Torvalds while (offset < dir->i_size) { 7731da177e4SLinus Torvalds struct cramfs_inode *de; 7741da177e4SLinus Torvalds char *name; 7751da177e4SLinus Torvalds int namelen, retval; 7766f772fe6SStefani Seibold int dir_off = OFFSET(dir) + offset; 7771da177e4SLinus Torvalds 7786f772fe6SStefani Seibold de = cramfs_read(dir->i_sb, dir_off, sizeof(*de)+CRAMFS_MAXPATHLEN); 7791da177e4SLinus Torvalds name = (char *)(de+1); 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds /* Try to take advantage of sorted directories */ 7821da177e4SLinus Torvalds if (sorted && (dentry->d_name.name[0] < name[0])) 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds namelen = de->namelen << 2; 7861da177e4SLinus Torvalds offset += sizeof(*de) + namelen; 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds /* Quick check that the name is roughly the right length */ 7891da177e4SLinus Torvalds if (((dentry->d_name.len + 3) & ~3) != namelen) 7901da177e4SLinus Torvalds continue; 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds for (;;) { 7931da177e4SLinus Torvalds if (!namelen) { 7940577d1baSAl Viro inode = ERR_PTR(-EIO); 7950577d1baSAl Viro goto out; 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds if (name[namelen-1]) 7981da177e4SLinus Torvalds break; 7991da177e4SLinus Torvalds namelen--; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds if (namelen != dentry->d_name.len) 8021da177e4SLinus Torvalds continue; 8031da177e4SLinus Torvalds retval = memcmp(dentry->d_name.name, name, namelen); 8041da177e4SLinus Torvalds if (retval > 0) 8051da177e4SLinus Torvalds continue; 8061da177e4SLinus Torvalds if (!retval) { 8070577d1baSAl Viro inode = get_cramfs_inode(dir->i_sb, de, dir_off); 8080577d1baSAl Viro break; 8091da177e4SLinus Torvalds } 8101da177e4SLinus Torvalds /* else (retval < 0) */ 8111da177e4SLinus Torvalds if (sorted) 8121da177e4SLinus Torvalds break; 8131da177e4SLinus Torvalds } 8140577d1baSAl Viro out: 815353ab6e9SIngo Molnar mutex_unlock(&read_mutex); 816d023b3a1SAl Viro return d_splice_alias(inode, dentry); 8171da177e4SLinus Torvalds } 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds static int cramfs_readpage(struct file *file, struct page *page) 8201da177e4SLinus Torvalds { 8211da177e4SLinus Torvalds struct inode *inode = page->mapping->host; 82298310e58SDavid VomLehn u32 maxblock; 82398310e58SDavid VomLehn int bytes_filled; 8241da177e4SLinus Torvalds void *pgdata; 8251da177e4SLinus Torvalds 82609cbfeafSKirill A. Shutemov maxblock = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; 8271da177e4SLinus Torvalds bytes_filled = 0; 82898310e58SDavid VomLehn pgdata = kmap(page); 82998310e58SDavid VomLehn 8301da177e4SLinus Torvalds if (page->index < maxblock) { 8311da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 8321da177e4SLinus Torvalds u32 blkptr_offset = OFFSET(inode) + page->index * 4; 833fd4f6f2aSNicolas Pitre u32 block_ptr, block_start, block_len; 834fd4f6f2aSNicolas Pitre bool uncompressed, direct; 8351da177e4SLinus Torvalds 836353ab6e9SIngo Molnar mutex_lock(&read_mutex); 837fd4f6f2aSNicolas Pitre block_ptr = *(u32 *) cramfs_read(sb, blkptr_offset, 4); 838fd4f6f2aSNicolas Pitre uncompressed = (block_ptr & CRAMFS_BLK_FLAG_UNCOMPRESSED); 839fd4f6f2aSNicolas Pitre direct = (block_ptr & CRAMFS_BLK_FLAG_DIRECT_PTR); 840fd4f6f2aSNicolas Pitre block_ptr &= ~CRAMFS_BLK_FLAGS; 84198310e58SDavid VomLehn 842fd4f6f2aSNicolas Pitre if (direct) { 843fd4f6f2aSNicolas Pitre /* 844fd4f6f2aSNicolas Pitre * The block pointer is an absolute start pointer, 845fd4f6f2aSNicolas Pitre * shifted by 2 bits. The size is included in the 846fd4f6f2aSNicolas Pitre * first 2 bytes of the data block when compressed, 847fd4f6f2aSNicolas Pitre * or PAGE_SIZE otherwise. 848fd4f6f2aSNicolas Pitre */ 849fd4f6f2aSNicolas Pitre block_start = block_ptr << CRAMFS_BLK_DIRECT_PTR_SHIFT; 850fd4f6f2aSNicolas Pitre if (uncompressed) { 851fd4f6f2aSNicolas Pitre block_len = PAGE_SIZE; 852fd4f6f2aSNicolas Pitre /* if last block: cap to file length */ 853fd4f6f2aSNicolas Pitre if (page->index == maxblock - 1) 854fd4f6f2aSNicolas Pitre block_len = 855fd4f6f2aSNicolas Pitre offset_in_page(inode->i_size); 85698310e58SDavid VomLehn } else { 857fd4f6f2aSNicolas Pitre block_len = *(u16 *) 858fd4f6f2aSNicolas Pitre cramfs_read(sb, block_start, 2); 859fd4f6f2aSNicolas Pitre block_start += 2; 860fd4f6f2aSNicolas Pitre } 861fd4f6f2aSNicolas Pitre } else { 862fd4f6f2aSNicolas Pitre /* 863fd4f6f2aSNicolas Pitre * The block pointer indicates one past the end of 864fd4f6f2aSNicolas Pitre * the current block (start of next block). If this 865fd4f6f2aSNicolas Pitre * is the first block then it starts where the block 866fd4f6f2aSNicolas Pitre * pointer table ends, otherwise its start comes 867fd4f6f2aSNicolas Pitre * from the previous block's pointer. 868fd4f6f2aSNicolas Pitre */ 869fd4f6f2aSNicolas Pitre block_start = OFFSET(inode) + maxblock * 4; 870fd4f6f2aSNicolas Pitre if (page->index) 871fd4f6f2aSNicolas Pitre block_start = *(u32 *) 872fd4f6f2aSNicolas Pitre cramfs_read(sb, blkptr_offset - 4, 4); 873fd4f6f2aSNicolas Pitre /* Beware... previous ptr might be a direct ptr */ 874fd4f6f2aSNicolas Pitre if (unlikely(block_start & CRAMFS_BLK_FLAG_DIRECT_PTR)) { 875fd4f6f2aSNicolas Pitre /* See comments on earlier code. */ 876fd4f6f2aSNicolas Pitre u32 prev_start = block_start; 877fd4f6f2aSNicolas Pitre block_start = prev_start & ~CRAMFS_BLK_FLAGS; 878fd4f6f2aSNicolas Pitre block_start <<= CRAMFS_BLK_DIRECT_PTR_SHIFT; 879fd4f6f2aSNicolas Pitre if (prev_start & CRAMFS_BLK_FLAG_UNCOMPRESSED) { 880fd4f6f2aSNicolas Pitre block_start += PAGE_SIZE; 881fd4f6f2aSNicolas Pitre } else { 882fd4f6f2aSNicolas Pitre block_len = *(u16 *) 883fd4f6f2aSNicolas Pitre cramfs_read(sb, block_start, 2); 884fd4f6f2aSNicolas Pitre block_start += 2 + block_len; 885fd4f6f2aSNicolas Pitre } 886fd4f6f2aSNicolas Pitre } 887fd4f6f2aSNicolas Pitre block_start &= ~CRAMFS_BLK_FLAGS; 888fd4f6f2aSNicolas Pitre block_len = block_ptr - block_start; 889fd4f6f2aSNicolas Pitre } 890fd4f6f2aSNicolas Pitre 891fd4f6f2aSNicolas Pitre if (block_len == 0) 892fd4f6f2aSNicolas Pitre ; /* hole */ 893fd4f6f2aSNicolas Pitre else if (unlikely(block_len > 2*PAGE_SIZE || 894fd4f6f2aSNicolas Pitre (uncompressed && block_len > PAGE_SIZE))) { 895fd4f6f2aSNicolas Pitre mutex_unlock(&read_mutex); 896fd4f6f2aSNicolas Pitre pr_err("bad data blocksize %u\n", block_len); 897fd4f6f2aSNicolas Pitre goto err; 898fd4f6f2aSNicolas Pitre } else if (uncompressed) { 899fd4f6f2aSNicolas Pitre memcpy(pgdata, 900fd4f6f2aSNicolas Pitre cramfs_read(sb, block_start, block_len), 901fd4f6f2aSNicolas Pitre block_len); 902fd4f6f2aSNicolas Pitre bytes_filled = block_len; 903fd4f6f2aSNicolas Pitre } else { 9041da177e4SLinus Torvalds bytes_filled = cramfs_uncompress_block(pgdata, 90509cbfeafSKirill A. Shutemov PAGE_SIZE, 906fd4f6f2aSNicolas Pitre cramfs_read(sb, block_start, block_len), 907fd4f6f2aSNicolas Pitre block_len); 908fd4f6f2aSNicolas Pitre } 909353ab6e9SIngo Molnar mutex_unlock(&read_mutex); 91098310e58SDavid VomLehn if (unlikely(bytes_filled < 0)) 91198310e58SDavid VomLehn goto err; 9121da177e4SLinus Torvalds } 91398310e58SDavid VomLehn 91409cbfeafSKirill A. Shutemov memset(pgdata + bytes_filled, 0, PAGE_SIZE - bytes_filled); 9151da177e4SLinus Torvalds flush_dcache_page(page); 91698310e58SDavid VomLehn kunmap(page); 9171da177e4SLinus Torvalds SetPageUptodate(page); 9181da177e4SLinus Torvalds unlock_page(page); 9191da177e4SLinus Torvalds return 0; 92098310e58SDavid VomLehn 92198310e58SDavid VomLehn err: 92298310e58SDavid VomLehn kunmap(page); 92398310e58SDavid VomLehn ClearPageUptodate(page); 92498310e58SDavid VomLehn SetPageError(page); 92598310e58SDavid VomLehn unlock_page(page); 92698310e58SDavid VomLehn return 0; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds 929f5e54d6eSChristoph Hellwig static const struct address_space_operations cramfs_aops = { 9301da177e4SLinus Torvalds .readpage = cramfs_readpage 9311da177e4SLinus Torvalds }; 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds /* 9341da177e4SLinus Torvalds * Our operations: 9351da177e4SLinus Torvalds */ 9361da177e4SLinus Torvalds 9371da177e4SLinus Torvalds /* 9381da177e4SLinus Torvalds * A directory can only readdir 9391da177e4SLinus Torvalds */ 9404b6f5d20SArjan van de Ven static const struct file_operations cramfs_directory_operations = { 9411da177e4SLinus Torvalds .llseek = generic_file_llseek, 9421da177e4SLinus Torvalds .read = generic_read_dir, 943c51da20cSAl Viro .iterate_shared = cramfs_readdir, 9441da177e4SLinus Torvalds }; 9451da177e4SLinus Torvalds 946754661f1SArjan van de Ven static const struct inode_operations cramfs_dir_inode_operations = { 9471da177e4SLinus Torvalds .lookup = cramfs_lookup, 9481da177e4SLinus Torvalds }; 9491da177e4SLinus Torvalds 950ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations cramfs_ops = { 9511da177e4SLinus Torvalds .statfs = cramfs_statfs, 9521da177e4SLinus Torvalds }; 9531da177e4SLinus Torvalds 95474f78fc5SDavid Howells static int cramfs_get_tree(struct fs_context *fc) 9551da177e4SLinus Torvalds { 95674f78fc5SDavid Howells int ret = -ENOPROTOOPT; 95799c18ce5SNicolas Pitre 95899c18ce5SNicolas Pitre if (IS_ENABLED(CONFIG_CRAMFS_MTD)) { 95974f78fc5SDavid Howells ret = get_tree_mtd(fc, cramfs_mtd_fill_super); 9603e5aeec0SMaxime Bizon if (!ret) 9613e5aeec0SMaxime Bizon return 0; 96299c18ce5SNicolas Pitre } 96374f78fc5SDavid Howells if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) 96474f78fc5SDavid Howells ret = get_tree_bdev(fc, cramfs_blkdev_fill_super); 96599c18ce5SNicolas Pitre return ret; 9661da177e4SLinus Torvalds } 9671da177e4SLinus Torvalds 96874f78fc5SDavid Howells static const struct fs_context_operations cramfs_context_ops = { 96974f78fc5SDavid Howells .get_tree = cramfs_get_tree, 97074f78fc5SDavid Howells .reconfigure = cramfs_reconfigure, 97174f78fc5SDavid Howells }; 97274f78fc5SDavid Howells 97374f78fc5SDavid Howells /* 97474f78fc5SDavid Howells * Set up the filesystem mount context. 97574f78fc5SDavid Howells */ 97674f78fc5SDavid Howells static int cramfs_init_fs_context(struct fs_context *fc) 97774f78fc5SDavid Howells { 97874f78fc5SDavid Howells fc->ops = &cramfs_context_ops; 97974f78fc5SDavid Howells return 0; 98074f78fc5SDavid Howells } 98174f78fc5SDavid Howells 9821da177e4SLinus Torvalds static struct file_system_type cramfs_fs_type = { 9831da177e4SLinus Torvalds .owner = THIS_MODULE, 9841da177e4SLinus Torvalds .name = "cramfs", 98574f78fc5SDavid Howells .init_fs_context = cramfs_init_fs_context, 9862309fb8eSAl Viro .kill_sb = cramfs_kill_sb, 9871da177e4SLinus Torvalds .fs_flags = FS_REQUIRES_DEV, 9881da177e4SLinus Torvalds }; 9897f78e035SEric W. Biederman MODULE_ALIAS_FS("cramfs"); 9901da177e4SLinus Torvalds 9911da177e4SLinus Torvalds static int __init init_cramfs_fs(void) 9921da177e4SLinus Torvalds { 99350d44ed0SAlexey Dobriyan int rv; 99450d44ed0SAlexey Dobriyan 99550d44ed0SAlexey Dobriyan rv = cramfs_uncompress_init(); 99650d44ed0SAlexey Dobriyan if (rv < 0) 99750d44ed0SAlexey Dobriyan return rv; 99850d44ed0SAlexey Dobriyan rv = register_filesystem(&cramfs_fs_type); 99950d44ed0SAlexey Dobriyan if (rv < 0) 100050d44ed0SAlexey Dobriyan cramfs_uncompress_exit(); 100150d44ed0SAlexey Dobriyan return rv; 10021da177e4SLinus Torvalds } 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds static void __exit exit_cramfs_fs(void) 10051da177e4SLinus Torvalds { 10061da177e4SLinus Torvalds cramfs_uncompress_exit(); 10071da177e4SLinus Torvalds unregister_filesystem(&cramfs_fs_type); 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds module_init(init_cramfs_fs) 10111da177e4SLinus Torvalds module_exit(exit_cramfs_fs) 10121da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1013