2 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
3 * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
4 * Licensed under the GPL
7 #include "linux/kernel.h"
8 #include "linux/slab.h"
9 #include "linux/init.h"
10 #include "linux/notifier.h"
11 #include "linux/reboot.h"
12 #include "linux/utsname.h"
13 #include "linux/ctype.h"
14 #include "linux/interrupt.h"
15 #include "linux/sysrq.h"
16 #include "linux/workqueue.h"
17 #include "linux/module.h"
18 #include "linux/file.h"
20 #include "linux/namei.h"
21 #include "linux/proc_fs.h"
22 #include "linux/syscalls.h"
23 #include "linux/list.h"
25 #include "linux/console.h"
27 #include "asm/uaccess.h"
28 #include "user_util.h"
29 #include "kern_util.h"
32 #include "mconsole_kern.h"
38 #include "choose-mode.h"
40 static int do_unlink_socket(struct notifier_block
*notifier
,
41 unsigned long what
, void *data
)
43 return(mconsole_unlink_socket());
47 static struct notifier_block reboot_notifier
= {
48 .notifier_call
= do_unlink_socket
,
52 /* Safe without explicit locking for now. Tasklets provide their own
53 * locking, and the interrupt handler is safe because it can't interrupt
54 * itself and it can only happen on CPU 0.
57 static LIST_HEAD(mc_requests
);
59 static void mc_work_proc(void *unused
)
61 struct mconsole_entry
*req
;
64 while(!list_empty(&mc_requests
)){
65 local_irq_save(flags
);
66 req
= list_entry(mc_requests
.next
, struct mconsole_entry
,
69 local_irq_restore(flags
);
70 req
->request
.cmd
->handler(&req
->request
);
75 static DECLARE_WORK(mconsole_work
, mc_work_proc
, NULL
);
77 static irqreturn_t
mconsole_interrupt(int irq
, void *dev_id
)
79 /* long to avoid size mismatch warnings from gcc */
81 struct mconsole_entry
*new;
82 struct mc_request req
;
85 while (mconsole_get_request(fd
, &req
)){
86 if(req
.cmd
->context
== MCONSOLE_INTR
)
87 (*req
.cmd
->handler
)(&req
);
89 new = kmalloc(sizeof(*new), GFP_NOWAIT
);
91 mconsole_reply(&req
, "Out of memory", 1, 0);
94 list_add(&new->list
, &mc_requests
);
98 if(!list_empty(&mc_requests
))
99 schedule_work(&mconsole_work
);
100 reactivate_fd(fd
, MCONSOLE_IRQ
);
104 void mconsole_version(struct mc_request
*req
)
108 sprintf(version
, "%s %s %s %s %s", utsname()->sysname
,
109 utsname()->nodename
, utsname()->release
,
110 utsname()->version
, utsname()->machine
);
111 mconsole_reply(req
, version
, 0, 0);
114 void mconsole_log(struct mc_request
*req
)
117 char *ptr
= req
->request
.data
;
119 ptr
+= strlen("log ");
121 len
= req
->len
- (ptr
- req
->request
.data
);
122 printk("%.*s", len
, ptr
);
123 mconsole_reply(req
, "", 0, 0);
126 /* This is a more convoluted version of mconsole_proc, which has some stability
127 * problems; however, we need it fixed, because it is expected that UML users
128 * mount HPPFS instead of procfs on /proc. And we want mconsole_proc to still
129 * show the real procfs content, not the ones from hppfs.*/
131 void mconsole_proc(struct mc_request
*req
)
134 struct file_system_type
*proc
;
135 struct super_block
*super
;
138 char *ptr
= req
->request
.data
, *buf
;
140 ptr
+= strlen("proc");
141 while(isspace(*ptr
)) ptr
++;
143 proc
= get_fs_type("proc");
145 mconsole_reply(req
, "procfs not registered", 1, 0);
149 super
= (*proc
->get_sb
)(proc
, 0, NULL
, NULL
);
150 put_filesystem(proc
);
152 mconsole_reply(req
, "Failed to get procfs superblock", 1, 0);
155 up_write(&super
->s_umount
);
157 nd
.dentry
= super
->s_root
;
159 nd
.flags
= O_RDONLY
+ 1;
160 nd
.last_type
= LAST_ROOT
;
162 /* START: it was experienced that the stability problems are closed
163 * if commenting out these two calls + the below read cycle. To
164 * make UML crash again, it was enough to readd either one.*/
165 err
= link_path_walk(ptr
, &nd
);
167 mconsole_reply(req
, "Failed to look up file", 1, 0);
171 file
= dentry_open(nd
.dentry
, nd
.mnt
, O_RDONLY
);
173 mconsole_reply(req
, "Failed to open file", 1, 0);
178 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
180 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
184 if((file
->f_op
!= NULL
) && (file
->f_op
->read
!= NULL
)){
186 n
= (*file
->f_op
->read
)(file
, buf
, PAGE_SIZE
- 1,
190 mconsole_reply(req
, buf
, 0, (n
> 0));
193 mconsole_reply(req
, "Read of file failed",
199 else mconsole_reply(req
, "", 0, 0);
206 deactivate_super(super
);
211 void mconsole_proc(struct mc_request
*req
)
218 char *ptr
= req
->request
.data
;
220 ptr
+= strlen("proc");
221 while(isspace(*ptr
)) ptr
++;
222 snprintf(path
, sizeof(path
), "/proc/%s", ptr
);
224 fd
= sys_open(path
, 0, 0);
226 mconsole_reply(req
, "Failed to open file", 1, 0);
227 printk("open %s: %d\n",path
,fd
);
231 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
233 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
238 len
= sys_read(fd
, buf
, PAGE_SIZE
-1);
240 mconsole_reply(req
, "Read of file failed", 1, 0);
243 /*Begin the file content on his own line.*/
245 mconsole_reply(req
, "\n", 0, 1);
248 if (len
== PAGE_SIZE
-1) {
250 mconsole_reply(req
, buf
, 0, 1);
253 mconsole_reply(req
, buf
, 0, 0);
266 #define UML_MCONSOLE_HELPTEXT \
268 version - Get kernel version \n\
269 help - Print this message \n\
271 reboot - Reboot UML \n\
272 config <dev>=<config> - Add a new device to UML; \n\
273 same syntax as command line \n\
274 config <dev> - Query the configuration of a device \n\
275 remove <dev> - Remove a device from UML \n\
276 sysrq <letter> - Performs the SysRq action controlled by the letter \n\
277 cad - invoke the Ctrl-Alt-Del handler \n\
278 stop - pause the UML; it will do nothing until it receives a 'go' \n\
279 go - continue the UML after a 'stop' \n\
280 log <string> - make UML enter <string> into the kernel log\n\
281 proc <file> - returns the contents of the UML's /proc/<file>\n\
282 stack <pid> - returns the stack of the specified pid\n\
285 void mconsole_help(struct mc_request
*req
)
287 mconsole_reply(req
, UML_MCONSOLE_HELPTEXT
, 0, 0);
290 void mconsole_halt(struct mc_request
*req
)
292 mconsole_reply(req
, "", 0, 0);
296 void mconsole_reboot(struct mc_request
*req
)
298 mconsole_reply(req
, "", 0, 0);
299 machine_restart(NULL
);
302 void mconsole_cad(struct mc_request
*req
)
304 mconsole_reply(req
, "", 0, 0);
308 void mconsole_go(struct mc_request
*req
)
310 mconsole_reply(req
, "Not stopped", 1, 0);
313 void mconsole_stop(struct mc_request
*req
)
315 deactivate_fd(req
->originating_fd
, MCONSOLE_IRQ
);
316 os_set_fd_block(req
->originating_fd
, 1);
317 mconsole_reply(req
, "", 0, 0);
318 while(mconsole_get_request(req
->originating_fd
, req
)){
319 if(req
->cmd
->handler
== mconsole_go
) break;
320 (*req
->cmd
->handler
)(req
);
322 os_set_fd_block(req
->originating_fd
, 0);
323 reactivate_fd(req
->originating_fd
, MCONSOLE_IRQ
);
324 mconsole_reply(req
, "", 0, 0);
327 /* This list is populated by __initcall routines. */
329 static LIST_HEAD(mconsole_devices
);
331 void mconsole_register_dev(struct mc_device
*new)
333 list_add(&new->list
, &mconsole_devices
);
336 static struct mc_device
*mconsole_find_dev(char *name
)
338 struct list_head
*ele
;
339 struct mc_device
*dev
;
341 list_for_each(ele
, &mconsole_devices
){
342 dev
= list_entry(ele
, struct mc_device
, list
);
343 if(!strncmp(name
, dev
->name
, strlen(dev
->name
)))
349 #define UNPLUGGED_PER_PAGE \
350 ((PAGE_SIZE - sizeof(struct list_head)) / sizeof(unsigned long))
352 struct unplugged_pages
{
353 struct list_head list
;
354 void *pages
[UNPLUGGED_PER_PAGE
];
357 static unsigned long long unplugged_pages_count
= 0;
358 static struct list_head unplugged_pages
= LIST_HEAD_INIT(unplugged_pages
);
359 static int unplug_index
= UNPLUGGED_PER_PAGE
;
361 static int mem_config(char *str
)
363 unsigned long long diff
;
364 int err
= -EINVAL
, i
, add
;
373 else if(str
[0] == '+'){
379 diff
= memparse(str
, &ret
);
385 for(i
= 0; i
< diff
; i
++){
386 struct unplugged_pages
*unplugged
;
390 if(list_empty(&unplugged_pages
))
393 unplugged
= list_entry(unplugged_pages
.next
,
394 struct unplugged_pages
, list
);
396 addr
= unplugged
->pages
[--unplug_index
];
398 list_del(&unplugged
->list
);
400 unplug_index
= UNPLUGGED_PER_PAGE
;
403 free_page((unsigned long) addr
);
404 unplugged_pages_count
--;
409 page
= alloc_page(GFP_ATOMIC
);
413 unplugged
= page_address(page
);
414 if(unplug_index
== UNPLUGGED_PER_PAGE
){
415 list_add(&unplugged
->list
, &unplugged_pages
);
419 struct list_head
*entry
= unplugged_pages
.next
;
422 unplugged
= list_entry(entry
,
423 struct unplugged_pages
,
425 unplugged
->pages
[unplug_index
++] = addr
;
426 err
= os_drop_memory(addr
, PAGE_SIZE
);
428 printk("Failed to release memory - "
429 "errno = %d\n", err
);
432 unplugged_pages_count
++;
441 static int mem_get_config(char *name
, char *str
, int size
, char **error_out
)
443 char buf
[sizeof("18446744073709551615")];
446 sprintf(buf
, "%ld", uml_physmem
);
447 CONFIG_CHUNK(str
, size
, len
, buf
, 1);
452 static int mem_id(char **str
, int *start_out
, int *end_out
)
460 static int mem_remove(int n
)
465 static struct mc_device mem_mc
= {
467 .config
= mem_config
,
468 .get_config
= mem_get_config
,
470 .remove
= mem_remove
,
473 static int mem_mc_init(void)
475 if(can_drop_memory())
476 mconsole_register_dev(&mem_mc
);
477 else printk("Can't release memory to the host - memory hotplug won't "
482 __initcall(mem_mc_init
);
484 #define CONFIG_BUF_SIZE 64
486 static void mconsole_get_config(int (*get_config
)(char *, char *, int,
488 struct mc_request
*req
, char *name
)
490 char default_buf
[CONFIG_BUF_SIZE
], *error
, *buf
;
493 if(get_config
== NULL
){
494 mconsole_reply(req
, "No get_config routine defined", 1, 0);
499 size
= ARRAY_SIZE(default_buf
);
503 n
= (*get_config
)(name
, buf
, size
, &error
);
505 mconsole_reply(req
, error
, 1, 0);
510 mconsole_reply(req
, buf
, 0, 0);
514 if(buf
!= default_buf
)
518 buf
= kmalloc(size
, GFP_KERNEL
);
520 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
525 if(buf
!= default_buf
)
529 void mconsole_config(struct mc_request
*req
)
531 struct mc_device
*dev
;
532 char *ptr
= req
->request
.data
, *name
;
535 ptr
+= strlen("config");
536 while(isspace(*ptr
)) ptr
++;
537 dev
= mconsole_find_dev(ptr
);
539 mconsole_reply(req
, "Bad configuration option", 1, 0);
543 name
= &ptr
[strlen(dev
->name
)];
545 while((*ptr
!= '=') && (*ptr
!= '\0'))
549 err
= (*dev
->config
)(name
);
550 mconsole_reply(req
, "", err
, 0);
552 else mconsole_get_config(dev
->get_config
, req
, name
);
555 void mconsole_remove(struct mc_request
*req
)
557 struct mc_device
*dev
;
558 char *ptr
= req
->request
.data
, *err_msg
= "";
560 int err
, start
, end
, n
;
562 ptr
+= strlen("remove");
563 while(isspace(*ptr
)) ptr
++;
564 dev
= mconsole_find_dev(ptr
);
566 mconsole_reply(req
, "Bad remove option", 1, 0);
570 ptr
= &ptr
[strlen(dev
->name
)];
573 n
= (*dev
->id
)(&ptr
, &start
, &end
);
575 err_msg
= "Couldn't parse device number";
578 else if((n
< start
) || (n
> end
)){
579 sprintf(error
, "Invalid device number - must be between "
580 "%d and %d", start
, end
);
585 err
= (*dev
->remove
)(n
);
588 err_msg
= "Device doesn't exist";
591 err_msg
= "Device is currently open";
597 mconsole_reply(req
, err_msg
, err
, 0);
600 struct mconsole_output
{
601 struct list_head list
;
602 struct mc_request
*req
;
605 static DEFINE_SPINLOCK(console_lock
);
606 static LIST_HEAD(clients
);
607 static char console_buf
[MCONSOLE_MAX_DATA
];
608 static int console_index
= 0;
610 static void console_write(struct console
*console
, const char *string
,
613 struct list_head
*ele
;
616 if(list_empty(&clients
))
620 n
= min((size_t) len
, ARRAY_SIZE(console_buf
) - console_index
);
621 strncpy(&console_buf
[console_index
], string
, n
);
628 list_for_each(ele
, &clients
){
629 struct mconsole_output
*entry
;
631 entry
= list_entry(ele
, struct mconsole_output
, list
);
632 mconsole_reply_len(entry
->req
, console_buf
,
633 console_index
, 0, 1);
640 static struct console mc_console
= { .name
= "mc",
641 .write
= console_write
,
642 .flags
= CON_ENABLED
,
645 static int mc_add_console(void)
647 register_console(&mc_console
);
651 late_initcall(mc_add_console
);
653 static void with_console(struct mc_request
*req
, void (*proc
)(void *),
656 struct mconsole_output entry
;
660 list_add(&entry
.list
, &clients
);
661 spin_lock_irqsave(&console_lock
, flags
);
665 mconsole_reply_len(req
, console_buf
, console_index
, 0, 0);
668 spin_unlock_irqrestore(&console_lock
, flags
);
669 list_del(&entry
.list
);
672 #ifdef CONFIG_MAGIC_SYSRQ
673 static void sysrq_proc(void *arg
)
676 struct pt_regs
*old_regs
= set_irq_regs(¤t
->thread
.regs
);
677 handle_sysrq(*op
, NULL
);
678 set_irq_regs(old_regs
);
681 void mconsole_sysrq(struct mc_request
*req
)
683 char *ptr
= req
->request
.data
;
685 ptr
+= strlen("sysrq");
686 while(isspace(*ptr
)) ptr
++;
688 /* With 'b', the system will shut down without a chance to reply,
689 * so in this case, we reply first.
692 mconsole_reply(req
, "", 0, 0);
694 with_console(req
, sysrq_proc
, ptr
);
697 void mconsole_sysrq(struct mc_request
*req
)
699 mconsole_reply(req
, "Sysrq not compiled in", 1, 0);
703 #ifdef CONFIG_MODE_SKAS
705 static void stack_proc(void *arg
)
707 struct task_struct
*from
= current
, *to
= arg
;
709 to
->thread
.saved_task
= from
;
710 switch_to(from
, to
, from
);
713 /* Mconsole stack trace
714 * Added by Allan Graves, Jeff Dike
715 * Dumps a stacks registers to the linux console.
718 static void do_stack_trace(struct mc_request
*req
)
720 char *ptr
= req
->request
.data
;
721 int pid_requested
= -1;
722 struct task_struct
*from
= NULL
;
723 struct task_struct
*to
= NULL
;
726 * 1) Send showregs output to mconsole.
727 * 2) Add a way to stack dump all pids.
730 ptr
+= strlen("stack");
731 while(isspace(*ptr
)) ptr
++;
733 /* Should really check for multiple pids or reject bad args here */
734 /* What do the arguments in mconsole_reply mean? */
735 if(sscanf(ptr
, "%d", &pid_requested
) == 0){
736 mconsole_reply(req
, "Please specify a pid", 1, 0);
742 to
= find_task_by_pid(pid_requested
);
743 if((to
== NULL
) || (pid_requested
== 0)) {
744 mconsole_reply(req
, "Couldn't find that pid", 1, 0);
747 with_console(req
, stack_proc
, to
);
749 #endif /* CONFIG_MODE_SKAS */
751 void mconsole_stack(struct mc_request
*req
)
753 /* This command doesn't work in TT mode, so let's check and then
756 CHOOSE_MODE(mconsole_reply(req
, "Sorry, this doesn't work in TT mode",
758 do_stack_trace(req
));
761 /* Changed by mconsole_setup, which is __setup, and called before SMP is
764 static char *notify_socket
= NULL
;
766 static int mconsole_init(void)
768 /* long to avoid size mismatch warnings from gcc */
773 if(umid_file_name("mconsole", file
, sizeof(file
))) return(-1);
774 snprintf(mconsole_socket_name
, sizeof(file
), "%s", file
);
776 sock
= os_create_unix_socket(file
, sizeof(file
), 1);
778 printk("Failed to initialize management console\n");
782 register_reboot_notifier(&reboot_notifier
);
784 err
= um_request_irq(MCONSOLE_IRQ
, sock
, IRQ_READ
, mconsole_interrupt
,
785 IRQF_DISABLED
| IRQF_SHARED
| IRQF_SAMPLE_RANDOM
,
786 "mconsole", (void *)sock
);
788 printk("Failed to get IRQ for management console\n");
792 if(notify_socket
!= NULL
){
793 notify_socket
= kstrdup(notify_socket
, GFP_KERNEL
);
794 if(notify_socket
!= NULL
)
795 mconsole_notify(notify_socket
, MCONSOLE_SOCKET
,
796 mconsole_socket_name
,
797 strlen(mconsole_socket_name
) + 1);
798 else printk(KERN_ERR
"mconsole_setup failed to strdup "
802 printk("mconsole (version %d) initialized on %s\n",
803 MCONSOLE_VERSION
, mconsole_socket_name
);
807 __initcall(mconsole_init
);
809 static int write_proc_mconsole(struct file
*file
, const char __user
*buffer
,
810 unsigned long count
, void *data
)
814 buf
= kmalloc(count
+ 1, GFP_KERNEL
);
818 if(copy_from_user(buf
, buffer
, count
)){
825 mconsole_notify(notify_socket
, MCONSOLE_USER_NOTIFY
, buf
, count
);
831 static int create_proc_mconsole(void)
833 struct proc_dir_entry
*ent
;
835 if(notify_socket
== NULL
) return(0);
837 ent
= create_proc_entry("mconsole", S_IFREG
| 0200, NULL
);
839 printk(KERN_INFO
"create_proc_mconsole : create_proc_entry failed\n");
843 ent
->read_proc
= NULL
;
844 ent
->write_proc
= write_proc_mconsole
;
848 static DEFINE_SPINLOCK(notify_spinlock
);
850 void lock_notify(void)
852 spin_lock(¬ify_spinlock
);
855 void unlock_notify(void)
857 spin_unlock(¬ify_spinlock
);
860 __initcall(create_proc_mconsole
);
862 #define NOTIFY "=notify:"
864 static int mconsole_setup(char *str
)
866 if(!strncmp(str
, NOTIFY
, strlen(NOTIFY
))){
867 str
+= strlen(NOTIFY
);
870 else printk(KERN_ERR
"mconsole_setup : Unknown option - '%s'\n", str
);
874 __setup("mconsole", mconsole_setup
);
876 __uml_help(mconsole_setup
,
877 "mconsole=notify:<socket>\n"
878 " Requests that the mconsole driver send a message to the named Unix\n"
879 " socket containing the name of the mconsole socket. This also serves\n"
880 " to notify outside processes when UML has booted far enough to respond\n"
881 " to mconsole requests.\n\n"
884 static int notify_panic(struct notifier_block
*self
, unsigned long unused1
,
889 if(notify_socket
== NULL
) return(0);
891 mconsole_notify(notify_socket
, MCONSOLE_PANIC
, message
,
892 strlen(message
) + 1);
896 static struct notifier_block panic_exit_notifier
= {
897 .notifier_call
= notify_panic
,
902 static int add_notifier(void)
904 atomic_notifier_chain_register(&panic_notifier_list
,
905 &panic_exit_notifier
);
909 __initcall(add_notifier
);
911 char *mconsole_notify_socket(void)
913 return(notify_socket
);
916 EXPORT_SYMBOL(mconsole_notify_socket
);