blob: 30ac05a8d28f71cacbdf70c9c94e559f91671ff0 [file] [log] [blame]
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -07001/*
2 * Machine specific setup for xen
3 *
4 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
5 */
6
7#include <linux/module.h>
8#include <linux/sched.h>
9#include <linux/mm.h>
10#include <linux/pm.h>
Yinghai Lua9ce6bc2010-08-25 13:39:17 -070011#include <linux/memblock.h>
Len Brownd91ee582011-04-01 18:28:35 -040012#include <linux/cpuidle.h>
Konrad Rzeszutek Wilk48cdd822012-03-13 20:06:57 -040013#include <linux/cpufreq.h>
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070014
15#include <asm/elf.h>
Roland McGrath6c3652e2008-01-30 13:30:42 +010016#include <asm/vdso.h>
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070017#include <asm/e820.h>
18#include <asm/setup.h>
Jeremy Fitzhardingeb792c752008-06-16 14:54:49 -070019#include <asm/acpi.h>
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070020#include <asm/xen/hypervisor.h>
21#include <asm/xen/hypercall.h>
22
Ian Campbell45263cb2010-10-25 16:32:29 -070023#include <xen/xen.h>
Jeremy Fitzhardinge8006ec32008-05-26 23:31:19 +010024#include <xen/page.h>
Jeremy Fitzhardingee2a81ba2008-03-17 16:37:17 -070025#include <xen/interface/callback.h>
Ian Campbell35ae11f2009-02-06 19:09:48 -080026#include <xen/interface/memory.h>
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070027#include <xen/interface/physdev.h>
28#include <xen/features.h>
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070029#include "xen-ops.h"
Roland McGrathd2eea682007-07-20 00:31:43 -070030#include "vdso.h"
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070031
32/* These are code, but not functions. Defined in entry.S */
33extern const char xen_hypervisor_callback[];
34extern const char xen_failsafe_callback[];
Tejf63c2f22008-12-16 11:56:06 -080035extern void xen_sysenter_target(void);
36extern void xen_syscall_target(void);
37extern void xen_syscall32_target(void);
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -070038
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070039/* Amount of extra memory space we add to the e820 ranges */
David Vrabel8b5d44a2011-09-28 17:46:34 +010040struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070041
David Vrabelaa244112011-09-28 17:46:32 +010042/* Number of pages released from the initial allocation. */
43unsigned long xen_released_pages;
44
Jeremy Fitzhardinge698bb8d2010-09-14 10:19:14 -070045/*
46 * The maximum amount of extra memory compared to the base size. The
47 * main scaling factor is the size of struct page. At extreme ratios
48 * of base:extra, all the base memory can be filled with page
49 * structures for the extra memory, leaving no space for anything
50 * else.
51 *
52 * 10x seems like a reasonable balance between scaling flexibility and
53 * leaving a practically usable system.
54 */
55#define EXTRA_MEM_RATIO (10)
56
David Vrabeldc91c722011-09-29 12:26:19 +010057static void __init xen_add_extra_mem(u64 start, u64 size)
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070058{
Konrad Rzeszutek Wilk6eaa4122011-01-18 20:09:41 -050059 unsigned long pfn;
David Vrabeldc91c722011-09-29 12:26:19 +010060 int i;
Konrad Rzeszutek Wilk6eaa4122011-01-18 20:09:41 -050061
David Vrabeldc91c722011-09-29 12:26:19 +010062 for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) {
63 /* Add new region. */
64 if (xen_extra_mem[i].size == 0) {
65 xen_extra_mem[i].start = start;
66 xen_extra_mem[i].size = size;
67 break;
68 }
69 /* Append to existing region. */
70 if (xen_extra_mem[i].start + xen_extra_mem[i].size == start) {
71 xen_extra_mem[i].size += size;
72 break;
73 }
74 }
75 if (i == XEN_EXTRA_MEM_MAX_REGIONS)
76 printk(KERN_WARNING "Warning: not enough extra memory regions\n");
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070077
Tejun Heod4bbf7e2011-11-28 09:46:22 -080078 memblock_reserve(start, size);
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070079
David Vrabeldc91c722011-09-29 12:26:19 +010080 xen_max_p2m_pfn = PFN_DOWN(start + size);
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070081
David Vrabeldc91c722011-09-29 12:26:19 +010082 for (pfn = PFN_DOWN(start); pfn <= xen_max_p2m_pfn; pfn++)
Konrad Rzeszutek Wilk6eaa4122011-01-18 20:09:41 -050083 __set_phys_to_machine(pfn, INVALID_P2M_ENTRY);
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -070084}
85
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -040086static unsigned long __init xen_do_chunk(unsigned long start,
87 unsigned long end, bool release)
Miroslav Rezanina093d7b42009-09-16 03:56:17 -040088{
89 struct xen_memory_reservation reservation = {
90 .address_bits = 0,
91 .extent_order = 0,
92 .domid = DOMID_SELF
93 };
Jeremy Fitzhardingef89e0482009-09-16 12:38:33 -070094 unsigned long len = 0;
Miroslav Rezanina093d7b42009-09-16 03:56:17 -040095 unsigned long pfn;
96 int ret;
97
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -040098 for (pfn = start; pfn < end; pfn++) {
99 unsigned long frame;
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400100 unsigned long mfn = pfn_to_mfn(pfn);
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400101
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400102 if (release) {
103 /* Make sure pfn exists to start with */
104 if (mfn == INVALID_P2M_ENTRY || mfn_to_pfn(mfn) != pfn)
105 continue;
106 frame = mfn;
107 } else {
108 if (mfn != INVALID_P2M_ENTRY)
109 continue;
110 frame = pfn;
111 }
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400112 set_xen_guest_handle(reservation.extent_start, &frame);
113 reservation.nr_extents = 1;
114
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400115 ret = HYPERVISOR_memory_op(release ? XENMEM_decrease_reservation : XENMEM_populate_physmap,
116 &reservation);
117 WARN(ret != 1, "Failed to %s pfn %lx err=%d\n",
118 release ? "release" : "populate", pfn, ret);
119
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400120 if (ret == 1) {
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400121 if (!early_set_phys_to_machine(pfn, release ? INVALID_P2M_ENTRY : frame)) {
122 if (release)
123 break;
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400124 set_xen_guest_handle(reservation.extent_start, &frame);
125 reservation.nr_extents = 1;
126 ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400127 &reservation);
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400128 break;
129 }
130 len++;
131 } else
132 break;
133 }
134 if (len)
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400135 printk(KERN_INFO "%s %lx-%lx pfn range: %lu pages %s\n",
136 release ? "Freeing" : "Populating",
137 start, end, len,
138 release ? "freed" : "added");
139
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400140 return len;
141}
142static unsigned long __init xen_populate_chunk(
143 const struct e820entry *list, size_t map_size,
144 unsigned long max_pfn, unsigned long *last_pfn,
145 unsigned long credits_left)
146{
147 const struct e820entry *entry;
148 unsigned int i;
149 unsigned long done = 0;
150 unsigned long dest_pfn;
151
152 for (i = 0, entry = list; i < map_size; i++, entry++) {
153 unsigned long credits = credits_left;
154 unsigned long s_pfn;
155 unsigned long e_pfn;
156 unsigned long pfns;
157 long capacity;
158
159 if (credits <= 0)
160 break;
161
162 if (entry->type != E820_RAM)
163 continue;
164
165 e_pfn = PFN_UP(entry->addr + entry->size);
166
167 /* We only care about E820 after the xen_start_info->nr_pages */
168 if (e_pfn <= max_pfn)
169 continue;
170
171 s_pfn = PFN_DOWN(entry->addr);
172 /* If the E820 falls within the nr_pages, we want to start
173 * at the nr_pages PFN.
174 * If that would mean going past the E820 entry, skip it
175 */
176 if (s_pfn <= max_pfn) {
177 capacity = e_pfn - max_pfn;
178 dest_pfn = max_pfn;
179 } else {
180 /* last_pfn MUST be within E820_RAM regions */
181 if (*last_pfn && e_pfn >= *last_pfn)
182 s_pfn = *last_pfn;
183 capacity = e_pfn - s_pfn;
184 dest_pfn = s_pfn;
185 }
186 /* If we had filled this E820_RAM entry, go to the next one. */
187 if (capacity <= 0)
188 continue;
189
190 if (credits > capacity)
191 credits = capacity;
192
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400193 pfns = xen_do_chunk(dest_pfn, dest_pfn + credits, false);
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400194 done += pfns;
195 credits_left -= pfns;
196 *last_pfn = (dest_pfn + pfns);
197 }
198 return done;
199}
David Vrabelf3f436e2011-09-28 17:46:36 +0100200static unsigned long __init xen_set_identity_and_release(
201 const struct e820entry *list, size_t map_size, unsigned long nr_pages)
Miroslav Rezanina093d7b42009-09-16 03:56:17 -0400202{
David Vrabelf3f436e2011-09-28 17:46:36 +0100203 phys_addr_t start = 0;
Miroslav Rezanina093d7b42009-09-16 03:56:17 -0400204 unsigned long released = 0;
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500205 unsigned long identity = 0;
David Vrabelf3f436e2011-09-28 17:46:36 +0100206 const struct e820entry *entry;
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500207 int i;
208
David Vrabelf3f436e2011-09-28 17:46:36 +0100209 /*
210 * Combine non-RAM regions and gaps until a RAM region (or the
211 * end of the map) is reached, then set the 1:1 map and
212 * release the pages (if available) in those non-RAM regions.
213 *
214 * The combined non-RAM regions are rounded to a whole number
215 * of pages so any partial pages are accessible via the 1:1
216 * mapping. This is needed for some BIOSes that put (for
217 * example) the DMI tables in a reserved region that begins on
218 * a non-page boundary.
219 */
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500220 for (i = 0, entry = list; i < map_size; i++, entry++) {
David Vrabelf3f436e2011-09-28 17:46:36 +0100221 phys_addr_t end = entry->addr + entry->size;
David Vrabelf3f436e2011-09-28 17:46:36 +0100222 if (entry->type == E820_RAM || i == map_size - 1) {
223 unsigned long start_pfn = PFN_DOWN(start);
224 unsigned long end_pfn = PFN_UP(end);
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500225
David Vrabelf3f436e2011-09-28 17:46:36 +0100226 if (entry->type == E820_RAM)
227 end_pfn = PFN_UP(entry->addr);
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500228
David Vrabelf3f436e2011-09-28 17:46:36 +0100229 if (start_pfn < end_pfn) {
230 if (start_pfn < nr_pages)
Konrad Rzeszutek Wilk96dc08b2012-04-06 16:10:20 -0400231 released += xen_do_chunk(
232 start_pfn, min(end_pfn, nr_pages), true);
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500233
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500234 identity += set_phys_range_identity(
David Vrabelf3f436e2011-09-28 17:46:36 +0100235 start_pfn, end_pfn);
236 }
237 start = end;
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500238 }
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500239 }
David Vrabelf3f436e2011-09-28 17:46:36 +0100240
Konrad Rzeszutek Wilkca118232012-03-30 15:37:07 -0400241 if (released)
242 printk(KERN_INFO "Released %lu pages of unused memory\n", released);
243 if (identity)
244 printk(KERN_INFO "Set %ld page(s) to 1-1 mapping\n", identity);
David Vrabelf3f436e2011-09-28 17:46:36 +0100245
246 return released;
Konrad Rzeszutek Wilk68df0da2011-02-01 17:15:30 -0500247}
David Vrabeld312ae872011-08-19 15:57:16 +0100248
249static unsigned long __init xen_get_max_pages(void)
250{
251 unsigned long max_pages = MAX_DOMAIN_PAGES;
252 domid_t domid = DOMID_SELF;
253 int ret;
254
Ian Campbelld3db7282011-12-14 12:16:08 +0000255 /*
256 * For the initial domain we use the maximum reservation as
257 * the maximum page.
258 *
259 * For guest domains the current maximum reservation reflects
260 * the current maximum rather than the static maximum. In this
261 * case the e820 map provided to us will cover the static
262 * maximum region.
263 */
264 if (xen_initial_domain()) {
265 ret = HYPERVISOR_memory_op(XENMEM_maximum_reservation, &domid);
266 if (ret > 0)
267 max_pages = ret;
268 }
269
David Vrabeld312ae872011-08-19 15:57:16 +0100270 return min(max_pages, MAX_DOMAIN_PAGES);
271}
272
David Vrabeldc91c722011-09-29 12:26:19 +0100273static void xen_align_and_add_e820_region(u64 start, u64 size, int type)
274{
275 u64 end = start + size;
276
277 /* Align RAM regions to page boundaries. */
278 if (type == E820_RAM) {
279 start = PAGE_ALIGN(start);
280 end &= ~((u64)PAGE_SIZE - 1);
281 }
282
283 e820_add_region(start, end - start, type);
284}
285
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700286/**
287 * machine_specific_memory_setup - Hook for machine specific memory setup.
288 **/
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700289char * __init xen_memory_setup(void)
290{
Ian Campbell35ae11f2009-02-06 19:09:48 -0800291 static struct e820entry map[E820MAX] __initdata;
292
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700293 unsigned long max_pfn = xen_start_info->nr_pages;
Ian Campbell35ae11f2009-02-06 19:09:48 -0800294 unsigned long long mem_end;
295 int rc;
296 struct xen_memory_map memmap;
David Vrabeldc91c722011-09-29 12:26:19 +0100297 unsigned long max_pages;
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400298 unsigned long last_pfn = 0;
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -0700299 unsigned long extra_pages = 0;
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400300 unsigned long populated;
Ian Campbell35ae11f2009-02-06 19:09:48 -0800301 int i;
Ian Campbell9e9a5fc2010-09-02 16:16:00 +0100302 int op;
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700303
Jeremy Fitzhardinge8006ec32008-05-26 23:31:19 +0100304 max_pfn = min(MAX_DOMAIN_PAGES, max_pfn);
Ian Campbell35ae11f2009-02-06 19:09:48 -0800305 mem_end = PFN_PHYS(max_pfn);
306
307 memmap.nr_entries = E820MAX;
308 set_xen_guest_handle(memmap.buffer, map);
309
Ian Campbell9e9a5fc2010-09-02 16:16:00 +0100310 op = xen_initial_domain() ?
311 XENMEM_machine_memory_map :
312 XENMEM_memory_map;
313 rc = HYPERVISOR_memory_op(op, &memmap);
Ian Campbell35ae11f2009-02-06 19:09:48 -0800314 if (rc == -ENOSYS) {
Ian Campbell9ec23a7f2010-10-28 11:32:29 -0700315 BUG_ON(xen_initial_domain());
Ian Campbell35ae11f2009-02-06 19:09:48 -0800316 memmap.nr_entries = 1;
317 map[0].addr = 0ULL;
318 map[0].size = mem_end;
319 /* 8MB slack (to balance backend allocations). */
320 map[0].size += 8ULL << 20;
321 map[0].type = E820_RAM;
322 rc = 0;
323 }
324 BUG_ON(rc);
Jeremy Fitzhardinge8006ec32008-05-26 23:31:19 +0100325
David Vrabeldc91c722011-09-29 12:26:19 +0100326 /* Make sure the Xen-supplied memory map is well-ordered. */
327 sanitize_e820_map(map, memmap.nr_entries, &memmap.nr_entries);
Jeremy Fitzhardingebe5bf9f2008-06-16 14:54:46 -0700328
David Vrabeldc91c722011-09-29 12:26:19 +0100329 max_pages = xen_get_max_pages();
330 if (max_pages > max_pfn)
331 extra_pages += max_pages - max_pfn;
Stefano Stabellini7cb31b72011-01-27 10:13:25 -0500332
David Vrabelf3f436e2011-09-28 17:46:36 +0100333 /*
334 * Set P2M for all non-RAM pages and E820 gaps to be identity
335 * type PFNs. Any RAM pages that would be made inaccesible by
336 * this are first released.
337 */
338 xen_released_pages = xen_set_identity_and_release(
339 map, memmap.nr_entries, max_pfn);
Jeremy Fitzhardinge42ee1472010-08-30 16:41:02 -0700340
David Vrabeldc91c722011-09-29 12:26:19 +0100341 /*
Konrad Rzeszutek Wilk2e2fb752012-04-06 10:07:11 -0400342 * Populate back the non-RAM pages and E820 gaps that had been
343 * released. */
344 populated = xen_populate_chunk(map, memmap.nr_entries,
345 max_pfn, &last_pfn, xen_released_pages);
346
347 extra_pages += (xen_released_pages - populated);
348
349 if (last_pfn > max_pfn) {
350 max_pfn = min(MAX_DOMAIN_PAGES, last_pfn);
351 mem_end = PFN_PHYS(max_pfn);
352 }
353 /*
David Vrabeldc91c722011-09-29 12:26:19 +0100354 * Clamp the amount of extra memory to a EXTRA_MEM_RATIO
355 * factor the base size. On non-highmem systems, the base
356 * size is the full initial memory allocation; on highmem it
357 * is limited to the max size of lowmem, so that it doesn't
358 * get completely filled.
359 *
360 * In principle there could be a problem in lowmem systems if
361 * the initial memory is also very large with respect to
362 * lowmem, but we won't try to deal with that here.
363 */
364 extra_pages = min(EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)),
365 extra_pages);
David Vrabeldc91c722011-09-29 12:26:19 +0100366 i = 0;
367 while (i < memmap.nr_entries) {
368 u64 addr = map[i].addr;
369 u64 size = map[i].size;
370 u32 type = map[i].type;
371
372 if (type == E820_RAM) {
373 if (addr < mem_end) {
374 size = min(size, mem_end - addr);
375 } else if (extra_pages) {
376 size = min(size, (u64)extra_pages * PAGE_SIZE);
377 extra_pages -= size / PAGE_SIZE;
378 xen_add_extra_mem(addr, size);
379 } else
380 type = E820_UNUSABLE;
Jeremy Fitzhardinge36545812010-09-29 16:54:33 -0700381 }
382
David Vrabeldc91c722011-09-29 12:26:19 +0100383 xen_align_and_add_e820_region(addr, size, type);
Jeremy Fitzhardingeb5b43ce2010-09-02 17:10:12 -0700384
David Vrabeldc91c722011-09-29 12:26:19 +0100385 map[i].addr += size;
386 map[i].size -= size;
387 if (map[i].size == 0)
388 i++;
Ian Campbell35ae11f2009-02-06 19:09:48 -0800389 }
Jeremy Fitzhardingeb792c752008-06-16 14:54:49 -0700390
391 /*
Ian Campbell9ec23a7f2010-10-28 11:32:29 -0700392 * In domU, the ISA region is normal, usable memory, but we
393 * reserve ISA memory anyway because too many things poke
Jeremy Fitzhardingeb792c752008-06-16 14:54:49 -0700394 * about in there.
395 */
396 e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS,
397 E820_RESERVED);
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700398
Jeremy Fitzhardingebe5bf9f2008-06-16 14:54:46 -0700399 /*
400 * Reserve Xen bits:
401 * - mfn_list
402 * - xen_start_info
403 * See comment above "struct start_info" in <xen/interface/xen.h>
404 */
Tejun Heo24aa0782011-07-12 11:16:06 +0200405 memblock_reserve(__pa(xen_start_info->mfn_list),
406 xen_start_info->pt_base - xen_start_info->mfn_list);
Jeremy Fitzhardingebe5bf9f2008-06-16 14:54:46 -0700407
408 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
409
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700410 return "Xen";
411}
412
Roland McGrathd2eea682007-07-20 00:31:43 -0700413/*
414 * Set the bit indicating "nosegneg" library variants should be used.
Jeremy Fitzhardinge6a52e4b2008-07-12 02:22:00 -0700415 * We only need to bother in pure 32-bit mode; compat 32-bit processes
416 * can have un-truncated segments, so wrapping around is allowed.
Roland McGrathd2eea682007-07-20 00:31:43 -0700417 */
Sam Ravnborg08b6d292008-01-30 13:33:25 +0100418static void __init fiddle_vdso(void)
Roland McGrathd2eea682007-07-20 00:31:43 -0700419{
Jeremy Fitzhardinge6a52e4b2008-07-12 02:22:00 -0700420#ifdef CONFIG_X86_32
421 u32 *mask;
422 mask = VDSO32_SYMBOL(&vdso32_int80_start, NOTE_MASK);
423 *mask |= 1 << VDSO_NOTE_NONEGSEG_BIT;
424 mask = VDSO32_SYMBOL(&vdso32_sysenter_start, NOTE_MASK);
Roland McGrathd2eea682007-07-20 00:31:43 -0700425 *mask |= 1 << VDSO_NOTE_NONEGSEG_BIT;
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700426#endif
Roland McGrathd2eea682007-07-20 00:31:43 -0700427}
428
Daniel Kiperae15a3b2011-05-04 20:17:21 +0200429static int __cpuinit register_callback(unsigned type, const void *func)
Jeremy Fitzhardingee2a81ba2008-03-17 16:37:17 -0700430{
Jeremy Fitzhardinge88459d42008-07-08 15:07:02 -0700431 struct callback_register callback = {
432 .type = type,
433 .address = XEN_CALLBACK(__KERNEL_CS, func),
Jeremy Fitzhardingee2a81ba2008-03-17 16:37:17 -0700434 .flags = CALLBACKF_mask_events,
435 };
436
Jeremy Fitzhardinge88459d42008-07-08 15:07:02 -0700437 return HYPERVISOR_callback_op(CALLBACKOP_register, &callback);
438}
439
440void __cpuinit xen_enable_sysenter(void)
441{
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700442 int ret;
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700443 unsigned sysenter_feature;
Jeremy Fitzhardinge88459d42008-07-08 15:07:02 -0700444
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700445#ifdef CONFIG_X86_32
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700446 sysenter_feature = X86_FEATURE_SEP;
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700447#else
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700448 sysenter_feature = X86_FEATURE_SYSENTER32;
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700449#endif
450
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700451 if (!boot_cpu_has(sysenter_feature))
452 return;
453
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700454 ret = register_callback(CALLBACKTYPE_sysenter, xen_sysenter_target);
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700455 if(ret != 0)
456 setup_clear_cpu_cap(sysenter_feature);
Jeremy Fitzhardingee2a81ba2008-03-17 16:37:17 -0700457}
458
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700459void __cpuinit xen_enable_syscall(void)
460{
461#ifdef CONFIG_X86_64
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700462 int ret;
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700463
464 ret = register_callback(CALLBACKTYPE_syscall, xen_syscall_target);
465 if (ret != 0) {
Jeremy Fitzhardinged5303b82008-07-12 02:22:06 -0700466 printk(KERN_ERR "Failed to set syscall callback: %d\n", ret);
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700467 /* Pretty fatal; 64-bit userspace has no other
468 mechanism for syscalls. */
469 }
470
471 if (boot_cpu_has(X86_FEATURE_SYSCALL32)) {
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700472 ret = register_callback(CALLBACKTYPE_syscall32,
473 xen_syscall32_target);
Jeremy Fitzhardinged5303b82008-07-12 02:22:06 -0700474 if (ret != 0)
Jeremy Fitzhardinge62541c32008-07-10 16:24:08 -0700475 setup_clear_cpu_cap(X86_FEATURE_SYSCALL32);
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700476 }
477#endif /* CONFIG_X86_64 */
478}
479
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700480void __init xen_arch_setup(void)
481{
Donald Dutilef09f6d12010-07-15 14:56:49 -0400482 xen_panic_handler_init();
483
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700484 HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments);
485 HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables);
486
487 if (!xen_feature(XENFEAT_auto_translated_physmap))
Tejf63c2f22008-12-16 11:56:06 -0800488 HYPERVISOR_vm_assist(VMASST_CMD_enable,
489 VMASST_TYPE_pae_extended_cr3);
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700490
Jeremy Fitzhardinge88459d42008-07-08 15:07:02 -0700491 if (register_callback(CALLBACKTYPE_event, xen_hypervisor_callback) ||
492 register_callback(CALLBACKTYPE_failsafe, xen_failsafe_callback))
493 BUG();
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700494
Jeremy Fitzhardingee2a81ba2008-03-17 16:37:17 -0700495 xen_enable_sysenter();
Jeremy Fitzhardinge6fcac6d2008-07-08 15:07:14 -0700496 xen_enable_syscall();
Jeremy Fitzhardingee2a81ba2008-03-17 16:37:17 -0700497
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700498#ifdef CONFIG_ACPI
499 if (!(xen_start_info->flags & SIF_INITDOMAIN)) {
500 printk(KERN_INFO "ACPI in unprivileged domain disabled\n");
501 disable_acpi();
502 }
503#endif
504
505 memcpy(boot_command_line, xen_start_info->cmd_line,
506 MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ?
507 COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE);
508
Jeremy Fitzhardingebc15fde2010-11-22 17:17:50 -0800509 /* Set up idle, making sure it calls safe_halt() pvop */
510#ifdef CONFIG_X86_32
511 boot_cpu_data.hlt_works_ok = 1;
512#endif
Len Brownd91ee582011-04-01 18:28:35 -0400513 disable_cpuidle();
Konrad Rzeszutek Wilk48cdd822012-03-13 20:06:57 -0400514 disable_cpufreq();
Konrad Rzeszutek Wilke5fd47b2011-11-21 18:02:02 -0500515 WARN_ON(set_pm_idle_to_default());
Roland McGrathd2eea682007-07-20 00:31:43 -0700516 fiddle_vdso();
Jeremy Fitzhardinge5ead97c2007-07-17 18:37:04 -0700517}