turn filp_clone_open() into inline wrapper for dentry_open()
[muen/linux.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/admin-guide/binfmt-misc.rst 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 = file_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                 ksys_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                 if (p != s) {
392                         int r = kstrtoint(p, 10, &e->offset);
393                         if (r != 0 || e->offset < 0)
394                                 goto einval;
395                 }
396                 p = s;
397                 if (*p++)
398                         goto einval;
399                 pr_debug("register: offset: %#x\n", e->offset);
400
401                 /* Parse the 'magic' field. */
402                 e->magic = p;
403                 p = scanarg(p, del);
404                 if (!p)
405                         goto einval;
406                 if (!e->magic[0])
407                         goto einval;
408                 if (USE_DEBUG)
409                         print_hex_dump_bytes(
410                                 KBUILD_MODNAME ": register: magic[raw]: ",
411                                 DUMP_PREFIX_NONE, e->magic, p - e->magic);
412
413                 /* Parse the 'mask' field. */
414                 e->mask = p;
415                 p = scanarg(p, del);
416                 if (!p)
417                         goto einval;
418                 if (!e->mask[0]) {
419                         e->mask = NULL;
420                         pr_debug("register:  mask[raw]: none\n");
421                 } else if (USE_DEBUG)
422                         print_hex_dump_bytes(
423                                 KBUILD_MODNAME ": register:  mask[raw]: ",
424                                 DUMP_PREFIX_NONE, e->mask, p - e->mask);
425
426                 /*
427                  * Decode the magic & mask fields.
428                  * Note: while we might have accepted embedded NUL bytes from
429                  * above, the unescape helpers here will stop at the first one
430                  * it encounters.
431                  */
432                 e->size = string_unescape_inplace(e->magic, UNESCAPE_HEX);
433                 if (e->mask &&
434                     string_unescape_inplace(e->mask, UNESCAPE_HEX) != e->size)
435                         goto einval;
436                 if (e->size > BINPRM_BUF_SIZE ||
437                     BINPRM_BUF_SIZE - e->size < e->offset)
438                         goto einval;
439                 pr_debug("register: magic/mask length: %i\n", e->size);
440                 if (USE_DEBUG) {
441                         print_hex_dump_bytes(
442                                 KBUILD_MODNAME ": register: magic[decoded]: ",
443                                 DUMP_PREFIX_NONE, e->magic, e->size);
444
445                         if (e->mask) {
446                                 int i;
447                                 char *masked = kmalloc(e->size, GFP_KERNEL);
448
449                                 print_hex_dump_bytes(
450                                         KBUILD_MODNAME ": register:  mask[decoded]: ",
451                                         DUMP_PREFIX_NONE, e->mask, e->size);
452
453                                 if (masked) {
454                                         for (i = 0; i < e->size; ++i)
455                                                 masked[i] = e->magic[i] & e->mask[i];
456                                         print_hex_dump_bytes(
457                                                 KBUILD_MODNAME ": register:  magic[masked]: ",
458                                                 DUMP_PREFIX_NONE, masked, e->size);
459
460                                         kfree(masked);
461                                 }
462                         }
463                 }
464         } else {
465                 /* Handle the 'E' (extension) format. */
466
467                 /* Skip the 'offset' field. */
468                 p = strchr(p, del);
469                 if (!p)
470                         goto einval;
471                 *p++ = '\0';
472
473                 /* Parse the 'magic' field. */
474                 e->magic = p;
475                 p = strchr(p, del);
476                 if (!p)
477                         goto einval;
478                 *p++ = '\0';
479                 if (!e->magic[0] || strchr(e->magic, '/'))
480                         goto einval;
481                 pr_debug("register: extension: {%s}\n", e->magic);
482
483                 /* Skip the 'mask' field. */
484                 p = strchr(p, del);
485                 if (!p)
486                         goto einval;
487                 *p++ = '\0';
488         }
489
490         /* Parse the 'interpreter' field. */
491         e->interpreter = p;
492         p = strchr(p, del);
493         if (!p)
494                 goto einval;
495         *p++ = '\0';
496         if (!e->interpreter[0])
497                 goto einval;
498         pr_debug("register: interpreter: {%s}\n", e->interpreter);
499
500         /* Parse the 'flags' field. */
501         p = check_special_flags(p, e);
502         if (*p == '\n')
503                 p++;
504         if (p != buf + count)
505                 goto einval;
506
507         return e;
508
509 out:
510         return ERR_PTR(err);
511
512 efault:
513         kfree(e);
514         return ERR_PTR(-EFAULT);
515 einval:
516         kfree(e);
517         return ERR_PTR(-EINVAL);
518 }
519
520 /*
521  * Set status of entry/binfmt_misc:
522  * '1' enables, '0' disables and '-1' clears entry/binfmt_misc
523  */
524 static int parse_command(const char __user *buffer, size_t count)
525 {
526         char s[4];
527
528         if (count > 3)
529                 return -EINVAL;
530         if (copy_from_user(s, buffer, count))
531                 return -EFAULT;
532         if (!count)
533                 return 0;
534         if (s[count - 1] == '\n')
535                 count--;
536         if (count == 1 && s[0] == '0')
537                 return 1;
538         if (count == 1 && s[0] == '1')
539                 return 2;
540         if (count == 2 && s[0] == '-' && s[1] == '1')
541                 return 3;
542         return -EINVAL;
543 }
544
545 /* generic stuff */
546
547 static void entry_status(Node *e, char *page)
548 {
549         char *dp = page;
550         const char *status = "disabled";
551
552         if (test_bit(Enabled, &e->flags))
553                 status = "enabled";
554
555         if (!VERBOSE_STATUS) {
556                 sprintf(page, "%s\n", status);
557                 return;
558         }
559
560         dp += sprintf(dp, "%s\ninterpreter %s\n", status, e->interpreter);
561
562         /* print the special flags */
563         dp += sprintf(dp, "flags: ");
564         if (e->flags & MISC_FMT_PRESERVE_ARGV0)
565                 *dp++ = 'P';
566         if (e->flags & MISC_FMT_OPEN_BINARY)
567                 *dp++ = 'O';
568         if (e->flags & MISC_FMT_CREDENTIALS)
569                 *dp++ = 'C';
570         if (e->flags & MISC_FMT_OPEN_FILE)
571                 *dp++ = 'F';
572         *dp++ = '\n';
573
574         if (!test_bit(Magic, &e->flags)) {
575                 sprintf(dp, "extension .%s\n", e->magic);
576         } else {
577                 dp += sprintf(dp, "offset %i\nmagic ", e->offset);
578                 dp = bin2hex(dp, e->magic, e->size);
579                 if (e->mask) {
580                         dp += sprintf(dp, "\nmask ");
581                         dp = bin2hex(dp, e->mask, e->size);
582                 }
583                 *dp++ = '\n';
584                 *dp = '\0';
585         }
586 }
587
588 static struct inode *bm_get_inode(struct super_block *sb, int mode)
589 {
590         struct inode *inode = new_inode(sb);
591
592         if (inode) {
593                 inode->i_ino = get_next_ino();
594                 inode->i_mode = mode;
595                 inode->i_atime = inode->i_mtime = inode->i_ctime =
596                         current_time(inode);
597         }
598         return inode;
599 }
600
601 static void bm_evict_inode(struct inode *inode)
602 {
603         Node *e = inode->i_private;
604
605         if (e && e->flags & MISC_FMT_OPEN_FILE)
606                 filp_close(e->interp_file, NULL);
607
608         clear_inode(inode);
609         kfree(e);
610 }
611
612 static void kill_node(Node *e)
613 {
614         struct dentry *dentry;
615
616         write_lock(&entries_lock);
617         list_del_init(&e->list);
618         write_unlock(&entries_lock);
619
620         dentry = e->dentry;
621         drop_nlink(d_inode(dentry));
622         d_drop(dentry);
623         dput(dentry);
624         simple_release_fs(&bm_mnt, &entry_count);
625 }
626
627 /* /<entry> */
628
629 static ssize_t
630 bm_entry_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
631 {
632         Node *e = file_inode(file)->i_private;
633         ssize_t res;
634         char *page;
635
636         page = (char *) __get_free_page(GFP_KERNEL);
637         if (!page)
638                 return -ENOMEM;
639
640         entry_status(e, page);
641
642         res = simple_read_from_buffer(buf, nbytes, ppos, page, strlen(page));
643
644         free_page((unsigned long) page);
645         return res;
646 }
647
648 static ssize_t bm_entry_write(struct file *file, const char __user *buffer,
649                                 size_t count, loff_t *ppos)
650 {
651         struct dentry *root;
652         Node *e = file_inode(file)->i_private;
653         int res = parse_command(buffer, count);
654
655         switch (res) {
656         case 1:
657                 /* Disable this handler. */
658                 clear_bit(Enabled, &e->flags);
659                 break;
660         case 2:
661                 /* Enable this handler. */
662                 set_bit(Enabled, &e->flags);
663                 break;
664         case 3:
665                 /* Delete this handler. */
666                 root = file_inode(file)->i_sb->s_root;
667                 inode_lock(d_inode(root));
668
669                 if (!list_empty(&e->list))
670                         kill_node(e);
671
672                 inode_unlock(d_inode(root));
673                 break;
674         default:
675                 return res;
676         }
677
678         return count;
679 }
680
681 static const struct file_operations bm_entry_operations = {
682         .read           = bm_entry_read,
683         .write          = bm_entry_write,
684         .llseek         = default_llseek,
685 };
686
687 /* /register */
688
689 static ssize_t bm_register_write(struct file *file, const char __user *buffer,
690                                size_t count, loff_t *ppos)
691 {
692         Node *e;
693         struct inode *inode;
694         struct super_block *sb = file_inode(file)->i_sb;
695         struct dentry *root = sb->s_root, *dentry;
696         int err = 0;
697
698         e = create_entry(buffer, count);
699
700         if (IS_ERR(e))
701                 return PTR_ERR(e);
702
703         inode_lock(d_inode(root));
704         dentry = lookup_one_len(e->name, root, strlen(e->name));
705         err = PTR_ERR(dentry);
706         if (IS_ERR(dentry))
707                 goto out;
708
709         err = -EEXIST;
710         if (d_really_is_positive(dentry))
711                 goto out2;
712
713         inode = bm_get_inode(sb, S_IFREG | 0644);
714
715         err = -ENOMEM;
716         if (!inode)
717                 goto out2;
718
719         err = simple_pin_fs(&bm_fs_type, &bm_mnt, &entry_count);
720         if (err) {
721                 iput(inode);
722                 inode = NULL;
723                 goto out2;
724         }
725
726         if (e->flags & MISC_FMT_OPEN_FILE) {
727                 struct file *f;
728
729                 f = open_exec(e->interpreter);
730                 if (IS_ERR(f)) {
731                         err = PTR_ERR(f);
732                         pr_notice("register: failed to install interpreter file %s\n", e->interpreter);
733                         simple_release_fs(&bm_mnt, &entry_count);
734                         iput(inode);
735                         inode = NULL;
736                         goto out2;
737                 }
738                 e->interp_file = f;
739         }
740
741         e->dentry = dget(dentry);
742         inode->i_private = e;
743         inode->i_fop = &bm_entry_operations;
744
745         d_instantiate(dentry, inode);
746         write_lock(&entries_lock);
747         list_add(&e->list, &entries);
748         write_unlock(&entries_lock);
749
750         err = 0;
751 out2:
752         dput(dentry);
753 out:
754         inode_unlock(d_inode(root));
755
756         if (err) {
757                 kfree(e);
758                 return err;
759         }
760         return count;
761 }
762
763 static const struct file_operations bm_register_operations = {
764         .write          = bm_register_write,
765         .llseek         = noop_llseek,
766 };
767
768 /* /status */
769
770 static ssize_t
771 bm_status_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
772 {
773         char *s = enabled ? "enabled\n" : "disabled\n";
774
775         return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
776 }
777
778 static ssize_t bm_status_write(struct file *file, const char __user *buffer,
779                 size_t count, loff_t *ppos)
780 {
781         int res = parse_command(buffer, count);
782         struct dentry *root;
783
784         switch (res) {
785         case 1:
786                 /* Disable all handlers. */
787                 enabled = 0;
788                 break;
789         case 2:
790                 /* Enable all handlers. */
791                 enabled = 1;
792                 break;
793         case 3:
794                 /* Delete all handlers. */
795                 root = file_inode(file)->i_sb->s_root;
796                 inode_lock(d_inode(root));
797
798                 while (!list_empty(&entries))
799                         kill_node(list_first_entry(&entries, Node, list));
800
801                 inode_unlock(d_inode(root));
802                 break;
803         default:
804                 return res;
805         }
806
807         return count;
808 }
809
810 static const struct file_operations bm_status_operations = {
811         .read           = bm_status_read,
812         .write          = bm_status_write,
813         .llseek         = default_llseek,
814 };
815
816 /* Superblock handling */
817
818 static const struct super_operations s_ops = {
819         .statfs         = simple_statfs,
820         .evict_inode    = bm_evict_inode,
821 };
822
823 static int bm_fill_super(struct super_block *sb, void *data, int silent)
824 {
825         int err;
826         static const struct tree_descr bm_files[] = {
827                 [2] = {"status", &bm_status_operations, S_IWUSR|S_IRUGO},
828                 [3] = {"register", &bm_register_operations, S_IWUSR},
829                 /* last one */ {""}
830         };
831
832         err = simple_fill_super(sb, BINFMTFS_MAGIC, bm_files);
833         if (!err)
834                 sb->s_op = &s_ops;
835         return err;
836 }
837
838 static struct dentry *bm_mount(struct file_system_type *fs_type,
839         int flags, const char *dev_name, void *data)
840 {
841         return mount_single(fs_type, flags, data, bm_fill_super);
842 }
843
844 static struct linux_binfmt misc_format = {
845         .module = THIS_MODULE,
846         .load_binary = load_misc_binary,
847 };
848
849 static struct file_system_type bm_fs_type = {
850         .owner          = THIS_MODULE,
851         .name           = "binfmt_misc",
852         .mount          = bm_mount,
853         .kill_sb        = kill_litter_super,
854 };
855 MODULE_ALIAS_FS("binfmt_misc");
856
857 static int __init init_misc_binfmt(void)
858 {
859         int err = register_filesystem(&bm_fs_type);
860         if (!err)
861                 insert_binfmt(&misc_format);
862         return err;
863 }
864
865 static void __exit exit_misc_binfmt(void)
866 {
867         unregister_binfmt(&misc_format);
868         unregister_filesystem(&bm_fs_type);
869 }
870
871 core_initcall(init_misc_binfmt);
872 module_exit(exit_misc_binfmt);
873 MODULE_LICENSE("GPL");