1dbddf429SAlex Dewar // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
4827b3f6aSJeff Dike * Copyright (C) 2001 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
51da177e4SLinus Torvalds */
61da177e4SLinus Torvalds
7827b3f6aSJeff Dike #include <linux/console.h>
8827b3f6aSJeff Dike #include <linux/ctype.h>
9e7d2860bSAndré Goddard Rosa #include <linux/string.h>
10827b3f6aSJeff Dike #include <linux/interrupt.h>
11827b3f6aSJeff Dike #include <linux/list.h>
12827b3f6aSJeff Dike #include <linux/mm.h>
13827b3f6aSJeff Dike #include <linux/module.h>
14827b3f6aSJeff Dike #include <linux/notifier.h>
15f39650deSAndy Shevchenko #include <linux/panic_notifier.h>
16827b3f6aSJeff Dike #include <linux/reboot.h>
17b17b0153SIngo Molnar #include <linux/sched/debug.h>
18827b3f6aSJeff Dike #include <linux/proc_fs.h>
19827b3f6aSJeff Dike #include <linux/slab.h>
20827b3f6aSJeff Dike #include <linux/syscalls.h>
21827b3f6aSJeff Dike #include <linux/utsname.h>
2236137120SBalbir Singh #include <linux/socket.h>
2336137120SBalbir Singh #include <linux/un.h>
24827b3f6aSJeff Dike #include <linux/workqueue.h>
25827b3f6aSJeff Dike #include <linux/mutex.h>
26723a1d77SAl Viro #include <linux/fs.h>
27723a1d77SAl Viro #include <linux/mount.h>
28723a1d77SAl Viro #include <linux/file.h>
297c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
30a3a85a76SRichard Weinberger #include <asm/switch_to.h>
31827b3f6aSJeff Dike
3237185b33SAl Viro #include <init.h>
3337185b33SAl Viro #include <irq_kern.h>
3437185b33SAl Viro #include <irq_user.h>
3537185b33SAl Viro #include <kern_util.h>
361da177e4SLinus Torvalds #include "mconsole.h"
371da177e4SLinus Torvalds #include "mconsole_kern.h"
3837185b33SAl Viro #include <os.h>
391da177e4SLinus Torvalds
4076313c70SEric W. Biederman static struct vfsmount *proc_mnt = NULL;
4176313c70SEric W. Biederman
do_unlink_socket(struct notifier_block * notifier,unsigned long what,void * data)421da177e4SLinus Torvalds static int do_unlink_socket(struct notifier_block *notifier,
431da177e4SLinus Torvalds unsigned long what, void *data)
441da177e4SLinus Torvalds {
45ae2587e4SJeff Dike return mconsole_unlink_socket();
461da177e4SLinus Torvalds }
471da177e4SLinus Torvalds
481da177e4SLinus Torvalds
491da177e4SLinus Torvalds static struct notifier_block reboot_notifier = {
501da177e4SLinus Torvalds .notifier_call = do_unlink_socket,
511da177e4SLinus Torvalds .priority = 0,
521da177e4SLinus Torvalds };
531da177e4SLinus Torvalds
541da177e4SLinus Torvalds /* Safe without explicit locking for now. Tasklets provide their own
551da177e4SLinus Torvalds * locking, and the interrupt handler is safe because it can't interrupt
561da177e4SLinus Torvalds * itself and it can only happen on CPU 0.
571da177e4SLinus Torvalds */
581da177e4SLinus Torvalds
599010772cSJeff Dike static LIST_HEAD(mc_requests);
601da177e4SLinus Torvalds
mc_work_proc(struct work_struct * unused)616d5aefb8SDavid Howells static void mc_work_proc(struct work_struct *unused)
621da177e4SLinus Torvalds {
631da177e4SLinus Torvalds struct mconsole_entry *req;
641da177e4SLinus Torvalds unsigned long flags;
651da177e4SLinus Torvalds
661da177e4SLinus Torvalds while (!list_empty(&mc_requests)) {
67dbdb4c06SPaolo 'Blaisorblade' Giarrusso local_irq_save(flags);
68ae2587e4SJeff Dike req = list_entry(mc_requests.next, struct mconsole_entry, list);
691da177e4SLinus Torvalds list_del(&req->list);
701da177e4SLinus Torvalds local_irq_restore(flags);
711da177e4SLinus Torvalds req->request.cmd->handler(&req->request);
721da177e4SLinus Torvalds kfree(req);
731da177e4SLinus Torvalds }
741da177e4SLinus Torvalds }
751da177e4SLinus Torvalds
766d5aefb8SDavid Howells static DECLARE_WORK(mconsole_work, mc_work_proc);
771da177e4SLinus Torvalds
mconsole_interrupt(int irq,void * dev_id)787bea96fdSAl Viro static irqreturn_t mconsole_interrupt(int irq, void *dev_id)
791da177e4SLinus Torvalds {
801da177e4SLinus Torvalds /* long to avoid size mismatch warnings from gcc */
811da177e4SLinus Torvalds long fd;
821da177e4SLinus Torvalds struct mconsole_entry *new;
833a51237dSAl Viro static struct mc_request req; /* that's OK */
841da177e4SLinus Torvalds
851da177e4SLinus Torvalds fd = (long) dev_id;
861da177e4SLinus Torvalds while (mconsole_get_request(fd, &req)) {
871da177e4SLinus Torvalds if (req.cmd->context == MCONSOLE_INTR)
881da177e4SLinus Torvalds (*req.cmd->handler)(&req);
891da177e4SLinus Torvalds else {
9060baa158SJeff Dike new = kmalloc(sizeof(*new), GFP_NOWAIT);
911da177e4SLinus Torvalds if (new == NULL)
921da177e4SLinus Torvalds mconsole_reply(&req, "Out of memory", 1, 0);
931da177e4SLinus Torvalds else {
941da177e4SLinus Torvalds new->request = req;
953a51237dSAl Viro new->request.regs = get_irq_regs()->regs;
961da177e4SLinus Torvalds list_add(&new->list, &mc_requests);
971da177e4SLinus Torvalds }
981da177e4SLinus Torvalds }
991da177e4SLinus Torvalds }
1001da177e4SLinus Torvalds if (!list_empty(&mc_requests))
1011da177e4SLinus Torvalds schedule_work(&mconsole_work);
102ae2587e4SJeff Dike return IRQ_HANDLED;
1031da177e4SLinus Torvalds }
1041da177e4SLinus Torvalds
mconsole_version(struct mc_request * req)1051da177e4SLinus Torvalds void mconsole_version(struct mc_request *req)
1061da177e4SLinus Torvalds {
1071da177e4SLinus Torvalds char version[256];
1081da177e4SLinus Torvalds
109e9ff3990SSerge E. Hallyn sprintf(version, "%s %s %s %s %s", utsname()->sysname,
110ae2587e4SJeff Dike utsname()->nodename, utsname()->release, utsname()->version,
111ae2587e4SJeff Dike utsname()->machine);
1121da177e4SLinus Torvalds mconsole_reply(req, version, 0, 0);
1131da177e4SLinus Torvalds }
1141da177e4SLinus Torvalds
mconsole_log(struct mc_request * req)1151da177e4SLinus Torvalds void mconsole_log(struct mc_request *req)
1161da177e4SLinus Torvalds {
1171da177e4SLinus Torvalds int len;
1181da177e4SLinus Torvalds char *ptr = req->request.data;
1191da177e4SLinus Torvalds
1201da177e4SLinus Torvalds ptr += strlen("log ");
1211da177e4SLinus Torvalds
1221da177e4SLinus Torvalds len = req->len - (ptr - req->request.data);
123ae2587e4SJeff Dike printk(KERN_WARNING "%.*s", len, ptr);
1241da177e4SLinus Torvalds mconsole_reply(req, "", 0, 0);
1251da177e4SLinus Torvalds }
1261da177e4SLinus Torvalds
mconsole_proc(struct mc_request * req)1271da177e4SLinus Torvalds void mconsole_proc(struct mc_request *req)
1281da177e4SLinus Torvalds {
12976313c70SEric W. Biederman struct vfsmount *mnt = proc_mnt;
130723a1d77SAl Viro char *buf;
131723a1d77SAl Viro int len;
1321da177e4SLinus Torvalds struct file *file;
133723a1d77SAl Viro int first_chunk = 1;
134723a1d77SAl Viro char *ptr = req->request.data;
1357a501609SAl Viro loff_t pos = 0;
1361da177e4SLinus Torvalds
1371da177e4SLinus Torvalds ptr += strlen("proc");
138e7d2860bSAndré Goddard Rosa ptr = skip_spaces(ptr);
1391da177e4SLinus Torvalds
14076313c70SEric W. Biederman if (!mnt) {
14176313c70SEric W. Biederman mconsole_reply(req, "Proc not available", 1, 0);
14276313c70SEric W. Biederman goto out;
14376313c70SEric W. Biederman }
144ffb37ca3SAl Viro file = file_open_root_mnt(mnt, ptr, O_RDONLY, 0);
1451da177e4SLinus Torvalds if (IS_ERR(file)) {
1461da177e4SLinus Torvalds mconsole_reply(req, "Failed to open file", 1, 0);
147723a1d77SAl Viro printk(KERN_ERR "open /proc/%s: %ld\n", ptr, PTR_ERR(file));
1484ecf09fdSAl Viro goto out;
1491da177e4SLinus Torvalds }
1501da177e4SLinus Torvalds
1511da177e4SLinus Torvalds buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1521da177e4SLinus Torvalds if (buf == NULL) {
1531da177e4SLinus Torvalds mconsole_reply(req, "Failed to allocate buffer", 1, 0);
1541da177e4SLinus Torvalds goto out_fput;
1551da177e4SLinus Torvalds }
1561da177e4SLinus Torvalds
1571da177e4SLinus Torvalds do {
1587a501609SAl Viro len = kernel_read(file, buf, PAGE_SIZE - 1, &pos);
1591da177e4SLinus Torvalds if (len < 0) {
1601da177e4SLinus Torvalds mconsole_reply(req, "Read of file failed", 1, 0);
1611da177e4SLinus Torvalds goto out_free;
1621da177e4SLinus Torvalds }
1631da177e4SLinus Torvalds /* Begin the file content on his own line. */
1641da177e4SLinus Torvalds if (first_chunk) {
1651da177e4SLinus Torvalds mconsole_reply(req, "\n", 0, 1);
1661da177e4SLinus Torvalds first_chunk = 0;
1671da177e4SLinus Torvalds }
1681da177e4SLinus Torvalds buf[len] = '\0';
169723a1d77SAl Viro mconsole_reply(req, buf, 0, (len > 0));
170723a1d77SAl Viro } while (len > 0);
1711da177e4SLinus Torvalds out_free:
1721da177e4SLinus Torvalds kfree(buf);
173723a1d77SAl Viro out_fput:
174723a1d77SAl Viro fput(file);
175723a1d77SAl Viro out: ;
1761da177e4SLinus Torvalds }
1771da177e4SLinus Torvalds
1781da177e4SLinus Torvalds #define UML_MCONSOLE_HELPTEXT \
1791da177e4SLinus Torvalds "Commands: \n\
1801da177e4SLinus Torvalds version - Get kernel version \n\
1811da177e4SLinus Torvalds help - Print this message \n\
1821da177e4SLinus Torvalds halt - Halt UML \n\
1831da177e4SLinus Torvalds reboot - Reboot UML \n\
1841da177e4SLinus Torvalds config <dev>=<config> - Add a new device to UML; \n\
1851da177e4SLinus Torvalds same syntax as command line \n\
1861da177e4SLinus Torvalds config <dev> - Query the configuration of a device \n\
1871da177e4SLinus Torvalds remove <dev> - Remove a device from UML \n\
1881da177e4SLinus Torvalds sysrq <letter> - Performs the SysRq action controlled by the letter \n\
189db805812SJeff Dike cad - invoke the Ctrl-Alt-Del handler \n\
1901da177e4SLinus Torvalds stop - pause the UML; it will do nothing until it receives a 'go' \n\
1911da177e4SLinus Torvalds go - continue the UML after a 'stop' \n\
1921da177e4SLinus Torvalds log <string> - make UML enter <string> into the kernel log\n\
1931da177e4SLinus Torvalds proc <file> - returns the contents of the UML's /proc/<file>\n\
1943eddddcfSJeff Dike stack <pid> - returns the stack of the specified pid\n\
1951da177e4SLinus Torvalds "
1961da177e4SLinus Torvalds
mconsole_help(struct mc_request * req)1971da177e4SLinus Torvalds void mconsole_help(struct mc_request *req)
1981da177e4SLinus Torvalds {
1991da177e4SLinus Torvalds mconsole_reply(req, UML_MCONSOLE_HELPTEXT, 0, 0);
2001da177e4SLinus Torvalds }
2011da177e4SLinus Torvalds
mconsole_halt(struct mc_request * req)2021da177e4SLinus Torvalds void mconsole_halt(struct mc_request *req)
2031da177e4SLinus Torvalds {
2041da177e4SLinus Torvalds mconsole_reply(req, "", 0, 0);
2051da177e4SLinus Torvalds machine_halt();
2061da177e4SLinus Torvalds }
2071da177e4SLinus Torvalds
mconsole_reboot(struct mc_request * req)2081da177e4SLinus Torvalds void mconsole_reboot(struct mc_request *req)
2091da177e4SLinus Torvalds {
2101da177e4SLinus Torvalds mconsole_reply(req, "", 0, 0);
2111da177e4SLinus Torvalds machine_restart(NULL);
2121da177e4SLinus Torvalds }
2131da177e4SLinus Torvalds
mconsole_cad(struct mc_request * req)2141da177e4SLinus Torvalds void mconsole_cad(struct mc_request *req)
2151da177e4SLinus Torvalds {
2161da177e4SLinus Torvalds mconsole_reply(req, "", 0, 0);
2171da177e4SLinus Torvalds ctrl_alt_del();
2181da177e4SLinus Torvalds }
2191da177e4SLinus Torvalds
mconsole_go(struct mc_request * req)2201da177e4SLinus Torvalds void mconsole_go(struct mc_request *req)
2211da177e4SLinus Torvalds {
2221da177e4SLinus Torvalds mconsole_reply(req, "Not stopped", 1, 0);
2231da177e4SLinus Torvalds }
2241da177e4SLinus Torvalds
mconsole_stop(struct mc_request * req)2251da177e4SLinus Torvalds void mconsole_stop(struct mc_request *req)
2261da177e4SLinus Torvalds {
2271a3a6a2aSAnton Ivanov block_signals();
2281da177e4SLinus Torvalds os_set_fd_block(req->originating_fd, 1);
2293a51237dSAl Viro mconsole_reply(req, "stopped", 0, 0);
230cc0be0fbSKarol Swietlicki for (;;) {
231cc0be0fbSKarol Swietlicki if (!mconsole_get_request(req->originating_fd, req))
232cc0be0fbSKarol Swietlicki continue;
2333a51237dSAl Viro if (req->cmd->handler == mconsole_go)
2343a51237dSAl Viro break;
2353a51237dSAl Viro if (req->cmd->handler == mconsole_stop) {
2363a51237dSAl Viro mconsole_reply(req, "Already stopped", 1, 0);
2373a51237dSAl Viro continue;
2383a51237dSAl Viro }
2393a51237dSAl Viro if (req->cmd->handler == mconsole_sysrq) {
2403a51237dSAl Viro struct pt_regs *old_regs;
2413a51237dSAl Viro old_regs = set_irq_regs((struct pt_regs *)&req->regs);
2423a51237dSAl Viro mconsole_sysrq(req);
2433a51237dSAl Viro set_irq_regs(old_regs);
2443a51237dSAl Viro continue;
2453a51237dSAl Viro }
2461da177e4SLinus Torvalds (*req->cmd->handler)(req);
2471da177e4SLinus Torvalds }
2481da177e4SLinus Torvalds os_set_fd_block(req->originating_fd, 0);
2491da177e4SLinus Torvalds mconsole_reply(req, "", 0, 0);
2501a3a6a2aSAnton Ivanov unblock_signals();
2511da177e4SLinus Torvalds }
2521da177e4SLinus Torvalds
25384f48d4fSJeff Dike static DEFINE_SPINLOCK(mc_devices_lock);
25442947cb9SPaolo 'Blaisorblade' Giarrusso static LIST_HEAD(mconsole_devices);
2551da177e4SLinus Torvalds
mconsole_register_dev(struct mc_device * new)2561da177e4SLinus Torvalds void mconsole_register_dev(struct mc_device *new)
2571da177e4SLinus Torvalds {
25884f48d4fSJeff Dike spin_lock(&mc_devices_lock);
25984f48d4fSJeff Dike BUG_ON(!list_empty(&new->list));
2601da177e4SLinus Torvalds list_add(&new->list, &mconsole_devices);
26184f48d4fSJeff Dike spin_unlock(&mc_devices_lock);
2621da177e4SLinus Torvalds }
2631da177e4SLinus Torvalds
mconsole_find_dev(char * name)2641da177e4SLinus Torvalds static struct mc_device *mconsole_find_dev(char *name)
2651da177e4SLinus Torvalds {
2661da177e4SLinus Torvalds struct list_head *ele;
2671da177e4SLinus Torvalds struct mc_device *dev;
2681da177e4SLinus Torvalds
2691da177e4SLinus Torvalds list_for_each(ele, &mconsole_devices) {
2701da177e4SLinus Torvalds dev = list_entry(ele, struct mc_device, list);
2711da177e4SLinus Torvalds if (!strncmp(name, dev->name, strlen(dev->name)))
272ae2587e4SJeff Dike return dev;
2731da177e4SLinus Torvalds }
274ae2587e4SJeff Dike return NULL;
2751da177e4SLinus Torvalds }
2761da177e4SLinus Torvalds
27702dea087SJeff Dike #define UNPLUGGED_PER_PAGE \
27802dea087SJeff Dike ((PAGE_SIZE - sizeof(struct list_head)) / sizeof(unsigned long))
27902dea087SJeff Dike
28002dea087SJeff Dike struct unplugged_pages {
28102dea087SJeff Dike struct list_head list;
28202dea087SJeff Dike void *pages[UNPLUGGED_PER_PAGE];
28302dea087SJeff Dike };
28402dea087SJeff Dike
285e98fa281SDaniel Walker static DEFINE_MUTEX(plug_mem_mutex);
2864dc5a328SXin Gao static unsigned long long unplugged_pages_count;
287c59bce62SJeff Dike static LIST_HEAD(unplugged_pages);
28802dea087SJeff Dike static int unplug_index = UNPLUGGED_PER_PAGE;
28902dea087SJeff Dike
mem_config(char * str,char ** error_out)290f28169d2SJeff Dike static int mem_config(char *str, char **error_out)
29102dea087SJeff Dike {
29202dea087SJeff Dike unsigned long long diff;
29302dea087SJeff Dike int err = -EINVAL, i, add;
29402dea087SJeff Dike char *ret;
29502dea087SJeff Dike
296f28169d2SJeff Dike if (str[0] != '=') {
297f28169d2SJeff Dike *error_out = "Expected '=' after 'mem'";
29802dea087SJeff Dike goto out;
299f28169d2SJeff Dike }
30002dea087SJeff Dike
30102dea087SJeff Dike str++;
30202dea087SJeff Dike if (str[0] == '-')
30302dea087SJeff Dike add = 0;
30402dea087SJeff Dike else if (str[0] == '+') {
30502dea087SJeff Dike add = 1;
30602dea087SJeff Dike }
307f28169d2SJeff Dike else {
308f28169d2SJeff Dike *error_out = "Expected increment to start with '-' or '+'";
309f28169d2SJeff Dike goto out;
310f28169d2SJeff Dike }
31102dea087SJeff Dike
31202dea087SJeff Dike str++;
31302dea087SJeff Dike diff = memparse(str, &ret);
314f28169d2SJeff Dike if (*ret != '\0') {
315f28169d2SJeff Dike *error_out = "Failed to parse memory increment";
31602dea087SJeff Dike goto out;
317f28169d2SJeff Dike }
31802dea087SJeff Dike
31902dea087SJeff Dike diff /= PAGE_SIZE;
32002dea087SJeff Dike
321e98fa281SDaniel Walker mutex_lock(&plug_mem_mutex);
32202dea087SJeff Dike for (i = 0; i < diff; i++) {
32302dea087SJeff Dike struct unplugged_pages *unplugged;
32402dea087SJeff Dike void *addr;
32502dea087SJeff Dike
32602dea087SJeff Dike if (add) {
32702dea087SJeff Dike if (list_empty(&unplugged_pages))
32802dea087SJeff Dike break;
32902dea087SJeff Dike
33002dea087SJeff Dike unplugged = list_entry(unplugged_pages.next,
33102dea087SJeff Dike struct unplugged_pages, list);
33202dea087SJeff Dike if (unplug_index > 0)
33302dea087SJeff Dike addr = unplugged->pages[--unplug_index];
33402dea087SJeff Dike else {
33502dea087SJeff Dike list_del(&unplugged->list);
33602dea087SJeff Dike addr = unplugged;
33702dea087SJeff Dike unplug_index = UNPLUGGED_PER_PAGE;
33802dea087SJeff Dike }
33902dea087SJeff Dike
34002dea087SJeff Dike free_page((unsigned long) addr);
34102dea087SJeff Dike unplugged_pages_count--;
34202dea087SJeff Dike }
34302dea087SJeff Dike else {
34402dea087SJeff Dike struct page *page;
34502dea087SJeff Dike
34602dea087SJeff Dike page = alloc_page(GFP_ATOMIC);
34702dea087SJeff Dike if (page == NULL)
34802dea087SJeff Dike break;
34902dea087SJeff Dike
35002dea087SJeff Dike unplugged = page_address(page);
35102dea087SJeff Dike if (unplug_index == UNPLUGGED_PER_PAGE) {
35202dea087SJeff Dike list_add(&unplugged->list, &unplugged_pages);
35302dea087SJeff Dike unplug_index = 0;
35402dea087SJeff Dike }
35502dea087SJeff Dike else {
35602dea087SJeff Dike struct list_head *entry = unplugged_pages.next;
35702dea087SJeff Dike addr = unplugged;
35802dea087SJeff Dike
35902dea087SJeff Dike unplugged = list_entry(entry,
36002dea087SJeff Dike struct unplugged_pages,
36102dea087SJeff Dike list);
36202dea087SJeff Dike err = os_drop_memory(addr, PAGE_SIZE);
363f28169d2SJeff Dike if (err) {
364ae2587e4SJeff Dike printk(KERN_ERR "Failed to release "
365ae2587e4SJeff Dike "memory - errno = %d\n", err);
366f28169d2SJeff Dike *error_out = "Failed to release memory";
36784f48d4fSJeff Dike goto out_unlock;
368f28169d2SJeff Dike }
369f28169d2SJeff Dike unplugged->pages[unplug_index++] = addr;
37002dea087SJeff Dike }
37102dea087SJeff Dike
37202dea087SJeff Dike unplugged_pages_count++;
37302dea087SJeff Dike }
37402dea087SJeff Dike }
37502dea087SJeff Dike
37602dea087SJeff Dike err = 0;
37784f48d4fSJeff Dike out_unlock:
378e98fa281SDaniel Walker mutex_unlock(&plug_mem_mutex);
37902dea087SJeff Dike out:
38002dea087SJeff Dike return err;
38102dea087SJeff Dike }
38202dea087SJeff Dike
mem_get_config(char * name,char * str,int size,char ** error_out)38302dea087SJeff Dike static int mem_get_config(char *name, char *str, int size, char **error_out)
38402dea087SJeff Dike {
38502dea087SJeff Dike char buf[sizeof("18446744073709551615")];
38602dea087SJeff Dike int len = 0;
38702dea087SJeff Dike
38802dea087SJeff Dike sprintf(buf, "%ld", uml_physmem);
38902dea087SJeff Dike CONFIG_CHUNK(str, size, len, buf, 1);
39002dea087SJeff Dike
39102dea087SJeff Dike return len;
39202dea087SJeff Dike }
39302dea087SJeff Dike
mem_id(char ** str,int * start_out,int * end_out)39402dea087SJeff Dike static int mem_id(char **str, int *start_out, int *end_out)
39502dea087SJeff Dike {
39602dea087SJeff Dike *start_out = 0;
39702dea087SJeff Dike *end_out = 0;
39802dea087SJeff Dike
39902dea087SJeff Dike return 0;
40002dea087SJeff Dike }
40102dea087SJeff Dike
mem_remove(int n,char ** error_out)402f28169d2SJeff Dike static int mem_remove(int n, char **error_out)
40302dea087SJeff Dike {
404f28169d2SJeff Dike *error_out = "Memory doesn't support the remove operation";
40502dea087SJeff Dike return -EBUSY;
40602dea087SJeff Dike }
40702dea087SJeff Dike
40802dea087SJeff Dike static struct mc_device mem_mc = {
40984f48d4fSJeff Dike .list = LIST_HEAD_INIT(mem_mc.list),
41002dea087SJeff Dike .name = "mem",
41102dea087SJeff Dike .config = mem_config,
41202dea087SJeff Dike .get_config = mem_get_config,
41302dea087SJeff Dike .id = mem_id,
41402dea087SJeff Dike .remove = mem_remove,
41502dea087SJeff Dike };
41602dea087SJeff Dike
mem_mc_init(void)41797a1fcbbSJeff Dike static int __init mem_mc_init(void)
41802dea087SJeff Dike {
41902dea087SJeff Dike if (can_drop_memory())
42002dea087SJeff Dike mconsole_register_dev(&mem_mc);
421ae2587e4SJeff Dike else printk(KERN_ERR "Can't release memory to the host - memory "
422ae2587e4SJeff Dike "hotplug won't be supported\n");
42302dea087SJeff Dike return 0;
42402dea087SJeff Dike }
42502dea087SJeff Dike
42602dea087SJeff Dike __initcall(mem_mc_init);
42702dea087SJeff Dike
4281da177e4SLinus Torvalds #define CONFIG_BUF_SIZE 64
4291da177e4SLinus Torvalds
mconsole_get_config(int (* get_config)(char *,char *,int,char **),struct mc_request * req,char * name)4301da177e4SLinus Torvalds static void mconsole_get_config(int (*get_config)(char *, char *, int,
4311da177e4SLinus Torvalds char **),
4321da177e4SLinus Torvalds struct mc_request *req, char *name)
4331da177e4SLinus Torvalds {
4341da177e4SLinus Torvalds char default_buf[CONFIG_BUF_SIZE], *error, *buf;
4351da177e4SLinus Torvalds int n, size;
4361da177e4SLinus Torvalds
4371da177e4SLinus Torvalds if (get_config == NULL) {
4381da177e4SLinus Torvalds mconsole_reply(req, "No get_config routine defined", 1, 0);
4391da177e4SLinus Torvalds return;
4401da177e4SLinus Torvalds }
4411da177e4SLinus Torvalds
4421da177e4SLinus Torvalds error = NULL;
44391b165c0SJeff Dike size = ARRAY_SIZE(default_buf);
4441da177e4SLinus Torvalds buf = default_buf;
4451da177e4SLinus Torvalds
4461da177e4SLinus Torvalds while (1) {
4471da177e4SLinus Torvalds n = (*get_config)(name, buf, size, &error);
4481da177e4SLinus Torvalds if (error != NULL) {
4491da177e4SLinus Torvalds mconsole_reply(req, error, 1, 0);
4501da177e4SLinus Torvalds goto out;
4511da177e4SLinus Torvalds }
4521da177e4SLinus Torvalds
4531da177e4SLinus Torvalds if (n <= size) {
4541da177e4SLinus Torvalds mconsole_reply(req, buf, 0, 0);
4551da177e4SLinus Torvalds goto out;
4561da177e4SLinus Torvalds }
4571da177e4SLinus Torvalds
4581da177e4SLinus Torvalds if (buf != default_buf)
4591da177e4SLinus Torvalds kfree(buf);
4601da177e4SLinus Torvalds
4611da177e4SLinus Torvalds size = n;
4621da177e4SLinus Torvalds buf = kmalloc(size, GFP_KERNEL);
4631da177e4SLinus Torvalds if (buf == NULL) {
4641da177e4SLinus Torvalds mconsole_reply(req, "Failed to allocate buffer", 1, 0);
4651da177e4SLinus Torvalds return;
4661da177e4SLinus Torvalds }
4671da177e4SLinus Torvalds }
4681da177e4SLinus Torvalds out:
4691da177e4SLinus Torvalds if (buf != default_buf)
4701da177e4SLinus Torvalds kfree(buf);
4711da177e4SLinus Torvalds }
4721da177e4SLinus Torvalds
mconsole_config(struct mc_request * req)4731da177e4SLinus Torvalds void mconsole_config(struct mc_request *req)
4741da177e4SLinus Torvalds {
4751da177e4SLinus Torvalds struct mc_device *dev;
476f28169d2SJeff Dike char *ptr = req->request.data, *name, *error_string = "";
4771da177e4SLinus Torvalds int err;
4781da177e4SLinus Torvalds
4791da177e4SLinus Torvalds ptr += strlen("config");
480e7d2860bSAndré Goddard Rosa ptr = skip_spaces(ptr);
4811da177e4SLinus Torvalds dev = mconsole_find_dev(ptr);
4821da177e4SLinus Torvalds if (dev == NULL) {
4831da177e4SLinus Torvalds mconsole_reply(req, "Bad configuration option", 1, 0);
4841da177e4SLinus Torvalds return;
4851da177e4SLinus Torvalds }
4861da177e4SLinus Torvalds
4871da177e4SLinus Torvalds name = &ptr[strlen(dev->name)];
4881da177e4SLinus Torvalds ptr = name;
4891da177e4SLinus Torvalds while ((*ptr != '=') && (*ptr != '\0'))
4901da177e4SLinus Torvalds ptr++;
4911da177e4SLinus Torvalds
4921da177e4SLinus Torvalds if (*ptr == '=') {
493f28169d2SJeff Dike err = (*dev->config)(name, &error_string);
494f28169d2SJeff Dike mconsole_reply(req, error_string, err, 0);
4951da177e4SLinus Torvalds }
4961da177e4SLinus Torvalds else mconsole_get_config(dev->get_config, req, name);
4971da177e4SLinus Torvalds }
4981da177e4SLinus Torvalds
mconsole_remove(struct mc_request * req)4991da177e4SLinus Torvalds void mconsole_remove(struct mc_request *req)
5001da177e4SLinus Torvalds {
5011da177e4SLinus Torvalds struct mc_device *dev;
50229d56cfeSJeff Dike char *ptr = req->request.data, *err_msg = "";
50329d56cfeSJeff Dike char error[256];
50429d56cfeSJeff Dike int err, start, end, n;
5051da177e4SLinus Torvalds
5061da177e4SLinus Torvalds ptr += strlen("remove");
507e7d2860bSAndré Goddard Rosa ptr = skip_spaces(ptr);
5081da177e4SLinus Torvalds dev = mconsole_find_dev(ptr);
5091da177e4SLinus Torvalds if (dev == NULL) {
5101da177e4SLinus Torvalds mconsole_reply(req, "Bad remove option", 1, 0);
5111da177e4SLinus Torvalds return;
5121da177e4SLinus Torvalds }
51329d56cfeSJeff Dike
51429d56cfeSJeff Dike ptr = &ptr[strlen(dev->name)];
51529d56cfeSJeff Dike
51629d56cfeSJeff Dike err = 1;
51729d56cfeSJeff Dike n = (*dev->id)(&ptr, &start, &end);
51829d56cfeSJeff Dike if (n < 0) {
51929d56cfeSJeff Dike err_msg = "Couldn't parse device number";
52029d56cfeSJeff Dike goto out;
52129d56cfeSJeff Dike }
52229d56cfeSJeff Dike else if ((n < start) || (n > end)) {
52329d56cfeSJeff Dike sprintf(error, "Invalid device number - must be between "
52429d56cfeSJeff Dike "%d and %d", start, end);
52529d56cfeSJeff Dike err_msg = error;
52629d56cfeSJeff Dike goto out;
52729d56cfeSJeff Dike }
52829d56cfeSJeff Dike
529f28169d2SJeff Dike err_msg = NULL;
530f28169d2SJeff Dike err = (*dev->remove)(n, &err_msg);
53129d56cfeSJeff Dike switch(err) {
532d40f6d71SJeff Dike case 0:
533d40f6d71SJeff Dike err_msg = "";
534d40f6d71SJeff Dike break;
53529d56cfeSJeff Dike case -ENODEV:
536f28169d2SJeff Dike if (err_msg == NULL)
53729d56cfeSJeff Dike err_msg = "Device doesn't exist";
53829d56cfeSJeff Dike break;
53929d56cfeSJeff Dike case -EBUSY:
540f28169d2SJeff Dike if (err_msg == NULL)
54129d56cfeSJeff Dike err_msg = "Device is currently open";
54229d56cfeSJeff Dike break;
54329d56cfeSJeff Dike default:
54429d56cfeSJeff Dike break;
54529d56cfeSJeff Dike }
54629d56cfeSJeff Dike out:
54729d56cfeSJeff Dike mconsole_reply(req, err_msg, err, 0);
5481da177e4SLinus Torvalds }
5491da177e4SLinus Torvalds
550f92afe56SJeff Dike struct mconsole_output {
551f92afe56SJeff Dike struct list_head list;
552f92afe56SJeff Dike struct mc_request *req;
553f92afe56SJeff Dike };
554f92afe56SJeff Dike
55584f48d4fSJeff Dike static DEFINE_SPINLOCK(client_lock);
5566f517d3fSJeff Dike static LIST_HEAD(clients);
557*32280e83SJustin Stitt static char console_buf[MCONSOLE_MAX_DATA] __nonstring;
5586f517d3fSJeff Dike
console_write(struct console * console,const char * string,unsigned int len)5596f517d3fSJeff Dike static void console_write(struct console *console, const char *string,
56054fa0ba4SJeff Dike unsigned int len)
5616f517d3fSJeff Dike {
5626f517d3fSJeff Dike struct list_head *ele;
5636f517d3fSJeff Dike int n;
5646f517d3fSJeff Dike
5656f517d3fSJeff Dike if (list_empty(&clients))
5666f517d3fSJeff Dike return;
5676f517d3fSJeff Dike
56854fa0ba4SJeff Dike while (len > 0) {
56954fa0ba4SJeff Dike n = min((size_t) len, ARRAY_SIZE(console_buf));
570*32280e83SJustin Stitt memcpy(console_buf, string, n);
5716f517d3fSJeff Dike string += n;
5726f517d3fSJeff Dike len -= n;
5736f517d3fSJeff Dike
5746f517d3fSJeff Dike list_for_each(ele, &clients) {
575f92afe56SJeff Dike struct mconsole_output *entry;
5766f517d3fSJeff Dike
577f92afe56SJeff Dike entry = list_entry(ele, struct mconsole_output, list);
57854fa0ba4SJeff Dike mconsole_reply_len(entry->req, console_buf, n, 0, 1);
5796f517d3fSJeff Dike }
5806f517d3fSJeff Dike }
5816f517d3fSJeff Dike }
5826f517d3fSJeff Dike
5836f517d3fSJeff Dike static struct console mc_console = { .name = "mc",
5846f517d3fSJeff Dike .write = console_write,
585a174b30eSJeff Dike .flags = CON_ENABLED,
5866f517d3fSJeff Dike .index = -1 };
5876f517d3fSJeff Dike
mc_add_console(void)5886f517d3fSJeff Dike static int mc_add_console(void)
5896f517d3fSJeff Dike {
5906f517d3fSJeff Dike register_console(&mc_console);
5916f517d3fSJeff Dike return 0;
5926f517d3fSJeff Dike }
5936f517d3fSJeff Dike
5946f517d3fSJeff Dike late_initcall(mc_add_console);
5956f517d3fSJeff Dike
with_console(struct mc_request * req,void (* proc)(void *),void * arg)5966f517d3fSJeff Dike static void with_console(struct mc_request *req, void (*proc)(void *),
5976f517d3fSJeff Dike void *arg)
5986f517d3fSJeff Dike {
599f92afe56SJeff Dike struct mconsole_output entry;
6006f517d3fSJeff Dike unsigned long flags;
6016f517d3fSJeff Dike
602f92afe56SJeff Dike entry.req = req;
60384f48d4fSJeff Dike spin_lock_irqsave(&client_lock, flags);
6046f517d3fSJeff Dike list_add(&entry.list, &clients);
60584f48d4fSJeff Dike spin_unlock_irqrestore(&client_lock, flags);
6066f517d3fSJeff Dike
6076f517d3fSJeff Dike (*proc)(arg);
6086f517d3fSJeff Dike
60954fa0ba4SJeff Dike mconsole_reply_len(req, "", 0, 0, 0);
6106f517d3fSJeff Dike
61184f48d4fSJeff Dike spin_lock_irqsave(&client_lock, flags);
6126f517d3fSJeff Dike list_del(&entry.list);
61384f48d4fSJeff Dike spin_unlock_irqrestore(&client_lock, flags);
6146f517d3fSJeff Dike }
6156f517d3fSJeff Dike
6164111b025SJeff Dike #ifdef CONFIG_MAGIC_SYSRQ
61754fa0ba4SJeff Dike
61854fa0ba4SJeff Dike #include <linux/sysrq.h>
61954fa0ba4SJeff Dike
sysrq_proc(void * arg)6204111b025SJeff Dike static void sysrq_proc(void *arg)
6214111b025SJeff Dike {
6224111b025SJeff Dike char *op = arg;
623f335397dSDmitry Torokhov handle_sysrq(*op);
6244111b025SJeff Dike }
6254111b025SJeff Dike
mconsole_sysrq(struct mc_request * req)6264111b025SJeff Dike void mconsole_sysrq(struct mc_request *req)
6274111b025SJeff Dike {
6284111b025SJeff Dike char *ptr = req->request.data;
6294111b025SJeff Dike
6304111b025SJeff Dike ptr += strlen("sysrq");
631e7d2860bSAndré Goddard Rosa ptr = skip_spaces(ptr);
6324111b025SJeff Dike
633ae2587e4SJeff Dike /*
634ae2587e4SJeff Dike * With 'b', the system will shut down without a chance to reply,
6354111b025SJeff Dike * so in this case, we reply first.
6364111b025SJeff Dike */
6374111b025SJeff Dike if (*ptr == 'b')
6384111b025SJeff Dike mconsole_reply(req, "", 0, 0);
6394111b025SJeff Dike
6404111b025SJeff Dike with_console(req, sysrq_proc, ptr);
6414111b025SJeff Dike }
6424111b025SJeff Dike #else
mconsole_sysrq(struct mc_request * req)6434111b025SJeff Dike void mconsole_sysrq(struct mc_request *req)
6444111b025SJeff Dike {
6454111b025SJeff Dike mconsole_reply(req, "Sysrq not compiled in", 1, 0);
6464111b025SJeff Dike }
6474111b025SJeff Dike #endif
6484111b025SJeff Dike
stack_proc(void * arg)6496f517d3fSJeff Dike static void stack_proc(void *arg)
6506f517d3fSJeff Dike {
651a1850e9cSRichard Weinberger struct task_struct *task = arg;
6526f517d3fSJeff Dike
6539cb8f069SDmitry Safonov show_stack(task, NULL, KERN_INFO);
6546f517d3fSJeff Dike }
6556f517d3fSJeff Dike
656ae2587e4SJeff Dike /*
657ae2587e4SJeff Dike * Mconsole stack trace
6583eddddcfSJeff Dike * Added by Allan Graves, Jeff Dike
6593eddddcfSJeff Dike * Dumps a stacks registers to the linux console.
6603eddddcfSJeff Dike * Usage stack <pid>.
6613eddddcfSJeff Dike */
mconsole_stack(struct mc_request * req)66242fda663SJeff Dike void mconsole_stack(struct mc_request *req)
6633eddddcfSJeff Dike {
6643eddddcfSJeff Dike char *ptr = req->request.data;
6653eddddcfSJeff Dike int pid_requested= -1;
6663eddddcfSJeff Dike struct task_struct *to = NULL;
6673eddddcfSJeff Dike
668ae2587e4SJeff Dike /*
669ae2587e4SJeff Dike * Would be nice:
6703eddddcfSJeff Dike * 1) Send showregs output to mconsole.
6713eddddcfSJeff Dike * 2) Add a way to stack dump all pids.
6723eddddcfSJeff Dike */
6733eddddcfSJeff Dike
6743eddddcfSJeff Dike ptr += strlen("stack");
675e7d2860bSAndré Goddard Rosa ptr = skip_spaces(ptr);
6763eddddcfSJeff Dike
677ae2587e4SJeff Dike /*
678ae2587e4SJeff Dike * Should really check for multiple pids or reject bad args here
679ae2587e4SJeff Dike */
6803eddddcfSJeff Dike /* What do the arguments in mconsole_reply mean? */
6813eddddcfSJeff Dike if (sscanf(ptr, "%d", &pid_requested) == 0) {
6823eddddcfSJeff Dike mconsole_reply(req, "Please specify a pid", 1, 0);
6833eddddcfSJeff Dike return;
6843eddddcfSJeff Dike }
6853eddddcfSJeff Dike
686827b3f6aSJeff Dike to = find_task_by_pid_ns(pid_requested, &init_pid_ns);
6873eddddcfSJeff Dike if ((to == NULL) || (pid_requested == 0)) {
6883eddddcfSJeff Dike mconsole_reply(req, "Couldn't find that pid", 1, 0);
6893eddddcfSJeff Dike return;
6903eddddcfSJeff Dike }
6916f517d3fSJeff Dike with_console(req, stack_proc, to);
6923eddddcfSJeff Dike }
6933eddddcfSJeff Dike
mount_proc(void)69476313c70SEric W. Biederman static int __init mount_proc(void)
69576313c70SEric W. Biederman {
69676313c70SEric W. Biederman struct file_system_type *proc_fs_type;
69776313c70SEric W. Biederman struct vfsmount *mnt;
69876313c70SEric W. Biederman
69976313c70SEric W. Biederman proc_fs_type = get_fs_type("proc");
70076313c70SEric W. Biederman if (!proc_fs_type)
70176313c70SEric W. Biederman return -ENODEV;
70276313c70SEric W. Biederman
70376313c70SEric W. Biederman mnt = kern_mount(proc_fs_type);
70476313c70SEric W. Biederman put_filesystem(proc_fs_type);
70576313c70SEric W. Biederman if (IS_ERR(mnt))
70676313c70SEric W. Biederman return PTR_ERR(mnt);
70776313c70SEric W. Biederman
70876313c70SEric W. Biederman proc_mnt = mnt;
70976313c70SEric W. Biederman return 0;
71076313c70SEric W. Biederman }
71176313c70SEric W. Biederman
712ae2587e4SJeff Dike /*
713ae2587e4SJeff Dike * Changed by mconsole_setup, which is __setup, and called before SMP is
7141da177e4SLinus Torvalds * active.
7151da177e4SLinus Torvalds */
7161da177e4SLinus Torvalds static char *notify_socket = NULL;
7171da177e4SLinus Torvalds
mconsole_init(void)71897a1fcbbSJeff Dike static int __init mconsole_init(void)
7191da177e4SLinus Torvalds {
7201da177e4SLinus Torvalds /* long to avoid size mismatch warnings from gcc */
7211da177e4SLinus Torvalds long sock;
7221da177e4SLinus Torvalds int err;
72336137120SBalbir Singh char file[UNIX_PATH_MAX];
7241da177e4SLinus Torvalds
72576313c70SEric W. Biederman mount_proc();
72676313c70SEric W. Biederman
727ae2587e4SJeff Dike if (umid_file_name("mconsole", file, sizeof(file)))
728ae2587e4SJeff Dike return -1;
7291da177e4SLinus Torvalds snprintf(mconsole_socket_name, sizeof(file), "%s", file);
7301da177e4SLinus Torvalds
7311da177e4SLinus Torvalds sock = os_create_unix_socket(file, sizeof(file), 1);
7321da177e4SLinus Torvalds if (sock < 0) {
733ae2587e4SJeff Dike printk(KERN_ERR "Failed to initialize management console\n");
734ae2587e4SJeff Dike return 1;
7351da177e4SLinus Torvalds }
736438ee679SJeff Dike if (os_set_fd_block(sock, 0))
737438ee679SJeff Dike goto out;
7381da177e4SLinus Torvalds
7391da177e4SLinus Torvalds register_reboot_notifier(&reboot_notifier);
7401da177e4SLinus Torvalds
7411da177e4SLinus Torvalds err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
742aab94460STheodore Ts'o IRQF_SHARED, "mconsole", (void *)sock);
74336d46a59SJohannes Berg if (err < 0) {
744ae2587e4SJeff Dike printk(KERN_ERR "Failed to get IRQ for management console\n");
745438ee679SJeff Dike goto out;
7461da177e4SLinus Torvalds }
7471da177e4SLinus Torvalds
7481da177e4SLinus Torvalds if (notify_socket != NULL) {
749970d6e3aSJeff Dike notify_socket = kstrdup(notify_socket, GFP_KERNEL);
7501da177e4SLinus Torvalds if (notify_socket != NULL)
7511da177e4SLinus Torvalds mconsole_notify(notify_socket, MCONSOLE_SOCKET,
7521da177e4SLinus Torvalds mconsole_socket_name,
7531da177e4SLinus Torvalds strlen(mconsole_socket_name) + 1);
7541da177e4SLinus Torvalds else printk(KERN_ERR "mconsole_setup failed to strdup "
7551da177e4SLinus Torvalds "string\n");
7561da177e4SLinus Torvalds }
7571da177e4SLinus Torvalds
758ae2587e4SJeff Dike printk(KERN_INFO "mconsole (version %d) initialized on %s\n",
7591da177e4SLinus Torvalds MCONSOLE_VERSION, mconsole_socket_name);
760ae2587e4SJeff Dike return 0;
761438ee679SJeff Dike
762438ee679SJeff Dike out:
763438ee679SJeff Dike os_close_file(sock);
764438ee679SJeff Dike return 1;
7651da177e4SLinus Torvalds }
7661da177e4SLinus Torvalds
7671da177e4SLinus Torvalds __initcall(mconsole_init);
7681da177e4SLinus Torvalds
mconsole_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * pos)7696613c5e8SAlexey Dobriyan static ssize_t mconsole_proc_write(struct file *file,
7706613c5e8SAlexey Dobriyan const char __user *buffer, size_t count, loff_t *pos)
7711da177e4SLinus Torvalds {
7721da177e4SLinus Torvalds char *buf;
7731da177e4SLinus Torvalds
774793b796eSAl Viro buf = memdup_user_nul(buffer, count);
775793b796eSAl Viro if (IS_ERR(buf))
776793b796eSAl Viro return PTR_ERR(buf);
7771da177e4SLinus Torvalds
7781da177e4SLinus Torvalds mconsole_notify(notify_socket, MCONSOLE_USER_NOTIFY, buf, count);
7791da177e4SLinus Torvalds kfree(buf);
780ae2587e4SJeff Dike return count;
7811da177e4SLinus Torvalds }
7821da177e4SLinus Torvalds
78397a32539SAlexey Dobriyan static const struct proc_ops mconsole_proc_ops = {
78497a32539SAlexey Dobriyan .proc_write = mconsole_proc_write,
78597a32539SAlexey Dobriyan .proc_lseek = noop_llseek,
7866613c5e8SAlexey Dobriyan };
7876613c5e8SAlexey Dobriyan
create_proc_mconsole(void)7881da177e4SLinus Torvalds static int create_proc_mconsole(void)
7891da177e4SLinus Torvalds {
7901da177e4SLinus Torvalds struct proc_dir_entry *ent;
7911da177e4SLinus Torvalds
792ae2587e4SJeff Dike if (notify_socket == NULL)
793ae2587e4SJeff Dike return 0;
7941da177e4SLinus Torvalds
79597a32539SAlexey Dobriyan ent = proc_create("mconsole", 0200, NULL, &mconsole_proc_ops);
7961da177e4SLinus Torvalds if (ent == NULL) {
7974554eb90SDavid Howells printk(KERN_INFO "create_proc_mconsole : proc_create failed\n");
798ae2587e4SJeff Dike return 0;
7991da177e4SLinus Torvalds }
800ae2587e4SJeff Dike return 0;
8011da177e4SLinus Torvalds }
8021da177e4SLinus Torvalds
8031da177e4SLinus Torvalds static DEFINE_SPINLOCK(notify_spinlock);
8041da177e4SLinus Torvalds
lock_notify(void)8051da177e4SLinus Torvalds void lock_notify(void)
8061da177e4SLinus Torvalds {
8071da177e4SLinus Torvalds spin_lock(¬ify_spinlock);
8081da177e4SLinus Torvalds }
8091da177e4SLinus Torvalds
unlock_notify(void)8101da177e4SLinus Torvalds void unlock_notify(void)
8111da177e4SLinus Torvalds {
8121da177e4SLinus Torvalds spin_unlock(¬ify_spinlock);
8131da177e4SLinus Torvalds }
8141da177e4SLinus Torvalds
8151da177e4SLinus Torvalds __initcall(create_proc_mconsole);
8161da177e4SLinus Torvalds
817088bec41SJeff Dike #define NOTIFY "notify:"
8181da177e4SLinus Torvalds
mconsole_setup(char * str)8191da177e4SLinus Torvalds static int mconsole_setup(char *str)
8201da177e4SLinus Torvalds {
8211da177e4SLinus Torvalds if (!strncmp(str, NOTIFY, strlen(NOTIFY))) {
8221da177e4SLinus Torvalds str += strlen(NOTIFY);
8231da177e4SLinus Torvalds notify_socket = str;
8241da177e4SLinus Torvalds }
8251da177e4SLinus Torvalds else printk(KERN_ERR "mconsole_setup : Unknown option - '%s'\n", str);
826ae2587e4SJeff Dike return 1;
8271da177e4SLinus Torvalds }
8281da177e4SLinus Torvalds
829088bec41SJeff Dike __setup("mconsole=", mconsole_setup);
8301da177e4SLinus Torvalds
8311da177e4SLinus Torvalds __uml_help(mconsole_setup,
8321da177e4SLinus Torvalds "mconsole=notify:<socket>\n"
8331da177e4SLinus Torvalds " Requests that the mconsole driver send a message to the named Unix\n"
8341da177e4SLinus Torvalds " socket containing the name of the mconsole socket. This also serves\n"
8351da177e4SLinus Torvalds " to notify outside processes when UML has booted far enough to respond\n"
8361da177e4SLinus Torvalds " to mconsole requests.\n\n"
8371da177e4SLinus Torvalds );
8381da177e4SLinus Torvalds
notify_panic(struct notifier_block * self,unsigned long unused1,void * ptr)8391da177e4SLinus Torvalds static int notify_panic(struct notifier_block *self, unsigned long unused1,
8401da177e4SLinus Torvalds void *ptr)
8411da177e4SLinus Torvalds {
8421da177e4SLinus Torvalds char *message = ptr;
8431da177e4SLinus Torvalds
844ae2587e4SJeff Dike if (notify_socket == NULL)
845ae2587e4SJeff Dike return 0;
8461da177e4SLinus Torvalds
8471da177e4SLinus Torvalds mconsole_notify(notify_socket, MCONSOLE_PANIC, message,
8481da177e4SLinus Torvalds strlen(message) + 1);
849758dfdb9SGuilherme G. Piccoli return NOTIFY_DONE;
8501da177e4SLinus Torvalds }
8511da177e4SLinus Torvalds
8521da177e4SLinus Torvalds static struct notifier_block panic_exit_notifier = {
8531da177e4SLinus Torvalds .notifier_call = notify_panic,
854758dfdb9SGuilherme G. Piccoli .priority = INT_MAX, /* run as soon as possible */
8551da177e4SLinus Torvalds };
8561da177e4SLinus Torvalds
add_notifier(void)8571da177e4SLinus Torvalds static int add_notifier(void)
8581da177e4SLinus Torvalds {
859e041c683SAlan Stern atomic_notifier_chain_register(&panic_notifier_list,
860e041c683SAlan Stern &panic_exit_notifier);
861ae2587e4SJeff Dike return 0;
8621da177e4SLinus Torvalds }
8631da177e4SLinus Torvalds
8641da177e4SLinus Torvalds __initcall(add_notifier);
8651da177e4SLinus Torvalds
mconsole_notify_socket(void)8661da177e4SLinus Torvalds char *mconsole_notify_socket(void)
8671da177e4SLinus Torvalds {
868ae2587e4SJeff Dike return notify_socket;
8691da177e4SLinus Torvalds }
8701da177e4SLinus Torvalds
8711da177e4SLinus Torvalds EXPORT_SYMBOL(mconsole_notify_socket);
872