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"
24 #include "asm/uaccess.h"
25 #include "user_util.h"
26 #include "kern_util.h"
29 #include "mconsole_kern.h"
35 #include "choose-mode.h"
37 static int do_unlink_socket(struct notifier_block
*notifier
,
38 unsigned long what
, void *data
)
40 return(mconsole_unlink_socket());
44 static struct notifier_block reboot_notifier
= {
45 .notifier_call
= do_unlink_socket
,
49 /* Safe without explicit locking for now. Tasklets provide their own
50 * locking, and the interrupt handler is safe because it can't interrupt
51 * itself and it can only happen on CPU 0.
54 LIST_HEAD(mc_requests
);
56 static void mc_work_proc(void *unused
)
58 struct mconsole_entry
*req
;
61 while(!list_empty(&mc_requests
)){
62 local_save_flags(flags
);
63 req
= list_entry(mc_requests
.next
, struct mconsole_entry
,
66 local_irq_restore(flags
);
67 req
->request
.cmd
->handler(&req
->request
);
72 DECLARE_WORK(mconsole_work
, mc_work_proc
, NULL
);
74 static irqreturn_t
mconsole_interrupt(int irq
, void *dev_id
,
77 /* long to avoid size mismatch warnings from gcc */
79 struct mconsole_entry
*new;
80 struct mc_request req
;
83 while (mconsole_get_request(fd
, &req
)){
84 if(req
.cmd
->context
== MCONSOLE_INTR
)
85 (*req
.cmd
->handler
)(&req
);
87 new = kmalloc(sizeof(*new), GFP_ATOMIC
);
89 mconsole_reply(&req
, "Out of memory", 1, 0);
92 list_add(&new->list
, &mc_requests
);
96 if(!list_empty(&mc_requests
))
97 schedule_work(&mconsole_work
);
98 reactivate_fd(fd
, MCONSOLE_IRQ
);
102 void mconsole_version(struct mc_request
*req
)
106 sprintf(version
, "%s %s %s %s %s", system_utsname
.sysname
,
107 system_utsname
.nodename
, system_utsname
.release
,
108 system_utsname
.version
, system_utsname
.machine
);
109 mconsole_reply(req
, version
, 0, 0);
112 void mconsole_log(struct mc_request
*req
)
115 char *ptr
= req
->request
.data
;
117 ptr
+= strlen("log ");
119 len
= req
->len
- (ptr
- req
->request
.data
);
120 printk("%.*s", len
, ptr
);
121 mconsole_reply(req
, "", 0, 0);
124 /* This is a more convoluted version of mconsole_proc, which has some stability
125 * problems; however, we need it fixed, because it is expected that UML users
126 * mount HPPFS instead of procfs on /proc. And we want mconsole_proc to still
127 * show the real procfs content, not the ones from hppfs.*/
129 void mconsole_proc(struct mc_request
*req
)
132 struct file_system_type
*proc
;
133 struct super_block
*super
;
136 char *ptr
= req
->request
.data
, *buf
;
138 ptr
+= strlen("proc");
139 while(isspace(*ptr
)) ptr
++;
141 proc
= get_fs_type("proc");
143 mconsole_reply(req
, "procfs not registered", 1, 0);
147 super
= (*proc
->get_sb
)(proc
, 0, NULL
, NULL
);
148 put_filesystem(proc
);
150 mconsole_reply(req
, "Failed to get procfs superblock", 1, 0);
153 up_write(&super
->s_umount
);
155 nd
.dentry
= super
->s_root
;
157 nd
.flags
= O_RDONLY
+ 1;
158 nd
.last_type
= LAST_ROOT
;
160 /* START: it was experienced that the stability problems are closed
161 * if commenting out these two calls + the below read cycle. To
162 * make UML crash again, it was enough to readd either one.*/
163 err
= link_path_walk(ptr
, &nd
);
165 mconsole_reply(req
, "Failed to look up file", 1, 0);
169 file
= dentry_open(nd
.dentry
, nd
.mnt
, O_RDONLY
);
171 mconsole_reply(req
, "Failed to open file", 1, 0);
176 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
178 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
182 if((file
->f_op
!= NULL
) && (file
->f_op
->read
!= NULL
)){
184 n
= (*file
->f_op
->read
)(file
, buf
, PAGE_SIZE
- 1,
188 mconsole_reply(req
, buf
, 0, (n
> 0));
191 mconsole_reply(req
, "Read of file failed",
197 else mconsole_reply(req
, "", 0, 0);
204 deactivate_super(super
);
209 void mconsole_proc(struct mc_request
*req
)
216 char *ptr
= req
->request
.data
;
218 ptr
+= strlen("proc");
219 while(isspace(*ptr
)) ptr
++;
220 snprintf(path
, sizeof(path
), "/proc/%s", ptr
);
222 fd
= sys_open(path
, 0, 0);
224 mconsole_reply(req
, "Failed to open file", 1, 0);
225 printk("open %s: %d\n",path
,fd
);
229 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
231 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
236 len
= sys_read(fd
, buf
, PAGE_SIZE
-1);
238 mconsole_reply(req
, "Read of file failed", 1, 0);
241 /*Begin the file content on his own line.*/
243 mconsole_reply(req
, "\n", 0, 1);
246 if (len
== PAGE_SIZE
-1) {
248 mconsole_reply(req
, buf
, 0, 1);
251 mconsole_reply(req
, buf
, 0, 0);
264 #define UML_MCONSOLE_HELPTEXT \
266 version - Get kernel version \n\
267 help - Print this message \n\
269 reboot - Reboot UML \n\
270 config <dev>=<config> - Add a new device to UML; \n\
271 same syntax as command line \n\
272 config <dev> - Query the configuration of a device \n\
273 remove <dev> - Remove a device from UML \n\
274 sysrq <letter> - Performs the SysRq action controlled by the letter \n\
275 cad - invoke the Ctl-Alt-Del handler \n\
276 stop - pause the UML; it will do nothing until it receives a 'go' \n\
277 go - continue the UML after a 'stop' \n\
278 log <string> - make UML enter <string> into the kernel log\n\
279 proc <file> - returns the contents of the UML's /proc/<file>\n\
280 stack <pid> - returns the stack of the specified pid\n\
283 void mconsole_help(struct mc_request
*req
)
285 mconsole_reply(req
, UML_MCONSOLE_HELPTEXT
, 0, 0);
288 void mconsole_halt(struct mc_request
*req
)
290 mconsole_reply(req
, "", 0, 0);
294 void mconsole_reboot(struct mc_request
*req
)
296 mconsole_reply(req
, "", 0, 0);
297 machine_restart(NULL
);
300 extern void ctrl_alt_del(void);
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 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 CONFIG_BUF_SIZE 64
351 static void mconsole_get_config(int (*get_config
)(char *, char *, int,
353 struct mc_request
*req
, char *name
)
355 char default_buf
[CONFIG_BUF_SIZE
], *error
, *buf
;
358 if(get_config
== NULL
){
359 mconsole_reply(req
, "No get_config routine defined", 1, 0);
364 size
= sizeof(default_buf
)/sizeof(default_buf
[0]);
368 n
= (*get_config
)(name
, buf
, size
, &error
);
370 mconsole_reply(req
, error
, 1, 0);
375 mconsole_reply(req
, buf
, 0, 0);
379 if(buf
!= default_buf
)
383 buf
= kmalloc(size
, GFP_KERNEL
);
385 mconsole_reply(req
, "Failed to allocate buffer", 1, 0);
390 if(buf
!= default_buf
)
395 void mconsole_config(struct mc_request
*req
)
397 struct mc_device
*dev
;
398 char *ptr
= req
->request
.data
, *name
;
401 ptr
+= strlen("config");
402 while(isspace(*ptr
)) ptr
++;
403 dev
= mconsole_find_dev(ptr
);
405 mconsole_reply(req
, "Bad configuration option", 1, 0);
409 name
= &ptr
[strlen(dev
->name
)];
411 while((*ptr
!= '=') && (*ptr
!= '\0'))
415 err
= (*dev
->config
)(name
);
416 mconsole_reply(req
, "", err
, 0);
418 else mconsole_get_config(dev
->get_config
, req
, name
);
421 void mconsole_remove(struct mc_request
*req
)
423 struct mc_device
*dev
;
424 char *ptr
= req
->request
.data
, *err_msg
= "";
426 int err
, start
, end
, n
;
428 ptr
+= strlen("remove");
429 while(isspace(*ptr
)) ptr
++;
430 dev
= mconsole_find_dev(ptr
);
432 mconsole_reply(req
, "Bad remove option", 1, 0);
436 ptr
= &ptr
[strlen(dev
->name
)];
439 n
= (*dev
->id
)(&ptr
, &start
, &end
);
441 err_msg
= "Couldn't parse device number";
444 else if((n
< start
) || (n
> end
)){
445 sprintf(error
, "Invalid device number - must be between "
446 "%d and %d", start
, end
);
451 err
= (*dev
->remove
)(n
);
454 err_msg
= "Device doesn't exist";
457 err_msg
= "Device is currently open";
463 mconsole_reply(req
, err_msg
, err
, 0);
466 #ifdef CONFIG_MAGIC_SYSRQ
467 void mconsole_sysrq(struct mc_request
*req
)
469 char *ptr
= req
->request
.data
;
471 ptr
+= strlen("sysrq");
472 while(isspace(*ptr
)) ptr
++;
474 mconsole_reply(req
, "", 0, 0);
475 handle_sysrq(*ptr
, ¤t
->thread
.regs
, NULL
);
478 void mconsole_sysrq(struct mc_request
*req
)
480 mconsole_reply(req
, "Sysrq not compiled in", 1, 0);
484 /* Mconsole stack trace
485 * Added by Allan Graves, Jeff Dike
486 * Dumps a stacks registers to the linux console.
489 void do_stack(struct mc_request
*req
)
491 char *ptr
= req
->request
.data
;
492 int pid_requested
= -1;
493 struct task_struct
*from
= NULL
;
494 struct task_struct
*to
= NULL
;
497 * 1) Send showregs output to mconsole.
498 * 2) Add a way to stack dump all pids.
501 ptr
+= strlen("stack");
502 while(isspace(*ptr
)) ptr
++;
504 /* Should really check for multiple pids or reject bad args here */
505 /* What do the arguments in mconsole_reply mean? */
506 if(sscanf(ptr
, "%d", &pid_requested
) == 0){
507 mconsole_reply(req
, "Please specify a pid", 1, 0);
512 to
= find_task_by_pid(pid_requested
);
514 if((to
== NULL
) || (pid_requested
== 0)) {
515 mconsole_reply(req
, "Couldn't find that pid", 1, 0);
518 to
->thread
.saved_task
= current
;
520 switch_to(from
, to
, from
);
521 mconsole_reply(req
, "Stack Dumped to console and message log", 0, 0);
524 void mconsole_stack(struct mc_request
*req
)
526 /* This command doesn't work in TT mode, so let's check and then
529 CHOOSE_MODE(mconsole_reply(req
, "Sorry, this doesn't work in TT mode",
534 /* Changed by mconsole_setup, which is __setup, and called before SMP is
537 static char *notify_socket
= NULL
;
539 int mconsole_init(void)
541 /* long to avoid size mismatch warnings from gcc */
546 if(umid_file_name("mconsole", file
, sizeof(file
))) return(-1);
547 snprintf(mconsole_socket_name
, sizeof(file
), "%s", file
);
549 sock
= os_create_unix_socket(file
, sizeof(file
), 1);
551 printk("Failed to initialize management console\n");
555 register_reboot_notifier(&reboot_notifier
);
557 err
= um_request_irq(MCONSOLE_IRQ
, sock
, IRQ_READ
, mconsole_interrupt
,
558 SA_INTERRUPT
| SA_SHIRQ
| SA_SAMPLE_RANDOM
,
559 "mconsole", (void *)sock
);
561 printk("Failed to get IRQ for management console\n");
565 if(notify_socket
!= NULL
){
566 notify_socket
= uml_strdup(notify_socket
);
567 if(notify_socket
!= NULL
)
568 mconsole_notify(notify_socket
, MCONSOLE_SOCKET
,
569 mconsole_socket_name
,
570 strlen(mconsole_socket_name
) + 1);
571 else printk(KERN_ERR
"mconsole_setup failed to strdup "
575 printk("mconsole (version %d) initialized on %s\n",
576 MCONSOLE_VERSION
, mconsole_socket_name
);
580 __initcall(mconsole_init
);
582 static int write_proc_mconsole(struct file
*file
, const char __user
*buffer
,
583 unsigned long count
, void *data
)
587 buf
= kmalloc(count
+ 1, GFP_KERNEL
);
591 if(copy_from_user(buf
, buffer
, count
)){
598 mconsole_notify(notify_socket
, MCONSOLE_USER_NOTIFY
, buf
, count
);
604 static int create_proc_mconsole(void)
606 struct proc_dir_entry
*ent
;
608 if(notify_socket
== NULL
) return(0);
610 ent
= create_proc_entry("mconsole", S_IFREG
| 0200, NULL
);
612 printk(KERN_INFO
"create_proc_mconsole : create_proc_entry failed\n");
616 ent
->read_proc
= NULL
;
617 ent
->write_proc
= write_proc_mconsole
;
621 static DEFINE_SPINLOCK(notify_spinlock
);
623 void lock_notify(void)
625 spin_lock(¬ify_spinlock
);
628 void unlock_notify(void)
630 spin_unlock(¬ify_spinlock
);
633 __initcall(create_proc_mconsole
);
635 #define NOTIFY "=notify:"
637 static int mconsole_setup(char *str
)
639 if(!strncmp(str
, NOTIFY
, strlen(NOTIFY
))){
640 str
+= strlen(NOTIFY
);
643 else printk(KERN_ERR
"mconsole_setup : Unknown option - '%s'\n", str
);
647 __setup("mconsole", mconsole_setup
);
649 __uml_help(mconsole_setup
,
650 "mconsole=notify:<socket>\n"
651 " Requests that the mconsole driver send a message to the named Unix\n"
652 " socket containing the name of the mconsole socket. This also serves\n"
653 " to notify outside processes when UML has booted far enough to respond\n"
654 " to mconsole requests.\n\n"
657 static int notify_panic(struct notifier_block
*self
, unsigned long unused1
,
662 if(notify_socket
== NULL
) return(0);
664 mconsole_notify(notify_socket
, MCONSOLE_PANIC
, message
,
665 strlen(message
) + 1);
669 static struct notifier_block panic_exit_notifier
= {
670 .notifier_call
= notify_panic
,
675 static int add_notifier(void)
677 notifier_chain_register(&panic_notifier_list
, &panic_exit_notifier
);
681 __initcall(add_notifier
);
683 char *mconsole_notify_socket(void)
685 return(notify_socket
);
688 EXPORT_SYMBOL(mconsole_notify_socket
);
691 * Overrides for Emacs so that we follow Linus's tabbing style.
692 * Emacs will notice this stuff at the end of the file and automatically
693 * adjust the settings for this buffer only. This must remain at the end
695 * ---------------------------------------------------------------------------
697 * c-file-style: "linux"