1/* 2 * Squashfs - a compressed read only filesystem for Linux 3 * 4 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 5 * Phillip Lougher <phillip@lougher.demon.co.uk> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2, 10 * or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 * file.c 22 */ 23 24/* 25 * This file contains code for handling regular files. A regular file 26 * consists of a sequence of contiguous compressed blocks, and/or a 27 * compressed fragment block (tail-end packed block). The compressed size 28 * of each datablock is stored in a block list contained within the 29 * file inode (itself stored in one or more compressed metadata blocks). 30 * 31 * To speed up access to datablocks when reading 'large' files (256 Mbytes or 32 * larger), the code implements an index cache that caches the mapping from 33 * block index to datablock location on disk. 34 * 35 * The index cache allows Squashfs to handle large files (up to 1.75 TiB) while 36 * retaining a simple and space-efficient block list on disk. The cache 37 * is split into slots, caching up to eight 224 GiB files (128 KiB blocks). 38 * Larger files use multiple slots, with 1.75 TiB files using all 8 slots. 39 * The index cache is designed to be memory efficient, and by default uses 40 * 16 KiB. 41 */ 42 43#include <linux/fs.h> 44#include <linux/vfs.h> 45#include <linux/kernel.h> 46#include <linux/slab.h> 47#include <linux/string.h> 48#include <linux/pagemap.h> 49#include <linux/mutex.h> 50 51#include "squashfs_fs.h" 52#include "squashfs_fs_sb.h" 53#include "squashfs_fs_i.h" 54#include "squashfs.h" 55 56/* 57 * Locate cache slot in range [offset, index] for specified inode. If 58 * there's more than one return the slot closest to index. 59 */ 60static struct meta_index *locate_meta_index(struct inode *inode, int offset, 61 int index) 62{ 63 struct meta_index *meta = NULL; 64 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; 65 int i; 66 67 mutex_lock(&msblk->meta_index_mutex); 68 69 TRACE("locate_meta_index: index %d, offset %d\n", index, offset); 70 71 if (msblk->meta_index == NULL) 72 goto not_allocated; 73 74 for (i = 0; i < SQUASHFS_META_SLOTS; i++) { 75 if (msblk->meta_index[i].inode_number == inode->i_ino && 76 msblk->meta_index[i].offset >= offset && 77 msblk->meta_index[i].offset <= index && 78 msblk->meta_index[i].locked == 0) { 79 TRACE("locate_meta_index: entry %d, offset %d\n", i, 80 msblk->meta_index[i].offset); 81 meta = &msblk->meta_index[i]; 82 offset = meta->offset; 83 } 84 } 85 86 if (meta) 87 meta->locked = 1; 88 89not_allocated: 90 mutex_unlock(&msblk->meta_index_mutex); 91 92 return meta; 93} 94 95 96/* 97 * Find and initialise an empty cache slot for index offset. 98 */ 99static struct meta_index *empty_meta_index(struct inode *inode, int offset, 100 int skip) 101{ 102 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; 103 struct meta_index *meta = NULL; 104 int i; 105 106 mutex_lock(&msblk->meta_index_mutex); 107 108 TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip); 109 110 if (msblk->meta_index == NULL) { 111 /* 112 * First time cache index has been used, allocate and 113 * initialise. The cache index could be allocated at 114 * mount time but doing it here means it is allocated only 115 * if a 'large' file is read. 116 */ 117 msblk->meta_index = kcalloc(SQUASHFS_META_SLOTS, 118 sizeof(*(msblk->meta_index)), GFP_KERNEL); 119 if (msblk->meta_index == NULL) { 120 ERROR("Failed to allocate meta_index\n"); 121 goto failed; 122 } 123 for (i = 0; i < SQUASHFS_META_SLOTS; i++) { 124 msblk->meta_index[i].inode_number = 0; 125 msblk->meta_index[i].locked = 0; 126 } 127 msblk->next_meta_index = 0; 128 } 129 130 for (i = SQUASHFS_META_SLOTS; i && 131 msblk->meta_index[msblk->next_meta_index].locked; i--) 132 msblk->next_meta_index = (msblk->next_meta_index + 1) % 133 SQUASHFS_META_SLOTS; 134 135 if (i == 0) { 136 TRACE("empty_meta_index: failed!\n"); 137 goto failed; 138 } 139 140 TRACE("empty_meta_index: returned meta entry %d, %p\n", 141 msblk->next_meta_index, 142 &msblk->meta_index[msblk->next_meta_index]); 143 144 meta = &msblk->meta_index[msblk->next_meta_index]; 145 msblk->next_meta_index = (msblk->next_meta_index + 1) % 146 SQUASHFS_META_SLOTS; 147 148 meta->inode_number = inode->i_ino; 149 meta->offset = offset; 150 meta->skip = skip; 151 meta->entries = 0; 152 meta->locked = 1; 153 154failed: 155 mutex_unlock(&msblk->meta_index_mutex); 156 return meta; 157} 158 159 160static void release_meta_index(struct inode *inode, struct meta_index *meta) 161{ 162 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; 163 mutex_lock(&msblk->meta_index_mutex); 164 meta->locked = 0; 165 mutex_unlock(&msblk->meta_index_mutex); 166} 167 168 169/* 170 * Read the next n blocks from the block list, starting from 171 * metadata block <start_block, offset>. 172 */ 173static long long read_indexes(struct super_block *sb, int n, 174 u64 *start_block, int *offset) 175{ 176 int err, i; 177 long long block = 0; 178 __le32 *blist = kmalloc(PAGE_CACHE_SIZE, GFP_KERNEL); 179 180 if (blist == NULL) { 181 ERROR("read_indexes: Failed to allocate block_list\n"); 182 return -ENOMEM; 183 } 184 185 while (n) { 186 int blocks = min_t(int, n, PAGE_CACHE_SIZE >> 2); 187 188 err = squashfs_read_metadata(sb, blist, start_block, 189 offset, blocks << 2); 190 if (err < 0) { 191 ERROR("read_indexes: reading block [%llx:%x]\n", 192 *start_block, *offset); 193 goto failure; 194 } 195 196 for (i = 0; i < blocks; i++) { 197 int size = le32_to_cpu(blist[i]); 198 block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size); 199 } 200 n -= blocks; 201 } 202 203 kfree(blist); 204 return block; 205 206failure: 207 kfree(blist); 208 return err; 209} 210 211 212/* 213 * Each cache index slot has SQUASHFS_META_ENTRIES, each of which 214 * can cache one index -> datablock/blocklist-block mapping. We wish 215 * to distribute these over the length of the file, entry[0] maps index x, 216 * entry[1] maps index x + skip, entry[2] maps index x + 2 * skip, and so on. 217 * The larger the file, the greater the skip factor. The skip factor is 218 * limited to the size of the metadata cache (SQUASHFS_CACHED_BLKS) to ensure 219 * the number of metadata blocks that need to be read fits into the cache. 220 * If the skip factor is limited in this way then the file will use multiple 221 * slots. 222 */ 223static inline int calculate_skip(int blocks) 224{ 225 int skip = blocks / ((SQUASHFS_META_ENTRIES + 1) 226 * SQUASHFS_META_INDEXES); 227 return min(SQUASHFS_CACHED_BLKS - 1, skip + 1); 228} 229 230 231/* 232 * Search and grow the index cache for the specified inode, returning the 233 * on-disk locations of the datablock and block list metadata block 234 * <index_block, index_offset> for index (scaled to nearest cache index). 235 */ 236static int fill_meta_index(struct inode *inode, int index, 237 u64 *index_block, int *index_offset, u64 *data_block) 238{ 239 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; 240 int skip = calculate_skip(i_size_read(inode) >> msblk->block_log); 241 int offset = 0; 242 struct meta_index *meta; 243 struct meta_entry *meta_entry; 244 u64 cur_index_block = squashfs_i(inode)->block_list_start; 245 int cur_offset = squashfs_i(inode)->offset; 246 u64 cur_data_block = squashfs_i(inode)->start; 247 int err, i; 248 249 /* 250 * Scale index to cache index (cache slot entry) 251 */ 252 index /= SQUASHFS_META_INDEXES * skip; 253 254 while (offset < index) { 255 meta = locate_meta_index(inode, offset + 1, index); 256 257 if (meta == NULL) { 258 meta = empty_meta_index(inode, offset + 1, skip); 259 if (meta == NULL) 260 goto all_done; 261 } else { 262 offset = index < meta->offset + meta->entries ? index : 263 meta->offset + meta->entries - 1; 264 meta_entry = &meta->meta_entry[offset - meta->offset]; 265 cur_index_block = meta_entry->index_block + 266 msblk->inode_table; 267 cur_offset = meta_entry->offset; 268 cur_data_block = meta_entry->data_block; 269 TRACE("get_meta_index: offset %d, meta->offset %d, " 270 "meta->entries %d\n", offset, meta->offset, 271 meta->entries); 272 TRACE("get_meta_index: index_block 0x%llx, offset 0x%x" 273 " data_block 0x%llx\n", cur_index_block, 274 cur_offset, cur_data_block); 275 } 276 277 /* 278 * If necessary grow cache slot by reading block list. Cache 279 * slot is extended up to index or to the end of the slot, in 280 * which case further slots will be used. 281 */ 282 for (i = meta->offset + meta->entries; i <= index && 283 i < meta->offset + SQUASHFS_META_ENTRIES; i++) { 284 int blocks = skip * SQUASHFS_META_INDEXES; 285 long long res = read_indexes(inode->i_sb, blocks, 286 &cur_index_block, &cur_offset); 287 288 if (res < 0) { 289 if (meta->entries == 0) 290 /* 291 * Don't leave an empty slot on read 292 * error allocated to this inode... 293 */ 294 meta->inode_number = 0; 295 err = res; 296 goto failed; 297 } 298 299 cur_data_block += res; 300 meta_entry = &meta->meta_entry[i - meta->offset]; 301 meta_entry->index_block = cur_index_block - 302 msblk->inode_table; 303 meta_entry->offset = cur_offset; 304 meta_entry->data_block = cur_data_block; 305 meta->entries++; 306 offset++; 307 } 308 309 TRACE("get_meta_index: meta->offset %d, meta->entries %d\n", 310 meta->offset, meta->entries); 311 312 release_meta_index(inode, meta); 313 } 314 315all_done: 316 *index_block = cur_index_block; 317 *index_offset = cur_offset; 318 *data_block = cur_data_block; 319 320 /* 321 * Scale cache index (cache slot entry) to index 322 */ 323 return offset * SQUASHFS_META_INDEXES * skip; 324 325failed: 326 release_meta_index(inode, meta); 327 return err; 328} 329 330 331/* 332 * Get the on-disk location and compressed size of the datablock 333 * specified by index. Fill_meta_index() does most of the work. 334 */ 335static int read_blocklist(struct inode *inode, int index, u64 *block) 336{ 337 u64 start; 338 long long blks; 339 int offset; 340 __le32 size; 341 int res = fill_meta_index(inode, index, &start, &offset, block); 342 343 TRACE("read_blocklist: res %d, index %d, start 0x%llx, offset" 344 " 0x%x, block 0x%llx\n", res, index, start, offset, 345 *block); 346 347 if (res < 0) 348 return res; 349 350 /* 351 * res contains the index of the mapping returned by fill_meta_index(), 352 * this will likely be less than the desired index (because the 353 * meta_index cache works at a higher granularity). Read any 354 * extra block indexes needed. 355 */ 356 if (res < index) { 357 blks = read_indexes(inode->i_sb, index - res, &start, &offset); 358 if (blks < 0) 359 return (int) blks; 360 *block += blks; 361 } 362 363 /* 364 * Read length of block specified by index. 365 */ 366 res = squashfs_read_metadata(inode->i_sb, &size, &start, &offset, 367 sizeof(size)); 368 if (res < 0) 369 return res; 370 return le32_to_cpu(size); 371} 372 373 374static int squashfs_readpage(struct file *file, struct page *page) 375{ 376 struct inode *inode = page->mapping->host; 377 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; 378 int bytes, i, offset = 0, sparse = 0; 379 struct squashfs_cache_entry *buffer = NULL; 380 void *pageaddr; 381 382 int mask = (1 << (msblk->block_log - PAGE_CACHE_SHIFT)) - 1; 383 int index = page->index >> (msblk->block_log - PAGE_CACHE_SHIFT); 384 int start_index = page->index & ~mask; 385 int end_index = start_index | mask; 386 int file_end = i_size_read(inode) >> msblk->block_log; 387 388 TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n", 389 page->index, squashfs_i(inode)->start); 390 391 if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> 392 PAGE_CACHE_SHIFT)) 393 goto out; 394 395 if (index < file_end || squashfs_i(inode)->fragment_block == 396 SQUASHFS_INVALID_BLK) { 397 /* 398 * Reading a datablock from disk. Need to read block list 399 * to get location and block size. 400 */ 401 u64 block = 0; 402 int bsize = read_blocklist(inode, index, &block); 403 if (bsize < 0) 404 goto error_out; 405 406 if (bsize == 0) { /* hole */ 407 bytes = index == file_end ? 408 (i_size_read(inode) & (msblk->block_size - 1)) : 409 msblk->block_size; 410 sparse = 1; 411 } else { 412 /* 413 * Read and decompress datablock. 414 */ 415 buffer = squashfs_get_datablock(inode->i_sb, 416 block, bsize); 417 if (buffer->error) { 418 ERROR("Unable to read page, block %llx, size %x" 419 "\n", block, bsize); 420 squashfs_cache_put(buffer); 421 goto error_out; 422 } 423 bytes = buffer->length; 424 } 425 } else { 426 /* 427 * Datablock is stored inside a fragment (tail-end packed 428 * block). 429 */ 430 buffer = squashfs_get_fragment(inode->i_sb, 431 squashfs_i(inode)->fragment_block, 432 squashfs_i(inode)->fragment_size); 433 434 if (buffer->error) { 435 ERROR("Unable to read page, block %llx, size %x\n", 436 squashfs_i(inode)->fragment_block, 437 squashfs_i(inode)->fragment_size); 438 squashfs_cache_put(buffer); 439 goto error_out; 440 } 441 bytes = i_size_read(inode) & (msblk->block_size - 1); 442 offset = squashfs_i(inode)->fragment_offset; 443 } 444 445 /* 446 * Loop copying datablock into pages. As the datablock likely covers 447 * many PAGE_CACHE_SIZE pages (default block size is 128 KiB) explicitly 448 * grab the pages from the page cache, except for the page that we've 449 * been called to fill. 450 */ 451 for (i = start_index; i <= end_index && bytes > 0; i++, 452 bytes -= PAGE_CACHE_SIZE, offset += PAGE_CACHE_SIZE) { 453 struct page *push_page; 454 int avail = sparse ? 0 : min_t(int, bytes, PAGE_CACHE_SIZE); 455 456 TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail); 457 458 push_page = (i == page->index) ? page : 459 grab_cache_page_nowait(page->mapping, i); 460 461 if (!push_page) 462 continue; 463 464 if (PageUptodate(push_page)) 465 goto skip_page; 466 467 pageaddr = kmap_atomic(push_page, KM_USER0); 468 squashfs_copy_data(pageaddr, buffer, offset, avail); 469 memset(pageaddr + avail, 0, PAGE_CACHE_SIZE - avail); 470 kunmap_atomic(pageaddr, KM_USER0); 471 flush_dcache_page(push_page); 472 SetPageUptodate(push_page); 473skip_page: 474 unlock_page(push_page); 475 if (i != page->index) 476 page_cache_release(push_page); 477 } 478 479 if (!sparse) 480 squashfs_cache_put(buffer); 481 482 return 0; 483 484error_out: 485 SetPageError(page); 486out: 487 pageaddr = kmap_atomic(page, KM_USER0); 488 memset(pageaddr, 0, PAGE_CACHE_SIZE); 489 kunmap_atomic(pageaddr, KM_USER0); 490 flush_dcache_page(page); 491 if (!PageError(page)) 492 SetPageUptodate(page); 493 unlock_page(page); 494 495 return 0; 496} 497 498 499const struct address_space_operations squashfs_aops = { 500 .readpage = squashfs_readpage 501}; 502