fs/squashfs/decompressor_multi_percpu.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2013
   4  * Phillip Lougher <phillip@squashfs.org.uk>
   5  */
   6
   7 #include <linux/types.h>
   8 #include <linux/slab.h>
   9 #include <linux/percpu.h>
  10 #include <linux/buffer_head.h>
  11 #include <linux/local_lock.h>
  12
  13 #include "squashfs_fs.h"
  14 #include "squashfs_fs_sb.h"
  15 #include "decompressor.h"
  16 #include "squashfs.h"
  17
  18 /*
  19  * This file implements multi-threaded decompression using percpu
  20  * variables, one thread per cpu core.
  21  */
  22
  23 struct squashfs_stream {
  24         void                    *stream;
  25         local_lock_t    lock;
  26 };
  27
  28 void *squashfs_decompressor_create(struct squashfs_sb_info *msblk,
  29                                                 void *comp_opts)
  30 {
  31         struct squashfs_stream *stream;
  32         struct squashfs_stream __percpu *percpu;
  33         int err, cpu;
  34
  35         percpu = alloc_percpu(struct squashfs_stream);
  36         if (percpu == NULL)
  37                 return ERR_PTR(-ENOMEM);
  38
  39         for_each_possible_cpu(cpu) {
  40                 stream = per_cpu_ptr(percpu, cpu);
  41                 stream->stream = msblk->decompressor->init(msblk, comp_opts);
  42                 if (IS_ERR(stream->stream)) {
  43                         err = PTR_ERR(stream->stream);
  44                         goto out;
  45                 }
  46                 local_lock_init(&stream->lock);
  47         }
  48
  49         kfree(comp_opts);
  50         return (__force void *) percpu;
  51
  52 out:
  53         for_each_possible_cpu(cpu) {
  54                 stream = per_cpu_ptr(percpu, cpu);
  55                 if (!IS_ERR_OR_NULL(stream->stream))
  56                         msblk->decompressor->free(stream->stream);
  57         }
  58         free_percpu(percpu);
  59         return ERR_PTR(err);
  60 }
  61
  62 void squashfs_decompressor_destroy(struct squashfs_sb_info *msblk)
  63 {
  64         struct squashfs_stream __percpu *percpu =
  65                         (struct squashfs_stream __percpu *) msblk->stream;
  66         struct squashfs_stream *stream;
  67         int cpu;
  68
  69         if (msblk->stream) {
  70                 for_each_possible_cpu(cpu) {
  71                         stream = per_cpu_ptr(percpu, cpu);
  72                         msblk->decompressor->free(stream->stream);
  73                 }
  74                 free_percpu(percpu);
  75         }
  76 }
  77
  78 int squashfs_decompress(struct squashfs_sb_info *msblk, struct bio *bio,
  79         int offset, int length, struct squashfs_page_actor *output)
  80 {
  81         struct squashfs_stream *stream;
  82         int res;
  83
  84         local_lock(&msblk->stream->lock);
  85         stream = this_cpu_ptr(msblk->stream);
  86
  87         res = msblk->decompressor->decompress(msblk, stream->stream, bio,
  88                                               offset, length, output);
  89
  90         local_unlock(&msblk->stream->lock);
  91
  92         if (res < 0)
  93                 ERROR("%s decompression failed, data probably corrupt\n",
  94                         msblk->decompressor->name);
  95
  96         return res;
  97 }
  98
  99 int squashfs_max_decompressors(void)
 100 {
 101         return num_possible_cpus();
 102 }