fs/ubifs/compress.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This file is part of UBIFS.
   4  *
   5  * Copyright (C) 2006-2008 Nokia Corporation.
   6  * Copyright (C) 2006, 2007 University of Szeged, Hungary
   7  *
   8  * Authors: Adrian Hunter
   9  *          Artem Bityutskiy (Битюцкий Артём)
  10  *          Zoltan Sogor
  11  */
  12
  13 /*
  14  * This file provides a single place to access to compression and
  15  * decompression.
  16  */
  17
  18 #include <linux/crypto.h>
  19 #include "ubifs.h"
  20
  21 /* Fake description object for the "none" compressor */
  22 static struct ubifs_compressor none_compr = {
  23         .compr_type = UBIFS_COMPR_NONE,
  24         .name = "none",
  25         .capi_name = "",
  26 };
  27
  28 #ifdef CONFIG_UBIFS_FS_LZO
  29 static DEFINE_MUTEX(lzo_mutex);
  30
  31 static struct ubifs_compressor lzo_compr = {
  32         .compr_type = UBIFS_COMPR_LZO,
  33         .comp_mutex = &lzo_mutex,
  34         .name = "lzo",
  35         .capi_name = "lzo",
  36 };
  37 #else
  38 static struct ubifs_compressor lzo_compr = {
  39         .compr_type = UBIFS_COMPR_LZO,
  40         .name = "lzo",
  41 };
  42 #endif
  43
  44 #ifdef CONFIG_UBIFS_FS_ZLIB
  45 static DEFINE_MUTEX(deflate_mutex);
  46 static DEFINE_MUTEX(inflate_mutex);
  47
  48 static struct ubifs_compressor zlib_compr = {
  49         .compr_type = UBIFS_COMPR_ZLIB,
  50         .comp_mutex = &deflate_mutex,
  51         .decomp_mutex = &inflate_mutex,
  52         .name = "zlib",
  53         .capi_name = "deflate",
  54 };
  55 #else
  56 static struct ubifs_compressor zlib_compr = {
  57         .compr_type = UBIFS_COMPR_ZLIB,
  58         .name = "zlib",
  59 };
  60 #endif
  61
  62 #ifdef CONFIG_UBIFS_FS_ZSTD
  63 static DEFINE_MUTEX(zstd_enc_mutex);
  64 static DEFINE_MUTEX(zstd_dec_mutex);
  65
  66 static struct ubifs_compressor zstd_compr = {
  67         .compr_type = UBIFS_COMPR_ZSTD,
  68         .comp_mutex = &zstd_enc_mutex,
  69         .decomp_mutex = &zstd_dec_mutex,
  70         .name = "zstd",
  71         .capi_name = "zstd",
  72 };
  73 #else
  74 static struct ubifs_compressor zstd_compr = {
  75         .compr_type = UBIFS_COMPR_ZSTD,
  76         .name = "zstd",
  77 };
  78 #endif
  79
  80 /* All UBIFS compressors */
  81 struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
  82
  83 /**
  84  * ubifs_compress - compress data.
  85  * @c: UBIFS file-system description object
  86  * @in_buf: data to compress
  87  * @in_len: length of the data to compress
  88  * @out_buf: output buffer where compressed data should be stored
  89  * @out_len: output buffer length is returned here
  90  * @compr_type: type of compression to use on enter, actually used compression
  91  *              type on exit
  92  *
  93  * This function compresses input buffer @in_buf of length @in_len and stores
  94  * the result in the output buffer @out_buf and the resulting length in
  95  * @out_len. If the input buffer does not compress, it is just copied to the
  96  * @out_buf. The same happens if @compr_type is %UBIFS_COMPR_NONE or if
  97  * compression error occurred.
  98  *
  99  * Note, if the input buffer was not compressed, it is copied to the output
 100  * buffer and %UBIFS_COMPR_NONE is returned in @compr_type.
 101  */
 102 void ubifs_compress(const struct ubifs_info *c, const void *in_buf,
 103                     int in_len, void *out_buf, int *out_len, int *compr_type)
 104 {
 105         int err;
 106         struct ubifs_compressor *compr = ubifs_compressors[*compr_type];
 107
 108         if (*compr_type == UBIFS_COMPR_NONE)
 109                 goto no_compr;
 110
 111         /* If the input data is small, do not even try to compress it */
 112         if (in_len < UBIFS_MIN_COMPR_LEN)
 113                 goto no_compr;
 114
 115         if (compr->comp_mutex)
 116                 mutex_lock(compr->comp_mutex);
 117         err = crypto_comp_compress(compr->cc, in_buf, in_len, out_buf,
 118                                    (unsigned int *)out_len);
 119         if (compr->comp_mutex)
 120                 mutex_unlock(compr->comp_mutex);
 121         if (unlikely(err)) {
 122                 ubifs_warn(c, "cannot compress %d bytes, compressor %s, error %d, leave data uncompressed",
 123                            in_len, compr->name, err);
 124                 goto no_compr;
 125         }
 126
 127         /*
 128          * If the data compressed only slightly, it is better to leave it
 129          * uncompressed to improve read speed.
 130          */
 131         if (in_len - *out_len < UBIFS_MIN_COMPRESS_DIFF)
 132                 goto no_compr;
 133
 134         return;
 135
 136 no_compr:
 137         memcpy(out_buf, in_buf, in_len);
 138         *out_len = in_len;
 139         *compr_type = UBIFS_COMPR_NONE;
 140 }
 141
 142 /**
 143  * ubifs_decompress - decompress data.
 144  * @c: UBIFS file-system description object
 145  * @in_buf: data to decompress
 146  * @in_len: length of the data to decompress
 147  * @out_buf: output buffer where decompressed data should
 148  * @out_len: output length is returned here
 149  * @compr_type: type of compression
 150  *
 151  * This function decompresses data from buffer @in_buf into buffer @out_buf.
 152  * The length of the uncompressed data is returned in @out_len. This functions
 153  * returns %0 on success or a negative error code on failure.
 154  */
 155 int ubifs_decompress(const struct ubifs_info *c, const void *in_buf,
 156                      int in_len, void *out_buf, int *out_len, int compr_type)
 157 {
 158         int err;
 159         struct ubifs_compressor *compr;
 160
 161         if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
 162                 ubifs_err(c, "invalid compression type %d", compr_type);
 163                 return -EINVAL;
 164         }
 165
 166         compr = ubifs_compressors[compr_type];
 167
 168         if (unlikely(!compr->capi_name)) {
 169                 ubifs_err(c, "%s compression is not compiled in", compr->name);
 170                 return -EINVAL;
 171         }
 172
 173         if (compr_type == UBIFS_COMPR_NONE) {
 174                 memcpy(out_buf, in_buf, in_len);
 175                 *out_len = in_len;
 176                 return 0;
 177         }
 178
 179         if (compr->decomp_mutex)
 180                 mutex_lock(compr->decomp_mutex);
 181         err = crypto_comp_decompress(compr->cc, in_buf, in_len, out_buf,
 182                                      (unsigned int *)out_len);
 183         if (compr->decomp_mutex)
 184                 mutex_unlock(compr->decomp_mutex);
 185         if (err)
 186                 ubifs_err(c, "cannot decompress %d bytes, compressor %s, error %d",
 187                           in_len, compr->name, err);
 188
 189         return err;
 190 }
 191
 192 /**
 193  * compr_init - initialize a compressor.
 194  * @compr: compressor description object
 195  *
 196  * This function initializes the requested compressor and returns zero in case
 197  * of success or a negative error code in case of failure.
 198  */
 199 static int __init compr_init(struct ubifs_compressor *compr)
 200 {
 201         if (compr->capi_name) {
 202                 compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0);
 203                 if (IS_ERR(compr->cc)) {
 204                         pr_err("UBIFS error (pid %d): cannot initialize compressor %s, error %ld",
 205                                current->pid, compr->name, PTR_ERR(compr->cc));
 206                         return PTR_ERR(compr->cc);
 207                 }
 208         }
 209
 210         ubifs_compressors[compr->compr_type] = compr;
 211         return 0;
 212 }
 213
 214 /**
 215  * compr_exit - de-initialize a compressor.
 216  * @compr: compressor description object
 217  */
 218 static void compr_exit(struct ubifs_compressor *compr)
 219 {
 220         if (compr->capi_name)
 221                 crypto_free_comp(compr->cc);
 222 }
 223
 224 /**
 225  * ubifs_compressors_init - initialize UBIFS compressors.
 226  *
 227  * This function initializes the compressor which were compiled in. Returns
 228  * zero in case of success and a negative error code in case of failure.
 229  */
 230 int __init ubifs_compressors_init(void)
 231 {
 232         int err;
 233
 234         err = compr_init(&lzo_compr);
 235         if (err)
 236                 return err;
 237
 238         err = compr_init(&zstd_compr);
 239         if (err)
 240                 goto out_lzo;
 241
 242         err = compr_init(&zlib_compr);
 243         if (err)
 244                 goto out_zstd;
 245
 246         ubifs_compressors[UBIFS_COMPR_NONE] = &none_compr;
 247         return 0;
 248
 249 out_zstd:
 250         compr_exit(&zstd_compr);
 251 out_lzo:
 252         compr_exit(&lzo_compr);
 253         return err;
 254 }
 255
 256 /**
 257  * ubifs_compressors_exit - de-initialize UBIFS compressors.
 258  */
 259 void ubifs_compressors_exit(void)
 260 {
 261         compr_exit(&lzo_compr);
 262         compr_exit(&zlib_compr);
 263         compr_exit(&zstd_compr);
 264 }