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