1 files changed, 23 insertions, 5 deletions

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);