>From 19c055d73cee8e65f8c24393450014b3560a8c6a Mon Sep 17 00:00:00 2001
From: Manish Sharma <manishrma(a)gmail.com>
Date: Mon, 1 Apr 2013 12:52:35 +0530
Subject: [RFC PATCH 1/1] Dual Squashfs: multicore implementation
The basic idea includes getting big requests by using readpages and
then decompressing two blocks on each core.
This implementation gives 50% improvement for the sequential file reads.
1.Split the two chunks based on the squashfs block size in readpages
2.Removed the locks of the decompressor(zlib/lzo) for percpu.
3.Increase the number of the data cache to per cpu.
Points to consider:-
1. Need a lot of memory for the mutiple cache & multiple workspaces.
2. All the cpu will be too busy to process all the requests. cpu %usage
increase.
3. Own queue method is implemented can be replaced with workqueues.
4. percpu data strucutures can be used.
Signed-off-by: Manish Sharma <manishrma(a)gmail.com>
---
fs/squashfs/Kconfig | 23 +++
fs/squashfs/Makefile | 1 +
fs/squashfs/file.c | 250 ++++++++++++++++++++++++++++
fs/squashfs/lzo_wrapper.c | 113 ++++++++++++-
fs/squashfs/squashfs_fs_sb.h | 6 +-
fs/squashfs/super.c | 59 ++++++-
fs/squashfs/tegra_mp.c | 368
++++++++++++++++++++++++++++++++++++++++++
fs/squashfs/tegra_mp.h | 58 +++++++
fs/squashfs/zlib_wrapper.c | 160 +++++++++++++++++-
9 files changed, 1030 insertions(+), 8 deletions(-)
create mode 100644 fs/squashfs/tegra_mp.c
create mode 100644 fs/squashfs/tegra_mp.h
diff --git a/fs/squashfs/Kconfig b/fs/squashfs/Kconfig
index c70111e..ffcf730 100644
--- a/fs/squashfs/Kconfig
+++ b/fs/squashfs/Kconfig
@@ -121,3 +121,26 @@ config SQUASHFS_FRAGMENT_CACHE_SIZE
Note there must be at least one cached fragment. Anything
much more than three will probably not make much difference.
+
+config SQUASHFS_READPAGES_ENABLE
+ bool "Enable Readpages for Squashfs"
+ depends on SQUASHFS
+ default n
+ help
+ Saying Y here enables readpages functionality.
+ If unsure, say N.
+
+config SQUASHFS_MPCORE
+ bool "Include Multi Core support in SquashFS file systems"
+ depends on SQUASHFS && SQUASHFS_READPAGES_ENABLE
+ default n
+ select SQUASHFS_4K_DEVBLK_SIZE
+ select TEGRA_MPCORE
+ help
+ Saying Y here includes support for Multi Core in SquashFS file
systems
+ Multi Core supports creates the different kernel threads to improve
the
+ SquashFS boot time performance.
+ This implementation is independent of the TEGRA board anyway as of
now.
+ If unsure, say N.
+
+
diff --git a/fs/squashfs/Makefile b/fs/squashfs/Makefile
index 110b047..0b99517 100644
--- a/fs/squashfs/Makefile
+++ b/fs/squashfs/Makefile
@@ -9,3 +9,4 @@ squashfs-$(CONFIG_SQUASHFS_XATTR) += xattr.o xattr_id.o
squashfs-$(CONFIG_SQUASHFS_LZO) += lzo_wrapper.o
squashfs-$(CONFIG_SQUASHFS_XZ) += xz_wrapper.o
squashfs-$(CONFIG_SQUASHFS_ZLIB) += zlib_wrapper.o
+squashfs-$(CONFIG_SQUASHFS_MPCORE) += tegra_mp.o
diff --git a/fs/squashfs/file.c b/fs/squashfs/file.c
index 8ca62c2..c134e13 100644
--- a/fs/squashfs/file.c
+++ b/fs/squashfs/file.c
@@ -38,6 +38,11 @@
* 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.
+ *
+ * manish.s2(a)samsung.com
+ * Added support for readpages for getting the bigger requests.
+ * Added Multithread support for the bigger chunks > squashfs block size
+ *
*/
#include <linux/fs.h>
@@ -53,6 +58,22 @@
#include "squashfs_fs_i.h"
#include "squashfs.h"
+#ifdef CONFIG_SQUASHFS_MPCORE
+#include "tegra_mp.h"
+
+
+extern struct squashfs_queue *to_reader_1;
+#endif /* CONFIG_SQUASHFS_MPCORE*/
+
+
+
+#ifdef CONFIG_SQUASHFS_READPAGES_ENABLE
+#define list_to_page(head) (list_entry((head)->prev, struct page, lru))
+#define list_to_page_index(pos, head, index) \
+ for (pos = list_entry((head)->prev, struct page, lru);
pos->index != index;\
+ pos = list_entry((pos)->prev, struct page, lru))
+#endif
+
/*
* Locate cache slot in range [offset, index] for specified inode. If
* there's more than one return the slot closest to index.
@@ -494,8 +515,237 @@ out:
return 0;
}
+#ifdef CONFIG_SQUASHFS_READPAGES_ENABLE
+
+/*
+ * copy of squashfs_readpage function for
+ * supports
+ * readpages & Multicore implementation
+ */
+int read_this_page(struct file *file, struct page *page)
+{
+ struct inode *inode = page->mapping->host;
+ struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
+ int bytes, i, offset = 0, sparse = 0;
+ struct squashfs_cache_entry *buffer = NULL;
+ void *pageaddr;
+
+ int mask = (1 << (msblk->block_log - PAGE_CACHE_SHIFT)) - 1;
+ int index = page->index >> (msblk->block_log - PAGE_CACHE_SHIFT);
+ int start_index = page->index & ~mask;
+ int end_index = start_index | mask;
+ int file_end = i_size_read(inode) >> msblk->block_log;
+
+ TRACE("Entered read_this_page, page index %lx, start block %llx\n",
+ page->index, squashfs_i(inode)->start);
+
+
+ if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
+ PAGE_CACHE_SHIFT)){
+ goto out;
+ }
+
+ if (index < file_end || squashfs_i(inode)->fragment_block ==
+ SQUASHFS_INVALID_BLK) {
+ /*
+ * Reading a datablock from disk. Need to read block list
+ * to get location and block size.
+ */
+ u64 block = 0;
+ int bsize = read_blocklist(inode, index, &block);
+ if (bsize < 0)
+ goto error_out;
+
+
+ if (bsize == 0) { /* hole */
+ bytes = index == file_end ?
+ (i_size_read(inode) & (msblk->block_size - 1)) :
+ msblk->block_size;
+ sparse = 1;
+ } else {
+ /*
+ * Read and decompress datablock.
+ */
+ buffer = squashfs_get_datablock(inode->i_sb,
+ block, bsize);
+ if (buffer->error) {
+ ERROR("Unable to read page, block %llx, size %x"
+ "\n", block, bsize);
+ squashfs_cache_put(buffer);
+ goto error_out;
+ }
+ bytes = buffer->length;
+ }
+ } else {
+ /*
+ * Datablock is stored inside a fragment (tail-end packed
+ * block).
+ */
+ buffer = squashfs_get_fragment(inode->i_sb,
+ squashfs_i(inode)->fragment_block,
+ squashfs_i(inode)->fragment_size);
+
+ if (buffer->error) {
+ ERROR("Unable to read page, block %llx, size %x\n",
+ squashfs_i(inode)->fragment_block,
+ squashfs_i(inode)->fragment_size);
+ squashfs_cache_put(buffer);
+ goto error_out;
+ }
+ bytes = i_size_read(inode) & (msblk->block_size - 1);
+ offset = squashfs_i(inode)->fragment_offset;
+ }
+
+ /*
+ * Loop copying datablock into pages. As the datablock likely covers
+ * many PAGE_CACHE_SIZE pages (default block size is 128 KiB)
explicitly
+ * 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++,
+ bytes -= PAGE_CACHE_SIZE, offset += PAGE_CACHE_SIZE) {
+ struct page *push_page;
+ int avail = sparse ? 0 : min_t(int, bytes, PAGE_CACHE_SIZE);
+
+ 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;
+
+ pageaddr = kmap_atomic(push_page);
+ squashfs_copy_data(pageaddr, buffer, offset, avail);
+ memset(pageaddr + avail, 0, PAGE_CACHE_SIZE - avail);
+ kunmap_atomic(pageaddr);
+ flush_dcache_page(push_page);
+ SetPageUptodate(push_page);
+skip_page:
+ unlock_page(push_page);
+ if (i != page->index)
+ page_cache_release(push_page);
+ }
+
+ if (!sparse)
+ squashfs_cache_put(buffer);
+#ifdef CONFIG_SQUASHFS_MPCORE
+ page_cache_release(page);
+#endif
+
+ return 0;
+
+error_out:
+ SetPageError(page);
+out:
+ pageaddr = kmap_atomic(page);
+ memset(pageaddr, 0, PAGE_CACHE_SIZE);
+ kunmap_atomic(pageaddr);
+ flush_dcache_page(page);
+ if (!PageError(page))
+ SetPageUptodate(page);
+ unlock_page(page);
+
+ return 0;
+}
+
+/*
+ * readpages implementation and Multi Core implementation
+ * for squashfs
+ *
+ */
+static int squashfs_readpages(struct file *filp, struct address_space
*mapping,
+ struct list_head *pages, unsigned nr_pages)
+{
+ unsigned page_idx;
+
+
+#ifdef CONFIG_SQUASHFS_MPCORE
+ unsigned first_page_idx;
+ int err;
+ unsigned long index = 0;
+ struct squashfs_sb_info *msblk =
filp->f_path.dentry->d_inode->i_sb->s_fs_info;
+ unsigned int pages_per_block;
+
+ pages_per_block = (msblk->block_size/(PAGE_CACHE_SIZE));
+
+#ifdef DEBUG
+ printk(KERN_EMERG"[%d]%s %d %d Ino %lu \n", current->pid,
__FUNCTION__, nr_pages, pages_per_block,
filp->f_path.dentry->d_inode->i_ino);
+#endif
+
+ if (nr_pages > pages_per_block) {
+
+ /*Here we will grab the page and put into queue */
+ for (first_page_idx = 0, page_idx = 0; page_idx < nr_pages; ) {
+
+ struct page *page = NULL;
+
+ if (first_page_idx == page_idx) {
+ page = list_to_page(pages);
+ prefetchw(&page->flags);
+ list_del(&page->lru);
+ /* Add this page to page-cache */
+ /*err = add_to_page_cache_lru(page, mapping,
page->index, GFP_KERNEL);*/
+ err = add_to_page_cache(page, mapping, page->index,
GFP_KERNEL);
+ if (unlikely(err)) {
+ /*printk(KERN_EMERG "releasing page cache \n");*/
+ page_cache_release(page);
+ page_idx += 1;
+ first_page_idx = page_idx;
+ continue;
+ }
+ page_idx += pages_per_block;
+ index = page->index;
+ if (queue_put(to_reader_1, filp, page))
+ break;
+ } else {
+
+ page = grab_cache_page_nowait(mapping, (index +
page_idx));
+ if (unlikely(!page)) {
+ /*Need to do error checking here*/
+ page_idx += 1;
+ continue;
+ /*return -ENOMEM;*/
+ } else {
+ page_idx += pages_per_block;
+ queue_put(to_reader_1, filp, page);
+ }
+
+ }
+
+ }
+
+ work_on_queue(to_reader_1);
+ } else
+
+#endif /* CONFIG_SQUASHFS_MPCORE */
+ {
+ /* readpages Implementation */
+ for (page_idx = 0; page_idx < nr_pages; page_idx++) {
+ struct page *page = list_to_page(pages);
+ prefetchw(&page->flags);
+ list_del(&page->lru);
+ /*if (!add_to_page_cache_lru(page, mapping,
page->index, GFP_KERNEL)) {*/
+ if (!add_to_page_cache(page, mapping, page->index,
GFP_KERNEL)) {
+ squashfs_readpage(filp, page);
+ }
+ page_cache_release(page);
+ }
+ }
+
+
+ /*always return 0 as readpages either writes to a page or release it*/
+ return 0;
+}
+#endif
const struct address_space_operations squashfs_aops = {
+#ifdef CONFIG_SQUASHFS_READPAGES_ENABLE
+ .readpages = squashfs_readpages,
+#endif
.readpage = squashfs_readpage
};
diff --git a/fs/squashfs/lzo_wrapper.c b/fs/squashfs/lzo_wrapper.c
index 00f4dfc..4bcdf64 100644
--- a/fs/squashfs/lzo_wrapper.c
+++ b/fs/squashfs/lzo_wrapper.c
@@ -37,7 +37,114 @@ struct squashfs_lzo {
void *output;
};
-static void *lzo_init(struct squashfs_sb_info *msblk, void *buff, int len)
+#ifdef CONFIG_SQUASHFS_MPCORE
+static void *lzo_init(struct squashfs_sb_info *msblk)
+{
+ unsigned int i = 0;
+ int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE);
+ unsigned int processors = num_online_cpus();
+
+ /* Initialization of the lzo streams */
+ struct squashfs_lzo *stream = kmalloc(processors * sizeof(stream),
GFP_KERNEL);
+ if (NULL == stream) {
+ ERROR("Failed to allocate zlib stream\n");
+ goto failed;
+ }
+ for_each_online_cpu(i) {
+ stream[i].input = vmalloc(block_size);
+ if (stream[i].input == NULL)
+ goto failed;
+ stream[i].output = vmalloc(block_size);
+ if (stream[i].output == NULL)
+ goto failed;
+ }
+ return stream;
+
+failed:
+ ERROR("Failed to allocate lzo workspace\n");
+ i = 0;
+ for_each_online_cpu(i) {
+ if (stream[i].input)
+ vfree(stream[i].input);
+ }
+ if (stream)
+ kfree(stream);
+ return NULL;
+}
+
+
+static void lzo_free(void *strm)
+{
+ unsigned int i = 0;
+ struct squashfs_lzo *stream = strm;
+
+ if (stream) {
+ for_each_online_cpu(i) {
+ if (stream[i].input)
+ vfree(stream[i].input);
+ if (stream[i].output)
+ vfree(stream[i].output);
+ }
+ kfree(stream);
+ }
+ strm = NULL;
+}
+
+static int lzo_uncompress(struct squashfs_sb_info *msblk, void **buffer,
+ struct buffer_head **bh, int b, int offset, int length, int srclength,
+ int pages)
+{
+ unsigned int pid = smp_processor_id();
+ struct squashfs_lzo *stream = msblk->stream;
+ void *buff = stream[pid].input;
+ int avail, i, bytes = length, res;
+ size_t out_len = srclength;
+
+ mutex_lock(&msblk->read_data_mutex[pid]);
+
+ for (i = 0; i < b; i++) {
+ wait_on_buffer(bh[i]);
+ if (!buffer_uptodate(bh[i]))
+ goto block_release;
+
+ avail = min(bytes, msblk->devblksize - offset);
+ memcpy(buff, bh[i]->b_data + offset, avail);
+ buff += avail;
+ bytes -= avail;
+ offset = 0;
+ put_bh(bh[i]);
+ }
+
+ res = lzo1x_decompress_safe(stream[pid].input, (size_t)length,
+ stream[pid].output, &out_len);
+ if (res != LZO_E_OK)
+ goto failed;
+
+ res = bytes = (int)out_len;
+ for (i = 0, buff = stream[pid].output; bytes && i < pages; i++) {
+ avail = min_t(int, bytes, PAGE_CACHE_SIZE);
+ memcpy(buffer[i], buff, avail);
+ buff += avail;
+ bytes -= avail;
+ }
+
+ mutex_unlock(&msblk->read_data_mutex[pid]);
+ return res;
+
+block_release:
+ for (; i < b; i++)
+ put_bh(bh[i]);
+
+failed:
+ mutex_unlock(&msblk->read_data_mutex[pid]);
+
+ ERROR("lzo decompression failed, data probably corrupt\n");
+ return -EIO;
+}
+
+#else /* MPCORE*/
+
+static void *lzo_init(struct squashfs_sb_info *msblk)
{
int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE);
@@ -58,7 +165,7 @@ failed2:
failed:
ERROR("Failed to allocate lzo workspace\n");
kfree(stream);
- return ERR_PTR(-ENOMEM);
+ return NULL;
}
@@ -125,6 +232,8 @@ failed:
return -EIO;
}
+#endif /*MPCORE*/
+
const struct squashfs_decompressor squashfs_lzo_comp_ops = {
.init = lzo_init,
.free = lzo_free,
diff --git a/fs/squashfs/squashfs_fs_sb.h b/fs/squashfs/squashfs_fs_sb.h
index 52934a2..bd39cd5 100644
--- a/fs/squashfs/squashfs_fs_sb.h
+++ b/fs/squashfs/squashfs_fs_sb.h
@@ -63,7 +63,11 @@ struct squashfs_sb_info {
__le64 *id_table;
__le64 *fragment_index;
__le64 *xattr_id_table;
- struct mutex read_data_mutex;
+#ifdef CONFIG_SQUASHFS_MPCORE
+ struct mutex *read_data_mutex;
+#else
+ struct mutex read_data_mutex;
+#endif /*MPCORE*/
struct mutex meta_index_mutex;
struct meta_index *meta_index;
void *stream;
diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index 260e392..2484a67 100644
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -25,6 +25,8 @@
* This file implements code to read the superblock, read and initialise
* in-memory structures at mount time, and all the VFS glue code to
register
* the filesystem.
+ * manish.s2 : added support for multicore
+ * : Added generic decompression selection with multicore
*/
#include <linux/fs.h>
@@ -43,6 +45,9 @@
#include "squashfs.h"
#include "decompressor.h"
#include "xattr.h"
+#ifdef CONFIG_SQUASHFS_MPCORE
+#include "tegra_mp.h"
+#endif
static struct file_system_type squashfs_fs_type;
static const struct super_operations squashfs_super_ops;
@@ -85,7 +90,10 @@ static int squashfs_fill_super(struct super_block *sb,
void *data, int silent)
unsigned int fragments;
u64 lookup_table_start, xattr_id_table_start, next_table;
int err;
-
+#ifdef CONFIG_SQUASHFS_MPCORE
+ unsigned int i = 0;
+ unsigned int processors = num_online_cpus();
+#endif
TRACE("Entered squashfs_fill_superblock\n");
sb->s_fs_info = kzalloc(sizeof(*msblk), GFP_KERNEL);
@@ -98,7 +106,20 @@ static int squashfs_fill_super(struct super_block *sb,
void *data, int silent)
msblk->devblksize = sb_min_blocksize(sb, SQUASHFS_DEVBLK_SIZE);
msblk->devblksize_log2 = ffz(~msblk->devblksize);
+#ifdef CONFIG_SQUASHFS_MPCORE
+ /* Initialization of mutex for each core */
+ i = 0;
+ msblk->read_data_mutex = kmalloc((processors)*sizeof(struct mutex),
GFP_KERNEL);
+ if (NULL == msblk->read_data_mutex) {
+ ERROR("unable to allocate Mutex Mem \n");
+ goto failed_mount;
+ }
+ for_each_online_cpu(i) {
+ mutex_init(&msblk->read_data_mutex[i]);
+ }
+#else /*MPCORE */
mutex_init(&msblk->read_data_mutex);
+#endif /*MPCORE */
mutex_init(&msblk->meta_index_mutex);
/*
@@ -205,13 +226,21 @@ static int squashfs_fill_super(struct super_block
*sb, void *data, int silent)
if (msblk->block_cache == NULL)
goto failed_mount;
+#ifdef CONFIG_SQUASHFS_MPCORE
+ /* Allocate read_page block */
+ msblk->read_page = squashfs_cache_init("data", processors,
(msblk->block_size));
+ if (msblk->read_page == NULL) {
+ ERROR("Failed to allocate read_page block\n");
+ goto failed_mount;
+ }
+#else
/* Allocate read_page block */
msblk->read_page = squashfs_cache_init("data", 1, msblk->block_size);
if (msblk->read_page == NULL) {
ERROR("Failed to allocate read_page block\n");
goto failed_mount;
}
-
+#endif
msblk->stream = squashfs_decompressor_init(sb, flags);
if (IS_ERR(msblk->stream)) {
err = PTR_ERR(msblk->stream);
@@ -446,7 +475,26 @@ static int __init init_squashfs_fs(void)
destroy_inodecache();
return err;
}
-
+#ifdef CONFIG_SQUASHFS_MPCORE
+/*M.S the size of different cache */
+/*fragment_buffer_size = msblk->block_size;
+data_buffer_size = msblk->block_size;
+metadata_buffer_size = SQUASHFS_METADATA_SIZE;
+queue_buffer_size = data_buffer_size;
+pages_per_block = (msblk->block_size/(PAGE_CACHE_SIZE));*/
+/*
+* queue_buffer_size = fragment_buffer_size + data_buffer_size +
metadata_buffer_size;
+* M.S :- As of now we don't need that much big size of queue
+* 1. we are currently working on offsets equal to number of pages in the
block size
+* so we will take the size of the queue equal to data_buffer_size only
+* 2. The metadata requests are same as previous no threading.
+* 3. We reduced the queue size further to 64
+* As of now max queue request will not be more than 64.
+*/
+/* M.S Adding Threads here */
+initialise_threads(SQFS_QBUFFER_SIZE);
+
+#endif
printk(KERN_INFO "squashfs: version 4.0 (2009/01/31) "
"Phillip Lougher\n");
@@ -456,6 +504,11 @@ static int __init init_squashfs_fs(void)
static void __exit exit_squashfs_fs(void)
{
+#ifdef CONFIG_SQUASHFS_MPCORE
+ printk(KERN_INFO"%s \n", __FUNCTION__);
+ /*MS Adding the exiting code */
+ exit_threads();
+#endif
unregister_filesystem(&squashfs_fs_type);
destroy_inodecache();
}
diff --git a/fs/squashfs/tegra_mp.c b/fs/squashfs/tegra_mp.c
new file mode 100644
index 0000000..1d7e03f
--- /dev/null
+++ b/fs/squashfs/tegra_mp.c
@@ -0,0 +1,368 @@
+/**
+* @file: tegra_mp.c
+* @brief: Multi Core support for squashFS
+* Copyright: Copyright(C) Samsung India Pvt. Ltd 2011. All Rights
Reserved.
+* @author: SISC: manish.s2
+* @date: 2011/03/10
+* @History:
+* v1.1a is stable & support dual core.
+* v1.2 added multi core support.
+* v1.8 Fix the bug for the queue fill ptr overrun
+*/
+
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#include <linux/cpumask.h>
+#include <linux/cpu.h>
+#include <linux/slab.h>
+
+#include "squashfs_fs_i.h"
+#include "squashfs.h"
+#include "tegra_mp.h"
+
+
+struct squashfs_queue *to_reader_1;
+static struct task_struct **thread;
+
+extern int read_this_page(struct file *file, struct page *page);
+
+int queue_fini(struct squashfs_queue *queue)
+{
+
+ if (queue == NULL) {
+ printk(KERN_INFO "ERROR: Wrong queue ptr\n");
+ return -EFAULT;
+ }
+
+
+ if (NULL != queue->data) {
+ kfree(queue->data);
+ queue->data = NULL;
+ }
+
+ if (NULL != queue->cpu) {
+ kfree(queue->cpu);
+ queue = NULL;
+ }
+ if (NULL != queue) {
+ kfree(queue);
+ queue = NULL;
+ }
+
+ return 0;
+}
+
+struct squashfs_queue *queue_init(int size)
+{
+
+ unsigned int i = 0;
+ int processors;
+ struct squashfs_queue *queue = NULL;
+
+#ifdef DEBUG
+ printk(KERN_INFO "[%s] size %d \n", __FUNCTION__, size + 1);
+#endif
+
+ processors = num_online_cpus();
+
+ queue = (struct squashfs_queue *)kmalloc(sizeof(struct
squashfs_queue), GFP_KERNEL);
+ if (queue == NULL) {
+ printk(KERN_INFO "Out of memory in queue_init\n");
+ return NULL;
+ }
+
+ queue->data = (struct squashfs_qdata *)kmalloc((sizeof(struct
squashfs_qdata) * (size + 1)), GFP_KERNEL);
+ if (NULL == queue->data) {
+ printk(KERN_INFO "unable to get the memory \n");
+ queue_fini(queue);
+ return NULL;
+ }
+
+ queue->cpu = kmalloc(processors * (sizeof(int)), GFP_KERNEL);
+ if (NULL == queue->cpu) {
+ printk(KERN_INFO "unable to get the memory for cpu \n");
+ queue_fini(queue);
+ return NULL;
+ }
+
+
+ for_each_online_cpu(i) {
+ queue->cpu[i] = 0;
+ }
+
+ queue->size = size + 1;
+ queue->readp = queue->writep = 0;
+ queue->empty = 1;
+ queue->full = 0;
+ queue->stop = 0;
+ init_waitqueue_head(&queue->wait_queue);
+ spin_lock_init(&queue->lock);
+
+ return queue;
+}
+
+
+int queue_put(struct squashfs_queue *queue, void *filp, void *page)
+{
+ int processor_id = 0;
+ unsigned int i = 0;
+ spin_lock(&queue->lock);
+
+ processor_id = raw_smp_processor_id();
+
+ if (((queue->writep + 1) % queue->size) == queue->readp) {
+#ifdef DEBUG
+ printk(KERN_INFO "[%d] Queue is full: page %lu \n", current->pid,
((struct page *)page)->index);
+#endif
+ queue->full = 1;
+ spin_unlock(&queue->lock);
+
+ for_each_online_cpu(i) {
+ if (i != processor_id) {
+ queue->cpu[i] = 1;
+ }
+
+ }
+ wake_up(&queue->wait_queue);
+ wait_event_timeout(queue->wait_queue, !queue->full,
msecs_to_jiffies(100));
+ spin_lock(&queue->lock);
+ if (((queue->writep + 1) % queue->size) == queue->readp) {
+#ifdef DEBUG
+ printk(KERN_EMERG "[%d] Queue is still full: page %lu \n",
current->pid, ((struct page *)page)->index);
+ printk(KERN_EMERG "[%d] Check threads \n", current->pid);
+#endif
+ spin_unlock(&queue->lock);
+ return -1;
+ }
+ processor_id = raw_smp_processor_id();
+ }
+
+ queue->data[queue->writep].filp = filp;
+ queue->data[queue->writep].page = page;
+ queue->writep = ((queue->writep + 1) % queue->size);
+ queue->empty = 0;
+
+#ifdef DEBUG
+ printk(KERN_EMERG "[%d]queue put w%d:r%d page %lu \n", current->pid,
queue->writep, queue->readp, ((struct page *)page)->index);
+#endif
+
+ for_each_online_cpu(i) {
+ if (i != processor_id) {
+ /*printk(KERN_INFO"waking up %d processor \n",i);*/
+ queue->cpu[i] = 1;
+ }
+
+ }
+ spin_unlock(&queue->lock);
+ wake_up(&queue->wait_queue);
+ return 0;
+}
+
+
+int queue_get(struct squashfs_queue *queue, int id, struct squashfs_qdata
*data)
+{
+ /*struct squashfs_qdata *data;*/
+ int processor_id = 0;
+#ifdef DEBUG
+ printk(KERN_INFO "queue get %d \n", raw_smp_processor_id());
+#endif
+ spin_lock(&queue->lock);
+ processor_id = raw_smp_processor_id();
+
+ /* wait here if queue is empty */
+ if (queue->readp == queue->writep) {
+
+ if (1 == id) {
+ queue->empty = 1;
+ queue->full = 0;
+ spin_unlock(&queue->lock);
+ wake_up(&queue->wait_queue);
+ return -1;
+ }
+
+#ifdef DEBUG
+ printk(KERN_EMERG "[%d] Need to wait here as queue is empty
\n", current->pid);
+#endif
+ queue->empty = 1;
+ queue->full = 0;
+ queue->cpu[processor_id] = 0;
+ wake_up(&queue->wait_queue);
+ spin_unlock(&queue->lock);
+ wait_event_interruptible(queue->wait_queue,
queue->cpu[processor_id]);
+
+ /* After the thread gets out from wait queue */
+ spin_lock(&queue->lock);
+ if (queue->stop || (queue->readp == queue->writep)) {
+ queue->empty = 1;
+ queue->full = 0;
+ wake_up(&queue->wait_queue);
+ spin_unlock(&queue->lock);
+#ifdef DEBUG
+ printk(KERN_INFO " Thread%ld %s \n",
current->cpus_allowed, (queue->stop ? "should stop" : "queue is empty"));
+#endif
+ return -1;
+ }
+ }
+
+
+ data->filp = queue->data[queue->readp].filp;
+ data->page = queue->data[queue->readp].page;
+ queue->data[queue->readp].filp = NULL;
+ queue->data[queue->readp].page = NULL;
+ queue->readp = (queue->readp + 1) % queue->size;
+ queue->full = 0;
+#ifdef DEBUG
+ printk(KERN_EMERG "[%d]queue get w%d:r%d page %lu \n", \
+ current->pid, queue->writep, queue->readp, ((struct page
*)data->page)->index);
+#endif
+ spin_unlock(&queue->lock);
+ wake_up(&queue->wait_queue);
+
+
+ return 0;
+}
+
+
+
+void squashfs_thread(void *arg)
+{
+
+ struct squashfs_qdata data;
+ int ret = 0;
+
+ set_user_nice(current, -20);
+ printk(KERN_INFO "### Started squashfs thread_%d \n",
raw_smp_processor_id());
+ while (!kthread_should_stop()) {
+
+
+ ret = queue_get(to_reader_1, 0, &data);
+ if (unlikely(0 > ret)) {
+ if (to_reader_1->stop) {
+ printk(KERN_INFO"ERROR : We are seeing the stop being
set\n");
+ break;
+ } else {
+ continue;
+ }
+ } else {
+#ifdef DEBUG
+ /* Can remove this as its for error checking */
+ if ((NULL != data.filp) && (NULL != data.page)) {
+ printk(KERN_INFO "here it is page index %ld \n",
data.page->index);
+ read_this_page(data.filp, data.page);
+ } else {
+ printk(KERN_INFO"Ptr is NULL \n");
+ }
+#else
+ read_this_page(data.filp, data.page);
+#endif
+
+
+ }
+
+ }
+ printk(KERN_INFO"SquashFS Thread : I am dying!\n");
+
+}
+
+void squashfs_process_data(void)
+{
+
+ struct squashfs_qdata data;
+ int ret = 0;
+
+ while (1) {
+
+
+ ret = queue_get(to_reader_1, 1, &data);
+ if (unlikely(0 > ret)) {
+#ifdef DEBUG
+ printk(KERN_INFO "[%s][%d] Q is empty so we are exiting \n",
__FUNCTION__, current->pid);
+#endif
+ break;
+ } else {
+ read_this_page(data.filp, data.page);
+ }
+
+ }
+
+}
+
+void work_on_queue(struct squashfs_queue *queue)
+{
+ squashfs_process_data();
+}
+
+int initialise_threads(int queue_buffer_size)
+{
+ unsigned int i = 0;
+ int processors;
+
+ processors = num_online_cpus();
+
+#ifdef DEBUG
+ printk(KERN_INFO "no of active cores %d \n", processors);
+#endif
+
+ /* Initialize the Queue */
+ to_reader_1 = queue_init(queue_buffer_size);
+
+
+ if ((thread = kmalloc((NOTHR_THREADS + processors) * sizeof(struct
task_struct *), GFP_KERNEL)) == NULL) {
+ printk(KERN_INFO "Out of memory allocating thread descriptors\n");
+ return -ENOMEM;
+ }
+
+
+ /* Create Number n Number of Deflator threads same as core.*/
+ for_each_online_cpu(i) {
+ printk(KERN_INFO "Created %d thread \n", i);
+ thread[NOTHR_THREADS + i] = kthread_create((void
*)squashfs_thread, NULL, MODULE_NAME);
+ if (IS_ERR(thread[NOTHR_THREADS + i])) {
+ printk(KERN_ERR ": unable to start deflator kernel thread\n");
+ return -ENOMEM;
+ } else {
+ printk(KERN_INFO" ################## \n");
+ printk(KERN_INFO"Binding cpu %d \n", i);
+ kthread_bind(thread[NOTHR_THREADS + i], i);
+ wake_up_process(thread[NOTHR_THREADS + i]);
+ }
+ }
+
+
+ return 0;
+
+}
+
+void exit_threads()
+{
+ int i = 0;
+
+ /* wake up both threads */
+ to_reader_1->empty = 0;
+ to_reader_1->stop = 1;
+ for_each_online_cpu(i) {
+ to_reader_1->cpu[i] = 1;
+ }
+ wake_up_all(&to_reader_1->wait_queue);
+
+#if 0
+ for (i = NOTHR_THREADS; i < (NOTHR_THREADS + NR_CPUS); i++) {
+
+ if (NULL != thread[i])
+ kthread_stop(thread[i]);
+
+ }
+ if (thread)
+ kfree(thread);
+
+#endif
+ /* We have only one queue as of now */
+ if (queue_fini(to_reader_1))
+ printk(KERN_INFO"ERROR: In queue deallocation \n");
+
+
+}
+
diff --git a/fs/squashfs/tegra_mp.h b/fs/squashfs/tegra_mp.h
new file mode 100644
index 0000000..ca60c56
--- /dev/null
+++ b/fs/squashfs/tegra_mp.h
@@ -0,0 +1,58 @@
+/**
+* @file tegra_mp.h
+* @brief Multi Core support for squashFS
+* Copyright: Copyright(C) Samsung India Pvt. Ltd 2011. All Rights
Reserved.
+* @author SISC: manish.s2
+* @date 2011/03/10
+* @desc Added Multi core support in squashfs
+*/
+#ifndef __MP_TEGRA__
+#define __MP_TEGRA__
+
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/wait.h>
+
+/* Total number of other threads except if needed */
+/*#define NOTHR_THREADS 3 // To be used if we additional threads or
so.*/
+#define NOTHR_THREADS 0
+#define MODULE_NAME "tegra_mpcore"
+
+/* Max page pool size 64 and min squashfs block size 4k */
+#define SQFS_QBUFFER_SIZE (64)
+
+/*#define DEBUG*/
+
+struct squashfs_qdata{
+ struct file *filp;
+ struct page *page;
+ int index;
+};
+
+
+/* struct describing queues used to pass data between threads */
+struct squashfs_queue {
+ int size;
+ int readp;
+ int writep;
+ wait_queue_head_t wait_queue;
+ spinlock_t lock;
+
+ int empty;
+ int full;
+ int *cpu;
+ int stop;
+ struct squashfs_qdata *data;
+};
+
+
+/* Functions */
+int initialise_threads(int queue_buffer_size);
+void exit_threads(void);
+int queue_put(struct squashfs_queue *queue, void *filp, void *page);
+int queue_get(struct squashfs_queue *queue, int id, struct squashfs_qdata
*data);
+struct squashfs_queue *queue_init(int size);
+void work_on_queue(struct squashfs_queue *queue);
+
+#endif /*__MP_TEGRA__*/
diff --git a/fs/squashfs/zlib_wrapper.c b/fs/squashfs/zlib_wrapper.c
index 55d918f..5e8b0a1 100644
--- a/fs/squashfs/zlib_wrapper.c
+++ b/fs/squashfs/zlib_wrapper.c
@@ -19,7 +19,13 @@
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* zlib_wrapper.c
- */
+ * manish.s2: added the dual core support for squashfs.
+ * : Seperate mutex & z_stream for each core.
+ * : generalized for multicores.
+ * : Added seperate mutex and zlib stream for Multicore.
+ * : Replace zlib_init with zlib_reset for performance.
+ *
+*/
#include <linux/mutex.h>
@@ -33,6 +39,156 @@
#include "squashfs.h"
#include "decompressor.h"
+#ifdef CONFIG_SQUASHFS_MPCORE
+static void *zlib_init(struct squashfs_sb_info *dummy, void *buff, int len)
+{
+ unsigned int processors = num_online_cpus();
+ unsigned int i = 0;
+ int zlib_err = 0;
+
+ z_stream *stream = kmalloc((processors * sizeof(z_stream)),
GFP_KERNEL);
+ if (stream == NULL)
+ goto failed;
+
+ for_each_online_cpu(i) {
+ stream[i].workspace = kmalloc(zlib_inflate_workspacesize(),
+ GFP_KERNEL);
+ if (stream[i].workspace == NULL)
+ goto failed;
+ zlib_err = zlib_inflateInit(&(stream[i]));
+ if (zlib_err != Z_OK) {
+ ERROR("zlib_inflateInit returned unexpected "
+ "result 0x%x\n",
+ zlib_err);
+ goto failed;
+ }
+ }
+ return stream;
+
+failed:
+ ERROR("Failed to allocate zlib workspace\n");
+ i = 0;
+ for_each_online_cpu(i) {
+ if (stream[i].workspace)
+ kfree(stream[i].workspace);
+ }
+ if (stream)
+ kfree(stream);
+ return NULL;
+}
+
+
+static void zlib_free(void *strm)
+{
+ z_stream *stream = strm;
+ unsigned int i = 0;
+
+ for_each_online_cpu(i) {
+ if (stream[i].workspace)
+ kfree(stream[i].workspace);
+ }
+ if (stream)
+ kfree(stream);
+ strm = NULL;
+}
+
+
+static int zlib_uncompress(struct squashfs_sb_info *msblk, void **buffer,
+ struct buffer_head **bh, int b, int offset, int length, int srclength,
+ int pages)
+{
+ int zlib_err = 0;
+ int avail, bytes, k = 0, page = 0;
+ unsigned int pid = smp_processor_id();
+ z_stream *stream = msblk->stream;
+
+ mutex_lock(&msblk->read_data_mutex[pid]);
+ /*printk(KERN_INFO "[%s] pid %d \n",__FUNCTION__,pid);*/
+ /*
+ * We are resetting zlib stream here so that it avoids the
+ * overhead of zlib_init again and again for each
+ * request.
+ */
+ zlib_err = zlib_inflateReset(&(stream[pid]));
+ if (zlib_err != Z_OK) {
+ ERROR("zlib_Reset returned %d \n", zlib_err);
+ printk(KERN_EMERG"zlib_Reset returned %d \n", zlib_err);
+ goto release_mutex;
+ }
+
+ stream[pid].avail_out = 0;
+ stream[pid].avail_in = 0;
+
+ bytes = length;
+ do {
+ if (stream[pid].avail_in == 0 && k < b) {
+ avail = min(bytes, msblk->devblksize - offset);
+ bytes -= avail;
+ wait_on_buffer(bh[k]);
+ if (!buffer_uptodate(bh[k]))
+ goto release_mutex;
+
+ if (avail == 0) {
+ offset = 0;
+ put_bh(bh[k++]);
+ continue;
+ }
+
+ stream[pid].next_in = bh[k]->b_data + offset;
+ stream[pid].avail_in = avail;
+ offset = 0;
+ }
+
+ if (stream[pid].avail_out == 0 && page < pages) {
+ stream[pid].next_out = buffer[page++];
+ stream[pid].avail_out = PAGE_CACHE_SIZE;
+ }
+#if 0
+ if (!zlib_init) {
+ zlib_err = zlib_inflateInit(&(stream[pid]));
+ if (zlib_err != Z_OK) {
+ ERROR("zlib_inflateInit returned unexpected "
+ "result 0x%x, srclength %d\n",
+ zlib_err, srclength);
+ goto release_mutex;
+ }
+ zlib_init = 1;
+ }
+#endif
+
+ zlib_err = zlib_inflate(&(stream[pid]), Z_SYNC_FLUSH);
+
+ if (stream[pid].avail_in == 0 && k < b)
+ put_bh(bh[k++]);
+ } while (zlib_err == Z_OK);
+
+ if (zlib_err != Z_STREAM_END) {
+ ERROR("zlib_inflate error, data probably corrupt %d \n", zlib_err);
+ printk(KERN_INFO"avail in %d avail out %d \n",
stream[pid].avail_in, stream[pid].avail_out);
+ goto release_mutex;
+ }
+#if 0
+ zlib_err = zlib_inflateEnd(&(stream[pid]));
+ if (zlib_err != Z_OK) {
+ ERROR("zlib_inflate error, data probably corrupt\n");
+ goto release_mutex;
+ }
+#endif
+ length = stream[pid].total_out;
+ mutex_unlock(&msblk->read_data_mutex[pid]);
+ return length;
+
+release_mutex:
+ mutex_unlock(&msblk->read_data_mutex[pid]);
+
+ for (; k < b; k++)
+ put_bh(bh[k]);
+
+ return -EIO;
+}
+
+#else /* MPCORE*/
+
static void *zlib_init(struct squashfs_sb_info *dummy, void *buff, int len)
{
z_stream *stream = kmalloc(sizeof(z_stream), GFP_KERNEL);
@@ -137,7 +293,7 @@ release_mutex:
return -EIO;
}
-
+#endif /* MPCORE*/
const struct squashfs_decompressor squashfs_zlib_comp_ops = {
.init = zlib_init,
.free = zlib_free,
--
1.7.9.5
