mirror of
https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git
synced 2025-09-08 17:18:05 -04:00
Fixed MTP to work with TWRP
This commit is contained in:
awab228
commit
f6dfaef42e
50820 changed files with 20846062 additions and 0 deletions
380
fs/isofs/compress.c
Normal file
380
fs/isofs/compress.c
Normal file
|
|
@ -0,0 +1,380 @@
|
|||
/* -*- linux-c -*- ------------------------------------------------------- *
|
||||
*
|
||||
* Copyright 2001 H. Peter Anvin - All Rights Reserved
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
|
||||
* USA; either version 2 of the License, or (at your option) any later
|
||||
* version; incorporated herein by reference.
|
||||
*
|
||||
* ----------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* linux/fs/isofs/compress.c
|
||||
*
|
||||
* Transparent decompression of files on an iso9660 filesystem
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/zlib.h>
|
||||
|
||||
#include "isofs.h"
|
||||
#include "zisofs.h"
|
||||
|
||||
/* This should probably be global. */
|
||||
static char zisofs_sink_page[PAGE_CACHE_SIZE];
|
||||
|
||||
/*
|
||||
* This contains the zlib memory allocation and the mutex for the
|
||||
* allocation; this avoids failures at block-decompression time.
|
||||
*/
|
||||
static void *zisofs_zlib_workspace;
|
||||
static DEFINE_MUTEX(zisofs_zlib_lock);
|
||||
|
||||
/*
|
||||
* Read data of @inode from @block_start to @block_end and uncompress
|
||||
* to one zisofs block. Store the data in the @pages array with @pcount
|
||||
* entries. Start storing at offset @poffset of the first page.
|
||||
*/
|
||||
static loff_t zisofs_uncompress_block(struct inode *inode, loff_t block_start,
|
||||
loff_t block_end, int pcount,
|
||||
struct page **pages, unsigned poffset,
|
||||
int *errp)
|
||||
{
|
||||
unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
|
||||
unsigned int bufsize = ISOFS_BUFFER_SIZE(inode);
|
||||
unsigned int bufshift = ISOFS_BUFFER_BITS(inode);
|
||||
unsigned int bufmask = bufsize - 1;
|
||||
int i, block_size = block_end - block_start;
|
||||
z_stream stream = { .total_out = 0,
|
||||
.avail_in = 0,
|
||||
.avail_out = 0, };
|
||||
int zerr;
|
||||
int needblocks = (block_size + (block_start & bufmask) + bufmask)
|
||||
>> bufshift;
|
||||
int haveblocks;
|
||||
blkcnt_t blocknum;
|
||||
struct buffer_head *bhs[needblocks + 1];
|
||||
int curbh, curpage;
|
||||
|
||||
if (block_size > deflateBound(1UL << zisofs_block_shift)) {
|
||||
*errp = -EIO;
|
||||
return 0;
|
||||
}
|
||||
/* Empty block? */
|
||||
if (block_size == 0) {
|
||||
for ( i = 0 ; i < pcount ; i++ ) {
|
||||
if (!pages[i])
|
||||
continue;
|
||||
memset(page_address(pages[i]), 0, PAGE_CACHE_SIZE);
|
||||
flush_dcache_page(pages[i]);
|
||||
SetPageUptodate(pages[i]);
|
||||
}
|
||||
return ((loff_t)pcount) << PAGE_CACHE_SHIFT;
|
||||
}
|
||||
|
||||
/* Because zlib is not thread-safe, do all the I/O at the top. */
|
||||
blocknum = block_start >> bufshift;
|
||||
memset(bhs, 0, (needblocks + 1) * sizeof(struct buffer_head *));
|
||||
haveblocks = isofs_get_blocks(inode, blocknum, bhs, needblocks);
|
||||
ll_rw_block(READ, haveblocks, bhs);
|
||||
|
||||
curbh = 0;
|
||||
curpage = 0;
|
||||
/*
|
||||
* First block is special since it may be fractional. We also wait for
|
||||
* it before grabbing the zlib mutex; odds are that the subsequent
|
||||
* blocks are going to come in in short order so we don't hold the zlib
|
||||
* mutex longer than necessary.
|
||||
*/
|
||||
|
||||
if (!bhs[0])
|
||||
goto b_eio;
|
||||
|
||||
wait_on_buffer(bhs[0]);
|
||||
if (!buffer_uptodate(bhs[0])) {
|
||||
*errp = -EIO;
|
||||
goto b_eio;
|
||||
}
|
||||
|
||||
stream.workspace = zisofs_zlib_workspace;
|
||||
mutex_lock(&zisofs_zlib_lock);
|
||||
|
||||
zerr = zlib_inflateInit(&stream);
|
||||
if (zerr != Z_OK) {
|
||||
if (zerr == Z_MEM_ERROR)
|
||||
*errp = -ENOMEM;
|
||||
else
|
||||
*errp = -EIO;
|
||||
printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n",
|
||||
zerr);
|
||||
goto z_eio;
|
||||
}
|
||||
|
||||
while (curpage < pcount && curbh < haveblocks &&
|
||||
zerr != Z_STREAM_END) {
|
||||
if (!stream.avail_out) {
|
||||
if (pages[curpage]) {
|
||||
stream.next_out = page_address(pages[curpage])
|
||||
+ poffset;
|
||||
stream.avail_out = PAGE_CACHE_SIZE - poffset;
|
||||
poffset = 0;
|
||||
} else {
|
||||
stream.next_out = (void *)&zisofs_sink_page;
|
||||
stream.avail_out = PAGE_CACHE_SIZE;
|
||||
}
|
||||
}
|
||||
if (!stream.avail_in) {
|
||||
wait_on_buffer(bhs[curbh]);
|
||||
if (!buffer_uptodate(bhs[curbh])) {
|
||||
*errp = -EIO;
|
||||
break;
|
||||
}
|
||||
stream.next_in = bhs[curbh]->b_data +
|
||||
(block_start & bufmask);
|
||||
stream.avail_in = min_t(unsigned, bufsize -
|
||||
(block_start & bufmask),
|
||||
block_size);
|
||||
block_size -= stream.avail_in;
|
||||
block_start = 0;
|
||||
}
|
||||
|
||||
while (stream.avail_out && stream.avail_in) {
|
||||
zerr = zlib_inflate(&stream, Z_SYNC_FLUSH);
|
||||
if (zerr == Z_BUF_ERROR && stream.avail_in == 0)
|
||||
break;
|
||||
if (zerr == Z_STREAM_END)
|
||||
break;
|
||||
if (zerr != Z_OK) {
|
||||
/* EOF, error, or trying to read beyond end of input */
|
||||
if (zerr == Z_MEM_ERROR)
|
||||
*errp = -ENOMEM;
|
||||
else {
|
||||
printk(KERN_DEBUG
|
||||
"zisofs: zisofs_inflate returned"
|
||||
" %d, inode = %lu,"
|
||||
" page idx = %d, bh idx = %d,"
|
||||
" avail_in = %ld,"
|
||||
" avail_out = %ld\n",
|
||||
zerr, inode->i_ino, curpage,
|
||||
curbh, stream.avail_in,
|
||||
stream.avail_out);
|
||||
*errp = -EIO;
|
||||
}
|
||||
goto inflate_out;
|
||||
}
|
||||
}
|
||||
|
||||
if (!stream.avail_out) {
|
||||
/* This page completed */
|
||||
if (pages[curpage]) {
|
||||
flush_dcache_page(pages[curpage]);
|
||||
SetPageUptodate(pages[curpage]);
|
||||
}
|
||||
curpage++;
|
||||
}
|
||||
if (!stream.avail_in)
|
||||
curbh++;
|
||||
}
|
||||
inflate_out:
|
||||
zlib_inflateEnd(&stream);
|
||||
|
||||
z_eio:
|
||||
mutex_unlock(&zisofs_zlib_lock);
|
||||
|
||||
b_eio:
|
||||
for (i = 0; i < haveblocks; i++)
|
||||
brelse(bhs[i]);
|
||||
return stream.total_out;
|
||||
}
|
||||
|
||||
/*
|
||||
* Uncompress data so that pages[full_page] is fully uptodate and possibly
|
||||
* fills in other pages if we have data for them.
|
||||
*/
|
||||
static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
|
||||
struct page **pages)
|
||||
{
|
||||
loff_t start_off, end_off;
|
||||
loff_t block_start, block_end;
|
||||
unsigned int header_size = ISOFS_I(inode)->i_format_parm[0];
|
||||
unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
|
||||
unsigned int blockptr;
|
||||
loff_t poffset = 0;
|
||||
blkcnt_t cstart_block, cend_block;
|
||||
struct buffer_head *bh;
|
||||
unsigned int blkbits = ISOFS_BUFFER_BITS(inode);
|
||||
unsigned int blksize = 1 << blkbits;
|
||||
int err;
|
||||
loff_t ret;
|
||||
|
||||
BUG_ON(!pages[full_page]);
|
||||
|
||||
/*
|
||||
* We want to read at least 'full_page' page. Because we have to
|
||||
* uncompress the whole compression block anyway, fill the surrounding
|
||||
* pages with the data we have anyway...
|
||||
*/
|
||||
start_off = page_offset(pages[full_page]);
|
||||
end_off = min_t(loff_t, start_off + PAGE_CACHE_SIZE, inode->i_size);
|
||||
|
||||
cstart_block = start_off >> zisofs_block_shift;
|
||||
cend_block = (end_off + (1 << zisofs_block_shift) - 1)
|
||||
>> zisofs_block_shift;
|
||||
|
||||
WARN_ON(start_off - (full_page << PAGE_CACHE_SHIFT) !=
|
||||
((cstart_block << zisofs_block_shift) & PAGE_CACHE_MASK));
|
||||
|
||||
/* Find the pointer to this specific chunk */
|
||||
/* Note: we're not using isonum_731() here because the data is known aligned */
|
||||
/* Note: header_size is in 32-bit words (4 bytes) */
|
||||
blockptr = (header_size + cstart_block) << 2;
|
||||
bh = isofs_bread(inode, blockptr >> blkbits);
|
||||
if (!bh)
|
||||
return -EIO;
|
||||
block_start = le32_to_cpu(*(__le32 *)
|
||||
(bh->b_data + (blockptr & (blksize - 1))));
|
||||
|
||||
while (cstart_block < cend_block && pcount > 0) {
|
||||
/* Load end of the compressed block in the file */
|
||||
blockptr += 4;
|
||||
/* Traversed to next block? */
|
||||
if (!(blockptr & (blksize - 1))) {
|
||||
brelse(bh);
|
||||
|
||||
bh = isofs_bread(inode, blockptr >> blkbits);
|
||||
if (!bh)
|
||||
return -EIO;
|
||||
}
|
||||
block_end = le32_to_cpu(*(__le32 *)
|
||||
(bh->b_data + (blockptr & (blksize - 1))));
|
||||
if (block_start > block_end) {
|
||||
brelse(bh);
|
||||
return -EIO;
|
||||
}
|
||||
err = 0;
|
||||
ret = zisofs_uncompress_block(inode, block_start, block_end,
|
||||
pcount, pages, poffset, &err);
|
||||
poffset += ret;
|
||||
pages += poffset >> PAGE_CACHE_SHIFT;
|
||||
pcount -= poffset >> PAGE_CACHE_SHIFT;
|
||||
full_page -= poffset >> PAGE_CACHE_SHIFT;
|
||||
poffset &= ~PAGE_CACHE_MASK;
|
||||
|
||||
if (err) {
|
||||
brelse(bh);
|
||||
/*
|
||||
* Did we finish reading the page we really wanted
|
||||
* to read?
|
||||
*/
|
||||
if (full_page < 0)
|
||||
return 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
block_start = block_end;
|
||||
cstart_block++;
|
||||
}
|
||||
|
||||
if (poffset && *pages) {
|
||||
memset(page_address(*pages) + poffset, 0,
|
||||
PAGE_CACHE_SIZE - poffset);
|
||||
flush_dcache_page(*pages);
|
||||
SetPageUptodate(*pages);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* When decompressing, we typically obtain more than one page
|
||||
* per reference. We inject the additional pages into the page
|
||||
* cache as a form of readahead.
|
||||
*/
|
||||
static int zisofs_readpage(struct file *file, struct page *page)
|
||||
{
|
||||
struct inode *inode = file_inode(file);
|
||||
struct address_space *mapping = inode->i_mapping;
|
||||
int err;
|
||||
int i, pcount, full_page;
|
||||
unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
|
||||
unsigned int zisofs_pages_per_cblock =
|
||||
PAGE_CACHE_SHIFT <= zisofs_block_shift ?
|
||||
(1 << (zisofs_block_shift - PAGE_CACHE_SHIFT)) : 0;
|
||||
struct page *pages[max_t(unsigned, zisofs_pages_per_cblock, 1)];
|
||||
pgoff_t index = page->index, end_index;
|
||||
|
||||
end_index = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
|
||||
/*
|
||||
* If this page is wholly outside i_size we just return zero;
|
||||
* do_generic_file_read() will handle this for us
|
||||
*/
|
||||
if (index >= end_index) {
|
||||
SetPageUptodate(page);
|
||||
unlock_page(page);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (PAGE_CACHE_SHIFT <= zisofs_block_shift) {
|
||||
/* We have already been given one page, this is the one
|
||||
we must do. */
|
||||
full_page = index & (zisofs_pages_per_cblock - 1);
|
||||
pcount = min_t(int, zisofs_pages_per_cblock,
|
||||
end_index - (index & ~(zisofs_pages_per_cblock - 1)));
|
||||
index -= full_page;
|
||||
} else {
|
||||
full_page = 0;
|
||||
pcount = 1;
|
||||
}
|
||||
pages[full_page] = page;
|
||||
|
||||
for (i = 0; i < pcount; i++, index++) {
|
||||
if (i != full_page)
|
||||
pages[i] = grab_cache_page_nowait(mapping, index);
|
||||
if (pages[i]) {
|
||||
ClearPageError(pages[i]);
|
||||
kmap(pages[i]);
|
||||
}
|
||||
}
|
||||
|
||||
err = zisofs_fill_pages(inode, full_page, pcount, pages);
|
||||
|
||||
/* Release any residual pages, do not SetPageUptodate */
|
||||
for (i = 0; i < pcount; i++) {
|
||||
if (pages[i]) {
|
||||
flush_dcache_page(pages[i]);
|
||||
if (i == full_page && err)
|
||||
SetPageError(pages[i]);
|
||||
kunmap(pages[i]);
|
||||
unlock_page(pages[i]);
|
||||
if (i != full_page)
|
||||
page_cache_release(pages[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/* At this point, err contains 0 or -EIO depending on the "critical" page */
|
||||
return err;
|
||||
}
|
||||
|
||||
const struct address_space_operations zisofs_aops = {
|
||||
.readpage = zisofs_readpage,
|
||||
/* No sync_page operation supported? */
|
||||
/* No bmap operation supported */
|
||||
};
|
||||
|
||||
int __init zisofs_init(void)
|
||||
{
|
||||
zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
|
||||
if ( !zisofs_zlib_workspace )
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void zisofs_cleanup(void)
|
||||
{
|
||||
vfree(zisofs_zlib_workspace);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue