Release 4.10 drivers/xen/manage.c

Directory: drivers/xen
/*
 * Handle extern requests for shutdown, reboot and sysrq
 */


#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/reboot.h>
#include <linux/sysrq.h>
#include <linux/stop_machine.h>
#include <linux/freezer.h>
#include <linux/syscore_ops.h>
#include <linux/export.h>

#include <xen/xen.h>
#include <xen/xenbus.h>
#include <xen/grant_table.h>
#include <xen/events.h>
#include <xen/hvc-console.h>
#include <xen/page.h>
#include <xen/xen-ops.h>

#include <asm/xen/hypercall.h>
#include <asm/xen/hypervisor.h>


enum shutdown_state {
	
SHUTDOWN_INVALID = -1,
	
SHUTDOWN_POWEROFF = 0,
	
SHUTDOWN_SUSPEND = 2,
	/* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
           report a crash, not be instructed to crash!
           HALT is the same as POWEROFF, as far as we're concerned.  The tools use
           the distinction when we return the reason code to them.  */
	 
SHUTDOWN_HALT = 4,
};

/* Ignore multiple shutdown requests. */

static enum shutdown_state shutting_down = SHUTDOWN_INVALID;


struct suspend_info {
	
int cancelled;
};

static RAW_NOTIFIER_HEAD(xen_resume_notifier);



void xen_resume_notifier_register(struct notifier_block *nb)
{
	raw_notifier_chain_register(&xen_resume_notifier, nb);
}
Contributors
Person Tokens Prop Commits CommitProp
stanislaw gruszka stanislaw gruszka 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(xen_resume_notifier_register);



void xen_resume_notifier_unregister(struct notifier_block *nb)
{
	raw_notifier_chain_unregister(&xen_resume_notifier, nb);
}
Contributors
Person Tokens Prop Commits CommitProp
stanislaw gruszka stanislaw gruszka 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister);

#ifdef CONFIG_HIBERNATE_CALLBACKS


static int xen_suspend(void *data)
{
	struct suspend_info *si = data;
	int err;

	BUG_ON(!irqs_disabled());

	err = syscore_suspend();
	if (err) {
		pr_err("%s: system core suspend failed: %d\n", __func__, err);
		return err;
	}

	gnttab_suspend();
	xen_arch_pre_suspend();

	/*
         * This hypercall returns 1 if suspend was cancelled
         * or the domain was merely checkpointed, and 0 if it
         * is resuming in a new domain.
         */
	si->cancelled = HYPERVISOR_suspend(xen_pv_domain()
                                           ? virt_to_gfn(xen_start_info)
                                           : 0);

	xen_arch_post_suspend(si->cancelled);
	gnttab_resume();

	if (!si->cancelled) {
		xen_irq_resume();
		xen_timer_resume();
	}

	syscore_resume();

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 36 34.29% 2 20.00%
rafael j. wysocki rafael j. wysocki 20 19.05% 2 20.00%
david vrabel david vrabel 16 15.24% 1 10.00%
stefano stabellini stefano stabellini 13 12.38% 1 10.00%
ian campbell ian campbell 12 11.43% 1 10.00%
joe perches joe perches 4 3.81% 1 10.00%
isaku yamahata isaku yamahata 3 2.86% 1 10.00%
julien grall julien grall 1 0.95% 1 10.00%
Total 105 100.00% 10 100.00%



static void do_suspend(void)
{
	int err;
	struct suspend_info si;

	shutting_down = SHUTDOWN_SUSPEND;

	err = freeze_processes();
	if (err) {
		pr_err("%s: freeze processes failed %d\n", __func__, err);
		goto out;
	}

	err = freeze_kernel_threads();
	if (err) {
		pr_err("%s: freeze kernel threads failed %d\n", __func__, err);
		goto out_thaw;
	}

	err = dpm_suspend_start(PMSG_FREEZE);
	if (err) {
		pr_err("%s: dpm_suspend_start %d\n", __func__, err);
		goto out_thaw;
	}

	printk(KERN_DEBUG "suspending xenstore...\n");
	xs_suspend();

	err = dpm_suspend_end(PMSG_FREEZE);
	if (err) {
		pr_err("dpm_suspend_end failed: %d\n", err);
		si.cancelled = 0;
		goto out_resume;
	}

	xen_arch_suspend();

	si.cancelled = 1;

	err = stop_machine(xen_suspend, &si, cpumask_of(0));

	/* Resume console as early as possible. */
	if (!si.cancelled)
		xen_console_resume();

	raw_notifier_call_chain(&xen_resume_notifier, 0, NULL);

	dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);

	if (err) {
		pr_err("failed to start xen_suspend: %d\n", err);
		si.cancelled = 1;
	}

	xen_arch_resume();

out_resume:
	if (!si.cancelled)
		xs_resume();
	else
		xs_suspend_cancel();

	dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);

out_thaw:
	thaw_processes();
out:
	shutting_down = SHUTDOWN_INVALID;
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 94 38.52% 2 9.52%
ian campbell ian campbell 37 15.16% 5 23.81%
ross lagerwall ross lagerwall 24 9.84% 1 4.76%
rafael j. wysocki rafael j. wysocki 21 8.61% 2 9.52%
shriram rajagopalan shriram rajagopalan 16 6.56% 1 4.76%
david vrabel david vrabel 11 4.51% 1 4.76%
stanislaw gruszka stanislaw gruszka 10 4.10% 1 4.76%
joe perches joe perches 9 3.69% 1 4.76%
konrad rzeszutek wilk konrad rzeszutek wilk 6 2.46% 1 4.76%
boris ostrovsky boris ostrovsky 6 2.46% 1 4.76%
rusty russell rusty russell 4 1.64% 2 9.52%
stephen rothwell stephen rothwell 2 0.82% 1 4.76%
alan stern alan stern 2 0.82% 1 4.76%
tejun heo tejun heo 2 0.82% 1 4.76%
Total 244 100.00% 21 100.00%

#endif	/* CONFIG_HIBERNATE_CALLBACKS */


struct shutdown_handler {

#define SHUTDOWN_CMD_SIZE 11
	
const char command[SHUTDOWN_CMD_SIZE];
	
bool flag;
	
void (*cb)(void);
};



static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused)
{
	switch (code) {
	case SYS_DOWN:
	case SYS_HALT:
	case SYS_POWER_OFF:
		shutting_down = SHUTDOWN_POWEROFF;
	default:
		break;
	}
	return NOTIFY_DONE;
}
Contributors
Person Tokens Prop Commits CommitProp
konrad rzeszutek wilk konrad rzeszutek wilk 34 79.07% 1 50.00%
ian campbell ian campbell 9 20.93% 1 50.00%
Total 43 100.00% 2 100.00%



static void do_poweroff(void)
{
	switch (system_state) {
	case SYSTEM_BOOTING:
		orderly_poweroff(true);
		break;
	case SYSTEM_RUNNING:
		orderly_poweroff(false);
		break;
	default:
		/* Don't do it when we are halting/rebooting. */
		pr_info("Ignoring Xen toolstack shutdown.\n");
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
konrad rzeszutek wilk konrad rzeszutek wilk 34 85.00% 1 50.00%
ian campbell ian campbell 6 15.00% 1 50.00%
Total 40 100.00% 2 100.00%



static void do_reboot(void)
{
	shutting_down = SHUTDOWN_POWEROFF; /* ? */
	ctrl_alt_del();
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


static struct shutdown_handler shutdown_handlers[] = {
	{ "poweroff",	true,	do_poweroff },
	{ "halt",	false,	do_poweroff },
	{ "reboot",	true,	do_reboot   },
#ifdef CONFIG_HIBERNATE_CALLBACKS
	{ "suspend",	true,	do_suspend  },
#endif
};



static void shutdown_handler(struct xenbus_watch *watch,
			     const char **vec, unsigned int len)
{
	char *str;
	struct xenbus_transaction xbt;
	int err;
	int idx;

	if (shutting_down != SHUTDOWN_INVALID)
		return;

 again:
	err = xenbus_transaction_start(&xbt);
	if (err)
		return;

	str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
	/* Ignore read errors and empty reads. */
	if (XENBUS_IS_ERR_READ(str)) {
		xenbus_transaction_end(xbt, 1);
		return;
	}

	for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
		if (strcmp(str, shutdown_handlers[idx].command) == 0)
			break;
	}

	/* Only acknowledge commands which we are prepared to handle. */
	if (idx < ARRAY_SIZE(shutdown_handlers))
		xenbus_write(xbt, "control", "shutdown", "");

	err = xenbus_transaction_end(xbt, 0);
	if (err == -EAGAIN) {
		kfree(str);
		goto again;
	}

	if (idx < ARRAY_SIZE(shutdown_handlers)) {
		shutdown_handlers[idx].cb();
	} else {
		pr_info("Ignoring shutdown request: %s\n", str);
		shutting_down = SHUTDOWN_INVALID;
	}

	kfree(str);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 120 56.60% 2 40.00%
juergen gross juergen gross 60 28.30% 1 20.00%
ian campbell ian campbell 31 14.62% 1 20.00%
joe perches joe perches 1 0.47% 1 20.00%
Total 212 100.00% 5 100.00%

#ifdef CONFIG_MAGIC_SYSRQ


static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
			  unsigned int len)
{
	char sysrq_key = '\0';
	struct xenbus_transaction xbt;
	int err;

 again:
	err = xenbus_transaction_start(&xbt);
	if (err)
		return;
	if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
		pr_err("Unable to read sysrq code in control/sysrq\n");
		xenbus_transaction_end(xbt, 1);
		return;
	}

	if (sysrq_key != '\0')
		xenbus_printf(xbt, "control", "sysrq", "%c", '\0');

	err = xenbus_transaction_end(xbt, 0);
	if (err == -EAGAIN)
		goto again;

	if (sysrq_key != '\0')
		handle_sysrq(sysrq_key);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 127 98.45% 1 50.00%
joe perches joe perches 2 1.55% 1 50.00%
Total 129 100.00% 2 100.00%


static struct xenbus_watch sysrq_watch = {
	.node = "control/sysrq",
	.callback = sysrq_handler
};
#endif


static struct xenbus_watch shutdown_watch = {
	.node = "control/shutdown",
	.callback = shutdown_handler
};


static struct notifier_block xen_reboot_nb = {
	.notifier_call = poweroff_nb,
};



static int setup_shutdown_watcher(void)
{
	int err;
	int idx;

#define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))
	char node[FEATURE_PATH_SIZE];

	err = register_xenbus_watch(&shutdown_watch);
	if (err) {
		pr_err("Failed to set shutdown watcher\n");
		return err;
	}


#ifdef CONFIG_MAGIC_SYSRQ
	err = register_xenbus_watch(&sysrq_watch);
	if (err) {
		pr_err("Failed to set sysrq watcher\n");
		return err;
	}
#endif

	for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
		if (!shutdown_handlers[idx].flag)
			continue;
		snprintf(node, FEATURE_PATH_SIZE, "feature-%s",
			 shutdown_handlers[idx].command);
		xenbus_printf(XBT_NIL, "control", node, "%u", 1);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
juergen gross juergen gross 71 52.99% 1 25.00%
jeremy fitzhardinge jeremy fitzhardinge 56 41.79% 1 25.00%
randy dunlap randy dunlap 5 3.73% 1 25.00%
joe perches joe perches 2 1.49% 1 25.00%
Total 134 100.00% 4 100.00%



static int shutdown_event(struct notifier_block *notifier,
			  unsigned long event,
			  void *data)
{
	setup_shutdown_watcher();
	return NOTIFY_DONE;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



int xen_setup_shutdown_event(void)
{
	static struct notifier_block xenstore_notifier = {
		.notifier_call = shutdown_event
	};

	if (!xen_domain())
		return -ENODEV;
	register_xenstore_notifier(&xenstore_notifier);
	register_reboot_notifier(&xen_reboot_nb);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 26 59.09% 1 25.00%
stefano stabellini stefano stabellini 12 27.27% 2 50.00%
konrad rzeszutek wilk konrad rzeszutek wilk 6 13.64% 1 25.00%
Total 44 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);


subsys_initcall(xen_setup_shutdown_event);
Overall Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 585 45.53% 5 12.20%
ian campbell ian campbell 173 13.46% 6 14.63%
juergen gross juergen gross 150 11.67% 1 2.44%
konrad rzeszutek wilk konrad rzeszutek wilk 92 7.16% 2 4.88%
stanislaw gruszka stanislaw gruszka 62 4.82% 1 2.44%
rafael j. wysocki rafael j. wysocki 46 3.58% 5 12.20%
stefano stabellini stefano stabellini 40 3.11% 4 9.76%
david vrabel david vrabel 27 2.10% 2 4.88%
joe perches joe perches 25 1.95% 1 2.44%
ross lagerwall ross lagerwall 24 1.87% 1 2.44%
randy dunlap randy dunlap 16 1.25% 1 2.44%
shriram rajagopalan shriram rajagopalan 16 1.25% 1 2.44%
boris ostrovsky boris ostrovsky 6 0.47% 1 2.44%
tejun heo tejun heo 5 0.39% 2 4.88%
rusty russell rusty russell 4 0.31% 2 4.88%
julien grall julien grall 4 0.31% 2 4.88%
paul gortmaker paul gortmaker 3 0.23% 1 2.44%
isaku yamahata isaku yamahata 3 0.23% 1 2.44%
stephen rothwell stephen rothwell 2 0.16% 1 2.44%
alan stern alan stern 2 0.16% 1 2.44%
Total 1285 100.00% 41 100.00%
Directory: drivers/xen

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
stanislaw gruszka	stanislaw gruszka	18	100.00%	1	100.00%
	Total	18	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 drivers/xen/manage.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
