2 * Machine specific setup for xen
4 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
7 #include <linux/init.h>
8 #include <linux/sched.h>
11 #include <linux/memblock.h>
12 #include <linux/cpuidle.h>
13 #include <linux/cpufreq.h>
17 #include <asm/e820/api.h>
18 #include <asm/setup.h>
21 #include <asm/xen/hypervisor.h>
22 #include <asm/xen/hypercall.h>
26 #include <xen/interface/callback.h>
27 #include <xen/interface/memory.h>
28 #include <xen/interface/physdev.h>
29 #include <xen/features.h>
30 #include <xen/hvc-console.h>
35 #define GB(x) ((uint64_t)(x) * 1024 * 1024 * 1024)
37 /* Amount of extra memory space we add to the e820 ranges */
38 struct xen_memory_region xen_extra_mem
[XEN_EXTRA_MEM_MAX_REGIONS
] __initdata
;
40 /* Number of pages released from the initial allocation. */
41 unsigned long xen_released_pages
;
43 /* E820 map used during setting up memory. */
44 static struct e820_table xen_e820_table __initdata
;
47 * Buffer used to remap identity mapped pages. We only need the virtual space.
48 * The physical page behind this address is remapped as needed to different
51 #define REMAP_SIZE (P2M_PER_PAGE - 3)
53 unsigned long next_area_mfn
;
54 unsigned long target_pfn
;
56 unsigned long mfns
[REMAP_SIZE
];
57 } xen_remap_buf __initdata
__aligned(PAGE_SIZE
);
58 static unsigned long xen_remap_mfn __initdata
= INVALID_P2M_ENTRY
;
61 * The maximum amount of extra memory compared to the base size. The
62 * main scaling factor is the size of struct page. At extreme ratios
63 * of base:extra, all the base memory can be filled with page
64 * structures for the extra memory, leaving no space for anything
67 * 10x seems like a reasonable balance between scaling flexibility and
68 * leaving a practically usable system.
70 #define EXTRA_MEM_RATIO (10)
72 static bool xen_512gb_limit __initdata
= IS_ENABLED(CONFIG_XEN_512GB
);
74 static void __init
xen_parse_512gb(void)
79 arg
= strstr(xen_start_info
->cmd_line
, "xen_512gb_limit");
83 arg
= strstr(xen_start_info
->cmd_line
, "xen_512gb_limit=");
86 else if (strtobool(arg
+ strlen("xen_512gb_limit="), &val
))
89 xen_512gb_limit
= val
;
92 static void __init
xen_add_extra_mem(unsigned long start_pfn
,
98 * No need to check for zero size, should happen rarely and will only
99 * write a new entry regarded to be unused due to zero size.
101 for (i
= 0; i
< XEN_EXTRA_MEM_MAX_REGIONS
; i
++) {
102 /* Add new region. */
103 if (xen_extra_mem
[i
].n_pfns
== 0) {
104 xen_extra_mem
[i
].start_pfn
= start_pfn
;
105 xen_extra_mem
[i
].n_pfns
= n_pfns
;
108 /* Append to existing region. */
109 if (xen_extra_mem
[i
].start_pfn
+ xen_extra_mem
[i
].n_pfns
==
111 xen_extra_mem
[i
].n_pfns
+= n_pfns
;
115 if (i
== XEN_EXTRA_MEM_MAX_REGIONS
)
116 printk(KERN_WARNING
"Warning: not enough extra memory regions\n");
118 memblock_reserve(PFN_PHYS(start_pfn
), PFN_PHYS(n_pfns
));
121 static void __init
xen_del_extra_mem(unsigned long start_pfn
,
122 unsigned long n_pfns
)
125 unsigned long start_r
, size_r
;
127 for (i
= 0; i
< XEN_EXTRA_MEM_MAX_REGIONS
; i
++) {
128 start_r
= xen_extra_mem
[i
].start_pfn
;
129 size_r
= xen_extra_mem
[i
].n_pfns
;
131 /* Start of region. */
132 if (start_r
== start_pfn
) {
133 BUG_ON(n_pfns
> size_r
);
134 xen_extra_mem
[i
].start_pfn
+= n_pfns
;
135 xen_extra_mem
[i
].n_pfns
-= n_pfns
;
139 if (start_r
+ size_r
== start_pfn
+ n_pfns
) {
140 BUG_ON(n_pfns
> size_r
);
141 xen_extra_mem
[i
].n_pfns
-= n_pfns
;
145 if (start_pfn
> start_r
&& start_pfn
< start_r
+ size_r
) {
146 BUG_ON(start_pfn
+ n_pfns
> start_r
+ size_r
);
147 xen_extra_mem
[i
].n_pfns
= start_pfn
- start_r
;
148 /* Calling memblock_reserve() again is okay. */
149 xen_add_extra_mem(start_pfn
+ n_pfns
, start_r
+ size_r
-
150 (start_pfn
+ n_pfns
));
154 memblock_free(PFN_PHYS(start_pfn
), PFN_PHYS(n_pfns
));
158 * Called during boot before the p2m list can take entries beyond the
159 * hypervisor supplied p2m list. Entries in extra mem are to be regarded as
162 unsigned long __ref
xen_chk_extra_mem(unsigned long pfn
)
166 for (i
= 0; i
< XEN_EXTRA_MEM_MAX_REGIONS
; i
++) {
167 if (pfn
>= xen_extra_mem
[i
].start_pfn
&&
168 pfn
< xen_extra_mem
[i
].start_pfn
+ xen_extra_mem
[i
].n_pfns
)
169 return INVALID_P2M_ENTRY
;
172 return IDENTITY_FRAME(pfn
);
176 * Mark all pfns of extra mem as invalid in p2m list.
178 void __init
xen_inv_extra_mem(void)
180 unsigned long pfn
, pfn_s
, pfn_e
;
183 for (i
= 0; i
< XEN_EXTRA_MEM_MAX_REGIONS
; i
++) {
184 if (!xen_extra_mem
[i
].n_pfns
)
186 pfn_s
= xen_extra_mem
[i
].start_pfn
;
187 pfn_e
= pfn_s
+ xen_extra_mem
[i
].n_pfns
;
188 for (pfn
= pfn_s
; pfn
< pfn_e
; pfn
++)
189 set_phys_to_machine(pfn
, INVALID_P2M_ENTRY
);
194 * Finds the next RAM pfn available in the E820 map after min_pfn.
195 * This function updates min_pfn with the pfn found and returns
196 * the size of that range or zero if not found.
198 static unsigned long __init
xen_find_pfn_range(unsigned long *min_pfn
)
200 const struct e820_entry
*entry
= xen_e820_table
.entries
;
202 unsigned long done
= 0;
204 for (i
= 0; i
< xen_e820_table
.nr_entries
; i
++, entry
++) {
208 if (entry
->type
!= E820_TYPE_RAM
)
211 e_pfn
= PFN_DOWN(entry
->addr
+ entry
->size
);
213 /* We only care about E820 after this */
214 if (e_pfn
<= *min_pfn
)
217 s_pfn
= PFN_UP(entry
->addr
);
219 /* If min_pfn falls within the E820 entry, we want to start
220 * at the min_pfn PFN.
222 if (s_pfn
<= *min_pfn
) {
223 done
= e_pfn
- *min_pfn
;
225 done
= e_pfn
- s_pfn
;
234 static int __init
xen_free_mfn(unsigned long mfn
)
236 struct xen_memory_reservation reservation
= {
242 set_xen_guest_handle(reservation
.extent_start
, &mfn
);
243 reservation
.nr_extents
= 1;
245 return HYPERVISOR_memory_op(XENMEM_decrease_reservation
, &reservation
);
249 * This releases a chunk of memory and then does the identity map. It's used
250 * as a fallback if the remapping fails.
252 static void __init
xen_set_identity_and_release_chunk(unsigned long start_pfn
,
253 unsigned long end_pfn
, unsigned long nr_pages
)
255 unsigned long pfn
, end
;
258 WARN_ON(start_pfn
> end_pfn
);
260 /* Release pages first. */
261 end
= min(end_pfn
, nr_pages
);
262 for (pfn
= start_pfn
; pfn
< end
; pfn
++) {
263 unsigned long mfn
= pfn_to_mfn(pfn
);
265 /* Make sure pfn exists to start with */
266 if (mfn
== INVALID_P2M_ENTRY
|| mfn_to_pfn(mfn
) != pfn
)
269 ret
= xen_free_mfn(mfn
);
270 WARN(ret
!= 1, "Failed to release pfn %lx err=%d\n", pfn
, ret
);
273 xen_released_pages
++;
274 if (!__set_phys_to_machine(pfn
, INVALID_P2M_ENTRY
))
280 set_phys_range_identity(start_pfn
, end_pfn
);
284 * Helper function to update the p2m and m2p tables and kernel mapping.
286 static void __init
xen_update_mem_tables(unsigned long pfn
, unsigned long mfn
)
288 struct mmu_update update
= {
289 .ptr
= ((uint64_t)mfn
<< PAGE_SHIFT
) | MMU_MACHPHYS_UPDATE
,
294 if (!set_phys_to_machine(pfn
, mfn
)) {
295 WARN(1, "Failed to set p2m mapping for pfn=%ld mfn=%ld\n",
301 if (HYPERVISOR_mmu_update(&update
, 1, NULL
, DOMID_SELF
) < 0) {
302 WARN(1, "Failed to set m2p mapping for mfn=%ld pfn=%ld\n",
307 /* Update kernel mapping, but not for highmem. */
308 if (pfn
>= PFN_UP(__pa(high_memory
- 1)))
311 if (HYPERVISOR_update_va_mapping((unsigned long)__va(pfn
<< PAGE_SHIFT
),
312 mfn_pte(mfn
, PAGE_KERNEL
), 0)) {
313 WARN(1, "Failed to update kernel mapping for mfn=%ld pfn=%ld\n",
320 * This function updates the p2m and m2p tables with an identity map from
321 * start_pfn to start_pfn+size and prepares remapping the underlying RAM of the
322 * original allocation at remap_pfn. The information needed for remapping is
323 * saved in the memory itself to avoid the need for allocating buffers. The
324 * complete remap information is contained in a list of MFNs each containing
325 * up to REMAP_SIZE MFNs and the start target PFN for doing the remap.
326 * This enables us to preserve the original mfn sequence while doing the
327 * remapping at a time when the memory management is capable of allocating
328 * virtual and physical memory in arbitrary amounts, see 'xen_remap_memory' and
331 static void __init
xen_do_set_identity_and_remap_chunk(
332 unsigned long start_pfn
, unsigned long size
, unsigned long remap_pfn
)
334 unsigned long buf
= (unsigned long)&xen_remap_buf
;
335 unsigned long mfn_save
, mfn
;
336 unsigned long ident_pfn_iter
, remap_pfn_iter
;
337 unsigned long ident_end_pfn
= start_pfn
+ size
;
338 unsigned long left
= size
;
339 unsigned int i
, chunk
;
343 mfn_save
= virt_to_mfn(buf
);
345 for (ident_pfn_iter
= start_pfn
, remap_pfn_iter
= remap_pfn
;
346 ident_pfn_iter
< ident_end_pfn
;
347 ident_pfn_iter
+= REMAP_SIZE
, remap_pfn_iter
+= REMAP_SIZE
) {
348 chunk
= (left
< REMAP_SIZE
) ? left
: REMAP_SIZE
;
350 /* Map first pfn to xen_remap_buf */
351 mfn
= pfn_to_mfn(ident_pfn_iter
);
352 set_pte_mfn(buf
, mfn
, PAGE_KERNEL
);
354 /* Save mapping information in page */
355 xen_remap_buf
.next_area_mfn
= xen_remap_mfn
;
356 xen_remap_buf
.target_pfn
= remap_pfn_iter
;
357 xen_remap_buf
.size
= chunk
;
358 for (i
= 0; i
< chunk
; i
++)
359 xen_remap_buf
.mfns
[i
] = pfn_to_mfn(ident_pfn_iter
+ i
);
361 /* Put remap buf into list. */
364 /* Set identity map */
365 set_phys_range_identity(ident_pfn_iter
, ident_pfn_iter
+ chunk
);
370 /* Restore old xen_remap_buf mapping */
371 set_pte_mfn(buf
, mfn_save
, PAGE_KERNEL
);
375 * This function takes a contiguous pfn range that needs to be identity mapped
378 * 1) Finds a new range of pfns to use to remap based on E820 and remap_pfn.
379 * 2) Calls the do_ function to actually do the mapping/remapping work.
381 * The goal is to not allocate additional memory but to remap the existing
382 * pages. In the case of an error the underlying memory is simply released back
383 * to Xen and not remapped.
385 static unsigned long __init
xen_set_identity_and_remap_chunk(
386 unsigned long start_pfn
, unsigned long end_pfn
, unsigned long nr_pages
,
387 unsigned long remap_pfn
)
391 unsigned long n
= end_pfn
- start_pfn
;
394 remap_pfn
= nr_pages
;
397 unsigned long cur_pfn
= start_pfn
+ i
;
398 unsigned long left
= n
- i
;
399 unsigned long size
= left
;
400 unsigned long remap_range_size
;
402 /* Do not remap pages beyond the current allocation */
403 if (cur_pfn
>= nr_pages
) {
404 /* Identity map remaining pages */
405 set_phys_range_identity(cur_pfn
, cur_pfn
+ size
);
408 if (cur_pfn
+ size
> nr_pages
)
409 size
= nr_pages
- cur_pfn
;
411 remap_range_size
= xen_find_pfn_range(&remap_pfn
);
412 if (!remap_range_size
) {
413 pr_warning("Unable to find available pfn range, not remapping identity pages\n");
414 xen_set_identity_and_release_chunk(cur_pfn
,
415 cur_pfn
+ left
, nr_pages
);
418 /* Adjust size to fit in current e820 RAM region */
419 if (size
> remap_range_size
)
420 size
= remap_range_size
;
422 xen_do_set_identity_and_remap_chunk(cur_pfn
, size
, remap_pfn
);
424 /* Update variables to reflect new mappings. */
430 * If the PFNs are currently mapped, the VA mapping also needs
431 * to be updated to be 1:1.
433 for (pfn
= start_pfn
; pfn
<= max_pfn_mapped
&& pfn
< end_pfn
; pfn
++)
434 (void)HYPERVISOR_update_va_mapping(
435 (unsigned long)__va(pfn
<< PAGE_SHIFT
),
436 mfn_pte(pfn
, PAGE_KERNEL_IO
), 0);
441 static unsigned long __init
xen_count_remap_pages(
442 unsigned long start_pfn
, unsigned long end_pfn
, unsigned long nr_pages
,
443 unsigned long remap_pages
)
445 if (start_pfn
>= nr_pages
)
448 return remap_pages
+ min(end_pfn
, nr_pages
) - start_pfn
;
451 static unsigned long __init
xen_foreach_remap_area(unsigned long nr_pages
,
452 unsigned long (*func
)(unsigned long start_pfn
, unsigned long end_pfn
,
453 unsigned long nr_pages
, unsigned long last_val
))
455 phys_addr_t start
= 0;
456 unsigned long ret_val
= 0;
457 const struct e820_entry
*entry
= xen_e820_table
.entries
;
461 * Combine non-RAM regions and gaps until a RAM region (or the
462 * end of the map) is reached, then call the provided function
463 * to perform its duty on the non-RAM region.
465 * The combined non-RAM regions are rounded to a whole number
466 * of pages so any partial pages are accessible via the 1:1
467 * mapping. This is needed for some BIOSes that put (for
468 * example) the DMI tables in a reserved region that begins on
469 * a non-page boundary.
471 for (i
= 0; i
< xen_e820_table
.nr_entries
; i
++, entry
++) {
472 phys_addr_t end
= entry
->addr
+ entry
->size
;
473 if (entry
->type
== E820_TYPE_RAM
|| i
== xen_e820_table
.nr_entries
- 1) {
474 unsigned long start_pfn
= PFN_DOWN(start
);
475 unsigned long end_pfn
= PFN_UP(end
);
477 if (entry
->type
== E820_TYPE_RAM
)
478 end_pfn
= PFN_UP(entry
->addr
);
480 if (start_pfn
< end_pfn
)
481 ret_val
= func(start_pfn
, end_pfn
, nr_pages
,
491 * Remap the memory prepared in xen_do_set_identity_and_remap_chunk().
492 * The remap information (which mfn remap to which pfn) is contained in the
493 * to be remapped memory itself in a linked list anchored at xen_remap_mfn.
494 * This scheme allows to remap the different chunks in arbitrary order while
495 * the resulting mapping will be independant from the order.
497 void __init
xen_remap_memory(void)
499 unsigned long buf
= (unsigned long)&xen_remap_buf
;
500 unsigned long mfn_save
, pfn
;
501 unsigned long remapped
= 0;
503 unsigned long pfn_s
= ~0UL;
504 unsigned long len
= 0;
506 mfn_save
= virt_to_mfn(buf
);
508 while (xen_remap_mfn
!= INVALID_P2M_ENTRY
) {
509 /* Map the remap information */
510 set_pte_mfn(buf
, xen_remap_mfn
, PAGE_KERNEL
);
512 BUG_ON(xen_remap_mfn
!= xen_remap_buf
.mfns
[0]);
514 pfn
= xen_remap_buf
.target_pfn
;
515 for (i
= 0; i
< xen_remap_buf
.size
; i
++) {
516 xen_update_mem_tables(pfn
, xen_remap_buf
.mfns
[i
]);
520 if (pfn_s
== ~0UL || pfn
== pfn_s
) {
521 pfn_s
= xen_remap_buf
.target_pfn
;
522 len
+= xen_remap_buf
.size
;
523 } else if (pfn_s
+ len
== xen_remap_buf
.target_pfn
) {
524 len
+= xen_remap_buf
.size
;
526 xen_del_extra_mem(pfn_s
, len
);
527 pfn_s
= xen_remap_buf
.target_pfn
;
528 len
= xen_remap_buf
.size
;
530 xen_remap_mfn
= xen_remap_buf
.next_area_mfn
;
533 if (pfn_s
!= ~0UL && len
)
534 xen_del_extra_mem(pfn_s
, len
);
536 set_pte_mfn(buf
, mfn_save
, PAGE_KERNEL
);
538 pr_info("Remapped %ld page(s)\n", remapped
);
541 static unsigned long __init
xen_get_pages_limit(void)
546 limit
= GB(64) / PAGE_SIZE
;
548 limit
= MAXMEM
/ PAGE_SIZE
;
549 if (!xen_initial_domain() && xen_512gb_limit
)
550 limit
= GB(512) / PAGE_SIZE
;
555 static unsigned long __init
xen_get_max_pages(void)
557 unsigned long max_pages
, limit
;
558 domid_t domid
= DOMID_SELF
;
561 limit
= xen_get_pages_limit();
565 * For the initial domain we use the maximum reservation as
568 * For guest domains the current maximum reservation reflects
569 * the current maximum rather than the static maximum. In this
570 * case the e820 map provided to us will cover the static
573 if (xen_initial_domain()) {
574 ret
= HYPERVISOR_memory_op(XENMEM_maximum_reservation
, &domid
);
579 return min(max_pages
, limit
);
582 static void __init
xen_align_and_add_e820_region(phys_addr_t start
,
583 phys_addr_t size
, int type
)
585 phys_addr_t end
= start
+ size
;
587 /* Align RAM regions to page boundaries. */
588 if (type
== E820_TYPE_RAM
) {
589 start
= PAGE_ALIGN(start
);
590 end
&= ~((phys_addr_t
)PAGE_SIZE
- 1);
593 e820__range_add(start
, end
- start
, type
);
596 static void __init
xen_ignore_unusable(void)
598 struct e820_entry
*entry
= xen_e820_table
.entries
;
601 for (i
= 0; i
< xen_e820_table
.nr_entries
; i
++, entry
++) {
602 if (entry
->type
== E820_TYPE_UNUSABLE
)
603 entry
->type
= E820_TYPE_RAM
;
607 bool __init
xen_is_e820_reserved(phys_addr_t start
, phys_addr_t size
)
609 struct e820_entry
*entry
;
617 entry
= xen_e820_table
.entries
;
619 for (mapcnt
= 0; mapcnt
< xen_e820_table
.nr_entries
; mapcnt
++) {
620 if (entry
->type
== E820_TYPE_RAM
&& entry
->addr
<= start
&&
621 (entry
->addr
+ entry
->size
) >= end
)
631 * Find a free area in physical memory not yet reserved and compliant with
633 * Used to relocate pre-allocated areas like initrd or p2m list which are in
634 * conflict with the to be used E820 map.
635 * In case no area is found, return 0. Otherwise return the physical address
636 * of the area which is already reserved for convenience.
638 phys_addr_t __init
xen_find_free_area(phys_addr_t size
)
641 phys_addr_t addr
, start
;
642 struct e820_entry
*entry
= xen_e820_table
.entries
;
644 for (mapcnt
= 0; mapcnt
< xen_e820_table
.nr_entries
; mapcnt
++, entry
++) {
645 if (entry
->type
!= E820_TYPE_RAM
|| entry
->size
< size
)
648 for (addr
= start
; addr
< start
+ size
; addr
+= PAGE_SIZE
) {
649 if (!memblock_is_reserved(addr
))
651 start
= addr
+ PAGE_SIZE
;
652 if (start
+ size
> entry
->addr
+ entry
->size
)
655 if (addr
>= start
+ size
) {
656 memblock_reserve(start
, size
);
665 * Like memcpy, but with physical addresses for dest and src.
667 static void __init
xen_phys_memcpy(phys_addr_t dest
, phys_addr_t src
,
670 phys_addr_t dest_off
, src_off
, dest_len
, src_len
, len
;
674 dest_off
= dest
& ~PAGE_MASK
;
675 src_off
= src
& ~PAGE_MASK
;
677 if (dest_len
> (NR_FIX_BTMAPS
<< PAGE_SHIFT
) - dest_off
)
678 dest_len
= (NR_FIX_BTMAPS
<< PAGE_SHIFT
) - dest_off
;
680 if (src_len
> (NR_FIX_BTMAPS
<< PAGE_SHIFT
) - src_off
)
681 src_len
= (NR_FIX_BTMAPS
<< PAGE_SHIFT
) - src_off
;
682 len
= min(dest_len
, src_len
);
683 to
= early_memremap(dest
- dest_off
, dest_len
+ dest_off
);
684 from
= early_memremap(src
- src_off
, src_len
+ src_off
);
685 memcpy(to
, from
, len
);
686 early_memunmap(to
, dest_len
+ dest_off
);
687 early_memunmap(from
, src_len
+ src_off
);
695 * Reserve Xen mfn_list.
697 static void __init
xen_reserve_xen_mfnlist(void)
699 phys_addr_t start
, size
;
701 if (xen_start_info
->mfn_list
>= __START_KERNEL_map
) {
702 start
= __pa(xen_start_info
->mfn_list
);
703 size
= PFN_ALIGN(xen_start_info
->nr_pages
*
704 sizeof(unsigned long));
706 start
= PFN_PHYS(xen_start_info
->first_p2m_pfn
);
707 size
= PFN_PHYS(xen_start_info
->nr_p2m_frames
);
710 memblock_reserve(start
, size
);
711 if (!xen_is_e820_reserved(start
, size
))
716 * Relocating the p2m on 32 bit system to an arbitrary virtual address
717 * is not supported, so just give up.
719 xen_raw_console_write("Xen hypervisor allocated p2m list conflicts with E820 map\n");
723 memblock_free(start
, size
);
728 * machine_specific_memory_setup - Hook for machine specific memory setup.
730 char * __init
xen_memory_setup(void)
732 unsigned long max_pfn
, pfn_s
, n_pfns
;
733 phys_addr_t mem_end
, addr
, size
, chunk_size
;
736 struct xen_memory_map memmap
;
737 unsigned long max_pages
;
738 unsigned long extra_pages
= 0;
743 max_pfn
= xen_get_pages_limit();
744 max_pfn
= min(max_pfn
, xen_start_info
->nr_pages
);
745 mem_end
= PFN_PHYS(max_pfn
);
747 memmap
.nr_entries
= ARRAY_SIZE(xen_e820_table
.entries
);
748 set_xen_guest_handle(memmap
.buffer
, xen_e820_table
.entries
);
750 op
= xen_initial_domain() ?
751 XENMEM_machine_memory_map
:
753 rc
= HYPERVISOR_memory_op(op
, &memmap
);
755 BUG_ON(xen_initial_domain());
756 memmap
.nr_entries
= 1;
757 xen_e820_table
.entries
[0].addr
= 0ULL;
758 xen_e820_table
.entries
[0].size
= mem_end
;
759 /* 8MB slack (to balance backend allocations). */
760 xen_e820_table
.entries
[0].size
+= 8ULL << 20;
761 xen_e820_table
.entries
[0].type
= E820_TYPE_RAM
;
765 BUG_ON(memmap
.nr_entries
== 0);
766 xen_e820_table
.nr_entries
= memmap
.nr_entries
;
769 * Xen won't allow a 1:1 mapping to be created to UNUSABLE
770 * regions, so if we're using the machine memory map leave the
771 * region as RAM as it is in the pseudo-physical map.
773 * UNUSABLE regions in domUs are not handled and will need
774 * a patch in the future.
776 if (xen_initial_domain())
777 xen_ignore_unusable();
779 /* Make sure the Xen-supplied memory map is well-ordered. */
780 e820__update_table(&xen_e820_table
);
782 max_pages
= xen_get_max_pages();
784 /* How many extra pages do we need due to remapping? */
785 max_pages
+= xen_foreach_remap_area(max_pfn
, xen_count_remap_pages
);
787 if (max_pages
> max_pfn
)
788 extra_pages
+= max_pages
- max_pfn
;
791 * Clamp the amount of extra memory to a EXTRA_MEM_RATIO
792 * factor the base size. On non-highmem systems, the base
793 * size is the full initial memory allocation; on highmem it
794 * is limited to the max size of lowmem, so that it doesn't
795 * get completely filled.
797 * Make sure we have no memory above max_pages, as this area
798 * isn't handled by the p2m management.
800 * In principle there could be a problem in lowmem systems if
801 * the initial memory is also very large with respect to
802 * lowmem, but we won't try to deal with that here.
804 extra_pages
= min3(EXTRA_MEM_RATIO
* min(max_pfn
, PFN_DOWN(MAXMEM
)),
805 extra_pages
, max_pages
- max_pfn
);
807 addr
= xen_e820_table
.entries
[0].addr
;
808 size
= xen_e820_table
.entries
[0].size
;
809 while (i
< xen_e820_table
.nr_entries
) {
810 bool discard
= false;
813 type
= xen_e820_table
.entries
[i
].type
;
815 if (type
== E820_TYPE_RAM
) {
816 if (addr
< mem_end
) {
817 chunk_size
= min(size
, mem_end
- addr
);
818 } else if (extra_pages
) {
819 chunk_size
= min(size
, PFN_PHYS(extra_pages
));
820 pfn_s
= PFN_UP(addr
);
821 n_pfns
= PFN_DOWN(addr
+ chunk_size
) - pfn_s
;
822 extra_pages
-= n_pfns
;
823 xen_add_extra_mem(pfn_s
, n_pfns
);
824 xen_max_p2m_pfn
= pfn_s
+ n_pfns
;
830 xen_align_and_add_e820_region(addr
, chunk_size
, type
);
836 if (i
< xen_e820_table
.nr_entries
) {
837 addr
= xen_e820_table
.entries
[i
].addr
;
838 size
= xen_e820_table
.entries
[i
].size
;
844 * Set the rest as identity mapped, in case PCI BARs are
847 set_phys_range_identity(addr
/ PAGE_SIZE
, ~0ul);
850 * In domU, the ISA region is normal, usable memory, but we
851 * reserve ISA memory anyway because too many things poke
854 e820__range_add(ISA_START_ADDRESS
, ISA_END_ADDRESS
- ISA_START_ADDRESS
, E820_TYPE_RESERVED
);
856 e820__update_table(e820_table
);
859 * Check whether the kernel itself conflicts with the target E820 map.
860 * Failing now is better than running into weird problems later due
861 * to relocating (and even reusing) pages with kernel text or data.
863 if (xen_is_e820_reserved(__pa_symbol(_text
),
864 __pa_symbol(__bss_stop
) - __pa_symbol(_text
))) {
865 xen_raw_console_write("Xen hypervisor allocated kernel memory conflicts with E820 map\n");
870 * Check for a conflict of the hypervisor supplied page tables with
871 * the target E820 map.
875 xen_reserve_xen_mfnlist();
877 /* Check for a conflict of the initrd with the target E820 map. */
878 if (xen_is_e820_reserved(boot_params
.hdr
.ramdisk_image
,
879 boot_params
.hdr
.ramdisk_size
)) {
880 phys_addr_t new_area
, start
, size
;
882 new_area
= xen_find_free_area(boot_params
.hdr
.ramdisk_size
);
884 xen_raw_console_write("Can't find new memory area for initrd needed due to E820 map conflict\n");
888 start
= boot_params
.hdr
.ramdisk_image
;
889 size
= boot_params
.hdr
.ramdisk_size
;
890 xen_phys_memcpy(new_area
, start
, size
);
891 pr_info("initrd moved from [mem %#010llx-%#010llx] to [mem %#010llx-%#010llx]\n",
892 start
, start
+ size
, new_area
, new_area
+ size
);
893 memblock_free(start
, size
);
894 boot_params
.hdr
.ramdisk_image
= new_area
;
895 boot_params
.ext_ramdisk_image
= new_area
>> 32;
899 * Set identity map on non-RAM pages and prepare remapping the
902 xen_foreach_remap_area(max_pfn
, xen_set_identity_and_remap_chunk
);
904 pr_info("Released %ld page(s)\n", xen_released_pages
);
910 * Machine specific memory setup for auto-translated guests.
912 char * __init
xen_auto_xlated_memory_setup(void)
914 struct xen_memory_map memmap
;
918 memmap
.nr_entries
= ARRAY_SIZE(xen_e820_table
.entries
);
919 set_xen_guest_handle(memmap
.buffer
, xen_e820_table
.entries
);
921 rc
= HYPERVISOR_memory_op(XENMEM_memory_map
, &memmap
);
923 panic("No memory map (%d)\n", rc
);
925 xen_e820_table
.nr_entries
= memmap
.nr_entries
;
927 e820__update_table(&xen_e820_table
);
929 for (i
= 0; i
< xen_e820_table
.nr_entries
; i
++)
930 e820__range_add(xen_e820_table
.entries
[i
].addr
, xen_e820_table
.entries
[i
].size
, xen_e820_table
.entries
[i
].type
);
932 /* Remove p2m info, it is not needed. */
933 xen_start_info
->mfn_list
= 0;
934 xen_start_info
->first_p2m_pfn
= 0;
935 xen_start_info
->nr_p2m_frames
= 0;
941 * Set the bit indicating "nosegneg" library variants should be used.
942 * We only need to bother in pure 32-bit mode; compat 32-bit processes
943 * can have un-truncated segments, so wrapping around is allowed.
945 static void __init
fiddle_vdso(void)
948 u32
*mask
= vdso_image_32
.data
+
949 vdso_image_32
.sym_VDSO32_NOTE_MASK
;
950 *mask
|= 1 << VDSO_NOTE_NONEGSEG_BIT
;
954 static int register_callback(unsigned type
, const void *func
)
956 struct callback_register callback
= {
958 .address
= XEN_CALLBACK(__KERNEL_CS
, func
),
959 .flags
= CALLBACKF_mask_events
,
962 return HYPERVISOR_callback_op(CALLBACKOP_register
, &callback
);
965 void xen_enable_sysenter(void)
968 unsigned sysenter_feature
;
971 sysenter_feature
= X86_FEATURE_SEP
;
973 sysenter_feature
= X86_FEATURE_SYSENTER32
;
976 if (!boot_cpu_has(sysenter_feature
))
979 ret
= register_callback(CALLBACKTYPE_sysenter
, xen_sysenter_target
);
981 setup_clear_cpu_cap(sysenter_feature
);
984 void xen_enable_syscall(void)
989 ret
= register_callback(CALLBACKTYPE_syscall
, xen_syscall_target
);
991 printk(KERN_ERR
"Failed to set syscall callback: %d\n", ret
);
992 /* Pretty fatal; 64-bit userspace has no other
993 mechanism for syscalls. */
996 if (boot_cpu_has(X86_FEATURE_SYSCALL32
)) {
997 ret
= register_callback(CALLBACKTYPE_syscall32
,
998 xen_syscall32_target
);
1000 setup_clear_cpu_cap(X86_FEATURE_SYSCALL32
);
1002 #endif /* CONFIG_X86_64 */
1005 void __init
xen_pvmmu_arch_setup(void)
1007 HYPERVISOR_vm_assist(VMASST_CMD_enable
, VMASST_TYPE_4gb_segments
);
1008 HYPERVISOR_vm_assist(VMASST_CMD_enable
, VMASST_TYPE_writable_pagetables
);
1010 HYPERVISOR_vm_assist(VMASST_CMD_enable
,
1011 VMASST_TYPE_pae_extended_cr3
);
1013 if (register_callback(CALLBACKTYPE_event
, xen_hypervisor_callback
) ||
1014 register_callback(CALLBACKTYPE_failsafe
, xen_failsafe_callback
))
1017 xen_enable_sysenter();
1018 xen_enable_syscall();
1021 /* This function is not called for HVM domains */
1022 void __init
xen_arch_setup(void)
1024 xen_panic_handler_init();
1025 xen_pvmmu_arch_setup();
1028 if (!(xen_start_info
->flags
& SIF_INITDOMAIN
)) {
1029 printk(KERN_INFO
"ACPI in unprivileged domain disabled\n");
1034 memcpy(boot_command_line
, xen_start_info
->cmd_line
,
1035 MAX_GUEST_CMDLINE
> COMMAND_LINE_SIZE
?
1036 COMMAND_LINE_SIZE
: MAX_GUEST_CMDLINE
);
1038 /* Set up idle, making sure it calls safe_halt() pvop */
1041 WARN_ON(xen_set_default_idle());