462731db51309c046d956d36c4d34a4633e0dc4a
[firefly-linux-kernel-4.4.55.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         }
123
124         WARN_ON(stream->avail_decomp);
125         kfree(stream->comp_opts);
126         kfree(stream);
127 }
128
129
130 static struct decomp_stream *get_decomp_stream(struct squashfs_sb_info *msblk,
131                                         struct squashfs_stream *stream)
132 {
133         struct decomp_stream *decomp_strm;
134
135         while (1) {
136                 mutex_lock(&stream->mutex);
137
138                 /* There is available decomp_stream */
139                 if (!list_empty(&stream->strm_list)) {
140                         decomp_strm = list_entry(stream->strm_list.prev,
141                                 struct decomp_stream, list);
142                         list_del(&decomp_strm->list);
143                         mutex_unlock(&stream->mutex);
144                         break;
145                 }
146
147                 /*
148                  * If there is no available decomp and already full,
149                  * let's wait for releasing decomp from other users.
150                  */
151                 if (stream->avail_decomp >= MAX_DECOMPRESSOR)
152                         goto wait;
153
154                 /* Let's allocate new decomp */
155                 decomp_strm = kmalloc(sizeof(*decomp_strm), GFP_KERNEL);
156                 if (!decomp_strm)
157                         goto wait;
158
159                 decomp_strm->stream = msblk->decompressor->init(msblk,
160                                                 stream->comp_opts);
161                 if (IS_ERR(decomp_strm->stream)) {
162                         kfree(decomp_strm);
163                         goto wait;
164                 }
165
166                 stream->avail_decomp++;
167                 WARN_ON(stream->avail_decomp > MAX_DECOMPRESSOR);
168
169                 mutex_unlock(&stream->mutex);
170                 break;
171 wait:
172                 /*
173                  * If system memory is tough, let's for other's
174                  * releasing instead of hurting VM because it could
175                  * make page cache thrashing.
176                  */
177                 mutex_unlock(&stream->mutex);
178                 wait_event(stream->wait,
179                         !list_empty(&stream->strm_list));
180         }
181
182         return decomp_strm;
183 }
184
185
186 int squashfs_decompress(struct squashfs_sb_info *msblk,
187         void **buffer, struct buffer_head **bh, int b, int offset, int length,
188         int srclength, int pages)
189 {
190         int res;
191         struct squashfs_stream *stream = msblk->stream;
192         struct decomp_stream *decomp_stream = get_decomp_stream(msblk, stream);
193         res = msblk->decompressor->decompress(msblk, decomp_stream->stream,
194                 buffer, bh, b, offset, length, srclength, pages);
195         put_decomp_stream(decomp_stream, stream);
196         if (res < 0)
197                 ERROR("%s decompression failed, data probably corrupt\n",
198                         msblk->decompressor->name);
199         return res;
200 }