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 */
check_file(struct linux_binprm * bprm)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 */
load_misc_binary(struct linux_binprm * bprm)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 */
scanarg(char * s,char del)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
check_special_flags(char * sfs,Node * e)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 */
create_entry(const char __user * buffer,size_t count)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 */
parse_command(const char __user * buffer,size_t count)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
entry_status(Node * e,char * page)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
bm_get_inode(struct super_block * sb,int mode)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
bm_evict_inode(struct inode * inode)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
kill_node(Node * e)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
bm_entry_read(struct file * file,char __user * buf,size_t nbytes,loff_t * ppos)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
bm_entry_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)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
bm_register_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)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
bm_status_read(struct file * file,char __user * buf,size_t nbytes,loff_t * ppos)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
bm_status_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)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
bm_fill_super(struct super_block * sb,struct fs_context * fc)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
bm_get_tree(struct fs_context * fc)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
bm_init_fs_context(struct fs_context * fc)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
init_misc_binfmt(void)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
exit_misc_binfmt(void)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