v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / fs / jffs2 / compr_zlib.c
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright (C) 2001 Red Hat, Inc.
5  *
6  * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
7  *
8  * The original JFFS, from which the design for JFFS2 was derived,
9  * was designed and implemented by Axis Communications AB.
10  *
11  * The contents of this file are subject to the Red Hat eCos Public
12  * License Version 1.1 (the "Licence"); you may not use this file
13  * except in compliance with the Licence.  You may obtain a copy of
14  * the Licence at http://www.redhat.com/
15  *
16  * Software distributed under the Licence is distributed on an "AS IS"
17  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
18  * See the Licence for the specific language governing rights and
19  * limitations under the Licence.
20  *
21  * The Original Code is JFFS2 - Journalling Flash File System, version 2
22  *
23  * Alternatively, the contents of this file may be used under the
24  * terms of the GNU General Public License version 2 (the "GPL"), in
25  * which case the provisions of the GPL are applicable instead of the
26  * above.  If you wish to allow the use of your version of this file
27  * only under the terms of the GPL and not to allow others to use your
28  * version of this file under the RHEPL, indicate your decision by
29  * deleting the provisions above and replace them with the notice and
30  * other provisions required by the GPL.  If you do not delete the
31  * provisions above, a recipient may use your version of this file
32  * under either the RHEPL or the GPL.
33  *
34  * $Id: compr_zlib.c,v 1.6 2001/04/18 15:04:00 dwmw2 Exp $
35  *
36  */
37
38 #include "zlib.h"
39
40 #ifdef __KERNEL__
41 #include <linux/kernel.h>
42 #include <linux/slab.h>
43 #include <linux/jffs2.h>
44 #include "nodelist.h"
45
46 static void *zalloc(void *opaque, unsigned nr, unsigned size)
47 {
48         /* How much does it request? Should we use vmalloc? Or be dynamic? */
49         return kmalloc(nr * size, GFP_KERNEL);
50 }
51
52 static void zfree(void *opaque, void *addr)
53 {
54         kfree(addr);
55 }
56 #else
57 #define min(x,y) ((x)<(y)?(x):(y))
58 #ifndef D1
59 #define D1(x)
60 #endif
61 #define KERN_DEBUG
62 #define KERN_NOTICE
63 #define KERN_WARNING
64 #define printk printf
65 #include <stdio.h>
66 #include <asm/types.h>
67 #endif
68
69         /* Plan: call deflate() with avail_in == *sourcelen, 
70                 avail_out = *dstlen - 12 and flush == Z_FINISH. 
71                 If it doesn't manage to finish, call it again with
72                 avail_in == 0 and avail_out set to the remaining 12
73                 bytes for it to clean up. 
74            Q: Is 12 bytes sufficient?
75         */
76 #define STREAM_END_SPACE 12
77
78 int zlib_compress(unsigned char *data_in, unsigned char *cpage_out, 
79                    __u32 *sourcelen, __u32 *dstlen)
80 {
81         z_stream strm;
82         int ret;
83
84         if (*dstlen <= STREAM_END_SPACE)
85                 return -1;
86
87 #ifdef __KERNEL__
88         strm.zalloc = zalloc;
89         strm.zfree = zfree;
90 #else
91         strm.zalloc = (void *)0;
92         strm.zfree = (void *)0;
93 #endif
94
95         if (Z_OK != deflateInit(&strm, 3)) {
96                 printk(KERN_WARNING "deflateInit failed\n");
97                 return -1;
98         }
99         strm.next_in = data_in;
100         strm.total_in = 0;
101         
102         strm.next_out = cpage_out;
103         strm.total_out = 0;
104
105         while (strm.total_out < *dstlen - STREAM_END_SPACE && strm.total_in < *sourcelen) {
106                 strm.avail_out = *dstlen - (strm.total_out + STREAM_END_SPACE);
107                 strm.avail_in = min(*sourcelen-strm.total_in, strm.avail_out);
108                 D1(printk(KERN_DEBUG "calling deflate with avail_in %d, avail_out %d\n",
109                           strm.avail_in, strm.avail_out));
110                 ret = deflate(&strm, Z_PARTIAL_FLUSH);
111                 D1(printk(KERN_DEBUG "deflate returned with avail_in %d, avail_out %d, total_in %ld, total_out %ld\n", 
112                           strm.avail_in, strm.avail_out, strm.total_in, strm.total_out));
113                 if (ret != Z_OK) {
114                         D1(printk(KERN_DEBUG "deflate in loop returned %d\n", ret));
115                         deflateEnd(&strm);
116                         return -1;
117                 }
118         }
119         strm.avail_out += STREAM_END_SPACE;
120         strm.avail_in = 0;
121         ret = deflate(&strm, Z_FINISH);
122         if (ret != Z_STREAM_END) {
123                 D1(printk(KERN_DEBUG "final deflate returned %d\n", ret));
124                 deflateEnd(&strm);
125                 return -1;
126         }
127         deflateEnd(&strm);
128
129         D1(printk(KERN_DEBUG "zlib compressed %ld bytes into %ld\n", strm.total_in, strm.total_out));
130
131         if (strm.total_out >= strm.total_in)
132                 return -1;
133
134
135         *dstlen = strm.total_out;
136         *sourcelen = strm.total_in;
137         return 0;
138 }
139
140 void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
141                       __u32 srclen, __u32 destlen)
142 {
143         z_stream strm;
144         int ret;
145
146 #ifdef __KERNEL__
147         strm.zalloc = zalloc;
148         strm.zfree = zfree;
149 #else
150         strm.zalloc = (void *)0;
151         strm.zfree = (void *)0;
152 #endif
153
154         if (Z_OK != inflateInit(&strm)) {
155                 printk(KERN_WARNING "inflateInit failed\n");
156                 return;
157         }
158         strm.next_in = data_in;
159         strm.avail_in = srclen;
160         strm.total_in = 0;
161         
162         strm.next_out = cpage_out;
163         strm.avail_out = destlen;
164         strm.total_out = 0;
165
166         while((ret = inflate(&strm, Z_FINISH)) == Z_OK)
167                 ;
168         if (ret != Z_STREAM_END) {
169                 printk(KERN_NOTICE "inflate returned %d\n", ret);
170         }
171         inflateEnd(&strm);
172 }