Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[platform/kernel/linux-starfive.git] / 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 }