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