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 #include <linux/module.h> 15 #include <linux/fs.h> 16 #include <linux/pagemap.h> 17 #include <linux/init.h> 18 #include <linux/string.h> 19 #include <linux/blkdev.h> 20 #include <linux/cramfs_fs.h> 21 #include <linux/slab.h> 22 #include <linux/cramfs_fs_sb.h> 23 #include <linux/buffer_head.h> 24 #include <linux/vfs.h> 25 #include <linux/mutex.h> 26 27 #include <asm/uaccess.h> 28 29 static const struct super_operations cramfs_ops; 30 static const struct inode_operations cramfs_dir_inode_operations; 31 static const struct file_operations cramfs_directory_operations; 32 static const struct address_space_operations cramfs_aops; 33 34 static DEFINE_MUTEX(read_mutex); 35 36 37 /* These macros may change in future, to provide better st_ino semantics. */ 38 #define OFFSET(x) ((x)->i_ino) 39 40 static unsigned long cramino(const struct cramfs_inode *cino, unsigned int offset) 41 { 42 if (!cino->offset) 43 return offset + 1; 44 if (!cino->size) 45 return offset + 1; 46 47 /* 48 * The file mode test fixes buggy mkcramfs implementations where 49 * cramfs_inode->offset is set to a non zero value for entries 50 * which did not contain data, like devices node and fifos. 51 */ 52 switch (cino->mode & S_IFMT) { 53 case S_IFREG: 54 case S_IFDIR: 55 case S_IFLNK: 56 return cino->offset << 2; 57 default: 58 break; 59 } 60 return offset + 1; 61 } 62 63 static struct inode *get_cramfs_inode(struct super_block *sb, 64 const struct cramfs_inode *cramfs_inode, unsigned int offset) 65 { 66 struct inode *inode; 67 static struct timespec zerotime; 68 69 inode = iget_locked(sb, cramino(cramfs_inode, offset)); 70 if (!inode) 71 return ERR_PTR(-ENOMEM); 72 if (!(inode->i_state & I_NEW)) 73 return inode; 74 75 switch (cramfs_inode->mode & S_IFMT) { 76 case S_IFREG: 77 inode->i_fop = &generic_ro_fops; 78 inode->i_data.a_ops = &cramfs_aops; 79 break; 80 case S_IFDIR: 81 inode->i_op = &cramfs_dir_inode_operations; 82 inode->i_fop = &cramfs_directory_operations; 83 break; 84 case S_IFLNK: 85 inode->i_op = &page_symlink_inode_operations; 86 inode->i_data.a_ops = &cramfs_aops; 87 break; 88 default: 89 init_special_inode(inode, cramfs_inode->mode, 90 old_decode_dev(cramfs_inode->size)); 91 } 92 93 inode->i_mode = cramfs_inode->mode; 94 inode->i_uid = cramfs_inode->uid; 95 inode->i_gid = cramfs_inode->gid; 96 97 /* if the lower 2 bits are zero, the inode contains data */ 98 if (!(inode->i_ino & 3)) { 99 inode->i_size = cramfs_inode->size; 100 inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1; 101 } 102 103 /* Struct copy intentional */ 104 inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime; 105 /* inode->i_nlink is left 1 - arguably wrong for directories, 106 but it's the best we can do without reading the directory 107 contents. 1 yields the right result in GNU find, even 108 without -noleaf option. */ 109 110 unlock_new_inode(inode); 111 112 return inode; 113 } 114 115 /* 116 * We have our own block cache: don't fill up the buffer cache 117 * with the rom-image, because the way the filesystem is set 118 * up the accesses should be fairly regular and cached in the 119 * page cache and dentry tree anyway.. 120 * 121 * This also acts as a way to guarantee contiguous areas of up to 122 * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to 123 * worry about end-of-buffer issues even when decompressing a full 124 * page cache. 125 */ 126 #define READ_BUFFERS (2) 127 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */ 128 #define NEXT_BUFFER(_ix) ((_ix) ^ 1) 129 130 /* 131 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed" 132 * data that takes up more space than the original and with unlucky 133 * alignment. 134 */ 135 #define BLKS_PER_BUF_SHIFT (2) 136 #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT) 137 #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_CACHE_SIZE) 138 139 static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE]; 140 static unsigned buffer_blocknr[READ_BUFFERS]; 141 static struct super_block * buffer_dev[READ_BUFFERS]; 142 static int next_buffer; 143 144 /* 145 * Returns a pointer to a buffer containing at least LEN bytes of 146 * filesystem starting at byte offset OFFSET into the filesystem. 147 */ 148 static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned int len) 149 { 150 struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; 151 struct page *pages[BLKS_PER_BUF]; 152 unsigned i, blocknr, buffer; 153 unsigned long devsize; 154 char *data; 155 156 if (!len) 157 return NULL; 158 blocknr = offset >> PAGE_CACHE_SHIFT; 159 offset &= PAGE_CACHE_SIZE - 1; 160 161 /* Check if an existing buffer already has the data.. */ 162 for (i = 0; i < READ_BUFFERS; i++) { 163 unsigned int blk_offset; 164 165 if (buffer_dev[i] != sb) 166 continue; 167 if (blocknr < buffer_blocknr[i]) 168 continue; 169 blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_CACHE_SHIFT; 170 blk_offset += offset; 171 if (blk_offset + len > BUFFER_SIZE) 172 continue; 173 return read_buffers[i] + blk_offset; 174 } 175 176 devsize = mapping->host->i_size >> PAGE_CACHE_SHIFT; 177 178 /* Ok, read in BLKS_PER_BUF pages completely first. */ 179 for (i = 0; i < BLKS_PER_BUF; i++) { 180 struct page *page = NULL; 181 182 if (blocknr + i < devsize) { 183 page = read_mapping_page_async(mapping, blocknr + i, 184 NULL); 185 /* synchronous error? */ 186 if (IS_ERR(page)) 187 page = NULL; 188 } 189 pages[i] = page; 190 } 191 192 for (i = 0; i < BLKS_PER_BUF; i++) { 193 struct page *page = pages[i]; 194 if (page) { 195 wait_on_page_locked(page); 196 if (!PageUptodate(page)) { 197 /* asynchronous error */ 198 page_cache_release(page); 199 pages[i] = NULL; 200 } 201 } 202 } 203 204 buffer = next_buffer; 205 next_buffer = NEXT_BUFFER(buffer); 206 buffer_blocknr[buffer] = blocknr; 207 buffer_dev[buffer] = sb; 208 209 data = read_buffers[buffer]; 210 for (i = 0; i < BLKS_PER_BUF; i++) { 211 struct page *page = pages[i]; 212 if (page) { 213 memcpy(data, kmap(page), PAGE_CACHE_SIZE); 214 kunmap(page); 215 page_cache_release(page); 216 } else 217 memset(data, 0, PAGE_CACHE_SIZE); 218 data += PAGE_CACHE_SIZE; 219 } 220 return read_buffers[buffer] + offset; 221 } 222 223 static void cramfs_put_super(struct super_block *sb) 224 { 225 kfree(sb->s_fs_info); 226 sb->s_fs_info = NULL; 227 } 228 229 static int cramfs_remount(struct super_block *sb, int *flags, char *data) 230 { 231 *flags |= MS_RDONLY; 232 return 0; 233 } 234 235 static int cramfs_fill_super(struct super_block *sb, void *data, int silent) 236 { 237 int i; 238 struct cramfs_super super; 239 unsigned long root_offset; 240 struct cramfs_sb_info *sbi; 241 struct inode *root; 242 243 sb->s_flags |= MS_RDONLY; 244 245 sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL); 246 if (!sbi) 247 return -ENOMEM; 248 sb->s_fs_info = sbi; 249 250 /* Invalidate the read buffers on mount: think disk change.. */ 251 mutex_lock(&read_mutex); 252 for (i = 0; i < READ_BUFFERS; i++) 253 buffer_blocknr[i] = -1; 254 255 /* Read the first block and get the superblock from it */ 256 memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super)); 257 mutex_unlock(&read_mutex); 258 259 /* Do sanity checks on the superblock */ 260 if (super.magic != CRAMFS_MAGIC) { 261 /* check for wrong endianess */ 262 if (super.magic == CRAMFS_MAGIC_WEND) { 263 if (!silent) 264 printk(KERN_ERR "cramfs: wrong endianess\n"); 265 goto out; 266 } 267 268 /* check at 512 byte offset */ 269 mutex_lock(&read_mutex); 270 memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super)); 271 mutex_unlock(&read_mutex); 272 if (super.magic != CRAMFS_MAGIC) { 273 if (super.magic == CRAMFS_MAGIC_WEND && !silent) 274 printk(KERN_ERR "cramfs: wrong endianess\n"); 275 else if (!silent) 276 printk(KERN_ERR "cramfs: wrong magic\n"); 277 goto out; 278 } 279 } 280 281 /* get feature flags first */ 282 if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) { 283 printk(KERN_ERR "cramfs: unsupported filesystem features\n"); 284 goto out; 285 } 286 287 /* Check that the root inode is in a sane state */ 288 if (!S_ISDIR(super.root.mode)) { 289 printk(KERN_ERR "cramfs: root is not a directory\n"); 290 goto out; 291 } 292 /* correct strange, hard-coded permissions of mkcramfs */ 293 super.root.mode |= (S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); 294 295 root_offset = super.root.offset << 2; 296 if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) { 297 sbi->size=super.size; 298 sbi->blocks=super.fsid.blocks; 299 sbi->files=super.fsid.files; 300 } else { 301 sbi->size=1<<28; 302 sbi->blocks=0; 303 sbi->files=0; 304 } 305 sbi->magic=super.magic; 306 sbi->flags=super.flags; 307 if (root_offset == 0) 308 printk(KERN_INFO "cramfs: empty filesystem"); 309 else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) && 310 ((root_offset != sizeof(struct cramfs_super)) && 311 (root_offset != 512 + sizeof(struct cramfs_super)))) 312 { 313 printk(KERN_ERR "cramfs: bad root offset %lu\n", root_offset); 314 goto out; 315 } 316 317 /* Set it all up.. */ 318 sb->s_op = &cramfs_ops; 319 root = get_cramfs_inode(sb, &super.root, 0); 320 if (IS_ERR(root)) 321 goto out; 322 sb->s_root = d_alloc_root(root); 323 if (!sb->s_root) { 324 iput(root); 325 goto out; 326 } 327 return 0; 328 out: 329 kfree(sbi); 330 sb->s_fs_info = NULL; 331 return -EINVAL; 332 } 333 334 static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf) 335 { 336 struct super_block *sb = dentry->d_sb; 337 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 338 339 buf->f_type = CRAMFS_MAGIC; 340 buf->f_bsize = PAGE_CACHE_SIZE; 341 buf->f_blocks = CRAMFS_SB(sb)->blocks; 342 buf->f_bfree = 0; 343 buf->f_bavail = 0; 344 buf->f_files = CRAMFS_SB(sb)->files; 345 buf->f_ffree = 0; 346 buf->f_fsid.val[0] = (u32)id; 347 buf->f_fsid.val[1] = (u32)(id >> 32); 348 buf->f_namelen = CRAMFS_MAXPATHLEN; 349 return 0; 350 } 351 352 /* 353 * Read a cramfs directory entry. 354 */ 355 static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 356 { 357 struct inode *inode = filp->f_path.dentry->d_inode; 358 struct super_block *sb = inode->i_sb; 359 char *buf; 360 unsigned int offset; 361 int copied; 362 363 /* Offset within the thing. */ 364 offset = filp->f_pos; 365 if (offset >= inode->i_size) 366 return 0; 367 /* Directory entries are always 4-byte aligned */ 368 if (offset & 3) 369 return -EINVAL; 370 371 buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL); 372 if (!buf) 373 return -ENOMEM; 374 375 copied = 0; 376 while (offset < inode->i_size) { 377 struct cramfs_inode *de; 378 unsigned long nextoffset; 379 char *name; 380 ino_t ino; 381 mode_t mode; 382 int namelen, error; 383 384 mutex_lock(&read_mutex); 385 de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN); 386 name = (char *)(de+1); 387 388 /* 389 * Namelengths on disk are shifted by two 390 * and the name padded out to 4-byte boundaries 391 * with zeroes. 392 */ 393 namelen = de->namelen << 2; 394 memcpy(buf, name, namelen); 395 ino = cramino(de, OFFSET(inode) + offset); 396 mode = de->mode; 397 mutex_unlock(&read_mutex); 398 nextoffset = offset + sizeof(*de) + namelen; 399 for (;;) { 400 if (!namelen) { 401 kfree(buf); 402 return -EIO; 403 } 404 if (buf[namelen-1]) 405 break; 406 namelen--; 407 } 408 error = filldir(dirent, buf, namelen, offset, ino, mode >> 12); 409 if (error) 410 break; 411 412 offset = nextoffset; 413 filp->f_pos = offset; 414 copied++; 415 } 416 kfree(buf); 417 return 0; 418 } 419 420 /* 421 * Lookup and fill in the inode data.. 422 */ 423 static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 424 { 425 unsigned int offset = 0; 426 struct inode *inode = NULL; 427 int sorted; 428 429 mutex_lock(&read_mutex); 430 sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS; 431 while (offset < dir->i_size) { 432 struct cramfs_inode *de; 433 char *name; 434 int namelen, retval; 435 int dir_off = OFFSET(dir) + offset; 436 437 de = cramfs_read(dir->i_sb, dir_off, sizeof(*de)+CRAMFS_MAXPATHLEN); 438 name = (char *)(de+1); 439 440 /* Try to take advantage of sorted directories */ 441 if (sorted && (dentry->d_name.name[0] < name[0])) 442 break; 443 444 namelen = de->namelen << 2; 445 offset += sizeof(*de) + namelen; 446 447 /* Quick check that the name is roughly the right length */ 448 if (((dentry->d_name.len + 3) & ~3) != namelen) 449 continue; 450 451 for (;;) { 452 if (!namelen) { 453 inode = ERR_PTR(-EIO); 454 goto out; 455 } 456 if (name[namelen-1]) 457 break; 458 namelen--; 459 } 460 if (namelen != dentry->d_name.len) 461 continue; 462 retval = memcmp(dentry->d_name.name, name, namelen); 463 if (retval > 0) 464 continue; 465 if (!retval) { 466 inode = get_cramfs_inode(dir->i_sb, de, dir_off); 467 break; 468 } 469 /* else (retval < 0) */ 470 if (sorted) 471 break; 472 } 473 out: 474 mutex_unlock(&read_mutex); 475 if (IS_ERR(inode)) 476 return ERR_CAST(inode); 477 d_add(dentry, inode); 478 return NULL; 479 } 480 481 static int cramfs_readpage(struct file *file, struct page * page) 482 { 483 struct inode *inode = page->mapping->host; 484 u32 maxblock; 485 int bytes_filled; 486 void *pgdata; 487 488 maxblock = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; 489 bytes_filled = 0; 490 pgdata = kmap(page); 491 492 if (page->index < maxblock) { 493 struct super_block *sb = inode->i_sb; 494 u32 blkptr_offset = OFFSET(inode) + page->index*4; 495 u32 start_offset, compr_len; 496 497 start_offset = OFFSET(inode) + maxblock*4; 498 mutex_lock(&read_mutex); 499 if (page->index) 500 start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4, 501 4); 502 compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) - 503 start_offset); 504 mutex_unlock(&read_mutex); 505 506 if (compr_len == 0) 507 ; /* hole */ 508 else if (unlikely(compr_len > (PAGE_CACHE_SIZE << 1))) { 509 pr_err("cramfs: bad compressed blocksize %u\n", 510 compr_len); 511 goto err; 512 } else { 513 mutex_lock(&read_mutex); 514 bytes_filled = cramfs_uncompress_block(pgdata, 515 PAGE_CACHE_SIZE, 516 cramfs_read(sb, start_offset, compr_len), 517 compr_len); 518 mutex_unlock(&read_mutex); 519 if (unlikely(bytes_filled < 0)) 520 goto err; 521 } 522 } 523 524 memset(pgdata + bytes_filled, 0, PAGE_CACHE_SIZE - bytes_filled); 525 flush_dcache_page(page); 526 kunmap(page); 527 SetPageUptodate(page); 528 unlock_page(page); 529 return 0; 530 531 err: 532 kunmap(page); 533 ClearPageUptodate(page); 534 SetPageError(page); 535 unlock_page(page); 536 return 0; 537 } 538 539 static const struct address_space_operations cramfs_aops = { 540 .readpage = cramfs_readpage 541 }; 542 543 /* 544 * Our operations: 545 */ 546 547 /* 548 * A directory can only readdir 549 */ 550 static const struct file_operations cramfs_directory_operations = { 551 .llseek = generic_file_llseek, 552 .read = generic_read_dir, 553 .readdir = cramfs_readdir, 554 }; 555 556 static const struct inode_operations cramfs_dir_inode_operations = { 557 .lookup = cramfs_lookup, 558 }; 559 560 static const struct super_operations cramfs_ops = { 561 .put_super = cramfs_put_super, 562 .remount_fs = cramfs_remount, 563 .statfs = cramfs_statfs, 564 }; 565 566 static struct dentry *cramfs_mount(struct file_system_type *fs_type, 567 int flags, const char *dev_name, void *data) 568 { 569 return mount_bdev(fs_type, flags, dev_name, data, cramfs_fill_super); 570 } 571 572 static struct file_system_type cramfs_fs_type = { 573 .owner = THIS_MODULE, 574 .name = "cramfs", 575 .mount = cramfs_mount, 576 .kill_sb = kill_block_super, 577 .fs_flags = FS_REQUIRES_DEV, 578 }; 579 580 static int __init init_cramfs_fs(void) 581 { 582 int rv; 583 584 rv = cramfs_uncompress_init(); 585 if (rv < 0) 586 return rv; 587 rv = register_filesystem(&cramfs_fs_type); 588 if (rv < 0) 589 cramfs_uncompress_exit(); 590 return rv; 591 } 592 593 static void __exit exit_cramfs_fs(void) 594 { 595 cramfs_uncompress_exit(); 596 unregister_filesystem(&cramfs_fs_type); 597 } 598 599 module_init(init_cramfs_fs) 600 module_exit(exit_cramfs_fs) 601 MODULE_LICENSE("GPL"); 602