GNU Linux-libre 4.9.308-gnu1
[releases.git] / fs / squashfs / decompressor_multi.c
1 /*
2  *  Copyright (c) 2013
3  *  Minchan Kim <minchan@kernel.org>
4  *
5  *  This work is licensed under the terms of the GNU GPL, version 2. See
6  *  the COPYING file in the top-level directory.
7  */
8 #include <linux/types.h>
9 #include <linux/mutex.h>
10 #include <linux/slab.h>
11 #include <linux/buffer_head.h>
12 #include <linux/sched.h>
13 #include <linux/wait.h>
14 #include <linux/cpumask.h>
15
16 #include "squashfs_fs.h"
17 #include "squashfs_fs_sb.h"
18 #include "decompressor.h"
19 #include "squashfs.h"
20
21 /*
22  * This file implements multi-threaded decompression in the
23  * decompressor framework
24  */
25
26
27 /*
28  * The reason that multiply two is that a CPU can request new I/O
29  * while it is waiting previous request.
30  */
31 #define MAX_DECOMPRESSOR        (num_online_cpus() * 2)
32
33
34 int squashfs_max_decompressors(void)
35 {
36         return MAX_DECOMPRESSOR;
37 }
38
39
40 struct squashfs_stream {
41         void                    *comp_opts;
42         struct list_head        strm_list;
43         struct mutex            mutex;
44         int                     avail_decomp;
45         wait_queue_head_t       wait;
46 };
47
48
49 struct decomp_stream {
50         void *stream;
51         struct list_head list;
52 };
53
54
55 static void put_decomp_stream(struct decomp_stream *decomp_strm,
56                                 struct squashfs_stream *stream)
57 {
58         mutex_lock(&stream->mutex);
59         list_add(&decomp_strm->list, &stream->strm_list);
60         mutex_unlock(&stream->mutex);
61         wake_up(&stream->wait);
62 }
63
64 void *squashfs_decompressor_create(struct squashfs_sb_info *msblk,
65                                 void *comp_opts)
66 {
67         struct squashfs_stream *stream;
68         struct decomp_stream *decomp_strm = NULL;
69         int err = -ENOMEM;
70
71         stream = kzalloc(sizeof(*stream), GFP_KERNEL);
72         if (!stream)
73                 goto out;
74
75         stream->comp_opts = comp_opts;
76         mutex_init(&stream->mutex);
77         INIT_LIST_HEAD(&stream->strm_list);
78         init_waitqueue_head(&stream->wait);
79
80         /*
81          * We should have a decompressor at least as default
82          * so if we fail to allocate new decompressor dynamically,
83          * we could always fall back to default decompressor and
84          * file system works.
85          */
86         decomp_strm = kmalloc(sizeof(*decomp_strm), GFP_KERNEL);
87         if (!decomp_strm)
88                 goto out;
89
90         decomp_strm->stream = msblk->decompressor->init(msblk,
91                                                 stream->comp_opts);
92         if (IS_ERR(decomp_strm->stream)) {
93                 err = PTR_ERR(decomp_strm->stream);
94                 goto out;
95         }
96
97         list_add(&decomp_strm->list, &stream->strm_list);
98         stream->avail_decomp = 1;
99         return stream;
100
101 out:
102         kfree(decomp_strm);
103         kfree(stream);
104         return ERR_PTR(err);
105 }
106
107
108 void squashfs_decompressor_destroy(struct squashfs_sb_info *msblk)
109 {
110         struct squashfs_stream *stream = msblk->stream;
111         if (stream) {
112                 struct decomp_stream *decomp_strm;
113
114                 while (!list_empty(&stream->strm_list)) {
115                         decomp_strm = list_entry(stream->strm_list.prev,
116                                                 struct decomp_stream, list);
117                         list_del(&decomp_strm->list);
118                         msblk->decompressor->free(decomp_strm->stream);
119                         kfree(decomp_strm);
120                         stream->avail_decomp--;
121                 }
122                 WARN_ON(stream->avail_decomp);
123                 kfree(stream->comp_opts);
124                 kfree(stream);
125         }
126 }
127
128
129 static struct decomp_stream *get_decomp_stream(struct squashfs_sb_info *msblk,
130                                         struct squashfs_stream *stream)
131 {
132         struct decomp_stream *decomp_strm;
133
134         while (1) {
135                 mutex_lock(&stream->mutex);
136
137                 /* There is available decomp_stream */
138                 if (!list_empty(&stream->strm_list)) {
139                         decomp_strm = list_entry(stream->strm_list.prev,
140                                 struct decomp_stream, list);
141                         list_del(&decomp_strm->list);
142                         mutex_unlock(&stream->mutex);
143                         break;
144                 }
145
146                 /*
147                  * If there is no available decomp and already full,
148                  * let's wait for releasing decomp from other users.
149                  */
150                 if (stream->avail_decomp >= MAX_DECOMPRESSOR)
151                         goto wait;
152
153                 /* Let's allocate new decomp */
154                 decomp_strm = kmalloc(sizeof(*decomp_strm), GFP_KERNEL);
155                 if (!decomp_strm)
156                         goto wait;
157
158                 decomp_strm->stream = msblk->decompressor->init(msblk,
159                                                 stream->comp_opts);
160                 if (IS_ERR(decomp_strm->stream)) {
161                         kfree(decomp_strm);
162                         goto wait;
163                 }
164
165                 stream->avail_decomp++;
166                 WARN_ON(stream->avail_decomp > MAX_DECOMPRESSOR);
167
168                 mutex_unlock(&stream->mutex);
169                 break;
170 wait:
171                 /*
172                  * If system memory is tough, let's for other's
173                  * releasing instead of hurting VM because it could
174                  * make page cache thrashing.
175                  */
176                 mutex_unlock(&stream->mutex);
177                 wait_event(stream->wait,
178                         !list_empty(&stream->strm_list));
179         }
180
181         return decomp_strm;
182 }
183
184
185 int squashfs_decompress(struct squashfs_sb_info *msblk, struct buffer_head **bh,
186         int b, int offset, int length, struct squashfs_page_actor *output)
187 {
188         int res;
189         struct squashfs_stream *stream = msblk->stream;
190         struct decomp_stream *decomp_stream = get_decomp_stream(msblk, stream);
191         res = msblk->decompressor->decompress(msblk, decomp_stream->stream,
192                 bh, b, offset, length, output);
193         put_decomp_stream(decomp_stream, stream);
194         if (res < 0)
195                 ERROR("%s decompression failed, data probably corrupt\n",
196                         msblk->decompressor->name);
197         return res;
198 }