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