Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 1 | /* |
| 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 Lu | a9ce6bc | 2010-08-25 13:39:17 -0700 | [diff] [blame] | 11 | #include <linux/memblock.h> |
Len Brown | d91ee58 | 2011-04-01 18:28:35 -0400 | [diff] [blame] | 12 | #include <linux/cpuidle.h> |
Konrad Rzeszutek Wilk | 48cdd82 | 2012-03-13 20:06:57 -0400 | [diff] [blame] | 13 | #include <linux/cpufreq.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 14 | |
| 15 | #include <asm/elf.h> |
Roland McGrath | 6c3652e | 2008-01-30 13:30:42 +0100 | [diff] [blame] | 16 | #include <asm/vdso.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 17 | #include <asm/e820.h> |
| 18 | #include <asm/setup.h> |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 19 | #include <asm/acpi.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 20 | #include <asm/xen/hypervisor.h> |
| 21 | #include <asm/xen/hypercall.h> |
| 22 | |
Ian Campbell | 45263cb | 2010-10-25 16:32:29 -0700 | [diff] [blame] | 23 | #include <xen/xen.h> |
Jeremy Fitzhardinge | 8006ec3 | 2008-05-26 23:31:19 +0100 | [diff] [blame] | 24 | #include <xen/page.h> |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 25 | #include <xen/interface/callback.h> |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 26 | #include <xen/interface/memory.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 27 | #include <xen/interface/physdev.h> |
| 28 | #include <xen/features.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 29 | #include "xen-ops.h" |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 30 | #include "vdso.h" |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 31 | |
| 32 | /* These are code, but not functions. Defined in entry.S */ |
| 33 | extern const char xen_hypervisor_callback[]; |
| 34 | extern const char xen_failsafe_callback[]; |
Tej | f63c2f2 | 2008-12-16 11:56:06 -0800 | [diff] [blame] | 35 | extern void xen_sysenter_target(void); |
| 36 | extern void xen_syscall_target(void); |
| 37 | extern void xen_syscall32_target(void); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 38 | |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 39 | /* Amount of extra memory space we add to the e820 ranges */ |
David Vrabel | 8b5d44a | 2011-09-28 17:46:34 +0100 | [diff] [blame] | 40 | struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata; |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 41 | |
David Vrabel | aa24411 | 2011-09-28 17:46:32 +0100 | [diff] [blame] | 42 | /* Number of pages released from the initial allocation. */ |
| 43 | unsigned long xen_released_pages; |
| 44 | |
Jeremy Fitzhardinge | 698bb8d | 2010-09-14 10:19:14 -0700 | [diff] [blame] | 45 | /* |
| 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 Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 57 | static void __init xen_add_extra_mem(u64 start, u64 size) |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 58 | { |
Konrad Rzeszutek Wilk | 6eaa412 | 2011-01-18 20:09:41 -0500 | [diff] [blame] | 59 | unsigned long pfn; |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 60 | int i; |
Konrad Rzeszutek Wilk | 6eaa412 | 2011-01-18 20:09:41 -0500 | [diff] [blame] | 61 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 62 | 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 Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 77 | |
Tejun Heo | d4bbf7e | 2011-11-28 09:46:22 -0800 | [diff] [blame] | 78 | memblock_reserve(start, size); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 79 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 80 | xen_max_p2m_pfn = PFN_DOWN(start + size); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 81 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 82 | for (pfn = PFN_DOWN(start); pfn <= xen_max_p2m_pfn; pfn++) |
Konrad Rzeszutek Wilk | 6eaa412 | 2011-01-18 20:09:41 -0500 | [diff] [blame] | 83 | __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 84 | } |
| 85 | |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 86 | static unsigned long __init xen_do_chunk(unsigned long start, |
| 87 | unsigned long end, bool release) |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 88 | { |
| 89 | struct xen_memory_reservation reservation = { |
| 90 | .address_bits = 0, |
| 91 | .extent_order = 0, |
| 92 | .domid = DOMID_SELF |
| 93 | }; |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 94 | unsigned long len = 0; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 95 | unsigned long pfn; |
| 96 | int ret; |
| 97 | |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 98 | for (pfn = start; pfn < end; pfn++) { |
| 99 | unsigned long frame; |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 100 | unsigned long mfn = pfn_to_mfn(pfn); |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 101 | |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 102 | 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 Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 112 | set_xen_guest_handle(reservation.extent_start, &frame); |
| 113 | reservation.nr_extents = 1; |
| 114 | |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 115 | 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 Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 120 | if (ret == 1) { |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 121 | if (!early_set_phys_to_machine(pfn, release ? INVALID_P2M_ENTRY : frame)) { |
| 122 | if (release) |
| 123 | break; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 124 | set_xen_guest_handle(reservation.extent_start, &frame); |
| 125 | reservation.nr_extents = 1; |
| 126 | ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 127 | &reservation); |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 128 | break; |
| 129 | } |
| 130 | len++; |
| 131 | } else |
| 132 | break; |
| 133 | } |
| 134 | if (len) |
Konrad Rzeszutek Wilk | 96dc08b | 2012-04-06 16:10:20 -0400 | [diff] [blame] | 135 | 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 Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 140 | return len; |
| 141 | } |
David Vrabel | 83d51ab | 2012-05-03 16:15:42 +0100 | [diff] [blame] | 142 | |
| 143 | static unsigned long __init xen_release_chunk(unsigned long start, |
| 144 | unsigned long end) |
| 145 | { |
| 146 | return xen_do_chunk(start, end, true); |
| 147 | } |
| 148 | |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 149 | static unsigned long __init xen_populate_chunk( |
| 150 | const struct e820entry *list, size_t map_size, |
| 151 | unsigned long max_pfn, unsigned long *last_pfn, |
| 152 | unsigned long credits_left) |
| 153 | { |
| 154 | const struct e820entry *entry; |
| 155 | unsigned int i; |
| 156 | unsigned long done = 0; |
| 157 | unsigned long dest_pfn; |
| 158 | |
| 159 | for (i = 0, entry = list; i < map_size; i++, entry++) { |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 160 | unsigned long s_pfn; |
| 161 | unsigned long e_pfn; |
| 162 | unsigned long pfns; |
| 163 | long capacity; |
| 164 | |
zhenzhong.duan | c3d93f8 | 2012-07-18 13:06:39 +0800 | [diff] [blame] | 165 | if (credits_left <= 0) |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 166 | break; |
| 167 | |
| 168 | if (entry->type != E820_RAM) |
| 169 | continue; |
| 170 | |
zhenzhong.duan | c3d93f8 | 2012-07-18 13:06:39 +0800 | [diff] [blame] | 171 | e_pfn = PFN_DOWN(entry->addr + entry->size); |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 172 | |
| 173 | /* We only care about E820 after the xen_start_info->nr_pages */ |
| 174 | if (e_pfn <= max_pfn) |
| 175 | continue; |
| 176 | |
zhenzhong.duan | c3d93f8 | 2012-07-18 13:06:39 +0800 | [diff] [blame] | 177 | s_pfn = PFN_UP(entry->addr); |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 178 | /* If the E820 falls within the nr_pages, we want to start |
| 179 | * at the nr_pages PFN. |
| 180 | * If that would mean going past the E820 entry, skip it |
| 181 | */ |
| 182 | if (s_pfn <= max_pfn) { |
| 183 | capacity = e_pfn - max_pfn; |
| 184 | dest_pfn = max_pfn; |
| 185 | } else { |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 186 | capacity = e_pfn - s_pfn; |
| 187 | dest_pfn = s_pfn; |
| 188 | } |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 189 | |
zhenzhong.duan | c3d93f8 | 2012-07-18 13:06:39 +0800 | [diff] [blame] | 190 | if (credits_left < capacity) |
| 191 | capacity = credits_left; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 192 | |
zhenzhong.duan | c3d93f8 | 2012-07-18 13:06:39 +0800 | [diff] [blame] | 193 | pfns = xen_do_chunk(dest_pfn, dest_pfn + capacity, false); |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 194 | done += pfns; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 195 | *last_pfn = (dest_pfn + pfns); |
zhenzhong.duan | c3d93f8 | 2012-07-18 13:06:39 +0800 | [diff] [blame] | 196 | if (pfns < capacity) |
| 197 | break; |
| 198 | credits_left -= pfns; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 199 | } |
| 200 | return done; |
| 201 | } |
David Vrabel | 83d51ab | 2012-05-03 16:15:42 +0100 | [diff] [blame] | 202 | |
| 203 | static void __init xen_set_identity_and_release_chunk( |
| 204 | unsigned long start_pfn, unsigned long end_pfn, unsigned long nr_pages, |
| 205 | unsigned long *released, unsigned long *identity) |
| 206 | { |
| 207 | unsigned long pfn; |
| 208 | |
| 209 | /* |
| 210 | * If the PFNs are currently mapped, the VA mapping also needs |
| 211 | * to be updated to be 1:1. |
| 212 | */ |
| 213 | for (pfn = start_pfn; pfn <= max_pfn_mapped && pfn < end_pfn; pfn++) |
| 214 | (void)HYPERVISOR_update_va_mapping( |
| 215 | (unsigned long)__va(pfn << PAGE_SHIFT), |
| 216 | mfn_pte(pfn, PAGE_KERNEL_IO), 0); |
| 217 | |
| 218 | if (start_pfn < nr_pages) |
| 219 | *released += xen_release_chunk( |
| 220 | start_pfn, min(end_pfn, nr_pages)); |
| 221 | |
| 222 | *identity += set_phys_range_identity(start_pfn, end_pfn); |
| 223 | } |
| 224 | |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 225 | static unsigned long __init xen_set_identity_and_release( |
| 226 | const struct e820entry *list, size_t map_size, unsigned long nr_pages) |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 227 | { |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 228 | phys_addr_t start = 0; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 229 | unsigned long released = 0; |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 230 | unsigned long identity = 0; |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 231 | const struct e820entry *entry; |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 232 | int i; |
| 233 | |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 234 | /* |
| 235 | * Combine non-RAM regions and gaps until a RAM region (or the |
| 236 | * end of the map) is reached, then set the 1:1 map and |
| 237 | * release the pages (if available) in those non-RAM regions. |
| 238 | * |
| 239 | * The combined non-RAM regions are rounded to a whole number |
| 240 | * of pages so any partial pages are accessible via the 1:1 |
| 241 | * mapping. This is needed for some BIOSes that put (for |
| 242 | * example) the DMI tables in a reserved region that begins on |
| 243 | * a non-page boundary. |
| 244 | */ |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 245 | for (i = 0, entry = list; i < map_size; i++, entry++) { |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 246 | phys_addr_t end = entry->addr + entry->size; |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 247 | if (entry->type == E820_RAM || i == map_size - 1) { |
| 248 | unsigned long start_pfn = PFN_DOWN(start); |
| 249 | unsigned long end_pfn = PFN_UP(end); |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 250 | |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 251 | if (entry->type == E820_RAM) |
| 252 | end_pfn = PFN_UP(entry->addr); |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 253 | |
David Vrabel | 83d51ab | 2012-05-03 16:15:42 +0100 | [diff] [blame] | 254 | if (start_pfn < end_pfn) |
| 255 | xen_set_identity_and_release_chunk( |
| 256 | start_pfn, end_pfn, nr_pages, |
| 257 | &released, &identity); |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 258 | |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 259 | start = end; |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 260 | } |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 261 | } |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 262 | |
Konrad Rzeszutek Wilk | ca11823 | 2012-03-30 15:37:07 -0400 | [diff] [blame] | 263 | if (released) |
| 264 | printk(KERN_INFO "Released %lu pages of unused memory\n", released); |
| 265 | if (identity) |
| 266 | printk(KERN_INFO "Set %ld page(s) to 1-1 mapping\n", identity); |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 267 | |
| 268 | return released; |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 269 | } |
David Vrabel | d312ae87 | 2011-08-19 15:57:16 +0100 | [diff] [blame] | 270 | |
| 271 | static unsigned long __init xen_get_max_pages(void) |
| 272 | { |
| 273 | unsigned long max_pages = MAX_DOMAIN_PAGES; |
| 274 | domid_t domid = DOMID_SELF; |
| 275 | int ret; |
| 276 | |
Ian Campbell | d3db728 | 2011-12-14 12:16:08 +0000 | [diff] [blame] | 277 | /* |
| 278 | * For the initial domain we use the maximum reservation as |
| 279 | * the maximum page. |
| 280 | * |
| 281 | * For guest domains the current maximum reservation reflects |
| 282 | * the current maximum rather than the static maximum. In this |
| 283 | * case the e820 map provided to us will cover the static |
| 284 | * maximum region. |
| 285 | */ |
| 286 | if (xen_initial_domain()) { |
| 287 | ret = HYPERVISOR_memory_op(XENMEM_maximum_reservation, &domid); |
| 288 | if (ret > 0) |
| 289 | max_pages = ret; |
| 290 | } |
| 291 | |
David Vrabel | d312ae87 | 2011-08-19 15:57:16 +0100 | [diff] [blame] | 292 | return min(max_pages, MAX_DOMAIN_PAGES); |
| 293 | } |
| 294 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 295 | static void xen_align_and_add_e820_region(u64 start, u64 size, int type) |
| 296 | { |
| 297 | u64 end = start + size; |
| 298 | |
| 299 | /* Align RAM regions to page boundaries. */ |
| 300 | if (type == E820_RAM) { |
| 301 | start = PAGE_ALIGN(start); |
| 302 | end &= ~((u64)PAGE_SIZE - 1); |
| 303 | } |
| 304 | |
| 305 | e820_add_region(start, end - start, type); |
| 306 | } |
| 307 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 308 | /** |
| 309 | * machine_specific_memory_setup - Hook for machine specific memory setup. |
| 310 | **/ |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 311 | char * __init xen_memory_setup(void) |
| 312 | { |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 313 | static struct e820entry map[E820MAX] __initdata; |
| 314 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 315 | unsigned long max_pfn = xen_start_info->nr_pages; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 316 | unsigned long long mem_end; |
| 317 | int rc; |
| 318 | struct xen_memory_map memmap; |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 319 | unsigned long max_pages; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 320 | unsigned long last_pfn = 0; |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 321 | unsigned long extra_pages = 0; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 322 | unsigned long populated; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 323 | int i; |
Ian Campbell | 9e9a5fc | 2010-09-02 16:16:00 +0100 | [diff] [blame] | 324 | int op; |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 325 | |
Jeremy Fitzhardinge | 8006ec3 | 2008-05-26 23:31:19 +0100 | [diff] [blame] | 326 | max_pfn = min(MAX_DOMAIN_PAGES, max_pfn); |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 327 | mem_end = PFN_PHYS(max_pfn); |
| 328 | |
| 329 | memmap.nr_entries = E820MAX; |
| 330 | set_xen_guest_handle(memmap.buffer, map); |
| 331 | |
Ian Campbell | 9e9a5fc | 2010-09-02 16:16:00 +0100 | [diff] [blame] | 332 | op = xen_initial_domain() ? |
| 333 | XENMEM_machine_memory_map : |
| 334 | XENMEM_memory_map; |
| 335 | rc = HYPERVISOR_memory_op(op, &memmap); |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 336 | if (rc == -ENOSYS) { |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 337 | BUG_ON(xen_initial_domain()); |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 338 | memmap.nr_entries = 1; |
| 339 | map[0].addr = 0ULL; |
| 340 | map[0].size = mem_end; |
| 341 | /* 8MB slack (to balance backend allocations). */ |
| 342 | map[0].size += 8ULL << 20; |
| 343 | map[0].type = E820_RAM; |
| 344 | rc = 0; |
| 345 | } |
| 346 | BUG_ON(rc); |
Jeremy Fitzhardinge | 8006ec3 | 2008-05-26 23:31:19 +0100 | [diff] [blame] | 347 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 348 | /* Make sure the Xen-supplied memory map is well-ordered. */ |
| 349 | sanitize_e820_map(map, memmap.nr_entries, &memmap.nr_entries); |
Jeremy Fitzhardinge | be5bf9f | 2008-06-16 14:54:46 -0700 | [diff] [blame] | 350 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 351 | max_pages = xen_get_max_pages(); |
| 352 | if (max_pages > max_pfn) |
| 353 | extra_pages += max_pages - max_pfn; |
Stefano Stabellini | 7cb31b7 | 2011-01-27 10:13:25 -0500 | [diff] [blame] | 354 | |
David Vrabel | f3f436e | 2011-09-28 17:46:36 +0100 | [diff] [blame] | 355 | /* |
| 356 | * Set P2M for all non-RAM pages and E820 gaps to be identity |
| 357 | * type PFNs. Any RAM pages that would be made inaccesible by |
| 358 | * this are first released. |
| 359 | */ |
| 360 | xen_released_pages = xen_set_identity_and_release( |
| 361 | map, memmap.nr_entries, max_pfn); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 362 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 363 | /* |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 364 | * Populate back the non-RAM pages and E820 gaps that had been |
| 365 | * released. */ |
| 366 | populated = xen_populate_chunk(map, memmap.nr_entries, |
| 367 | max_pfn, &last_pfn, xen_released_pages); |
| 368 | |
Konrad Rzeszutek Wilk | 58b7b53 | 2012-05-29 12:36:43 -0400 | [diff] [blame] | 369 | xen_released_pages -= populated; |
| 370 | extra_pages += xen_released_pages; |
Konrad Rzeszutek Wilk | 2e2fb75 | 2012-04-06 10:07:11 -0400 | [diff] [blame] | 371 | |
| 372 | if (last_pfn > max_pfn) { |
| 373 | max_pfn = min(MAX_DOMAIN_PAGES, last_pfn); |
| 374 | mem_end = PFN_PHYS(max_pfn); |
| 375 | } |
| 376 | /* |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 377 | * Clamp the amount of extra memory to a EXTRA_MEM_RATIO |
| 378 | * factor the base size. On non-highmem systems, the base |
| 379 | * size is the full initial memory allocation; on highmem it |
| 380 | * is limited to the max size of lowmem, so that it doesn't |
| 381 | * get completely filled. |
| 382 | * |
| 383 | * In principle there could be a problem in lowmem systems if |
| 384 | * the initial memory is also very large with respect to |
| 385 | * lowmem, but we won't try to deal with that here. |
| 386 | */ |
| 387 | extra_pages = min(EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)), |
| 388 | extra_pages); |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 389 | i = 0; |
| 390 | while (i < memmap.nr_entries) { |
| 391 | u64 addr = map[i].addr; |
| 392 | u64 size = map[i].size; |
| 393 | u32 type = map[i].type; |
| 394 | |
| 395 | if (type == E820_RAM) { |
| 396 | if (addr < mem_end) { |
| 397 | size = min(size, mem_end - addr); |
| 398 | } else if (extra_pages) { |
| 399 | size = min(size, (u64)extra_pages * PAGE_SIZE); |
| 400 | extra_pages -= size / PAGE_SIZE; |
| 401 | xen_add_extra_mem(addr, size); |
| 402 | } else |
| 403 | type = E820_UNUSABLE; |
Jeremy Fitzhardinge | 3654581 | 2010-09-29 16:54:33 -0700 | [diff] [blame] | 404 | } |
| 405 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 406 | xen_align_and_add_e820_region(addr, size, type); |
Jeremy Fitzhardinge | b5b43ce | 2010-09-02 17:10:12 -0700 | [diff] [blame] | 407 | |
David Vrabel | dc91c72 | 2011-09-29 12:26:19 +0100 | [diff] [blame] | 408 | map[i].addr += size; |
| 409 | map[i].size -= size; |
| 410 | if (map[i].size == 0) |
| 411 | i++; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 412 | } |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 413 | |
| 414 | /* |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 415 | * In domU, the ISA region is normal, usable memory, but we |
| 416 | * reserve ISA memory anyway because too many things poke |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 417 | * about in there. |
| 418 | */ |
| 419 | e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS, |
| 420 | E820_RESERVED); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 421 | |
Jeremy Fitzhardinge | be5bf9f | 2008-06-16 14:54:46 -0700 | [diff] [blame] | 422 | /* |
| 423 | * Reserve Xen bits: |
| 424 | * - mfn_list |
| 425 | * - xen_start_info |
| 426 | * See comment above "struct start_info" in <xen/interface/xen.h> |
| 427 | */ |
Tejun Heo | 24aa078 | 2011-07-12 11:16:06 +0200 | [diff] [blame] | 428 | memblock_reserve(__pa(xen_start_info->mfn_list), |
| 429 | xen_start_info->pt_base - xen_start_info->mfn_list); |
Jeremy Fitzhardinge | be5bf9f | 2008-06-16 14:54:46 -0700 | [diff] [blame] | 430 | |
| 431 | sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); |
| 432 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 433 | return "Xen"; |
| 434 | } |
| 435 | |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 436 | /* |
| 437 | * Set the bit indicating "nosegneg" library variants should be used. |
Jeremy Fitzhardinge | 6a52e4b | 2008-07-12 02:22:00 -0700 | [diff] [blame] | 438 | * We only need to bother in pure 32-bit mode; compat 32-bit processes |
| 439 | * can have un-truncated segments, so wrapping around is allowed. |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 440 | */ |
Sam Ravnborg | 08b6d29 | 2008-01-30 13:33:25 +0100 | [diff] [blame] | 441 | static void __init fiddle_vdso(void) |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 442 | { |
Jeremy Fitzhardinge | 6a52e4b | 2008-07-12 02:22:00 -0700 | [diff] [blame] | 443 | #ifdef CONFIG_X86_32 |
| 444 | u32 *mask; |
| 445 | mask = VDSO32_SYMBOL(&vdso32_int80_start, NOTE_MASK); |
| 446 | *mask |= 1 << VDSO_NOTE_NONEGSEG_BIT; |
| 447 | mask = VDSO32_SYMBOL(&vdso32_sysenter_start, NOTE_MASK); |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 448 | *mask |= 1 << VDSO_NOTE_NONEGSEG_BIT; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 449 | #endif |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 450 | } |
| 451 | |
Daniel Kiper | ae15a3b | 2011-05-04 20:17:21 +0200 | [diff] [blame] | 452 | static int __cpuinit register_callback(unsigned type, const void *func) |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 453 | { |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 454 | struct callback_register callback = { |
| 455 | .type = type, |
| 456 | .address = XEN_CALLBACK(__KERNEL_CS, func), |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 457 | .flags = CALLBACKF_mask_events, |
| 458 | }; |
| 459 | |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 460 | return HYPERVISOR_callback_op(CALLBACKOP_register, &callback); |
| 461 | } |
| 462 | |
| 463 | void __cpuinit xen_enable_sysenter(void) |
| 464 | { |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 465 | int ret; |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 466 | unsigned sysenter_feature; |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 467 | |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 468 | #ifdef CONFIG_X86_32 |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 469 | sysenter_feature = X86_FEATURE_SEP; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 470 | #else |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 471 | sysenter_feature = X86_FEATURE_SYSENTER32; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 472 | #endif |
| 473 | |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 474 | if (!boot_cpu_has(sysenter_feature)) |
| 475 | return; |
| 476 | |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 477 | ret = register_callback(CALLBACKTYPE_sysenter, xen_sysenter_target); |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 478 | if(ret != 0) |
| 479 | setup_clear_cpu_cap(sysenter_feature); |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 480 | } |
| 481 | |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 482 | void __cpuinit xen_enable_syscall(void) |
| 483 | { |
| 484 | #ifdef CONFIG_X86_64 |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 485 | int ret; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 486 | |
| 487 | ret = register_callback(CALLBACKTYPE_syscall, xen_syscall_target); |
| 488 | if (ret != 0) { |
Jeremy Fitzhardinge | d5303b8 | 2008-07-12 02:22:06 -0700 | [diff] [blame] | 489 | printk(KERN_ERR "Failed to set syscall callback: %d\n", ret); |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 490 | /* Pretty fatal; 64-bit userspace has no other |
| 491 | mechanism for syscalls. */ |
| 492 | } |
| 493 | |
| 494 | if (boot_cpu_has(X86_FEATURE_SYSCALL32)) { |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 495 | ret = register_callback(CALLBACKTYPE_syscall32, |
| 496 | xen_syscall32_target); |
Jeremy Fitzhardinge | d5303b8 | 2008-07-12 02:22:06 -0700 | [diff] [blame] | 497 | if (ret != 0) |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 498 | setup_clear_cpu_cap(X86_FEATURE_SYSCALL32); |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 499 | } |
| 500 | #endif /* CONFIG_X86_64 */ |
| 501 | } |
| 502 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 503 | void __init xen_arch_setup(void) |
| 504 | { |
Donald Dutile | f09f6d1 | 2010-07-15 14:56:49 -0400 | [diff] [blame] | 505 | xen_panic_handler_init(); |
| 506 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 507 | HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments); |
| 508 | HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables); |
| 509 | |
| 510 | if (!xen_feature(XENFEAT_auto_translated_physmap)) |
Tej | f63c2f2 | 2008-12-16 11:56:06 -0800 | [diff] [blame] | 511 | HYPERVISOR_vm_assist(VMASST_CMD_enable, |
| 512 | VMASST_TYPE_pae_extended_cr3); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 513 | |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 514 | if (register_callback(CALLBACKTYPE_event, xen_hypervisor_callback) || |
| 515 | register_callback(CALLBACKTYPE_failsafe, xen_failsafe_callback)) |
| 516 | BUG(); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 517 | |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 518 | xen_enable_sysenter(); |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 519 | xen_enable_syscall(); |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 520 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 521 | #ifdef CONFIG_ACPI |
| 522 | if (!(xen_start_info->flags & SIF_INITDOMAIN)) { |
| 523 | printk(KERN_INFO "ACPI in unprivileged domain disabled\n"); |
| 524 | disable_acpi(); |
| 525 | } |
| 526 | #endif |
| 527 | |
| 528 | memcpy(boot_command_line, xen_start_info->cmd_line, |
| 529 | MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ? |
| 530 | COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE); |
| 531 | |
Jeremy Fitzhardinge | bc15fde | 2010-11-22 17:17:50 -0800 | [diff] [blame] | 532 | /* Set up idle, making sure it calls safe_halt() pvop */ |
| 533 | #ifdef CONFIG_X86_32 |
| 534 | boot_cpu_data.hlt_works_ok = 1; |
| 535 | #endif |
Len Brown | d91ee58 | 2011-04-01 18:28:35 -0400 | [diff] [blame] | 536 | disable_cpuidle(); |
Konrad Rzeszutek Wilk | 48cdd82 | 2012-03-13 20:06:57 -0400 | [diff] [blame] | 537 | disable_cpufreq(); |
Konrad Rzeszutek Wilk | e5fd47b | 2011-11-21 18:02:02 -0500 | [diff] [blame] | 538 | WARN_ON(set_pm_idle_to_default()); |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 539 | fiddle_vdso(); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 540 | } |