?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Indentation fix, cleanup.
[AROS.git] / arch / all-pc / boot / grub2-aros / grub-core / fs / squash4.c
blobb97b34440ed10d93eab511a2f6613eb1ed8f3d2f
1 /* squash4.c - SquashFS */
2 /*
3 * GRUB -- GRand Unified Bootloader
4 * Copyright (C) 2010 Free Software Foundation, Inc.
5 *
6 * GRUB is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GRUB is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <grub/err.h>
21 #include <grub/file.h>
22 #include <grub/mm.h>
23 #include <grub/misc.h>
24 #include <grub/disk.h>
25 #include <grub/dl.h>
26 #include <grub/types.h>
27 #include <grub/fshelp.h>
28 #include <grub/deflate.h>
29 #include <minilzo.h>
30
31 #include "xz.h"
32 #include "xz_stream.h"
33
34 GRUB_MOD_LICENSE ("GPLv3+");
35
36 /*
37 object format Pointed by
38 superblock RAW Fixed offset (0)
39 data RAW ? Fixed offset (60)
40 inode table Chunk superblock
41 dir table Chunk superblock
42 fragment table Chunk unk1
43 unk1 RAW, Chunk superblock
44 unk2 RAW superblock
45 UID/GID Chunk exttblptr
46 exttblptr RAW superblock
47
48 UID/GID table is the array ot uint32_t
49 unk1 contains pointer to fragment table followed by some chunk.
50 unk2 containts one uint64_t
51 */
52
53 struct grub_squash_super
54 {
55 grub_uint32_t magic;
56 #define SQUASH_MAGIC 0x73717368
57 grub_uint32_t dummy1;
58 grub_uint32_t creation_time;
59 grub_uint32_t block_size;
60 grub_uint32_t dummy2;
61 grub_uint16_t compression;
62 grub_uint16_t dummy3;
63 grub_uint64_t dummy4;
64 grub_uint16_t root_ino_offset;
65 grub_uint32_t root_ino_chunk;
66 grub_uint16_t dummy5;
67 grub_uint64_t total_size;
68 grub_uint64_t exttbloffset;
69 grub_uint64_t dummy6;
70 grub_uint64_t inodeoffset;
71 grub_uint64_t diroffset;
72 grub_uint64_t unk1offset;
73 grub_uint64_t unk2offset;
74 } GRUB_PACKED;
75
76 /* Chunk-based */
77 struct grub_squash_inode
78 {
79 /* Same values as direlem types. */
80 grub_uint16_t type;
81 grub_uint16_t dummy[3];
82 grub_uint32_t mtime;
83 grub_uint32_t dummy2;
84 union
85 {
86 struct {
87 grub_uint32_t chunk;
88 grub_uint32_t fragment;
89 grub_uint32_t offset;
90 grub_uint32_t size;
91 grub_uint32_t block_size[0];
92 } GRUB_PACKED file;
93 struct {
94 grub_uint64_t chunk;
95 grub_uint64_t size;
96 grub_uint32_t dummy1[3];
97 grub_uint32_t fragment;
98 grub_uint32_t offset;
99 grub_uint32_t dummy3;
100 grub_uint32_t block_size[0];
101 } GRUB_PACKED long_file;
102 struct {
103 grub_uint32_t chunk;
104 grub_uint32_t dummy;
105 grub_uint16_t size;
106 grub_uint16_t offset;
107 } GRUB_PACKED dir;
108 struct {
109 grub_uint32_t dummy1;
110 grub_uint32_t size;
111 grub_uint32_t chunk;
112 grub_uint32_t dummy2;
113 grub_uint16_t dummy3;
114 grub_uint16_t offset;
115 } GRUB_PACKED long_dir;
116 struct {
117 grub_uint32_t dummy;
118 grub_uint32_t namelen;
119 char name[0];
120 } GRUB_PACKED symlink;
121 } GRUB_PACKED;
122 } GRUB_PACKED;
123
124 struct grub_squash_cache_inode
125 {
126 struct grub_squash_inode ino;
127 grub_disk_addr_t ino_chunk;
128 grub_uint16_t ino_offset;
129 grub_uint32_t *block_sizes;
130 grub_disk_addr_t *cumulated_block_sizes;
131 };
132
133 /* Chunk-based. */
134 struct grub_squash_dirent_header
135 {
136 /* Actually the value is the number of elements - 1. */
137 grub_uint32_t nelems;
138 grub_uint32_t ino_chunk;
139 grub_uint32_t dummy;
140 } GRUB_PACKED;
141
142 struct grub_squash_dirent
143 {
144 grub_uint16_t ino_offset;
145 grub_uint16_t dummy;
146 grub_uint16_t type;
147 /* Actually the value is the length of name - 1. */
148 grub_uint16_t namelen;
149 char name[0];
150 } GRUB_PACKED;
151
152 enum
153 {
154 SQUASH_TYPE_DIR = 1,
155 SQUASH_TYPE_REGULAR = 2,
156 SQUASH_TYPE_SYMLINK = 3,
157 SQUASH_TYPE_LONG_DIR = 8,
158 SQUASH_TYPE_LONG_REGULAR = 9,
159 };
160
161
162 struct grub_squash_frag_desc
163 {
164 grub_uint64_t offset;
165 grub_uint32_t size;
166 grub_uint32_t dummy;
167 } GRUB_PACKED;
168
169 enum
170 {
171 SQUASH_CHUNK_FLAGS = 0x8000,
172 SQUASH_CHUNK_UNCOMPRESSED = 0x8000
173 };
174
175 enum
176 {
177 SQUASH_BLOCK_FLAGS = 0x1000000,
178 SQUASH_BLOCK_UNCOMPRESSED = 0x1000000
179 };
180
181 enum
182 {
183 COMPRESSION_ZLIB = 1,
184 COMPRESSION_LZO = 3,
185 COMPRESSION_XZ = 4,
186 };
187
188
189 #define SQUASH_CHUNK_SIZE 0x2000
190 #define XZBUFSIZ 0x2000
191
192 struct grub_squash_data
193 {
194 grub_disk_t disk;
195 struct grub_squash_super sb;
196 struct grub_squash_cache_inode ino;
197 grub_uint64_t fragments;
198 int log2_blksz;
199 grub_size_t blksz;
200 grub_ssize_t (*decompress) (char *inbuf, grub_size_t insize, grub_off_t off,
201 char *outbuf, grub_size_t outsize,
202 struct grub_squash_data *data);
203 struct xz_dec *xzdec;
204 char *xzbuf;
205 };
206
207 struct grub_fshelp_node
208 {
209 struct grub_squash_data *data;
210 struct grub_squash_inode ino;
211 grub_size_t stsize;
212 struct
213 {
214 grub_disk_addr_t ino_chunk;
215 grub_uint16_t ino_offset;
216 } stack[1];
217 };
218
219 static grub_err_t
220 read_chunk (struct grub_squash_data *data, void *buf, grub_size_t len,
221 grub_uint64_t chunk_start, grub_off_t offset)
222 {
223 while (len > 0)
224 {
225 grub_uint64_t csize;
226 grub_uint16_t d;
227 grub_err_t err;
228 while (1)
229 {
230 err = grub_disk_read (data->disk,
231 chunk_start >> GRUB_DISK_SECTOR_BITS,
232 chunk_start & (GRUB_DISK_SECTOR_SIZE - 1),
233 sizeof (d), &d);
234 if (err)
235 return err;
236 if (offset < SQUASH_CHUNK_SIZE)
237 break;
238 offset -= SQUASH_CHUNK_SIZE;
239 chunk_start += 2 + (grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS);
240 }
241
242 csize = SQUASH_CHUNK_SIZE - offset;
243 if (csize > len)
244 csize = len;
245
246 if (grub_le_to_cpu16 (d) & SQUASH_CHUNK_UNCOMPRESSED)
247 {
248 grub_disk_addr_t a = chunk_start + 2 + offset;
249 err = grub_disk_read (data->disk, (a >> GRUB_DISK_SECTOR_BITS),
250 a & (GRUB_DISK_SECTOR_SIZE - 1),
251 csize, buf);
252 if (err)
253 return err;
254 }
255 else
256 {
257 char *tmp;
258 grub_size_t bsize = grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS;
259 grub_disk_addr_t a = chunk_start + 2;
260 tmp = grub_malloc (bsize);
261 if (!tmp)
262 return grub_errno;
263 /* FIXME: buffer uncompressed data. */
264 err = grub_disk_read (data->disk, (a >> GRUB_DISK_SECTOR_BITS),
265 a & (GRUB_DISK_SECTOR_SIZE - 1),
266 bsize, tmp);
267 if (err)
268 {
269 grub_free (tmp);
270 return err;
271 }
272
273 if (data->decompress (tmp, bsize, offset,
274 buf, csize, data) < 0)
275 {
276 grub_free (tmp);
277 return grub_errno;
278 }
279 grub_free (tmp);
280 }
281 len -= csize;
282 offset += csize;
283 buf = (char *) buf + csize;
284 }
285 return GRUB_ERR_NONE;
286 }
287
288 static grub_ssize_t
289 zlib_decompress (char *inbuf, grub_size_t insize, grub_off_t off,
290 char *outbuf, grub_size_t outsize,
291 struct grub_squash_data *data __attribute__ ((unused)))
292 {
293 return grub_zlib_decompress (inbuf, insize, off, outbuf, outsize);
294 }
295
296 static grub_ssize_t
297 lzo_decompress (char *inbuf, grub_size_t insize, grub_off_t off,
298 char *outbuf, grub_size_t len, struct grub_squash_data *data)
299 {
300 lzo_uint usize = data->blksz;
301 grub_uint8_t *udata;
302
303 if (usize < 8192)
304 usize = 8192;
305
306 udata = grub_malloc (usize);
307 if (!udata)
308 return -1;
309
310 if (lzo1x_decompress_safe ((grub_uint8_t *) inbuf,
311 insize, udata, &usize, NULL) != LZO_E_OK)
312 {
313 grub_error (GRUB_ERR_BAD_FS, "incorrect compressed chunk");
314 grub_free (udata);
315 return -1;
316 }
317 grub_memcpy (outbuf, udata + off, len);
318 grub_free (udata);
319 return len;
320 }
321
322 static grub_ssize_t
323 xz_decompress (char *inbuf, grub_size_t insize, grub_off_t off,
324 char *outbuf, grub_size_t len, struct grub_squash_data *data)
325 {
326 grub_size_t ret = 0;
327 grub_off_t pos = 0;
328 struct xz_buf buf;
329
330 xz_dec_reset (data->xzdec);
331 buf.in = (grub_uint8_t *) inbuf;
332 buf.in_pos = 0;
333 buf.in_size = insize;
334 buf.out = (grub_uint8_t *) data->xzbuf;
335 buf.out_pos = 0;
336 buf.out_size = XZBUFSIZ;
337
338 while (len)
339 {
340 enum xz_ret xzret;
341
342 buf.out_pos = 0;
343
344 xzret = xz_dec_run (data->xzdec, &buf);
345
346 if (xzret != XZ_OK && xzret != XZ_STREAM_END)
347 {
348 grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "invalid xz chunk");
349 return -1;
350 }
351 if (pos + buf.out_pos >= off)
352 {
353 grub_ssize_t outoff = pos - off;
354 grub_size_t l;
355 if (outoff >= 0)
356 {
357 l = buf.out_pos;
358 if (l > len)
359 l = len;
360 grub_memcpy (outbuf + outoff, buf.out, l);
361 }
362 else
363 {
364 outoff = -outoff;
365 l = buf.out_pos - outoff;
366 if (l > len)
367 l = len;
368 grub_memcpy (outbuf, buf.out + outoff, l);
369 }
370 ret += l;
371 len -= l;
372 }
373 pos += buf.out_pos;
374 if (xzret == XZ_STREAM_END)
375 break;
376 }
377 return ret;
378 }
379
380 static struct grub_squash_data *
381 squash_mount (grub_disk_t disk)
382 {
383 struct grub_squash_super sb;
384 grub_err_t err;
385 struct grub_squash_data *data;
386 grub_uint64_t frag;
387
388 err = grub_disk_read (disk, 0, 0, sizeof (sb), &sb);
389 if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
390 grub_error (GRUB_ERR_BAD_FS, "not a squash4");
391 if (err)
392 return NULL;
393 if (sb.magic != grub_cpu_to_le32_compile_time (SQUASH_MAGIC)
394 || sb.block_size == 0
395 || ((sb.block_size - 1) & sb.block_size))
396 {
397 grub_error (GRUB_ERR_BAD_FS, "not squash4");
398 return NULL;
399 }
400
401 err = grub_disk_read (disk,
402 grub_le_to_cpu64 (sb.unk1offset)
403 >> GRUB_DISK_SECTOR_BITS,
404 grub_le_to_cpu64 (sb.unk1offset)
405 & (GRUB_DISK_SECTOR_SIZE - 1), sizeof (frag), &frag);
406 if (grub_errno == GRUB_ERR_OUT_OF_RANGE)
407 grub_error (GRUB_ERR_BAD_FS, "not a squash4");
408 if (err)
409 return NULL;
410
411 data = grub_zalloc (sizeof (*data));
412 if (!data)
413 return NULL;
414 data->sb = sb;
415 data->disk = disk;
416 data->fragments = grub_le_to_cpu64 (frag);
417
418 switch (sb.compression)
419 {
420 case grub_cpu_to_le16_compile_time (COMPRESSION_ZLIB):
421 data->decompress = zlib_decompress;
422 break;
423 case grub_cpu_to_le16_compile_time (COMPRESSION_LZO):
424 data->decompress = lzo_decompress;
425 break;
426 case grub_cpu_to_le16_compile_time (COMPRESSION_XZ):
427 data->decompress = xz_decompress;
428 data->xzbuf = grub_malloc (XZBUFSIZ);
429 if (!data->xzbuf)
430 {
431 grub_free (data);
432 return NULL;
433 }
434 data->xzdec = xz_dec_init (1 << 16);
435 if (!data->xzdec)
436 {
437 grub_free (data->xzbuf);
438 grub_free (data);
439 return NULL;
440 }
441 break;
442 default:
443 grub_free (data);
444 grub_error (GRUB_ERR_BAD_FS, "unsupported compression %d",
445 grub_le_to_cpu16 (sb.compression));
446 return NULL;
447 }
448
449 data->blksz = grub_le_to_cpu32 (data->sb.block_size);
450 for (data->log2_blksz = 0;
451 (1U << data->log2_blksz) < data->blksz;
452 data->log2_blksz++);
453
454 return data;
455 }
456
457 static char *
458 grub_squash_read_symlink (grub_fshelp_node_t node)
459 {
460 char *ret;
461 grub_err_t err;
462 ret = grub_malloc (grub_le_to_cpu32 (node->ino.symlink.namelen) + 1);
463
464 err = read_chunk (node->data, ret,
465 grub_le_to_cpu32 (node->ino.symlink.namelen),
466 grub_le_to_cpu64 (node->data->sb.inodeoffset)
467 + node->stack[node->stsize - 1].ino_chunk,
468 node->stack[node->stsize - 1].ino_offset
469 + (node->ino.symlink.name - (char *) &node->ino));
470 if (err)
471 {
472 grub_free (ret);
473 return NULL;
474 }
475 ret[grub_le_to_cpu32 (node->ino.symlink.namelen)] = 0;
476 return ret;
477 }
478
479 static int
480 grub_squash_iterate_dir (grub_fshelp_node_t dir,
481 grub_fshelp_iterate_dir_hook_t hook, void *hook_data)
482 {
483 grub_uint32_t off;
484 grub_uint32_t endoff;
485 grub_uint64_t chunk;
486 unsigned i;
487
488 /* FIXME: why - 3 ? */
489 switch (dir->ino.type)
490 {
491 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_DIR):
492 off = grub_le_to_cpu16 (dir->ino.dir.offset);
493 endoff = grub_le_to_cpu16 (dir->ino.dir.size) + off - 3;
494 chunk = grub_le_to_cpu32 (dir->ino.dir.chunk);
495 break;
496 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_DIR):
497 off = grub_le_to_cpu16 (dir->ino.long_dir.offset);
498 endoff = grub_le_to_cpu16 (dir->ino.long_dir.size) + off - 3;
499 chunk = grub_le_to_cpu32 (dir->ino.long_dir.chunk);
500 break;
501 default:
502 grub_error (GRUB_ERR_BAD_FS, "unexpected ino type 0x%x",
503 grub_le_to_cpu16 (dir->ino.type));
504 return 0;
505 }
506
507 {
508 grub_fshelp_node_t node;
509 node = grub_malloc (sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
510 if (!node)
511 return 0;
512 grub_memcpy (node, dir,
513 sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
514 if (hook (".", GRUB_FSHELP_DIR, node, hook_data))
515 return 1;
516
517 if (dir->stsize != 1)
518 {
519 grub_err_t err;
520
521 node = grub_malloc (sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
522 if (!node)
523 return 0;
524
525 grub_memcpy (node, dir,
526 sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
527
528 node->stsize--;
529 err = read_chunk (dir->data, &node->ino, sizeof (node->ino),
530 grub_le_to_cpu64 (dir->data->sb.inodeoffset)
531 + node->stack[node->stsize - 1].ino_chunk,
532 node->stack[node->stsize - 1].ino_offset);
533 if (err)
534 return 0;
535
536 if (hook ("..", GRUB_FSHELP_DIR, node, hook_data))
537 return 1;
538 }
539 }
540
541 while (off < endoff)
542 {
543 struct grub_squash_dirent_header dh;
544 grub_err_t err;
545
546 err = read_chunk (dir->data, &dh, sizeof (dh),
547 grub_le_to_cpu64 (dir->data->sb.diroffset)
548 + chunk, off);
549 if (err)
550 return 0;
551 off += sizeof (dh);
552 for (i = 0; i < (unsigned) grub_le_to_cpu32 (dh.nelems) + 1; i++)
553 {
554 char *buf;
555 int r;
556 struct grub_fshelp_node *node;
557 enum grub_fshelp_filetype filetype = GRUB_FSHELP_REG;
558 struct grub_squash_dirent di;
559 struct grub_squash_inode ino;
560
561 err = read_chunk (dir->data, &di, sizeof (di),
562 grub_le_to_cpu64 (dir->data->sb.diroffset)
563 + chunk, off);
564 if (err)
565 return 0;
566 off += sizeof (di);
567
568 err = read_chunk (dir->data, &ino, sizeof (ino),
569 grub_le_to_cpu64 (dir->data->sb.inodeoffset)
570 + grub_le_to_cpu32 (dh.ino_chunk),
571 grub_cpu_to_le16 (di.ino_offset));
572 if (err)
573 return 0;
574
575 buf = grub_malloc (grub_le_to_cpu16 (di.namelen) + 2);
576 if (!buf)
577 return 0;
578 err = read_chunk (dir->data, buf,
579 grub_le_to_cpu16 (di.namelen) + 1,
580 grub_le_to_cpu64 (dir->data->sb.diroffset)
581 + chunk, off);
582 if (err)
583 return 0;
584
585 off += grub_le_to_cpu16 (di.namelen) + 1;
586 buf[grub_le_to_cpu16 (di.namelen) + 1] = 0;
587 if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_DIR)
588 filetype = GRUB_FSHELP_DIR;
589 if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_SYMLINK)
590 filetype = GRUB_FSHELP_SYMLINK;
591
592 node = grub_malloc (sizeof (*node)
593 + (dir->stsize + 1) * sizeof (dir->stack[0]));
594 if (! node)
595 return 0;
596
597 grub_memcpy (node, dir,
598 sizeof (*node) + dir->stsize * sizeof (dir->stack[0]));
599
600 node->ino = ino;
601 node->stack[node->stsize].ino_chunk = grub_le_to_cpu32 (dh.ino_chunk);
602 node->stack[node->stsize].ino_offset = grub_le_to_cpu16 (di.ino_offset);
603 node->stsize++;
604 r = hook (buf, filetype, node, hook_data);
605
606 grub_free (buf);
607 if (r)
608 return r;
609 }
610 }
611 return 0;
612 }
613
614 static grub_err_t
615 make_root_node (struct grub_squash_data *data, struct grub_fshelp_node *root)
616 {
617 grub_memset (root, 0, sizeof (*root));
618 root->data = data;
619 root->stsize = 1;
620 root->stack[0].ino_chunk = grub_le_to_cpu32 (data->sb.root_ino_chunk);
621 root->stack[0].ino_offset = grub_cpu_to_le16 (data->sb.root_ino_offset);
622 return read_chunk (data, &root->ino, sizeof (root->ino),
623 grub_le_to_cpu64 (data->sb.inodeoffset)
624 + root->stack[0].ino_chunk,
625 root->stack[0].ino_offset);
626 }
627
628 static void
629 squash_unmount (struct grub_squash_data *data)
630 {
631 if (data->xzdec)
632 xz_dec_end (data->xzdec);
633 grub_free (data->xzbuf);
634 grub_free (data->ino.cumulated_block_sizes);
635 grub_free (data->ino.block_sizes);
636 grub_free (data);
637 }
638
639
640 /* Context for grub_squash_dir. */
641 struct grub_squash_dir_ctx
642 {
643 grub_fs_dir_hook_t hook;
644 void *hook_data;
645 };
646
647 /* Helper for grub_squash_dir. */
648 static int
649 grub_squash_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
650 grub_fshelp_node_t node, void *data)
651 {
652 struct grub_squash_dir_ctx *ctx = data;
653 struct grub_dirhook_info info;
654
655 grub_memset (&info, 0, sizeof (info));
656 info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
657 info.mtimeset = 1;
658 info.mtime = grub_le_to_cpu32 (node->ino.mtime);
659 grub_free (node);
660 return ctx->hook (filename, &info, ctx->hook_data);
661 }
662
663 static grub_err_t
664 grub_squash_dir (grub_device_t device, const char *path,
665 grub_fs_dir_hook_t hook, void *hook_data)
666 {
667 struct grub_squash_dir_ctx ctx = { hook, hook_data };
668 struct grub_squash_data *data = 0;
669 struct grub_fshelp_node *fdiro = 0;
670 struct grub_fshelp_node root;
671 grub_err_t err;
672
673 data = squash_mount (device->disk);
674 if (! data)
675 return grub_errno;
676
677 err = make_root_node (data, &root);
678 if (err)
679 return err;
680
681 grub_fshelp_find_file (path, &root, &fdiro, grub_squash_iterate_dir,
682 grub_squash_read_symlink, GRUB_FSHELP_DIR);
683 if (!grub_errno)
684 grub_squash_iterate_dir (fdiro, grub_squash_dir_iter, &ctx);
685
686 squash_unmount (data);
687
688 return grub_errno;
689 }
690
691 static grub_err_t
692 grub_squash_open (struct grub_file *file, const char *name)
693 {
694 struct grub_squash_data *data = 0;
695 struct grub_fshelp_node *fdiro = 0;
696 struct grub_fshelp_node root;
697 grub_err_t err;
698
699 data = squash_mount (file->device->disk);
700 if (! data)
701 return grub_errno;
702
703 err = make_root_node (data, &root);
704 if (err)
705 return err;
706
707 grub_fshelp_find_file (name, &root, &fdiro, grub_squash_iterate_dir,
708 grub_squash_read_symlink, GRUB_FSHELP_REG);
709 if (grub_errno)
710 {
711 squash_unmount (data);
712 return grub_errno;
713 }
714
715 file->data = data;
716 data->ino.ino = fdiro->ino;
717 data->ino.block_sizes = NULL;
718 data->ino.cumulated_block_sizes = NULL;
719 data->ino.ino_chunk = fdiro->stack[fdiro->stsize - 1].ino_chunk;
720 data->ino.ino_offset = fdiro->stack[fdiro->stsize - 1].ino_offset;
721
722 switch (fdiro->ino.type)
723 {
724 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR):
725 file->size = grub_le_to_cpu64 (fdiro->ino.long_file.size);
726 break;
727 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR):
728 file->size = grub_le_to_cpu32 (fdiro->ino.file.size);
729 break;
730 default:
731 {
732 grub_uint16_t type = grub_le_to_cpu16 (fdiro->ino.type);
733 grub_free (fdiro);
734 squash_unmount (data);
735 return grub_error (GRUB_ERR_BAD_FS, "unexpected ino type 0x%x", type);
736 }
737 }
738
739 grub_free (fdiro);
740
741 return GRUB_ERR_NONE;
742 }
743
744 static grub_ssize_t
745 direct_read (struct grub_squash_data *data,
746 struct grub_squash_cache_inode *ino,
747 grub_off_t off, char *buf, grub_size_t len)
748 {
749 grub_err_t err;
750 grub_off_t cumulated_uncompressed_size = 0;
751 grub_uint64_t a = 0;
752 grub_size_t i;
753 grub_size_t origlen = len;
754
755 switch (ino->ino.type)
756 {
757 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR):
758 a = grub_le_to_cpu64 (ino->ino.long_file.chunk);
759 break;
760 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR):
761 a = grub_le_to_cpu32 (ino->ino.file.chunk);
762 break;
763 }
764
765 if (!ino->block_sizes)
766 {
767 grub_off_t total_size = 0;
768 grub_size_t total_blocks;
769 grub_size_t block_offset = 0;
770 switch (ino->ino.type)
771 {
772 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR):
773 total_size = grub_le_to_cpu64 (ino->ino.long_file.size);
774 block_offset = ((char *) &ino->ino.long_file.block_size
775 - (char *) &ino->ino);
776 break;
777 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR):
778 total_size = grub_le_to_cpu32 (ino->ino.file.size);
779 block_offset = ((char *) &ino->ino.file.block_size
780 - (char *) &ino->ino);
781 break;
782 }
783 total_blocks = ((total_size + data->blksz - 1) >> data->log2_blksz);
784 ino->block_sizes = grub_malloc (total_blocks
785 * sizeof (ino->block_sizes[0]));
786 ino->cumulated_block_sizes = grub_malloc (total_blocks
787 * sizeof (ino->cumulated_block_sizes[0]));
788 if (!ino->block_sizes || !ino->cumulated_block_sizes)
789 {
790 grub_free (ino->block_sizes);
791 grub_free (ino->cumulated_block_sizes);
792 ino->block_sizes = 0;
793 ino->cumulated_block_sizes = 0;
794 return -1;
795 }
796 err = read_chunk (data, ino->block_sizes,
797 total_blocks * sizeof (ino->block_sizes[0]),
798 grub_le_to_cpu64 (data->sb.inodeoffset)
799 + ino->ino_chunk,
800 ino->ino_offset + block_offset);
801 if (err)
802 {
803 grub_free (ino->block_sizes);
804 grub_free (ino->cumulated_block_sizes);
805 ino->block_sizes = 0;
806 ino->cumulated_block_sizes = 0;
807 return -1;
808 }
809 ino->cumulated_block_sizes[0] = 0;
810 for (i = 1; i < total_blocks; i++)
811 ino->cumulated_block_sizes[i] = ino->cumulated_block_sizes[i - 1]
812 + (grub_le_to_cpu32 (ino->block_sizes[i - 1]) & ~SQUASH_BLOCK_FLAGS);
813 }
814
815 if (a == 0)
816 a = sizeof (struct grub_squash_super);
817 i = off >> data->log2_blksz;
818 cumulated_uncompressed_size = data->blksz * (grub_disk_addr_t) i;
819 while (cumulated_uncompressed_size < off + len)
820 {
821 grub_size_t boff, curread;
822 boff = off - cumulated_uncompressed_size;
823 curread = data->blksz - boff;
824 if (curread > len)
825 curread = len;
826 if (!(ino->block_sizes[i]
827 & grub_cpu_to_le32_compile_time (SQUASH_BLOCK_UNCOMPRESSED)))
828 {
829 char *block;
830 grub_size_t csize;
831 csize = grub_le_to_cpu32 (ino->block_sizes[i]) & ~SQUASH_BLOCK_FLAGS;
832 block = grub_malloc (csize);
833 if (!block)
834 return -1;
835 err = grub_disk_read (data->disk,
836 (ino->cumulated_block_sizes[i] + a)
837 >> GRUB_DISK_SECTOR_BITS,
838 (ino->cumulated_block_sizes[i] + a)
839 & (GRUB_DISK_SECTOR_SIZE - 1),
840 csize, block);
841 if (err)
842 {
843 grub_free (block);
844 return -1;
845 }
846 if (data->decompress (block, csize, boff, buf, curread, data)
847 != (grub_ssize_t) curread)
848 {
849 grub_free (block);
850 if (!grub_errno)
851 grub_error (GRUB_ERR_BAD_FS, "incorrect compressed chunk");
852 return -1;
853 }
854 grub_free (block);
855 }
856 else
857 err = grub_disk_read (data->disk,
858 (ino->cumulated_block_sizes[i] + a + boff)
859 >> GRUB_DISK_SECTOR_BITS,
860 (ino->cumulated_block_sizes[i] + a + boff)
861 & (GRUB_DISK_SECTOR_SIZE - 1),
862 curread, buf);
863 if (err)
864 return -1;
865 off += curread;
866 len -= curread;
867 buf += curread;
868 cumulated_uncompressed_size += grub_le_to_cpu32 (data->sb.block_size);
869 i++;
870 }
871 return origlen;
872 }
873
874
875 static grub_ssize_t
876 grub_squash_read_data (struct grub_squash_data *data,
877 struct grub_squash_cache_inode *ino,
878 grub_off_t off, char *buf, grub_size_t len)
879 {
880 grub_err_t err;
881 grub_uint64_t a = 0, b;
882 grub_uint32_t fragment = 0;
883 int compressed = 0;
884 struct grub_squash_frag_desc frag;
885
886 switch (ino->ino.type)
887 {
888 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR):
889 a = grub_le_to_cpu64 (ino->ino.long_file.chunk);
890 fragment = grub_le_to_cpu32 (ino->ino.long_file.fragment);
891 break;
892 case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR):
893 a = grub_le_to_cpu32 (ino->ino.file.chunk);
894 fragment = grub_le_to_cpu32 (ino->ino.file.fragment);
895 break;
896 }
897
898 if (fragment == 0xffffffff)
899 return direct_read (data, ino, off, buf, len);
900
901 err = read_chunk (data, &frag, sizeof (frag),
902 data->fragments, sizeof (frag) * fragment);
903 if (err)
904 return -1;
905 a += grub_le_to_cpu64 (frag.offset);
906 compressed = !(frag.size & grub_cpu_to_le32_compile_time (SQUASH_BLOCK_UNCOMPRESSED));
907 if (ino->ino.type == grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR))
908 b = grub_le_to_cpu32 (ino->ino.long_file.offset) + off;
909 else
910 b = grub_le_to_cpu32 (ino->ino.file.offset) + off;
911
912 /* FIXME: cache uncompressed chunks. */
913 if (compressed)
914 {
915 char *block;
916 block = grub_malloc (grub_le_to_cpu32 (frag.size));
917 if (!block)
918 return -1;
919 err = grub_disk_read (data->disk,
920 a >> GRUB_DISK_SECTOR_BITS,
921 a & (GRUB_DISK_SECTOR_SIZE - 1),
922 grub_le_to_cpu32 (frag.size), block);
923 if (err)
924 {
925 grub_free (block);
926 return -1;
927 }
928 if (data->decompress (block, grub_le_to_cpu32 (frag.size),
929 b, buf, len, data)
930 != (grub_ssize_t) len)
931 {
932 grub_free (block);
933 if (!grub_errno)
934 grub_error (GRUB_ERR_BAD_FS, "incorrect compressed chunk");
935 return -1;
936 }
937 grub_free (block);
938 }
939 else
940 {
941 err = grub_disk_read (data->disk, (a + b) >> GRUB_DISK_SECTOR_BITS,
942 (a + b) & (GRUB_DISK_SECTOR_SIZE - 1), len, buf);
943 if (err)
944 return -1;
945 }
946 return len;
947 }
948
949 static grub_ssize_t
950 grub_squash_read (grub_file_t file, char *buf, grub_size_t len)
951 {
952 struct grub_squash_data *data = file->data;
953
954 return grub_squash_read_data (data, &data->ino,
955 file->offset, buf, len);
956 }
957
958 static grub_err_t
959 grub_squash_close (grub_file_t file)
960 {
961 squash_unmount (file->data);
962 return GRUB_ERR_NONE;
963 }
964
965 static grub_err_t
966 grub_squash_mtime (grub_device_t dev, grub_int32_t *tm)
967 {
968 struct grub_squash_data *data = 0;
969
970 data = squash_mount (dev->disk);
971 if (! data)
972 return grub_errno;
973 *tm = grub_le_to_cpu32 (data->sb.creation_time);
974 squash_unmount (data);
975 return GRUB_ERR_NONE;
976 }
977
978 static struct grub_fs grub_squash_fs =
979 {
980 .name = "squash4",
981 .dir = grub_squash_dir,
982 .open = grub_squash_open,
983 .read = grub_squash_read,
984 .close = grub_squash_close,
985 .mtime = grub_squash_mtime,
986 #ifdef GRUB_UTIL
987 .reserved_first_sector = 0,
988 .blocklist_install = 0,
989 #endif
990 .next = 0
991 };
992
993 GRUB_MOD_INIT(squash4)
994 {
995 grub_fs_register (&grub_squash_fs);
996 }
997
998 GRUB_MOD_FINI(squash4)
999 {
1000 grub_fs_unregister (&grub_squash_fs);
1001 }
1002
Mirror of AROS' svn.