linux/fs/squashfs/file.c
<<
>>
Prefs
   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@squashfs.org.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);
 468                squashfs_copy_data(pageaddr, buffer, offset, avail);
 469                memset(pageaddr + avail, 0, PAGE_CACHE_SIZE - avail);
 470                kunmap_atomic(pageaddr);
 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);
 488        memset(pageaddr, 0, PAGE_CACHE_SIZE);
 489        kunmap_atomic(pageaddr);
 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
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.