Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
4 * Copyright (C) 2001 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
5 */
6
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>
12#include <linux/mm.h>
13#include <linux/module.h>
14#include <linux/notifier.h>
15#include <linux/panic_notifier.h>
16#include <linux/reboot.h>
17#include <linux/sched/debug.h>
18#include <linux/proc_fs.h>
19#include <linux/slab.h>
20#include <linux/syscalls.h>
21#include <linux/utsname.h>
22#include <linux/socket.h>
23#include <linux/un.h>
24#include <linux/workqueue.h>
25#include <linux/mutex.h>
26#include <linux/fs.h>
27#include <linux/mount.h>
28#include <linux/file.h>
29#include <linux/uaccess.h>
30#include <asm/switch_to.h>
31
32#include <init.h>
33#include <irq_kern.h>
34#include <irq_user.h>
35#include <kern_util.h>
36#include "mconsole.h"
37#include "mconsole_kern.h"
38#include <os.h>
39
40static struct vfsmount *proc_mnt = NULL;
41
42static int do_unlink_socket(struct notifier_block *notifier,
43 unsigned long what, void *data)
44{
45 return mconsole_unlink_socket();
46}
47
48
49static struct notifier_block reboot_notifier = {
50 .notifier_call = do_unlink_socket,
51 .priority = 0,
52};
53
54/* Safe without explicit locking for now. Tasklets provide their own
55 * locking, and the interrupt handler is safe because it can't interrupt
56 * itself and it can only happen on CPU 0.
57 */
58
59static LIST_HEAD(mc_requests);
60
61static void mc_work_proc(struct work_struct *unused)
62{
63 struct mconsole_entry *req;
64 unsigned long flags;
65
66 while (!list_empty(&mc_requests)) {
67 local_irq_save(flags);
68 req = list_entry(mc_requests.next, struct mconsole_entry, list);
69 list_del(&req->list);
70 local_irq_restore(flags);
71 req->request.cmd->handler(&req->request);
72 kfree(req);
73 }
74}
75
76static DECLARE_WORK(mconsole_work, mc_work_proc);
77
78static irqreturn_t mconsole_interrupt(int irq, void *dev_id)
79{
80 /* long to avoid size mismatch warnings from gcc */
81 long fd;
82 struct mconsole_entry *new;
83 static struct mc_request req; /* that's OK */
84
85 fd = (long) dev_id;
86 while (mconsole_get_request(fd, &req)) {
87 if (req.cmd->context == MCONSOLE_INTR)
88 (*req.cmd->handler)(&req);
89 else {
90 new = kmalloc(sizeof(*new), GFP_NOWAIT);
91 if (new == NULL)
92 mconsole_reply(&req, "Out of memory", 1, 0);
93 else {
94 new->request = req;
95 new->request.regs = get_irq_regs()->regs;
96 list_add(&new->list, &mc_requests);
97 }
98 }
99 }
100 if (!list_empty(&mc_requests))
101 schedule_work(&mconsole_work);
102 return IRQ_HANDLED;
103}
104
105void mconsole_version(struct mc_request *req)
106{
107 char version[256];
108
109 sprintf(version, "%s %s %s %s %s", utsname()->sysname,
110 utsname()->nodename, utsname()->release, utsname()->version,
111 utsname()->machine);
112 mconsole_reply(req, version, 0, 0);
113}
114
115void mconsole_log(struct mc_request *req)
116{
117 int len;
118 char *ptr = req->request.data;
119
120 ptr += strlen("log ");
121
122 len = req->len - (ptr - req->request.data);
123 printk(KERN_WARNING "%.*s", len, ptr);
124 mconsole_reply(req, "", 0, 0);
125}
126
127void mconsole_proc(struct mc_request *req)
128{
129 struct vfsmount *mnt = proc_mnt;
130 char *buf;
131 int len;
132 struct file *file;
133 int first_chunk = 1;
134 char *ptr = req->request.data;
135 loff_t pos = 0;
136
137 ptr += strlen("proc");
138 ptr = skip_spaces(ptr);
139
140 if (!mnt) {
141 mconsole_reply(req, "Proc not available", 1, 0);
142 goto out;
143 }
144 file = file_open_root_mnt(mnt, ptr, O_RDONLY, 0);
145 if (IS_ERR(file)) {
146 mconsole_reply(req, "Failed to open file", 1, 0);
147 printk(KERN_ERR "open /proc/%s: %ld\n", ptr, PTR_ERR(file));
148 goto out;
149 }
150
151 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
152 if (buf == NULL) {
153 mconsole_reply(req, "Failed to allocate buffer", 1, 0);
154 goto out_fput;
155 }
156
157 do {
158 len = kernel_read(file, buf, PAGE_SIZE - 1, &pos);
159 if (len < 0) {
160 mconsole_reply(req, "Read of file failed", 1, 0);
161 goto out_free;
162 }
163 /* Begin the file content on his own line. */
164 if (first_chunk) {
165 mconsole_reply(req, "\n", 0, 1);
166 first_chunk = 0;
167 }
168 buf[len] = '\0';
169 mconsole_reply(req, buf, 0, (len > 0));
170 } while (len > 0);
171 out_free:
172 kfree(buf);
173 out_fput:
174 fput(file);
175 out: ;
176}
177
178#define UML_MCONSOLE_HELPTEXT \
179"Commands: \n\
180 version - Get kernel version \n\
181 help - Print this message \n\
182 halt - Halt UML \n\
183 reboot - Reboot UML \n\
184 config <dev>=<config> - Add a new device to UML; \n\
185 same syntax as command line \n\
186 config <dev> - Query the configuration of a device \n\
187 remove <dev> - Remove a device from UML \n\
188 sysrq <letter> - Performs the SysRq action controlled by the letter \n\
189 cad - invoke the Ctrl-Alt-Del handler \n\
190 stop - pause the UML; it will do nothing until it receives a 'go' \n\
191 go - continue the UML after a 'stop' \n\
192 log <string> - make UML enter <string> into the kernel log\n\
193 proc <file> - returns the contents of the UML's /proc/<file>\n\
194 stack <pid> - returns the stack of the specified pid\n\
195"
196
197void mconsole_help(struct mc_request *req)
198{
199 mconsole_reply(req, UML_MCONSOLE_HELPTEXT, 0, 0);
200}
201
202void mconsole_halt(struct mc_request *req)
203{
204 mconsole_reply(req, "", 0, 0);
205 machine_halt();
206}
207
208void mconsole_reboot(struct mc_request *req)
209{
210 mconsole_reply(req, "", 0, 0);
211 machine_restart(NULL);
212}
213
214void mconsole_cad(struct mc_request *req)
215{
216 mconsole_reply(req, "", 0, 0);
217 ctrl_alt_del();
218}
219
220void mconsole_go(struct mc_request *req)
221{
222 mconsole_reply(req, "Not stopped", 1, 0);
223}
224
225void mconsole_stop(struct mc_request *req)
226{
227 block_signals();
228 os_set_fd_block(req->originating_fd, 1);
229 mconsole_reply(req, "stopped", 0, 0);
230 for (;;) {
231 if (!mconsole_get_request(req->originating_fd, req))
232 continue;
233 if (req->cmd->handler == mconsole_go)
234 break;
235 if (req->cmd->handler == mconsole_stop) {
236 mconsole_reply(req, "Already stopped", 1, 0);
237 continue;
238 }
239 if (req->cmd->handler == mconsole_sysrq) {
240 struct pt_regs *old_regs;
241 old_regs = set_irq_regs((struct pt_regs *)&req->regs);
242 mconsole_sysrq(req);
243 set_irq_regs(old_regs);
244 continue;
245 }
246 (*req->cmd->handler)(req);
247 }
248 os_set_fd_block(req->originating_fd, 0);
249 mconsole_reply(req, "", 0, 0);
250 unblock_signals();
251}
252
253static DEFINE_SPINLOCK(mc_devices_lock);
254static LIST_HEAD(mconsole_devices);
255
256void mconsole_register_dev(struct mc_device *new)
257{
258 spin_lock(&mc_devices_lock);
259 BUG_ON(!list_empty(&new->list));
260 list_add(&new->list, &mconsole_devices);
261 spin_unlock(&mc_devices_lock);
262}
263
264static struct mc_device *mconsole_find_dev(char *name)
265{
266 struct list_head *ele;
267 struct mc_device *dev;
268
269 list_for_each(ele, &mconsole_devices) {
270 dev = list_entry(ele, struct mc_device, list);
271 if (!strncmp(name, dev->name, strlen(dev->name)))
272 return dev;
273 }
274 return NULL;
275}
276
277#define UNPLUGGED_PER_PAGE \
278 ((PAGE_SIZE - sizeof(struct list_head)) / sizeof(unsigned long))
279
280struct unplugged_pages {
281 struct list_head list;
282 void *pages[UNPLUGGED_PER_PAGE];
283};
284
285static DEFINE_MUTEX(plug_mem_mutex);
286static unsigned long long unplugged_pages_count;
287static LIST_HEAD(unplugged_pages);
288static int unplug_index = UNPLUGGED_PER_PAGE;
289
290static int mem_config(char *str, char **error_out)
291{
292 unsigned long long diff;
293 int err = -EINVAL, i, add;
294 char *ret;
295
296 if (str[0] != '=') {
297 *error_out = "Expected '=' after 'mem'";
298 goto out;
299 }
300
301 str++;
302 if (str[0] == '-')
303 add = 0;
304 else if (str[0] == '+') {
305 add = 1;
306 }
307 else {
308 *error_out = "Expected increment to start with '-' or '+'";
309 goto out;
310 }
311
312 str++;
313 diff = memparse(str, &ret);
314 if (*ret != '\0') {
315 *error_out = "Failed to parse memory increment";
316 goto out;
317 }
318
319 diff /= PAGE_SIZE;
320
321 mutex_lock(&plug_mem_mutex);
322 for (i = 0; i < diff; i++) {
323 struct unplugged_pages *unplugged;
324 void *addr;
325
326 if (add) {
327 if (list_empty(&unplugged_pages))
328 break;
329
330 unplugged = list_entry(unplugged_pages.next,
331 struct unplugged_pages, list);
332 if (unplug_index > 0)
333 addr = unplugged->pages[--unplug_index];
334 else {
335 list_del(&unplugged->list);
336 addr = unplugged;
337 unplug_index = UNPLUGGED_PER_PAGE;
338 }
339
340 free_page((unsigned long) addr);
341 unplugged_pages_count--;
342 }
343 else {
344 struct page *page;
345
346 page = alloc_page(GFP_ATOMIC);
347 if (page == NULL)
348 break;
349
350 unplugged = page_address(page);
351 if (unplug_index == UNPLUGGED_PER_PAGE) {
352 list_add(&unplugged->list, &unplugged_pages);
353 unplug_index = 0;
354 }
355 else {
356 struct list_head *entry = unplugged_pages.next;
357 addr = unplugged;
358
359 unplugged = list_entry(entry,
360 struct unplugged_pages,
361 list);
362 err = os_drop_memory(addr, PAGE_SIZE);
363 if (err) {
364 printk(KERN_ERR "Failed to release "
365 "memory - errno = %d\n", err);
366 *error_out = "Failed to release memory";
367 goto out_unlock;
368 }
369 unplugged->pages[unplug_index++] = addr;
370 }
371
372 unplugged_pages_count++;
373 }
374 }
375
376 err = 0;
377out_unlock:
378 mutex_unlock(&plug_mem_mutex);
379out:
380 return err;
381}
382
383static int mem_get_config(char *name, char *str, int size, char **error_out)
384{
385 char buf[sizeof("18446744073709551615")];
386 int len = 0;
387
388 sprintf(buf, "%ld", uml_physmem);
389 CONFIG_CHUNK(str, size, len, buf, 1);
390
391 return len;
392}
393
394static int mem_id(char **str, int *start_out, int *end_out)
395{
396 *start_out = 0;
397 *end_out = 0;
398
399 return 0;
400}
401
402static int mem_remove(int n, char **error_out)
403{
404 *error_out = "Memory doesn't support the remove operation";
405 return -EBUSY;
406}
407
408static struct mc_device mem_mc = {
409 .list = LIST_HEAD_INIT(mem_mc.list),
410 .name = "mem",
411 .config = mem_config,
412 .get_config = mem_get_config,
413 .id = mem_id,
414 .remove = mem_remove,
415};
416
417static int __init mem_mc_init(void)
418{
419 if (can_drop_memory())
420 mconsole_register_dev(&mem_mc);
421 else printk(KERN_ERR "Can't release memory to the host - memory "
422 "hotplug won't be supported\n");
423 return 0;
424}
425
426__initcall(mem_mc_init);
427
428#define CONFIG_BUF_SIZE 64
429
430static void mconsole_get_config(int (*get_config)(char *, char *, int,
431 char **),
432 struct mc_request *req, char *name)
433{
434 char default_buf[CONFIG_BUF_SIZE], *error, *buf;
435 int n, size;
436
437 if (get_config == NULL) {
438 mconsole_reply(req, "No get_config routine defined", 1, 0);
439 return;
440 }
441
442 error = NULL;
443 size = ARRAY_SIZE(default_buf);
444 buf = default_buf;
445
446 while (1) {
447 n = (*get_config)(name, buf, size, &error);
448 if (error != NULL) {
449 mconsole_reply(req, error, 1, 0);
450 goto out;
451 }
452
453 if (n <= size) {
454 mconsole_reply(req, buf, 0, 0);
455 goto out;
456 }
457
458 if (buf != default_buf)
459 kfree(buf);
460
461 size = n;
462 buf = kmalloc(size, GFP_KERNEL);
463 if (buf == NULL) {
464 mconsole_reply(req, "Failed to allocate buffer", 1, 0);
465 return;
466 }
467 }
468 out:
469 if (buf != default_buf)
470 kfree(buf);
471}
472
473void mconsole_config(struct mc_request *req)
474{
475 struct mc_device *dev;
476 char *ptr = req->request.data, *name, *error_string = "";
477 int err;
478
479 ptr += strlen("config");
480 ptr = skip_spaces(ptr);
481 dev = mconsole_find_dev(ptr);
482 if (dev == NULL) {
483 mconsole_reply(req, "Bad configuration option", 1, 0);
484 return;
485 }
486
487 name = &ptr[strlen(dev->name)];
488 ptr = name;
489 while ((*ptr != '=') && (*ptr != '\0'))
490 ptr++;
491
492 if (*ptr == '=') {
493 err = (*dev->config)(name, &error_string);
494 mconsole_reply(req, error_string, err, 0);
495 }
496 else mconsole_get_config(dev->get_config, req, name);
497}
498
499void mconsole_remove(struct mc_request *req)
500{
501 struct mc_device *dev;
502 char *ptr = req->request.data, *err_msg = "";
503 char error[256];
504 int err, start, end, n;
505
506 ptr += strlen("remove");
507 ptr = skip_spaces(ptr);
508 dev = mconsole_find_dev(ptr);
509 if (dev == NULL) {
510 mconsole_reply(req, "Bad remove option", 1, 0);
511 return;
512 }
513
514 ptr = &ptr[strlen(dev->name)];
515
516 err = 1;
517 n = (*dev->id)(&ptr, &start, &end);
518 if (n < 0) {
519 err_msg = "Couldn't parse device number";
520 goto out;
521 }
522 else if ((n < start) || (n > end)) {
523 sprintf(error, "Invalid device number - must be between "
524 "%d and %d", start, end);
525 err_msg = error;
526 goto out;
527 }
528
529 err_msg = NULL;
530 err = (*dev->remove)(n, &err_msg);
531 switch(err) {
532 case 0:
533 err_msg = "";
534 break;
535 case -ENODEV:
536 if (err_msg == NULL)
537 err_msg = "Device doesn't exist";
538 break;
539 case -EBUSY:
540 if (err_msg == NULL)
541 err_msg = "Device is currently open";
542 break;
543 default:
544 break;
545 }
546out:
547 mconsole_reply(req, err_msg, err, 0);
548}
549
550struct mconsole_output {
551 struct list_head list;
552 struct mc_request *req;
553};
554
555static DEFINE_SPINLOCK(client_lock);
556static LIST_HEAD(clients);
557static char console_buf[MCONSOLE_MAX_DATA] __nonstring;
558
559static void console_write(struct console *console, const char *string,
560 unsigned int len)
561{
562 struct list_head *ele;
563 int n;
564
565 if (list_empty(&clients))
566 return;
567
568 while (len > 0) {
569 n = min((size_t) len, ARRAY_SIZE(console_buf));
570 memcpy(console_buf, string, n);
571 string += n;
572 len -= n;
573
574 list_for_each(ele, &clients) {
575 struct mconsole_output *entry;
576
577 entry = list_entry(ele, struct mconsole_output, list);
578 mconsole_reply_len(entry->req, console_buf, n, 0, 1);
579 }
580 }
581}
582
583static struct console mc_console = { .name = "mc",
584 .write = console_write,
585 .flags = CON_ENABLED,
586 .index = -1 };
587
588static int mc_add_console(void)
589{
590 register_console(&mc_console);
591 return 0;
592}
593
594late_initcall(mc_add_console);
595
596static void with_console(struct mc_request *req, void (*proc)(void *),
597 void *arg)
598{
599 struct mconsole_output entry;
600 unsigned long flags;
601
602 entry.req = req;
603 spin_lock_irqsave(&client_lock, flags);
604 list_add(&entry.list, &clients);
605 spin_unlock_irqrestore(&client_lock, flags);
606
607 (*proc)(arg);
608
609 mconsole_reply_len(req, "", 0, 0, 0);
610
611 spin_lock_irqsave(&client_lock, flags);
612 list_del(&entry.list);
613 spin_unlock_irqrestore(&client_lock, flags);
614}
615
616#ifdef CONFIG_MAGIC_SYSRQ
617
618#include <linux/sysrq.h>
619
620static void sysrq_proc(void *arg)
621{
622 char *op = arg;
623 handle_sysrq(*op);
624}
625
626void mconsole_sysrq(struct mc_request *req)
627{
628 char *ptr = req->request.data;
629
630 ptr += strlen("sysrq");
631 ptr = skip_spaces(ptr);
632
633 /*
634 * With 'b', the system will shut down without a chance to reply,
635 * so in this case, we reply first.
636 */
637 if (*ptr == 'b')
638 mconsole_reply(req, "", 0, 0);
639
640 with_console(req, sysrq_proc, ptr);
641}
642#else
643void mconsole_sysrq(struct mc_request *req)
644{
645 mconsole_reply(req, "Sysrq not compiled in", 1, 0);
646}
647#endif
648
649static void stack_proc(void *arg)
650{
651 struct task_struct *task = arg;
652
653 show_stack(task, NULL, KERN_INFO);
654}
655
656/*
657 * Mconsole stack trace
658 * Added by Allan Graves, Jeff Dike
659 * Dumps a stacks registers to the linux console.
660 * Usage stack <pid>.
661 */
662void mconsole_stack(struct mc_request *req)
663{
664 char *ptr = req->request.data;
665 int pid_requested= -1;
666 struct task_struct *to = NULL;
667
668 /*
669 * Would be nice:
670 * 1) Send showregs output to mconsole.
671 * 2) Add a way to stack dump all pids.
672 */
673
674 ptr += strlen("stack");
675 ptr = skip_spaces(ptr);
676
677 /*
678 * Should really check for multiple pids or reject bad args here
679 */
680 /* What do the arguments in mconsole_reply mean? */
681 if (sscanf(ptr, "%d", &pid_requested) == 0) {
682 mconsole_reply(req, "Please specify a pid", 1, 0);
683 return;
684 }
685
686 to = find_task_by_pid_ns(pid_requested, &init_pid_ns);
687 if ((to == NULL) || (pid_requested == 0)) {
688 mconsole_reply(req, "Couldn't find that pid", 1, 0);
689 return;
690 }
691 with_console(req, stack_proc, to);
692}
693
694static int __init mount_proc(void)
695{
696 struct file_system_type *proc_fs_type;
697 struct vfsmount *mnt;
698
699 proc_fs_type = get_fs_type("proc");
700 if (!proc_fs_type)
701 return -ENODEV;
702
703 mnt = kern_mount(proc_fs_type);
704 put_filesystem(proc_fs_type);
705 if (IS_ERR(mnt))
706 return PTR_ERR(mnt);
707
708 proc_mnt = mnt;
709 return 0;
710}
711
712/*
713 * Changed by mconsole_setup, which is __setup, and called before SMP is
714 * active.
715 */
716static char *notify_socket = NULL;
717
718static int __init mconsole_init(void)
719{
720 /* long to avoid size mismatch warnings from gcc */
721 long sock;
722 int err;
723 char file[UNIX_PATH_MAX];
724
725 mount_proc();
726
727 if (umid_file_name("mconsole", file, sizeof(file)))
728 return -1;
729 snprintf(mconsole_socket_name, sizeof(file), "%s", file);
730
731 sock = os_create_unix_socket(file, sizeof(file), 1);
732 if (sock < 0) {
733 printk(KERN_ERR "Failed to initialize management console\n");
734 return 1;
735 }
736 if (os_set_fd_block(sock, 0))
737 goto out;
738
739 register_reboot_notifier(&reboot_notifier);
740
741 err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
742 IRQF_SHARED, "mconsole", (void *)sock);
743 if (err < 0) {
744 printk(KERN_ERR "Failed to get IRQ for management console\n");
745 goto out;
746 }
747
748 if (notify_socket != NULL) {
749 notify_socket = kstrdup(notify_socket, GFP_KERNEL);
750 if (notify_socket != NULL)
751 mconsole_notify(notify_socket, MCONSOLE_SOCKET,
752 mconsole_socket_name,
753 strlen(mconsole_socket_name) + 1);
754 else printk(KERN_ERR "mconsole_setup failed to strdup "
755 "string\n");
756 }
757
758 printk(KERN_INFO "mconsole (version %d) initialized on %s\n",
759 MCONSOLE_VERSION, mconsole_socket_name);
760 return 0;
761
762 out:
763 os_close_file(sock);
764 return 1;
765}
766
767__initcall(mconsole_init);
768
769static ssize_t mconsole_proc_write(struct file *file,
770 const char __user *buffer, size_t count, loff_t *pos)
771{
772 char *buf;
773
774 buf = memdup_user_nul(buffer, count);
775 if (IS_ERR(buf))
776 return PTR_ERR(buf);
777
778 mconsole_notify(notify_socket, MCONSOLE_USER_NOTIFY, buf, count);
779 kfree(buf);
780 return count;
781}
782
783static const struct proc_ops mconsole_proc_ops = {
784 .proc_write = mconsole_proc_write,
785 .proc_lseek = noop_llseek,
786};
787
788static int create_proc_mconsole(void)
789{
790 struct proc_dir_entry *ent;
791
792 if (notify_socket == NULL)
793 return 0;
794
795 ent = proc_create("mconsole", 0200, NULL, &mconsole_proc_ops);
796 if (ent == NULL) {
797 printk(KERN_INFO "create_proc_mconsole : proc_create failed\n");
798 return 0;
799 }
800 return 0;
801}
802
803static DEFINE_SPINLOCK(notify_spinlock);
804
805void lock_notify(void)
806{
807 spin_lock(¬ify_spinlock);
808}
809
810void unlock_notify(void)
811{
812 spin_unlock(¬ify_spinlock);
813}
814
815__initcall(create_proc_mconsole);
816
817#define NOTIFY "notify:"
818
819static int mconsole_setup(char *str)
820{
821 if (!strncmp(str, NOTIFY, strlen(NOTIFY))) {
822 str += strlen(NOTIFY);
823 notify_socket = str;
824 }
825 else printk(KERN_ERR "mconsole_setup : Unknown option - '%s'\n", str);
826 return 1;
827}
828
829__setup("mconsole=", mconsole_setup);
830
831__uml_help(mconsole_setup,
832"mconsole=notify:<socket>\n"
833" Requests that the mconsole driver send a message to the named Unix\n"
834" socket containing the name of the mconsole socket. This also serves\n"
835" to notify outside processes when UML has booted far enough to respond\n"
836" to mconsole requests.\n\n"
837);
838
839static int notify_panic(struct notifier_block *self, unsigned long unused1,
840 void *ptr)
841{
842 char *message = ptr;
843
844 if (notify_socket == NULL)
845 return 0;
846
847 mconsole_notify(notify_socket, MCONSOLE_PANIC, message,
848 strlen(message) + 1);
849 return NOTIFY_DONE;
850}
851
852static struct notifier_block panic_exit_notifier = {
853 .notifier_call = notify_panic,
854 .priority = INT_MAX, /* run as soon as possible */
855};
856
857static int add_notifier(void)
858{
859 atomic_notifier_chain_register(&panic_notifier_list,
860 &panic_exit_notifier);
861 return 0;
862}
863
864__initcall(add_notifier);
865
866char *mconsole_notify_socket(void)
867{
868 return notify_socket;
869}
870
871EXPORT_SYMBOL(mconsole_notify_socket);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
4 * Copyright (C) 2001 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
5 */
6
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>
12#include <linux/mm.h>
13#include <linux/module.h>
14#include <linux/notifier.h>
15#include <linux/panic_notifier.h>
16#include <linux/reboot.h>
17#include <linux/sched/debug.h>
18#include <linux/proc_fs.h>
19#include <linux/slab.h>
20#include <linux/syscalls.h>
21#include <linux/utsname.h>
22#include <linux/socket.h>
23#include <linux/un.h>
24#include <linux/workqueue.h>
25#include <linux/mutex.h>
26#include <linux/fs.h>
27#include <linux/mount.h>
28#include <linux/file.h>
29#include <linux/uaccess.h>
30#include <asm/switch_to.h>
31
32#include <init.h>
33#include <irq_kern.h>
34#include <irq_user.h>
35#include <kern_util.h>
36#include "mconsole.h"
37#include "mconsole_kern.h"
38#include <os.h>
39
40static struct vfsmount *proc_mnt = NULL;
41
42static int do_unlink_socket(struct notifier_block *notifier,
43 unsigned long what, void *data)
44{
45 return mconsole_unlink_socket();
46}
47
48
49static struct notifier_block reboot_notifier = {
50 .notifier_call = do_unlink_socket,
51 .priority = 0,
52};
53
54/* Safe without explicit locking for now. Tasklets provide their own
55 * locking, and the interrupt handler is safe because it can't interrupt
56 * itself and it can only happen on CPU 0.
57 */
58
59static LIST_HEAD(mc_requests);
60
61static void mc_work_proc(struct work_struct *unused)
62{
63 struct mconsole_entry *req;
64 unsigned long flags;
65
66 while (!list_empty(&mc_requests)) {
67 local_irq_save(flags);
68 req = list_entry(mc_requests.next, struct mconsole_entry, list);
69 list_del(&req->list);
70 local_irq_restore(flags);
71 req->request.cmd->handler(&req->request);
72 kfree(req);
73 }
74}
75
76static DECLARE_WORK(mconsole_work, mc_work_proc);
77
78static irqreturn_t mconsole_interrupt(int irq, void *dev_id)
79{
80 /* long to avoid size mismatch warnings from gcc */
81 long fd;
82 struct mconsole_entry *new;
83 static struct mc_request req; /* that's OK */
84
85 fd = (long) dev_id;
86 while (mconsole_get_request(fd, &req)) {
87 if (req.cmd->context == MCONSOLE_INTR)
88 (*req.cmd->handler)(&req);
89 else {
90 new = kmalloc(sizeof(*new), GFP_NOWAIT);
91 if (new == NULL)
92 mconsole_reply(&req, "Out of memory", 1, 0);
93 else {
94 new->request = req;
95 new->request.regs = get_irq_regs()->regs;
96 list_add(&new->list, &mc_requests);
97 }
98 }
99 }
100 if (!list_empty(&mc_requests))
101 schedule_work(&mconsole_work);
102 return IRQ_HANDLED;
103}
104
105void mconsole_version(struct mc_request *req)
106{
107 char version[256];
108
109 sprintf(version, "%s %s %s %s %s", utsname()->sysname,
110 utsname()->nodename, utsname()->release, utsname()->version,
111 utsname()->machine);
112 mconsole_reply(req, version, 0, 0);
113}
114
115void mconsole_log(struct mc_request *req)
116{
117 int len;
118 char *ptr = req->request.data;
119
120 ptr += strlen("log ");
121
122 len = req->len - (ptr - req->request.data);
123 printk(KERN_WARNING "%.*s", len, ptr);
124 mconsole_reply(req, "", 0, 0);
125}
126
127void mconsole_proc(struct mc_request *req)
128{
129 struct vfsmount *mnt = proc_mnt;
130 char *buf;
131 int len;
132 struct file *file;
133 int first_chunk = 1;
134 char *ptr = req->request.data;
135 loff_t pos = 0;
136
137 ptr += strlen("proc");
138 ptr = skip_spaces(ptr);
139
140 if (!mnt) {
141 mconsole_reply(req, "Proc not available", 1, 0);
142 goto out;
143 }
144 file = file_open_root_mnt(mnt, ptr, O_RDONLY, 0);
145 if (IS_ERR(file)) {
146 mconsole_reply(req, "Failed to open file", 1, 0);
147 printk(KERN_ERR "open /proc/%s: %ld\n", ptr, PTR_ERR(file));
148 goto out;
149 }
150
151 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
152 if (buf == NULL) {
153 mconsole_reply(req, "Failed to allocate buffer", 1, 0);
154 goto out_fput;
155 }
156
157 do {
158 len = kernel_read(file, buf, PAGE_SIZE - 1, &pos);
159 if (len < 0) {
160 mconsole_reply(req, "Read of file failed", 1, 0);
161 goto out_free;
162 }
163 /* Begin the file content on his own line. */
164 if (first_chunk) {
165 mconsole_reply(req, "\n", 0, 1);
166 first_chunk = 0;
167 }
168 buf[len] = '\0';
169 mconsole_reply(req, buf, 0, (len > 0));
170 } while (len > 0);
171 out_free:
172 kfree(buf);
173 out_fput:
174 fput(file);
175 out: ;
176}
177
178#define UML_MCONSOLE_HELPTEXT \
179"Commands: \n\
180 version - Get kernel version \n\
181 help - Print this message \n\
182 halt - Halt UML \n\
183 reboot - Reboot UML \n\
184 config <dev>=<config> - Add a new device to UML; \n\
185 same syntax as command line \n\
186 config <dev> - Query the configuration of a device \n\
187 remove <dev> - Remove a device from UML \n\
188 sysrq <letter> - Performs the SysRq action controlled by the letter \n\
189 cad - invoke the Ctrl-Alt-Del handler \n\
190 stop - pause the UML; it will do nothing until it receives a 'go' \n\
191 go - continue the UML after a 'stop' \n\
192 log <string> - make UML enter <string> into the kernel log\n\
193 proc <file> - returns the contents of the UML's /proc/<file>\n\
194 stack <pid> - returns the stack of the specified pid\n\
195"
196
197void mconsole_help(struct mc_request *req)
198{
199 mconsole_reply(req, UML_MCONSOLE_HELPTEXT, 0, 0);
200}
201
202void mconsole_halt(struct mc_request *req)
203{
204 mconsole_reply(req, "", 0, 0);
205 machine_halt();
206}
207
208void mconsole_reboot(struct mc_request *req)
209{
210 mconsole_reply(req, "", 0, 0);
211 machine_restart(NULL);
212}
213
214void mconsole_cad(struct mc_request *req)
215{
216 mconsole_reply(req, "", 0, 0);
217 ctrl_alt_del();
218}
219
220void mconsole_go(struct mc_request *req)
221{
222 mconsole_reply(req, "Not stopped", 1, 0);
223}
224
225void mconsole_stop(struct mc_request *req)
226{
227 deactivate_fd(req->originating_fd, MCONSOLE_IRQ);
228 os_set_fd_block(req->originating_fd, 1);
229 mconsole_reply(req, "stopped", 0, 0);
230 for (;;) {
231 if (!mconsole_get_request(req->originating_fd, req))
232 continue;
233 if (req->cmd->handler == mconsole_go)
234 break;
235 if (req->cmd->handler == mconsole_stop) {
236 mconsole_reply(req, "Already stopped", 1, 0);
237 continue;
238 }
239 if (req->cmd->handler == mconsole_sysrq) {
240 struct pt_regs *old_regs;
241 old_regs = set_irq_regs((struct pt_regs *)&req->regs);
242 mconsole_sysrq(req);
243 set_irq_regs(old_regs);
244 continue;
245 }
246 (*req->cmd->handler)(req);
247 }
248 os_set_fd_block(req->originating_fd, 0);
249 mconsole_reply(req, "", 0, 0);
250}
251
252static DEFINE_SPINLOCK(mc_devices_lock);
253static LIST_HEAD(mconsole_devices);
254
255void mconsole_register_dev(struct mc_device *new)
256{
257 spin_lock(&mc_devices_lock);
258 BUG_ON(!list_empty(&new->list));
259 list_add(&new->list, &mconsole_devices);
260 spin_unlock(&mc_devices_lock);
261}
262
263static struct mc_device *mconsole_find_dev(char *name)
264{
265 struct list_head *ele;
266 struct mc_device *dev;
267
268 list_for_each(ele, &mconsole_devices) {
269 dev = list_entry(ele, struct mc_device, list);
270 if (!strncmp(name, dev->name, strlen(dev->name)))
271 return dev;
272 }
273 return NULL;
274}
275
276#define UNPLUGGED_PER_PAGE \
277 ((PAGE_SIZE - sizeof(struct list_head)) / sizeof(unsigned long))
278
279struct unplugged_pages {
280 struct list_head list;
281 void *pages[UNPLUGGED_PER_PAGE];
282};
283
284static DEFINE_MUTEX(plug_mem_mutex);
285static unsigned long long unplugged_pages_count = 0;
286static LIST_HEAD(unplugged_pages);
287static int unplug_index = UNPLUGGED_PER_PAGE;
288
289static int mem_config(char *str, char **error_out)
290{
291 unsigned long long diff;
292 int err = -EINVAL, i, add;
293 char *ret;
294
295 if (str[0] != '=') {
296 *error_out = "Expected '=' after 'mem'";
297 goto out;
298 }
299
300 str++;
301 if (str[0] == '-')
302 add = 0;
303 else if (str[0] == '+') {
304 add = 1;
305 }
306 else {
307 *error_out = "Expected increment to start with '-' or '+'";
308 goto out;
309 }
310
311 str++;
312 diff = memparse(str, &ret);
313 if (*ret != '\0') {
314 *error_out = "Failed to parse memory increment";
315 goto out;
316 }
317
318 diff /= PAGE_SIZE;
319
320 mutex_lock(&plug_mem_mutex);
321 for (i = 0; i < diff; i++) {
322 struct unplugged_pages *unplugged;
323 void *addr;
324
325 if (add) {
326 if (list_empty(&unplugged_pages))
327 break;
328
329 unplugged = list_entry(unplugged_pages.next,
330 struct unplugged_pages, list);
331 if (unplug_index > 0)
332 addr = unplugged->pages[--unplug_index];
333 else {
334 list_del(&unplugged->list);
335 addr = unplugged;
336 unplug_index = UNPLUGGED_PER_PAGE;
337 }
338
339 free_page((unsigned long) addr);
340 unplugged_pages_count--;
341 }
342 else {
343 struct page *page;
344
345 page = alloc_page(GFP_ATOMIC);
346 if (page == NULL)
347 break;
348
349 unplugged = page_address(page);
350 if (unplug_index == UNPLUGGED_PER_PAGE) {
351 list_add(&unplugged->list, &unplugged_pages);
352 unplug_index = 0;
353 }
354 else {
355 struct list_head *entry = unplugged_pages.next;
356 addr = unplugged;
357
358 unplugged = list_entry(entry,
359 struct unplugged_pages,
360 list);
361 err = os_drop_memory(addr, PAGE_SIZE);
362 if (err) {
363 printk(KERN_ERR "Failed to release "
364 "memory - errno = %d\n", err);
365 *error_out = "Failed to release memory";
366 goto out_unlock;
367 }
368 unplugged->pages[unplug_index++] = addr;
369 }
370
371 unplugged_pages_count++;
372 }
373 }
374
375 err = 0;
376out_unlock:
377 mutex_unlock(&plug_mem_mutex);
378out:
379 return err;
380}
381
382static int mem_get_config(char *name, char *str, int size, char **error_out)
383{
384 char buf[sizeof("18446744073709551615")];
385 int len = 0;
386
387 sprintf(buf, "%ld", uml_physmem);
388 CONFIG_CHUNK(str, size, len, buf, 1);
389
390 return len;
391}
392
393static int mem_id(char **str, int *start_out, int *end_out)
394{
395 *start_out = 0;
396 *end_out = 0;
397
398 return 0;
399}
400
401static int mem_remove(int n, char **error_out)
402{
403 *error_out = "Memory doesn't support the remove operation";
404 return -EBUSY;
405}
406
407static struct mc_device mem_mc = {
408 .list = LIST_HEAD_INIT(mem_mc.list),
409 .name = "mem",
410 .config = mem_config,
411 .get_config = mem_get_config,
412 .id = mem_id,
413 .remove = mem_remove,
414};
415
416static int __init mem_mc_init(void)
417{
418 if (can_drop_memory())
419 mconsole_register_dev(&mem_mc);
420 else printk(KERN_ERR "Can't release memory to the host - memory "
421 "hotplug won't be supported\n");
422 return 0;
423}
424
425__initcall(mem_mc_init);
426
427#define CONFIG_BUF_SIZE 64
428
429static void mconsole_get_config(int (*get_config)(char *, char *, int,
430 char **),
431 struct mc_request *req, char *name)
432{
433 char default_buf[CONFIG_BUF_SIZE], *error, *buf;
434 int n, size;
435
436 if (get_config == NULL) {
437 mconsole_reply(req, "No get_config routine defined", 1, 0);
438 return;
439 }
440
441 error = NULL;
442 size = ARRAY_SIZE(default_buf);
443 buf = default_buf;
444
445 while (1) {
446 n = (*get_config)(name, buf, size, &error);
447 if (error != NULL) {
448 mconsole_reply(req, error, 1, 0);
449 goto out;
450 }
451
452 if (n <= size) {
453 mconsole_reply(req, buf, 0, 0);
454 goto out;
455 }
456
457 if (buf != default_buf)
458 kfree(buf);
459
460 size = n;
461 buf = kmalloc(size, GFP_KERNEL);
462 if (buf == NULL) {
463 mconsole_reply(req, "Failed to allocate buffer", 1, 0);
464 return;
465 }
466 }
467 out:
468 if (buf != default_buf)
469 kfree(buf);
470}
471
472void mconsole_config(struct mc_request *req)
473{
474 struct mc_device *dev;
475 char *ptr = req->request.data, *name, *error_string = "";
476 int err;
477
478 ptr += strlen("config");
479 ptr = skip_spaces(ptr);
480 dev = mconsole_find_dev(ptr);
481 if (dev == NULL) {
482 mconsole_reply(req, "Bad configuration option", 1, 0);
483 return;
484 }
485
486 name = &ptr[strlen(dev->name)];
487 ptr = name;
488 while ((*ptr != '=') && (*ptr != '\0'))
489 ptr++;
490
491 if (*ptr == '=') {
492 err = (*dev->config)(name, &error_string);
493 mconsole_reply(req, error_string, err, 0);
494 }
495 else mconsole_get_config(dev->get_config, req, name);
496}
497
498void mconsole_remove(struct mc_request *req)
499{
500 struct mc_device *dev;
501 char *ptr = req->request.data, *err_msg = "";
502 char error[256];
503 int err, start, end, n;
504
505 ptr += strlen("remove");
506 ptr = skip_spaces(ptr);
507 dev = mconsole_find_dev(ptr);
508 if (dev == NULL) {
509 mconsole_reply(req, "Bad remove option", 1, 0);
510 return;
511 }
512
513 ptr = &ptr[strlen(dev->name)];
514
515 err = 1;
516 n = (*dev->id)(&ptr, &start, &end);
517 if (n < 0) {
518 err_msg = "Couldn't parse device number";
519 goto out;
520 }
521 else if ((n < start) || (n > end)) {
522 sprintf(error, "Invalid device number - must be between "
523 "%d and %d", start, end);
524 err_msg = error;
525 goto out;
526 }
527
528 err_msg = NULL;
529 err = (*dev->remove)(n, &err_msg);
530 switch(err) {
531 case 0:
532 err_msg = "";
533 break;
534 case -ENODEV:
535 if (err_msg == NULL)
536 err_msg = "Device doesn't exist";
537 break;
538 case -EBUSY:
539 if (err_msg == NULL)
540 err_msg = "Device is currently open";
541 break;
542 default:
543 break;
544 }
545out:
546 mconsole_reply(req, err_msg, err, 0);
547}
548
549struct mconsole_output {
550 struct list_head list;
551 struct mc_request *req;
552};
553
554static DEFINE_SPINLOCK(client_lock);
555static LIST_HEAD(clients);
556static char console_buf[MCONSOLE_MAX_DATA];
557
558static void console_write(struct console *console, const char *string,
559 unsigned int len)
560{
561 struct list_head *ele;
562 int n;
563
564 if (list_empty(&clients))
565 return;
566
567 while (len > 0) {
568 n = min((size_t) len, ARRAY_SIZE(console_buf));
569 strncpy(console_buf, string, n);
570 string += n;
571 len -= n;
572
573 list_for_each(ele, &clients) {
574 struct mconsole_output *entry;
575
576 entry = list_entry(ele, struct mconsole_output, list);
577 mconsole_reply_len(entry->req, console_buf, n, 0, 1);
578 }
579 }
580}
581
582static struct console mc_console = { .name = "mc",
583 .write = console_write,
584 .flags = CON_ENABLED,
585 .index = -1 };
586
587static int mc_add_console(void)
588{
589 register_console(&mc_console);
590 return 0;
591}
592
593late_initcall(mc_add_console);
594
595static void with_console(struct mc_request *req, void (*proc)(void *),
596 void *arg)
597{
598 struct mconsole_output entry;
599 unsigned long flags;
600
601 entry.req = req;
602 spin_lock_irqsave(&client_lock, flags);
603 list_add(&entry.list, &clients);
604 spin_unlock_irqrestore(&client_lock, flags);
605
606 (*proc)(arg);
607
608 mconsole_reply_len(req, "", 0, 0, 0);
609
610 spin_lock_irqsave(&client_lock, flags);
611 list_del(&entry.list);
612 spin_unlock_irqrestore(&client_lock, flags);
613}
614
615#ifdef CONFIG_MAGIC_SYSRQ
616
617#include <linux/sysrq.h>
618
619static void sysrq_proc(void *arg)
620{
621 char *op = arg;
622 handle_sysrq(*op);
623}
624
625void mconsole_sysrq(struct mc_request *req)
626{
627 char *ptr = req->request.data;
628
629 ptr += strlen("sysrq");
630 ptr = skip_spaces(ptr);
631
632 /*
633 * With 'b', the system will shut down without a chance to reply,
634 * so in this case, we reply first.
635 */
636 if (*ptr == 'b')
637 mconsole_reply(req, "", 0, 0);
638
639 with_console(req, sysrq_proc, ptr);
640}
641#else
642void mconsole_sysrq(struct mc_request *req)
643{
644 mconsole_reply(req, "Sysrq not compiled in", 1, 0);
645}
646#endif
647
648static void stack_proc(void *arg)
649{
650 struct task_struct *task = arg;
651
652 show_stack(task, NULL, KERN_INFO);
653}
654
655/*
656 * Mconsole stack trace
657 * Added by Allan Graves, Jeff Dike
658 * Dumps a stacks registers to the linux console.
659 * Usage stack <pid>.
660 */
661void mconsole_stack(struct mc_request *req)
662{
663 char *ptr = req->request.data;
664 int pid_requested= -1;
665 struct task_struct *to = NULL;
666
667 /*
668 * Would be nice:
669 * 1) Send showregs output to mconsole.
670 * 2) Add a way to stack dump all pids.
671 */
672
673 ptr += strlen("stack");
674 ptr = skip_spaces(ptr);
675
676 /*
677 * Should really check for multiple pids or reject bad args here
678 */
679 /* What do the arguments in mconsole_reply mean? */
680 if (sscanf(ptr, "%d", &pid_requested) == 0) {
681 mconsole_reply(req, "Please specify a pid", 1, 0);
682 return;
683 }
684
685 to = find_task_by_pid_ns(pid_requested, &init_pid_ns);
686 if ((to == NULL) || (pid_requested == 0)) {
687 mconsole_reply(req, "Couldn't find that pid", 1, 0);
688 return;
689 }
690 with_console(req, stack_proc, to);
691}
692
693static int __init mount_proc(void)
694{
695 struct file_system_type *proc_fs_type;
696 struct vfsmount *mnt;
697
698 proc_fs_type = get_fs_type("proc");
699 if (!proc_fs_type)
700 return -ENODEV;
701
702 mnt = kern_mount(proc_fs_type);
703 put_filesystem(proc_fs_type);
704 if (IS_ERR(mnt))
705 return PTR_ERR(mnt);
706
707 proc_mnt = mnt;
708 return 0;
709}
710
711/*
712 * Changed by mconsole_setup, which is __setup, and called before SMP is
713 * active.
714 */
715static char *notify_socket = NULL;
716
717static int __init mconsole_init(void)
718{
719 /* long to avoid size mismatch warnings from gcc */
720 long sock;
721 int err;
722 char file[UNIX_PATH_MAX];
723
724 mount_proc();
725
726 if (umid_file_name("mconsole", file, sizeof(file)))
727 return -1;
728 snprintf(mconsole_socket_name, sizeof(file), "%s", file);
729
730 sock = os_create_unix_socket(file, sizeof(file), 1);
731 if (sock < 0) {
732 printk(KERN_ERR "Failed to initialize management console\n");
733 return 1;
734 }
735 if (os_set_fd_block(sock, 0))
736 goto out;
737
738 register_reboot_notifier(&reboot_notifier);
739
740 err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
741 IRQF_SHARED, "mconsole", (void *)sock);
742 if (err < 0) {
743 printk(KERN_ERR "Failed to get IRQ for management console\n");
744 goto out;
745 }
746
747 if (notify_socket != NULL) {
748 notify_socket = kstrdup(notify_socket, GFP_KERNEL);
749 if (notify_socket != NULL)
750 mconsole_notify(notify_socket, MCONSOLE_SOCKET,
751 mconsole_socket_name,
752 strlen(mconsole_socket_name) + 1);
753 else printk(KERN_ERR "mconsole_setup failed to strdup "
754 "string\n");
755 }
756
757 printk(KERN_INFO "mconsole (version %d) initialized on %s\n",
758 MCONSOLE_VERSION, mconsole_socket_name);
759 return 0;
760
761 out:
762 os_close_file(sock);
763 return 1;
764}
765
766__initcall(mconsole_init);
767
768static ssize_t mconsole_proc_write(struct file *file,
769 const char __user *buffer, size_t count, loff_t *pos)
770{
771 char *buf;
772
773 buf = memdup_user_nul(buffer, count);
774 if (IS_ERR(buf))
775 return PTR_ERR(buf);
776
777 mconsole_notify(notify_socket, MCONSOLE_USER_NOTIFY, buf, count);
778 kfree(buf);
779 return count;
780}
781
782static const struct proc_ops mconsole_proc_ops = {
783 .proc_write = mconsole_proc_write,
784 .proc_lseek = noop_llseek,
785};
786
787static int create_proc_mconsole(void)
788{
789 struct proc_dir_entry *ent;
790
791 if (notify_socket == NULL)
792 return 0;
793
794 ent = proc_create("mconsole", 0200, NULL, &mconsole_proc_ops);
795 if (ent == NULL) {
796 printk(KERN_INFO "create_proc_mconsole : proc_create failed\n");
797 return 0;
798 }
799 return 0;
800}
801
802static DEFINE_SPINLOCK(notify_spinlock);
803
804void lock_notify(void)
805{
806 spin_lock(¬ify_spinlock);
807}
808
809void unlock_notify(void)
810{
811 spin_unlock(¬ify_spinlock);
812}
813
814__initcall(create_proc_mconsole);
815
816#define NOTIFY "notify:"
817
818static int mconsole_setup(char *str)
819{
820 if (!strncmp(str, NOTIFY, strlen(NOTIFY))) {
821 str += strlen(NOTIFY);
822 notify_socket = str;
823 }
824 else printk(KERN_ERR "mconsole_setup : Unknown option - '%s'\n", str);
825 return 1;
826}
827
828__setup("mconsole=", mconsole_setup);
829
830__uml_help(mconsole_setup,
831"mconsole=notify:<socket>\n"
832" Requests that the mconsole driver send a message to the named Unix\n"
833" socket containing the name of the mconsole socket. This also serves\n"
834" to notify outside processes when UML has booted far enough to respond\n"
835" to mconsole requests.\n\n"
836);
837
838static int notify_panic(struct notifier_block *self, unsigned long unused1,
839 void *ptr)
840{
841 char *message = ptr;
842
843 if (notify_socket == NULL)
844 return 0;
845
846 mconsole_notify(notify_socket, MCONSOLE_PANIC, message,
847 strlen(message) + 1);
848 return 0;
849}
850
851static struct notifier_block panic_exit_notifier = {
852 .notifier_call = notify_panic,
853 .next = NULL,
854 .priority = 1
855};
856
857static int add_notifier(void)
858{
859 atomic_notifier_chain_register(&panic_notifier_list,
860 &panic_exit_notifier);
861 return 0;
862}
863
864__initcall(add_notifier);
865
866char *mconsole_notify_socket(void)
867{
868 return notify_socket;
869}
870
871EXPORT_SYMBOL(mconsole_notify_socket);