fs/squashfs/decompressor.c

   1 /*
   2  * Squashfs - a compressed read only filesystem for Linux
   3  *
   4  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   5  * Phillip Lougher <phillip@squashfs.org.uk>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2,
  10  * or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * decompressor.c
  22  */
  23
  24 #include <linux/types.h>
  25 #include <linux/mutex.h>
  26 #include <linux/slab.h>
  27 #include <linux/highmem.h>
  28 #include <linux/fs.h>
  29
  30 #include "squashfs_fs.h"
  31 #include "squashfs_fs_sb.h"
  32 #include "decompressor.h"
  33 #include "squashfs.h"
  34 #include "page_actor.h"
  35
  36 /*
  37  * This file (and decompressor.h) implements a decompressor framework for
  38  * Squashfs, allowing multiple decompressors to be easily supported
  39  */
  40
  41 static const struct squashfs_decompressor squashfs_lzma_unsupported_comp_ops = {
  42         NULL, NULL, NULL, NULL, LZMA_COMPRESSION, "lzma", 0
  43 };
  44
  45 #ifndef CONFIG_SQUASHFS_LZ4
  46 static const struct squashfs_decompressor squashfs_lz4_comp_ops = {
  47         NULL, NULL, NULL, NULL, LZ4_COMPRESSION, "lz4", 0
  48 };
  49 #endif
  50
  51 #ifndef CONFIG_SQUASHFS_LZO
  52 static const struct squashfs_decompressor squashfs_lzo_comp_ops = {
  53         NULL, NULL, NULL, NULL, LZO_COMPRESSION, "lzo", 0
  54 };
  55 #endif
  56
  57 #ifndef CONFIG_SQUASHFS_XZ
  58 static const struct squashfs_decompressor squashfs_xz_comp_ops = {
  59         NULL, NULL, NULL, NULL, XZ_COMPRESSION, "xz", 0
  60 };
  61 #endif
  62
  63 #ifndef CONFIG_SQUASHFS_ZLIB
  64 static const struct squashfs_decompressor squashfs_zlib_comp_ops = {
  65         NULL, NULL, NULL, NULL, ZLIB_COMPRESSION, "zlib", 0
  66 };
  67 #endif
  68
  69 static const struct squashfs_decompressor squashfs_unknown_comp_ops = {
  70         NULL, NULL, NULL, NULL, 0, "unknown", 0
  71 };
  72
  73 static const struct squashfs_decompressor *decompressor[] = {
  74         &squashfs_zlib_comp_ops,
  75         &squashfs_lz4_comp_ops,
  76         &squashfs_lzo_comp_ops,
  77         &squashfs_xz_comp_ops,
  78         &squashfs_lzma_unsupported_comp_ops,
  79         &squashfs_unknown_comp_ops
  80 };
  81
  82
  83 const struct squashfs_decompressor *squashfs_lookup_decompressor(int id)
  84 {
  85         int i;
  86
  87         for (i = 0; decompressor[i]->id; i++)
  88                 if (id == decompressor[i]->id)
  89                         break;
  90
  91         return decompressor[i];
  92 }
  93
  94
  95 static void *get_comp_opts(struct super_block *sb, unsigned short flags)
  96 {
  97         struct squashfs_sb_info *msblk = sb->s_fs_info;
  98         void *comp_opts, *buffer = NULL;
  99         struct page *page;
 100         struct squashfs_page_actor *actor = NULL;
 101         int length = 0;
 102
 103         if (!SQUASHFS_COMP_OPTS(flags))
 104                 return squashfs_comp_opts(msblk, buffer, length);
 105
 106         /*
 107          * Read decompressor specific options from file system if present
 108          */
 109
 110         page = alloc_page(GFP_KERNEL);
 111         if (!page)
 112                 return ERR_PTR(-ENOMEM);
 113
 114         actor = squashfs_page_actor_init(&page, 1, 0, NULL);
 115         if (actor == NULL) {
 116                 comp_opts = ERR_PTR(-ENOMEM);
 117                 goto actor_error;
 118         }
 119
 120         length = squashfs_read_data(sb,
 121                 sizeof(struct squashfs_super_block), 0, NULL, actor);
 122
 123         if (length < 0) {
 124                 comp_opts = ERR_PTR(length);
 125                 goto read_error;
 126         }
 127
 128         buffer = kmap_atomic(page);
 129         comp_opts = squashfs_comp_opts(msblk, buffer, length);
 130         kunmap_atomic(buffer);
 131
 132 read_error:
 133         squashfs_page_actor_free(actor, 0);
 134 actor_error:
 135         __free_page(page);
 136         return comp_opts;
 137 }
 138
 139
 140 void *squashfs_decompressor_setup(struct super_block *sb, unsigned short flags)
 141 {
 142         struct squashfs_sb_info *msblk = sb->s_fs_info;
 143         void *stream, *comp_opts = get_comp_opts(sb, flags);
 144
 145         if (IS_ERR(comp_opts))
 146                 return comp_opts;
 147
 148         stream = squashfs_decompressor_create(msblk, comp_opts);
 149         if (IS_ERR(stream))
 150                 kfree(comp_opts);
 151
 152         return stream;
 153 }