13 files changed, 163 insertions, 67 deletions

diff --git a/fs/squashfs/block.c b/fs/squashfs/block.c
index 4dd402597f22..0cea9b9236d0 100644
--- a/fs/squashfs/block.c
+++ b/fs/squashfs/block.c
@@ -36,6 +36,7 @@
 #include "squashfs_fs_sb.h"
 #include "squashfs.h"
 #include "decompressor.h"
+#include "page_actor.h"
 
 /*
  * Read the metadata block length, this is stored in the first two
@@ -86,16 +87,16 @@ static struct buffer_head *get_block_length(struct super_block *sb,
  * generated a larger block - this does occasionally happen with compression
  * algorithms).
  */
-int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
-                        int length, u64 *next_index, int srclength, int pages)
+int squashfs_read_data(struct super_block *sb, u64 index, int length,
+                u64 *next_index, struct squashfs_page_actor *output)
 {
         struct squashfs_sb_info *msblk = sb->s_fs_info;
         struct buffer_head **bh;
         int offset = index & ((1 << msblk->devblksize_log2) - 1);
         u64 cur_index = index >> msblk->devblksize_log2;
-        int bytes, compressed, b = 0, k = 0, page = 0, avail, i;
+        int bytes, compressed, b = 0, k = 0, avail, i;
 
-        bh = kcalloc(((srclength + msblk->devblksize - 1)
+        bh = kcalloc(((output->length + msblk->devblksize - 1)
                 >> msblk->devblksize_log2) + 1, sizeof(*bh), GFP_KERNEL);
         if (bh == NULL)
                 return -ENOMEM;
@@ -111,9 +112,9 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
                         *next_index = index + length;
 
                 TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",
-                        index, compressed ? "" : "un", length, srclength);
+                        index, compressed ? "" : "un", length, output->length);
 
-                if (length < 0 || length > srclength ||
+                if (length < 0 || length > output->length ||
                                 (index + length) > msblk->bytes_used)
                         goto read_failure;
 
@@ -145,7 +146,7 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
                 TRACE("Block @ 0x%llx, %scompressed size %d\n", index,
                                 compressed ? "" : "un", length);
 
-                if (length < 0 || length > srclength ||
+                if (length < 0 || length > output->length ||
                                         (index + length) > msblk->bytes_used)
                         goto block_release;
 
@@ -165,8 +166,8 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
         }
 
         if (compressed) {
-                length = squashfs_decompress(msblk, buffer, bh, b, offset,
-                         length, srclength, pages);
+                length = squashfs_decompress(msblk, bh, b, offset, length,
+                        output);
                 if (length < 0)
                         goto read_failure;
         } else {
@@ -174,19 +175,20 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
                  * Block is uncompressed.
                  */
                 int in, pg_offset = 0;
+                void *data = squashfs_first_page(output);
 
                 for (bytes = length; k < b; k++) {
                         in = min(bytes, msblk->devblksize - offset);
                         bytes -= in;
                         while (in) {
                                 if (pg_offset == PAGE_CACHE_SIZE) {
-                                        page++;
+                                        data = squashfs_next_page(output);
                                         pg_offset = 0;
                                 }
                                 avail = min_t(int, in, PAGE_CACHE_SIZE -
                                                 pg_offset);
-                                memcpy(buffer[page] + pg_offset,
-                                                bh[k]->b_data + offset, avail);
+                                memcpy(data + pg_offset, bh[k]->b_data + offset,
+                                                avail);
                                 in -= avail;
                                 pg_offset += avail;
                                 offset += avail;
@@ -194,6 +196,7 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,
                         offset = 0;
                         put_bh(bh[k]);
                 }
+                squashfs_finish_page(output);
         }
 
         kfree(bh);
diff --git a/fs/squashfs/cache.c b/fs/squashfs/cache.c
index af0b73802592..1cb70a0b2168 100644
--- a/fs/squashfs/cache.c
+++ b/fs/squashfs/cache.c
@@ -56,6 +56,7 @@
 #include "squashfs_fs.h"
 #include "squashfs_fs_sb.h"
 #include "squashfs.h"
+#include "page_actor.h"
 
 /*
  * Look-up block in cache, and increment usage count.  If not in cache, read
@@ -119,9 +120,8 @@ struct squashfs_cache_entry *squashfs_cache_get(struct super_block *sb,
                         entry->error = 0;
                         spin_unlock(&cache->lock);
 
-                        entry->length = squashfs_read_data(sb, entry->data,
-                                block, length, &entry->next_index,
-                                cache->block_size, cache->pages);
+                        entry->length = squashfs_read_data(sb, block, length,
+                                &entry->next_index, entry->actor);
 
                         spin_lock(&cache->lock);
 
@@ -220,6 +220,7 @@ void squashfs_cache_delete(struct squashfs_cache *cache)
                                 kfree(cache->entry[i].data[j]);
                         kfree(cache->entry[i].data);
                 }
+                kfree(cache->entry[i].actor);
         }
 
         kfree(cache->entry);
@@ -280,6 +281,13 @@ struct squashfs_cache *squashfs_cache_init(char *name, int entries,
                                 goto cleanup;
                         }
                 }
+
+                entry->actor = squashfs_page_actor_init(entry->data,
+                                                cache->pages, 0);
+                if (entry->actor == NULL) {
+                        ERROR("Failed to allocate %s cache entry\n", name);
+                        goto cleanup;
+                }
         }
 
         return cache;
@@ -410,6 +418,7 @@ void *squashfs_read_table(struct super_block *sb, u64 block, int length)
         int pages = (length + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
         int i, res;
         void *table, *buffer, **data;
+        struct squashfs_page_actor *actor;
 
         table = buffer = kmalloc(length, GFP_KERNEL);
         if (table == NULL)
@@ -421,19 +430,28 @@ void *squashfs_read_table(struct super_block *sb, u64 block, int length)
                 goto failed;
         }
 
+        actor = squashfs_page_actor_init(data, pages, length);
+        if (actor == NULL) {
+                res = -ENOMEM;
+                goto failed2;
+        }
+
         for (i = 0; i < pages; i++, buffer += PAGE_CACHE_SIZE)
                 data[i] = buffer;
 
-        res = squashfs_read_data(sb, data, block, length |
-                SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length, pages);
+        res = squashfs_read_data(sb, block, length |
+                SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, actor);
 
         kfree(data);
+        kfree(actor);
 
         if (res < 0)
                 goto failed;
 
         return table;
 
+failed2:
+        kfree(data);
 failed:
         kfree(table);
         return ERR_PTR(res);
diff --git a/fs/squashfs/decompressor.c b/fs/squashfs/decompressor.c
index 234291f79ba5..ac22fe73b0ad 100644
--- a/fs/squashfs/decompressor.c
+++ b/fs/squashfs/decompressor.c
@@ -30,6 +30,7 @@
 #include "squashfs_fs_sb.h"
 #include "decompressor.h"
 #include "squashfs.h"
+#include "page_actor.h"
 
 /*
  * This file (and decompressor.h) implements a decompressor framework for
@@ -87,6 +88,7 @@ static void *get_comp_opts(struct super_block *sb, unsigned short flags)
 {
         struct squashfs_sb_info *msblk = sb->s_fs_info;
         void *buffer = NULL, *comp_opts;
+        struct squashfs_page_actor *actor = NULL;
         int length = 0;
 
         /*
@@ -99,9 +101,14 @@ static void *get_comp_opts(struct super_block *sb, unsigned short flags)
                         goto out;
                 }
 
-                length = squashfs_read_data(sb, &buffer,
-                        sizeof(struct squashfs_super_block), 0, NULL,
-                                PAGE_CACHE_SIZE, 1);
+                actor = squashfs_page_actor_init(&buffer, 1, 0);
+                if (actor == NULL) {
+                        comp_opts = ERR_PTR(-ENOMEM);
+                        goto out;
+                }
+
+                length = squashfs_read_data(sb,
+                        sizeof(struct squashfs_super_block), 0, NULL, actor);
 
                 if (length < 0) {
                         comp_opts = ERR_PTR(length);
@@ -112,6 +119,7 @@ static void *get_comp_opts(struct super_block *sb, unsigned short flags)
         comp_opts = squashfs_comp_opts(msblk, buffer, length);
 
 out:
+        kfree(actor);
         kfree(buffer);
         return comp_opts;
 }
diff --git a/fs/squashfs/decompressor.h b/fs/squashfs/decompressor.h
index 6cdb20a3878a..af0985321808 100644
--- a/fs/squashfs/decompressor.h
+++ b/fs/squashfs/decompressor.h
@@ -27,8 +27,9 @@ struct squashfs_decompressor {
         void    *(*init)(struct squashfs_sb_info *, void *);
         void    *(*comp_opts)(struct squashfs_sb_info *, void *, int);
         void    (*free)(void *);
-        int     (*decompress)(struct squashfs_sb_info *, void *, void **,
-                struct buffer_head **, int, int, int, int, int);
+        int     (*decompress)(struct squashfs_sb_info *, void *,
+                struct buffer_head **, int, int, int,
+                struct squashfs_page_actor *);
         int     id;
         char    *name;
         int     supported;
diff --git a/fs/squashfs/decompressor_multi.c b/fs/squashfs/decompressor_multi.c
index 462731db5130..ae54675a3526 100644
--- a/fs/squashfs/decompressor_multi.c
+++ b/fs/squashfs/decompressor_multi.c
@@ -183,15 +183,14 @@ wait:
 }
 
 
-int squashfs_decompress(struct squashfs_sb_info *msblk,
-        void **buffer, struct buffer_head **bh, int b, int offset, int length,
-        int srclength, int pages)
+int squashfs_decompress(struct squashfs_sb_info *msblk, struct buffer_head **bh,
+        int b, int offset, int length, struct squashfs_page_actor *output)
 {
         int res;
         struct squashfs_stream *stream = msblk->stream;
         struct decomp_stream *decomp_stream = get_decomp_stream(msblk, stream);
         res = msblk->decompressor->decompress(msblk, decomp_stream->stream,
-                buffer, bh, b, offset, length, srclength, pages);
+                bh, b, offset, length, output);
         put_decomp_stream(decomp_stream, stream);
         if (res < 0)
                 ERROR("%s decompression failed, data probably corrupt\n",
diff --git a/fs/squashfs/decompressor_multi_percpu.c b/fs/squashfs/decompressor_multi_percpu.c
index 0e7b679bc4ad..23a9c28ad8ea 100644
--- a/fs/squashfs/decompressor_multi_percpu.c
+++ b/fs/squashfs/decompressor_multi_percpu.c
@@ -74,15 +74,14 @@ void squashfs_decompressor_destroy(struct squashfs_sb_info *msblk)
         }
 }
 
-int squashfs_decompress(struct squashfs_sb_info *msblk,
-        void **buffer, struct buffer_head **bh, int b, int offset, int length,
-        int srclength, int pages)
+int squashfs_decompress(struct squashfs_sb_info *msblk, struct buffer_head **bh,
+        int b, int offset, int length, struct squashfs_page_actor *output)
 {
         struct squashfs_stream __percpu *percpu =
                         (struct squashfs_stream __percpu *) msblk->stream;
         struct squashfs_stream *stream = get_cpu_ptr(percpu);
-        int res = msblk->decompressor->decompress(msblk, stream->stream, buffer,
-                bh, b, offset, length, srclength, pages);
+        int res = msblk->decompressor->decompress(msblk, stream->stream, bh, b,
+                offset, length, output);
         put_cpu_ptr(stream);
 
         if (res < 0)
diff --git a/fs/squashfs/decompressor_single.c b/fs/squashfs/decompressor_single.c
index f857cf6f22d4..a6c75929a00e 100644
--- a/fs/squashfs/decompressor_single.c
+++ b/fs/squashfs/decompressor_single.c
@@ -61,16 +61,15 @@ void squashfs_decompressor_destroy(struct squashfs_sb_info *msblk)
         }
 }
 
-int squashfs_decompress(struct squashfs_sb_info *msblk,
-        void **buffer, struct buffer_head **bh, int b, int offset, int length,
-        int srclength, int pages)
+int squashfs_decompress(struct squashfs_sb_info *msblk, struct buffer_head **bh,
+        int b, int offset, int length, struct squashfs_page_actor *output)
 {
         int res;
         struct squashfs_stream *stream = msblk->stream;
 
         mutex_lock(&stream->mutex);
-        res = msblk->decompressor->decompress(msblk, stream->stream, buffer,
-                bh, b, offset, length, srclength, pages);
+        res = msblk->decompressor->decompress(msblk, stream->stream, bh, b,
+                offset, length, output);
         mutex_unlock(&stream->mutex);
 
         if (res < 0)
diff --git a/fs/squashfs/lzo_wrapper.c b/fs/squashfs/lzo_wrapper.c
index 75c3b5779172..244b9fbfff7b 100644
--- a/fs/squashfs/lzo_wrapper.c
+++ b/fs/squashfs/lzo_wrapper.c
@@ -31,6 +31,7 @@
 #include "squashfs_fs_sb.h"
 #include "squashfs.h"
 #include "decompressor.h"
+#include "page_actor.h"
 
 struct squashfs_lzo {
         void    *input;
@@ -75,13 +76,13 @@ static void lzo_free(void *strm)
 
 
 static int lzo_uncompress(struct squashfs_sb_info *msblk, void *strm,
-        void **buffer, struct buffer_head **bh, int b, int offset, int length,
-        int srclength, int pages)
+        struct buffer_head **bh, int b, int offset, int length,
+        struct squashfs_page_actor *output)
 {
         struct squashfs_lzo *stream = strm;
-        void *buff = stream->input;
+        void *buff = stream->input, *data;
         int avail, i, bytes = length, res;
-        size_t out_len = srclength;
+        size_t out_len = output->length;
 
         for (i = 0; i < b; i++) {
                 avail = min(bytes, msblk->devblksize - offset);
@@ -98,12 +99,20 @@ static int lzo_uncompress(struct squashfs_sb_info *msblk, void *strm,
                 goto failed;
 
         res = bytes = (int)out_len;
-        for (i = 0, buff = stream->output; bytes && i < pages; i++) {
-                avail = min_t(int, bytes, PAGE_CACHE_SIZE);
-                memcpy(buffer[i], buff, avail);
-                buff += avail;
-                bytes -= avail;
+        data = squashfs_first_page(output);
+        buff = stream->output;
+        while (data) {
+                if (bytes <= PAGE_CACHE_SIZE) {
+                        memcpy(data, buff, bytes);
+                        break;
+                } else {
+                        memcpy(data, buff, PAGE_CACHE_SIZE);
+                        buff += PAGE_CACHE_SIZE;
+                        bytes -= PAGE_CACHE_SIZE;
+                        data = squashfs_next_page(output);
+                }
         }
+        squashfs_finish_page(output);
 
         return res;
 
diff --git a/fs/squashfs/page_actor.h b/fs/squashfs/page_actor.h
new file mode 100644
index 000000000000..5b0ba5a7133a
--- /dev/null
+++ b/fs/squashfs/page_actor.h
@@ -0,0 +1,49 @@
+#ifndef PAGE_ACTOR_H
+#define PAGE_ACTOR_H
+/*
+ * Copyright (c) 2013
+ * Phillip Lougher <phillip@squashfs.org.uk>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ */
+
+struct squashfs_page_actor {
+        void    **page;
+        int     pages;
+        int     length;
+        int     next_page;
+};
+
+static inline struct squashfs_page_actor *squashfs_page_actor_init(void **page,
+        int pages, int length)
+{
+        struct squashfs_page_actor *actor = kmalloc(sizeof(*actor), GFP_KERNEL);
+
+        if (actor == NULL)
+                return NULL;
+
+        actor->length = length ? : pages * PAGE_CACHE_SIZE;
+        actor->page = page;
+        actor->pages = pages;
+        actor->next_page = 0;
+        return actor;
+}
+
+static inline void *squashfs_first_page(struct squashfs_page_actor *actor)
+{
+        actor->next_page = 1;
+        return actor->page[0];
+}
+
+static inline void *squashfs_next_page(struct squashfs_page_actor *actor)
+{
+        return actor->next_page == actor->pages ? NULL :
+                actor->page[actor->next_page++];
+}
+
+static inline void squashfs_finish_page(struct squashfs_page_actor *actor)
+{
+        /* empty */
+}
+#endif
diff --git a/fs/squashfs/squashfs.h b/fs/squashfs/squashfs.h
index 2e2751df8452..6a97e63ca173 100644
--- a/fs/squashfs/squashfs.h
+++ b/fs/squashfs/squashfs.h
@@ -28,8 +28,8 @@
 #define WARNING(s, args...)     pr_warning("SQUASHFS: "s, ## args)
 
 /* block.c */
-extern int squashfs_read_data(struct super_block *, void **, u64, int, u64 *,
-                                int, int);
+extern int squashfs_read_data(struct super_block *, u64, int, u64 *,
+                                struct squashfs_page_actor *);
 
 /* cache.c */
 extern struct squashfs_cache *squashfs_cache_init(char *, int, int);
@@ -53,8 +53,8 @@ extern void *squashfs_decompressor_setup(struct super_block *, unsigned short);
 /* decompressor_xxx.c */
 extern void *squashfs_decompressor_create(struct squashfs_sb_info *, void *);
 extern void squashfs_decompressor_destroy(struct squashfs_sb_info *);
-extern int squashfs_decompress(struct squashfs_sb_info *, void **,
-        struct buffer_head **, int, int, int, int, int);
+extern int squashfs_decompress(struct squashfs_sb_info *, struct buffer_head **,
+        int, int, int, struct squashfs_page_actor *);
 extern int squashfs_max_decompressors(void);
 
 /* export.c */
diff --git a/fs/squashfs/squashfs_fs_sb.h b/fs/squashfs/squashfs_fs_sb.h
index 9cdcf4150d59..1da565cb50c3 100644
--- a/fs/squashfs/squashfs_fs_sb.h
+++ b/fs/squashfs/squashfs_fs_sb.h
@@ -50,6 +50,7 @@ struct squashfs_cache_entry {
         wait_queue_head_t       wait_queue;
         struct squashfs_cache   *cache;
         void                    **data;
+        struct squashfs_page_actor      *actor;
 };
 
 struct squashfs_sb_info {
diff --git a/fs/squashfs/xz_wrapper.c b/fs/squashfs/xz_wrapper.c
index 5d1d07cca6b4..c609624e4b8a 100644
--- a/fs/squashfs/xz_wrapper.c
+++ b/fs/squashfs/xz_wrapper.c
@@ -32,6 +32,7 @@
 #include "squashfs_fs_sb.h"
 #include "squashfs.h"
 #include "decompressor.h"
+#include "page_actor.h"
 
 struct squashfs_xz {
         struct xz_dec *state;
@@ -129,11 +130,11 @@ static void squashfs_xz_free(void *strm)
 
 
 static int squashfs_xz_uncompress(struct squashfs_sb_info *msblk, void *strm,
-        void **buffer, struct buffer_head **bh, int b, int offset, int length,
-        int srclength, int pages)
+        struct buffer_head **bh, int b, int offset, int length,
+        struct squashfs_page_actor *output)
 {
         enum xz_ret xz_err;
-        int avail, total = 0, k = 0, page = 0;
+        int avail, total = 0, k = 0;
         struct squashfs_xz *stream = strm;
 
         xz_dec_reset(stream->state);
@@ -141,7 +142,7 @@ static int squashfs_xz_uncompress(struct squashfs_sb_info *msblk, void *strm,
         stream->buf.in_size = 0;
         stream->buf.out_pos = 0;
         stream->buf.out_size = PAGE_CACHE_SIZE;
-        stream->buf.out = buffer[page++];
+        stream->buf.out = squashfs_first_page(output);
 
         do {
                 if (stream->buf.in_pos == stream->buf.in_size && k < b) {
@@ -153,11 +154,12 @@ static int squashfs_xz_uncompress(struct squashfs_sb_info *msblk, void *strm,
                         offset = 0;
                 }
 
-                if (stream->buf.out_pos == stream->buf.out_size
-                                                        && page < pages) {
-                        stream->buf.out = buffer[page++];
-                        stream->buf.out_pos = 0;
-                        total += PAGE_CACHE_SIZE;
+                if (stream->buf.out_pos == stream->buf.out_size) {
+                        stream->buf.out = squashfs_next_page(output);
+                        if (stream->buf.out != NULL) {
+                                stream->buf.out_pos = 0;
+                                total += PAGE_CACHE_SIZE;
+                        }
                 }
 
                 xz_err = xz_dec_run(stream->state, &stream->buf);
@@ -166,6 +168,8 @@ static int squashfs_xz_uncompress(struct squashfs_sb_info *msblk, void *strm,
                         put_bh(bh[k++]);
         } while (xz_err == XZ_OK);
 
+        squashfs_finish_page(output);
+
         if (xz_err != XZ_STREAM_END || k < b)
                 goto out;
 
diff --git a/fs/squashfs/zlib_wrapper.c b/fs/squashfs/zlib_wrapper.c
index bb049027d15c..8727caba6882 100644
--- a/fs/squashfs/zlib_wrapper.c
+++ b/fs/squashfs/zlib_wrapper.c
@@ -32,6 +32,7 @@
 #include "squashfs_fs_sb.h"
 #include "squashfs.h"
 #include "decompressor.h"
+#include "page_actor.h"
 
 static void *zlib_init(struct squashfs_sb_info *dummy, void *buff)
 {
@@ -62,14 +63,14 @@ static void zlib_free(void *strm)
 
 
 static int zlib_uncompress(struct squashfs_sb_info *msblk, void *strm,
-        void **buffer, struct buffer_head **bh, int b, int offset, int length,
-        int srclength, int pages)
+        struct buffer_head **bh, int b, int offset, int length,
+        struct squashfs_page_actor *output)
 {
-        int zlib_err, zlib_init = 0;
-        int k = 0, page = 0;
+        int zlib_err, zlib_init = 0, k = 0;
         z_stream *stream = strm;
 
-        stream->avail_out = 0;
+        stream->avail_out = PAGE_CACHE_SIZE;
+        stream->next_out = squashfs_first_page(output);
         stream->avail_in = 0;
 
         do {
@@ -81,15 +82,18 @@ static int zlib_uncompress(struct squashfs_sb_info *msblk, void *strm,
                         offset = 0;
                 }
 
-                if (stream->avail_out == 0 && page < pages) {
-                        stream->next_out = buffer[page++];
-                        stream->avail_out = PAGE_CACHE_SIZE;
+                if (stream->avail_out == 0) {
+                        stream->next_out = squashfs_next_page(output);
+                        if (stream->next_out != NULL)
+                                stream->avail_out = PAGE_CACHE_SIZE;
                 }
 
                 if (!zlib_init) {
                         zlib_err = zlib_inflateInit(stream);
-                        if (zlib_err != Z_OK)
+                        if (zlib_err != Z_OK) {
+                                squashfs_finish_page(output);
                                 goto out;
+                        }
                         zlib_init = 1;
                 }
 
@@ -99,6 +103,8 @@ static int zlib_uncompress(struct squashfs_sb_info *msblk, void *strm,
                         put_bh(bh[k++]);
         } while (zlib_err == Z_OK);
 
+        squashfs_finish_page(output);
+
         if (zlib_err != Z_STREAM_END)
                 goto out;