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