1 /* 2 * 842 Software Decompression 3 * 4 * Copyright (C) 2015 Dan Streetman, IBM Corp 5 * 6 * This program 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 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program 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 * See 842.h for details of the 842 compressed format. 17 */ 18 19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 #define MODULE_NAME "842_decompress" 21 22 #include "842.h" 23 #include "842_debugfs.h" 24 25 /* rolling fifo sizes */ 26 #define I2_FIFO_SIZE (2 * (1 << I2_BITS)) 27 #define I4_FIFO_SIZE (4 * (1 << I4_BITS)) 28 #define I8_FIFO_SIZE (8 * (1 << I8_BITS)) 29 30 static u8 decomp_ops[OPS_MAX][4] = { 31 { D8, N0, N0, N0 }, 32 { D4, D2, I2, N0 }, 33 { D4, I2, D2, N0 }, 34 { D4, I2, I2, N0 }, 35 { D4, I4, N0, N0 }, 36 { D2, I2, D4, N0 }, 37 { D2, I2, D2, I2 }, 38 { D2, I2, I2, D2 }, 39 { D2, I2, I2, I2 }, 40 { D2, I2, I4, N0 }, 41 { I2, D2, D4, N0 }, 42 { I2, D4, I2, N0 }, 43 { I2, D2, I2, D2 }, 44 { I2, D2, I2, I2 }, 45 { I2, D2, I4, N0 }, 46 { I2, I2, D4, N0 }, 47 { I2, I2, D2, I2 }, 48 { I2, I2, I2, D2 }, 49 { I2, I2, I2, I2 }, 50 { I2, I2, I4, N0 }, 51 { I4, D4, N0, N0 }, 52 { I4, D2, I2, N0 }, 53 { I4, I2, D2, N0 }, 54 { I4, I2, I2, N0 }, 55 { I4, I4, N0, N0 }, 56 { I8, N0, N0, N0 } 57 }; 58 59 struct sw842_param { 60 u8 *in; 61 u8 bit; 62 u64 ilen; 63 u8 *out; 64 u8 *ostart; 65 u64 olen; 66 }; 67 68 #define beN_to_cpu(d, s) \ 69 ((s) == 2 ? be16_to_cpu(get_unaligned((__be16 *)d)) : \ 70 (s) == 4 ? be32_to_cpu(get_unaligned((__be32 *)d)) : \ 71 (s) == 8 ? be64_to_cpu(get_unaligned((__be64 *)d)) : \ 72 0) 73 74 static int next_bits(struct sw842_param *p, u64 *d, u8 n); 75 76 static int __split_next_bits(struct sw842_param *p, u64 *d, u8 n, u8 s) 77 { 78 u64 tmp = 0; 79 int ret; 80 81 if (n <= s) { 82 pr_debug("split_next_bits invalid n %u s %u\n", n, s); 83 return -EINVAL; 84 } 85 86 ret = next_bits(p, &tmp, n - s); 87 if (ret) 88 return ret; 89 ret = next_bits(p, d, s); 90 if (ret) 91 return ret; 92 *d |= tmp << s; 93 return 0; 94 } 95 96 static int next_bits(struct sw842_param *p, u64 *d, u8 n) 97 { 98 u8 *in = p->in, b = p->bit, bits = b + n; 99 100 if (n > 64) { 101 pr_debug("next_bits invalid n %u\n", n); 102 return -EINVAL; 103 } 104 105 /* split this up if reading > 8 bytes, or if we're at the end of 106 * the input buffer and would read past the end 107 */ 108 if (bits > 64) 109 return __split_next_bits(p, d, n, 32); 110 else if (p->ilen < 8 && bits > 32 && bits <= 56) 111 return __split_next_bits(p, d, n, 16); 112 else if (p->ilen < 4 && bits > 16 && bits <= 24) 113 return __split_next_bits(p, d, n, 8); 114 115 if (DIV_ROUND_UP(bits, 8) > p->ilen) 116 return -EOVERFLOW; 117 118 if (bits <= 8) 119 *d = *in >> (8 - bits); 120 else if (bits <= 16) 121 *d = be16_to_cpu(get_unaligned((__be16 *)in)) >> (16 - bits); 122 else if (bits <= 32) 123 *d = be32_to_cpu(get_unaligned((__be32 *)in)) >> (32 - bits); 124 else 125 *d = be64_to_cpu(get_unaligned((__be64 *)in)) >> (64 - bits); 126 127 *d &= GENMASK_ULL(n - 1, 0); 128 129 p->bit += n; 130 131 if (p->bit > 7) { 132 p->in += p->bit / 8; 133 p->ilen -= p->bit / 8; 134 p->bit %= 8; 135 } 136 137 return 0; 138 } 139 140 static int do_data(struct sw842_param *p, u8 n) 141 { 142 u64 v; 143 int ret; 144 145 if (n > p->olen) 146 return -ENOSPC; 147 148 ret = next_bits(p, &v, n * 8); 149 if (ret) 150 return ret; 151 152 switch (n) { 153 case 2: 154 put_unaligned(cpu_to_be16((u16)v), (__be16 *)p->out); 155 break; 156 case 4: 157 put_unaligned(cpu_to_be32((u32)v), (__be32 *)p->out); 158 break; 159 case 8: 160 put_unaligned(cpu_to_be64((u64)v), (__be64 *)p->out); 161 break; 162 default: 163 return -EINVAL; 164 } 165 166 p->out += n; 167 p->olen -= n; 168 169 return 0; 170 } 171 172 static int __do_index(struct sw842_param *p, u8 size, u8 bits, u64 fsize) 173 { 174 u64 index, offset, total = round_down(p->out - p->ostart, 8); 175 int ret; 176 177 ret = next_bits(p, &index, bits); 178 if (ret) 179 return ret; 180 181 offset = index * size; 182 183 /* a ring buffer of fsize is used; correct the offset */ 184 if (total > fsize) { 185 /* this is where the current fifo is */ 186 u64 section = round_down(total, fsize); 187 /* the current pos in the fifo */ 188 u64 pos = total - section; 189 190 /* if the offset is past/at the pos, we need to 191 * go back to the last fifo section 192 */ 193 if (offset >= pos) 194 section -= fsize; 195 196 offset += section; 197 } 198 199 if (offset + size > total) { 200 pr_debug("index%x %lx points past end %lx\n", size, 201 (unsigned long)offset, (unsigned long)total); 202 return -EINVAL; 203 } 204 205 if (size != 2 && size != 4 && size != 8) 206 WARN(1, "__do_index invalid size %x\n", size); 207 else 208 pr_debug("index%x to %lx off %lx adjoff %lx tot %lx data %lx\n", 209 size, (unsigned long)index, 210 (unsigned long)(index * size), (unsigned long)offset, 211 (unsigned long)total, 212 (unsigned long)beN_to_cpu(&p->ostart[offset], size)); 213 214 memcpy(p->out, &p->ostart[offset], size); 215 p->out += size; 216 p->olen -= size; 217 218 return 0; 219 } 220 221 static int do_index(struct sw842_param *p, u8 n) 222 { 223 switch (n) { 224 case 2: 225 return __do_index(p, 2, I2_BITS, I2_FIFO_SIZE); 226 case 4: 227 return __do_index(p, 4, I4_BITS, I4_FIFO_SIZE); 228 case 8: 229 return __do_index(p, 8, I8_BITS, I8_FIFO_SIZE); 230 default: 231 return -EINVAL; 232 } 233 } 234 235 static int do_op(struct sw842_param *p, u8 o) 236 { 237 int i, ret = 0; 238 239 if (o >= OPS_MAX) 240 return -EINVAL; 241 242 for (i = 0; i < 4; i++) { 243 u8 op = decomp_ops[o][i]; 244 245 pr_debug("op is %x\n", op); 246 247 switch (op & OP_ACTION) { 248 case OP_ACTION_DATA: 249 ret = do_data(p, op & OP_AMOUNT); 250 break; 251 case OP_ACTION_INDEX: 252 ret = do_index(p, op & OP_AMOUNT); 253 break; 254 case OP_ACTION_NOOP: 255 break; 256 default: 257 pr_err("Interal error, invalid op %x\n", op); 258 return -EINVAL; 259 } 260 261 if (ret) 262 return ret; 263 } 264 265 if (sw842_template_counts) 266 atomic_inc(&template_count[o]); 267 268 return 0; 269 } 270 271 /** 272 * sw842_decompress 273 * 274 * Decompress the 842-compressed buffer of length @ilen at @in 275 * to the output buffer @out, using no more than @olen bytes. 276 * 277 * The compressed buffer must be only a single 842-compressed buffer, 278 * with the standard format described in the comments in 842.h 279 * Processing will stop when the 842 "END" template is detected, 280 * not the end of the buffer. 281 * 282 * Returns: 0 on success, error on failure. The @olen parameter 283 * will contain the number of output bytes written on success, or 284 * 0 on error. 285 */ 286 int sw842_decompress(const u8 *in, unsigned int ilen, 287 u8 *out, unsigned int *olen) 288 { 289 struct sw842_param p; 290 int ret; 291 u64 op, rep, tmp, bytes, total; 292 u64 crc; 293 294 p.in = (u8 *)in; 295 p.bit = 0; 296 p.ilen = ilen; 297 p.out = out; 298 p.ostart = out; 299 p.olen = *olen; 300 301 total = p.olen; 302 303 *olen = 0; 304 305 do { 306 ret = next_bits(&p, &op, OP_BITS); 307 if (ret) 308 return ret; 309 310 pr_debug("template is %lx\n", (unsigned long)op); 311 312 switch (op) { 313 case OP_REPEAT: 314 ret = next_bits(&p, &rep, REPEAT_BITS); 315 if (ret) 316 return ret; 317 318 if (p.out == out) /* no previous bytes */ 319 return -EINVAL; 320 321 /* copy rep + 1 */ 322 rep++; 323 324 if (rep * 8 > p.olen) 325 return -ENOSPC; 326 327 while (rep-- > 0) { 328 memcpy(p.out, p.out - 8, 8); 329 p.out += 8; 330 p.olen -= 8; 331 } 332 333 if (sw842_template_counts) 334 atomic_inc(&template_repeat_count); 335 336 break; 337 case OP_ZEROS: 338 if (8 > p.olen) 339 return -ENOSPC; 340 341 memset(p.out, 0, 8); 342 p.out += 8; 343 p.olen -= 8; 344 345 if (sw842_template_counts) 346 atomic_inc(&template_zeros_count); 347 348 break; 349 case OP_SHORT_DATA: 350 ret = next_bits(&p, &bytes, SHORT_DATA_BITS); 351 if (ret) 352 return ret; 353 354 if (!bytes || bytes > SHORT_DATA_BITS_MAX) 355 return -EINVAL; 356 357 while (bytes-- > 0) { 358 ret = next_bits(&p, &tmp, 8); 359 if (ret) 360 return ret; 361 *p.out = (u8)tmp; 362 p.out++; 363 p.olen--; 364 } 365 366 if (sw842_template_counts) 367 atomic_inc(&template_short_data_count); 368 369 break; 370 case OP_END: 371 if (sw842_template_counts) 372 atomic_inc(&template_end_count); 373 374 break; 375 default: /* use template */ 376 ret = do_op(&p, op); 377 if (ret) 378 return ret; 379 break; 380 } 381 } while (op != OP_END); 382 383 /* 384 * crc(0:31) is saved in compressed data starting with the 385 * next bit after End of stream template. 386 */ 387 ret = next_bits(&p, &crc, CRC_BITS); 388 if (ret) 389 return ret; 390 391 /* 392 * Validate CRC saved in compressed data. 393 */ 394 if (crc != (u64)crc32_be(0, out, total - p.olen)) { 395 pr_debug("CRC mismatch for decompression\n"); 396 return -EINVAL; 397 } 398 399 if (unlikely((total - p.olen) > UINT_MAX)) 400 return -ENOSPC; 401 402 *olen = total - p.olen; 403 404 return 0; 405 } 406 EXPORT_SYMBOL_GPL(sw842_decompress); 407 408 static int __init sw842_init(void) 409 { 410 if (sw842_template_counts) 411 sw842_debugfs_create(); 412 413 return 0; 414 } 415 module_init(sw842_init); 416 417 static void __exit sw842_exit(void) 418 { 419 if (sw842_template_counts) 420 sw842_debugfs_remove(); 421 } 422 module_exit(sw842_exit); 423 424 MODULE_LICENSE("GPL"); 425 MODULE_DESCRIPTION("Software 842 Decompressor"); 426 MODULE_AUTHOR("Dan Streetman <ddstreet@ieee.org>"); 427