zlib.c revision 696ab562
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2008 Oracle.  All rights reserved.
4 *
5 * Based on jffs2 zlib code:
6 * Copyright �� 2001-2007 Red Hat, Inc.
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 */
9
10#include <linux/kernel.h>
11#include <linux/slab.h>
12#include <linux/zlib.h>
13#include <linux/zutil.h>
14#include <linux/mm.h>
15#include <linux/init.h>
16#include <linux/err.h>
17#include <linux/sched.h>
18#include <linux/pagemap.h>
19#include <linux/bio.h>
20#include <linux/refcount.h>
21#include "compression.h"
22
23/* workspace buffer size for s390 zlib hardware support */
24#define ZLIB_DFLTCC_BUF_SIZE    (4 * PAGE_SIZE)
25
26struct workspace {
27	z_stream strm;
28	char *buf;
29	unsigned int buf_size;
30	struct list_head list;
31	int level;
32};
33
34static struct workspace_manager wsm;
35
36struct list_head *zlib_get_workspace(unsigned int level)
37{
38	struct list_head *ws = btrfs_get_workspace(BTRFS_COMPRESS_ZLIB, level);
39	struct workspace *workspace = list_entry(ws, struct workspace, list);
40
41	workspace->level = level;
42
43	return ws;
44}
45
46void zlib_free_workspace(struct list_head *ws)
47{
48	struct workspace *workspace = list_entry(ws, struct workspace, list);
49
50	kvfree(workspace->strm.workspace);
51	kfree(workspace->buf);
52	kfree(workspace);
53}
54
55struct list_head *zlib_alloc_workspace(unsigned int level)
56{
57	struct workspace *workspace;
58	int workspacesize;
59
60	workspace = kzalloc(sizeof(*workspace), GFP_KERNEL);
61	if (!workspace)
62		return ERR_PTR(-ENOMEM);
63
64	workspacesize = max(zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL),
65			zlib_inflate_workspacesize());
66	workspace->strm.workspace = kvmalloc(workspacesize, GFP_KERNEL);
67	workspace->level = level;
68	workspace->buf = NULL;
69	/*
70	 * In case of s390 zlib hardware support, allocate lager workspace
71	 * buffer. If allocator fails, fall back to a single page buffer.
72	 */
73	if (zlib_deflate_dfltcc_enabled()) {
74		workspace->buf = kmalloc(ZLIB_DFLTCC_BUF_SIZE,
75					 __GFP_NOMEMALLOC | __GFP_NORETRY |
76					 __GFP_NOWARN | GFP_NOIO);
77		workspace->buf_size = ZLIB_DFLTCC_BUF_SIZE;
78	}
79	if (!workspace->buf) {
80		workspace->buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
81		workspace->buf_size = PAGE_SIZE;
82	}
83	if (!workspace->strm.workspace || !workspace->buf)
84		goto fail;
85
86	INIT_LIST_HEAD(&workspace->list);
87
88	return &workspace->list;
89fail:
90	zlib_free_workspace(&workspace->list);
91	return ERR_PTR(-ENOMEM);
92}
93
94int zlib_compress_pages(struct list_head *ws, struct address_space *mapping,
95		u64 start, struct page **pages, unsigned long *out_pages,
96		unsigned long *total_in, unsigned long *total_out)
97{
98	struct workspace *workspace = list_entry(ws, struct workspace, list);
99	int ret;
100	char *data_in;
101	char *cpage_out;
102	int nr_pages = 0;
103	struct page *in_page = NULL;
104	struct page *out_page = NULL;
105	unsigned long bytes_left;
106	unsigned int in_buf_pages;
107	unsigned long len = *total_out;
108	unsigned long nr_dest_pages = *out_pages;
109	const unsigned long max_out = nr_dest_pages * PAGE_SIZE;
110
111	*out_pages = 0;
112	*total_out = 0;
113	*total_in = 0;
114
115	if (Z_OK != zlib_deflateInit(&workspace->strm, workspace->level)) {
116		pr_warn("BTRFS: deflateInit failed\n");
117		ret = -EIO;
118		goto out;
119	}
120
121	workspace->strm.total_in = 0;
122	workspace->strm.total_out = 0;
123
124	out_page = alloc_page(GFP_NOFS);
125	if (out_page == NULL) {
126		ret = -ENOMEM;
127		goto out;
128	}
129	cpage_out = page_address(out_page);
130	pages[0] = out_page;
131	nr_pages = 1;
132
133	workspace->strm.next_in = workspace->buf;
134	workspace->strm.avail_in = 0;
135	workspace->strm.next_out = cpage_out;
136	workspace->strm.avail_out = PAGE_SIZE;
137
138	while (workspace->strm.total_in < len) {
139		/*
140		 * Get next input pages and copy the contents to
141		 * the workspace buffer if required.
142		 */
143		if (workspace->strm.avail_in == 0) {
144			bytes_left = len - workspace->strm.total_in;
145			in_buf_pages = min(DIV_ROUND_UP(bytes_left, PAGE_SIZE),
146					   workspace->buf_size / PAGE_SIZE);
147			if (in_buf_pages > 1) {
148				int i;
149
150				for (i = 0; i < in_buf_pages; i++) {
151					if (in_page)
152						put_page(in_page);
153					in_page = find_get_page(mapping,
154								start >> PAGE_SHIFT);
155					data_in = page_address(in_page);
156					memcpy(workspace->buf + i * PAGE_SIZE,
157					       data_in, PAGE_SIZE);
158					start += PAGE_SIZE;
159				}
160				workspace->strm.next_in = workspace->buf;
161			} else {
162				if (in_page)
163					put_page(in_page);
164				in_page = find_get_page(mapping,
165							start >> PAGE_SHIFT);
166				data_in = page_address(in_page);
167				start += PAGE_SIZE;
168				workspace->strm.next_in = data_in;
169			}
170			workspace->strm.avail_in = min(bytes_left,
171						       (unsigned long) workspace->buf_size);
172		}
173
174		ret = zlib_deflate(&workspace->strm, Z_SYNC_FLUSH);
175		if (ret != Z_OK) {
176			pr_debug("BTRFS: deflate in loop returned %d\n",
177			       ret);
178			zlib_deflateEnd(&workspace->strm);
179			ret = -EIO;
180			goto out;
181		}
182
183		/* we're making it bigger, give up */
184		if (workspace->strm.total_in > 8192 &&
185		    workspace->strm.total_in <
186		    workspace->strm.total_out) {
187			ret = -E2BIG;
188			goto out;
189		}
190		/* we need another page for writing out.  Test this
191		 * before the total_in so we will pull in a new page for
192		 * the stream end if required
193		 */
194		if (workspace->strm.avail_out == 0) {
195			if (nr_pages == nr_dest_pages) {
196				out_page = NULL;
197				ret = -E2BIG;
198				goto out;
199			}
200			out_page = alloc_page(GFP_NOFS);
201			if (out_page == NULL) {
202				ret = -ENOMEM;
203				goto out;
204			}
205			cpage_out = page_address(out_page);
206			pages[nr_pages] = out_page;
207			nr_pages++;
208			workspace->strm.avail_out = PAGE_SIZE;
209			workspace->strm.next_out = cpage_out;
210		}
211		/* we're all done */
212		if (workspace->strm.total_in >= len)
213			break;
214		if (workspace->strm.total_out > max_out)
215			break;
216	}
217	workspace->strm.avail_in = 0;
218	/*
219	 * Call deflate with Z_FINISH flush parameter providing more output
220	 * space but no more input data, until it returns with Z_STREAM_END.
221	 */
222	while (ret != Z_STREAM_END) {
223		ret = zlib_deflate(&workspace->strm, Z_FINISH);
224		if (ret == Z_STREAM_END)
225			break;
226		if (ret != Z_OK && ret != Z_BUF_ERROR) {
227			zlib_deflateEnd(&workspace->strm);
228			ret = -EIO;
229			goto out;
230		} else if (workspace->strm.avail_out == 0) {
231			/* get another page for the stream end */
232			if (nr_pages == nr_dest_pages) {
233				out_page = NULL;
234				ret = -E2BIG;
235				goto out;
236			}
237			out_page = alloc_page(GFP_NOFS);
238			if (out_page == NULL) {
239				ret = -ENOMEM;
240				goto out;
241			}
242			cpage_out = page_address(out_page);
243			pages[nr_pages] = out_page;
244			nr_pages++;
245			workspace->strm.avail_out = PAGE_SIZE;
246			workspace->strm.next_out = cpage_out;
247		}
248	}
249	zlib_deflateEnd(&workspace->strm);
250
251	if (workspace->strm.total_out >= workspace->strm.total_in) {
252		ret = -E2BIG;
253		goto out;
254	}
255
256	ret = 0;
257	*total_out = workspace->strm.total_out;
258	*total_in = workspace->strm.total_in;
259out:
260	*out_pages = nr_pages;
261	if (in_page)
262		put_page(in_page);
263	return ret;
264}
265
266int zlib_decompress_bio(struct list_head *ws, struct compressed_bio *cb)
267{
268	struct workspace *workspace = list_entry(ws, struct workspace, list);
269	int ret = 0, ret2;
270	int wbits = MAX_WBITS;
271	char *data_in;
272	size_t total_out = 0;
273	unsigned long page_in_index = 0;
274	size_t srclen = cb->compressed_len;
275	unsigned long total_pages_in = DIV_ROUND_UP(srclen, PAGE_SIZE);
276	unsigned long buf_start;
277	struct page **pages_in = cb->compressed_pages;
278	u64 disk_start = cb->start;
279	struct bio *orig_bio = cb->orig_bio;
280
281	data_in = page_address(pages_in[page_in_index]);
282	workspace->strm.next_in = data_in;
283	workspace->strm.avail_in = min_t(size_t, srclen, PAGE_SIZE);
284	workspace->strm.total_in = 0;
285
286	workspace->strm.total_out = 0;
287	workspace->strm.next_out = workspace->buf;
288	workspace->strm.avail_out = workspace->buf_size;
289
290	/* If it's deflate, and it's got no preset dictionary, then
291	   we can tell zlib to skip the adler32 check. */
292	if (srclen > 2 && !(data_in[1] & PRESET_DICT) &&
293	    ((data_in[0] & 0x0f) == Z_DEFLATED) &&
294	    !(((data_in[0]<<8) + data_in[1]) % 31)) {
295
296		wbits = -((data_in[0] >> 4) + 8);
297		workspace->strm.next_in += 2;
298		workspace->strm.avail_in -= 2;
299	}
300
301	if (Z_OK != zlib_inflateInit2(&workspace->strm, wbits)) {
302		pr_warn("BTRFS: inflateInit failed\n");
303		return -EIO;
304	}
305	while (workspace->strm.total_in < srclen) {
306		ret = zlib_inflate(&workspace->strm, Z_NO_FLUSH);
307		if (ret != Z_OK && ret != Z_STREAM_END)
308			break;
309
310		buf_start = total_out;
311		total_out = workspace->strm.total_out;
312
313		/* we didn't make progress in this inflate call, we're done */
314		if (buf_start == total_out)
315			break;
316
317		ret2 = btrfs_decompress_buf2page(workspace->buf, buf_start,
318						 total_out, disk_start,
319						 orig_bio);
320		if (ret2 == 0) {
321			ret = 0;
322			goto done;
323		}
324
325		workspace->strm.next_out = workspace->buf;
326		workspace->strm.avail_out = workspace->buf_size;
327
328		if (workspace->strm.avail_in == 0) {
329			unsigned long tmp;
330
331			page_in_index++;
332			if (page_in_index >= total_pages_in) {
333				data_in = NULL;
334				break;
335			}
336			data_in = page_address(pages_in[page_in_index]);
337			workspace->strm.next_in = data_in;
338			tmp = srclen - workspace->strm.total_in;
339			workspace->strm.avail_in = min(tmp,
340							   PAGE_SIZE);
341		}
342	}
343	if (ret != Z_STREAM_END)
344		ret = -EIO;
345	else
346		ret = 0;
347done:
348	zlib_inflateEnd(&workspace->strm);
349	if (!ret)
350		zero_fill_bio(orig_bio);
351	return ret;
352}
353
354int zlib_decompress(struct list_head *ws, unsigned char *data_in,
355		struct page *dest_page, unsigned long start_byte, size_t srclen,
356		size_t destlen)
357{
358	struct workspace *workspace = list_entry(ws, struct workspace, list);
359	int ret = 0;
360	int wbits = MAX_WBITS;
361	unsigned long bytes_left;
362	unsigned long total_out = 0;
363	unsigned long pg_offset = 0;
364
365	destlen = min_t(unsigned long, destlen, PAGE_SIZE);
366	bytes_left = destlen;
367
368	workspace->strm.next_in = data_in;
369	workspace->strm.avail_in = srclen;
370	workspace->strm.total_in = 0;
371
372	workspace->strm.next_out = workspace->buf;
373	workspace->strm.avail_out = workspace->buf_size;
374	workspace->strm.total_out = 0;
375	/* If it's deflate, and it's got no preset dictionary, then
376	   we can tell zlib to skip the adler32 check. */
377	if (srclen > 2 && !(data_in[1] & PRESET_DICT) &&
378	    ((data_in[0] & 0x0f) == Z_DEFLATED) &&
379	    !(((data_in[0]<<8) + data_in[1]) % 31)) {
380
381		wbits = -((data_in[0] >> 4) + 8);
382		workspace->strm.next_in += 2;
383		workspace->strm.avail_in -= 2;
384	}
385
386	if (Z_OK != zlib_inflateInit2(&workspace->strm, wbits)) {
387		pr_warn("BTRFS: inflateInit failed\n");
388		return -EIO;
389	}
390
391	while (bytes_left > 0) {
392		unsigned long buf_start;
393		unsigned long buf_offset;
394		unsigned long bytes;
395
396		ret = zlib_inflate(&workspace->strm, Z_NO_FLUSH);
397		if (ret != Z_OK && ret != Z_STREAM_END)
398			break;
399
400		buf_start = total_out;
401		total_out = workspace->strm.total_out;
402
403		if (total_out == buf_start) {
404			ret = -EIO;
405			break;
406		}
407
408		if (total_out <= start_byte)
409			goto next;
410
411		if (total_out > start_byte && buf_start < start_byte)
412			buf_offset = start_byte - buf_start;
413		else
414			buf_offset = 0;
415
416		bytes = min(PAGE_SIZE - pg_offset,
417			    PAGE_SIZE - (buf_offset % PAGE_SIZE));
418		bytes = min(bytes, bytes_left);
419
420		memcpy_to_page(dest_page, pg_offset,
421			       workspace->buf + buf_offset, bytes);
422
423		pg_offset += bytes;
424		bytes_left -= bytes;
425next:
426		workspace->strm.next_out = workspace->buf;
427		workspace->strm.avail_out = workspace->buf_size;
428	}
429
430	if (ret != Z_STREAM_END && bytes_left != 0)
431		ret = -EIO;
432	else
433		ret = 0;
434
435	zlib_inflateEnd(&workspace->strm);
436
437	/*
438	 * this should only happen if zlib returned fewer bytes than we
439	 * expected.  btrfs_get_block is responsible for zeroing from the
440	 * end of the inline extent (destlen) to the end of the page
441	 */
442	if (pg_offset < destlen) {
443		memzero_page(dest_page, pg_offset, destlen - pg_offset);
444	}
445	return ret;
446}
447
448const struct btrfs_compress_op btrfs_zlib_compress = {
449	.workspace_manager	= &wsm,
450	.max_level		= 9,
451	.default_level		= BTRFS_ZLIB_DEFAULT_LEVEL,
452};
453