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