manage.c 5.4 KB
Newer Older
1 2 3 4 5
/*
 * Handle extern requests for shutdown, reboot and sysrq
 */
#include <linux/kernel.h>
#include <linux/err.h>
6
#include <linux/slab.h>
7 8
#include <linux/reboot.h>
#include <linux/sysrq.h>
9 10
#include <linux/stop_machine.h>
#include <linux/freezer.h>
11 12

#include <xen/xenbus.h>
13 14 15 16
#include <xen/grant_table.h>
#include <xen/events.h>
#include <xen/hvc-console.h>
#include <xen/xen-ops.h>
17

18 19 20 21 22 23 24 25 26 27 28 29 30
#include <asm/xen/hypercall.h>
#include <asm/xen/page.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,
};
31 32

/* Ignore multiple shutdown requests. */
33 34
static enum shutdown_state shutting_down = SHUTDOWN_INVALID;

35
#ifdef CONFIG_PM_SLEEP
36 37 38
static int xen_suspend(void *data)
{
	int *cancelled = data;
39
	int err;
40 41 42

	BUG_ON(!irqs_disabled());

43 44 45 46 47 48
	err = sysdev_suspend(PMSG_SUSPEND);
	if (err) {
		printk(KERN_ERR "xen_suspend: sysdev_suspend failed: %d\n",
			err);
		return err;
	}
49

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
	xen_mm_pin_all();
	gnttab_suspend();
	xen_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.
	 */
	*cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));

	xen_post_suspend(*cancelled);
	gnttab_resume();
	xen_mm_unpin_all();

	if (!*cancelled) {
		xen_irq_resume();
		xen_console_resume();
68
		xen_timer_resume();
69 70
	}

71 72
	sysdev_resume();

73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
	return 0;
}

static void do_suspend(void)
{
	int err;
	int cancelled = 1;

	shutting_down = SHUTDOWN_SUSPEND;

#ifdef CONFIG_PREEMPT
	/* If the kernel is preemptible, we need to freeze all the processes
	   to prevent them from being in the middle of a pagetable update
	   during suspend. */
	err = freeze_processes();
	if (err) {
		printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
90
		goto out;
91 92 93
	}
#endif

94
	err = dpm_suspend_start(PMSG_SUSPEND);
95
	if (err) {
96
		printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
97
		goto out_thaw;
98 99
	}

I
Ian Campbell 已提交
100 101 102
	printk(KERN_DEBUG "suspending xenstore...\n");
	xs_suspend();

103
	err = dpm_suspend_noirq(PMSG_SUSPEND);
104
	if (err) {
105
		printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
106
		goto out_resume;
107 108
	}

109
	err = stop_machine(xen_suspend, &cancelled, cpumask_of(0));
110 111 112

	dpm_resume_noirq(PMSG_RESUME);

113 114
	if (err) {
		printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
115
		cancelled = 1;
116 117
	}

I
Ian Campbell 已提交
118
out_resume:
119 120
	if (!cancelled) {
		xen_arch_resume();
121
		xs_resume();
122
	} else
123
		xs_suspend_cancel();
124

125
	dpm_resume_end(PMSG_RESUME);
126

127 128
	/* Make sure timer events get retriggered on all CPUs */
	clock_was_set();
129 130

out_thaw:
131 132
#ifdef CONFIG_PREEMPT
	thaw_processes();
133
out:
134
#endif
135 136
	shutting_down = SHUTDOWN_INVALID;
}
137
#endif	/* CONFIG_PM_SLEEP */
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169

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

	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;
	}

	xenbus_write(xbt, "control", "shutdown", "");

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

	if (strcmp(str, "poweroff") == 0 ||
170 171
	    strcmp(str, "halt") == 0) {
		shutting_down = SHUTDOWN_POWEROFF;
172
		orderly_poweroff(false);
173 174
	} else if (strcmp(str, "reboot") == 0) {
		shutting_down = SHUTDOWN_POWEROFF; /* ? */
175
		ctrl_alt_del();
176 177 178 179 180
#ifdef CONFIG_PM_SLEEP
	} else if (strcmp(str, "suspend") == 0) {
		do_suspend();
#endif
	} else {
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
		printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
		shutting_down = SHUTDOWN_INVALID;
	}

	kfree(str);
}

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)) {
		printk(KERN_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, NULL);
}

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

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

static int setup_shutdown_watcher(void)
{
	int err;

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

	err = register_xenbus_watch(&sysrq_watch);
	if (err) {
		printk(KERN_ERR "Failed to set sysrq watcher\n");
		return err;
	}

	return 0;
}

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

static int __init setup_shutdown_event(void)
{
	static struct notifier_block xenstore_notifier = {
		.notifier_call = shutdown_event
	};
	register_xenstore_notifier(&xenstore_notifier);

	return 0;
}

subsys_initcall(setup_shutdown_event);