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> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 13 | |
| 14 | #include <asm/elf.h> |
Roland McGrath | 6c3652e | 2008-01-30 13:30:42 +0100 | [diff] [blame] | 15 | #include <asm/vdso.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 16 | #include <asm/e820.h> |
| 17 | #include <asm/setup.h> |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 18 | #include <asm/acpi.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 19 | #include <asm/xen/hypervisor.h> |
| 20 | #include <asm/xen/hypercall.h> |
| 21 | |
Ian Campbell | 45263cb | 2010-10-25 16:32:29 -0700 | [diff] [blame] | 22 | #include <xen/xen.h> |
Jeremy Fitzhardinge | 8006ec3 | 2008-05-26 23:31:19 +0100 | [diff] [blame] | 23 | #include <xen/page.h> |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 24 | #include <xen/interface/callback.h> |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 25 | #include <xen/interface/memory.h> |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 26 | #include <xen/interface/physdev.h> |
| 27 | #include <xen/features.h> |
| 28 | |
| 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 */ |
| 40 | phys_addr_t xen_extra_mem_start, xen_extra_mem_size; |
| 41 | |
Jeremy Fitzhardinge | 698bb8d | 2010-09-14 10:19:14 -0700 | [diff] [blame] | 42 | /* |
| 43 | * The maximum amount of extra memory compared to the base size. The |
| 44 | * main scaling factor is the size of struct page. At extreme ratios |
| 45 | * of base:extra, all the base memory can be filled with page |
| 46 | * structures for the extra memory, leaving no space for anything |
| 47 | * else. |
| 48 | * |
| 49 | * 10x seems like a reasonable balance between scaling flexibility and |
| 50 | * leaving a practically usable system. |
| 51 | */ |
| 52 | #define EXTRA_MEM_RATIO (10) |
| 53 | |
Daniel Kiper | ae15a3b | 2011-05-04 20:17:21 +0200 | [diff] [blame] | 54 | static void __init xen_add_extra_mem(unsigned long pages) |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 55 | { |
Konrad Rzeszutek Wilk | 6eaa412 | 2011-01-18 20:09:41 -0500 | [diff] [blame] | 56 | unsigned long pfn; |
| 57 | |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 58 | u64 size = (u64)pages * PAGE_SIZE; |
Jeremy Fitzhardinge | 3654581 | 2010-09-29 16:54:33 -0700 | [diff] [blame] | 59 | u64 extra_start = xen_extra_mem_start + xen_extra_mem_size; |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 60 | |
| 61 | if (!pages) |
| 62 | return; |
| 63 | |
Jeremy Fitzhardinge | 3654581 | 2010-09-29 16:54:33 -0700 | [diff] [blame] | 64 | e820_add_region(extra_start, size, E820_RAM); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 65 | sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); |
| 66 | |
Linus Torvalds | 520045d | 2010-10-26 18:20:19 -0700 | [diff] [blame] | 67 | memblock_x86_reserve_range(extra_start, extra_start + size, "XEN EXTRA"); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 68 | |
| 69 | xen_extra_mem_size += size; |
Jeremy Fitzhardinge | 2f7acb2 | 2010-09-15 13:32:49 -0700 | [diff] [blame] | 70 | |
Jeremy Fitzhardinge | 3654581 | 2010-09-29 16:54:33 -0700 | [diff] [blame] | 71 | xen_max_p2m_pfn = PFN_DOWN(extra_start + size); |
Konrad Rzeszutek Wilk | 6eaa412 | 2011-01-18 20:09:41 -0500 | [diff] [blame] | 72 | |
| 73 | for (pfn = PFN_DOWN(extra_start); pfn <= xen_max_p2m_pfn; pfn++) |
| 74 | __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 77 | static unsigned long __init xen_release_chunk(phys_addr_t start_addr, |
| 78 | phys_addr_t end_addr) |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 79 | { |
| 80 | struct xen_memory_reservation reservation = { |
| 81 | .address_bits = 0, |
| 82 | .extent_order = 0, |
| 83 | .domid = DOMID_SELF |
| 84 | }; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 85 | unsigned long start, end; |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 86 | unsigned long len = 0; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 87 | unsigned long pfn; |
| 88 | int ret; |
| 89 | |
| 90 | start = PFN_UP(start_addr); |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 91 | end = PFN_DOWN(end_addr); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 92 | |
| 93 | if (end <= start) |
| 94 | return 0; |
| 95 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 96 | for(pfn = start; pfn < end; pfn++) { |
| 97 | unsigned long mfn = pfn_to_mfn(pfn); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 98 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 99 | /* Make sure pfn exists to start with */ |
| 100 | if (mfn == INVALID_P2M_ENTRY || mfn_to_pfn(mfn) != pfn) |
| 101 | continue; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 102 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 103 | set_xen_guest_handle(reservation.extent_start, &mfn); |
| 104 | reservation.nr_extents = 1; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 105 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 106 | ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, |
| 107 | &reservation); |
Igor Mammedov | 98f531d | 2011-08-02 11:45:25 +0200 | [diff] [blame] | 108 | WARN(ret != 1, "Failed to release pfn %lx err=%d\n", pfn, ret); |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 109 | if (ret == 1) { |
Konrad Rzeszutek Wilk | 6eaa412 | 2011-01-18 20:09:41 -0500 | [diff] [blame] | 110 | __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 111 | len++; |
| 112 | } |
| 113 | } |
Igor Mammedov | 98f531d | 2011-08-02 11:45:25 +0200 | [diff] [blame] | 114 | printk(KERN_INFO "Freeing %lx-%lx pfn range: %lu pages freed\n", |
| 115 | start, end, len); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 116 | |
| 117 | return len; |
| 118 | } |
| 119 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 120 | static unsigned long __init xen_return_unused_memory(unsigned long max_pfn, |
| 121 | const struct e820map *e820) |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 122 | { |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 123 | phys_addr_t max_addr = PFN_PHYS(max_pfn); |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 124 | phys_addr_t last_end = ISA_END_ADDRESS; |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 125 | unsigned long released = 0; |
| 126 | int i; |
| 127 | |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 128 | /* Free any unused memory above the low 1Mbyte. */ |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 129 | for (i = 0; i < e820->nr_map && last_end < max_addr; i++) { |
| 130 | phys_addr_t end = e820->map[i].addr; |
| 131 | end = min(max_addr, end); |
| 132 | |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 133 | if (last_end < end) |
| 134 | released += xen_release_chunk(last_end, end); |
| 135 | last_end = max(last_end, e820->map[i].addr + e820->map[i].size); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 136 | } |
| 137 | |
Jeremy Fitzhardinge | f89e048 | 2009-09-16 12:38:33 -0700 | [diff] [blame] | 138 | if (last_end < max_addr) |
| 139 | released += xen_release_chunk(last_end, max_addr); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 140 | |
Igor Mammedov | 8f3c588 | 2011-08-02 11:45:24 +0200 | [diff] [blame] | 141 | printk(KERN_INFO "released %lu pages of unused memory\n", released); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 142 | return released; |
| 143 | } |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 144 | |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 145 | static unsigned long __init xen_set_identity(const struct e820entry *list, |
| 146 | ssize_t map_size) |
| 147 | { |
| 148 | phys_addr_t last = xen_initial_domain() ? 0 : ISA_END_ADDRESS; |
| 149 | phys_addr_t start_pci = last; |
| 150 | const struct e820entry *entry; |
| 151 | unsigned long identity = 0; |
| 152 | int i; |
| 153 | |
| 154 | for (i = 0, entry = list; i < map_size; i++, entry++) { |
| 155 | phys_addr_t start = entry->addr; |
| 156 | phys_addr_t end = start + entry->size; |
| 157 | |
| 158 | if (start < last) |
| 159 | start = last; |
| 160 | |
| 161 | if (end <= start) |
| 162 | continue; |
| 163 | |
| 164 | /* Skip over the 1MB region. */ |
| 165 | if (last > end) |
| 166 | continue; |
| 167 | |
Konrad Rzeszutek Wilk | 15bfc09 | 2011-04-12 07:57:15 -0400 | [diff] [blame] | 168 | if ((entry->type == E820_RAM) || (entry->type == E820_UNUSABLE)) { |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 169 | if (start > start_pci) |
| 170 | identity += set_phys_range_identity( |
| 171 | PFN_UP(start_pci), PFN_DOWN(start)); |
| 172 | |
| 173 | /* Without saving 'last' we would gooble RAM too |
| 174 | * at the end of the loop. */ |
| 175 | last = end; |
| 176 | start_pci = end; |
| 177 | continue; |
| 178 | } |
| 179 | start_pci = min(start, start_pci); |
| 180 | last = end; |
| 181 | } |
| 182 | if (last > start_pci) |
| 183 | identity += set_phys_range_identity( |
| 184 | PFN_UP(start_pci), PFN_DOWN(last)); |
| 185 | return identity; |
| 186 | } |
David Vrabel | d312ae87 | 2011-08-19 15:57:16 +0100 | [diff] [blame] | 187 | |
| 188 | static unsigned long __init xen_get_max_pages(void) |
| 189 | { |
| 190 | unsigned long max_pages = MAX_DOMAIN_PAGES; |
| 191 | domid_t domid = DOMID_SELF; |
| 192 | int ret; |
| 193 | |
| 194 | ret = HYPERVISOR_memory_op(XENMEM_maximum_reservation, &domid); |
| 195 | if (ret > 0) |
| 196 | max_pages = ret; |
| 197 | return min(max_pages, MAX_DOMAIN_PAGES); |
| 198 | } |
| 199 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 200 | /** |
| 201 | * machine_specific_memory_setup - Hook for machine specific memory setup. |
| 202 | **/ |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 203 | char * __init xen_memory_setup(void) |
| 204 | { |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 205 | static struct e820entry map[E820MAX] __initdata; |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 206 | static struct e820entry map_raw[E820MAX] __initdata; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 207 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 208 | unsigned long max_pfn = xen_start_info->nr_pages; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 209 | unsigned long long mem_end; |
| 210 | int rc; |
| 211 | struct xen_memory_map memmap; |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 212 | unsigned long extra_pages = 0; |
Jeremy Fitzhardinge | 698bb8d | 2010-09-14 10:19:14 -0700 | [diff] [blame] | 213 | unsigned long extra_limit; |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 214 | unsigned long identity_pages = 0; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 215 | int i; |
Ian Campbell | 9e9a5fc | 2010-09-02 16:16:00 +0100 | [diff] [blame] | 216 | int op; |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 217 | |
Jeremy Fitzhardinge | 8006ec3 | 2008-05-26 23:31:19 +0100 | [diff] [blame] | 218 | max_pfn = min(MAX_DOMAIN_PAGES, max_pfn); |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 219 | mem_end = PFN_PHYS(max_pfn); |
| 220 | |
| 221 | memmap.nr_entries = E820MAX; |
| 222 | set_xen_guest_handle(memmap.buffer, map); |
| 223 | |
Ian Campbell | 9e9a5fc | 2010-09-02 16:16:00 +0100 | [diff] [blame] | 224 | op = xen_initial_domain() ? |
| 225 | XENMEM_machine_memory_map : |
| 226 | XENMEM_memory_map; |
| 227 | rc = HYPERVISOR_memory_op(op, &memmap); |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 228 | if (rc == -ENOSYS) { |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 229 | BUG_ON(xen_initial_domain()); |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 230 | memmap.nr_entries = 1; |
| 231 | map[0].addr = 0ULL; |
| 232 | map[0].size = mem_end; |
| 233 | /* 8MB slack (to balance backend allocations). */ |
| 234 | map[0].size += 8ULL << 20; |
| 235 | map[0].type = E820_RAM; |
| 236 | rc = 0; |
| 237 | } |
| 238 | BUG_ON(rc); |
Jeremy Fitzhardinge | 8006ec3 | 2008-05-26 23:31:19 +0100 | [diff] [blame] | 239 | |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 240 | memcpy(map_raw, map, sizeof(map)); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 241 | e820.nr_map = 0; |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 242 | xen_extra_mem_start = mem_end; |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 243 | for (i = 0; i < memmap.nr_entries; i++) { |
Stefano Stabellini | 7cb31b7 | 2011-01-27 10:13:25 -0500 | [diff] [blame] | 244 | unsigned long long end; |
Jeremy Fitzhardinge | be5bf9f | 2008-06-16 14:54:46 -0700 | [diff] [blame] | 245 | |
Stefano Stabellini | 7cb31b7 | 2011-01-27 10:13:25 -0500 | [diff] [blame] | 246 | /* Guard against non-page aligned E820 entries. */ |
| 247 | if (map[i].type == E820_RAM) |
| 248 | map[i].size -= (map[i].size + map[i].addr) % PAGE_SIZE; |
| 249 | |
| 250 | end = map[i].addr + map[i].size; |
Jeremy Fitzhardinge | c2d0879 | 2010-11-22 16:31:35 -0800 | [diff] [blame] | 251 | if (map[i].type == E820_RAM && end > mem_end) { |
| 252 | /* RAM off the end - may be partially included */ |
| 253 | u64 delta = min(map[i].size, end - mem_end); |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 254 | |
Jeremy Fitzhardinge | c2d0879 | 2010-11-22 16:31:35 -0800 | [diff] [blame] | 255 | map[i].size -= delta; |
| 256 | end -= delta; |
Jeremy Fitzhardinge | 3654581 | 2010-09-29 16:54:33 -0700 | [diff] [blame] | 257 | |
Jeremy Fitzhardinge | c2d0879 | 2010-11-22 16:31:35 -0800 | [diff] [blame] | 258 | extra_pages += PFN_DOWN(delta); |
Zhang, Fengzhe | 2f14ddc | 2011-02-16 22:26:20 +0800 | [diff] [blame] | 259 | /* |
| 260 | * Set RAM below 4GB that is not for us to be unusable. |
| 261 | * This prevents "System RAM" address space from being |
| 262 | * used as potential resource for I/O address (happens |
| 263 | * when 'allocate_resource' is called). |
| 264 | */ |
Konrad Rzeszutek Wilk | 86b3212 | 2011-03-09 22:03:16 -0500 | [diff] [blame] | 265 | if (delta && |
| 266 | (xen_initial_domain() && end < 0x100000000ULL)) |
Zhang, Fengzhe | 2f14ddc | 2011-02-16 22:26:20 +0800 | [diff] [blame] | 267 | e820_add_region(end, delta, E820_UNUSABLE); |
Jeremy Fitzhardinge | 3654581 | 2010-09-29 16:54:33 -0700 | [diff] [blame] | 268 | } |
| 269 | |
Jeremy Fitzhardinge | c2d0879 | 2010-11-22 16:31:35 -0800 | [diff] [blame] | 270 | if (map[i].size > 0 && end > xen_extra_mem_start) |
Jeremy Fitzhardinge | 36bc251 | 2010-09-02 17:07:03 -0700 | [diff] [blame] | 271 | xen_extra_mem_start = end; |
Jeremy Fitzhardinge | b5b43ce | 2010-09-02 17:10:12 -0700 | [diff] [blame] | 272 | |
Jeremy Fitzhardinge | c2d0879 | 2010-11-22 16:31:35 -0800 | [diff] [blame] | 273 | /* Add region if any remains */ |
| 274 | if (map[i].size > 0) |
Ian Campbell | 35ae11f | 2009-02-06 19:09:48 -0800 | [diff] [blame] | 275 | e820_add_region(map[i].addr, map[i].size, map[i].type); |
| 276 | } |
Konrad Rzeszutek Wilk | acd049c | 2011-06-16 13:07:19 -0400 | [diff] [blame] | 277 | /* Align the balloon area so that max_low_pfn does not get set |
| 278 | * to be at the _end_ of the PCI gap at the far end (fee01000). |
| 279 | * Note that xen_extra_mem_start gets set in the loop above to be |
| 280 | * past the last E820 region. */ |
| 281 | if (xen_initial_domain() && (xen_extra_mem_start < (1ULL<<32))) |
| 282 | xen_extra_mem_start = (1ULL<<32); |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 283 | |
| 284 | /* |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 285 | * In domU, the ISA region is normal, usable memory, but we |
| 286 | * reserve ISA memory anyway because too many things poke |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 287 | * about in there. |
Juan Quintela | 4ec5387 | 2010-09-02 15:45:43 +0100 | [diff] [blame] | 288 | * |
Ian Campbell | 9ec23a7f | 2010-10-28 11:32:29 -0700 | [diff] [blame] | 289 | * In Dom0, the host E820 information can leave gaps in the |
| 290 | * ISA range, which would cause us to release those pages. To |
| 291 | * avoid this, we unconditionally reserve them here. |
Jeremy Fitzhardinge | b792c75 | 2008-06-16 14:54:49 -0700 | [diff] [blame] | 292 | */ |
| 293 | e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS, |
| 294 | E820_RESERVED); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 295 | |
Jeremy Fitzhardinge | be5bf9f | 2008-06-16 14:54:46 -0700 | [diff] [blame] | 296 | /* |
| 297 | * Reserve Xen bits: |
| 298 | * - mfn_list |
| 299 | * - xen_start_info |
| 300 | * See comment above "struct start_info" in <xen/interface/xen.h> |
| 301 | */ |
Yinghai Lu | a9ce6bc | 2010-08-25 13:39:17 -0700 | [diff] [blame] | 302 | memblock_x86_reserve_range(__pa(xen_start_info->mfn_list), |
Jeremy Fitzhardinge | 6b2e852 | 2009-05-07 11:56:49 -0700 | [diff] [blame] | 303 | __pa(xen_start_info->pt_base), |
| 304 | "XEN START INFO"); |
Jeremy Fitzhardinge | be5bf9f | 2008-06-16 14:54:46 -0700 | [diff] [blame] | 305 | |
| 306 | sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); |
| 307 | |
David Vrabel | d312ae87 | 2011-08-19 15:57:16 +0100 | [diff] [blame] | 308 | extra_limit = xen_get_max_pages(); |
David Vrabel | e3b73c4 | 2011-09-13 10:17:32 -0400 | [diff] [blame] | 309 | if (max_pfn + extra_pages > extra_limit) { |
| 310 | if (extra_limit > max_pfn) |
| 311 | extra_pages = extra_limit - max_pfn; |
| 312 | else |
| 313 | extra_pages = 0; |
| 314 | } |
David Vrabel | d312ae87 | 2011-08-19 15:57:16 +0100 | [diff] [blame] | 315 | |
Jeremy Fitzhardinge | 42ee147 | 2010-08-30 16:41:02 -0700 | [diff] [blame] | 316 | extra_pages += xen_return_unused_memory(xen_start_info->nr_pages, &e820); |
| 317 | |
Jeremy Fitzhardinge | 698bb8d | 2010-09-14 10:19:14 -0700 | [diff] [blame] | 318 | /* |
| 319 | * Clamp the amount of extra memory to a EXTRA_MEM_RATIO |
| 320 | * factor the base size. On non-highmem systems, the base |
| 321 | * size is the full initial memory allocation; on highmem it |
| 322 | * is limited to the max size of lowmem, so that it doesn't |
| 323 | * get completely filled. |
| 324 | * |
| 325 | * In principle there could be a problem in lowmem systems if |
| 326 | * the initial memory is also very large with respect to |
| 327 | * lowmem, but we won't try to deal with that here. |
| 328 | */ |
| 329 | extra_limit = min(EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)), |
| 330 | max_pfn + extra_pages); |
| 331 | |
| 332 | if (extra_limit >= max_pfn) |
| 333 | extra_pages = extra_limit - max_pfn; |
| 334 | else |
| 335 | extra_pages = 0; |
| 336 | |
Jeremy Fitzhardinge | d2a8171 | 2010-11-19 23:27:06 -0800 | [diff] [blame] | 337 | xen_add_extra_mem(extra_pages); |
Miroslav Rezanina | 093d7b4 | 2009-09-16 03:56:17 -0400 | [diff] [blame] | 338 | |
Konrad Rzeszutek Wilk | 68df0da | 2011-02-01 17:15:30 -0500 | [diff] [blame] | 339 | /* |
| 340 | * Set P2M for all non-RAM pages and E820 gaps to be identity |
| 341 | * type PFNs. We supply it with the non-sanitized version |
| 342 | * of the E820. |
| 343 | */ |
| 344 | identity_pages = xen_set_identity(map_raw, memmap.nr_entries); |
| 345 | printk(KERN_INFO "Set %ld page(s) to 1-1 mapping.\n", identity_pages); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 346 | return "Xen"; |
| 347 | } |
| 348 | |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 349 | /* |
| 350 | * Set the bit indicating "nosegneg" library variants should be used. |
Jeremy Fitzhardinge | 6a52e4b | 2008-07-12 02:22:00 -0700 | [diff] [blame] | 351 | * We only need to bother in pure 32-bit mode; compat 32-bit processes |
| 352 | * can have un-truncated segments, so wrapping around is allowed. |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 353 | */ |
Sam Ravnborg | 08b6d29 | 2008-01-30 13:33:25 +0100 | [diff] [blame] | 354 | static void __init fiddle_vdso(void) |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 355 | { |
Jeremy Fitzhardinge | 6a52e4b | 2008-07-12 02:22:00 -0700 | [diff] [blame] | 356 | #ifdef CONFIG_X86_32 |
| 357 | u32 *mask; |
| 358 | mask = VDSO32_SYMBOL(&vdso32_int80_start, NOTE_MASK); |
| 359 | *mask |= 1 << VDSO_NOTE_NONEGSEG_BIT; |
| 360 | mask = VDSO32_SYMBOL(&vdso32_sysenter_start, NOTE_MASK); |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 361 | *mask |= 1 << VDSO_NOTE_NONEGSEG_BIT; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 362 | #endif |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 363 | } |
| 364 | |
Daniel Kiper | ae15a3b | 2011-05-04 20:17:21 +0200 | [diff] [blame] | 365 | static int __cpuinit register_callback(unsigned type, const void *func) |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 366 | { |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 367 | struct callback_register callback = { |
| 368 | .type = type, |
| 369 | .address = XEN_CALLBACK(__KERNEL_CS, func), |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 370 | .flags = CALLBACKF_mask_events, |
| 371 | }; |
| 372 | |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 373 | return HYPERVISOR_callback_op(CALLBACKOP_register, &callback); |
| 374 | } |
| 375 | |
| 376 | void __cpuinit xen_enable_sysenter(void) |
| 377 | { |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 378 | int ret; |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 379 | unsigned sysenter_feature; |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 380 | |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 381 | #ifdef CONFIG_X86_32 |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 382 | sysenter_feature = X86_FEATURE_SEP; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 383 | #else |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 384 | sysenter_feature = X86_FEATURE_SYSENTER32; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 385 | #endif |
| 386 | |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 387 | if (!boot_cpu_has(sysenter_feature)) |
| 388 | return; |
| 389 | |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 390 | ret = register_callback(CALLBACKTYPE_sysenter, xen_sysenter_target); |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 391 | if(ret != 0) |
| 392 | setup_clear_cpu_cap(sysenter_feature); |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 393 | } |
| 394 | |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 395 | void __cpuinit xen_enable_syscall(void) |
| 396 | { |
| 397 | #ifdef CONFIG_X86_64 |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 398 | int ret; |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 399 | |
| 400 | ret = register_callback(CALLBACKTYPE_syscall, xen_syscall_target); |
| 401 | if (ret != 0) { |
Jeremy Fitzhardinge | d5303b8 | 2008-07-12 02:22:06 -0700 | [diff] [blame] | 402 | printk(KERN_ERR "Failed to set syscall callback: %d\n", ret); |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 403 | /* Pretty fatal; 64-bit userspace has no other |
| 404 | mechanism for syscalls. */ |
| 405 | } |
| 406 | |
| 407 | if (boot_cpu_has(X86_FEATURE_SYSCALL32)) { |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 408 | ret = register_callback(CALLBACKTYPE_syscall32, |
| 409 | xen_syscall32_target); |
Jeremy Fitzhardinge | d5303b8 | 2008-07-12 02:22:06 -0700 | [diff] [blame] | 410 | if (ret != 0) |
Jeremy Fitzhardinge | 62541c3 | 2008-07-10 16:24:08 -0700 | [diff] [blame] | 411 | setup_clear_cpu_cap(X86_FEATURE_SYSCALL32); |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 412 | } |
| 413 | #endif /* CONFIG_X86_64 */ |
| 414 | } |
| 415 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 416 | void __init xen_arch_setup(void) |
| 417 | { |
Donald Dutile | f09f6d1 | 2010-07-15 14:56:49 -0400 | [diff] [blame] | 418 | xen_panic_handler_init(); |
| 419 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 420 | HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments); |
| 421 | HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables); |
| 422 | |
| 423 | if (!xen_feature(XENFEAT_auto_translated_physmap)) |
Tej | f63c2f2 | 2008-12-16 11:56:06 -0800 | [diff] [blame] | 424 | HYPERVISOR_vm_assist(VMASST_CMD_enable, |
| 425 | VMASST_TYPE_pae_extended_cr3); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 426 | |
Jeremy Fitzhardinge | 88459d4 | 2008-07-08 15:07:02 -0700 | [diff] [blame] | 427 | if (register_callback(CALLBACKTYPE_event, xen_hypervisor_callback) || |
| 428 | register_callback(CALLBACKTYPE_failsafe, xen_failsafe_callback)) |
| 429 | BUG(); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 430 | |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 431 | xen_enable_sysenter(); |
Jeremy Fitzhardinge | 6fcac6d | 2008-07-08 15:07:14 -0700 | [diff] [blame] | 432 | xen_enable_syscall(); |
Jeremy Fitzhardinge | e2a81ba | 2008-03-17 16:37:17 -0700 | [diff] [blame] | 433 | |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 434 | #ifdef CONFIG_ACPI |
| 435 | if (!(xen_start_info->flags & SIF_INITDOMAIN)) { |
| 436 | printk(KERN_INFO "ACPI in unprivileged domain disabled\n"); |
| 437 | disable_acpi(); |
| 438 | } |
| 439 | #endif |
| 440 | |
| 441 | memcpy(boot_command_line, xen_start_info->cmd_line, |
| 442 | MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ? |
| 443 | COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE); |
| 444 | |
Jeremy Fitzhardinge | bc15fde | 2010-11-22 17:17:50 -0800 | [diff] [blame] | 445 | /* Set up idle, making sure it calls safe_halt() pvop */ |
| 446 | #ifdef CONFIG_X86_32 |
| 447 | boot_cpu_data.hlt_works_ok = 1; |
| 448 | #endif |
Len Brown | d91ee58 | 2011-04-01 18:28:35 -0400 | [diff] [blame] | 449 | disable_cpuidle(); |
Stefano Stabellini | 23febed | 2011-01-26 17:07:27 +0000 | [diff] [blame] | 450 | boot_option_idle_override = IDLE_HALT; |
Jeremy Fitzhardinge | f87e4ca | 2007-07-17 18:37:06 -0700 | [diff] [blame] | 451 | |
Roland McGrath | d2eea68 | 2007-07-20 00:31:43 -0700 | [diff] [blame] | 452 | fiddle_vdso(); |
Jeremy Fitzhardinge | 5ead97c | 2007-07-17 18:37:04 -0700 | [diff] [blame] | 453 | } |