4 * Copyright (C) 1997 Richard Günther
6 * binfmt_misc detects binaries via a magic or filename extension and invokes
7 * a specified wrapper. This should obsolete binfmt_java, binfmt_em86 and
10 * 1997-04-25 first version
13 * 1997-06-26 hpa: pass the real filename rather than argv[0]
14 * 1997-06-30 minor cleanup
15 * 1997-08-09 removed extension stripping, locking cleanup
16 * 2001-02-28 AV: rewritten into something that resembles C. Original didn't.
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/sched.h>
22 #include <linux/magic.h>
23 #include <linux/binfmts.h>
24 #include <linux/slab.h>
25 #include <linux/ctype.h>
26 #include <linux/file.h>
27 #include <linux/pagemap.h>
28 #include <linux/namei.h>
29 #include <linux/mount.h>
30 #include <linux/syscalls.h>
33 #include <asm/uaccess.h>
36 VERBOSE_STATUS
= 1 /* make it zero to save 400 bytes kernel memory */
39 static LIST_HEAD(entries
);
40 static int enabled
= 1;
42 enum {Enabled
, Magic
};
43 #define MISC_FMT_PRESERVE_ARGV0 (1<<31)
44 #define MISC_FMT_OPEN_BINARY (1<<30)
45 #define MISC_FMT_CREDENTIALS (1<<29)
48 struct list_head list
;
49 unsigned long flags
; /* type, status, etc. */
50 int offset
; /* offset of magic */
51 int size
; /* size of magic/mask */
52 char *magic
; /* magic or filename extension */
53 char *mask
; /* mask, NULL for exact match */
54 char *interpreter
; /* filename of interpreter */
56 struct dentry
*dentry
;
59 static DEFINE_RWLOCK(entries_lock
);
60 static struct file_system_type bm_fs_type
;
61 static struct vfsmount
*bm_mnt
;
62 static int entry_count
;
65 * Check if we support the binfmt
66 * if we do, return the node, else NULL
67 * locking is done in load_misc_binary
69 static Node
*check_file(struct linux_binprm
*bprm
)
71 char *p
= strrchr(bprm
->interp
, '.');
74 list_for_each(l
, &entries
) {
75 Node
*e
= list_entry(l
, Node
, list
);
79 if (!test_bit(Enabled
, &e
->flags
))
82 if (!test_bit(Magic
, &e
->flags
)) {
83 if (p
&& !strcmp(e
->magic
, p
+ 1))
88 s
= bprm
->buf
+ e
->offset
;
90 for (j
= 0; j
< e
->size
; j
++)
91 if ((*s
++ ^ e
->magic
[j
]) & e
->mask
[j
])
94 for (j
= 0; j
< e
->size
; j
++)
95 if ((*s
++ ^ e
->magic
[j
]))
107 static int load_misc_binary(struct linux_binprm
*bprm
)
110 struct file
* interp_file
= NULL
;
111 char iname
[BINPRM_BUF_SIZE
];
112 const char *iname_addr
= iname
;
120 /* to keep locking time low, we copy the interpreter string */
121 read_lock(&entries_lock
);
122 fmt
= check_file(bprm
);
124 strlcpy(iname
, fmt
->interpreter
, BINPRM_BUF_SIZE
);
125 read_unlock(&entries_lock
);
129 if (!(fmt
->flags
& MISC_FMT_PRESERVE_ARGV0
)) {
130 retval
= remove_arg_zero(bprm
);
135 if (fmt
->flags
& MISC_FMT_OPEN_BINARY
) {
137 /* if the binary should be opened on behalf of the
138 * interpreter than keep it open and assign descriptor
140 fd_binary
= get_unused_fd();
145 fd_install(fd_binary
, bprm
->file
);
147 /* if the binary is not readable than enforce mm->dumpable=0
148 regardless of the interpreter's permissions */
149 would_dump(bprm
, bprm
->file
);
151 allow_write_access(bprm
->file
);
154 /* mark the bprm that fd should be passed to interp */
155 bprm
->interp_flags
|= BINPRM_FLAGS_EXECFD
;
156 bprm
->interp_data
= fd_binary
;
159 allow_write_access(bprm
->file
);
163 /* make argv[1] be the path to the binary */
164 retval
= copy_strings_kernel (1, &bprm
->interp
, bprm
);
169 /* add the interp as argv[0] */
170 retval
= copy_strings_kernel (1, &iname_addr
, bprm
);
175 bprm
->interp
= iname
; /* for binfmt_script */
177 interp_file
= open_exec (iname
);
178 retval
= PTR_ERR (interp_file
);
179 if (IS_ERR (interp_file
))
182 bprm
->file
= interp_file
;
183 if (fmt
->flags
& MISC_FMT_CREDENTIALS
) {
185 * No need to call prepare_binprm(), it's already been
186 * done. bprm->buf is stale, update from interp_file.
188 memset(bprm
->buf
, 0, BINPRM_BUF_SIZE
);
189 retval
= kernel_read(bprm
->file
, 0, bprm
->buf
, BINPRM_BUF_SIZE
);
191 retval
= prepare_binprm (bprm
);
196 retval
= search_binary_handler(bprm
);
204 sys_close(fd_binary
);
205 bprm
->interp_flags
= 0;
206 bprm
->interp_data
= 0;
210 /* Command parsers */
213 * parses and copies one argument enclosed in del from *sp to *dp,
214 * recognising the \x special.
215 * returns pointer to the copied argument or NULL in case of an
216 * error (and sets err) or null argument length.
218 static char *scanarg(char *s
, char del
)
222 while ((c
= *s
++) != del
) {
223 if (c
== '\\' && *s
== 'x') {
234 static int unquote(char *from
)
236 char c
= 0, *s
= from
, *p
= from
;
238 while ((c
= *s
++) != '\0') {
239 if (c
== '\\' && *s
== 'x') {
242 *p
= (c
- (isdigit(c
) ? '0' : 'A' - 10)) << 4;
244 *p
++ |= c
- (isdigit(c
) ? '0' : 'A' - 10);
252 static char * check_special_flags (char * sfs
, Node
* e
)
262 e
->flags
|= MISC_FMT_PRESERVE_ARGV0
;
266 e
->flags
|= MISC_FMT_OPEN_BINARY
;
270 /* this flags also implies the
272 e
->flags
|= (MISC_FMT_CREDENTIALS
|
273 MISC_FMT_OPEN_BINARY
);
283 * This registers a new binary format, it recognises the syntax
284 * ':name:type:offset:magic:mask:interpreter:flags'
285 * where the ':' is the IFS, that can be chosen with the first char
287 static Node
*create_entry(const char __user
*buffer
, size_t count
)
294 /* some sanity checks */
296 if ((count
< 11) || (count
> 256))
300 memsize
= sizeof(Node
) + count
+ 8;
301 e
= kmalloc(memsize
, GFP_USER
);
305 p
= buf
= (char *)e
+ sizeof(Node
);
307 memset(e
, 0, sizeof(Node
));
308 if (copy_from_user(buf
, buffer
, count
))
311 del
= *p
++; /* delimeter */
313 memset(buf
+count
, del
, 8);
321 !strcmp(e
->name
, ".") ||
322 !strcmp(e
->name
, "..") ||
323 strchr(e
->name
, '/'))
326 case 'E': e
->flags
= 1<<Enabled
; break;
327 case 'M': e
->flags
= (1<<Enabled
) | (1<<Magic
); break;
328 default: goto Einval
;
332 if (test_bit(Magic
, &e
->flags
)) {
333 char *s
= strchr(p
, del
);
337 e
->offset
= simple_strtoul(p
, &p
, 10);
354 e
->size
= unquote(e
->magic
);
355 if (e
->mask
&& unquote(e
->mask
) != e
->size
)
357 if (e
->size
+ e
->offset
> BINPRM_BUF_SIZE
)
369 if (!e
->magic
[0] || strchr(e
->magic
, '/'))
381 if (!e
->interpreter
[0])
385 p
= check_special_flags (p
, e
);
389 if (p
!= buf
+ count
)
398 return ERR_PTR(-EFAULT
);
401 return ERR_PTR(-EINVAL
);
405 * Set status of entry/binfmt_misc:
406 * '1' enables, '0' disables and '-1' clears entry/binfmt_misc
408 static int parse_command(const char __user
*buffer
, size_t count
)
416 if (copy_from_user(s
, buffer
, count
))
418 if (s
[count
-1] == '\n')
420 if (count
== 1 && s
[0] == '0')
422 if (count
== 1 && s
[0] == '1')
424 if (count
== 2 && s
[0] == '-' && s
[1] == '1')
431 static void entry_status(Node
*e
, char *page
)
434 char *status
= "disabled";
435 const char * flags
= "flags: ";
437 if (test_bit(Enabled
, &e
->flags
))
440 if (!VERBOSE_STATUS
) {
441 sprintf(page
, "%s\n", status
);
445 sprintf(page
, "%s\ninterpreter %s\n", status
, e
->interpreter
);
446 dp
= page
+ strlen(page
);
448 /* print the special flags */
449 sprintf (dp
, "%s", flags
);
450 dp
+= strlen (flags
);
451 if (e
->flags
& MISC_FMT_PRESERVE_ARGV0
) {
454 if (e
->flags
& MISC_FMT_OPEN_BINARY
) {
457 if (e
->flags
& MISC_FMT_CREDENTIALS
) {
463 if (!test_bit(Magic
, &e
->flags
)) {
464 sprintf(dp
, "extension .%s\n", e
->magic
);
468 sprintf(dp
, "offset %i\nmagic ", e
->offset
);
469 dp
= page
+ strlen(page
);
470 for (i
= 0; i
< e
->size
; i
++) {
471 sprintf(dp
, "%02x", 0xff & (int) (e
->magic
[i
]));
475 sprintf(dp
, "\nmask ");
477 for (i
= 0; i
< e
->size
; i
++) {
478 sprintf(dp
, "%02x", 0xff & (int) (e
->mask
[i
]));
487 static struct inode
*bm_get_inode(struct super_block
*sb
, int mode
)
489 struct inode
* inode
= new_inode(sb
);
492 inode
->i_ino
= get_next_ino();
493 inode
->i_mode
= mode
;
494 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
=
495 current_fs_time(inode
->i_sb
);
500 static void bm_evict_inode(struct inode
*inode
)
503 kfree(inode
->i_private
);
506 static void kill_node(Node
*e
)
508 struct dentry
*dentry
;
510 write_lock(&entries_lock
);
513 list_del_init(&e
->list
);
516 write_unlock(&entries_lock
);
519 drop_nlink(dentry
->d_inode
);
522 simple_release_fs(&bm_mnt
, &entry_count
);
529 bm_entry_read(struct file
* file
, char __user
* buf
, size_t nbytes
, loff_t
*ppos
)
531 Node
*e
= file
->f_path
.dentry
->d_inode
->i_private
;
535 if (!(page
= (char*) __get_free_page(GFP_KERNEL
)))
538 entry_status(e
, page
);
540 res
= simple_read_from_buffer(buf
, nbytes
, ppos
, page
, strlen(page
));
542 free_page((unsigned long) page
);
546 static ssize_t
bm_entry_write(struct file
*file
, const char __user
*buffer
,
547 size_t count
, loff_t
*ppos
)
550 Node
*e
= file
->f_path
.dentry
->d_inode
->i_private
;
551 int res
= parse_command(buffer
, count
);
554 case 1: clear_bit(Enabled
, &e
->flags
);
556 case 2: set_bit(Enabled
, &e
->flags
);
558 case 3: root
= dget(file
->f_path
.dentry
->d_sb
->s_root
);
559 mutex_lock(&root
->d_inode
->i_mutex
);
563 mutex_unlock(&root
->d_inode
->i_mutex
);
571 static const struct file_operations bm_entry_operations
= {
572 .read
= bm_entry_read
,
573 .write
= bm_entry_write
,
574 .llseek
= default_llseek
,
579 static ssize_t
bm_register_write(struct file
*file
, const char __user
*buffer
,
580 size_t count
, loff_t
*ppos
)
584 struct dentry
*root
, *dentry
;
585 struct super_block
*sb
= file
->f_path
.dentry
->d_sb
;
588 e
= create_entry(buffer
, count
);
593 root
= dget(sb
->s_root
);
594 mutex_lock(&root
->d_inode
->i_mutex
);
595 dentry
= lookup_one_len(e
->name
, root
, strlen(e
->name
));
596 err
= PTR_ERR(dentry
);
604 inode
= bm_get_inode(sb
, S_IFREG
| 0644);
610 err
= simple_pin_fs(&bm_fs_type
, &bm_mnt
, &entry_count
);
617 e
->dentry
= dget(dentry
);
618 inode
->i_private
= e
;
619 inode
->i_fop
= &bm_entry_operations
;
621 d_instantiate(dentry
, inode
);
622 write_lock(&entries_lock
);
623 list_add(&e
->list
, &entries
);
624 write_unlock(&entries_lock
);
630 mutex_unlock(&root
->d_inode
->i_mutex
);
640 static const struct file_operations bm_register_operations
= {
641 .write
= bm_register_write
,
642 .llseek
= noop_llseek
,
648 bm_status_read(struct file
*file
, char __user
*buf
, size_t nbytes
, loff_t
*ppos
)
650 char *s
= enabled
? "enabled\n" : "disabled\n";
652 return simple_read_from_buffer(buf
, nbytes
, ppos
, s
, strlen(s
));
655 static ssize_t
bm_status_write(struct file
* file
, const char __user
* buffer
,
656 size_t count
, loff_t
*ppos
)
658 int res
= parse_command(buffer
, count
);
662 case 1: enabled
= 0; break;
663 case 2: enabled
= 1; break;
664 case 3: root
= dget(file
->f_path
.dentry
->d_sb
->s_root
);
665 mutex_lock(&root
->d_inode
->i_mutex
);
667 while (!list_empty(&entries
))
668 kill_node(list_entry(entries
.next
, Node
, list
));
670 mutex_unlock(&root
->d_inode
->i_mutex
);
677 static const struct file_operations bm_status_operations
= {
678 .read
= bm_status_read
,
679 .write
= bm_status_write
,
680 .llseek
= default_llseek
,
683 /* Superblock handling */
685 static const struct super_operations s_ops
= {
686 .statfs
= simple_statfs
,
687 .evict_inode
= bm_evict_inode
,
690 static int bm_fill_super(struct super_block
* sb
, void * data
, int silent
)
692 static struct tree_descr bm_files
[] = {
693 [2] = {"status", &bm_status_operations
, S_IWUSR
|S_IRUGO
},
694 [3] = {"register", &bm_register_operations
, S_IWUSR
},
697 int err
= simple_fill_super(sb
, BINFMTFS_MAGIC
, bm_files
);
703 static struct dentry
*bm_mount(struct file_system_type
*fs_type
,
704 int flags
, const char *dev_name
, void *data
)
706 return mount_single(fs_type
, flags
, data
, bm_fill_super
);
709 static struct linux_binfmt misc_format
= {
710 .module
= THIS_MODULE
,
711 .load_binary
= load_misc_binary
,
714 static struct file_system_type bm_fs_type
= {
715 .owner
= THIS_MODULE
,
716 .name
= "binfmt_misc",
718 .kill_sb
= kill_litter_super
,
721 static int __init
init_misc_binfmt(void)
723 int err
= register_filesystem(&bm_fs_type
);
725 insert_binfmt(&misc_format
);
729 static void __exit
exit_misc_binfmt(void)
731 unregister_binfmt(&misc_format
);
732 unregister_filesystem(&bm_fs_type
);
735 core_initcall(init_misc_binfmt
);
736 module_exit(exit_misc_binfmt
);
737 MODULE_LICENSE("GPL");