1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Decompression module for stand alone file systems.
29 */
30
31 #include <sys/param.h>
32 #include <sys/sysmacros.h>
33 #include <sys/vnode.h>
34 #include <sys/bootvfs.h>
35 #include <sys/filep.h>
36 #include <zlib.h>
37
38 #ifdef _BOOT
39 #include "../common/util.h"
40 #else
41 #include <sys/sunddi.h>
42 #endif
43
44 #define MAX_DECOMP_BUFS 8
45 #define GZIP_ID_BYTE_1 0x1f
46 #define GZIP_ID_BYTE_2 0x8b
47 #define GZIP_CM_DEFLATE 0x08
48 #define SEEKBUFSIZE 8192
49
50 extern void prom_printf(const char *fmt, ...);
51
52 #ifdef _BOOT
53 #define dprintf if (cf_debug) prom_printf
54 #else
55 #define dprintf if (cf_debug) prom_printf
56
57 #endif
58
59 extern int bootrd_debug;
60 extern void *bkmem_alloc(size_t);
61 extern void bkmem_free(void *, size_t);
62
63 caddr_t scratch_bufs[MAX_DECOMP_BUFS]; /* array of free scratch mem bufs */
64 int decomp_bufcnt; /* total no, of allocated decomp bufs */
65 int free_dcomp_bufs; /* no. of free decomp bufs */
66 char seek_scrbuf[SEEKBUFSIZE]; /* buffer for seeking */
67 int cf_debug = 0; /* non-zero enables debug prints */
68
69 void *
cf_alloc(void * opaque,unsigned int items,unsigned int size)70 cf_alloc(void *opaque, unsigned int items, unsigned int size)
71 {
72 fileid_t *filep;
73 unsigned int nbytes;
74 caddr_t ptr;
75
76 filep = (fileid_t *)opaque;
77 nbytes = roundup(items * size, sizeof (long));
78 if (nbytes > (DECOMP_BUFSIZE - filep->fi_dcscrused)) {
79 ptr = bkmem_alloc(nbytes);
80 } else {
81 ptr = &filep->fi_dcscrbuf[filep->fi_dcscrused];
82 filep->fi_dcscrused += nbytes;
83 }
84 bzero(ptr, nbytes);
85 return (ptr);
86 }
87
88 /*
89 * Decompression scratch memory free routine, does nothing since we free
90 * the entire scratch area all at once on file close.
91 */
92 /* ARGSUSED */
93 void
cf_free(void * opaque,void * addr)94 cf_free(void *opaque, void *addr)
95 {
96 }
97
98 /*
99 * Read the first block of the file described by filep and determine if
100 * the file is gzip-compressed. If so, the compressed flag will be set
101 * in the fileid_t struct pointed to by filep and it will be initialized
102 * for doing decompression on reads to the file.
103 */
104 int
cf_check_compressed(fileid_t * filep)105 cf_check_compressed(fileid_t *filep)
106 {
107 unsigned char *filebytes;
108 z_stream *zsp;
109
110 /*
111 * checking for a dcfs compressed file first would involve:
112 *
113 * if (filep->fi_inode->i_cflags & ICOMPRESS)
114 * filep->fi_flags |= FI_COMPRESSED;
115 */
116
117 /*
118 * If the file is not long enough to check for a
119 * decompression header then return not compressed.
120 */
121 if (filep->fi_inode->i_size < 3)
122 return (0);
123 filep->fi_offset = 0;
124 if ((filep->fi_getblock)(filep) == -1)
125 return (-1);
126 filep->fi_offset = 0;
127 filep->fi_count = 0;
128 filep->fi_cfoff = 0;
129 filebytes = (unsigned char *)filep->fi_memp;
130 if (filebytes[0] != GZIP_ID_BYTE_1 ||
131 filebytes[1] != GZIP_ID_BYTE_2 ||
132 filebytes[2] != GZIP_CM_DEFLATE)
133 return (0); /* not compressed */
134 filep->fi_flags |= FI_COMPRESSED;
135
136 dprintf("file %s is compressed\n", filep->fi_path);
137
138 /*
139 * Allocate decompress scratch buffer
140 */
141 if (free_dcomp_bufs) {
142 filep->fi_dcscrbuf = scratch_bufs[--free_dcomp_bufs];
143 } else {
144 filep->fi_dcscrbuf = bkmem_alloc(DECOMP_BUFSIZE);
145 decomp_bufcnt++;
146 }
147 filep->fi_dcscrused = 0;
148 zsp = bkmem_alloc(sizeof (*zsp));
149 filep->fi_dcstream = zsp;
150 /*
151 * Initialize the decompression stream. Adding 16 to the window size
152 * indicates that zlib should expect a gzip header.
153 */
154 bzero(zsp, sizeof (*zsp));
155 zsp->opaque = filep;
156 zsp->zalloc = cf_alloc;
157 zsp->zfree = cf_free;
158 zsp->avail_in = 0;
159 zsp->next_in = NULL;
160 zsp->avail_out = 0;
161 zsp->next_out = NULL;
162 if (inflateInit2(zsp, MAX_WBITS | 0x20) != Z_OK) {
163 dprintf("inflateInit2() failed\n");
164 return (-1);
165 }
166 return (0);
167 }
168
169 /*
170 * If the file described by fileid_t struct at *filep is compressed
171 * free any resources associated with the decompression. (decompression
172 * buffer, etc.).
173 */
174 void
cf_close(fileid_t * filep)175 cf_close(fileid_t *filep)
176 {
177 if ((filep->fi_flags & FI_COMPRESSED) == 0)
178 return;
179 dprintf("cf_close: %s\n", filep->fi_path);
180 (void) inflateEnd(filep->fi_dcstream);
181 bkmem_free(filep->fi_dcstream, sizeof (z_stream));
182 if (free_dcomp_bufs == MAX_DECOMP_BUFS) {
183 bkmem_free(filep->fi_dcscrbuf, DECOMP_BUFSIZE);
184 } else {
185 scratch_bufs[free_dcomp_bufs++] = filep->fi_dcscrbuf;
186 }
187 }
188
189 void
cf_rewind(fileid_t * filep)190 cf_rewind(fileid_t *filep)
191 {
192 z_stream *zsp;
193
194 dprintf("cf_rewind: %s\n", filep->fi_path);
195 zsp = filep->fi_dcstream;
196 zsp->avail_in = 0;
197 zsp->next_in = NULL;
198 (void) inflateReset(zsp);
199 filep->fi_cfoff = 0;
200 }
201
202 #define FLG_FHCRC 0x02 /* crc field present */
203 #define FLG_FEXTRA 0x04 /* "extra" field present */
204 #define FLG_FNAME 0x08 /* file name field present */
205 #define FLG_FCOMMENT 0x10 /* comment field present */
206
207 /*
208 * Read at the current uncompressed offset from the compressed file described
209 * by *filep. Will return decompressed data.
210 */
211 int
cf_read(fileid_t * filep,caddr_t buf,size_t count)212 cf_read(fileid_t *filep, caddr_t buf, size_t count)
213 {
214 z_stream *zsp;
215 struct inode *ip;
216 int err = Z_OK;
217 int infbytes;
218 off_t soff;
219 caddr_t smemp;
220
221 dprintf("cf_read: %s ", filep->fi_path);
222 dprintf("%lx bytes\n", count);
223 zsp = filep->fi_dcstream;
224 ip = filep->fi_inode;
225 dprintf(" reading at offset %lx\n", zsp->total_out);
226 zsp->next_out = (unsigned char *)buf;
227 zsp->avail_out = count;
228 while (zsp->avail_out != 0) {
229 if (zsp->avail_in == 0 && filep->fi_cfoff < ip->i_size) {
230 /*
231 * read a block of the file to inflate
232 */
233 soff = filep->fi_offset;
234 smemp = filep->fi_memp;
235 filep->fi_memp = NULL;
236 filep->fi_offset = filep->fi_cfoff;
237 filep->fi_count = 0;
238 if ((*filep->fi_getblock)(filep) == -1)
239 return (-1);
240 filep->fi_offset = soff;
241 zsp->next_in = (unsigned char *)filep->fi_memp;
242 zsp->avail_in = filep->fi_count;
243 filep->fi_memp = smemp;
244 filep->fi_cfoff += filep->fi_count;
245 }
246 infbytes = zsp->avail_out;
247 dprintf("attempting inflate of %x bytes to buf at: %lx\n",
248 zsp->avail_out, (unsigned long)zsp->next_out);
249 err = inflate(zsp, Z_NO_FLUSH);
250 infbytes -= zsp->avail_out;
251 dprintf("inflated %x bytes, errcode=%d\n", infbytes, err);
252 /*
253 * break out if we hit end of the compressed file
254 * or the end of the compressed byte stream
255 */
256 if (filep->fi_cfoff >= ip->i_size || err == Z_STREAM_END)
257 break;
258 }
259 dprintf("cf_read: returned %lx bytes\n", count - zsp->avail_out);
260 return (count - zsp->avail_out);
261 }
262
263 /*
264 * Seek to the location specified by addr
265 */
266 void
cf_seek(fileid_t * filep,off_t addr,int whence)267 cf_seek(fileid_t *filep, off_t addr, int whence)
268 {
269 z_stream *zsp;
270 int readsz;
271
272 dprintf("cf_seek: %s ", filep->fi_path);
273 dprintf("to %lx\n", addr);
274 zsp = filep->fi_dcstream;
275 if (whence == SEEK_CUR)
276 addr += zsp->total_out;
277 /*
278 * To seek backwards, must rewind and seek forwards
279 */
280 if (addr < zsp->total_out) {
281 cf_rewind(filep);
282 filep->fi_offset = 0;
283 } else {
284 addr -= zsp->total_out;
285 }
286 while (addr > 0) {
287 readsz = MIN(addr, SEEKBUFSIZE);
288 (void) cf_read(filep, seek_scrbuf, readsz);
289 addr -= readsz;
290 }
291 }
292