1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * binfmt_misc.c 4 * 5 * Copyright (C) 1997 Richard Günther 6 * 7 * binfmt_misc detects binaries via a magic or filename extension and invokes 8 * a specified wrapper. See Documentation/admin-guide/binfmt-misc.rst for more details. 9 */ 10 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/sched/mm.h> 17 #include <linux/magic.h> 18 #include <linux/binfmts.h> 19 #include <linux/slab.h> 20 #include <linux/ctype.h> 21 #include <linux/string_helpers.h> 22 #include <linux/file.h> 23 #include <linux/pagemap.h> 24 #include <linux/namei.h> 25 #include <linux/mount.h> 26 #include <linux/fs_context.h> 27 #include <linux/syscalls.h> 28 #include <linux/fs.h> 29 #include <linux/uaccess.h> 30 31 #include "internal.h" 32 33 #ifdef DEBUG 34 # define USE_DEBUG 1 35 #else 36 # define USE_DEBUG 0 37 #endif 38 39 enum { 40 VERBOSE_STATUS = 1 /* make it zero to save 400 bytes kernel memory */ 41 }; 42 43 static LIST_HEAD(entries); 44 static int enabled = 1; 45 46 enum {Enabled, Magic}; 47 #define MISC_FMT_PRESERVE_ARGV0 (1UL << 31) 48 #define MISC_FMT_OPEN_BINARY (1UL << 30) 49 #define MISC_FMT_CREDENTIALS (1UL << 29) 50 #define MISC_FMT_OPEN_FILE (1UL << 28) 51 52 typedef struct { 53 struct list_head list; 54 unsigned long flags; /* type, status, etc. */ 55 int offset; /* offset of magic */ 56 int size; /* size of magic/mask */ 57 char *magic; /* magic or filename extension */ 58 char *mask; /* mask, NULL for exact match */ 59 const char *interpreter; /* filename of interpreter */ 60 char *name; 61 struct dentry *dentry; 62 struct file *interp_file; 63 } Node; 64 65 static DEFINE_RWLOCK(entries_lock); 66 static struct file_system_type bm_fs_type; 67 static struct vfsmount *bm_mnt; 68 static int entry_count; 69 70 /* 71 * Max length of the register string. Determined by: 72 * - 7 delimiters 73 * - name: ~50 bytes 74 * - type: 1 byte 75 * - offset: 3 bytes (has to be smaller than BINPRM_BUF_SIZE) 76 * - magic: 128 bytes (512 in escaped form) 77 * - mask: 128 bytes (512 in escaped form) 78 * - interp: ~50 bytes 79 * - flags: 5 bytes 80 * Round that up a bit, and then back off to hold the internal data 81 * (like struct Node). 82 */ 83 #define MAX_REGISTER_LENGTH 1920 84 85 /* 86 * Check if we support the binfmt 87 * if we do, return the node, else NULL 88 * locking is done in load_misc_binary 89 */ 90 static Node *check_file(struct linux_binprm *bprm) 91 { 92 char *p = strrchr(bprm->interp, '.'); 93 struct list_head *l; 94 95 /* Walk all the registered handlers. */ 96 list_for_each(l, &entries) { 97 Node *e = list_entry(l, Node, list); 98 char *s; 99 int j; 100 101 /* Make sure this one is currently enabled. */ 102 if (!test_bit(Enabled, &e->flags)) 103 continue; 104 105 /* Do matching based on extension if applicable. */ 106 if (!test_bit(Magic, &e->flags)) { 107 if (p && !strcmp(e->magic, p + 1)) 108 return e; 109 continue; 110 } 111 112 /* Do matching based on magic & mask. */ 113 s = bprm->buf + e->offset; 114 if (e->mask) { 115 for (j = 0; j < e->size; j++) 116 if ((*s++ ^ e->magic[j]) & e->mask[j]) 117 break; 118 } else { 119 for (j = 0; j < e->size; j++) 120 if ((*s++ ^ e->magic[j])) 121 break; 122 } 123 if (j == e->size) 124 return e; 125 } 126 return NULL; 127 } 128 129 /* 130 * the loader itself 131 */ 132 static int load_misc_binary(struct linux_binprm *bprm) 133 { 134 Node *fmt; 135 struct file *interp_file = NULL; 136 int retval; 137 138 retval = -ENOEXEC; 139 if (!enabled) 140 return retval; 141 142 /* to keep locking time low, we copy the interpreter string */ 143 read_lock(&entries_lock); 144 fmt = check_file(bprm); 145 if (fmt) 146 dget(fmt->dentry); 147 read_unlock(&entries_lock); 148 if (!fmt) 149 return retval; 150 151 /* Need to be able to load the file after exec */ 152 retval = -ENOENT; 153 if (bprm->interp_flags & BINPRM_FLAGS_PATH_INACCESSIBLE) 154 goto ret; 155 156 if (fmt->flags & MISC_FMT_PRESERVE_ARGV0) { 157 bprm->interp_flags |= BINPRM_FLAGS_PRESERVE_ARGV0; 158 } else { 159 retval = remove_arg_zero(bprm); 160 if (retval) 161 goto ret; 162 } 163 164 if (fmt->flags & MISC_FMT_OPEN_BINARY) 165 bprm->have_execfd = 1; 166 167 /* make argv[1] be the path to the binary */ 168 retval = copy_string_kernel(bprm->interp, bprm); 169 if (retval < 0) 170 goto ret; 171 bprm->argc++; 172 173 /* add the interp as argv[0] */ 174 retval = copy_string_kernel(fmt->interpreter, bprm); 175 if (retval < 0) 176 goto ret; 177 bprm->argc++; 178 179 /* Update interp in case binfmt_script needs it. */ 180 retval = bprm_change_interp(fmt->interpreter, bprm); 181 if (retval < 0) 182 goto ret; 183 184 if (fmt->flags & MISC_FMT_OPEN_FILE) { 185 interp_file = file_clone_open(fmt->interp_file); 186 if (!IS_ERR(interp_file)) 187 deny_write_access(interp_file); 188 } else { 189 interp_file = open_exec(fmt->interpreter); 190 } 191 retval = PTR_ERR(interp_file); 192 if (IS_ERR(interp_file)) 193 goto ret; 194 195 bprm->interpreter = interp_file; 196 if (fmt->flags & MISC_FMT_CREDENTIALS) 197 bprm->execfd_creds = 1; 198 199 retval = 0; 200 ret: 201 dput(fmt->dentry); 202 return retval; 203 } 204 205 /* Command parsers */ 206 207 /* 208 * parses and copies one argument enclosed in del from *sp to *dp, 209 * recognising the \x special. 210 * returns pointer to the copied argument or NULL in case of an 211 * error (and sets err) or null argument length. 212 */ 213 static char *scanarg(char *s, char del) 214 { 215 char c; 216 217 while ((c = *s++) != del) { 218 if (c == '\\' && *s == 'x') { 219 s++; 220 if (!isxdigit(*s++)) 221 return NULL; 222 if (!isxdigit(*s++)) 223 return NULL; 224 } 225 } 226 s[-1] ='\0'; 227 return s; 228 } 229 230 static char *check_special_flags(char *sfs, Node *e) 231 { 232 char *p = sfs; 233 int cont = 1; 234 235 /* special flags */ 236 while (cont) { 237 switch (*p) { 238 case 'P': 239 pr_debug("register: flag: P (preserve argv0)\n"); 240 p++; 241 e->flags |= MISC_FMT_PRESERVE_ARGV0; 242 break; 243 case 'O': 244 pr_debug("register: flag: O (open binary)\n"); 245 p++; 246 e->flags |= MISC_FMT_OPEN_BINARY; 247 break; 248 case 'C': 249 pr_debug("register: flag: C (preserve creds)\n"); 250 p++; 251 /* this flags also implies the 252 open-binary flag */ 253 e->flags |= (MISC_FMT_CREDENTIALS | 254 MISC_FMT_OPEN_BINARY); 255 break; 256 case 'F': 257 pr_debug("register: flag: F: open interpreter file now\n"); 258 p++; 259 e->flags |= MISC_FMT_OPEN_FILE; 260 break; 261 default: 262 cont = 0; 263 } 264 } 265 266 return p; 267 } 268 269 /* 270 * This registers a new binary format, it recognises the syntax 271 * ':name:type:offset:magic:mask:interpreter:flags' 272 * where the ':' is the IFS, that can be chosen with the first char 273 */ 274 static Node *create_entry(const char __user *buffer, size_t count) 275 { 276 Node *e; 277 int memsize, err; 278 char *buf, *p; 279 char del; 280 281 pr_debug("register: received %zu bytes\n", count); 282 283 /* some sanity checks */ 284 err = -EINVAL; 285 if ((count < 11) || (count > MAX_REGISTER_LENGTH)) 286 goto out; 287 288 err = -ENOMEM; 289 memsize = sizeof(Node) + count + 8; 290 e = kmalloc(memsize, GFP_KERNEL); 291 if (!e) 292 goto out; 293 294 p = buf = (char *)e + sizeof(Node); 295 296 memset(e, 0, sizeof(Node)); 297 if (copy_from_user(buf, buffer, count)) 298 goto efault; 299 300 del = *p++; /* delimeter */ 301 302 pr_debug("register: delim: %#x {%c}\n", del, del); 303 304 /* Pad the buffer with the delim to simplify parsing below. */ 305 memset(buf + count, del, 8); 306 307 /* Parse the 'name' field. */ 308 e->name = p; 309 p = strchr(p, del); 310 if (!p) 311 goto einval; 312 *p++ = '\0'; 313 if (!e->name[0] || 314 !strcmp(e->name, ".") || 315 !strcmp(e->name, "..") || 316 strchr(e->name, '/')) 317 goto einval; 318 319 pr_debug("register: name: {%s}\n", e->name); 320 321 /* Parse the 'type' field. */ 322 switch (*p++) { 323 case 'E': 324 pr_debug("register: type: E (extension)\n"); 325 e->flags = 1 << Enabled; 326 break; 327 case 'M': 328 pr_debug("register: type: M (magic)\n"); 329 e->flags = (1 << Enabled) | (1 << Magic); 330 break; 331 default: 332 goto einval; 333 } 334 if (*p++ != del) 335 goto einval; 336 337 if (test_bit(Magic, &e->flags)) { 338 /* Handle the 'M' (magic) format. */ 339 char *s; 340 341 /* Parse the 'offset' field. */ 342 s = strchr(p, del); 343 if (!s) 344 goto einval; 345 *s = '\0'; 346 if (p != s) { 347 int r = kstrtoint(p, 10, &e->offset); 348 if (r != 0 || e->offset < 0) 349 goto einval; 350 } 351 p = s; 352 if (*p++) 353 goto einval; 354 pr_debug("register: offset: %#x\n", e->offset); 355 356 /* Parse the 'magic' field. */ 357 e->magic = p; 358 p = scanarg(p, del); 359 if (!p) 360 goto einval; 361 if (!e->magic[0]) 362 goto einval; 363 if (USE_DEBUG) 364 print_hex_dump_bytes( 365 KBUILD_MODNAME ": register: magic[raw]: ", 366 DUMP_PREFIX_NONE, e->magic, p - e->magic); 367 368 /* Parse the 'mask' field. */ 369 e->mask = p; 370 p = scanarg(p, del); 371 if (!p) 372 goto einval; 373 if (!e->mask[0]) { 374 e->mask = NULL; 375 pr_debug("register: mask[raw]: none\n"); 376 } else if (USE_DEBUG) 377 print_hex_dump_bytes( 378 KBUILD_MODNAME ": register: mask[raw]: ", 379 DUMP_PREFIX_NONE, e->mask, p - e->mask); 380 381 /* 382 * Decode the magic & mask fields. 383 * Note: while we might have accepted embedded NUL bytes from 384 * above, the unescape helpers here will stop at the first one 385 * it encounters. 386 */ 387 e->size = string_unescape_inplace(e->magic, UNESCAPE_HEX); 388 if (e->mask && 389 string_unescape_inplace(e->mask, UNESCAPE_HEX) != e->size) 390 goto einval; 391 if (e->size > BINPRM_BUF_SIZE || 392 BINPRM_BUF_SIZE - e->size < e->offset) 393 goto einval; 394 pr_debug("register: magic/mask length: %i\n", e->size); 395 if (USE_DEBUG) { 396 print_hex_dump_bytes( 397 KBUILD_MODNAME ": register: magic[decoded]: ", 398 DUMP_PREFIX_NONE, e->magic, e->size); 399 400 if (e->mask) { 401 int i; 402 char *masked = kmalloc(e->size, GFP_KERNEL); 403 404 print_hex_dump_bytes( 405 KBUILD_MODNAME ": register: mask[decoded]: ", 406 DUMP_PREFIX_NONE, e->mask, e->size); 407 408 if (masked) { 409 for (i = 0; i < e->size; ++i) 410 masked[i] = e->magic[i] & e->mask[i]; 411 print_hex_dump_bytes( 412 KBUILD_MODNAME ": register: magic[masked]: ", 413 DUMP_PREFIX_NONE, masked, e->size); 414 415 kfree(masked); 416 } 417 } 418 } 419 } else { 420 /* Handle the 'E' (extension) format. */ 421 422 /* Skip the 'offset' field. */ 423 p = strchr(p, del); 424 if (!p) 425 goto einval; 426 *p++ = '\0'; 427 428 /* Parse the 'magic' field. */ 429 e->magic = p; 430 p = strchr(p, del); 431 if (!p) 432 goto einval; 433 *p++ = '\0'; 434 if (!e->magic[0] || strchr(e->magic, '/')) 435 goto einval; 436 pr_debug("register: extension: {%s}\n", e->magic); 437 438 /* Skip the 'mask' field. */ 439 p = strchr(p, del); 440 if (!p) 441 goto einval; 442 *p++ = '\0'; 443 } 444 445 /* Parse the 'interpreter' field. */ 446 e->interpreter = p; 447 p = strchr(p, del); 448 if (!p) 449 goto einval; 450 *p++ = '\0'; 451 if (!e->interpreter[0]) 452 goto einval; 453 pr_debug("register: interpreter: {%s}\n", e->interpreter); 454 455 /* Parse the 'flags' field. */ 456 p = check_special_flags(p, e); 457 if (*p == '\n') 458 p++; 459 if (p != buf + count) 460 goto einval; 461 462 return e; 463 464 out: 465 return ERR_PTR(err); 466 467 efault: 468 kfree(e); 469 return ERR_PTR(-EFAULT); 470 einval: 471 kfree(e); 472 return ERR_PTR(-EINVAL); 473 } 474 475 /* 476 * Set status of entry/binfmt_misc: 477 * '1' enables, '0' disables and '-1' clears entry/binfmt_misc 478 */ 479 static int parse_command(const char __user *buffer, size_t count) 480 { 481 char s[4]; 482 483 if (count > 3) 484 return -EINVAL; 485 if (copy_from_user(s, buffer, count)) 486 return -EFAULT; 487 if (!count) 488 return 0; 489 if (s[count - 1] == '\n') 490 count--; 491 if (count == 1 && s[0] == '0') 492 return 1; 493 if (count == 1 && s[0] == '1') 494 return 2; 495 if (count == 2 && s[0] == '-' && s[1] == '1') 496 return 3; 497 return -EINVAL; 498 } 499 500 /* generic stuff */ 501 502 static void entry_status(Node *e, char *page) 503 { 504 char *dp = page; 505 const char *status = "disabled"; 506 507 if (test_bit(Enabled, &e->flags)) 508 status = "enabled"; 509 510 if (!VERBOSE_STATUS) { 511 sprintf(page, "%s\n", status); 512 return; 513 } 514 515 dp += sprintf(dp, "%s\ninterpreter %s\n", status, e->interpreter); 516 517 /* print the special flags */ 518 dp += sprintf(dp, "flags: "); 519 if (e->flags & MISC_FMT_PRESERVE_ARGV0) 520 *dp++ = 'P'; 521 if (e->flags & MISC_FMT_OPEN_BINARY) 522 *dp++ = 'O'; 523 if (e->flags & MISC_FMT_CREDENTIALS) 524 *dp++ = 'C'; 525 if (e->flags & MISC_FMT_OPEN_FILE) 526 *dp++ = 'F'; 527 *dp++ = '\n'; 528 529 if (!test_bit(Magic, &e->flags)) { 530 sprintf(dp, "extension .%s\n", e->magic); 531 } else { 532 dp += sprintf(dp, "offset %i\nmagic ", e->offset); 533 dp = bin2hex(dp, e->magic, e->size); 534 if (e->mask) { 535 dp += sprintf(dp, "\nmask "); 536 dp = bin2hex(dp, e->mask, e->size); 537 } 538 *dp++ = '\n'; 539 *dp = '\0'; 540 } 541 } 542 543 static struct inode *bm_get_inode(struct super_block *sb, int mode) 544 { 545 struct inode *inode = new_inode(sb); 546 547 if (inode) { 548 inode->i_ino = get_next_ino(); 549 inode->i_mode = mode; 550 inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode); 551 } 552 return inode; 553 } 554 555 static void bm_evict_inode(struct inode *inode) 556 { 557 Node *e = inode->i_private; 558 559 if (e && e->flags & MISC_FMT_OPEN_FILE) 560 filp_close(e->interp_file, NULL); 561 562 clear_inode(inode); 563 kfree(e); 564 } 565 566 static void kill_node(Node *e) 567 { 568 struct dentry *dentry; 569 570 write_lock(&entries_lock); 571 list_del_init(&e->list); 572 write_unlock(&entries_lock); 573 574 dentry = e->dentry; 575 drop_nlink(d_inode(dentry)); 576 d_drop(dentry); 577 dput(dentry); 578 simple_release_fs(&bm_mnt, &entry_count); 579 } 580 581 /* /<entry> */ 582 583 static ssize_t 584 bm_entry_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) 585 { 586 Node *e = file_inode(file)->i_private; 587 ssize_t res; 588 char *page; 589 590 page = (char *) __get_free_page(GFP_KERNEL); 591 if (!page) 592 return -ENOMEM; 593 594 entry_status(e, page); 595 596 res = simple_read_from_buffer(buf, nbytes, ppos, page, strlen(page)); 597 598 free_page((unsigned long) page); 599 return res; 600 } 601 602 static ssize_t bm_entry_write(struct file *file, const char __user *buffer, 603 size_t count, loff_t *ppos) 604 { 605 struct dentry *root; 606 Node *e = file_inode(file)->i_private; 607 int res = parse_command(buffer, count); 608 609 switch (res) { 610 case 1: 611 /* Disable this handler. */ 612 clear_bit(Enabled, &e->flags); 613 break; 614 case 2: 615 /* Enable this handler. */ 616 set_bit(Enabled, &e->flags); 617 break; 618 case 3: 619 /* Delete this handler. */ 620 root = file_inode(file)->i_sb->s_root; 621 inode_lock(d_inode(root)); 622 623 if (!list_empty(&e->list)) 624 kill_node(e); 625 626 inode_unlock(d_inode(root)); 627 break; 628 default: 629 return res; 630 } 631 632 return count; 633 } 634 635 static const struct file_operations bm_entry_operations = { 636 .read = bm_entry_read, 637 .write = bm_entry_write, 638 .llseek = default_llseek, 639 }; 640 641 /* /register */ 642 643 static ssize_t bm_register_write(struct file *file, const char __user *buffer, 644 size_t count, loff_t *ppos) 645 { 646 Node *e; 647 struct inode *inode; 648 struct super_block *sb = file_inode(file)->i_sb; 649 struct dentry *root = sb->s_root, *dentry; 650 int err = 0; 651 struct file *f = NULL; 652 653 e = create_entry(buffer, count); 654 655 if (IS_ERR(e)) 656 return PTR_ERR(e); 657 658 if (e->flags & MISC_FMT_OPEN_FILE) { 659 f = open_exec(e->interpreter); 660 if (IS_ERR(f)) { 661 pr_notice("register: failed to install interpreter file %s\n", 662 e->interpreter); 663 kfree(e); 664 return PTR_ERR(f); 665 } 666 e->interp_file = f; 667 } 668 669 inode_lock(d_inode(root)); 670 dentry = lookup_one_len(e->name, root, strlen(e->name)); 671 err = PTR_ERR(dentry); 672 if (IS_ERR(dentry)) 673 goto out; 674 675 err = -EEXIST; 676 if (d_really_is_positive(dentry)) 677 goto out2; 678 679 inode = bm_get_inode(sb, S_IFREG | 0644); 680 681 err = -ENOMEM; 682 if (!inode) 683 goto out2; 684 685 err = simple_pin_fs(&bm_fs_type, &bm_mnt, &entry_count); 686 if (err) { 687 iput(inode); 688 inode = NULL; 689 goto out2; 690 } 691 692 e->dentry = dget(dentry); 693 inode->i_private = e; 694 inode->i_fop = &bm_entry_operations; 695 696 d_instantiate(dentry, inode); 697 write_lock(&entries_lock); 698 list_add(&e->list, &entries); 699 write_unlock(&entries_lock); 700 701 err = 0; 702 out2: 703 dput(dentry); 704 out: 705 inode_unlock(d_inode(root)); 706 707 if (err) { 708 if (f) 709 filp_close(f, NULL); 710 kfree(e); 711 return err; 712 } 713 return count; 714 } 715 716 static const struct file_operations bm_register_operations = { 717 .write = bm_register_write, 718 .llseek = noop_llseek, 719 }; 720 721 /* /status */ 722 723 static ssize_t 724 bm_status_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) 725 { 726 char *s = enabled ? "enabled\n" : "disabled\n"; 727 728 return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s)); 729 } 730 731 static ssize_t bm_status_write(struct file *file, const char __user *buffer, 732 size_t count, loff_t *ppos) 733 { 734 int res = parse_command(buffer, count); 735 struct dentry *root; 736 737 switch (res) { 738 case 1: 739 /* Disable all handlers. */ 740 enabled = 0; 741 break; 742 case 2: 743 /* Enable all handlers. */ 744 enabled = 1; 745 break; 746 case 3: 747 /* Delete all handlers. */ 748 root = file_inode(file)->i_sb->s_root; 749 inode_lock(d_inode(root)); 750 751 while (!list_empty(&entries)) 752 kill_node(list_first_entry(&entries, Node, list)); 753 754 inode_unlock(d_inode(root)); 755 break; 756 default: 757 return res; 758 } 759 760 return count; 761 } 762 763 static const struct file_operations bm_status_operations = { 764 .read = bm_status_read, 765 .write = bm_status_write, 766 .llseek = default_llseek, 767 }; 768 769 /* Superblock handling */ 770 771 static const struct super_operations s_ops = { 772 .statfs = simple_statfs, 773 .evict_inode = bm_evict_inode, 774 }; 775 776 static int bm_fill_super(struct super_block *sb, struct fs_context *fc) 777 { 778 int err; 779 static const struct tree_descr bm_files[] = { 780 [2] = {"status", &bm_status_operations, S_IWUSR|S_IRUGO}, 781 [3] = {"register", &bm_register_operations, S_IWUSR}, 782 /* last one */ {""} 783 }; 784 785 err = simple_fill_super(sb, BINFMTFS_MAGIC, bm_files); 786 if (!err) 787 sb->s_op = &s_ops; 788 return err; 789 } 790 791 static int bm_get_tree(struct fs_context *fc) 792 { 793 return get_tree_single(fc, bm_fill_super); 794 } 795 796 static const struct fs_context_operations bm_context_ops = { 797 .get_tree = bm_get_tree, 798 }; 799 800 static int bm_init_fs_context(struct fs_context *fc) 801 { 802 fc->ops = &bm_context_ops; 803 return 0; 804 } 805 806 static struct linux_binfmt misc_format = { 807 .module = THIS_MODULE, 808 .load_binary = load_misc_binary, 809 }; 810 811 static struct file_system_type bm_fs_type = { 812 .owner = THIS_MODULE, 813 .name = "binfmt_misc", 814 .init_fs_context = bm_init_fs_context, 815 .kill_sb = kill_litter_super, 816 }; 817 MODULE_ALIAS_FS("binfmt_misc"); 818 819 static int __init init_misc_binfmt(void) 820 { 821 int err = register_filesystem(&bm_fs_type); 822 if (!err) 823 insert_binfmt(&misc_format); 824 return err; 825 } 826 827 static void __exit exit_misc_binfmt(void) 828 { 829 unregister_binfmt(&misc_format); 830 unregister_filesystem(&bm_fs_type); 831 } 832 833 core_initcall(init_misc_binfmt); 834 module_exit(exit_misc_binfmt); 835 MODULE_LICENSE("GPL"); 836