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