1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright 2021 Google LLC. 4 */ 5 6 #include <linux/init.h> 7 #include <linux/highmem.h> 8 #include <linux/kobject.h> 9 #include <linux/mm.h> 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <linux/sysfs.h> 13 #include <linux/vmalloc.h> 14 15 #include "internal.h" 16 17 static int module_extend_max_pages(struct load_info *info, unsigned int extent) 18 { 19 struct page **new_pages; 20 21 new_pages = kvmalloc_array(info->max_pages + extent, 22 sizeof(info->pages), GFP_KERNEL); 23 if (!new_pages) 24 return -ENOMEM; 25 26 memcpy(new_pages, info->pages, info->max_pages * sizeof(info->pages)); 27 kvfree(info->pages); 28 info->pages = new_pages; 29 info->max_pages += extent; 30 31 return 0; 32 } 33 34 static struct page *module_get_next_page(struct load_info *info) 35 { 36 struct page *page; 37 int error; 38 39 if (info->max_pages == info->used_pages) { 40 error = module_extend_max_pages(info, info->used_pages); 41 if (error) 42 return ERR_PTR(error); 43 } 44 45 page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM); 46 if (!page) 47 return ERR_PTR(-ENOMEM); 48 49 info->pages[info->used_pages++] = page; 50 return page; 51 } 52 53 #if defined(CONFIG_MODULE_COMPRESS_GZIP) 54 #include <linux/zlib.h> 55 #define MODULE_COMPRESSION gzip 56 #define MODULE_DECOMPRESS_FN module_gzip_decompress 57 58 /* 59 * Calculate length of the header which consists of signature, header 60 * flags, time stamp and operating system ID (10 bytes total), plus 61 * an optional filename. 62 */ 63 static size_t module_gzip_header_len(const u8 *buf, size_t size) 64 { 65 const u8 signature[] = { 0x1f, 0x8b, 0x08 }; 66 size_t len = 10; 67 68 if (size < len || memcmp(buf, signature, sizeof(signature))) 69 return 0; 70 71 if (buf[3] & 0x08) { 72 do { 73 /* 74 * If we can't find the end of the file name we must 75 * be dealing with a corrupted file. 76 */ 77 if (len == size) 78 return 0; 79 } while (buf[len++] != '\0'); 80 } 81 82 return len; 83 } 84 85 static ssize_t module_gzip_decompress(struct load_info *info, 86 const void *buf, size_t size) 87 { 88 struct z_stream_s s = { 0 }; 89 size_t new_size = 0; 90 size_t gzip_hdr_len; 91 ssize_t retval; 92 int rc; 93 94 gzip_hdr_len = module_gzip_header_len(buf, size); 95 if (!gzip_hdr_len) { 96 pr_err("not a gzip compressed module\n"); 97 return -EINVAL; 98 } 99 100 s.next_in = buf + gzip_hdr_len; 101 s.avail_in = size - gzip_hdr_len; 102 103 s.workspace = kvmalloc(zlib_inflate_workspacesize(), GFP_KERNEL); 104 if (!s.workspace) 105 return -ENOMEM; 106 107 rc = zlib_inflateInit2(&s, -MAX_WBITS); 108 if (rc != Z_OK) { 109 pr_err("failed to initialize decompressor: %d\n", rc); 110 retval = -EINVAL; 111 goto out; 112 } 113 114 do { 115 struct page *page = module_get_next_page(info); 116 117 if (IS_ERR(page)) { 118 retval = PTR_ERR(page); 119 goto out_inflate_end; 120 } 121 122 s.next_out = kmap_local_page(page); 123 s.avail_out = PAGE_SIZE; 124 rc = zlib_inflate(&s, 0); 125 kunmap_local(s.next_out); 126 127 new_size += PAGE_SIZE - s.avail_out; 128 } while (rc == Z_OK); 129 130 if (rc != Z_STREAM_END) { 131 pr_err("decompression failed with status %d\n", rc); 132 retval = -EINVAL; 133 goto out_inflate_end; 134 } 135 136 retval = new_size; 137 138 out_inflate_end: 139 zlib_inflateEnd(&s); 140 out: 141 kvfree(s.workspace); 142 return retval; 143 } 144 #elif defined(CONFIG_MODULE_COMPRESS_XZ) 145 #include <linux/xz.h> 146 #define MODULE_COMPRESSION xz 147 #define MODULE_DECOMPRESS_FN module_xz_decompress 148 149 static ssize_t module_xz_decompress(struct load_info *info, 150 const void *buf, size_t size) 151 { 152 static const u8 signature[] = { 0xfd, '7', 'z', 'X', 'Z', 0 }; 153 struct xz_dec *xz_dec; 154 struct xz_buf xz_buf; 155 enum xz_ret xz_ret; 156 size_t new_size = 0; 157 ssize_t retval; 158 159 if (size < sizeof(signature) || 160 memcmp(buf, signature, sizeof(signature))) { 161 pr_err("not an xz compressed module\n"); 162 return -EINVAL; 163 } 164 165 xz_dec = xz_dec_init(XZ_DYNALLOC, (u32)-1); 166 if (!xz_dec) 167 return -ENOMEM; 168 169 xz_buf.in_size = size; 170 xz_buf.in = buf; 171 xz_buf.in_pos = 0; 172 173 do { 174 struct page *page = module_get_next_page(info); 175 176 if (IS_ERR(page)) { 177 retval = PTR_ERR(page); 178 goto out; 179 } 180 181 xz_buf.out = kmap_local_page(page); 182 xz_buf.out_pos = 0; 183 xz_buf.out_size = PAGE_SIZE; 184 xz_ret = xz_dec_run(xz_dec, &xz_buf); 185 kunmap_local(xz_buf.out); 186 187 new_size += xz_buf.out_pos; 188 } while (xz_buf.out_pos == PAGE_SIZE && xz_ret == XZ_OK); 189 190 if (xz_ret != XZ_STREAM_END) { 191 pr_err("decompression failed with status %d\n", xz_ret); 192 retval = -EINVAL; 193 goto out; 194 } 195 196 retval = new_size; 197 198 out: 199 xz_dec_end(xz_dec); 200 return retval; 201 } 202 #elif defined(CONFIG_MODULE_COMPRESS_ZSTD) 203 #include <linux/zstd.h> 204 #define MODULE_COMPRESSION zstd 205 #define MODULE_DECOMPRESS_FN module_zstd_decompress 206 207 static ssize_t module_zstd_decompress(struct load_info *info, 208 const void *buf, size_t size) 209 { 210 static const u8 signature[] = { 0x28, 0xb5, 0x2f, 0xfd }; 211 ZSTD_outBuffer zstd_dec; 212 ZSTD_inBuffer zstd_buf; 213 zstd_frame_header header; 214 size_t wksp_size; 215 void *wksp = NULL; 216 ZSTD_DStream *dstream; 217 size_t ret; 218 size_t new_size = 0; 219 int retval; 220 221 if (size < sizeof(signature) || 222 memcmp(buf, signature, sizeof(signature))) { 223 pr_err("not a zstd compressed module\n"); 224 return -EINVAL; 225 } 226 227 zstd_buf.src = buf; 228 zstd_buf.pos = 0; 229 zstd_buf.size = size; 230 231 ret = zstd_get_frame_header(&header, zstd_buf.src, zstd_buf.size); 232 if (ret != 0) { 233 pr_err("ZSTD-compressed data has an incomplete frame header\n"); 234 retval = -EINVAL; 235 goto out; 236 } 237 if (header.windowSize > (1 << ZSTD_WINDOWLOG_MAX)) { 238 pr_err("ZSTD-compressed data has too large a window size\n"); 239 retval = -EINVAL; 240 goto out; 241 } 242 243 wksp_size = zstd_dstream_workspace_bound(header.windowSize); 244 wksp = kvmalloc(wksp_size, GFP_KERNEL); 245 if (!wksp) { 246 retval = -ENOMEM; 247 goto out; 248 } 249 250 dstream = zstd_init_dstream(header.windowSize, wksp, wksp_size); 251 if (!dstream) { 252 pr_err("Can't initialize ZSTD stream\n"); 253 retval = -ENOMEM; 254 goto out; 255 } 256 257 do { 258 struct page *page = module_get_next_page(info); 259 260 if (IS_ERR(page)) { 261 retval = PTR_ERR(page); 262 goto out; 263 } 264 265 zstd_dec.dst = kmap_local_page(page); 266 zstd_dec.pos = 0; 267 zstd_dec.size = PAGE_SIZE; 268 269 ret = zstd_decompress_stream(dstream, &zstd_dec, &zstd_buf); 270 kunmap_local(zstd_dec.dst); 271 retval = zstd_get_error_code(ret); 272 if (retval) 273 break; 274 275 new_size += zstd_dec.pos; 276 } while (zstd_dec.pos == PAGE_SIZE && ret != 0); 277 278 if (retval) { 279 pr_err("ZSTD-decompression failed with status %d\n", retval); 280 retval = -EINVAL; 281 goto out; 282 } 283 284 retval = new_size; 285 286 out: 287 kvfree(wksp); 288 return retval; 289 } 290 #else 291 #error "Unexpected configuration for CONFIG_MODULE_DECOMPRESS" 292 #endif 293 294 int module_decompress(struct load_info *info, const void *buf, size_t size) 295 { 296 unsigned int n_pages; 297 ssize_t data_size; 298 int error; 299 300 #if defined(CONFIG_MODULE_STATS) 301 info->compressed_len = size; 302 #endif 303 304 /* 305 * Start with number of pages twice as big as needed for 306 * compressed data. 307 */ 308 n_pages = DIV_ROUND_UP(size, PAGE_SIZE) * 2; 309 error = module_extend_max_pages(info, n_pages); 310 311 data_size = MODULE_DECOMPRESS_FN(info, buf, size); 312 if (data_size < 0) { 313 error = data_size; 314 goto err; 315 } 316 317 info->hdr = vmap(info->pages, info->used_pages, VM_MAP, PAGE_KERNEL); 318 if (!info->hdr) { 319 error = -ENOMEM; 320 goto err; 321 } 322 323 info->len = data_size; 324 return 0; 325 326 err: 327 module_decompress_cleanup(info); 328 return error; 329 } 330 331 void module_decompress_cleanup(struct load_info *info) 332 { 333 int i; 334 335 if (info->hdr) 336 vunmap(info->hdr); 337 338 for (i = 0; i < info->used_pages; i++) 339 __free_page(info->pages[i]); 340 341 kvfree(info->pages); 342 343 info->pages = NULL; 344 info->max_pages = info->used_pages = 0; 345 } 346 347 #ifdef CONFIG_SYSFS 348 static ssize_t compression_show(struct kobject *kobj, 349 struct kobj_attribute *attr, char *buf) 350 { 351 return sysfs_emit(buf, __stringify(MODULE_COMPRESSION) "\n"); 352 } 353 354 static struct kobj_attribute module_compression_attr = __ATTR_RO(compression); 355 356 static int __init module_decompress_sysfs_init(void) 357 { 358 int error; 359 360 error = sysfs_create_file(&module_kset->kobj, 361 &module_compression_attr.attr); 362 if (error) 363 pr_warn("Failed to create 'compression' attribute"); 364 365 return 0; 366 } 367 late_initcall(module_decompress_sysfs_init); 368 #endif 369