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