2 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
3 * Copyright (C) 2001 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
4 * Licensed under the GPL
7 #include <linux/console.h>
8 #include <linux/ctype.h>
9 #include <linux/string.h>
10 #include <linux/interrupt.h>
11 #include <linux/list.h>
13 #include <linux/module.h>
14 #include <linux/notifier.h>
15 #include <linux/reboot.h>
16 #include <linux/proc_fs.h>
17 #include <linux/slab.h>
18 #include <linux/syscalls.h>
19 #include <linux/utsname.h>
20 #include <linux/socket.h>
22 #include <linux/workqueue.h>
23 #include <linux/mutex.h>
24 #include <asm/uaccess.h>
29 #include "kern_util.h"
31 #include "mconsole_kern.h"
34 static int do_unlink_socket(struct notifier_block
*notifier
,
35 unsigned long what
, void *data
)
37 return mconsole_unlink_socket();
41 static struct notifier_block reboot_notifier
= {
42 .notifier_call
= do_unlink_socket
,
46 /* Safe without explicit locking for now. Tasklets provide their own
47 * locking, and the interrupt handler is safe because it can't interrupt
48 * itself and it can only happen on CPU 0.
51 static LIST_HEAD(mc_requests
);
53 static void mc_work_proc(struct work_struct
*unused
)
55 struct mconsole_entry
*req
;
58 while (!list_empty(&mc_requests
)) {
59 local_irq_save(flags
);
60 req
= list_entry(mc_requests
.next
, struct mconsole_entry
, list
);
62 local_irq_restore(flags
);
63 req
->request
.cmd
->handler(&req
->request
);
68 static DECLARE_WORK(mconsole_work
, mc_work_proc
);
70 static irqreturn_t
mconsole_interrupt(int irq
, void *dev_id
)
72 /* long to avoid size mismatch warnings from gcc */
74 struct mconsole_entry
*new;
75 static struct mc_request req
; /* that's OK */
78 while (mconsole_get_request(fd
, &req
)) {
79 if (req
.cmd
->context
== MCONSOLE_INTR
)
80 (*req
.cmd
->handler
)(&req
);
82 new = kmalloc(sizeof(*new), GFP_NOWAIT
);
84 mconsole_reply(&req
, "Out of memory", 1, 0);
87 new->request
.regs
= get_irq_regs()->regs
;
88 list_add(&new->list
, &mc_requests
);
92 if (!list_empty(&mc_requests
))
93 schedule_work(&mconsole_work
);
94 reactivate_fd(fd
, MCONSOLE_IRQ
);
98 void mconsole_version(struct mc_request
*req
)
102 sprintf(version
, "%s %s %s %s %s", utsname()->sysname
,
103 utsname()->nodename
, utsname()->release
, utsname()->version
,
105 mconsole_reply(req
, version
, 0, 0);
108 void mconsole_log(struct mc_request
*req
)
111 char *ptr
= req
->request
.data
;
113 ptr
+= strlen("log ");
115 len
= req
->len
- (ptr
- req
->request
.data
);
116 printk(KERN_WARNING
"%.*s", len
, ptr
);
117 mconsole_reply(req
, "", 0, 0);
120 /* This is a more convoluted version of mconsole_proc, which has some stability
121 * problems; however, we need it fixed, because it is expected that UML users
122 * mount HPPFS instead of procfs on /proc. And we want mconsole_proc to still
123 * show the real procfs content, not the ones from hppfs.*/
125 void mconsole_proc(struct mc_request
*req
)
128 struct file_system_type
*proc
;
129 struct super_block
*super
;
132 char *ptr
= req
->request
.data
, *buf
;
134 ptr
+= strlen("proc");
135 ptr
= skip_spaces(ptr
);
137 proc
= get_fs_type("proc");
139 mconsole_reply(req
, "procfs not registered", 1, 0);
143 super
= (*proc
->get_sb
)(proc
, 0, NULL
, NULL
);
144 put_filesystem(proc
);
146 mconsole_reply(req
, "Failed to get procfs superblock", 1, 0);
149 up_write(&super
->s_umount
);
151 nd
.path
.dentry
= super
->s_root
;
153 nd
.flags
= O_RDONLY
+ 1;
154 nd
.last_type
= LAST_ROOT
;
156 /* START: it was experienced that the stability problems are closed
157 * if commenting out these two calls + the below read cycle. To
158 * make UML crash again, it was enough to readd either one.*/
159 err
= link_path_walk(ptr
, &nd
);
161 mconsole_reply(req
, "Failed to look up file", 1, 0);
165 file
= dentry_open(nd
.path
.dentry
, nd
.path
.mnt
, O_RDONLY
,
168 mconsole_reply(req
, "Failed to open file", 1, 0);
173 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
175 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
179 if ((file
->f_op
!= NULL
) && (file
->f_op
->read
!= NULL
)) {
181 n
= (*file
->f_op
->read
)(file
, buf
, PAGE_SIZE
- 1,
185 mconsole_reply(req
, buf
, 0, (n
> 0));
188 mconsole_reply(req
, "Read of file failed",
194 else mconsole_reply(req
, "", 0, 0);
201 deactivate_super(super
);
206 void mconsole_proc(struct mc_request
*req
)
213 char *ptr
= req
->request
.data
;
215 ptr
+= strlen("proc");
216 ptr
= skip_spaces(ptr
);
217 snprintf(path
, sizeof(path
), "/proc/%s", ptr
);
219 fd
= sys_open(path
, 0, 0);
221 mconsole_reply(req
, "Failed to open file", 1, 0);
222 printk(KERN_ERR
"open %s: %d\n",path
,fd
);
226 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
228 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
233 len
= sys_read(fd
, buf
, PAGE_SIZE
-1);
235 mconsole_reply(req
, "Read of file failed", 1, 0);
238 /* Begin the file content on his own line. */
240 mconsole_reply(req
, "\n", 0, 1);
243 if (len
== PAGE_SIZE
-1) {
245 mconsole_reply(req
, buf
, 0, 1);
248 mconsole_reply(req
, buf
, 0, 0);
261 #define UML_MCONSOLE_HELPTEXT \
263 version - Get kernel version \n\
264 help - Print this message \n\
266 reboot - Reboot UML \n\
267 config <dev>=<config> - Add a new device to UML; \n\
268 same syntax as command line \n\
269 config <dev> - Query the configuration of a device \n\
270 remove <dev> - Remove a device from UML \n\
271 sysrq <letter> - Performs the SysRq action controlled by the letter \n\
272 cad - invoke the Ctrl-Alt-Del handler \n\
273 stop - pause the UML; it will do nothing until it receives a 'go' \n\
274 go - continue the UML after a 'stop' \n\
275 log <string> - make UML enter <string> into the kernel log\n\
276 proc <file> - returns the contents of the UML's /proc/<file>\n\
277 stack <pid> - returns the stack of the specified pid\n\
280 void mconsole_help(struct mc_request
*req
)
282 mconsole_reply(req
, UML_MCONSOLE_HELPTEXT
, 0, 0);
285 void mconsole_halt(struct mc_request
*req
)
287 mconsole_reply(req
, "", 0, 0);
291 void mconsole_reboot(struct mc_request
*req
)
293 mconsole_reply(req
, "", 0, 0);
294 machine_restart(NULL
);
297 void mconsole_cad(struct mc_request
*req
)
299 mconsole_reply(req
, "", 0, 0);
303 void mconsole_go(struct mc_request
*req
)
305 mconsole_reply(req
, "Not stopped", 1, 0);
308 void mconsole_stop(struct mc_request
*req
)
310 deactivate_fd(req
->originating_fd
, MCONSOLE_IRQ
);
311 os_set_fd_block(req
->originating_fd
, 1);
312 mconsole_reply(req
, "stopped", 0, 0);
314 if (!mconsole_get_request(req
->originating_fd
, req
))
316 if (req
->cmd
->handler
== mconsole_go
)
318 if (req
->cmd
->handler
== mconsole_stop
) {
319 mconsole_reply(req
, "Already stopped", 1, 0);
322 if (req
->cmd
->handler
== mconsole_sysrq
) {
323 struct pt_regs
*old_regs
;
324 old_regs
= set_irq_regs((struct pt_regs
*)&req
->regs
);
326 set_irq_regs(old_regs
);
329 (*req
->cmd
->handler
)(req
);
331 os_set_fd_block(req
->originating_fd
, 0);
332 reactivate_fd(req
->originating_fd
, MCONSOLE_IRQ
);
333 mconsole_reply(req
, "", 0, 0);
336 static DEFINE_SPINLOCK(mc_devices_lock
);
337 static LIST_HEAD(mconsole_devices
);
339 void mconsole_register_dev(struct mc_device
*new)
341 spin_lock(&mc_devices_lock
);
342 BUG_ON(!list_empty(&new->list
));
343 list_add(&new->list
, &mconsole_devices
);
344 spin_unlock(&mc_devices_lock
);
347 static struct mc_device
*mconsole_find_dev(char *name
)
349 struct list_head
*ele
;
350 struct mc_device
*dev
;
352 list_for_each(ele
, &mconsole_devices
) {
353 dev
= list_entry(ele
, struct mc_device
, list
);
354 if (!strncmp(name
, dev
->name
, strlen(dev
->name
)))
360 #define UNPLUGGED_PER_PAGE \
361 ((PAGE_SIZE - sizeof(struct list_head)) / sizeof(unsigned long))
363 struct unplugged_pages
{
364 struct list_head list
;
365 void *pages
[UNPLUGGED_PER_PAGE
];
368 static DEFINE_MUTEX(plug_mem_mutex
);
369 static unsigned long long unplugged_pages_count
= 0;
370 static LIST_HEAD(unplugged_pages
);
371 static int unplug_index
= UNPLUGGED_PER_PAGE
;
373 static int mem_config(char *str
, char **error_out
)
375 unsigned long long diff
;
376 int err
= -EINVAL
, i
, add
;
380 *error_out
= "Expected '=' after 'mem'";
387 else if (str
[0] == '+') {
391 *error_out
= "Expected increment to start with '-' or '+'";
396 diff
= memparse(str
, &ret
);
398 *error_out
= "Failed to parse memory increment";
404 mutex_lock(&plug_mem_mutex
);
405 for (i
= 0; i
< diff
; i
++) {
406 struct unplugged_pages
*unplugged
;
410 if (list_empty(&unplugged_pages
))
413 unplugged
= list_entry(unplugged_pages
.next
,
414 struct unplugged_pages
, list
);
415 if (unplug_index
> 0)
416 addr
= unplugged
->pages
[--unplug_index
];
418 list_del(&unplugged
->list
);
420 unplug_index
= UNPLUGGED_PER_PAGE
;
423 free_page((unsigned long) addr
);
424 unplugged_pages_count
--;
429 page
= alloc_page(GFP_ATOMIC
);
433 unplugged
= page_address(page
);
434 if (unplug_index
== UNPLUGGED_PER_PAGE
) {
435 list_add(&unplugged
->list
, &unplugged_pages
);
439 struct list_head
*entry
= unplugged_pages
.next
;
442 unplugged
= list_entry(entry
,
443 struct unplugged_pages
,
445 err
= os_drop_memory(addr
, PAGE_SIZE
);
447 printk(KERN_ERR
"Failed to release "
448 "memory - errno = %d\n", err
);
449 *error_out
= "Failed to release memory";
452 unplugged
->pages
[unplug_index
++] = addr
;
455 unplugged_pages_count
++;
461 mutex_unlock(&plug_mem_mutex
);
466 static int mem_get_config(char *name
, char *str
, int size
, char **error_out
)
468 char buf
[sizeof("18446744073709551615")];
471 sprintf(buf
, "%ld", uml_physmem
);
472 CONFIG_CHUNK(str
, size
, len
, buf
, 1);
477 static int mem_id(char **str
, int *start_out
, int *end_out
)
485 static int mem_remove(int n
, char **error_out
)
487 *error_out
= "Memory doesn't support the remove operation";
491 static struct mc_device mem_mc
= {
492 .list
= LIST_HEAD_INIT(mem_mc
.list
),
494 .config
= mem_config
,
495 .get_config
= mem_get_config
,
497 .remove
= mem_remove
,
500 static int __init
mem_mc_init(void)
502 if (can_drop_memory())
503 mconsole_register_dev(&mem_mc
);
504 else printk(KERN_ERR
"Can't release memory to the host - memory "
505 "hotplug won't be supported\n");
509 __initcall(mem_mc_init
);
511 #define CONFIG_BUF_SIZE 64
513 static void mconsole_get_config(int (*get_config
)(char *, char *, int,
515 struct mc_request
*req
, char *name
)
517 char default_buf
[CONFIG_BUF_SIZE
], *error
, *buf
;
520 if (get_config
== NULL
) {
521 mconsole_reply(req
, "No get_config routine defined", 1, 0);
526 size
= ARRAY_SIZE(default_buf
);
530 n
= (*get_config
)(name
, buf
, size
, &error
);
532 mconsole_reply(req
, error
, 1, 0);
537 mconsole_reply(req
, buf
, 0, 0);
541 if (buf
!= default_buf
)
545 buf
= kmalloc(size
, GFP_KERNEL
);
547 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
552 if (buf
!= default_buf
)
556 void mconsole_config(struct mc_request
*req
)
558 struct mc_device
*dev
;
559 char *ptr
= req
->request
.data
, *name
, *error_string
= "";
562 ptr
+= strlen("config");
563 ptr
= skip_spaces(ptr
);
564 dev
= mconsole_find_dev(ptr
);
566 mconsole_reply(req
, "Bad configuration option", 1, 0);
570 name
= &ptr
[strlen(dev
->name
)];
572 while ((*ptr
!= '=') && (*ptr
!= '\0'))
576 err
= (*dev
->config
)(name
, &error_string
);
577 mconsole_reply(req
, error_string
, err
, 0);
579 else mconsole_get_config(dev
->get_config
, req
, name
);
582 void mconsole_remove(struct mc_request
*req
)
584 struct mc_device
*dev
;
585 char *ptr
= req
->request
.data
, *err_msg
= "";
587 int err
, start
, end
, n
;
589 ptr
+= strlen("remove");
590 ptr
= skip_spaces(ptr
);
591 dev
= mconsole_find_dev(ptr
);
593 mconsole_reply(req
, "Bad remove option", 1, 0);
597 ptr
= &ptr
[strlen(dev
->name
)];
600 n
= (*dev
->id
)(&ptr
, &start
, &end
);
602 err_msg
= "Couldn't parse device number";
605 else if ((n
< start
) || (n
> end
)) {
606 sprintf(error
, "Invalid device number - must be between "
607 "%d and %d", start
, end
);
613 err
= (*dev
->remove
)(n
, &err_msg
);
620 err_msg
= "Device doesn't exist";
624 err_msg
= "Device is currently open";
630 mconsole_reply(req
, err_msg
, err
, 0);
633 struct mconsole_output
{
634 struct list_head list
;
635 struct mc_request
*req
;
638 static DEFINE_SPINLOCK(client_lock
);
639 static LIST_HEAD(clients
);
640 static char console_buf
[MCONSOLE_MAX_DATA
];
642 static void console_write(struct console
*console
, const char *string
,
645 struct list_head
*ele
;
648 if (list_empty(&clients
))
652 n
= min((size_t) len
, ARRAY_SIZE(console_buf
));
653 strncpy(console_buf
, string
, n
);
657 list_for_each(ele
, &clients
) {
658 struct mconsole_output
*entry
;
660 entry
= list_entry(ele
, struct mconsole_output
, list
);
661 mconsole_reply_len(entry
->req
, console_buf
, n
, 0, 1);
666 static struct console mc_console
= { .name
= "mc",
667 .write
= console_write
,
668 .flags
= CON_ENABLED
,
671 static int mc_add_console(void)
673 register_console(&mc_console
);
677 late_initcall(mc_add_console
);
679 static void with_console(struct mc_request
*req
, void (*proc
)(void *),
682 struct mconsole_output entry
;
686 spin_lock_irqsave(&client_lock
, flags
);
687 list_add(&entry
.list
, &clients
);
688 spin_unlock_irqrestore(&client_lock
, flags
);
692 mconsole_reply_len(req
, "", 0, 0, 0);
694 spin_lock_irqsave(&client_lock
, flags
);
695 list_del(&entry
.list
);
696 spin_unlock_irqrestore(&client_lock
, flags
);
699 #ifdef CONFIG_MAGIC_SYSRQ
701 #include <linux/sysrq.h>
703 static void sysrq_proc(void *arg
)
706 handle_sysrq(*op
, NULL
);
709 void mconsole_sysrq(struct mc_request
*req
)
711 char *ptr
= req
->request
.data
;
713 ptr
+= strlen("sysrq");
714 ptr
= skip_spaces(ptr
);
717 * With 'b', the system will shut down without a chance to reply,
718 * so in this case, we reply first.
721 mconsole_reply(req
, "", 0, 0);
723 with_console(req
, sysrq_proc
, ptr
);
726 void mconsole_sysrq(struct mc_request
*req
)
728 mconsole_reply(req
, "Sysrq not compiled in", 1, 0);
732 static void stack_proc(void *arg
)
734 struct task_struct
*from
= current
, *to
= arg
;
736 to
->thread
.saved_task
= from
;
737 switch_to(from
, to
, from
);
741 * Mconsole stack trace
742 * Added by Allan Graves, Jeff Dike
743 * Dumps a stacks registers to the linux console.
746 void mconsole_stack(struct mc_request
*req
)
748 char *ptr
= req
->request
.data
;
749 int pid_requested
= -1;
750 struct task_struct
*to
= NULL
;
754 * 1) Send showregs output to mconsole.
755 * 2) Add a way to stack dump all pids.
758 ptr
+= strlen("stack");
759 ptr
= skip_spaces(ptr
);
762 * Should really check for multiple pids or reject bad args here
764 /* What do the arguments in mconsole_reply mean? */
765 if (sscanf(ptr
, "%d", &pid_requested
) == 0) {
766 mconsole_reply(req
, "Please specify a pid", 1, 0);
770 to
= find_task_by_pid_ns(pid_requested
, &init_pid_ns
);
771 if ((to
== NULL
) || (pid_requested
== 0)) {
772 mconsole_reply(req
, "Couldn't find that pid", 1, 0);
775 with_console(req
, stack_proc
, to
);
779 * Changed by mconsole_setup, which is __setup, and called before SMP is
782 static char *notify_socket
= NULL
;
784 static int __init
mconsole_init(void)
786 /* long to avoid size mismatch warnings from gcc */
789 char file
[UNIX_PATH_MAX
];
791 if (umid_file_name("mconsole", file
, sizeof(file
)))
793 snprintf(mconsole_socket_name
, sizeof(file
), "%s", file
);
795 sock
= os_create_unix_socket(file
, sizeof(file
), 1);
797 printk(KERN_ERR
"Failed to initialize management console\n");
800 if (os_set_fd_block(sock
, 0))
803 register_reboot_notifier(&reboot_notifier
);
805 err
= um_request_irq(MCONSOLE_IRQ
, sock
, IRQ_READ
, mconsole_interrupt
,
806 IRQF_DISABLED
| IRQF_SHARED
| IRQF_SAMPLE_RANDOM
,
807 "mconsole", (void *)sock
);
809 printk(KERN_ERR
"Failed to get IRQ for management console\n");
813 if (notify_socket
!= NULL
) {
814 notify_socket
= kstrdup(notify_socket
, GFP_KERNEL
);
815 if (notify_socket
!= NULL
)
816 mconsole_notify(notify_socket
, MCONSOLE_SOCKET
,
817 mconsole_socket_name
,
818 strlen(mconsole_socket_name
) + 1);
819 else printk(KERN_ERR
"mconsole_setup failed to strdup "
823 printk(KERN_INFO
"mconsole (version %d) initialized on %s\n",
824 MCONSOLE_VERSION
, mconsole_socket_name
);
832 __initcall(mconsole_init
);
834 static ssize_t
mconsole_proc_write(struct file
*file
,
835 const char __user
*buffer
, size_t count
, loff_t
*pos
)
839 buf
= kmalloc(count
+ 1, GFP_KERNEL
);
843 if (copy_from_user(buf
, buffer
, count
)) {
850 mconsole_notify(notify_socket
, MCONSOLE_USER_NOTIFY
, buf
, count
);
856 static const struct file_operations mconsole_proc_fops
= {
857 .owner
= THIS_MODULE
,
858 .write
= mconsole_proc_write
,
861 static int create_proc_mconsole(void)
863 struct proc_dir_entry
*ent
;
865 if (notify_socket
== NULL
)
868 ent
= proc_create("mconsole", 0200, NULL
, &mconsole_proc_fops
);
870 printk(KERN_INFO
"create_proc_mconsole : create_proc_entry "
877 static DEFINE_SPINLOCK(notify_spinlock
);
879 void lock_notify(void)
881 spin_lock(¬ify_spinlock
);
884 void unlock_notify(void)
886 spin_unlock(¬ify_spinlock
);
889 __initcall(create_proc_mconsole
);
891 #define NOTIFY "notify:"
893 static int mconsole_setup(char *str
)
895 if (!strncmp(str
, NOTIFY
, strlen(NOTIFY
))) {
896 str
+= strlen(NOTIFY
);
899 else printk(KERN_ERR
"mconsole_setup : Unknown option - '%s'\n", str
);
903 __setup("mconsole=", mconsole_setup
);
905 __uml_help(mconsole_setup
,
906 "mconsole=notify:<socket>\n"
907 " Requests that the mconsole driver send a message to the named Unix\n"
908 " socket containing the name of the mconsole socket. This also serves\n"
909 " to notify outside processes when UML has booted far enough to respond\n"
910 " to mconsole requests.\n\n"
913 static int notify_panic(struct notifier_block
*self
, unsigned long unused1
,
918 if (notify_socket
== NULL
)
921 mconsole_notify(notify_socket
, MCONSOLE_PANIC
, message
,
922 strlen(message
) + 1);
926 static struct notifier_block panic_exit_notifier
= {
927 .notifier_call
= notify_panic
,
932 static int add_notifier(void)
934 atomic_notifier_chain_register(&panic_notifier_list
,
935 &panic_exit_notifier
);
939 __initcall(add_notifier
);
941 char *mconsole_notify_socket(void)
943 return notify_socket
;
946 EXPORT_SYMBOL(mconsole_notify_socket
);