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 (1 << 31) 48 #define MISC_FMT_OPEN_BINARY (1 << 30) 49 #define MISC_FMT_CREDENTIALS (1 << 29) 50 #define MISC_FMT_OPEN_FILE (1 << 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 int fd_binary = -1; 138 139 retval = -ENOEXEC; 140 if (!enabled) 141 return retval; 142 143 /* to keep locking time low, we copy the interpreter string */ 144 read_lock(&entries_lock); 145 fmt = check_file(bprm); 146 if (fmt) 147 dget(fmt->dentry); 148 read_unlock(&entries_lock); 149 if (!fmt) 150 return retval; 151 152 /* Need to be able to load the file after exec */ 153 retval = -ENOENT; 154 if (bprm->interp_flags & BINPRM_FLAGS_PATH_INACCESSIBLE) 155 goto ret; 156 157 if (!(fmt->flags & MISC_FMT_PRESERVE_ARGV0)) { 158 retval = remove_arg_zero(bprm); 159 if (retval) 160 goto ret; 161 } 162 163 if (fmt->flags & MISC_FMT_OPEN_BINARY) { 164 165 /* if the binary should be opened on behalf of the 166 * interpreter than keep it open and assign descriptor 167 * to it 168 */ 169 fd_binary = get_unused_fd_flags(0); 170 if (fd_binary < 0) { 171 retval = fd_binary; 172 goto ret; 173 } 174 fd_install(fd_binary, bprm->file); 175 176 /* if the binary is not readable than enforce mm->dumpable=0 177 regardless of the interpreter's permissions */ 178 would_dump(bprm, bprm->file); 179 180 allow_write_access(bprm->file); 181 bprm->file = NULL; 182 183 /* mark the bprm that fd should be passed to interp */ 184 bprm->interp_flags |= BINPRM_FLAGS_EXECFD; 185 bprm->interp_data = fd_binary; 186 187 } else { 188 allow_write_access(bprm->file); 189 fput(bprm->file); 190 bprm->file = NULL; 191 } 192 /* make argv[1] be the path to the binary */ 193 retval = copy_strings_kernel(1, &bprm->interp, bprm); 194 if (retval < 0) 195 goto error; 196 bprm->argc++; 197 198 /* add the interp as argv[0] */ 199 retval = copy_strings_kernel(1, &fmt->interpreter, bprm); 200 if (retval < 0) 201 goto error; 202 bprm->argc++; 203 204 /* Update interp in case binfmt_script needs it. */ 205 retval = bprm_change_interp(fmt->interpreter, bprm); 206 if (retval < 0) 207 goto error; 208 209 if (fmt->flags & MISC_FMT_OPEN_FILE) { 210 interp_file = file_clone_open(fmt->interp_file); 211 if (!IS_ERR(interp_file)) 212 deny_write_access(interp_file); 213 } else { 214 interp_file = open_exec(fmt->interpreter); 215 } 216 retval = PTR_ERR(interp_file); 217 if (IS_ERR(interp_file)) 218 goto error; 219 220 bprm->file = interp_file; 221 if (fmt->flags & MISC_FMT_CREDENTIALS) 222 bprm->preserve_creds = 1; 223 224 retval = prepare_binprm(bprm); 225 if (retval < 0) 226 goto error; 227 228 retval = search_binary_handler(bprm); 229 if (retval < 0) 230 goto error; 231 232 ret: 233 dput(fmt->dentry); 234 return retval; 235 error: 236 if (fd_binary > 0) 237 ksys_close(fd_binary); 238 bprm->interp_flags = 0; 239 bprm->interp_data = 0; 240 goto ret; 241 } 242 243 /* Command parsers */ 244 245 /* 246 * parses and copies one argument enclosed in del from *sp to *dp, 247 * recognising the \x special. 248 * returns pointer to the copied argument or NULL in case of an 249 * error (and sets err) or null argument length. 250 */ 251 static char *scanarg(char *s, char del) 252 { 253 char c; 254 255 while ((c = *s++) != del) { 256 if (c == '\\' && *s == 'x') { 257 s++; 258 if (!isxdigit(*s++)) 259 return NULL; 260 if (!isxdigit(*s++)) 261 return NULL; 262 } 263 } 264 s[-1] ='\0'; 265 return s; 266 } 267 268 static char *check_special_flags(char *sfs, Node *e) 269 { 270 char *p = sfs; 271 int cont = 1; 272 273 /* special flags */ 274 while (cont) { 275 switch (*p) { 276 case 'P': 277 pr_debug("register: flag: P (preserve argv0)\n"); 278 p++; 279 e->flags |= MISC_FMT_PRESERVE_ARGV0; 280 break; 281 case 'O': 282 pr_debug("register: flag: O (open binary)\n"); 283 p++; 284 e->flags |= MISC_FMT_OPEN_BINARY; 285 break; 286 case 'C': 287 pr_debug("register: flag: C (preserve creds)\n"); 288 p++; 289 /* this flags also implies the 290 open-binary flag */ 291 e->flags |= (MISC_FMT_CREDENTIALS | 292 MISC_FMT_OPEN_BINARY); 293 break; 294 case 'F': 295 pr_debug("register: flag: F: open interpreter file now\n"); 296 p++; 297 e->flags |= MISC_FMT_OPEN_FILE; 298 break; 299 default: 300 cont = 0; 301 } 302 } 303 304 return p; 305 } 306 307 /* 308 * This registers a new binary format, it recognises the syntax 309 * ':name:type:offset:magic:mask:interpreter:flags' 310 * where the ':' is the IFS, that can be chosen with the first char 311 */ 312 static Node *create_entry(const char __user *buffer, size_t count) 313 { 314 Node *e; 315 int memsize, err; 316 char *buf, *p; 317 char del; 318 319 pr_debug("register: received %zu bytes\n", count); 320 321 /* some sanity checks */ 322 err = -EINVAL; 323 if ((count < 11) || (count > MAX_REGISTER_LENGTH)) 324 goto out; 325 326 err = -ENOMEM; 327 memsize = sizeof(Node) + count + 8; 328 e = kmalloc(memsize, GFP_KERNEL); 329 if (!e) 330 goto out; 331 332 p = buf = (char *)e + sizeof(Node); 333 334 memset(e, 0, sizeof(Node)); 335 if (copy_from_user(buf, buffer, count)) 336 goto efault; 337 338 del = *p++; /* delimeter */ 339 340 pr_debug("register: delim: %#x {%c}\n", del, del); 341 342 /* Pad the buffer with the delim to simplify parsing below. */ 343 memset(buf + count, del, 8); 344 345 /* Parse the 'name' field. */ 346 e->name = p; 347 p = strchr(p, del); 348 if (!p) 349 goto einval; 350 *p++ = '\0'; 351 if (!e->name[0] || 352 !strcmp(e->name, ".") || 353 !strcmp(e->name, "..") || 354 strchr(e->name, '/')) 355 goto einval; 356 357 pr_debug("register: name: {%s}\n", e->name); 358 359 /* Parse the 'type' field. */ 360 switch (*p++) { 361 case 'E': 362 pr_debug("register: type: E (extension)\n"); 363 e->flags = 1 << Enabled; 364 break; 365 case 'M': 366 pr_debug("register: type: M (magic)\n"); 367 e->flags = (1 << Enabled) | (1 << Magic); 368 break; 369 default: 370 goto einval; 371 } 372 if (*p++ != del) 373 goto einval; 374 375 if (test_bit(Magic, &e->flags)) { 376 /* Handle the 'M' (magic) format. */ 377 char *s; 378 379 /* Parse the 'offset' field. */ 380 s = strchr(p, del); 381 if (!s) 382 goto einval; 383 *s = '\0'; 384 if (p != s) { 385 int r = kstrtoint(p, 10, &e->offset); 386 if (r != 0 || e->offset < 0) 387 goto einval; 388 } 389 p = s; 390 if (*p++) 391 goto einval; 392 pr_debug("register: offset: %#x\n", e->offset); 393 394 /* Parse the 'magic' field. */ 395 e->magic = p; 396 p = scanarg(p, del); 397 if (!p) 398 goto einval; 399 if (!e->magic[0]) 400 goto einval; 401 if (USE_DEBUG) 402 print_hex_dump_bytes( 403 KBUILD_MODNAME ": register: magic[raw]: ", 404 DUMP_PREFIX_NONE, e->magic, p - e->magic); 405 406 /* Parse the 'mask' field. */ 407 e->mask = p; 408 p = scanarg(p, del); 409 if (!p) 410 goto einval; 411 if (!e->mask[0]) { 412 e->mask = NULL; 413 pr_debug("register: mask[raw]: none\n"); 414 } else if (USE_DEBUG) 415 print_hex_dump_bytes( 416 KBUILD_MODNAME ": register: mask[raw]: ", 417 DUMP_PREFIX_NONE, e->mask, p - e->mask); 418 419 /* 420 * Decode the magic & mask fields. 421 * Note: while we might have accepted embedded NUL bytes from 422 * above, the unescape helpers here will stop at the first one 423 * it encounters. 424 */ 425 e->size = string_unescape_inplace(e->magic, UNESCAPE_HEX); 426 if (e->mask && 427 string_unescape_inplace(e->mask, UNESCAPE_HEX) != e->size) 428 goto einval; 429 if (e->size > BINPRM_BUF_SIZE || 430 BINPRM_BUF_SIZE - e->size < e->offset) 431 goto einval; 432 pr_debug("register: magic/mask length: %i\n", e->size); 433 if (USE_DEBUG) { 434 print_hex_dump_bytes( 435 KBUILD_MODNAME ": register: magic[decoded]: ", 436 DUMP_PREFIX_NONE, e->magic, e->size); 437 438 if (e->mask) { 439 int i; 440 char *masked = kmalloc(e->size, GFP_KERNEL); 441 442 print_hex_dump_bytes( 443 KBUILD_MODNAME ": register: mask[decoded]: ", 444 DUMP_PREFIX_NONE, e->mask, e->size); 445 446 if (masked) { 447 for (i = 0; i < e->size; ++i) 448 masked[i] = e->magic[i] & e->mask[i]; 449 print_hex_dump_bytes( 450 KBUILD_MODNAME ": register: magic[masked]: ", 451 DUMP_PREFIX_NONE, masked, e->size); 452 453 kfree(masked); 454 } 455 } 456 } 457 } else { 458 /* Handle the 'E' (extension) format. */ 459 460 /* Skip the 'offset' field. */ 461 p = strchr(p, del); 462 if (!p) 463 goto einval; 464 *p++ = '\0'; 465 466 /* Parse the 'magic' field. */ 467 e->magic = p; 468 p = strchr(p, del); 469 if (!p) 470 goto einval; 471 *p++ = '\0'; 472 if (!e->magic[0] || strchr(e->magic, '/')) 473 goto einval; 474 pr_debug("register: extension: {%s}\n", e->magic); 475 476 /* Skip the 'mask' field. */ 477 p = strchr(p, del); 478 if (!p) 479 goto einval; 480 *p++ = '\0'; 481 } 482 483 /* Parse the 'interpreter' field. */ 484 e->interpreter = p; 485 p = strchr(p, del); 486 if (!p) 487 goto einval; 488 *p++ = '\0'; 489 if (!e->interpreter[0]) 490 goto einval; 491 pr_debug("register: interpreter: {%s}\n", e->interpreter); 492 493 /* Parse the 'flags' field. */ 494 p = check_special_flags(p, e); 495 if (*p == '\n') 496 p++; 497 if (p != buf + count) 498 goto einval; 499 500 return e; 501 502 out: 503 return ERR_PTR(err); 504 505 efault: 506 kfree(e); 507 return ERR_PTR(-EFAULT); 508 einval: 509 kfree(e); 510 return ERR_PTR(-EINVAL); 511 } 512 513 /* 514 * Set status of entry/binfmt_misc: 515 * '1' enables, '0' disables and '-1' clears entry/binfmt_misc 516 */ 517 static int parse_command(const char __user *buffer, size_t count) 518 { 519 char s[4]; 520 521 if (count > 3) 522 return -EINVAL; 523 if (copy_from_user(s, buffer, count)) 524 return -EFAULT; 525 if (!count) 526 return 0; 527 if (s[count - 1] == '\n') 528 count--; 529 if (count == 1 && s[0] == '0') 530 return 1; 531 if (count == 1 && s[0] == '1') 532 return 2; 533 if (count == 2 && s[0] == '-' && s[1] == '1') 534 return 3; 535 return -EINVAL; 536 } 537 538 /* generic stuff */ 539 540 static void entry_status(Node *e, char *page) 541 { 542 char *dp = page; 543 const char *status = "disabled"; 544 545 if (test_bit(Enabled, &e->flags)) 546 status = "enabled"; 547 548 if (!VERBOSE_STATUS) { 549 sprintf(page, "%s\n", status); 550 return; 551 } 552 553 dp += sprintf(dp, "%s\ninterpreter %s\n", status, e->interpreter); 554 555 /* print the special flags */ 556 dp += sprintf(dp, "flags: "); 557 if (e->flags & MISC_FMT_PRESERVE_ARGV0) 558 *dp++ = 'P'; 559 if (e->flags & MISC_FMT_OPEN_BINARY) 560 *dp++ = 'O'; 561 if (e->flags & MISC_FMT_CREDENTIALS) 562 *dp++ = 'C'; 563 if (e->flags & MISC_FMT_OPEN_FILE) 564 *dp++ = 'F'; 565 *dp++ = '\n'; 566 567 if (!test_bit(Magic, &e->flags)) { 568 sprintf(dp, "extension .%s\n", e->magic); 569 } else { 570 dp += sprintf(dp, "offset %i\nmagic ", e->offset); 571 dp = bin2hex(dp, e->magic, e->size); 572 if (e->mask) { 573 dp += sprintf(dp, "\nmask "); 574 dp = bin2hex(dp, e->mask, e->size); 575 } 576 *dp++ = '\n'; 577 *dp = '\0'; 578 } 579 } 580 581 static struct inode *bm_get_inode(struct super_block *sb, int mode) 582 { 583 struct inode *inode = new_inode(sb); 584 585 if (inode) { 586 inode->i_ino = get_next_ino(); 587 inode->i_mode = mode; 588 inode->i_atime = inode->i_mtime = inode->i_ctime = 589 current_time(inode); 590 } 591 return inode; 592 } 593 594 static void bm_evict_inode(struct inode *inode) 595 { 596 Node *e = inode->i_private; 597 598 if (e && e->flags & MISC_FMT_OPEN_FILE) 599 filp_close(e->interp_file, NULL); 600 601 clear_inode(inode); 602 kfree(e); 603 } 604 605 static void kill_node(Node *e) 606 { 607 struct dentry *dentry; 608 609 write_lock(&entries_lock); 610 list_del_init(&e->list); 611 write_unlock(&entries_lock); 612 613 dentry = e->dentry; 614 drop_nlink(d_inode(dentry)); 615 d_drop(dentry); 616 dput(dentry); 617 simple_release_fs(&bm_mnt, &entry_count); 618 } 619 620 /* /<entry> */ 621 622 static ssize_t 623 bm_entry_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) 624 { 625 Node *e = file_inode(file)->i_private; 626 ssize_t res; 627 char *page; 628 629 page = (char *) __get_free_page(GFP_KERNEL); 630 if (!page) 631 return -ENOMEM; 632 633 entry_status(e, page); 634 635 res = simple_read_from_buffer(buf, nbytes, ppos, page, strlen(page)); 636 637 free_page((unsigned long) page); 638 return res; 639 } 640 641 static ssize_t bm_entry_write(struct file *file, const char __user *buffer, 642 size_t count, loff_t *ppos) 643 { 644 struct dentry *root; 645 Node *e = file_inode(file)->i_private; 646 int res = parse_command(buffer, count); 647 648 switch (res) { 649 case 1: 650 /* Disable this handler. */ 651 clear_bit(Enabled, &e->flags); 652 break; 653 case 2: 654 /* Enable this handler. */ 655 set_bit(Enabled, &e->flags); 656 break; 657 case 3: 658 /* Delete this handler. */ 659 root = file_inode(file)->i_sb->s_root; 660 inode_lock(d_inode(root)); 661 662 if (!list_empty(&e->list)) 663 kill_node(e); 664 665 inode_unlock(d_inode(root)); 666 break; 667 default: 668 return res; 669 } 670 671 return count; 672 } 673 674 static const struct file_operations bm_entry_operations = { 675 .read = bm_entry_read, 676 .write = bm_entry_write, 677 .llseek = default_llseek, 678 }; 679 680 /* /register */ 681 682 static ssize_t bm_register_write(struct file *file, const char __user *buffer, 683 size_t count, loff_t *ppos) 684 { 685 Node *e; 686 struct inode *inode; 687 struct super_block *sb = file_inode(file)->i_sb; 688 struct dentry *root = sb->s_root, *dentry; 689 int err = 0; 690 691 e = create_entry(buffer, count); 692 693 if (IS_ERR(e)) 694 return PTR_ERR(e); 695 696 inode_lock(d_inode(root)); 697 dentry = lookup_one_len(e->name, root, strlen(e->name)); 698 err = PTR_ERR(dentry); 699 if (IS_ERR(dentry)) 700 goto out; 701 702 err = -EEXIST; 703 if (d_really_is_positive(dentry)) 704 goto out2; 705 706 inode = bm_get_inode(sb, S_IFREG | 0644); 707 708 err = -ENOMEM; 709 if (!inode) 710 goto out2; 711 712 err = simple_pin_fs(&bm_fs_type, &bm_mnt, &entry_count); 713 if (err) { 714 iput(inode); 715 inode = NULL; 716 goto out2; 717 } 718 719 if (e->flags & MISC_FMT_OPEN_FILE) { 720 struct file *f; 721 722 f = open_exec(e->interpreter); 723 if (IS_ERR(f)) { 724 err = PTR_ERR(f); 725 pr_notice("register: failed to install interpreter file %s\n", e->interpreter); 726 simple_release_fs(&bm_mnt, &entry_count); 727 iput(inode); 728 inode = NULL; 729 goto out2; 730 } 731 e->interp_file = f; 732 } 733 734 e->dentry = dget(dentry); 735 inode->i_private = e; 736 inode->i_fop = &bm_entry_operations; 737 738 d_instantiate(dentry, inode); 739 write_lock(&entries_lock); 740 list_add(&e->list, &entries); 741 write_unlock(&entries_lock); 742 743 err = 0; 744 out2: 745 dput(dentry); 746 out: 747 inode_unlock(d_inode(root)); 748 749 if (err) { 750 kfree(e); 751 return err; 752 } 753 return count; 754 } 755 756 static const struct file_operations bm_register_operations = { 757 .write = bm_register_write, 758 .llseek = noop_llseek, 759 }; 760 761 /* /status */ 762 763 static ssize_t 764 bm_status_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) 765 { 766 char *s = enabled ? "enabled\n" : "disabled\n"; 767 768 return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s)); 769 } 770 771 static ssize_t bm_status_write(struct file *file, const char __user *buffer, 772 size_t count, loff_t *ppos) 773 { 774 int res = parse_command(buffer, count); 775 struct dentry *root; 776 777 switch (res) { 778 case 1: 779 /* Disable all handlers. */ 780 enabled = 0; 781 break; 782 case 2: 783 /* Enable all handlers. */ 784 enabled = 1; 785 break; 786 case 3: 787 /* Delete all handlers. */ 788 root = file_inode(file)->i_sb->s_root; 789 inode_lock(d_inode(root)); 790 791 while (!list_empty(&entries)) 792 kill_node(list_first_entry(&entries, Node, list)); 793 794 inode_unlock(d_inode(root)); 795 break; 796 default: 797 return res; 798 } 799 800 return count; 801 } 802 803 static const struct file_operations bm_status_operations = { 804 .read = bm_status_read, 805 .write = bm_status_write, 806 .llseek = default_llseek, 807 }; 808 809 /* Superblock handling */ 810 811 static const struct super_operations s_ops = { 812 .statfs = simple_statfs, 813 .evict_inode = bm_evict_inode, 814 }; 815 816 static int bm_fill_super(struct super_block *sb, struct fs_context *fc) 817 { 818 int err; 819 static const struct tree_descr bm_files[] = { 820 [2] = {"status", &bm_status_operations, S_IWUSR|S_IRUGO}, 821 [3] = {"register", &bm_register_operations, S_IWUSR}, 822 /* last one */ {""} 823 }; 824 825 err = simple_fill_super(sb, BINFMTFS_MAGIC, bm_files); 826 if (!err) 827 sb->s_op = &s_ops; 828 return err; 829 } 830 831 static int bm_get_tree(struct fs_context *fc) 832 { 833 return get_tree_single(fc, bm_fill_super); 834 } 835 836 static const struct fs_context_operations bm_context_ops = { 837 .get_tree = bm_get_tree, 838 }; 839 840 static int bm_init_fs_context(struct fs_context *fc) 841 { 842 fc->ops = &bm_context_ops; 843 return 0; 844 } 845 846 static struct linux_binfmt misc_format = { 847 .module = THIS_MODULE, 848 .load_binary = load_misc_binary, 849 }; 850 851 static struct file_system_type bm_fs_type = { 852 .owner = THIS_MODULE, 853 .name = "binfmt_misc", 854 .init_fs_context = bm_init_fs_context, 855 .kill_sb = kill_litter_super, 856 }; 857 MODULE_ALIAS_FS("binfmt_misc"); 858 859 static int __init init_misc_binfmt(void) 860 { 861 int err = register_filesystem(&bm_fs_type); 862 if (!err) 863 insert_binfmt(&misc_format); 864 return err; 865 } 866 867 static void __exit exit_misc_binfmt(void) 868 { 869 unregister_binfmt(&misc_format); 870 unregister_filesystem(&bm_fs_type); 871 } 872 873 core_initcall(init_misc_binfmt); 874 module_exit(exit_misc_binfmt); 875 MODULE_LICENSE("GPL"); 876