jcs.org
"Das U-Boot" Source Tree
1// SPDX-License-Identifier: GPL 2.0+ OR BSD-3-Clause
2/*
3 * Copyright 2015 Google Inc.
4 */
5
6#include <compiler.h>
7#include <image.h>
8#include <linux/kernel.h>
9#include <linux/types.h>
10#include <asm/unaligned.h>
11#include <u-boot/lz4.h>
12
13/* lz4.c is unaltered (except removing unrelated code) from github.com/Cyan4973/lz4. */
14#include "lz4.c" /* #include for inlining, do not link! */
15
16#define LZ4F_BLOCKUNCOMPRESSED_FLAG 0x80000000U
17
18__rcode int ulz4fn(const void *src, size_t srcn, void *dst, size_t *dstn)
19{
20 const void *end = dst + *dstn;
21 const void *in = src;
22 void *out = dst;
23 int has_block_checksum;
24 int ret;
25 *dstn = 0;
26
27 { /* With in-place decompression the header may become invalid later. */
28 u32 magic;
29 u8 flags, version, independent_blocks, has_content_size;
30 u8 block_desc;
31
32 if (srcn < sizeof(u32) + 3*sizeof(u8))
33 return -EINVAL; /* input overrun */
34
35 magic = get_unaligned_le32(in);
36 in += sizeof(u32);
37 flags = *(u8 *)in;
38 in += sizeof(u8);
39 block_desc = *(u8 *)in;
40 in += sizeof(u8);
41
42 version = (flags >> 6) & 0x3;
43 independent_blocks = (flags >> 5) & 0x1;
44 has_block_checksum = (flags >> 4) & 0x1;
45 has_content_size = (flags >> 3) & 0x1;
46
47 /* We assume there's always only a single, standard frame. */
48 if (magic != LZ4F_MAGIC || version != 1)
49 return -EPROTONOSUPPORT; /* unknown format */
50 if ((flags & 0x03) || (block_desc & 0x8f))
51 return -EINVAL; /* reserved bits must be zero */
52 if (!independent_blocks)
53 return -EPROTONOSUPPORT; /* we can't support this yet */
54
55 if (has_content_size) {
56 if (srcn < sizeof(u32) + 3*sizeof(u8) + sizeof(u64))
57 return -EINVAL; /* input overrun */
58 in += sizeof(u64);
59 }
60 /* Header checksum byte */
61 in += sizeof(u8);
62 }
63
64 while (1) {
65 u32 block_header, block_size;
66
67 block_header = get_unaligned_le32(in);
68 in += sizeof(u32);
69 block_size = block_header & ~LZ4F_BLOCKUNCOMPRESSED_FLAG;
70
71 if (in - src + block_size > srcn) {
72 ret = -EINVAL; /* input overrun */
73 break;
74 }
75
76 if (!block_size) {
77 ret = 0; /* decompression successful */
78 break;
79 }
80
81 if (block_header & LZ4F_BLOCKUNCOMPRESSED_FLAG) {
82 size_t size = min((ptrdiff_t)block_size, (ptrdiff_t)(end - out));
83 memcpy(out, in, size);
84 out += size;
85 if (size < block_size) {
86 ret = -ENOBUFS; /* output overrun */
87 break;
88 }
89 } else {
90 /* constant folding essential, do not touch params! */
91 ret = LZ4_decompress_generic(in, out, block_size,
92 end - out, endOnInputSize,
93 decode_full_block, noDict, out, NULL, 0);
94 if (ret < 0) {
95 ret = -EPROTO; /* decompression error */
96 break;
97 }
98 out += ret;
99 }
100
101 in += block_size;
102 if (has_block_checksum)
103 in += sizeof(u32);
104 }
105
106 *dstn = out - dst;
107 return ret;
108}