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