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