xref: /openbmc/linux/drivers/block/zram/zcomp.c (revision c819e2cf)
1 /*
2  * Copyright (C) 2014 Sergey Senozhatsky.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version
7  * 2 of the License, or (at your option) any later version.
8  */
9 
10 #include <linux/kernel.h>
11 #include <linux/string.h>
12 #include <linux/err.h>
13 #include <linux/slab.h>
14 #include <linux/wait.h>
15 #include <linux/sched.h>
16 
17 #include "zcomp.h"
18 #include "zcomp_lzo.h"
19 #ifdef CONFIG_ZRAM_LZ4_COMPRESS
20 #include "zcomp_lz4.h"
21 #endif
22 
23 /*
24  * single zcomp_strm backend
25  */
26 struct zcomp_strm_single {
27 	struct mutex strm_lock;
28 	struct zcomp_strm *zstrm;
29 };
30 
31 /*
32  * multi zcomp_strm backend
33  */
34 struct zcomp_strm_multi {
35 	/* protect strm list */
36 	spinlock_t strm_lock;
37 	/* max possible number of zstrm streams */
38 	int max_strm;
39 	/* number of available zstrm streams */
40 	int avail_strm;
41 	/* list of available strms */
42 	struct list_head idle_strm;
43 	wait_queue_head_t strm_wait;
44 };
45 
46 static struct zcomp_backend *backends[] = {
47 	&zcomp_lzo,
48 #ifdef CONFIG_ZRAM_LZ4_COMPRESS
49 	&zcomp_lz4,
50 #endif
51 	NULL
52 };
53 
54 static struct zcomp_backend *find_backend(const char *compress)
55 {
56 	int i = 0;
57 	while (backends[i]) {
58 		if (sysfs_streq(compress, backends[i]->name))
59 			break;
60 		i++;
61 	}
62 	return backends[i];
63 }
64 
65 static void zcomp_strm_free(struct zcomp *comp, struct zcomp_strm *zstrm)
66 {
67 	if (zstrm->private)
68 		comp->backend->destroy(zstrm->private);
69 	free_pages((unsigned long)zstrm->buffer, 1);
70 	kfree(zstrm);
71 }
72 
73 /*
74  * allocate new zcomp_strm structure with ->private initialized by
75  * backend, return NULL on error
76  */
77 static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp)
78 {
79 	struct zcomp_strm *zstrm = kmalloc(sizeof(*zstrm), GFP_KERNEL);
80 	if (!zstrm)
81 		return NULL;
82 
83 	zstrm->private = comp->backend->create();
84 	/*
85 	 * allocate 2 pages. 1 for compressed data, plus 1 extra for the
86 	 * case when compressed size is larger than the original one
87 	 */
88 	zstrm->buffer = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1);
89 	if (!zstrm->private || !zstrm->buffer) {
90 		zcomp_strm_free(comp, zstrm);
91 		zstrm = NULL;
92 	}
93 	return zstrm;
94 }
95 
96 /*
97  * get idle zcomp_strm or wait until other process release
98  * (zcomp_strm_release()) one for us
99  */
100 static struct zcomp_strm *zcomp_strm_multi_find(struct zcomp *comp)
101 {
102 	struct zcomp_strm_multi *zs = comp->stream;
103 	struct zcomp_strm *zstrm;
104 
105 	while (1) {
106 		spin_lock(&zs->strm_lock);
107 		if (!list_empty(&zs->idle_strm)) {
108 			zstrm = list_entry(zs->idle_strm.next,
109 					struct zcomp_strm, list);
110 			list_del(&zstrm->list);
111 			spin_unlock(&zs->strm_lock);
112 			return zstrm;
113 		}
114 		/* zstrm streams limit reached, wait for idle stream */
115 		if (zs->avail_strm >= zs->max_strm) {
116 			spin_unlock(&zs->strm_lock);
117 			wait_event(zs->strm_wait, !list_empty(&zs->idle_strm));
118 			continue;
119 		}
120 		/* allocate new zstrm stream */
121 		zs->avail_strm++;
122 		spin_unlock(&zs->strm_lock);
123 
124 		zstrm = zcomp_strm_alloc(comp);
125 		if (!zstrm) {
126 			spin_lock(&zs->strm_lock);
127 			zs->avail_strm--;
128 			spin_unlock(&zs->strm_lock);
129 			wait_event(zs->strm_wait, !list_empty(&zs->idle_strm));
130 			continue;
131 		}
132 		break;
133 	}
134 	return zstrm;
135 }
136 
137 /* add stream back to idle list and wake up waiter or free the stream */
138 static void zcomp_strm_multi_release(struct zcomp *comp, struct zcomp_strm *zstrm)
139 {
140 	struct zcomp_strm_multi *zs = comp->stream;
141 
142 	spin_lock(&zs->strm_lock);
143 	if (zs->avail_strm <= zs->max_strm) {
144 		list_add(&zstrm->list, &zs->idle_strm);
145 		spin_unlock(&zs->strm_lock);
146 		wake_up(&zs->strm_wait);
147 		return;
148 	}
149 
150 	zs->avail_strm--;
151 	spin_unlock(&zs->strm_lock);
152 	zcomp_strm_free(comp, zstrm);
153 }
154 
155 /* change max_strm limit */
156 static bool zcomp_strm_multi_set_max_streams(struct zcomp *comp, int num_strm)
157 {
158 	struct zcomp_strm_multi *zs = comp->stream;
159 	struct zcomp_strm *zstrm;
160 
161 	spin_lock(&zs->strm_lock);
162 	zs->max_strm = num_strm;
163 	/*
164 	 * if user has lowered the limit and there are idle streams,
165 	 * immediately free as much streams (and memory) as we can.
166 	 */
167 	while (zs->avail_strm > num_strm && !list_empty(&zs->idle_strm)) {
168 		zstrm = list_entry(zs->idle_strm.next,
169 				struct zcomp_strm, list);
170 		list_del(&zstrm->list);
171 		zcomp_strm_free(comp, zstrm);
172 		zs->avail_strm--;
173 	}
174 	spin_unlock(&zs->strm_lock);
175 	return true;
176 }
177 
178 static void zcomp_strm_multi_destroy(struct zcomp *comp)
179 {
180 	struct zcomp_strm_multi *zs = comp->stream;
181 	struct zcomp_strm *zstrm;
182 
183 	while (!list_empty(&zs->idle_strm)) {
184 		zstrm = list_entry(zs->idle_strm.next,
185 				struct zcomp_strm, list);
186 		list_del(&zstrm->list);
187 		zcomp_strm_free(comp, zstrm);
188 	}
189 	kfree(zs);
190 }
191 
192 static int zcomp_strm_multi_create(struct zcomp *comp, int max_strm)
193 {
194 	struct zcomp_strm *zstrm;
195 	struct zcomp_strm_multi *zs;
196 
197 	comp->destroy = zcomp_strm_multi_destroy;
198 	comp->strm_find = zcomp_strm_multi_find;
199 	comp->strm_release = zcomp_strm_multi_release;
200 	comp->set_max_streams = zcomp_strm_multi_set_max_streams;
201 	zs = kmalloc(sizeof(struct zcomp_strm_multi), GFP_KERNEL);
202 	if (!zs)
203 		return -ENOMEM;
204 
205 	comp->stream = zs;
206 	spin_lock_init(&zs->strm_lock);
207 	INIT_LIST_HEAD(&zs->idle_strm);
208 	init_waitqueue_head(&zs->strm_wait);
209 	zs->max_strm = max_strm;
210 	zs->avail_strm = 1;
211 
212 	zstrm = zcomp_strm_alloc(comp);
213 	if (!zstrm) {
214 		kfree(zs);
215 		return -ENOMEM;
216 	}
217 	list_add(&zstrm->list, &zs->idle_strm);
218 	return 0;
219 }
220 
221 static struct zcomp_strm *zcomp_strm_single_find(struct zcomp *comp)
222 {
223 	struct zcomp_strm_single *zs = comp->stream;
224 	mutex_lock(&zs->strm_lock);
225 	return zs->zstrm;
226 }
227 
228 static void zcomp_strm_single_release(struct zcomp *comp,
229 		struct zcomp_strm *zstrm)
230 {
231 	struct zcomp_strm_single *zs = comp->stream;
232 	mutex_unlock(&zs->strm_lock);
233 }
234 
235 static bool zcomp_strm_single_set_max_streams(struct zcomp *comp, int num_strm)
236 {
237 	/* zcomp_strm_single support only max_comp_streams == 1 */
238 	return false;
239 }
240 
241 static void zcomp_strm_single_destroy(struct zcomp *comp)
242 {
243 	struct zcomp_strm_single *zs = comp->stream;
244 	zcomp_strm_free(comp, zs->zstrm);
245 	kfree(zs);
246 }
247 
248 static int zcomp_strm_single_create(struct zcomp *comp)
249 {
250 	struct zcomp_strm_single *zs;
251 
252 	comp->destroy = zcomp_strm_single_destroy;
253 	comp->strm_find = zcomp_strm_single_find;
254 	comp->strm_release = zcomp_strm_single_release;
255 	comp->set_max_streams = zcomp_strm_single_set_max_streams;
256 	zs = kmalloc(sizeof(struct zcomp_strm_single), GFP_KERNEL);
257 	if (!zs)
258 		return -ENOMEM;
259 
260 	comp->stream = zs;
261 	mutex_init(&zs->strm_lock);
262 	zs->zstrm = zcomp_strm_alloc(comp);
263 	if (!zs->zstrm) {
264 		kfree(zs);
265 		return -ENOMEM;
266 	}
267 	return 0;
268 }
269 
270 /* show available compressors */
271 ssize_t zcomp_available_show(const char *comp, char *buf)
272 {
273 	ssize_t sz = 0;
274 	int i = 0;
275 
276 	while (backends[i]) {
277 		if (sysfs_streq(comp, backends[i]->name))
278 			sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
279 					"[%s] ", backends[i]->name);
280 		else
281 			sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
282 					"%s ", backends[i]->name);
283 		i++;
284 	}
285 	sz += scnprintf(buf + sz, PAGE_SIZE - sz, "\n");
286 	return sz;
287 }
288 
289 bool zcomp_set_max_streams(struct zcomp *comp, int num_strm)
290 {
291 	return comp->set_max_streams(comp, num_strm);
292 }
293 
294 struct zcomp_strm *zcomp_strm_find(struct zcomp *comp)
295 {
296 	return comp->strm_find(comp);
297 }
298 
299 void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm)
300 {
301 	comp->strm_release(comp, zstrm);
302 }
303 
304 int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
305 		const unsigned char *src, size_t *dst_len)
306 {
307 	return comp->backend->compress(src, zstrm->buffer, dst_len,
308 			zstrm->private);
309 }
310 
311 int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
312 		size_t src_len, unsigned char *dst)
313 {
314 	return comp->backend->decompress(src, src_len, dst);
315 }
316 
317 void zcomp_destroy(struct zcomp *comp)
318 {
319 	comp->destroy(comp);
320 	kfree(comp);
321 }
322 
323 /*
324  * search available compressors for requested algorithm.
325  * allocate new zcomp and initialize it. return compressing
326  * backend pointer or ERR_PTR if things went bad. ERR_PTR(-EINVAL)
327  * if requested algorithm is not supported, ERR_PTR(-ENOMEM) in
328  * case of allocation error.
329  */
330 struct zcomp *zcomp_create(const char *compress, int max_strm)
331 {
332 	struct zcomp *comp;
333 	struct zcomp_backend *backend;
334 
335 	backend = find_backend(compress);
336 	if (!backend)
337 		return ERR_PTR(-EINVAL);
338 
339 	comp = kzalloc(sizeof(struct zcomp), GFP_KERNEL);
340 	if (!comp)
341 		return ERR_PTR(-ENOMEM);
342 
343 	comp->backend = backend;
344 	if (max_strm > 1)
345 		zcomp_strm_multi_create(comp, max_strm);
346 	else
347 		zcomp_strm_single_create(comp);
348 	if (!comp->stream) {
349 		kfree(comp);
350 		return ERR_PTR(-ENOMEM);
351 	}
352 	return comp;
353 }
354