manage.c 5.6 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
	return 0;
}

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

	shutting_down = SHUTDOWN_SUSPEND;

83 84 85 86 87 88
	err = stop_machine_create();
	if (err) {
		printk(KERN_ERR "xen suspend: failed to setup stop_machine %d\n", err);
		goto out;
	}

89 90 91 92 93 94 95
#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);
96
		goto out_destroy_sm;
97 98 99
	}
#endif

100
	err = dpm_suspend_start(PMSG_SUSPEND);
101
	if (err) {
102
		printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
103
		goto out_thaw;
104 105
	}

I
Ian Campbell 已提交
106 107 108
	printk(KERN_DEBUG "suspending xenstore...\n");
	xs_suspend();

109
	err = dpm_suspend_noirq(PMSG_SUSPEND);
110
	if (err) {
111
		printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
112
		goto out_resume;
113 114
	}

115
	err = stop_machine(xen_suspend, &cancelled, cpumask_of(0));
116 117 118

	dpm_resume_noirq(PMSG_RESUME);

119 120
	if (err) {
		printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
121
		cancelled = 1;
122 123
	}

I
Ian Campbell 已提交
124
out_resume:
125 126
	if (!cancelled) {
		xen_arch_resume();
127
		xs_resume();
128
	} else
129
		xs_suspend_cancel();
130

131
	dpm_resume_end(PMSG_RESUME);
132

133 134
	/* Make sure timer events get retriggered on all CPUs */
	clock_was_set();
135 136

out_thaw:
137 138
#ifdef CONFIG_PREEMPT
	thaw_processes();
139 140

out_destroy_sm:
141
#endif
142 143
	stop_machine_destroy();

144
out:
145 146
	shutting_down = SHUTDOWN_INVALID;
}
147
#endif	/* CONFIG_PM_SLEEP */
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179

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 ||
180 181
	    strcmp(str, "halt") == 0) {
		shutting_down = SHUTDOWN_POWEROFF;
182
		orderly_poweroff(false);
183 184
	} else if (strcmp(str, "reboot") == 0) {
		shutting_down = SHUTDOWN_POWEROFF; /* ? */
185
		ctrl_alt_del();
186 187 188 189 190
#ifdef CONFIG_PM_SLEEP
	} else if (strcmp(str, "suspend") == 0) {
		do_suspend();
#endif
	} else {
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 265 266 267 268 269 270 271 272 273 274
		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);