2019-05-20 17:08:00 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2009-01-05 08:46:24 +00:00
|
|
|
/*
|
|
|
|
* Squashfs - a compressed read only filesystem for Linux
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
|
2011-05-26 09:39:56 +00:00
|
|
|
* Phillip Lougher <phillip@squashfs.org.uk>
|
2009-01-05 08:46:24 +00:00
|
|
|
*
|
|
|
|
* file.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This file contains code for handling regular files. A regular file
|
|
|
|
* consists of a sequence of contiguous compressed blocks, and/or a
|
|
|
|
* compressed fragment block (tail-end packed block). The compressed size
|
|
|
|
* of each datablock is stored in a block list contained within the
|
|
|
|
* file inode (itself stored in one or more compressed metadata blocks).
|
|
|
|
*
|
|
|
|
* To speed up access to datablocks when reading 'large' files (256 Mbytes or
|
|
|
|
* larger), the code implements an index cache that caches the mapping from
|
|
|
|
* block index to datablock location on disk.
|
|
|
|
*
|
|
|
|
* The index cache allows Squashfs to handle large files (up to 1.75 TiB) while
|
|
|
|
* retaining a simple and space-efficient block list on disk. The cache
|
|
|
|
* is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
|
|
|
|
* Larger files use multiple slots, with 1.75 TiB files using all 8 slots.
|
|
|
|
* The index cache is designed to be memory efficient, and by default uses
|
|
|
|
* 16 KiB.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/vfs.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
|
|
|
#include "squashfs_fs.h"
|
|
|
|
#include "squashfs_fs_sb.h"
|
|
|
|
#include "squashfs_fs_i.h"
|
|
|
|
#include "squashfs.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Locate cache slot in range [offset, index] for specified inode. If
|
|
|
|
* there's more than one return the slot closest to index.
|
|
|
|
*/
|
|
|
|
static struct meta_index *locate_meta_index(struct inode *inode, int offset,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
struct meta_index *meta = NULL;
|
|
|
|
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&msblk->meta_index_mutex);
|
|
|
|
|
|
|
|
TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
|
|
|
|
|
|
|
|
if (msblk->meta_index == NULL)
|
|
|
|
goto not_allocated;
|
|
|
|
|
|
|
|
for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
|
|
|
|
if (msblk->meta_index[i].inode_number == inode->i_ino &&
|
|
|
|
msblk->meta_index[i].offset >= offset &&
|
|
|
|
msblk->meta_index[i].offset <= index &&
|
|
|
|
msblk->meta_index[i].locked == 0) {
|
|
|
|
TRACE("locate_meta_index: entry %d, offset %d\n", i,
|
|
|
|
msblk->meta_index[i].offset);
|
|
|
|
meta = &msblk->meta_index[i];
|
|
|
|
offset = meta->offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (meta)
|
|
|
|
meta->locked = 1;
|
|
|
|
|
|
|
|
not_allocated:
|
|
|
|
mutex_unlock(&msblk->meta_index_mutex);
|
|
|
|
|
|
|
|
return meta;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find and initialise an empty cache slot for index offset.
|
|
|
|
*/
|
|
|
|
static struct meta_index *empty_meta_index(struct inode *inode, int offset,
|
|
|
|
int skip)
|
|
|
|
{
|
|
|
|
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
|
|
|
|
struct meta_index *meta = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&msblk->meta_index_mutex);
|
|
|
|
|
|
|
|
TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
|
|
|
|
|
|
|
|
if (msblk->meta_index == NULL) {
|
|
|
|
/*
|
|
|
|
* First time cache index has been used, allocate and
|
|
|
|
* initialise. The cache index could be allocated at
|
|
|
|
* mount time but doing it here means it is allocated only
|
|
|
|
* if a 'large' file is read.
|
|
|
|
*/
|
|
|
|
msblk->meta_index = kcalloc(SQUASHFS_META_SLOTS,
|
|
|
|
sizeof(*(msblk->meta_index)), GFP_KERNEL);
|
|
|
|
if (msblk->meta_index == NULL) {
|
|
|
|
ERROR("Failed to allocate meta_index\n");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
|
|
|
|
msblk->meta_index[i].inode_number = 0;
|
|
|
|
msblk->meta_index[i].locked = 0;
|
|
|
|
}
|
|
|
|
msblk->next_meta_index = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = SQUASHFS_META_SLOTS; i &&
|
|
|
|
msblk->meta_index[msblk->next_meta_index].locked; i--)
|
|
|
|
msblk->next_meta_index = (msblk->next_meta_index + 1) %
|
|
|
|
SQUASHFS_META_SLOTS;
|
|
|
|
|
|
|
|
if (i == 0) {
|
|
|
|
TRACE("empty_meta_index: failed!\n");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
TRACE("empty_meta_index: returned meta entry %d, %p\n",
|
|
|
|
msblk->next_meta_index,
|
|
|
|
&msblk->meta_index[msblk->next_meta_index]);
|
|
|
|
|
|
|
|
meta = &msblk->meta_index[msblk->next_meta_index];
|
|
|
|
msblk->next_meta_index = (msblk->next_meta_index + 1) %
|
|
|
|
SQUASHFS_META_SLOTS;
|
|
|
|
|
|
|
|
meta->inode_number = inode->i_ino;
|
|
|
|
meta->offset = offset;
|
|
|
|
meta->skip = skip;
|
|
|
|
meta->entries = 0;
|
|
|
|
meta->locked = 1;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
mutex_unlock(&msblk->meta_index_mutex);
|
|
|
|
return meta;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void release_meta_index(struct inode *inode, struct meta_index *meta)
|
|
|
|
{
|
|
|
|
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
|
|
|
|
mutex_lock(&msblk->meta_index_mutex);
|
|
|
|
meta->locked = 0;
|
|
|
|
mutex_unlock(&msblk->meta_index_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the next n blocks from the block list, starting from
|
|
|
|
* metadata block <start_block, offset>.
|
|
|
|
*/
|
|
|
|
static long long read_indexes(struct super_block *sb, int n,
|
|
|
|
u64 *start_block, int *offset)
|
|
|
|
{
|
|
|
|
int err, i;
|
|
|
|
long long block = 0;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
__le32 *blist = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
2009-01-05 08:46:24 +00:00
|
|
|
|
|
|
|
if (blist == NULL) {
|
|
|
|
ERROR("read_indexes: Failed to allocate block_list\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (n) {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
int blocks = min_t(int, n, PAGE_SIZE >> 2);
|
2009-01-05 08:46:24 +00:00
|
|
|
|
|
|
|
err = squashfs_read_metadata(sb, blist, start_block,
|
|
|
|
offset, blocks << 2);
|
|
|
|
if (err < 0) {
|
|
|
|
ERROR("read_indexes: reading block [%llx:%x]\n",
|
|
|
|
*start_block, *offset);
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < blocks; i++) {
|
2018-07-29 19:44:46 +00:00
|
|
|
int size = squashfs_block_size(blist[i]);
|
|
|
|
if (size < 0) {
|
|
|
|
err = size;
|
|
|
|
goto failure;
|
|
|
|
}
|
2009-01-05 08:46:24 +00:00
|
|
|
block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
|
|
|
|
}
|
|
|
|
n -= blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(blist);
|
|
|
|
return block;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
kfree(blist);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each cache index slot has SQUASHFS_META_ENTRIES, each of which
|
|
|
|
* can cache one index -> datablock/blocklist-block mapping. We wish
|
|
|
|
* to distribute these over the length of the file, entry[0] maps index x,
|
|
|
|
* entry[1] maps index x + skip, entry[2] maps index x + 2 * skip, and so on.
|
|
|
|
* The larger the file, the greater the skip factor. The skip factor is
|
|
|
|
* limited to the size of the metadata cache (SQUASHFS_CACHED_BLKS) to ensure
|
|
|
|
* the number of metadata blocks that need to be read fits into the cache.
|
|
|
|
* If the skip factor is limited in this way then the file will use multiple
|
|
|
|
* slots.
|
|
|
|
*/
|
|
|
|
static inline int calculate_skip(int blocks)
|
|
|
|
{
|
|
|
|
int skip = blocks / ((SQUASHFS_META_ENTRIES + 1)
|
|
|
|
* SQUASHFS_META_INDEXES);
|
|
|
|
return min(SQUASHFS_CACHED_BLKS - 1, skip + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search and grow the index cache for the specified inode, returning the
|
|
|
|
* on-disk locations of the datablock and block list metadata block
|
|
|
|
* <index_block, index_offset> for index (scaled to nearest cache index).
|
|
|
|
*/
|
|
|
|
static int fill_meta_index(struct inode *inode, int index,
|
|
|
|
u64 *index_block, int *index_offset, u64 *data_block)
|
|
|
|
{
|
|
|
|
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
|
|
|
|
int skip = calculate_skip(i_size_read(inode) >> msblk->block_log);
|
|
|
|
int offset = 0;
|
|
|
|
struct meta_index *meta;
|
|
|
|
struct meta_entry *meta_entry;
|
|
|
|
u64 cur_index_block = squashfs_i(inode)->block_list_start;
|
|
|
|
int cur_offset = squashfs_i(inode)->offset;
|
|
|
|
u64 cur_data_block = squashfs_i(inode)->start;
|
|
|
|
int err, i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale index to cache index (cache slot entry)
|
|
|
|
*/
|
|
|
|
index /= SQUASHFS_META_INDEXES * skip;
|
|
|
|
|
|
|
|
while (offset < index) {
|
|
|
|
meta = locate_meta_index(inode, offset + 1, index);
|
|
|
|
|
|
|
|
if (meta == NULL) {
|
|
|
|
meta = empty_meta_index(inode, offset + 1, skip);
|
|
|
|
if (meta == NULL)
|
|
|
|
goto all_done;
|
|
|
|
} else {
|
|
|
|
offset = index < meta->offset + meta->entries ? index :
|
|
|
|
meta->offset + meta->entries - 1;
|
|
|
|
meta_entry = &meta->meta_entry[offset - meta->offset];
|
|
|
|
cur_index_block = meta_entry->index_block +
|
|
|
|
msblk->inode_table;
|
|
|
|
cur_offset = meta_entry->offset;
|
|
|
|
cur_data_block = meta_entry->data_block;
|
|
|
|
TRACE("get_meta_index: offset %d, meta->offset %d, "
|
|
|
|
"meta->entries %d\n", offset, meta->offset,
|
|
|
|
meta->entries);
|
|
|
|
TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
|
|
|
|
" data_block 0x%llx\n", cur_index_block,
|
|
|
|
cur_offset, cur_data_block);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If necessary grow cache slot by reading block list. Cache
|
|
|
|
* slot is extended up to index or to the end of the slot, in
|
|
|
|
* which case further slots will be used.
|
|
|
|
*/
|
|
|
|
for (i = meta->offset + meta->entries; i <= index &&
|
|
|
|
i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
|
|
|
|
int blocks = skip * SQUASHFS_META_INDEXES;
|
|
|
|
long long res = read_indexes(inode->i_sb, blocks,
|
|
|
|
&cur_index_block, &cur_offset);
|
|
|
|
|
|
|
|
if (res < 0) {
|
|
|
|
if (meta->entries == 0)
|
|
|
|
/*
|
|
|
|
* Don't leave an empty slot on read
|
|
|
|
* error allocated to this inode...
|
|
|
|
*/
|
|
|
|
meta->inode_number = 0;
|
|
|
|
err = res;
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_data_block += res;
|
|
|
|
meta_entry = &meta->meta_entry[i - meta->offset];
|
|
|
|
meta_entry->index_block = cur_index_block -
|
|
|
|
msblk->inode_table;
|
|
|
|
meta_entry->offset = cur_offset;
|
|
|
|
meta_entry->data_block = cur_data_block;
|
|
|
|
meta->entries++;
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
|
|
|
|
meta->offset, meta->entries);
|
|
|
|
|
|
|
|
release_meta_index(inode, meta);
|
|
|
|
}
|
|
|
|
|
|
|
|
all_done:
|
|
|
|
*index_block = cur_index_block;
|
|
|
|
*index_offset = cur_offset;
|
|
|
|
*data_block = cur_data_block;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale cache index (cache slot entry) to index
|
|
|
|
*/
|
|
|
|
return offset * SQUASHFS_META_INDEXES * skip;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
release_meta_index(inode, meta);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the on-disk location and compressed size of the datablock
|
|
|
|
* specified by index. Fill_meta_index() does most of the work.
|
|
|
|
*/
|
|
|
|
static int read_blocklist(struct inode *inode, int index, u64 *block)
|
|
|
|
{
|
|
|
|
u64 start;
|
|
|
|
long long blks;
|
|
|
|
int offset;
|
|
|
|
__le32 size;
|
|
|
|
int res = fill_meta_index(inode, index, &start, &offset, block);
|
|
|
|
|
|
|
|
TRACE("read_blocklist: res %d, index %d, start 0x%llx, offset"
|
|
|
|
" 0x%x, block 0x%llx\n", res, index, start, offset,
|
|
|
|
*block);
|
|
|
|
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* res contains the index of the mapping returned by fill_meta_index(),
|
|
|
|
* this will likely be less than the desired index (because the
|
|
|
|
* meta_index cache works at a higher granularity). Read any
|
|
|
|
* extra block indexes needed.
|
|
|
|
*/
|
|
|
|
if (res < index) {
|
|
|
|
blks = read_indexes(inode->i_sb, index - res, &start, &offset);
|
|
|
|
if (blks < 0)
|
|
|
|
return (int) blks;
|
|
|
|
*block += blks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read length of block specified by index.
|
|
|
|
*/
|
|
|
|
res = squashfs_read_metadata(inode->i_sb, &size, &start, &offset,
|
|
|
|
sizeof(size));
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
2018-07-29 19:44:46 +00:00
|
|
|
return squashfs_block_size(size);
|
2009-01-05 08:46:24 +00:00
|
|
|
}
|
|
|
|
|
2018-08-01 17:38:43 +00:00
|
|
|
void squashfs_fill_page(struct page *page, struct squashfs_cache_entry *buffer, int offset, int avail)
|
|
|
|
{
|
|
|
|
int copied;
|
|
|
|
void *pageaddr;
|
|
|
|
|
|
|
|
pageaddr = kmap_atomic(page);
|
|
|
|
copied = squashfs_copy_data(pageaddr, buffer, offset, avail);
|
|
|
|
memset(pageaddr + copied, 0, PAGE_SIZE - copied);
|
|
|
|
kunmap_atomic(pageaddr);
|
|
|
|
|
|
|
|
flush_dcache_page(page);
|
|
|
|
if (copied == avail)
|
|
|
|
SetPageUptodate(page);
|
|
|
|
else
|
|
|
|
SetPageError(page);
|
|
|
|
}
|
|
|
|
|
2013-10-31 19:24:27 +00:00
|
|
|
/* Copy data into page cache */
|
|
|
|
void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
|
|
|
|
int bytes, int offset)
|
2009-01-05 08:46:24 +00:00
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
int i, mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
|
2013-10-31 19:24:27 +00:00
|
|
|
int start_index = page->index & ~mask, end_index = start_index | mask;
|
2009-01-05 08:46:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop copying datablock into pages. As the datablock likely covers
|
2016-04-01 12:29:48 +00:00
|
|
|
* many PAGE_SIZE pages (default block size is 128 KiB) explicitly
|
2009-01-05 08:46:24 +00:00
|
|
|
* grab the pages from the page cache, except for the page that we've
|
|
|
|
* been called to fill.
|
|
|
|
*/
|
|
|
|
for (i = start_index; i <= end_index && bytes > 0; i++,
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
bytes -= PAGE_SIZE, offset += PAGE_SIZE) {
|
2009-01-05 08:46:24 +00:00
|
|
|
struct page *push_page;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
int avail = buffer ? min_t(int, bytes, PAGE_SIZE) : 0;
|
2009-01-05 08:46:24 +00:00
|
|
|
|
|
|
|
TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);
|
|
|
|
|
|
|
|
push_page = (i == page->index) ? page :
|
|
|
|
grab_cache_page_nowait(page->mapping, i);
|
|
|
|
|
|
|
|
if (!push_page)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (PageUptodate(push_page))
|
|
|
|
goto skip_page;
|
|
|
|
|
2018-08-01 17:38:43 +00:00
|
|
|
squashfs_fill_page(push_page, buffer, offset, avail);
|
2009-01-05 08:46:24 +00:00
|
|
|
skip_page:
|
|
|
|
unlock_page(push_page);
|
|
|
|
if (i != page->index)
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
put_page(push_page);
|
2009-01-05 08:46:24 +00:00
|
|
|
}
|
2013-10-31 19:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Read datablock stored packed inside a fragment (tail-end packed block) */
|
2018-08-02 15:45:15 +00:00
|
|
|
static int squashfs_readpage_fragment(struct page *page, int expected)
|
2013-10-31 19:24:27 +00:00
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct squashfs_cache_entry *buffer = squashfs_get_fragment(inode->i_sb,
|
|
|
|
squashfs_i(inode)->fragment_block,
|
|
|
|
squashfs_i(inode)->fragment_size);
|
|
|
|
int res = buffer->error;
|
|
|
|
|
|
|
|
if (res)
|
|
|
|
ERROR("Unable to read page, block %llx, size %x\n",
|
|
|
|
squashfs_i(inode)->fragment_block,
|
|
|
|
squashfs_i(inode)->fragment_size);
|
|
|
|
else
|
2018-08-02 15:45:15 +00:00
|
|
|
squashfs_copy_cache(page, buffer, expected,
|
2013-10-31 19:24:27 +00:00
|
|
|
squashfs_i(inode)->fragment_offset);
|
|
|
|
|
|
|
|
squashfs_cache_put(buffer);
|
|
|
|
return res;
|
|
|
|
}
|
2009-01-05 08:46:24 +00:00
|
|
|
|
2018-08-02 15:45:15 +00:00
|
|
|
static int squashfs_readpage_sparse(struct page *page, int expected)
|
2013-10-31 19:24:27 +00:00
|
|
|
{
|
2018-08-02 15:45:15 +00:00
|
|
|
squashfs_copy_cache(page, NULL, expected, 0);
|
2009-01-05 08:46:24 +00:00
|
|
|
return 0;
|
2013-10-31 19:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int squashfs_readpage(struct file *file, struct page *page)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
int index = page->index >> (msblk->block_log - PAGE_SHIFT);
|
2013-10-31 19:24:27 +00:00
|
|
|
int file_end = i_size_read(inode) >> msblk->block_log;
|
2018-08-02 15:45:15 +00:00
|
|
|
int expected = index == file_end ?
|
|
|
|
(i_size_read(inode) & (msblk->block_size - 1)) :
|
|
|
|
msblk->block_size;
|
2013-10-31 19:24:27 +00:00
|
|
|
int res;
|
|
|
|
void *pageaddr;
|
|
|
|
|
|
|
|
TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
|
|
|
|
page->index, squashfs_i(inode)->start);
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
if (page->index >= ((i_size_read(inode) + PAGE_SIZE - 1) >>
|
|
|
|
PAGE_SHIFT))
|
2013-10-31 19:24:27 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (index < file_end || squashfs_i(inode)->fragment_block ==
|
|
|
|
SQUASHFS_INVALID_BLK) {
|
|
|
|
u64 block = 0;
|
|
|
|
int bsize = read_blocklist(inode, index, &block);
|
|
|
|
if (bsize < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
if (bsize == 0)
|
2018-08-02 15:45:15 +00:00
|
|
|
res = squashfs_readpage_sparse(page, expected);
|
2013-10-31 19:24:27 +00:00
|
|
|
else
|
2018-08-02 15:45:15 +00:00
|
|
|
res = squashfs_readpage_block(page, block, bsize, expected);
|
2013-10-31 19:24:27 +00:00
|
|
|
} else
|
2018-08-02 15:45:15 +00:00
|
|
|
res = squashfs_readpage_fragment(page, expected);
|
2013-10-31 19:24:27 +00:00
|
|
|
|
|
|
|
if (!res)
|
|
|
|
return 0;
|
2009-01-05 08:46:24 +00:00
|
|
|
|
|
|
|
error_out:
|
|
|
|
SetPageError(page);
|
|
|
|
out:
|
2011-11-25 15:14:36 +00:00
|
|
|
pageaddr = kmap_atomic(page);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
memset(pageaddr, 0, PAGE_SIZE);
|
2011-11-25 15:14:36 +00:00
|
|
|
kunmap_atomic(pageaddr);
|
2009-01-05 08:46:24 +00:00
|
|
|
flush_dcache_page(page);
|
|
|
|
if (!PageError(page))
|
|
|
|
SetPageUptodate(page);
|
|
|
|
unlock_page(page);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const struct address_space_operations squashfs_aops = {
|
|
|
|
.readpage = squashfs_readpage
|
|
|
|
};
|