2008-05-20 06:52:27 +07:00
|
|
|
/*
|
2005-04-17 05:20:36 +07:00
|
|
|
* arch/sparc64/mm/init.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1996-1999 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
* Copyright (C) 1997-1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
|
|
*/
|
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
#include <linux/module.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/hugetlb.h>
|
|
|
|
#include <linux/initrd.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/pagemap.h>
|
2006-06-27 16:53:52 +07:00
|
|
|
#include <linux/poison.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2005-09-07 05:19:30 +07:00
|
|
|
#include <linux/kprobes.h>
|
2005-09-22 11:49:32 +07:00
|
|
|
#include <linux/cache.h>
|
2005-09-30 07:58:26 +07:00
|
|
|
#include <linux/sort.h>
|
2007-05-26 05:49:59 +07:00
|
|
|
#include <linux/percpu.h>
|
2010-07-12 11:36:09 +07:00
|
|
|
#include <linux/memblock.h>
|
2008-04-23 19:40:25 +07:00
|
|
|
#include <linux/mmzone.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/gfp.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <asm/head.h>
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/oplib.h>
|
|
|
|
#include <asm/iommu.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/dma.h>
|
|
|
|
#include <asm/starfire.h>
|
|
|
|
#include <asm/tlb.h>
|
|
|
|
#include <asm/spitfire.h>
|
|
|
|
#include <asm/sections.h>
|
2006-02-02 06:55:21 +07:00
|
|
|
#include <asm/tsb.h>
|
2006-02-08 12:51:08 +07:00
|
|
|
#include <asm/hypervisor.h>
|
2006-06-22 05:35:28 +07:00
|
|
|
#include <asm/prom.h>
|
2007-05-26 05:49:59 +07:00
|
|
|
#include <asm/mdesc.h>
|
2008-03-26 11:51:40 +07:00
|
|
|
#include <asm/cpudata.h>
|
2008-08-13 08:33:56 +07:00
|
|
|
#include <asm/irq.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-17 11:08:45 +07:00
|
|
|
#include "init_64.h"
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
unsigned long kern_linear_pte_xor[4] __read_mostly;
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
/* A bitmap, two bits for every 256MB of physical memory. These two
|
|
|
|
* bits determine what page size we use for kernel linear
|
|
|
|
* translations. They form an index into kern_linear_pte_xor[]. The
|
|
|
|
* value in the indexed slot is XOR'd with the TLB miss virtual
|
|
|
|
* address to form the resulting TTE. The mapping is:
|
|
|
|
*
|
|
|
|
* 0 ==> 4MB
|
|
|
|
* 1 ==> 256MB
|
|
|
|
* 2 ==> 2GB
|
|
|
|
* 3 ==> 16GB
|
|
|
|
*
|
|
|
|
* All sun4v chips support 256MB pages. Only SPARC-T4 and later
|
|
|
|
* support 2GB pages, and hopefully future cpus will support the 16GB
|
|
|
|
* pages as well. For slots 2 and 3, we encode a 256MB TTE xor there
|
|
|
|
* if these larger page sizes are not supported by the cpu.
|
|
|
|
*
|
|
|
|
* It would be nice to determine this from the machine description
|
|
|
|
* 'cpu' properties, but we need to have this table setup before the
|
|
|
|
* MDESC is initialized.
|
2006-02-22 11:51:13 +07:00
|
|
|
*/
|
|
|
|
unsigned long kpte_linear_bitmap[KPTE_BITMAP_BYTES / sizeof(unsigned long)];
|
|
|
|
|
2007-03-17 07:20:28 +07:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2012-09-07 08:13:58 +07:00
|
|
|
/* A special kernel TSB for 4MB, 256MB, 2GB and 16GB linear mappings.
|
|
|
|
* Space is allocated for this right after the trap table in
|
|
|
|
* arch/sparc64/kernel/head.S
|
2007-05-29 15:58:31 +07:00
|
|
|
*/
|
|
|
|
extern struct tsb swapper_4m_tsb[KERNEL_TSB4M_NENTRIES];
|
2007-03-17 07:20:28 +07:00
|
|
|
#endif
|
2006-02-22 13:31:11 +07:00
|
|
|
|
2012-09-07 09:01:25 +07:00
|
|
|
static unsigned long cpu_pgsz_mask;
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
#define MAX_BANKS 32
|
|
|
|
|
2012-12-22 05:03:26 +07:00
|
|
|
static struct linux_prom64_registers pavail[MAX_BANKS];
|
|
|
|
static int pavail_ents;
|
2005-09-30 07:58:26 +07:00
|
|
|
|
|
|
|
static int cmp_p64(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const struct linux_prom64_registers *x = a, *y = b;
|
|
|
|
|
|
|
|
if (x->phys_addr > y->phys_addr)
|
|
|
|
return 1;
|
|
|
|
if (x->phys_addr < y->phys_addr)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init read_obp_memory(const char *property,
|
|
|
|
struct linux_prom64_registers *regs,
|
|
|
|
int *num_ents)
|
|
|
|
{
|
2010-10-09 04:18:11 +07:00
|
|
|
phandle node = prom_finddevice("/memory");
|
2005-09-30 07:58:26 +07:00
|
|
|
int prop_size = prom_getproplen(node, property);
|
|
|
|
int ents, ret, i;
|
|
|
|
|
|
|
|
ents = prop_size / sizeof(struct linux_prom64_registers);
|
|
|
|
if (ents > MAX_BANKS) {
|
|
|
|
prom_printf("The machine has more %s property entries than "
|
|
|
|
"this kernel can support (%d).\n",
|
|
|
|
property, MAX_BANKS);
|
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = prom_getproperty(node, property, (char *) regs, prop_size);
|
|
|
|
if (ret == -1) {
|
2012-09-29 10:14:49 +07:00
|
|
|
prom_printf("Couldn't get %s property from /memory.\n",
|
|
|
|
property);
|
2005-09-30 07:58:26 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sanitize what we got from the firmware, by page aligning
|
|
|
|
* everything.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < ents; i++) {
|
|
|
|
unsigned long base, size;
|
|
|
|
|
|
|
|
base = regs[i].phys_addr;
|
|
|
|
size = regs[i].reg_size;
|
2005-09-29 11:46:43 +07:00
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
size &= PAGE_MASK;
|
|
|
|
if (base & ~PAGE_MASK) {
|
|
|
|
unsigned long new_base = PAGE_ALIGN(base);
|
|
|
|
|
|
|
|
size -= new_base - base;
|
|
|
|
if ((long) size < 0L)
|
|
|
|
size = 0UL;
|
|
|
|
base = new_base;
|
|
|
|
}
|
2007-03-15 14:06:34 +07:00
|
|
|
if (size == 0UL) {
|
|
|
|
/* If it is empty, simply get rid of it.
|
|
|
|
* This simplifies the logic of the other
|
|
|
|
* functions that process these arrays.
|
|
|
|
*/
|
|
|
|
memmove(®s[i], ®s[i + 1],
|
|
|
|
(ents - i - 1) * sizeof(regs[0]));
|
2006-06-22 14:00:00 +07:00
|
|
|
i--;
|
2007-03-15 14:06:34 +07:00
|
|
|
ents--;
|
|
|
|
continue;
|
2006-06-22 14:00:00 +07:00
|
|
|
}
|
2007-03-15 14:06:34 +07:00
|
|
|
regs[i].phys_addr = base;
|
|
|
|
regs[i].reg_size = size;
|
2006-06-22 14:00:00 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
*num_ents = ents;
|
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
sort(regs, ents, sizeof(struct linux_prom64_registers),
|
2005-09-30 07:58:26 +07:00
|
|
|
cmp_p64, NULL);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
sparc64: Validate linear D-TLB misses.
When page alloc debugging is not enabled, we essentially accept any
virtual address for linear kernel TLB misses. But with kgdb, kernel
address probing, and other facilities we can try to access arbitrary
crap.
So, make sure the address we miss on will translate to physical memory
that actually exists.
In order to make this work we have to embed the valid address bitmap
into the kernel image. And in order to make that less expensive we
make an adjustment, in that the max physical memory address is
decreased to "1 << 41", even on the chips that support a 42-bit
physical address space. We can do this because bit 41 indicates
"I/O space" and thus covers non-memory ranges.
The result of this is that:
1) kpte_linear_bitmap shrinks from 2K to 1K in size
2) we need 64K more for the valid address bitmap
We can't let the valid address bitmap be dynamically allocated
once we start using it to validate TLB misses, otherwise we have
crazy issues to deal with wrt. recursive TLB misses and such.
If we're in a TLB miss it could be the deepest trap level that's legal
inside of the cpu. So if we TLB miss referencing the bitmap, the cpu
will be out of trap levels and enter RED state.
To guard against out-of-range accesses to the bitmap, we have to check
to make sure no bits in the physical address above bit 40 are set. We
could export and use last_valid_pfn for this check, but that's just an
unnecessary extra memory reference.
On the plus side of all this, since we load all of these translations
into the special 4MB mapping TSB, and we check the TSB first for TLB
misses, there should be absolutely no real cost for these new checks
in the TLB miss path.
Reported-by: heyongli@gmail.com
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-08-26 06:47:46 +07:00
|
|
|
unsigned long sparc64_valid_addr_bitmap[VALID_ADDR_BITMAP_BYTES /
|
|
|
|
sizeof(unsigned long)];
|
2009-01-09 07:58:20 +07:00
|
|
|
EXPORT_SYMBOL(sparc64_valid_addr_bitmap);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-08 17:16:07 +07:00
|
|
|
/* Kernel physical address base and size in bytes. */
|
2005-09-22 11:49:32 +07:00
|
|
|
unsigned long kern_base __read_mostly;
|
|
|
|
unsigned long kern_size __read_mostly;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Initial ramdisk setup */
|
|
|
|
extern unsigned long sparc_ramdisk_image64;
|
|
|
|
extern unsigned int sparc_ramdisk_image;
|
|
|
|
extern unsigned int sparc_ramdisk_size;
|
|
|
|
|
2005-09-22 11:49:32 +07:00
|
|
|
struct page *mem_map_zero __read_mostly;
|
2008-04-29 19:11:12 +07:00
|
|
|
EXPORT_SYMBOL(mem_map_zero);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-10-05 05:23:20 +07:00
|
|
|
unsigned int sparc64_highest_unlocked_tlb_ent __read_mostly;
|
|
|
|
|
|
|
|
unsigned long sparc64_kern_pri_context __read_mostly;
|
|
|
|
unsigned long sparc64_kern_pri_nuc_bits __read_mostly;
|
|
|
|
unsigned long sparc64_kern_sec_context __read_mostly;
|
|
|
|
|
2008-03-22 07:01:38 +07:00
|
|
|
int num_kernel_image_mappings;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
atomic_t dcpage_flushes = ATOMIC_INIT(0);
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
atomic_t dcpage_flushes_xcall = ATOMIC_INIT(0);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2006-02-27 10:44:50 +07:00
|
|
|
inline void flush_dcache_page_impl(struct page *page)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-02-27 10:44:50 +07:00
|
|
|
BUG_ON(tlb_type == hypervisor);
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
atomic_inc(&dcpage_flushes);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef DCACHE_ALIASING_POSSIBLE
|
|
|
|
__flush_dcache_page(page_address(page),
|
|
|
|
((tlb_type == spitfire) &&
|
|
|
|
page_mapping(page) != NULL));
|
|
|
|
#else
|
|
|
|
if (page_mapping(page) != NULL &&
|
|
|
|
tlb_type == spitfire)
|
|
|
|
__flush_icache_page(__pa(page_address(page)));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PG_dcache_dirty PG_arch_1
|
2007-05-26 15:14:43 +07:00
|
|
|
#define PG_dcache_cpu_shift 32UL
|
|
|
|
#define PG_dcache_cpu_mask \
|
|
|
|
((1UL<<ilog2(roundup_pow_of_two(NR_CPUS)))-1UL)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#define dcache_dirty_cpu(page) \
|
2005-07-28 06:08:44 +07:00
|
|
|
(((page)->flags >> PG_dcache_cpu_shift) & PG_dcache_cpu_mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-27 14:13:04 +07:00
|
|
|
static inline void set_dcache_dirty(struct page *page, int this_cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long mask = this_cpu;
|
2005-07-28 06:08:44 +07:00
|
|
|
unsigned long non_cpu_bits;
|
|
|
|
|
|
|
|
non_cpu_bits = ~(PG_dcache_cpu_mask << PG_dcache_cpu_shift);
|
|
|
|
mask = (mask << PG_dcache_cpu_shift) | (1UL << PG_dcache_dirty);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
__asm__ __volatile__("1:\n\t"
|
|
|
|
"ldx [%2], %%g7\n\t"
|
|
|
|
"and %%g7, %1, %%g1\n\t"
|
|
|
|
"or %%g1, %0, %%g1\n\t"
|
|
|
|
"casx [%2], %%g7, %%g1\n\t"
|
|
|
|
"cmp %%g7, %%g1\n\t"
|
|
|
|
"bne,pn %%xcc, 1b\n\t"
|
[SPARC64]: Avoid membar instructions in delay slots.
In particular, avoid membar instructions in the delay
slot of a jmpl instruction.
UltraSPARC-I, II, IIi, and IIe have a bug, documented in
the UltraSPARC-IIi User's Manual, Appendix K, Erratum 51
The long and short of it is that if the IMU unit misses
on a branch or jmpl, and there is a store buffer synchronizing
membar in the delay slot, the chip can stop fetching instructions.
If interrupts are enabled or some other trap is enabled, the
chip will unwedge itself, but performance will suffer.
We already had a workaround for this bug in a few spots, but
it's better to have the entire tree sanitized for this rule.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-28 05:42:04 +07:00
|
|
|
" nop"
|
2005-04-17 05:20:36 +07:00
|
|
|
: /* no outputs */
|
|
|
|
: "r" (mask), "r" (non_cpu_bits), "r" (&page->flags)
|
|
|
|
: "g1", "g7");
|
|
|
|
}
|
|
|
|
|
2007-10-27 14:13:04 +07:00
|
|
|
static inline void clear_dcache_dirty_cpu(struct page *page, unsigned long cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long mask = (1UL << PG_dcache_dirty);
|
|
|
|
|
|
|
|
__asm__ __volatile__("! test_and_clear_dcache_dirty\n"
|
|
|
|
"1:\n\t"
|
|
|
|
"ldx [%2], %%g7\n\t"
|
2005-07-28 06:08:44 +07:00
|
|
|
"srlx %%g7, %4, %%g1\n\t"
|
2005-04-17 05:20:36 +07:00
|
|
|
"and %%g1, %3, %%g1\n\t"
|
|
|
|
"cmp %%g1, %0\n\t"
|
|
|
|
"bne,pn %%icc, 2f\n\t"
|
|
|
|
" andn %%g7, %1, %%g1\n\t"
|
|
|
|
"casx [%2], %%g7, %%g1\n\t"
|
|
|
|
"cmp %%g7, %%g1\n\t"
|
|
|
|
"bne,pn %%xcc, 1b\n\t"
|
[SPARC64]: Avoid membar instructions in delay slots.
In particular, avoid membar instructions in the delay
slot of a jmpl instruction.
UltraSPARC-I, II, IIi, and IIe have a bug, documented in
the UltraSPARC-IIi User's Manual, Appendix K, Erratum 51
The long and short of it is that if the IMU unit misses
on a branch or jmpl, and there is a store buffer synchronizing
membar in the delay slot, the chip can stop fetching instructions.
If interrupts are enabled or some other trap is enabled, the
chip will unwedge itself, but performance will suffer.
We already had a workaround for this bug in a few spots, but
it's better to have the entire tree sanitized for this rule.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-28 05:42:04 +07:00
|
|
|
" nop\n"
|
2005-04-17 05:20:36 +07:00
|
|
|
"2:"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (cpu), "r" (mask), "r" (&page->flags),
|
2005-07-28 06:08:44 +07:00
|
|
|
"i" (PG_dcache_cpu_mask),
|
|
|
|
"i" (PG_dcache_cpu_shift)
|
2005-04-17 05:20:36 +07:00
|
|
|
: "g1", "g7");
|
|
|
|
}
|
|
|
|
|
2006-02-02 06:55:21 +07:00
|
|
|
static inline void tsb_insert(struct tsb *ent, unsigned long tag, unsigned long pte)
|
|
|
|
{
|
|
|
|
unsigned long tsb_addr = (unsigned long) ent;
|
|
|
|
|
2006-02-18 00:54:42 +07:00
|
|
|
if (tlb_type == cheetah_plus || tlb_type == hypervisor)
|
2006-02-02 06:55:21 +07:00
|
|
|
tsb_addr = __pa(tsb_addr);
|
|
|
|
|
|
|
|
__tsb_insert(tsb_addr, tag, pte);
|
|
|
|
}
|
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
unsigned long _PAGE_ALL_SZ_BITS __read_mostly;
|
|
|
|
|
2009-01-07 03:51:26 +07:00
|
|
|
static void flush_dcache(unsigned long pfn)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-01-07 03:51:26 +07:00
|
|
|
struct page *page;
|
2006-02-27 10:44:50 +07:00
|
|
|
|
2009-01-07 03:51:26 +07:00
|
|
|
page = pfn_to_page(pfn);
|
2009-10-12 17:20:57 +07:00
|
|
|
if (page) {
|
2006-02-27 10:44:50 +07:00
|
|
|
unsigned long pg_flags;
|
|
|
|
|
2009-01-07 03:51:26 +07:00
|
|
|
pg_flags = page->flags;
|
|
|
|
if (pg_flags & (1UL << PG_dcache_dirty)) {
|
2006-02-27 10:44:50 +07:00
|
|
|
int cpu = ((pg_flags >> PG_dcache_cpu_shift) &
|
|
|
|
PG_dcache_cpu_mask);
|
|
|
|
int this_cpu = get_cpu();
|
|
|
|
|
|
|
|
/* This is just to optimize away some function calls
|
|
|
|
* in the SMP case.
|
|
|
|
*/
|
|
|
|
if (cpu == this_cpu)
|
|
|
|
flush_dcache_page_impl(page);
|
|
|
|
else
|
|
|
|
smp_flush_dcache_page_impl(page, cpu);
|
|
|
|
|
|
|
|
clear_dcache_dirty_cpu(page, cpu);
|
|
|
|
|
|
|
|
put_cpu();
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-01-07 03:51:26 +07:00
|
|
|
}
|
|
|
|
|
2012-10-09 06:34:29 +07:00
|
|
|
/* mm->context.lock must be held */
|
|
|
|
static void __update_mmu_tsb_insert(struct mm_struct *mm, unsigned long tsb_index,
|
|
|
|
unsigned long tsb_hash_shift, unsigned long address,
|
|
|
|
unsigned long tte)
|
|
|
|
{
|
|
|
|
struct tsb *tsb = mm->context.tsb_block[tsb_index].tsb;
|
|
|
|
unsigned long tag;
|
|
|
|
|
2013-02-20 04:20:08 +07:00
|
|
|
if (unlikely(!tsb))
|
|
|
|
return;
|
|
|
|
|
2012-10-09 06:34:29 +07:00
|
|
|
tsb += ((address >> tsb_hash_shift) &
|
|
|
|
(mm->context.tsb_block[tsb_index].tsb_nentries - 1UL));
|
|
|
|
tag = (address >> 22UL);
|
|
|
|
tsb_insert(tsb, tag, tte);
|
|
|
|
}
|
|
|
|
|
2013-02-20 04:20:08 +07:00
|
|
|
#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
|
|
|
|
static inline bool is_hugetlb_pte(pte_t pte)
|
|
|
|
{
|
|
|
|
if ((tlb_type == hypervisor &&
|
|
|
|
(pte_val(pte) & _PAGE_SZALL_4V) == _PAGE_SZHUGE_4V) ||
|
|
|
|
(tlb_type != hypervisor &&
|
|
|
|
(pte_val(pte) & _PAGE_SZALL_4U) == _PAGE_SZHUGE_4U))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
MM: Pass a PTE pointer to update_mmu_cache() rather than the PTE itself
On VIVT ARM, when we have multiple shared mappings of the same file
in the same MM, we need to ensure that we have coherency across all
copies. We do this via make_coherent() by making the pages
uncacheable.
This used to work fine, until we allowed highmem with highpte - we
now have a page table which is mapped as required, and is not available
for modification via update_mmu_cache().
Ralf Beache suggested getting rid of the PTE value passed to
update_mmu_cache():
On MIPS update_mmu_cache() calls __update_tlb() which walks pagetables
to construct a pointer to the pte again. Passing a pte_t * is much
more elegant. Maybe we might even replace the pte argument with the
pte_t?
Ben Herrenschmidt would also like the pte pointer for PowerPC:
Passing the ptep in there is exactly what I want. I want that
-instead- of the PTE value, because I have issue on some ppc cases,
for I$/D$ coherency, where set_pte_at() may decide to mask out the
_PAGE_EXEC.
So, pass in the mapped page table pointer into update_mmu_cache(), and
remove the PTE value, updating all implementations and call sites to
suit.
Includes a fix from Stephen Rothwell:
sparc: fix fallout from update_mmu_cache API change
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-12-18 23:40:18 +07:00
|
|
|
void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t *ptep)
|
2009-01-07 03:51:26 +07:00
|
|
|
{
|
|
|
|
struct mm_struct *mm;
|
2013-02-20 04:20:08 +07:00
|
|
|
unsigned long flags;
|
MM: Pass a PTE pointer to update_mmu_cache() rather than the PTE itself
On VIVT ARM, when we have multiple shared mappings of the same file
in the same MM, we need to ensure that we have coherency across all
copies. We do this via make_coherent() by making the pages
uncacheable.
This used to work fine, until we allowed highmem with highpte - we
now have a page table which is mapped as required, and is not available
for modification via update_mmu_cache().
Ralf Beache suggested getting rid of the PTE value passed to
update_mmu_cache():
On MIPS update_mmu_cache() calls __update_tlb() which walks pagetables
to construct a pointer to the pte again. Passing a pte_t * is much
more elegant. Maybe we might even replace the pte argument with the
pte_t?
Ben Herrenschmidt would also like the pte pointer for PowerPC:
Passing the ptep in there is exactly what I want. I want that
-instead- of the PTE value, because I have issue on some ppc cases,
for I$/D$ coherency, where set_pte_at() may decide to mask out the
_PAGE_EXEC.
So, pass in the mapped page table pointer into update_mmu_cache(), and
remove the PTE value, updating all implementations and call sites to
suit.
Includes a fix from Stephen Rothwell:
sparc: fix fallout from update_mmu_cache API change
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-12-18 23:40:18 +07:00
|
|
|
pte_t pte = *ptep;
|
2009-01-07 03:51:26 +07:00
|
|
|
|
|
|
|
if (tlb_type != hypervisor) {
|
|
|
|
unsigned long pfn = pte_pfn(pte);
|
|
|
|
|
|
|
|
if (pfn_valid(pfn))
|
|
|
|
flush_dcache(pfn);
|
|
|
|
}
|
2006-02-01 09:31:38 +07:00
|
|
|
|
|
|
|
mm = vma->vm_mm;
|
[SPARC64]: Fix and re-enable dynamic TSB sizing.
This is good for up to %50 performance improvement of some test cases.
The problem has been the race conditions, and hopefully I've plugged
them all up here.
1) There was a serious race in switch_mm() wrt. lazy TLB
switching to and from kernel threads.
We could erroneously skip a tsb_context_switch() and thus
use a stale TSB across a TSB grow event.
There is a big comment now in that function describing
exactly how it can happen.
2) All code paths that do something with the TSB need to be
guarded with the mm->context.lock spinlock. This makes
page table flushing paths properly synchronize with both
TSB growing and TLB context changes.
3) TSB growing events are moved to the end of successful fault
processing. Previously it was in update_mmu_cache() but
that is deadlock prone. At the end of do_sparc64_fault()
we hold no spinlocks that could deadlock the TSB grow
sequence. We also have dropped the address space semaphore.
While we're here, add prefetching to the copy_tsb() routine
and put it in assembler into the tsb.S file. This piece of
code is quite time critical.
There are some small negative side effects to this code which
can be improved upon. In particular we grab the mm->context.lock
even for the tsb insert done by update_mmu_cache() now and that's
a bit excessive. We can get rid of that locking, and the same
lock taking in flush_tsb_user(), by disabling PSTATE_IE around
the whole operation including the capturing of the tsb pointer
and tsb_nentries value. That would work because anyone growing
the TSB won't free up the old TSB until all cpus respond to the
TSB change cross call.
I'm not quite so confident in that optimization to put it in
right now, but eventually we might be able to and the description
is here for reference.
This code seems very solid now. It passes several parallel GCC
bootstrap builds, and our favorite "nut cruncher" stress test which is
a full "make -j8192" build of a "make allmodconfig" kernel. That puts
about 256 processes on each cpu's run queue, makes lots of process cpu
migrations occur, causes lots of page table and TLB flushing activity,
incurs many context version number changes, and it swaps the machine
real far out to disk even though there is 16GB of ram on this test
system. :-)
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-03-16 17:02:32 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&mm->context.lock, flags);
|
|
|
|
|
2012-10-09 06:34:29 +07:00
|
|
|
#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
|
2013-02-20 04:20:08 +07:00
|
|
|
if (mm->context.huge_pte_count && is_hugetlb_pte(pte))
|
|
|
|
__update_mmu_tsb_insert(mm, MM_TSB_HUGE, HPAGE_SHIFT,
|
|
|
|
address, pte_val(pte));
|
|
|
|
else
|
2006-03-22 15:49:59 +07:00
|
|
|
#endif
|
2013-02-20 04:20:08 +07:00
|
|
|
__update_mmu_tsb_insert(mm, MM_TSB_BASE, PAGE_SHIFT,
|
|
|
|
address, pte_val(pte));
|
[SPARC64]: Fix and re-enable dynamic TSB sizing.
This is good for up to %50 performance improvement of some test cases.
The problem has been the race conditions, and hopefully I've plugged
them all up here.
1) There was a serious race in switch_mm() wrt. lazy TLB
switching to and from kernel threads.
We could erroneously skip a tsb_context_switch() and thus
use a stale TSB across a TSB grow event.
There is a big comment now in that function describing
exactly how it can happen.
2) All code paths that do something with the TSB need to be
guarded with the mm->context.lock spinlock. This makes
page table flushing paths properly synchronize with both
TSB growing and TLB context changes.
3) TSB growing events are moved to the end of successful fault
processing. Previously it was in update_mmu_cache() but
that is deadlock prone. At the end of do_sparc64_fault()
we hold no spinlocks that could deadlock the TSB grow
sequence. We also have dropped the address space semaphore.
While we're here, add prefetching to the copy_tsb() routine
and put it in assembler into the tsb.S file. This piece of
code is quite time critical.
There are some small negative side effects to this code which
can be improved upon. In particular we grab the mm->context.lock
even for the tsb insert done by update_mmu_cache() now and that's
a bit excessive. We can get rid of that locking, and the same
lock taking in flush_tsb_user(), by disabling PSTATE_IE around
the whole operation including the capturing of the tsb pointer
and tsb_nentries value. That would work because anyone growing
the TSB won't free up the old TSB until all cpus respond to the
TSB change cross call.
I'm not quite so confident in that optimization to put it in
right now, but eventually we might be able to and the description
is here for reference.
This code seems very solid now. It passes several parallel GCC
bootstrap builds, and our favorite "nut cruncher" stress test which is
a full "make -j8192" build of a "make allmodconfig" kernel. That puts
about 256 processes on each cpu's run queue, makes lots of process cpu
migrations occur, causes lots of page table and TLB flushing activity,
incurs many context version number changes, and it swaps the machine
real far out to disk even though there is 16GB of ram on this test
system. :-)
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-03-16 17:02:32 +07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mm->context.lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void flush_dcache_page(struct page *page)
|
|
|
|
{
|
2005-04-18 08:03:09 +07:00
|
|
|
struct address_space *mapping;
|
|
|
|
int this_cpu;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-02-27 10:44:50 +07:00
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
return;
|
|
|
|
|
2005-04-18 08:03:09 +07:00
|
|
|
/* Do not bother with the expensive D-cache flush if it
|
|
|
|
* is merely the zero page. The 'bigcore' testcase in GDB
|
|
|
|
* causes this case to run millions of times.
|
|
|
|
*/
|
|
|
|
if (page == ZERO_PAGE(0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
this_cpu = get_cpu();
|
|
|
|
|
|
|
|
mapping = page_mapping(page);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (mapping && !mapping_mapped(mapping)) {
|
2005-04-18 08:03:09 +07:00
|
|
|
int dirty = test_bit(PG_dcache_dirty, &page->flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dirty) {
|
2005-04-18 08:03:09 +07:00
|
|
|
int dirty_cpu = dcache_dirty_cpu(page);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (dirty_cpu == this_cpu)
|
|
|
|
goto out;
|
|
|
|
smp_flush_dcache_page_impl(page, dirty_cpu);
|
|
|
|
}
|
|
|
|
set_dcache_dirty(page, this_cpu);
|
|
|
|
} else {
|
|
|
|
/* We could delay the flush for the !page_mapping
|
|
|
|
* case too. But that case is for exec env/arg
|
|
|
|
* pages and those are %99 certainly going to get
|
|
|
|
* faulted into the tlb (and thus flushed) anyways.
|
|
|
|
*/
|
|
|
|
flush_dcache_page_impl(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
put_cpu();
|
|
|
|
}
|
2009-01-09 07:58:20 +07:00
|
|
|
EXPORT_SYMBOL(flush_dcache_page);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-07 05:19:30 +07:00
|
|
|
void __kprobes flush_icache_range(unsigned long start, unsigned long end)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-02-04 18:10:53 +07:00
|
|
|
/* Cheetah and Hypervisor platform cpus have coherent I-cache. */
|
2005-04-17 05:20:36 +07:00
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
unsigned long kaddr;
|
|
|
|
|
2007-03-16 05:50:11 +07:00
|
|
|
/* This code only runs on Spitfire cpus so this is
|
|
|
|
* why we can assume _PAGE_PADDR_4U.
|
|
|
|
*/
|
|
|
|
for (kaddr = start; kaddr < end; kaddr += PAGE_SIZE) {
|
|
|
|
unsigned long paddr, mask = _PAGE_PADDR_4U;
|
|
|
|
|
|
|
|
if (kaddr >= PAGE_OFFSET)
|
|
|
|
paddr = kaddr & mask;
|
|
|
|
else {
|
|
|
|
pgd_t *pgdp = pgd_offset_k(kaddr);
|
|
|
|
pud_t *pudp = pud_offset(pgdp, kaddr);
|
|
|
|
pmd_t *pmdp = pmd_offset(pudp, kaddr);
|
|
|
|
pte_t *ptep = pte_offset_kernel(pmdp, kaddr);
|
|
|
|
|
|
|
|
paddr = pte_val(*ptep) & mask;
|
|
|
|
}
|
|
|
|
__flush_icache_page(paddr);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
2009-01-09 07:58:20 +07:00
|
|
|
EXPORT_SYMBOL(flush_icache_range);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
void mmu_info(struct seq_file *m)
|
|
|
|
{
|
2012-09-07 09:01:25 +07:00
|
|
|
static const char *pgsz_strings[] = {
|
|
|
|
"8K", "64K", "512K", "4MB", "32MB",
|
|
|
|
"256MB", "2GB", "16GB",
|
|
|
|
};
|
|
|
|
int i, printed;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (tlb_type == cheetah)
|
|
|
|
seq_printf(m, "MMU Type\t: Cheetah\n");
|
|
|
|
else if (tlb_type == cheetah_plus)
|
|
|
|
seq_printf(m, "MMU Type\t: Cheetah+\n");
|
|
|
|
else if (tlb_type == spitfire)
|
|
|
|
seq_printf(m, "MMU Type\t: Spitfire\n");
|
2006-02-04 18:10:53 +07:00
|
|
|
else if (tlb_type == hypervisor)
|
|
|
|
seq_printf(m, "MMU Type\t: Hypervisor (sun4v)\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
|
|
|
seq_printf(m, "MMU Type\t: ???\n");
|
|
|
|
|
2012-09-07 09:01:25 +07:00
|
|
|
seq_printf(m, "MMU PGSZs\t: ");
|
|
|
|
printed = 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pgsz_strings); i++) {
|
|
|
|
if (cpu_pgsz_mask & (1UL << i)) {
|
|
|
|
seq_printf(m, "%s%s",
|
|
|
|
printed ? "," : "", pgsz_strings[i]);
|
|
|
|
printed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
seq_putc(m, '\n');
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
seq_printf(m, "DCPageFlushes\t: %d\n",
|
|
|
|
atomic_read(&dcpage_flushes));
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
seq_printf(m, "DCPageFlushesXC\t: %d\n",
|
|
|
|
atomic_read(&dcpage_flushes_xcall));
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
#endif /* CONFIG_DEBUG_DCFLUSH */
|
|
|
|
}
|
|
|
|
|
2007-03-16 05:50:11 +07:00
|
|
|
struct linux_prom_translation prom_trans[512] __read_mostly;
|
|
|
|
unsigned int prom_trans_ents __read_mostly;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long kern_locked_tte_data;
|
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
/* The obp translations are saved based on 8k pagesize, since obp can
|
|
|
|
* use a mixture of pagesizes. Misses to the LOW_OBP_ADDRESS ->
|
2006-02-01 09:29:18 +07:00
|
|
|
* HI_OBP_ADDRESS range are handled in ktlb.S.
|
2005-10-13 02:22:46 +07:00
|
|
|
*/
|
2005-09-22 14:45:41 +07:00
|
|
|
static inline int in_obp_range(unsigned long vaddr)
|
|
|
|
{
|
|
|
|
return (vaddr >= LOW_OBP_ADDRESS &&
|
|
|
|
vaddr < HI_OBP_ADDRESS);
|
|
|
|
}
|
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
static int cmp_ptrans(const void *a, const void *b)
|
2005-09-22 14:12:35 +07:00
|
|
|
{
|
2005-10-13 02:22:46 +07:00
|
|
|
const struct linux_prom_translation *x = a, *y = b;
|
2005-09-22 14:12:35 +07:00
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
if (x->virt > y->virt)
|
|
|
|
return 1;
|
|
|
|
if (x->virt < y->virt)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
2005-09-22 14:12:35 +07:00
|
|
|
}
|
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
/* Read OBP translations property into 'prom_trans[]'. */
|
2005-10-06 05:12:00 +07:00
|
|
|
static void __init read_obp_translations(void)
|
2005-09-22 14:12:35 +07:00
|
|
|
{
|
2005-10-13 02:22:46 +07:00
|
|
|
int n, node, ents, first, last, i;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
node = prom_finddevice("/virtual-memory");
|
|
|
|
n = prom_getproplen(node, "translations");
|
2005-09-22 14:12:35 +07:00
|
|
|
if (unlikely(n == 0 || n == -1)) {
|
2005-09-22 12:31:13 +07:00
|
|
|
prom_printf("prom_mappings: Couldn't get size.\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
2005-09-22 14:12:35 +07:00
|
|
|
if (unlikely(n > sizeof(prom_trans))) {
|
2012-09-29 10:14:49 +07:00
|
|
|
prom_printf("prom_mappings: Size %d is too big.\n", n);
|
2005-04-17 05:20:36 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
2005-09-22 14:12:35 +07:00
|
|
|
|
2005-09-22 12:31:13 +07:00
|
|
|
if ((n = prom_getproperty(node, "translations",
|
2005-09-22 14:12:35 +07:00
|
|
|
(char *)&prom_trans[0],
|
|
|
|
sizeof(prom_trans))) == -1) {
|
2005-09-22 12:31:13 +07:00
|
|
|
prom_printf("prom_mappings: Couldn't get property.\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
2005-10-06 05:12:00 +07:00
|
|
|
|
2005-09-22 12:31:13 +07:00
|
|
|
n = n / sizeof(struct linux_prom_translation);
|
2005-10-06 05:12:00 +07:00
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
ents = n;
|
|
|
|
|
|
|
|
sort(prom_trans, ents, sizeof(struct linux_prom_translation),
|
|
|
|
cmp_ptrans, NULL);
|
|
|
|
|
|
|
|
/* Now kick out all the non-OBP entries. */
|
|
|
|
for (i = 0; i < ents; i++) {
|
|
|
|
if (in_obp_range(prom_trans[i].virt))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
first = i;
|
|
|
|
for (; i < ents; i++) {
|
|
|
|
if (!in_obp_range(prom_trans[i].virt))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last = i;
|
|
|
|
|
|
|
|
for (i = 0; i < (last - first); i++) {
|
|
|
|
struct linux_prom_translation *src = &prom_trans[i + first];
|
|
|
|
struct linux_prom_translation *dest = &prom_trans[i];
|
|
|
|
|
|
|
|
*dest = *src;
|
|
|
|
}
|
|
|
|
for (; i < ents; i++) {
|
|
|
|
struct linux_prom_translation *dest = &prom_trans[i];
|
|
|
|
dest->virt = dest->size = dest->data = 0x0UL;
|
|
|
|
}
|
|
|
|
|
|
|
|
prom_trans_ents = last - first;
|
|
|
|
|
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
/* Clear diag TTE bits. */
|
|
|
|
for (i = 0; i < prom_trans_ents; i++)
|
|
|
|
prom_trans[i].data &= ~0x0003fe0000000000UL;
|
|
|
|
}
|
2011-09-30 02:18:59 +07:00
|
|
|
|
|
|
|
/* Force execute bit on. */
|
|
|
|
for (i = 0; i < prom_trans_ents; i++)
|
|
|
|
prom_trans[i].data |= (tlb_type == hypervisor ?
|
|
|
|
_PAGE_EXEC_4V : _PAGE_EXEC_4U);
|
2005-09-22 14:12:35 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-02-09 17:52:44 +07:00
|
|
|
static void __init hypervisor_tlb_lock(unsigned long vaddr,
|
|
|
|
unsigned long pte,
|
|
|
|
unsigned long mmu)
|
|
|
|
{
|
2007-05-29 16:22:14 +07:00
|
|
|
unsigned long ret = sun4v_mmu_map_perm_addr(vaddr, 0, pte, mmu);
|
|
|
|
|
|
|
|
if (ret != 0) {
|
2012-09-29 10:14:49 +07:00
|
|
|
prom_printf("hypervisor_tlb_lock[%lx:%x:%lx:%lx]: "
|
2007-05-29 16:22:14 +07:00
|
|
|
"errors with %lx\n", vaddr, 0, pte, mmu, ret);
|
2006-02-18 05:40:30 +07:00
|
|
|
prom_halt();
|
|
|
|
}
|
2006-02-09 17:52:44 +07:00
|
|
|
}
|
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
static unsigned long kern_large_tte(unsigned long paddr);
|
|
|
|
|
2005-09-24 01:59:44 +07:00
|
|
|
static void __init remap_kernel(void)
|
2005-09-22 14:12:35 +07:00
|
|
|
{
|
|
|
|
unsigned long phys_page, tte_vaddr, tte_data;
|
2008-03-22 07:01:38 +07:00
|
|
|
int i, tlb_ent = sparc64_highest_locked_tlbent();
|
2005-09-22 14:12:35 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
tte_vaddr = (unsigned long) KERNBASE;
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-23 10:11:33 +07:00
|
|
|
phys_page = (prom_boot_mapping_phys_low >> 22UL) << 22UL;
|
2006-02-12 12:57:54 +07:00
|
|
|
tte_data = kern_large_tte(phys_page);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
kern_locked_tte_data = tte_data;
|
|
|
|
|
2006-02-09 17:52:44 +07:00
|
|
|
/* Now lock us into the TLBs via Hypervisor or OBP. */
|
|
|
|
if (tlb_type == hypervisor) {
|
2008-03-22 07:01:38 +07:00
|
|
|
for (i = 0; i < num_kernel_image_mappings; i++) {
|
2006-02-09 17:52:44 +07:00
|
|
|
hypervisor_tlb_lock(tte_vaddr, tte_data, HV_MMU_DMMU);
|
|
|
|
hypervisor_tlb_lock(tte_vaddr, tte_data, HV_MMU_IMMU);
|
2008-03-22 07:01:38 +07:00
|
|
|
tte_vaddr += 0x400000;
|
|
|
|
tte_data += 0x400000;
|
2006-02-09 17:52:44 +07:00
|
|
|
}
|
|
|
|
} else {
|
2008-03-22 07:01:38 +07:00
|
|
|
for (i = 0; i < num_kernel_image_mappings; i++) {
|
|
|
|
prom_dtlb_load(tlb_ent - i, tte_data, tte_vaddr);
|
|
|
|
prom_itlb_load(tlb_ent - i, tte_data, tte_vaddr);
|
|
|
|
tte_vaddr += 0x400000;
|
|
|
|
tte_data += 0x400000;
|
2006-02-09 17:52:44 +07:00
|
|
|
}
|
2008-03-22 07:01:38 +07:00
|
|
|
sparc64_highest_unlocked_tlb_ent = tlb_ent - i;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-10-05 05:23:20 +07:00
|
|
|
if (tlb_type == cheetah_plus) {
|
|
|
|
sparc64_kern_pri_context = (CTX_CHEETAH_PLUS_CTX0 |
|
|
|
|
CTX_CHEETAH_PLUS_NUC);
|
|
|
|
sparc64_kern_pri_nuc_bits = CTX_CHEETAH_PLUS_NUC;
|
|
|
|
sparc64_kern_sec_context = CTX_CHEETAH_PLUS_CTX0;
|
|
|
|
}
|
2005-09-22 14:12:35 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-22 14:12:35 +07:00
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
static void __init inherit_prom_mappings(void)
|
2005-10-06 05:12:00 +07:00
|
|
|
{
|
2005-09-22 14:12:35 +07:00
|
|
|
/* Now fixup OBP's idea about where we really are mapped. */
|
2008-02-18 14:22:50 +07:00
|
|
|
printk("Remapping the kernel... ");
|
2005-09-22 14:12:35 +07:00
|
|
|
remap_kernel();
|
2008-02-18 14:22:50 +07:00
|
|
|
printk("done.\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void prom_world(int enter)
|
|
|
|
{
|
|
|
|
if (!enter)
|
2012-09-26 12:21:14 +07:00
|
|
|
set_fs(get_fs());
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-02-01 09:33:25 +07:00
|
|
|
__asm__ __volatile__("flushw");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void __flush_dcache_range(unsigned long start, unsigned long end)
|
|
|
|
{
|
|
|
|
unsigned long va;
|
|
|
|
|
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
int n = 0;
|
|
|
|
|
|
|
|
for (va = start; va < end; va += 32) {
|
|
|
|
spitfire_put_dcache_tag(va & 0x3fe0, 0x0);
|
|
|
|
if (++n >= 512)
|
|
|
|
break;
|
|
|
|
}
|
2006-02-04 18:10:53 +07:00
|
|
|
} else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
2005-04-17 05:20:36 +07:00
|
|
|
start = __pa(start);
|
|
|
|
end = __pa(end);
|
|
|
|
for (va = start; va < end; va += 32)
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
|
|
|
|
"membar #Sync"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (va),
|
|
|
|
"i" (ASI_DCACHE_INVALIDATE));
|
|
|
|
}
|
|
|
|
}
|
2009-01-09 07:58:20 +07:00
|
|
|
EXPORT_SYMBOL(__flush_dcache_range);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-03-16 07:51:26 +07:00
|
|
|
/* get_new_mmu_context() uses "cache + 1". */
|
|
|
|
DEFINE_SPINLOCK(ctx_alloc_lock);
|
|
|
|
unsigned long tlb_context_cache = CTX_FIRST_VERSION - 1;
|
|
|
|
#define MAX_CTX_NR (1UL << CTX_NR_BITS)
|
|
|
|
#define CTX_BMAP_SLOTS BITS_TO_LONGS(MAX_CTX_NR)
|
|
|
|
DECLARE_BITMAP(mmu_context_bmap, MAX_CTX_NR);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Caller does TLB context flushing on local CPU if necessary.
|
|
|
|
* The caller also ensures that CTX_VALID(mm->context) is false.
|
|
|
|
*
|
|
|
|
* We must be careful about boundary cases so that we never
|
|
|
|
* let the user have CTX 0 (nucleus) or we ever use a CTX
|
|
|
|
* version of zero (and thus NO_CONTEXT would not be caught
|
|
|
|
* by version mis-match tests in mmu_context.h).
|
2006-02-24 05:19:28 +07:00
|
|
|
*
|
|
|
|
* Always invoked with interrupts disabled.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
void get_new_mmu_context(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
unsigned long ctx, new_ctx;
|
|
|
|
unsigned long orig_pgsz_bits;
|
2006-02-24 05:19:28 +07:00
|
|
|
int new_version;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-04-09 03:29:46 +07:00
|
|
|
spin_lock(&ctx_alloc_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
orig_pgsz_bits = (mm->context.sparc64_ctx_val & CTX_PGSZ_MASK);
|
|
|
|
ctx = (tlb_context_cache + 1) & CTX_NR_MASK;
|
|
|
|
new_ctx = find_next_zero_bit(mmu_context_bmap, 1 << CTX_NR_BITS, ctx);
|
2006-02-24 05:19:28 +07:00
|
|
|
new_version = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (new_ctx >= (1 << CTX_NR_BITS)) {
|
|
|
|
new_ctx = find_next_zero_bit(mmu_context_bmap, ctx, 1);
|
|
|
|
if (new_ctx >= ctx) {
|
|
|
|
int i;
|
|
|
|
new_ctx = (tlb_context_cache & CTX_VERSION_MASK) +
|
|
|
|
CTX_FIRST_VERSION;
|
|
|
|
if (new_ctx == 1)
|
|
|
|
new_ctx = CTX_FIRST_VERSION;
|
|
|
|
|
|
|
|
/* Don't call memset, for 16 entries that's just
|
|
|
|
* plain silly...
|
|
|
|
*/
|
|
|
|
mmu_context_bmap[0] = 3;
|
|
|
|
mmu_context_bmap[1] = 0;
|
|
|
|
mmu_context_bmap[2] = 0;
|
|
|
|
mmu_context_bmap[3] = 0;
|
|
|
|
for (i = 4; i < CTX_BMAP_SLOTS; i += 4) {
|
|
|
|
mmu_context_bmap[i + 0] = 0;
|
|
|
|
mmu_context_bmap[i + 1] = 0;
|
|
|
|
mmu_context_bmap[i + 2] = 0;
|
|
|
|
mmu_context_bmap[i + 3] = 0;
|
|
|
|
}
|
2006-02-24 05:19:28 +07:00
|
|
|
new_version = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mmu_context_bmap[new_ctx>>6] |= (1UL << (new_ctx & 63));
|
|
|
|
new_ctx |= (tlb_context_cache & CTX_VERSION_MASK);
|
|
|
|
out:
|
|
|
|
tlb_context_cache = new_ctx;
|
|
|
|
mm->context.sparc64_ctx_val = new_ctx | orig_pgsz_bits;
|
2013-04-09 03:29:46 +07:00
|
|
|
spin_unlock(&ctx_alloc_lock);
|
2006-02-24 05:19:28 +07:00
|
|
|
|
|
|
|
if (unlikely(new_version))
|
|
|
|
smp_new_mmu_context_version();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
static int numa_enabled = 1;
|
|
|
|
static int numa_debug;
|
|
|
|
|
|
|
|
static int __init early_numa(char *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-04-23 19:40:25 +07:00
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (strstr(p, "off"))
|
|
|
|
numa_enabled = 0;
|
2006-03-08 17:16:07 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
if (strstr(p, "debug"))
|
|
|
|
numa_debug = 1;
|
2006-03-08 17:16:07 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
return 0;
|
2006-03-08 17:16:07 +07:00
|
|
|
}
|
2008-04-23 19:40:25 +07:00
|
|
|
early_param("numa", early_numa);
|
|
|
|
|
|
|
|
#define numadbg(f, a...) \
|
|
|
|
do { if (numa_debug) \
|
|
|
|
printk(KERN_INFO f, ## a); \
|
|
|
|
} while (0)
|
2006-03-08 17:16:07 +07:00
|
|
|
|
2008-02-14 09:00:03 +07:00
|
|
|
static void __init find_ramdisk(unsigned long phys_base)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
if (sparc_ramdisk_image || sparc_ramdisk_image64) {
|
|
|
|
unsigned long ramdisk_image;
|
|
|
|
|
|
|
|
/* Older versions of the bootloader only supported a
|
|
|
|
* 32-bit physical address for the ramdisk image
|
|
|
|
* location, stored at sparc_ramdisk_image. Newer
|
|
|
|
* SILO versions set sparc_ramdisk_image to zero and
|
|
|
|
* provide a full 64-bit physical address at
|
|
|
|
* sparc_ramdisk_image64.
|
|
|
|
*/
|
|
|
|
ramdisk_image = sparc_ramdisk_image;
|
|
|
|
if (!ramdisk_image)
|
|
|
|
ramdisk_image = sparc_ramdisk_image64;
|
|
|
|
|
|
|
|
/* Another bootloader quirk. The bootloader normalizes
|
|
|
|
* the physical address to KERNBASE, so we have to
|
|
|
|
* factor that back out and add in the lowest valid
|
|
|
|
* physical page address to get the true physical address.
|
|
|
|
*/
|
|
|
|
ramdisk_image -= KERNBASE;
|
|
|
|
ramdisk_image += phys_base;
|
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
numadbg("Found ramdisk at physical address 0x%lx, size %u\n",
|
|
|
|
ramdisk_image, sparc_ramdisk_size);
|
|
|
|
|
2008-02-14 09:00:03 +07:00
|
|
|
initrd_start = ramdisk_image;
|
|
|
|
initrd_end = ramdisk_image + sparc_ramdisk_size;
|
2008-02-14 09:13:20 +07:00
|
|
|
|
2010-07-12 11:36:09 +07:00
|
|
|
memblock_reserve(initrd_start, sparc_ramdisk_size);
|
2008-05-07 05:19:54 +07:00
|
|
|
|
|
|
|
initrd_start += PAGE_OFFSET;
|
|
|
|
initrd_end += PAGE_OFFSET;
|
2008-02-14 09:00:03 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
struct node_mem_mask {
|
|
|
|
unsigned long mask;
|
|
|
|
unsigned long val;
|
|
|
|
};
|
|
|
|
static struct node_mem_mask node_masks[MAX_NUMNODES];
|
|
|
|
static int num_node_masks;
|
|
|
|
|
|
|
|
int numa_cpu_lookup_table[NR_CPUS];
|
|
|
|
cpumask_t numa_cpumask_lookup_table[MAX_NUMNODES];
|
|
|
|
|
|
|
|
#ifdef CONFIG_NEED_MULTIPLE_NODES
|
|
|
|
|
|
|
|
struct mdesc_mblock {
|
|
|
|
u64 base;
|
|
|
|
u64 size;
|
|
|
|
u64 offset; /* RA-to-PA */
|
|
|
|
};
|
|
|
|
static struct mdesc_mblock *mblocks;
|
|
|
|
static int num_mblocks;
|
|
|
|
|
|
|
|
static unsigned long ra_to_pa(unsigned long addr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_mblocks; i++) {
|
|
|
|
struct mdesc_mblock *m = &mblocks[i];
|
|
|
|
|
|
|
|
if (addr >= m->base &&
|
|
|
|
addr < (m->base + m->size)) {
|
|
|
|
addr += m->offset;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_node(unsigned long addr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
addr = ra_to_pa(addr);
|
|
|
|
for (i = 0; i < num_node_masks; i++) {
|
|
|
|
struct node_mem_mask *p = &node_masks[i];
|
|
|
|
|
|
|
|
if ((addr & p->mask) == p->val)
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-07-12 15:46:32 +07:00
|
|
|
static u64 memblock_nid_range(u64 start, u64 end, int *nid)
|
2008-04-23 19:40:25 +07:00
|
|
|
{
|
|
|
|
*nid = find_node(start);
|
|
|
|
start += PAGE_SIZE;
|
|
|
|
while (start < end) {
|
|
|
|
int n = find_node(start);
|
|
|
|
|
|
|
|
if (n != *nid)
|
|
|
|
break;
|
|
|
|
start += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
2008-08-14 15:41:39 +07:00
|
|
|
if (start > end)
|
|
|
|
start = end;
|
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
return start;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* This must be invoked after performing all of the necessary
|
2011-12-09 01:22:08 +07:00
|
|
|
* memblock_set_node() calls for 'nid'. We need to be able to get
|
2008-04-23 19:40:25 +07:00
|
|
|
* correct data from get_pfn_range_for_nid().
|
2007-03-16 12:52:18 +07:00
|
|
|
*/
|
2008-04-23 19:40:25 +07:00
|
|
|
static void __init allocate_node_data(int nid)
|
|
|
|
{
|
|
|
|
struct pglist_data *p;
|
2012-05-10 07:44:29 +07:00
|
|
|
unsigned long start_pfn, end_pfn;
|
2008-04-23 19:40:25 +07:00
|
|
|
#ifdef CONFIG_NEED_MULTIPLE_NODES
|
2012-05-10 07:44:29 +07:00
|
|
|
unsigned long paddr;
|
|
|
|
|
2010-07-07 05:39:17 +07:00
|
|
|
paddr = memblock_alloc_try_nid(sizeof(struct pglist_data), SMP_CACHE_BYTES, nid);
|
2008-04-23 19:40:25 +07:00
|
|
|
if (!paddr) {
|
|
|
|
prom_printf("Cannot allocate pglist_data for nid[%d]\n", nid);
|
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
NODE_DATA(nid) = __va(paddr);
|
|
|
|
memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
|
|
|
|
|
2012-04-26 03:13:43 +07:00
|
|
|
NODE_DATA(nid)->node_id = nid;
|
2008-04-23 19:40:25 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
p = NODE_DATA(nid);
|
|
|
|
|
|
|
|
get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
|
|
|
|
p->node_start_pfn = start_pfn;
|
|
|
|
p->node_spanned_pages = end_pfn - start_pfn;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void init_node_masks_nonnuma(void)
|
2006-03-08 17:16:07 +07:00
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
int i;
|
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
numadbg("Initializing tables for non-numa.\n");
|
2006-12-29 12:00:23 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
node_masks[0].mask = node_masks[0].val = 0;
|
|
|
|
num_node_masks = 1;
|
2006-03-08 17:16:07 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
for (i = 0; i < NR_CPUS; i++)
|
|
|
|
numa_cpu_lookup_table[i] = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-17 03:38:07 +07:00
|
|
|
cpumask_setall(&numa_cpumask_lookup_table[0]);
|
2008-04-23 19:40:25 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NEED_MULTIPLE_NODES
|
|
|
|
struct pglist_data *node_data[MAX_NUMNODES];
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(numa_cpu_lookup_table);
|
|
|
|
EXPORT_SYMBOL(numa_cpumask_lookup_table);
|
|
|
|
EXPORT_SYMBOL(node_data);
|
|
|
|
|
|
|
|
struct mdesc_mlgroup {
|
|
|
|
u64 node;
|
|
|
|
u64 latency;
|
|
|
|
u64 match;
|
|
|
|
u64 mask;
|
|
|
|
};
|
|
|
|
static struct mdesc_mlgroup *mlgroups;
|
|
|
|
static int num_mlgroups;
|
|
|
|
|
|
|
|
static int scan_pio_for_cfg_handle(struct mdesc_handle *md, u64 pio,
|
|
|
|
u32 cfg_handle)
|
|
|
|
{
|
|
|
|
u64 arc;
|
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, pio, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, target,
|
|
|
|
"cfg-handle", NULL);
|
|
|
|
if (val && *val == cfg_handle)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int scan_arcs_for_cfg_handle(struct mdesc_handle *md, u64 grp,
|
|
|
|
u32 cfg_handle)
|
|
|
|
{
|
|
|
|
u64 arc, candidate, best_latency = ~(u64)0;
|
|
|
|
|
|
|
|
candidate = MDESC_NODE_NULL;
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
const char *name = mdesc_node_name(md, target);
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
if (strcmp(name, "pio-latency-group"))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, target, "latency", NULL);
|
|
|
|
if (!val)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (*val < best_latency) {
|
|
|
|
candidate = target;
|
|
|
|
best_latency = *val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (candidate == MDESC_NODE_NULL)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return scan_pio_for_cfg_handle(md, candidate, cfg_handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
int of_node_to_nid(struct device_node *dp)
|
|
|
|
{
|
|
|
|
const struct linux_prom64_registers *regs;
|
|
|
|
struct mdesc_handle *md;
|
|
|
|
u32 cfg_handle;
|
|
|
|
int count, nid;
|
|
|
|
u64 grp;
|
|
|
|
|
2008-08-19 10:36:17 +07:00
|
|
|
/* This is the right thing to do on currently supported
|
|
|
|
* SUN4U NUMA platforms as well, as the PCI controller does
|
|
|
|
* not sit behind any particular memory controller.
|
|
|
|
*/
|
2008-04-23 19:40:25 +07:00
|
|
|
if (!mlgroups)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
regs = of_get_property(dp, "reg", NULL);
|
|
|
|
if (!regs)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
cfg_handle = (regs->phys_addr >> 32UL) & 0x0fffffff;
|
|
|
|
|
|
|
|
md = mdesc_grab();
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
nid = -1;
|
|
|
|
mdesc_for_each_node_by_name(md, grp, "group") {
|
|
|
|
if (!scan_arcs_for_cfg_handle(md, grp, cfg_handle)) {
|
|
|
|
nid = count;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdesc_release(md);
|
|
|
|
|
|
|
|
return nid;
|
|
|
|
}
|
|
|
|
|
2009-04-07 15:05:22 +07:00
|
|
|
static void __init add_node_ranges(void)
|
2008-04-23 19:40:25 +07:00
|
|
|
{
|
2010-08-04 10:43:31 +07:00
|
|
|
struct memblock_region *reg;
|
2008-04-23 19:40:25 +07:00
|
|
|
|
2010-08-04 10:43:31 +07:00
|
|
|
for_each_memblock(memory, reg) {
|
|
|
|
unsigned long size = reg->size;
|
2008-04-23 19:40:25 +07:00
|
|
|
unsigned long start, end;
|
|
|
|
|
2010-08-04 10:43:31 +07:00
|
|
|
start = reg->base;
|
2008-04-23 19:40:25 +07:00
|
|
|
end = start + size;
|
|
|
|
while (start < end) {
|
|
|
|
unsigned long this_end;
|
|
|
|
int nid;
|
|
|
|
|
2010-07-07 05:38:58 +07:00
|
|
|
this_end = memblock_nid_range(start, end, &nid);
|
2008-04-23 19:40:25 +07:00
|
|
|
|
2011-12-09 01:22:08 +07:00
|
|
|
numadbg("Setting memblock NUMA node nid[%d] "
|
2008-04-23 19:40:25 +07:00
|
|
|
"start[%lx] end[%lx]\n",
|
|
|
|
nid, start, this_end);
|
|
|
|
|
2011-12-09 01:22:08 +07:00
|
|
|
memblock_set_node(start, this_end - start, nid);
|
2008-04-23 19:40:25 +07:00
|
|
|
start = this_end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init grab_mlgroups(struct mdesc_handle *md)
|
|
|
|
{
|
|
|
|
unsigned long paddr;
|
|
|
|
int count = 0;
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "memory-latency-group")
|
|
|
|
count++;
|
|
|
|
if (!count)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2010-07-12 11:36:09 +07:00
|
|
|
paddr = memblock_alloc(count * sizeof(struct mdesc_mlgroup),
|
2008-04-23 19:40:25 +07:00
|
|
|
SMP_CACHE_BYTES);
|
|
|
|
if (!paddr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
mlgroups = __va(paddr);
|
|
|
|
num_mlgroups = count;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
mdesc_for_each_node_by_name(md, node, "memory-latency-group") {
|
|
|
|
struct mdesc_mlgroup *m = &mlgroups[count++];
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
m->node = node;
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, node, "latency", NULL);
|
|
|
|
m->latency = *val;
|
|
|
|
val = mdesc_get_property(md, node, "address-match", NULL);
|
|
|
|
m->match = *val;
|
|
|
|
val = mdesc_get_property(md, node, "address-mask", NULL);
|
|
|
|
m->mask = *val;
|
|
|
|
|
2009-01-07 04:19:28 +07:00
|
|
|
numadbg("MLGROUP[%d]: node[%llx] latency[%llx] "
|
|
|
|
"match[%llx] mask[%llx]\n",
|
2008-04-23 19:40:25 +07:00
|
|
|
count - 1, m->node, m->latency, m->match, m->mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init grab_mblocks(struct mdesc_handle *md)
|
|
|
|
{
|
|
|
|
unsigned long paddr;
|
|
|
|
int count = 0;
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
mdesc_for_each_node_by_name(md, node, "mblock")
|
|
|
|
count++;
|
|
|
|
if (!count)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2010-07-12 11:36:09 +07:00
|
|
|
paddr = memblock_alloc(count * sizeof(struct mdesc_mblock),
|
2008-04-23 19:40:25 +07:00
|
|
|
SMP_CACHE_BYTES);
|
|
|
|
if (!paddr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
mblocks = __va(paddr);
|
|
|
|
num_mblocks = count;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
mdesc_for_each_node_by_name(md, node, "mblock") {
|
|
|
|
struct mdesc_mblock *m = &mblocks[count++];
|
|
|
|
const u64 *val;
|
|
|
|
|
|
|
|
val = mdesc_get_property(md, node, "base", NULL);
|
|
|
|
m->base = *val;
|
|
|
|
val = mdesc_get_property(md, node, "size", NULL);
|
|
|
|
m->size = *val;
|
|
|
|
val = mdesc_get_property(md, node,
|
|
|
|
"address-congruence-offset", NULL);
|
2013-06-12 01:54:51 +07:00
|
|
|
|
|
|
|
/* The address-congruence-offset property is optional.
|
|
|
|
* Explicity zero it be identifty this.
|
|
|
|
*/
|
|
|
|
if (val)
|
|
|
|
m->offset = *val;
|
|
|
|
else
|
|
|
|
m->offset = 0UL;
|
2008-04-23 19:40:25 +07:00
|
|
|
|
2009-01-07 04:19:28 +07:00
|
|
|
numadbg("MBLOCK[%d]: base[%llx] size[%llx] offset[%llx]\n",
|
2008-04-23 19:40:25 +07:00
|
|
|
count - 1, m->base, m->size, m->offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init numa_parse_mdesc_group_cpus(struct mdesc_handle *md,
|
|
|
|
u64 grp, cpumask_t *mask)
|
|
|
|
{
|
|
|
|
u64 arc;
|
|
|
|
|
2011-05-17 03:38:07 +07:00
|
|
|
cpumask_clear(mask);
|
2008-04-23 19:40:25 +07:00
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_BACK) {
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
const char *name = mdesc_node_name(md, target);
|
|
|
|
const u64 *id;
|
|
|
|
|
|
|
|
if (strcmp(name, "cpu"))
|
|
|
|
continue;
|
|
|
|
id = mdesc_get_property(md, target, "id", NULL);
|
2009-03-16 11:10:23 +07:00
|
|
|
if (*id < nr_cpu_ids)
|
2011-05-17 03:38:07 +07:00
|
|
|
cpumask_set_cpu(*id, mask);
|
2008-04-23 19:40:25 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct mdesc_mlgroup * __init find_mlgroup(u64 node)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_mlgroups; i++) {
|
|
|
|
struct mdesc_mlgroup *m = &mlgroups[i];
|
|
|
|
if (m->node == node)
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init numa_attach_mlgroup(struct mdesc_handle *md, u64 grp,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
struct mdesc_mlgroup *candidate = NULL;
|
|
|
|
u64 arc, best_latency = ~(u64)0;
|
|
|
|
struct node_mem_mask *n;
|
|
|
|
|
|
|
|
mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 target = mdesc_arc_target(md, arc);
|
|
|
|
struct mdesc_mlgroup *m = find_mlgroup(target);
|
|
|
|
if (!m)
|
|
|
|
continue;
|
|
|
|
if (m->latency < best_latency) {
|
|
|
|
candidate = m;
|
|
|
|
best_latency = m->latency;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!candidate)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
if (num_node_masks != index) {
|
|
|
|
printk(KERN_ERR "Inconsistent NUMA state, "
|
|
|
|
"index[%d] != num_node_masks[%d]\n",
|
|
|
|
index, num_node_masks);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = &node_masks[num_node_masks++];
|
|
|
|
|
|
|
|
n->mask = candidate->mask;
|
|
|
|
n->val = candidate->match;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-07 04:19:28 +07:00
|
|
|
numadbg("NUMA NODE[%d]: mask[%lx] val[%lx] (latency[%llx])\n",
|
2008-04-23 19:40:25 +07:00
|
|
|
index, n->mask, n->val, candidate->latency);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init numa_parse_mdesc_group(struct mdesc_handle *md, u64 grp,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
cpumask_t mask;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
numa_parse_mdesc_group_cpus(md, grp, &mask);
|
|
|
|
|
2011-05-17 03:38:07 +07:00
|
|
|
for_each_cpu(cpu, &mask)
|
2008-04-23 19:40:25 +07:00
|
|
|
numa_cpu_lookup_table[cpu] = index;
|
2011-05-17 03:38:07 +07:00
|
|
|
cpumask_copy(&numa_cpumask_lookup_table[index], &mask);
|
2008-04-23 19:40:25 +07:00
|
|
|
|
|
|
|
if (numa_debug) {
|
|
|
|
printk(KERN_INFO "NUMA GROUP[%d]: cpus [ ", index);
|
2011-05-17 03:38:07 +07:00
|
|
|
for_each_cpu(cpu, &mask)
|
2008-04-23 19:40:25 +07:00
|
|
|
printk("%d ", cpu);
|
|
|
|
printk("]\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return numa_attach_mlgroup(md, grp, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init numa_parse_mdesc(void)
|
|
|
|
{
|
|
|
|
struct mdesc_handle *md = mdesc_grab();
|
|
|
|
int i, err, count;
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
node = mdesc_node_by_name(md, MDESC_NODE_NULL, "latency-groups");
|
|
|
|
if (node == MDESC_NODE_NULL) {
|
|
|
|
mdesc_release(md);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = grab_mblocks(md);
|
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = grab_mlgroups(md);
|
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
mdesc_for_each_node_by_name(md, node, "group") {
|
|
|
|
err = numa_parse_mdesc_group(md, node, count);
|
|
|
|
if (err < 0)
|
|
|
|
break;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
add_node_ranges();
|
|
|
|
|
|
|
|
for (i = 0; i < num_node_masks; i++) {
|
|
|
|
allocate_node_data(i);
|
|
|
|
node_set_online(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
out:
|
|
|
|
mdesc_release(md);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-08-19 10:36:17 +07:00
|
|
|
static int __init numa_parse_jbus(void)
|
|
|
|
{
|
|
|
|
unsigned long cpu, index;
|
|
|
|
|
|
|
|
/* NUMA node id is encoded in bits 36 and higher, and there is
|
|
|
|
* a 1-to-1 mapping from CPU ID to NUMA node ID.
|
|
|
|
*/
|
|
|
|
index = 0;
|
|
|
|
for_each_present_cpu(cpu) {
|
|
|
|
numa_cpu_lookup_table[cpu] = index;
|
2011-05-17 03:38:07 +07:00
|
|
|
cpumask_copy(&numa_cpumask_lookup_table[index], cpumask_of(cpu));
|
2008-08-19 10:36:17 +07:00
|
|
|
node_masks[index].mask = ~((1UL << 36UL) - 1UL);
|
|
|
|
node_masks[index].val = cpu << 36UL;
|
|
|
|
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
num_node_masks = index;
|
|
|
|
|
|
|
|
add_node_ranges();
|
|
|
|
|
|
|
|
for (index = 0; index < num_node_masks; index++) {
|
|
|
|
allocate_node_data(index);
|
|
|
|
node_set_online(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
static int __init numa_parse_sun4u(void)
|
|
|
|
{
|
2008-08-19 10:36:17 +07:00
|
|
|
if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
|
|
|
unsigned long ver;
|
|
|
|
|
|
|
|
__asm__ ("rdpr %%ver, %0" : "=r" (ver));
|
|
|
|
if ((ver >> 32UL) == __JALAPENO_ID ||
|
|
|
|
(ver >> 32UL) == __SERRANO_ID)
|
|
|
|
return numa_parse_jbus();
|
|
|
|
}
|
2008-04-23 19:40:25 +07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init bootmem_init_numa(void)
|
|
|
|
{
|
|
|
|
int err = -1;
|
|
|
|
|
|
|
|
numadbg("bootmem_init_numa()\n");
|
|
|
|
|
|
|
|
if (numa_enabled) {
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
err = numa_parse_mdesc();
|
|
|
|
else
|
|
|
|
err = numa_parse_sun4u();
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
static int bootmem_init_numa(void)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void __init bootmem_init_nonnuma(void)
|
|
|
|
{
|
2010-07-12 11:36:09 +07:00
|
|
|
unsigned long top_of_ram = memblock_end_of_DRAM();
|
|
|
|
unsigned long total_ram = memblock_phys_mem_size();
|
2008-04-23 19:40:25 +07:00
|
|
|
|
|
|
|
numadbg("bootmem_init_nonnuma()\n");
|
|
|
|
|
|
|
|
printk(KERN_INFO "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
|
|
|
|
top_of_ram, total_ram);
|
|
|
|
printk(KERN_INFO "Memory hole size: %ldMB\n",
|
|
|
|
(top_of_ram - total_ram) >> 20);
|
|
|
|
|
|
|
|
init_node_masks_nonnuma();
|
2011-12-09 01:22:08 +07:00
|
|
|
memblock_set_node(0, (phys_addr_t)ULLONG_MAX, 0);
|
2008-04-23 19:40:25 +07:00
|
|
|
allocate_node_data(0);
|
|
|
|
node_set_online(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long __init bootmem_init(unsigned long phys_base)
|
|
|
|
{
|
|
|
|
unsigned long end_pfn;
|
|
|
|
|
2010-07-12 11:36:09 +07:00
|
|
|
end_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT;
|
2008-04-23 19:40:25 +07:00
|
|
|
max_pfn = max_low_pfn = end_pfn;
|
|
|
|
min_low_pfn = (phys_base >> PAGE_SHIFT);
|
|
|
|
|
|
|
|
if (bootmem_init_numa() < 0)
|
|
|
|
bootmem_init_nonnuma();
|
|
|
|
|
2012-04-26 03:13:43 +07:00
|
|
|
/* Dump memblock with node info. */
|
|
|
|
memblock_dump_all();
|
2008-04-23 19:40:25 +07:00
|
|
|
|
2012-04-26 03:13:43 +07:00
|
|
|
/* XXX cpu notifier XXX */
|
2006-03-08 17:16:07 +07:00
|
|
|
|
2012-04-26 03:13:43 +07:00
|
|
|
sparse_memory_present_with_active_regions(MAX_NUMNODES);
|
2006-03-08 17:16:07 +07:00
|
|
|
sparse_init();
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return end_pfn;
|
|
|
|
}
|
|
|
|
|
2006-02-22 11:51:13 +07:00
|
|
|
static struct linux_prom64_registers pall[MAX_BANKS] __initdata;
|
|
|
|
static int pall_ents __initdata;
|
|
|
|
|
2005-09-26 06:46:57 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2008-02-25 10:49:52 +07:00
|
|
|
static unsigned long __ref kernel_map_range(unsigned long pstart,
|
|
|
|
unsigned long pend, pgprot_t prot)
|
2005-09-26 06:46:57 +07:00
|
|
|
{
|
|
|
|
unsigned long vstart = PAGE_OFFSET + pstart;
|
|
|
|
unsigned long vend = PAGE_OFFSET + pend;
|
|
|
|
unsigned long alloc_bytes = 0UL;
|
|
|
|
|
|
|
|
if ((vstart & ~PAGE_MASK) || (vend & ~PAGE_MASK)) {
|
2005-09-30 07:58:26 +07:00
|
|
|
prom_printf("kernel_map: Unaligned physmem[%lx:%lx]\n",
|
2005-09-26 06:46:57 +07:00
|
|
|
vstart, vend);
|
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
|
|
|
while (vstart < vend) {
|
|
|
|
unsigned long this_end, paddr = __pa(vstart);
|
|
|
|
pgd_t *pgd = pgd_offset_k(vstart);
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
pte_t *pte;
|
|
|
|
|
|
|
|
pud = pud_offset(pgd, vstart);
|
|
|
|
if (pud_none(*pud)) {
|
|
|
|
pmd_t *new;
|
|
|
|
|
|
|
|
new = __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, PAGE_SIZE);
|
|
|
|
alloc_bytes += PAGE_SIZE;
|
|
|
|
pud_populate(&init_mm, pud, new);
|
|
|
|
}
|
|
|
|
|
|
|
|
pmd = pmd_offset(pud, vstart);
|
|
|
|
if (!pmd_present(*pmd)) {
|
|
|
|
pte_t *new;
|
|
|
|
|
|
|
|
new = __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, PAGE_SIZE);
|
|
|
|
alloc_bytes += PAGE_SIZE;
|
|
|
|
pmd_populate_kernel(&init_mm, pmd, new);
|
|
|
|
}
|
|
|
|
|
|
|
|
pte = pte_offset_kernel(pmd, vstart);
|
|
|
|
this_end = (vstart + PMD_SIZE) & PMD_MASK;
|
|
|
|
if (this_end > vend)
|
|
|
|
this_end = vend;
|
|
|
|
|
|
|
|
while (vstart < this_end) {
|
|
|
|
pte_val(*pte) = (paddr | pgprot_val(prot));
|
|
|
|
|
|
|
|
vstart += PAGE_SIZE;
|
|
|
|
paddr += PAGE_SIZE;
|
|
|
|
pte++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return alloc_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern unsigned int kvmap_linear_patch[1];
|
2006-02-22 11:51:13 +07:00
|
|
|
#endif /* CONFIG_DEBUG_PAGEALLOC */
|
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
static void __init kpte_set_val(unsigned long index, unsigned long val)
|
2006-02-22 11:51:13 +07:00
|
|
|
{
|
2012-09-07 08:13:58 +07:00
|
|
|
unsigned long *ptr = kpte_linear_bitmap;
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
val <<= ((index % (BITS_PER_LONG / 2)) * 2);
|
|
|
|
ptr += (index / (BITS_PER_LONG / 2));
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
*ptr |= val;
|
|
|
|
}
|
2006-03-06 13:18:50 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
static const unsigned long kpte_shift_min = 28; /* 256MB */
|
|
|
|
static const unsigned long kpte_shift_max = 34; /* 16GB */
|
|
|
|
static const unsigned long kpte_shift_incr = 3;
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
static unsigned long kpte_mark_using_shift(unsigned long start, unsigned long end,
|
|
|
|
unsigned long shift)
|
|
|
|
{
|
|
|
|
unsigned long size = (1UL << shift);
|
|
|
|
unsigned long mask = (size - 1UL);
|
|
|
|
unsigned long remains = end - start;
|
|
|
|
unsigned long val;
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
if (remains < size || (start & mask))
|
|
|
|
return start;
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
/* VAL maps:
|
|
|
|
*
|
|
|
|
* shift 28 --> kern_linear_pte_xor index 1
|
|
|
|
* shift 31 --> kern_linear_pte_xor index 2
|
|
|
|
* shift 34 --> kern_linear_pte_xor index 3
|
|
|
|
*/
|
|
|
|
val = ((shift - kpte_shift_min) / kpte_shift_incr) + 1;
|
|
|
|
|
|
|
|
remains &= ~mask;
|
|
|
|
if (shift != kpte_shift_max)
|
|
|
|
remains = size;
|
|
|
|
|
|
|
|
while (remains) {
|
|
|
|
unsigned long index = start >> kpte_shift_min;
|
|
|
|
|
|
|
|
kpte_set_val(index, val);
|
|
|
|
|
|
|
|
start += 1UL << kpte_shift_min;
|
|
|
|
remains -= 1UL << kpte_shift_min;
|
|
|
|
}
|
|
|
|
|
|
|
|
return start;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init mark_kpte_bitmap(unsigned long start, unsigned long end)
|
|
|
|
{
|
|
|
|
unsigned long smallest_size, smallest_mask;
|
|
|
|
unsigned long s;
|
|
|
|
|
|
|
|
smallest_size = (1UL << kpte_shift_min);
|
|
|
|
smallest_mask = (smallest_size - 1UL);
|
|
|
|
|
|
|
|
while (start < end) {
|
|
|
|
unsigned long orig_start = start;
|
|
|
|
|
|
|
|
for (s = kpte_shift_max; s >= kpte_shift_min; s -= kpte_shift_incr) {
|
|
|
|
start = kpte_mark_using_shift(start, end, s);
|
|
|
|
|
|
|
|
if (start != orig_start)
|
|
|
|
break;
|
2006-02-22 11:51:13 +07:00
|
|
|
}
|
2012-09-07 08:13:58 +07:00
|
|
|
|
|
|
|
if (start == orig_start)
|
|
|
|
start = (start + smallest_size) & ~smallest_mask;
|
2006-02-22 11:51:13 +07:00
|
|
|
}
|
|
|
|
}
|
2005-09-26 06:46:57 +07:00
|
|
|
|
2007-12-13 21:13:38 +07:00
|
|
|
static void __init init_kpte_bitmap(void)
|
2005-09-26 06:46:57 +07:00
|
|
|
{
|
2006-02-22 11:51:13 +07:00
|
|
|
unsigned long i;
|
2005-09-30 07:58:26 +07:00
|
|
|
|
|
|
|
for (i = 0; i < pall_ents; i++) {
|
2005-09-26 06:46:57 +07:00
|
|
|
unsigned long phys_start, phys_end;
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
phys_start = pall[i].phys_addr;
|
|
|
|
phys_end = phys_start + pall[i].reg_size;
|
2006-02-22 11:51:13 +07:00
|
|
|
|
|
|
|
mark_kpte_bitmap(phys_start, phys_end);
|
2007-12-13 21:13:38 +07:00
|
|
|
}
|
|
|
|
}
|
2006-02-22 11:51:13 +07:00
|
|
|
|
2007-12-13 21:13:38 +07:00
|
|
|
static void __init kernel_physical_mapping_init(void)
|
|
|
|
{
|
2006-02-22 11:51:13 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2007-12-13 21:13:38 +07:00
|
|
|
unsigned long i, mem_alloced = 0UL;
|
|
|
|
|
|
|
|
for (i = 0; i < pall_ents; i++) {
|
|
|
|
unsigned long phys_start, phys_end;
|
|
|
|
|
|
|
|
phys_start = pall[i].phys_addr;
|
|
|
|
phys_end = phys_start + pall[i].reg_size;
|
|
|
|
|
2005-09-26 06:46:57 +07:00
|
|
|
mem_alloced += kernel_map_range(phys_start, phys_end,
|
|
|
|
PAGE_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
printk("Allocated %ld bytes for kernel page tables.\n",
|
|
|
|
mem_alloced);
|
|
|
|
|
|
|
|
kvmap_linear_patch[0] = 0x01000000; /* nop */
|
|
|
|
flushi(&kvmap_linear_patch[0]);
|
|
|
|
|
|
|
|
__flush_tlb_all();
|
2006-02-22 11:51:13 +07:00
|
|
|
#endif
|
2005-09-26 06:46:57 +07:00
|
|
|
}
|
|
|
|
|
2006-02-22 11:51:13 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2005-09-26 06:46:57 +07:00
|
|
|
void kernel_map_pages(struct page *page, int numpages, int enable)
|
|
|
|
{
|
|
|
|
unsigned long phys_start = page_to_pfn(page) << PAGE_SHIFT;
|
|
|
|
unsigned long phys_end = phys_start + (numpages * PAGE_SIZE);
|
|
|
|
|
|
|
|
kernel_map_range(phys_start, phys_end,
|
|
|
|
(enable ? PAGE_KERNEL : __pgprot(0)));
|
|
|
|
|
2006-02-01 09:29:18 +07:00
|
|
|
flush_tsb_kernel_range(PAGE_OFFSET + phys_start,
|
|
|
|
PAGE_OFFSET + phys_end);
|
|
|
|
|
2005-09-26 06:46:57 +07:00
|
|
|
/* we should perform an IPI and flush all tlbs,
|
|
|
|
* but that can deadlock->flush only current cpu.
|
|
|
|
*/
|
|
|
|
__flush_tlb_kernel_range(PAGE_OFFSET + phys_start,
|
|
|
|
PAGE_OFFSET + phys_end);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-09-29 11:46:43 +07:00
|
|
|
unsigned long __init find_ecache_flush_span(unsigned long size)
|
|
|
|
{
|
2005-09-29 11:38:08 +07:00
|
|
|
int i;
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
|
|
|
if (pavail[i].reg_size >= size)
|
|
|
|
return pavail[i].phys_addr;
|
2005-09-29 11:38:08 +07:00
|
|
|
}
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
return ~0UL;
|
2005-09-29 11:38:08 +07:00
|
|
|
}
|
|
|
|
|
2006-02-02 06:55:21 +07:00
|
|
|
static void __init tsb_phys_patch(void)
|
|
|
|
{
|
2006-02-07 14:44:37 +07:00
|
|
|
struct tsb_ldquad_phys_patch_entry *pquad;
|
2006-02-02 06:55:21 +07:00
|
|
|
struct tsb_phys_patch_entry *p;
|
|
|
|
|
2006-02-07 14:44:37 +07:00
|
|
|
pquad = &__tsb_ldquad_phys_patch;
|
|
|
|
while (pquad < &__tsb_ldquad_phys_patch_end) {
|
|
|
|
unsigned long addr = pquad->addr;
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
*(unsigned int *) addr = pquad->sun4v_insn;
|
|
|
|
else
|
|
|
|
*(unsigned int *) addr = pquad->sun4u_insn;
|
|
|
|
wmb();
|
|
|
|
__asm__ __volatile__("flush %0"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (addr));
|
|
|
|
|
|
|
|
pquad++;
|
|
|
|
}
|
|
|
|
|
2006-02-02 06:55:21 +07:00
|
|
|
p = &__tsb_phys_patch;
|
|
|
|
while (p < &__tsb_phys_patch_end) {
|
|
|
|
unsigned long addr = p->addr;
|
|
|
|
|
|
|
|
*(unsigned int *) addr = p->insn;
|
|
|
|
wmb();
|
|
|
|
__asm__ __volatile__("flush %0"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (addr));
|
|
|
|
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-12 05:41:18 +07:00
|
|
|
/* Don't mark as init, we give this to the Hypervisor. */
|
2007-03-17 07:20:28 +07:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
#define NUM_KTSB_DESCR 2
|
|
|
|
#else
|
|
|
|
#define NUM_KTSB_DESCR 1
|
|
|
|
#endif
|
|
|
|
static struct hv_tsb_descr ktsb_descr[NUM_KTSB_DESCR];
|
2006-02-12 05:41:18 +07:00
|
|
|
extern struct tsb swapper_tsb[KERNEL_TSB_NENTRIES];
|
|
|
|
|
2011-08-05 14:53:57 +07:00
|
|
|
static void patch_one_ktsb_phys(unsigned int *start, unsigned int *end, unsigned long pa)
|
|
|
|
{
|
|
|
|
pa >>= KTSB_PHYS_SHIFT;
|
|
|
|
|
|
|
|
while (start < end) {
|
|
|
|
unsigned int *ia = (unsigned int *)(unsigned long)*start;
|
|
|
|
|
|
|
|
ia[0] = (ia[0] & ~0x3fffff) | (pa >> 10);
|
|
|
|
__asm__ __volatile__("flush %0" : : "r" (ia));
|
|
|
|
|
|
|
|
ia[1] = (ia[1] & ~0x3ff) | (pa & 0x3ff);
|
|
|
|
__asm__ __volatile__("flush %0" : : "r" (ia + 1));
|
|
|
|
|
|
|
|
start++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ktsb_phys_patch(void)
|
|
|
|
{
|
|
|
|
extern unsigned int __swapper_tsb_phys_patch;
|
|
|
|
extern unsigned int __swapper_tsb_phys_patch_end;
|
|
|
|
unsigned long ktsb_pa;
|
|
|
|
|
|
|
|
ktsb_pa = kern_base + ((unsigned long)&swapper_tsb[0] - KERNBASE);
|
|
|
|
patch_one_ktsb_phys(&__swapper_tsb_phys_patch,
|
|
|
|
&__swapper_tsb_phys_patch_end, ktsb_pa);
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2011-08-06 19:26:35 +07:00
|
|
|
{
|
|
|
|
extern unsigned int __swapper_4m_tsb_phys_patch;
|
|
|
|
extern unsigned int __swapper_4m_tsb_phys_patch_end;
|
2011-08-05 14:53:57 +07:00
|
|
|
ktsb_pa = (kern_base +
|
|
|
|
((unsigned long)&swapper_4m_tsb[0] - KERNBASE));
|
|
|
|
patch_one_ktsb_phys(&__swapper_4m_tsb_phys_patch,
|
|
|
|
&__swapper_4m_tsb_phys_patch_end, ktsb_pa);
|
2011-08-06 19:26:35 +07:00
|
|
|
}
|
2011-08-05 14:53:57 +07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-02-12 05:41:18 +07:00
|
|
|
static void __init sun4v_ktsb_init(void)
|
|
|
|
{
|
|
|
|
unsigned long ktsb_pa;
|
|
|
|
|
2006-02-22 13:31:11 +07:00
|
|
|
/* First KTSB for PAGE_SIZE mappings. */
|
2006-02-12 05:41:18 +07:00
|
|
|
ktsb_pa = kern_base + ((unsigned long)&swapper_tsb[0] - KERNBASE);
|
|
|
|
|
|
|
|
switch (PAGE_SIZE) {
|
|
|
|
case 8 * 1024:
|
|
|
|
default:
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_8K;
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_8K;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 64 * 1024:
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_64K;
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_64K;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 512 * 1024:
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_512K;
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_512K;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4 * 1024 * 1024:
|
|
|
|
ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_4MB;
|
|
|
|
ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_4MB;
|
|
|
|
break;
|
2011-06-03 21:45:23 +07:00
|
|
|
}
|
2006-02-12 05:41:18 +07:00
|
|
|
|
2006-02-18 03:03:20 +07:00
|
|
|
ktsb_descr[0].assoc = 1;
|
2006-02-12 05:41:18 +07:00
|
|
|
ktsb_descr[0].num_ttes = KERNEL_TSB_NENTRIES;
|
|
|
|
ktsb_descr[0].ctx_idx = 0;
|
|
|
|
ktsb_descr[0].tsb_base = ktsb_pa;
|
|
|
|
ktsb_descr[0].resv = 0;
|
|
|
|
|
2007-03-17 07:20:28 +07:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2012-09-07 08:13:58 +07:00
|
|
|
/* Second KTSB for 4MB/256MB/2GB/16GB mappings. */
|
2006-02-22 13:31:11 +07:00
|
|
|
ktsb_pa = (kern_base +
|
|
|
|
((unsigned long)&swapper_4m_tsb[0] - KERNBASE));
|
|
|
|
|
|
|
|
ktsb_descr[1].pgsz_idx = HV_PGSZ_IDX_4MB;
|
2012-09-07 10:35:36 +07:00
|
|
|
ktsb_descr[1].pgsz_mask = ((HV_PGSZ_MASK_4MB |
|
|
|
|
HV_PGSZ_MASK_256MB |
|
|
|
|
HV_PGSZ_MASK_2GB |
|
|
|
|
HV_PGSZ_MASK_16GB) &
|
|
|
|
cpu_pgsz_mask);
|
2006-02-22 13:31:11 +07:00
|
|
|
ktsb_descr[1].assoc = 1;
|
|
|
|
ktsb_descr[1].num_ttes = KERNEL_TSB4M_NENTRIES;
|
|
|
|
ktsb_descr[1].ctx_idx = 0;
|
|
|
|
ktsb_descr[1].tsb_base = ktsb_pa;
|
|
|
|
ktsb_descr[1].resv = 0;
|
2007-03-17 07:20:28 +07:00
|
|
|
#endif
|
2006-02-12 05:41:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void __cpuinit sun4v_ktsb_register(void)
|
|
|
|
{
|
2007-05-29 16:22:14 +07:00
|
|
|
unsigned long pa, ret;
|
2006-02-12 05:41:18 +07:00
|
|
|
|
|
|
|
pa = kern_base + ((unsigned long)&ktsb_descr[0] - KERNBASE);
|
|
|
|
|
2007-05-29 16:22:14 +07:00
|
|
|
ret = sun4v_mmu_tsb_ctx0(NUM_KTSB_DESCR, pa);
|
|
|
|
if (ret != 0) {
|
|
|
|
prom_printf("hypervisor_mmu_tsb_ctx0[%lx]: "
|
|
|
|
"errors with %lx\n", pa, ret);
|
|
|
|
prom_halt();
|
|
|
|
}
|
2006-02-12 05:41:18 +07:00
|
|
|
}
|
|
|
|
|
2012-09-07 10:35:36 +07:00
|
|
|
static void __init sun4u_linear_pte_xor_finalize(void)
|
|
|
|
{
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
/* This is where we would add Panther support for
|
|
|
|
* 32MB and 256MB pages.
|
|
|
|
*/
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init sun4v_linear_pte_xor_finalize(void)
|
|
|
|
{
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
if (cpu_pgsz_mask & HV_PGSZ_MASK_256MB) {
|
|
|
|
kern_linear_pte_xor[1] = (_PAGE_VALID | _PAGE_SZ256MB_4V) ^
|
|
|
|
0xfffff80000000000UL;
|
|
|
|
kern_linear_pte_xor[1] |= (_PAGE_CP_4V | _PAGE_CV_4V |
|
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
} else {
|
|
|
|
kern_linear_pte_xor[1] = kern_linear_pte_xor[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu_pgsz_mask & HV_PGSZ_MASK_2GB) {
|
|
|
|
kern_linear_pte_xor[2] = (_PAGE_VALID | _PAGE_SZ2GB_4V) ^
|
|
|
|
0xfffff80000000000UL;
|
|
|
|
kern_linear_pte_xor[2] |= (_PAGE_CP_4V | _PAGE_CV_4V |
|
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
} else {
|
|
|
|
kern_linear_pte_xor[2] = kern_linear_pte_xor[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu_pgsz_mask & HV_PGSZ_MASK_16GB) {
|
|
|
|
kern_linear_pte_xor[3] = (_PAGE_VALID | _PAGE_SZ16GB_4V) ^
|
|
|
|
0xfffff80000000000UL;
|
|
|
|
kern_linear_pte_xor[3] |= (_PAGE_CP_4V | _PAGE_CV_4V |
|
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
} else {
|
|
|
|
kern_linear_pte_xor[3] = kern_linear_pte_xor[2];
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* paging_init() sets up the page tables */
|
|
|
|
|
|
|
|
static unsigned long last_valid_pfn;
|
2005-09-26 06:46:57 +07:00
|
|
|
pgd_t swapper_pg_dir[2048];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
static void sun4u_pgprot_init(void);
|
|
|
|
static void sun4v_pgprot_init(void);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
void __init paging_init(void)
|
|
|
|
{
|
2008-04-23 19:40:25 +07:00
|
|
|
unsigned long end_pfn, shift, phys_base;
|
2005-09-29 11:38:08 +07:00
|
|
|
unsigned long real_end, i;
|
2012-05-10 07:44:29 +07:00
|
|
|
int node;
|
2005-09-29 11:38:08 +07:00
|
|
|
|
2007-05-26 15:14:43 +07:00
|
|
|
/* These build time checkes make sure that the dcache_dirty_cpu()
|
|
|
|
* page->flags usage will work.
|
|
|
|
*
|
|
|
|
* When a page gets marked as dcache-dirty, we store the
|
|
|
|
* cpu number starting at bit 32 in the page->flags. Also,
|
|
|
|
* functions like clear_dcache_dirty_cpu use the cpu mask
|
|
|
|
* in 13-bit signed-immediate instruction fields.
|
|
|
|
*/
|
2008-04-28 16:12:48 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Page flags must not reach into upper 32 bits that are used
|
|
|
|
* for the cpu number
|
|
|
|
*/
|
|
|
|
BUILD_BUG_ON(NR_PAGEFLAGS > 32);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The bit fields placed in the high range must not reach below
|
|
|
|
* the 32 bit boundary. Otherwise we cannot place the cpu field
|
|
|
|
* at the 32 bit boundary.
|
|
|
|
*/
|
2007-05-26 15:14:43 +07:00
|
|
|
BUILD_BUG_ON(SECTIONS_WIDTH + NODES_WIDTH + ZONES_WIDTH +
|
2008-04-28 16:12:48 +07:00
|
|
|
ilog2(roundup_pow_of_two(NR_CPUS)) > 32);
|
|
|
|
|
2007-05-26 15:14:43 +07:00
|
|
|
BUILD_BUG_ON(NR_CPUS > 4096);
|
|
|
|
|
2006-02-08 12:51:08 +07:00
|
|
|
kern_base = (prom_boot_mapping_phys_low >> 22UL) << 22UL;
|
|
|
|
kern_size = (unsigned long)&_end - (unsigned long)KERNBASE;
|
|
|
|
|
2006-02-22 13:31:11 +07:00
|
|
|
/* Invalidate both kernel TSBs. */
|
2006-02-18 09:01:02 +07:00
|
|
|
memset(swapper_tsb, 0x40, sizeof(swapper_tsb));
|
2007-03-17 07:20:28 +07:00
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
2006-02-22 13:31:11 +07:00
|
|
|
memset(swapper_4m_tsb, 0x40, sizeof(swapper_4m_tsb));
|
2007-03-17 07:20:28 +07:00
|
|
|
#endif
|
2006-02-18 09:01:02 +07:00
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
sun4v_pgprot_init();
|
|
|
|
else
|
|
|
|
sun4u_pgprot_init();
|
|
|
|
|
2006-02-07 14:44:37 +07:00
|
|
|
if (tlb_type == cheetah_plus ||
|
2011-08-05 14:53:57 +07:00
|
|
|
tlb_type == hypervisor) {
|
2006-02-02 06:55:21 +07:00
|
|
|
tsb_phys_patch();
|
2011-08-05 14:53:57 +07:00
|
|
|
ktsb_phys_patch();
|
|
|
|
}
|
2006-02-02 06:55:21 +07:00
|
|
|
|
2012-09-07 10:35:36 +07:00
|
|
|
if (tlb_type == hypervisor)
|
2006-02-07 14:44:37 +07:00
|
|
|
sun4v_patch_tlb_handlers();
|
|
|
|
|
2008-05-12 11:04:48 +07:00
|
|
|
/* Find available physical memory...
|
|
|
|
*
|
|
|
|
* Read it twice in order to work around a bug in openfirmware.
|
|
|
|
* The call to grab this table itself can cause openfirmware to
|
|
|
|
* allocate memory, which in turn can take away some space from
|
|
|
|
* the list of available memory. Reading it twice makes sure
|
|
|
|
* we really do get the final value.
|
|
|
|
*/
|
|
|
|
read_obp_translations();
|
|
|
|
read_obp_memory("reg", &pall[0], &pall_ents);
|
|
|
|
read_obp_memory("available", &pavail[0], &pavail_ents);
|
2005-09-30 07:58:26 +07:00
|
|
|
read_obp_memory("available", &pavail[0], &pavail_ents);
|
2005-09-29 11:38:08 +07:00
|
|
|
|
|
|
|
phys_base = 0xffffffffffffffffUL;
|
2008-02-14 09:13:20 +07:00
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
2005-09-30 07:58:26 +07:00
|
|
|
phys_base = min(phys_base, pavail[i].phys_addr);
|
2010-07-12 11:36:09 +07:00
|
|
|
memblock_add(pavail[i].phys_addr, pavail[i].reg_size);
|
2008-02-14 09:13:20 +07:00
|
|
|
}
|
|
|
|
|
2010-07-12 11:36:09 +07:00
|
|
|
memblock_reserve(kern_base, kern_size);
|
2005-09-29 11:38:08 +07:00
|
|
|
|
2008-02-14 09:00:03 +07:00
|
|
|
find_ramdisk(phys_base);
|
|
|
|
|
2010-07-12 11:36:09 +07:00
|
|
|
memblock_enforce_memory_limit(cmdline_memory_size);
|
2008-02-14 09:20:14 +07:00
|
|
|
|
2011-12-09 01:22:08 +07:00
|
|
|
memblock_allow_resize();
|
2010-07-12 11:36:09 +07:00
|
|
|
memblock_dump_all();
|
2008-02-14 09:13:20 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
set_bit(0, mmu_context_bmap);
|
|
|
|
|
2005-09-22 15:08:57 +07:00
|
|
|
shift = kern_base + PAGE_OFFSET - ((unsigned long)KERNBASE);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
real_end = (unsigned long)_end;
|
2008-03-22 07:01:38 +07:00
|
|
|
num_kernel_image_mappings = DIV_ROUND_UP(real_end - KERNBASE, 1 << 22);
|
|
|
|
printk("Kernel: Using %d locked TLB entries for main kernel image.\n",
|
|
|
|
num_kernel_image_mappings);
|
2005-09-22 15:08:57 +07:00
|
|
|
|
|
|
|
/* Set kernel pgd to upper alias so physical page computations
|
2005-04-17 05:20:36 +07:00
|
|
|
* work.
|
|
|
|
*/
|
|
|
|
init_mm.pgd += ((shift) / (sizeof(pgd_t)));
|
|
|
|
|
2005-09-26 06:46:57 +07:00
|
|
|
memset(swapper_low_pmd_dir, 0, sizeof(swapper_low_pmd_dir));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Now can init the kernel/bad page tables. */
|
|
|
|
pud_set(pud_offset(&swapper_pg_dir[0], 0),
|
2005-09-26 06:46:57 +07:00
|
|
|
swapper_low_pmd_dir + (shift / sizeof(pgd_t)));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
inherit_prom_mappings();
|
2005-09-22 14:45:41 +07:00
|
|
|
|
2007-12-13 21:13:38 +07:00
|
|
|
init_kpte_bitmap();
|
|
|
|
|
2006-02-01 09:33:37 +07:00
|
|
|
/* Ok, we can use our TLB miss and window trap handlers safely. */
|
|
|
|
setup_tba();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-10-13 02:22:46 +07:00
|
|
|
__flush_tlb_all();
|
2005-10-06 05:12:00 +07:00
|
|
|
|
2008-02-14 10:21:51 +07:00
|
|
|
prom_build_devicetree();
|
2009-05-27 12:37:25 +07:00
|
|
|
of_populate_present_mask();
|
2009-06-18 15:44:19 +07:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
of_fill_in_cpu_data();
|
|
|
|
#endif
|
2008-02-14 10:21:51 +07:00
|
|
|
|
2009-04-01 17:13:15 +07:00
|
|
|
if (tlb_type == hypervisor) {
|
2008-02-14 10:22:23 +07:00
|
|
|
sun4v_mdesc_init();
|
2009-06-15 17:06:18 +07:00
|
|
|
mdesc_populate_present_mask(cpu_all_mask);
|
2009-06-18 15:44:19 +07:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
mdesc_fill_in_cpu_data(cpu_all_mask);
|
|
|
|
#endif
|
2012-09-07 09:01:25 +07:00
|
|
|
mdesc_get_page_sizes(cpu_all_mask, &cpu_pgsz_mask);
|
2012-09-07 10:35:36 +07:00
|
|
|
|
|
|
|
sun4v_linear_pte_xor_finalize();
|
|
|
|
|
|
|
|
sun4v_ktsb_init();
|
|
|
|
sun4v_ktsb_register();
|
2012-09-07 09:01:25 +07:00
|
|
|
} else {
|
|
|
|
unsigned long impl, ver;
|
|
|
|
|
|
|
|
cpu_pgsz_mask = (HV_PGSZ_MASK_8K | HV_PGSZ_MASK_64K |
|
|
|
|
HV_PGSZ_MASK_512K | HV_PGSZ_MASK_4MB);
|
|
|
|
|
|
|
|
__asm__ __volatile__("rdpr %%ver, %0" : "=r" (ver));
|
|
|
|
impl = ((ver >> 32) & 0xffff);
|
|
|
|
if (impl == PANTHER_IMPL)
|
|
|
|
cpu_pgsz_mask |= (HV_PGSZ_MASK_32MB |
|
|
|
|
HV_PGSZ_MASK_256MB);
|
2012-09-07 10:35:36 +07:00
|
|
|
|
|
|
|
sun4u_linear_pte_xor_finalize();
|
2009-04-01 17:13:15 +07:00
|
|
|
}
|
2008-02-14 10:22:23 +07:00
|
|
|
|
2012-09-07 10:35:36 +07:00
|
|
|
/* Flush the TLBs and the 4M TSB so that the updated linear
|
|
|
|
* pte XOR settings are realized for all mappings.
|
|
|
|
*/
|
|
|
|
__flush_tlb_all();
|
|
|
|
#ifndef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
memset(swapper_4m_tsb, 0x40, sizeof(swapper_4m_tsb));
|
|
|
|
#endif
|
|
|
|
__flush_tlb_all();
|
|
|
|
|
2012-04-27 10:50:34 +07:00
|
|
|
/* Setup bootmem... */
|
|
|
|
last_valid_pfn = end_pfn = bootmem_init(phys_base);
|
|
|
|
|
2008-08-13 08:33:56 +07:00
|
|
|
/* Once the OF device tree and MDESC have been setup, we know
|
|
|
|
* the list of possible cpus. Therefore we can allocate the
|
|
|
|
* IRQ stacks.
|
|
|
|
*/
|
|
|
|
for_each_possible_cpu(i) {
|
2012-05-10 07:44:29 +07:00
|
|
|
node = cpu_to_node(i);
|
2012-04-27 10:50:34 +07:00
|
|
|
|
|
|
|
softirq_stack[i] = __alloc_bootmem_node(NODE_DATA(node),
|
|
|
|
THREAD_SIZE,
|
|
|
|
THREAD_SIZE, 0);
|
|
|
|
hardirq_stack[i] = __alloc_bootmem_node(NODE_DATA(node),
|
|
|
|
THREAD_SIZE,
|
|
|
|
THREAD_SIZE, 0);
|
2008-08-13 08:33:56 +07:00
|
|
|
}
|
|
|
|
|
2005-09-26 06:46:57 +07:00
|
|
|
kernel_physical_mapping_init();
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-04-23 19:40:25 +07:00
|
|
|
unsigned long max_zone_pfns[MAX_NR_ZONES];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
max_zone_pfns[ZONE_NORMAL] = end_pfn;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-23 19:40:25 +07:00
|
|
|
free_area_init_nodes(max_zone_pfns);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-02-18 14:22:50 +07:00
|
|
|
printk("Booting Linux...\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2012-12-22 05:03:26 +07:00
|
|
|
int page_in_phys_avail(unsigned long paddr)
|
2008-04-23 19:40:25 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
paddr &= PAGE_MASK;
|
|
|
|
|
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
|
|
|
unsigned long start, end;
|
|
|
|
|
|
|
|
start = pavail[i].phys_addr;
|
|
|
|
end = start + pavail[i].reg_size;
|
|
|
|
|
|
|
|
if (paddr >= start && paddr < end)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (paddr >= kern_base && paddr < (kern_base + kern_size))
|
|
|
|
return 1;
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
if (paddr >= __pa(initrd_start) &&
|
|
|
|
paddr < __pa(PAGE_ALIGN(initrd_end)))
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct linux_prom64_registers pavail_rescan[MAX_BANKS] __initdata;
|
|
|
|
static int pavail_rescan_ents __initdata;
|
|
|
|
|
|
|
|
/* Certain OBP calls, such as fetching "available" properties, can
|
|
|
|
* claim physical memory. So, along with initializing the valid
|
|
|
|
* address bitmap, what we do here is refetch the physical available
|
|
|
|
* memory list again, and make sure it provides at least as much
|
|
|
|
* memory as 'pavail' does.
|
|
|
|
*/
|
sparc64: Validate linear D-TLB misses.
When page alloc debugging is not enabled, we essentially accept any
virtual address for linear kernel TLB misses. But with kgdb, kernel
address probing, and other facilities we can try to access arbitrary
crap.
So, make sure the address we miss on will translate to physical memory
that actually exists.
In order to make this work we have to embed the valid address bitmap
into the kernel image. And in order to make that less expensive we
make an adjustment, in that the max physical memory address is
decreased to "1 << 41", even on the chips that support a 42-bit
physical address space. We can do this because bit 41 indicates
"I/O space" and thus covers non-memory ranges.
The result of this is that:
1) kpte_linear_bitmap shrinks from 2K to 1K in size
2) we need 64K more for the valid address bitmap
We can't let the valid address bitmap be dynamically allocated
once we start using it to validate TLB misses, otherwise we have
crazy issues to deal with wrt. recursive TLB misses and such.
If we're in a TLB miss it could be the deepest trap level that's legal
inside of the cpu. So if we TLB miss referencing the bitmap, the cpu
will be out of trap levels and enter RED state.
To guard against out-of-range accesses to the bitmap, we have to check
to make sure no bits in the physical address above bit 40 are set. We
could export and use last_valid_pfn for this check, but that's just an
unnecessary extra memory reference.
On the plus side of all this, since we load all of these translations
into the special 4MB mapping TSB, and we check the TSB first for TLB
misses, there should be absolutely no real cost for these new checks
in the TLB miss path.
Reported-by: heyongli@gmail.com
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-08-26 06:47:46 +07:00
|
|
|
static void __init setup_valid_addr_bitmap_from_pavail(unsigned long *bitmap)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
read_obp_memory("available", &pavail_rescan[0], &pavail_rescan_ents);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
for (i = 0; i < pavail_ents; i++) {
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long old_start, old_end;
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
old_start = pavail[i].phys_addr;
|
2008-04-23 19:40:25 +07:00
|
|
|
old_end = old_start + pavail[i].reg_size;
|
2005-04-17 05:20:36 +07:00
|
|
|
while (old_start < old_end) {
|
|
|
|
int n;
|
|
|
|
|
2006-06-22 14:01:56 +07:00
|
|
|
for (n = 0; n < pavail_rescan_ents; n++) {
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long new_start, new_end;
|
|
|
|
|
2005-09-30 07:58:26 +07:00
|
|
|
new_start = pavail_rescan[n].phys_addr;
|
|
|
|
new_end = new_start +
|
|
|
|
pavail_rescan[n].reg_size;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (new_start <= old_start &&
|
|
|
|
new_end >= (old_start + PAGE_SIZE)) {
|
sparc64: Validate linear D-TLB misses.
When page alloc debugging is not enabled, we essentially accept any
virtual address for linear kernel TLB misses. But with kgdb, kernel
address probing, and other facilities we can try to access arbitrary
crap.
So, make sure the address we miss on will translate to physical memory
that actually exists.
In order to make this work we have to embed the valid address bitmap
into the kernel image. And in order to make that less expensive we
make an adjustment, in that the max physical memory address is
decreased to "1 << 41", even on the chips that support a 42-bit
physical address space. We can do this because bit 41 indicates
"I/O space" and thus covers non-memory ranges.
The result of this is that:
1) kpte_linear_bitmap shrinks from 2K to 1K in size
2) we need 64K more for the valid address bitmap
We can't let the valid address bitmap be dynamically allocated
once we start using it to validate TLB misses, otherwise we have
crazy issues to deal with wrt. recursive TLB misses and such.
If we're in a TLB miss it could be the deepest trap level that's legal
inside of the cpu. So if we TLB miss referencing the bitmap, the cpu
will be out of trap levels and enter RED state.
To guard against out-of-range accesses to the bitmap, we have to check
to make sure no bits in the physical address above bit 40 are set. We
could export and use last_valid_pfn for this check, but that's just an
unnecessary extra memory reference.
On the plus side of all this, since we load all of these translations
into the special 4MB mapping TSB, and we check the TSB first for TLB
misses, there should be absolutely no real cost for these new checks
in the TLB miss path.
Reported-by: heyongli@gmail.com
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-08-26 06:47:46 +07:00
|
|
|
set_bit(old_start >> 22, bitmap);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto do_next_page;
|
|
|
|
}
|
|
|
|
}
|
2008-04-23 19:40:25 +07:00
|
|
|
|
|
|
|
prom_printf("mem_init: Lost memory in pavail\n");
|
|
|
|
prom_printf("mem_init: OLD start[%lx] size[%lx]\n",
|
|
|
|
pavail[i].phys_addr,
|
|
|
|
pavail[i].reg_size);
|
|
|
|
prom_printf("mem_init: NEW start[%lx] size[%lx]\n",
|
|
|
|
pavail_rescan[i].phys_addr,
|
|
|
|
pavail_rescan[i].reg_size);
|
|
|
|
prom_printf("mem_init: Cannot continue, aborting.\n");
|
|
|
|
prom_halt();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
do_next_page:
|
|
|
|
old_start += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
sparc64: Validate linear D-TLB misses.
When page alloc debugging is not enabled, we essentially accept any
virtual address for linear kernel TLB misses. But with kgdb, kernel
address probing, and other facilities we can try to access arbitrary
crap.
So, make sure the address we miss on will translate to physical memory
that actually exists.
In order to make this work we have to embed the valid address bitmap
into the kernel image. And in order to make that less expensive we
make an adjustment, in that the max physical memory address is
decreased to "1 << 41", even on the chips that support a 42-bit
physical address space. We can do this because bit 41 indicates
"I/O space" and thus covers non-memory ranges.
The result of this is that:
1) kpte_linear_bitmap shrinks from 2K to 1K in size
2) we need 64K more for the valid address bitmap
We can't let the valid address bitmap be dynamically allocated
once we start using it to validate TLB misses, otherwise we have
crazy issues to deal with wrt. recursive TLB misses and such.
If we're in a TLB miss it could be the deepest trap level that's legal
inside of the cpu. So if we TLB miss referencing the bitmap, the cpu
will be out of trap levels and enter RED state.
To guard against out-of-range accesses to the bitmap, we have to check
to make sure no bits in the physical address above bit 40 are set. We
could export and use last_valid_pfn for this check, but that's just an
unnecessary extra memory reference.
On the plus side of all this, since we load all of these translations
into the special 4MB mapping TSB, and we check the TSB first for TLB
misses, there should be absolutely no real cost for these new checks
in the TLB miss path.
Reported-by: heyongli@gmail.com
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-08-26 06:47:46 +07:00
|
|
|
static void __init patch_tlb_miss_handler_bitmap(void)
|
|
|
|
{
|
|
|
|
extern unsigned int valid_addr_bitmap_insn[];
|
|
|
|
extern unsigned int valid_addr_bitmap_patch[];
|
|
|
|
|
|
|
|
valid_addr_bitmap_insn[1] = valid_addr_bitmap_patch[1];
|
|
|
|
mb();
|
|
|
|
valid_addr_bitmap_insn[0] = valid_addr_bitmap_patch[0];
|
|
|
|
flushi(&valid_addr_bitmap_insn[0]);
|
|
|
|
}
|
|
|
|
|
2012-11-17 10:39:21 +07:00
|
|
|
static void __init register_page_bootmem_info(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NEED_MULTIPLE_NODES
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_online_node(i)
|
|
|
|
if (NODE_DATA(i)->node_spanned_pages)
|
|
|
|
register_page_bootmem_info_node(NODE_DATA(i));
|
|
|
|
#endif
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
void __init mem_init(void)
|
|
|
|
{
|
|
|
|
unsigned long codepages, datapages, initpages;
|
|
|
|
unsigned long addr, last;
|
|
|
|
|
|
|
|
addr = PAGE_OFFSET + kern_base;
|
|
|
|
last = PAGE_ALIGN(kern_size) + addr;
|
|
|
|
while (addr < last) {
|
|
|
|
set_bit(__pa(addr) >> 22, sparc64_valid_addr_bitmap);
|
|
|
|
addr += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
sparc64: Validate linear D-TLB misses.
When page alloc debugging is not enabled, we essentially accept any
virtual address for linear kernel TLB misses. But with kgdb, kernel
address probing, and other facilities we can try to access arbitrary
crap.
So, make sure the address we miss on will translate to physical memory
that actually exists.
In order to make this work we have to embed the valid address bitmap
into the kernel image. And in order to make that less expensive we
make an adjustment, in that the max physical memory address is
decreased to "1 << 41", even on the chips that support a 42-bit
physical address space. We can do this because bit 41 indicates
"I/O space" and thus covers non-memory ranges.
The result of this is that:
1) kpte_linear_bitmap shrinks from 2K to 1K in size
2) we need 64K more for the valid address bitmap
We can't let the valid address bitmap be dynamically allocated
once we start using it to validate TLB misses, otherwise we have
crazy issues to deal with wrt. recursive TLB misses and such.
If we're in a TLB miss it could be the deepest trap level that's legal
inside of the cpu. So if we TLB miss referencing the bitmap, the cpu
will be out of trap levels and enter RED state.
To guard against out-of-range accesses to the bitmap, we have to check
to make sure no bits in the physical address above bit 40 are set. We
could export and use last_valid_pfn for this check, but that's just an
unnecessary extra memory reference.
On the plus side of all this, since we load all of these translations
into the special 4MB mapping TSB, and we check the TSB first for TLB
misses, there should be absolutely no real cost for these new checks
in the TLB miss path.
Reported-by: heyongli@gmail.com
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-08-26 06:47:46 +07:00
|
|
|
setup_valid_addr_bitmap_from_pavail(sparc64_valid_addr_bitmap);
|
|
|
|
patch_tlb_miss_handler_bitmap();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
high_memory = __va(last_valid_pfn << PAGE_SHIFT);
|
|
|
|
|
2012-11-17 10:39:21 +07:00
|
|
|
register_page_bootmem_info();
|
2013-07-04 05:03:24 +07:00
|
|
|
free_all_bootmem();
|
2008-04-23 19:40:25 +07:00
|
|
|
|
2007-03-16 12:52:18 +07:00
|
|
|
/* We subtract one to account for the mem_map_zero page
|
|
|
|
* allocated below.
|
|
|
|
*/
|
2013-05-08 06:18:08 +07:00
|
|
|
num_physpages = totalram_pages - 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the zero page, mark it reserved, so that page count
|
|
|
|
* is not manipulated when freeing the page from user ptes.
|
|
|
|
*/
|
|
|
|
mem_map_zero = alloc_pages(GFP_KERNEL|__GFP_ZERO, 0);
|
|
|
|
if (mem_map_zero == NULL) {
|
|
|
|
prom_printf("paging_init: Cannot alloc zero page.\n");
|
|
|
|
prom_halt();
|
|
|
|
}
|
2013-05-08 06:18:08 +07:00
|
|
|
mark_page_reserved(mem_map_zero);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
codepages = (((unsigned long) _etext) - ((unsigned long) _start));
|
|
|
|
codepages = PAGE_ALIGN(codepages) >> PAGE_SHIFT;
|
|
|
|
datapages = (((unsigned long) _edata) - ((unsigned long) _etext));
|
|
|
|
datapages = PAGE_ALIGN(datapages) >> PAGE_SHIFT;
|
|
|
|
initpages = (((unsigned long) __init_end) - ((unsigned long) __init_begin));
|
|
|
|
initpages = PAGE_ALIGN(initpages) >> PAGE_SHIFT;
|
|
|
|
|
2007-02-10 16:43:03 +07:00
|
|
|
printk("Memory: %luk available (%ldk kernel code, %ldk data, %ldk init) [%016lx,%016lx]\n",
|
2005-04-17 05:20:36 +07:00
|
|
|
nr_free_pages() << (PAGE_SHIFT-10),
|
|
|
|
codepages << (PAGE_SHIFT-10),
|
|
|
|
datapages << (PAGE_SHIFT-10),
|
|
|
|
initpages << (PAGE_SHIFT-10),
|
|
|
|
PAGE_OFFSET, (last_valid_pfn << PAGE_SHIFT));
|
|
|
|
|
|
|
|
if (tlb_type == cheetah || tlb_type == cheetah_plus)
|
|
|
|
cheetah_ecache_flush_init();
|
|
|
|
}
|
|
|
|
|
2005-09-24 01:59:44 +07:00
|
|
|
void free_initmem(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long addr, initend;
|
2008-08-14 15:45:41 +07:00
|
|
|
int do_free = 1;
|
|
|
|
|
|
|
|
/* If the physical memory maps were trimmed by kernel command
|
|
|
|
* line options, don't even try freeing this initmem stuff up.
|
|
|
|
* The kernel image could have been in the trimmed out region
|
|
|
|
* and if so the freeing below will free invalid page structs.
|
|
|
|
*/
|
|
|
|
if (cmdline_memory_size)
|
|
|
|
do_free = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The init section is aligned to 8k in vmlinux.lds. Page align for >8k pagesizes.
|
|
|
|
*/
|
|
|
|
addr = PAGE_ALIGN((unsigned long)(__init_begin));
|
|
|
|
initend = (unsigned long)(__init_end) & PAGE_MASK;
|
|
|
|
for (; addr < initend; addr += PAGE_SIZE) {
|
|
|
|
unsigned long page;
|
|
|
|
|
|
|
|
page = (addr +
|
|
|
|
((unsigned long) __va(kern_base)) -
|
|
|
|
((unsigned long) KERNBASE));
|
2006-06-27 16:53:52 +07:00
|
|
|
memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-05-08 06:18:08 +07:00
|
|
|
if (do_free)
|
|
|
|
free_reserved_page(virt_to_page(page));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
void free_initrd_mem(unsigned long start, unsigned long end)
|
|
|
|
{
|
mm: change signature of free_reserved_area() to fix building warnings
Change signature of free_reserved_area() according to Russell King's
suggestion to fix following build warnings:
arch/arm/mm/init.c: In function 'mem_init':
arch/arm/mm/init.c:603:2: warning: passing argument 1 of 'free_reserved_area' makes integer from pointer without a cast [enabled by default]
free_reserved_area(__va(PHYS_PFN_OFFSET), swapper_pg_dir, 0, NULL);
^
In file included from include/linux/mman.h:4:0,
from arch/arm/mm/init.c:15:
include/linux/mm.h:1301:22: note: expected 'long unsigned int' but argument is of type 'void *'
extern unsigned long free_reserved_area(unsigned long start, unsigned long end,
mm/page_alloc.c: In function 'free_reserved_area':
>> mm/page_alloc.c:5134:3: warning: passing argument 1 of 'virt_to_phys' makes pointer from integer without a cast [enabled by default]
In file included from arch/mips/include/asm/page.h:49:0,
from include/linux/mmzone.h:20,
from include/linux/gfp.h:4,
from include/linux/mm.h:8,
from mm/page_alloc.c:18:
arch/mips/include/asm/io.h:119:29: note: expected 'const volatile void *' but argument is of type 'long unsigned int'
mm/page_alloc.c: In function 'free_area_init_nodes':
mm/page_alloc.c:5030:34: warning: array subscript is below array bounds [-Warray-bounds]
Also address some minor code review comments.
Signed-off-by: Jiang Liu <jiang.liu@huawei.com>
Reported-by: Arnd Bergmann <arnd@arndb.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: <sworddragon2@aol.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Chris Metcalf <cmetcalf@tilera.com>
Cc: David Howells <dhowells@redhat.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jeremy Fitzhardinge <jeremy@goop.org>
Cc: Jianguo Wu <wujianguo@huawei.com>
Cc: Joonsoo Kim <js1304@gmail.com>
Cc: Kamezawa Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Cc: Marek Szyprowski <m.szyprowski@samsung.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: Michel Lespinasse <walken@google.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Tang Chen <tangchen@cn.fujitsu.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Wen Congyang <wency@cn.fujitsu.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Cc: Yinghai Lu <yinghai@kernel.org>
Cc: Russell King <rmk@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-04 05:02:48 +07:00
|
|
|
num_physpages += free_reserved_area((void *)start, (void *)end,
|
|
|
|
POISON_FREE_INITMEM, "initrd");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
#endif
|
2006-02-12 12:57:54 +07:00
|
|
|
|
|
|
|
#define _PAGE_CACHE_4U (_PAGE_CP_4U | _PAGE_CV_4U)
|
|
|
|
#define _PAGE_CACHE_4V (_PAGE_CP_4V | _PAGE_CV_4V)
|
|
|
|
#define __DIRTY_BITS_4U (_PAGE_MODIFIED_4U | _PAGE_WRITE_4U | _PAGE_W_4U)
|
|
|
|
#define __DIRTY_BITS_4V (_PAGE_MODIFIED_4V | _PAGE_WRITE_4V | _PAGE_W_4V)
|
|
|
|
#define __ACCESS_BITS_4U (_PAGE_ACCESSED_4U | _PAGE_READ_4U | _PAGE_R)
|
|
|
|
#define __ACCESS_BITS_4V (_PAGE_ACCESSED_4V | _PAGE_READ_4V | _PAGE_R)
|
|
|
|
|
|
|
|
pgprot_t PAGE_KERNEL __read_mostly;
|
|
|
|
EXPORT_SYMBOL(PAGE_KERNEL);
|
|
|
|
|
|
|
|
pgprot_t PAGE_KERNEL_LOCKED __read_mostly;
|
|
|
|
pgprot_t PAGE_COPY __read_mostly;
|
2006-02-19 03:43:16 +07:00
|
|
|
|
|
|
|
pgprot_t PAGE_SHARED __read_mostly;
|
|
|
|
EXPORT_SYMBOL(PAGE_SHARED);
|
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
unsigned long pg_iobits __read_mostly;
|
|
|
|
|
|
|
|
unsigned long _PAGE_IE __read_mostly;
|
2006-06-25 15:34:43 +07:00
|
|
|
EXPORT_SYMBOL(_PAGE_IE);
|
2006-02-23 16:55:55 +07:00
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
unsigned long _PAGE_E __read_mostly;
|
2006-02-23 16:55:55 +07:00
|
|
|
EXPORT_SYMBOL(_PAGE_E);
|
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
unsigned long _PAGE_CACHE __read_mostly;
|
2006-02-23 16:55:55 +07:00
|
|
|
EXPORT_SYMBOL(_PAGE_CACHE);
|
2006-02-12 12:57:54 +07:00
|
|
|
|
2007-10-16 15:24:16 +07:00
|
|
|
#ifdef CONFIG_SPARSEMEM_VMEMMAP
|
|
|
|
unsigned long vmemmap_table[VMEMMAP_SIZE];
|
|
|
|
|
2012-08-15 14:37:29 +07:00
|
|
|
static long __meminitdata addr_start, addr_end;
|
|
|
|
static int __meminitdata node_start;
|
|
|
|
|
2013-04-30 05:07:50 +07:00
|
|
|
int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
|
|
|
|
int node)
|
2007-10-16 15:24:16 +07:00
|
|
|
{
|
|
|
|
unsigned long phys_start = (vstart - VMEMMAP_BASE);
|
|
|
|
unsigned long phys_end = (vend - VMEMMAP_BASE);
|
|
|
|
unsigned long addr = phys_start & VMEMMAP_CHUNK_MASK;
|
|
|
|
unsigned long end = VMEMMAP_ALIGN(phys_end);
|
|
|
|
unsigned long pte_base;
|
|
|
|
|
|
|
|
pte_base = (_PAGE_VALID | _PAGE_SZ4MB_4U |
|
|
|
|
_PAGE_CP_4U | _PAGE_CV_4U |
|
|
|
|
_PAGE_P_4U | _PAGE_W_4U);
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
pte_base = (_PAGE_VALID | _PAGE_SZ4MB_4V |
|
|
|
|
_PAGE_CP_4V | _PAGE_CV_4V |
|
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
|
|
|
|
for (; addr < end; addr += VMEMMAP_CHUNK) {
|
|
|
|
unsigned long *vmem_pp =
|
|
|
|
vmemmap_table + (addr >> VMEMMAP_CHUNK_SHIFT);
|
|
|
|
void *block;
|
|
|
|
|
|
|
|
if (!(*vmem_pp & _PAGE_VALID)) {
|
|
|
|
block = vmemmap_alloc_block(1UL << 22, node);
|
|
|
|
if (!block)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*vmem_pp = pte_base | __pa(block);
|
|
|
|
|
2012-08-15 14:37:29 +07:00
|
|
|
/* check to see if we have contiguous blocks */
|
|
|
|
if (addr_end != addr || node_start != node) {
|
|
|
|
if (addr_start)
|
|
|
|
printk(KERN_DEBUG " [%lx-%lx] on node %d\n",
|
|
|
|
addr_start, addr_end-1, node_start);
|
|
|
|
addr_start = addr;
|
|
|
|
node_start = node;
|
|
|
|
}
|
|
|
|
addr_end = addr + VMEMMAP_CHUNK;
|
2007-10-16 15:24:16 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-08-15 14:37:29 +07:00
|
|
|
|
|
|
|
void __meminit vmemmap_populate_print_last(void)
|
|
|
|
{
|
|
|
|
if (addr_start) {
|
|
|
|
printk(KERN_DEBUG " [%lx-%lx] on node %d\n",
|
|
|
|
addr_start, addr_end-1, node_start);
|
|
|
|
addr_start = 0;
|
|
|
|
addr_end = 0;
|
|
|
|
node_start = 0;
|
|
|
|
}
|
|
|
|
}
|
2013-02-23 07:33:00 +07:00
|
|
|
|
2013-04-30 05:07:50 +07:00
|
|
|
void vmemmap_free(unsigned long start, unsigned long end)
|
2013-02-23 07:33:08 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-10-16 15:24:16 +07:00
|
|
|
#endif /* CONFIG_SPARSEMEM_VMEMMAP */
|
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
static void prot_init_common(unsigned long page_none,
|
|
|
|
unsigned long page_shared,
|
|
|
|
unsigned long page_copy,
|
|
|
|
unsigned long page_readonly,
|
|
|
|
unsigned long page_exec_bit)
|
|
|
|
{
|
|
|
|
PAGE_COPY = __pgprot(page_copy);
|
2006-02-19 03:43:16 +07:00
|
|
|
PAGE_SHARED = __pgprot(page_shared);
|
2006-02-12 12:57:54 +07:00
|
|
|
|
|
|
|
protection_map[0x0] = __pgprot(page_none);
|
|
|
|
protection_map[0x1] = __pgprot(page_readonly & ~page_exec_bit);
|
|
|
|
protection_map[0x2] = __pgprot(page_copy & ~page_exec_bit);
|
|
|
|
protection_map[0x3] = __pgprot(page_copy & ~page_exec_bit);
|
|
|
|
protection_map[0x4] = __pgprot(page_readonly);
|
|
|
|
protection_map[0x5] = __pgprot(page_readonly);
|
|
|
|
protection_map[0x6] = __pgprot(page_copy);
|
|
|
|
protection_map[0x7] = __pgprot(page_copy);
|
|
|
|
protection_map[0x8] = __pgprot(page_none);
|
|
|
|
protection_map[0x9] = __pgprot(page_readonly & ~page_exec_bit);
|
|
|
|
protection_map[0xa] = __pgprot(page_shared & ~page_exec_bit);
|
|
|
|
protection_map[0xb] = __pgprot(page_shared & ~page_exec_bit);
|
|
|
|
protection_map[0xc] = __pgprot(page_readonly);
|
|
|
|
protection_map[0xd] = __pgprot(page_readonly);
|
|
|
|
protection_map[0xe] = __pgprot(page_shared);
|
|
|
|
protection_map[0xf] = __pgprot(page_shared);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init sun4u_pgprot_init(void)
|
|
|
|
{
|
|
|
|
unsigned long page_none, page_shared, page_copy, page_readonly;
|
|
|
|
unsigned long page_exec_bit;
|
2012-09-07 08:13:58 +07:00
|
|
|
int i;
|
2006-02-12 12:57:54 +07:00
|
|
|
|
|
|
|
PAGE_KERNEL = __pgprot (_PAGE_PRESENT_4U | _PAGE_VALID |
|
|
|
|
_PAGE_CACHE_4U | _PAGE_P_4U |
|
|
|
|
__ACCESS_BITS_4U | __DIRTY_BITS_4U |
|
|
|
|
_PAGE_EXEC_4U);
|
|
|
|
PAGE_KERNEL_LOCKED = __pgprot (_PAGE_PRESENT_4U | _PAGE_VALID |
|
|
|
|
_PAGE_CACHE_4U | _PAGE_P_4U |
|
|
|
|
__ACCESS_BITS_4U | __DIRTY_BITS_4U |
|
|
|
|
_PAGE_EXEC_4U | _PAGE_L_4U);
|
|
|
|
|
|
|
|
_PAGE_IE = _PAGE_IE_4U;
|
|
|
|
_PAGE_E = _PAGE_E_4U;
|
|
|
|
_PAGE_CACHE = _PAGE_CACHE_4U;
|
|
|
|
|
|
|
|
pg_iobits = (_PAGE_VALID | _PAGE_PRESENT_4U | __DIRTY_BITS_4U |
|
|
|
|
__ACCESS_BITS_4U | _PAGE_E_4U);
|
|
|
|
|
2007-03-17 07:20:28 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2012-10-09 06:34:19 +07:00
|
|
|
kern_linear_pte_xor[0] = _PAGE_VALID ^ 0xfffff80000000000UL;
|
2007-03-17 07:20:28 +07:00
|
|
|
#else
|
2006-02-22 11:51:13 +07:00
|
|
|
kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZ4MB_4U) ^
|
2008-09-12 14:19:21 +07:00
|
|
|
0xfffff80000000000UL;
|
2007-03-17 07:20:28 +07:00
|
|
|
#endif
|
2006-02-22 11:51:13 +07:00
|
|
|
kern_linear_pte_xor[0] |= (_PAGE_CP_4U | _PAGE_CV_4U |
|
|
|
|
_PAGE_P_4U | _PAGE_W_4U);
|
|
|
|
|
2012-09-07 08:13:58 +07:00
|
|
|
for (i = 1; i < 4; i++)
|
|
|
|
kern_linear_pte_xor[i] = kern_linear_pte_xor[0];
|
2006-02-12 12:57:54 +07:00
|
|
|
|
|
|
|
_PAGE_ALL_SZ_BITS = (_PAGE_SZ4MB_4U | _PAGE_SZ512K_4U |
|
|
|
|
_PAGE_SZ64K_4U | _PAGE_SZ8K_4U |
|
|
|
|
_PAGE_SZ32MB_4U | _PAGE_SZ256MB_4U);
|
|
|
|
|
|
|
|
|
|
|
|
page_none = _PAGE_PRESENT_4U | _PAGE_ACCESSED_4U | _PAGE_CACHE_4U;
|
|
|
|
page_shared = (_PAGE_VALID | _PAGE_PRESENT_4U | _PAGE_CACHE_4U |
|
|
|
|
__ACCESS_BITS_4U | _PAGE_WRITE_4U | _PAGE_EXEC_4U);
|
|
|
|
page_copy = (_PAGE_VALID | _PAGE_PRESENT_4U | _PAGE_CACHE_4U |
|
|
|
|
__ACCESS_BITS_4U | _PAGE_EXEC_4U);
|
|
|
|
page_readonly = (_PAGE_VALID | _PAGE_PRESENT_4U | _PAGE_CACHE_4U |
|
|
|
|
__ACCESS_BITS_4U | _PAGE_EXEC_4U);
|
|
|
|
|
|
|
|
page_exec_bit = _PAGE_EXEC_4U;
|
|
|
|
|
|
|
|
prot_init_common(page_none, page_shared, page_copy, page_readonly,
|
|
|
|
page_exec_bit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init sun4v_pgprot_init(void)
|
|
|
|
{
|
|
|
|
unsigned long page_none, page_shared, page_copy, page_readonly;
|
|
|
|
unsigned long page_exec_bit;
|
2012-09-07 08:13:58 +07:00
|
|
|
int i;
|
2006-02-12 12:57:54 +07:00
|
|
|
|
|
|
|
PAGE_KERNEL = __pgprot (_PAGE_PRESENT_4V | _PAGE_VALID |
|
|
|
|
_PAGE_CACHE_4V | _PAGE_P_4V |
|
|
|
|
__ACCESS_BITS_4V | __DIRTY_BITS_4V |
|
|
|
|
_PAGE_EXEC_4V);
|
|
|
|
PAGE_KERNEL_LOCKED = PAGE_KERNEL;
|
|
|
|
|
|
|
|
_PAGE_IE = _PAGE_IE_4V;
|
|
|
|
_PAGE_E = _PAGE_E_4V;
|
|
|
|
_PAGE_CACHE = _PAGE_CACHE_4V;
|
|
|
|
|
2007-03-17 07:20:28 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
2012-10-09 06:34:19 +07:00
|
|
|
kern_linear_pte_xor[0] = _PAGE_VALID ^ 0xfffff80000000000UL;
|
2007-03-17 07:20:28 +07:00
|
|
|
#else
|
2006-02-22 11:51:13 +07:00
|
|
|
kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZ4MB_4V) ^
|
2008-09-12 14:19:21 +07:00
|
|
|
0xfffff80000000000UL;
|
2007-03-17 07:20:28 +07:00
|
|
|
#endif
|
2006-02-22 11:51:13 +07:00
|
|
|
kern_linear_pte_xor[0] |= (_PAGE_CP_4V | _PAGE_CV_4V |
|
|
|
|
_PAGE_P_4V | _PAGE_W_4V);
|
|
|
|
|
2012-09-07 10:35:36 +07:00
|
|
|
for (i = 1; i < 4; i++)
|
|
|
|
kern_linear_pte_xor[i] = kern_linear_pte_xor[0];
|
2012-09-07 08:13:58 +07:00
|
|
|
|
2006-02-12 12:57:54 +07:00
|
|
|
pg_iobits = (_PAGE_VALID | _PAGE_PRESENT_4V | __DIRTY_BITS_4V |
|
|
|
|
__ACCESS_BITS_4V | _PAGE_E_4V);
|
|
|
|
|
|
|
|
_PAGE_ALL_SZ_BITS = (_PAGE_SZ16GB_4V | _PAGE_SZ2GB_4V |
|
|
|
|
_PAGE_SZ256MB_4V | _PAGE_SZ32MB_4V |
|
|
|
|
_PAGE_SZ4MB_4V | _PAGE_SZ512K_4V |
|
|
|
|
_PAGE_SZ64K_4V | _PAGE_SZ8K_4V);
|
|
|
|
|
|
|
|
page_none = _PAGE_PRESENT_4V | _PAGE_ACCESSED_4V | _PAGE_CACHE_4V;
|
|
|
|
page_shared = (_PAGE_VALID | _PAGE_PRESENT_4V | _PAGE_CACHE_4V |
|
|
|
|
__ACCESS_BITS_4V | _PAGE_WRITE_4V | _PAGE_EXEC_4V);
|
|
|
|
page_copy = (_PAGE_VALID | _PAGE_PRESENT_4V | _PAGE_CACHE_4V |
|
|
|
|
__ACCESS_BITS_4V | _PAGE_EXEC_4V);
|
|
|
|
page_readonly = (_PAGE_VALID | _PAGE_PRESENT_4V | _PAGE_CACHE_4V |
|
|
|
|
__ACCESS_BITS_4V | _PAGE_EXEC_4V);
|
|
|
|
|
|
|
|
page_exec_bit = _PAGE_EXEC_4V;
|
|
|
|
|
|
|
|
prot_init_common(page_none, page_shared, page_copy, page_readonly,
|
|
|
|
page_exec_bit);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long pte_sz_bits(unsigned long sz)
|
|
|
|
{
|
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
switch (sz) {
|
|
|
|
case 8 * 1024:
|
|
|
|
default:
|
|
|
|
return _PAGE_SZ8K_4V;
|
|
|
|
case 64 * 1024:
|
|
|
|
return _PAGE_SZ64K_4V;
|
|
|
|
case 512 * 1024:
|
|
|
|
return _PAGE_SZ512K_4V;
|
|
|
|
case 4 * 1024 * 1024:
|
|
|
|
return _PAGE_SZ4MB_4V;
|
2011-06-03 21:45:23 +07:00
|
|
|
}
|
2006-02-12 12:57:54 +07:00
|
|
|
} else {
|
|
|
|
switch (sz) {
|
|
|
|
case 8 * 1024:
|
|
|
|
default:
|
|
|
|
return _PAGE_SZ8K_4U;
|
|
|
|
case 64 * 1024:
|
|
|
|
return _PAGE_SZ64K_4U;
|
|
|
|
case 512 * 1024:
|
|
|
|
return _PAGE_SZ512K_4U;
|
|
|
|
case 4 * 1024 * 1024:
|
|
|
|
return _PAGE_SZ4MB_4U;
|
2011-06-03 21:45:23 +07:00
|
|
|
}
|
2006-02-12 12:57:54 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pte_t mk_pte_io(unsigned long page, pgprot_t prot, int space, unsigned long page_size)
|
|
|
|
{
|
|
|
|
pte_t pte;
|
2006-02-13 12:10:07 +07:00
|
|
|
|
|
|
|
pte_val(pte) = page | pgprot_val(pgprot_noncached(prot));
|
2006-02-12 12:57:54 +07:00
|
|
|
pte_val(pte) |= (((unsigned long)space) << 32);
|
|
|
|
pte_val(pte) |= pte_sz_bits(page_size);
|
|
|
|
|
2006-02-13 12:10:07 +07:00
|
|
|
return pte;
|
2006-02-12 12:57:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long kern_large_tte(unsigned long paddr)
|
|
|
|
{
|
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
val = (_PAGE_VALID | _PAGE_SZ4MB_4U |
|
|
|
|
_PAGE_CP_4U | _PAGE_CV_4U | _PAGE_P_4U |
|
|
|
|
_PAGE_EXEC_4U | _PAGE_L_4U | _PAGE_W_4U);
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
val = (_PAGE_VALID | _PAGE_SZ4MB_4V |
|
|
|
|
_PAGE_CP_4V | _PAGE_CV_4V | _PAGE_P_4V |
|
|
|
|
_PAGE_EXEC_4V | _PAGE_W_4V);
|
|
|
|
|
|
|
|
return val | paddr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If not locked, zap it. */
|
|
|
|
void __flush_tlb_all(void)
|
|
|
|
{
|
|
|
|
unsigned long pstate;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
__asm__ __volatile__("flushw\n\t"
|
|
|
|
"rdpr %%pstate, %0\n\t"
|
|
|
|
"wrpr %0, %1, %%pstate"
|
|
|
|
: "=r" (pstate)
|
|
|
|
: "i" (PSTATE_IE));
|
2007-12-13 21:13:38 +07:00
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
sun4v_mmu_demap_all();
|
|
|
|
} else if (tlb_type == spitfire) {
|
2006-02-12 12:57:54 +07:00
|
|
|
for (i = 0; i < 64; i++) {
|
|
|
|
/* Spitfire Errata #32 workaround */
|
|
|
|
/* NOTE: Always runs on spitfire, so no
|
|
|
|
* cheetah+ page size encodings.
|
|
|
|
*/
|
|
|
|
__asm__ __volatile__("stxa %0, [%1] %2\n\t"
|
|
|
|
"flush %%g6"
|
|
|
|
: /* No outputs */
|
|
|
|
: "r" (0),
|
|
|
|
"r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
|
|
|
|
|
|
|
|
if (!(spitfire_get_dtlb_data(i) & _PAGE_L_4U)) {
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
|
|
|
|
"membar #Sync"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
|
|
|
|
spitfire_put_dtlb_data(i, 0x0UL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Spitfire Errata #32 workaround */
|
|
|
|
/* NOTE: Always runs on spitfire, so no
|
|
|
|
* cheetah+ page size encodings.
|
|
|
|
*/
|
|
|
|
__asm__ __volatile__("stxa %0, [%1] %2\n\t"
|
|
|
|
"flush %%g6"
|
|
|
|
: /* No outputs */
|
|
|
|
: "r" (0),
|
|
|
|
"r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
|
|
|
|
|
|
|
|
if (!(spitfire_get_itlb_data(i) & _PAGE_L_4U)) {
|
|
|
|
__asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
|
|
|
|
"membar #Sync"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
|
|
|
|
spitfire_put_itlb_data(i, 0x0UL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
|
|
|
cheetah_flush_dtlb_all();
|
|
|
|
cheetah_flush_itlb_all();
|
|
|
|
}
|
|
|
|
__asm__ __volatile__("wrpr %0, 0, %%pstate"
|
|
|
|
: : "r" (pstate));
|
|
|
|
}
|
2012-10-09 06:34:22 +07:00
|
|
|
|
|
|
|
static pte_t *get_from_cache(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
pte_t *ret;
|
|
|
|
|
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
page = mm->context.pgtable_page;
|
|
|
|
ret = NULL;
|
|
|
|
if (page) {
|
|
|
|
void *p = page_address(page);
|
|
|
|
|
|
|
|
mm->context.pgtable_page = NULL;
|
|
|
|
|
|
|
|
ret = (pte_t *) (p + (PAGE_SIZE / 2));
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct page *__alloc_for_cache(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK |
|
|
|
|
__GFP_REPEAT | __GFP_ZERO);
|
|
|
|
|
|
|
|
if (page) {
|
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
if (!mm->context.pgtable_page) {
|
|
|
|
atomic_set(&page->_count, 2);
|
|
|
|
mm->context.pgtable_page = page;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
}
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
|
|
|
pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
pte_t *pte;
|
|
|
|
|
|
|
|
pte = get_from_cache(mm);
|
|
|
|
if (pte)
|
|
|
|
return pte;
|
|
|
|
|
|
|
|
page = __alloc_for_cache(mm);
|
|
|
|
if (page)
|
|
|
|
pte = (pte_t *) page_address(page);
|
|
|
|
|
|
|
|
return pte;
|
|
|
|
}
|
|
|
|
|
|
|
|
pgtable_t pte_alloc_one(struct mm_struct *mm,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
pte_t *pte;
|
|
|
|
|
|
|
|
pte = get_from_cache(mm);
|
|
|
|
if (pte)
|
|
|
|
return pte;
|
|
|
|
|
|
|
|
page = __alloc_for_cache(mm);
|
|
|
|
if (page) {
|
|
|
|
pgtable_page_ctor(page);
|
|
|
|
pte = (pte_t *) page_address(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
return pte;
|
|
|
|
}
|
|
|
|
|
|
|
|
void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
|
|
|
|
{
|
|
|
|
struct page *page = virt_to_page(pte);
|
|
|
|
if (put_page_testzero(page))
|
|
|
|
free_hot_cold_page(page, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __pte_free(pgtable_t pte)
|
|
|
|
{
|
|
|
|
struct page *page = virt_to_page(pte);
|
|
|
|
if (put_page_testzero(page)) {
|
|
|
|
pgtable_page_dtor(page);
|
|
|
|
free_hot_cold_page(page, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void pte_free(struct mm_struct *mm, pgtable_t pte)
|
|
|
|
{
|
|
|
|
__pte_free(pte);
|
|
|
|
}
|
|
|
|
|
|
|
|
void pgtable_free(void *table, bool is_page)
|
|
|
|
{
|
|
|
|
if (is_page)
|
|
|
|
__pte_free(table);
|
|
|
|
else
|
|
|
|
kmem_cache_free(pgtable_cache, table);
|
|
|
|
}
|
2012-10-09 06:34:29 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
|
|
static pmd_t pmd_set_protbits(pmd_t pmd, pgprot_t pgprot, bool for_modify)
|
|
|
|
{
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_VALID)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_PRESENT;
|
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_WRITE_4V)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_WRITE;
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_EXEC_4V)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_EXEC;
|
|
|
|
|
|
|
|
if (!for_modify) {
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_ACCESSED_4V)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_ACCESSED;
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_MODIFIED_4V)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_DIRTY;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_WRITE_4U)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_WRITE;
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_EXEC_4U)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_EXEC;
|
|
|
|
|
|
|
|
if (!for_modify) {
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_ACCESSED_4U)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_ACCESSED;
|
|
|
|
if (pgprot_val(pgprot) & _PAGE_MODIFIED_4U)
|
|
|
|
pmd_val(pmd) |= PMD_HUGE_DIRTY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return pmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
|
|
|
|
{
|
|
|
|
pmd_t pmd;
|
|
|
|
|
|
|
|
pmd_val(pmd) = (page_nr << ((PAGE_SHIFT - PMD_PADDR_SHIFT)));
|
|
|
|
pmd_val(pmd) |= PMD_ISHUGE;
|
|
|
|
pmd = pmd_set_protbits(pmd, pgprot, false);
|
|
|
|
return pmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
|
|
|
|
{
|
|
|
|
pmd_val(pmd) &= ~(PMD_HUGE_PRESENT |
|
|
|
|
PMD_HUGE_WRITE |
|
|
|
|
PMD_HUGE_EXEC);
|
|
|
|
pmd = pmd_set_protbits(pmd, newprot, true);
|
|
|
|
return pmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
pgprot_t pmd_pgprot(pmd_t entry)
|
|
|
|
{
|
|
|
|
unsigned long pte = 0;
|
|
|
|
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_PRESENT)
|
|
|
|
pte |= _PAGE_VALID;
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor) {
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_PRESENT)
|
|
|
|
pte |= _PAGE_PRESENT_4V;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_EXEC)
|
|
|
|
pte |= _PAGE_EXEC_4V;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_WRITE)
|
|
|
|
pte |= _PAGE_W_4V;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_ACCESSED)
|
|
|
|
pte |= _PAGE_ACCESSED_4V;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_DIRTY)
|
|
|
|
pte |= _PAGE_MODIFIED_4V;
|
|
|
|
pte |= _PAGE_CP_4V|_PAGE_CV_4V;
|
|
|
|
} else {
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_PRESENT)
|
|
|
|
pte |= _PAGE_PRESENT_4U;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_EXEC)
|
|
|
|
pte |= _PAGE_EXEC_4U;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_WRITE)
|
|
|
|
pte |= _PAGE_W_4U;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_ACCESSED)
|
|
|
|
pte |= _PAGE_ACCESSED_4U;
|
|
|
|
if (pmd_val(entry) & PMD_HUGE_DIRTY)
|
|
|
|
pte |= _PAGE_MODIFIED_4U;
|
|
|
|
pte |= _PAGE_CP_4U|_PAGE_CV_4U;
|
|
|
|
}
|
|
|
|
|
|
|
|
return __pgprot(pte);
|
|
|
|
}
|
|
|
|
|
|
|
|
void update_mmu_cache_pmd(struct vm_area_struct *vma, unsigned long addr,
|
|
|
|
pmd_t *pmd)
|
|
|
|
{
|
|
|
|
unsigned long pte, flags;
|
|
|
|
struct mm_struct *mm;
|
|
|
|
pmd_t entry = *pmd;
|
|
|
|
pgprot_t prot;
|
|
|
|
|
|
|
|
if (!pmd_large(entry) || !pmd_young(entry))
|
|
|
|
return;
|
|
|
|
|
|
|
|
pte = (pmd_val(entry) & ~PMD_HUGE_PROTBITS);
|
|
|
|
pte <<= PMD_PADDR_SHIFT;
|
|
|
|
pte |= _PAGE_VALID;
|
|
|
|
|
|
|
|
prot = pmd_pgprot(entry);
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
pgprot_val(prot) |= _PAGE_SZHUGE_4V;
|
|
|
|
else
|
|
|
|
pgprot_val(prot) |= _PAGE_SZHUGE_4U;
|
|
|
|
|
|
|
|
pte |= pgprot_val(prot);
|
|
|
|
|
|
|
|
mm = vma->vm_mm;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mm->context.lock, flags);
|
|
|
|
|
|
|
|
if (mm->context.tsb_block[MM_TSB_HUGE].tsb != NULL)
|
|
|
|
__update_mmu_tsb_insert(mm, MM_TSB_HUGE, HPAGE_SHIFT,
|
|
|
|
addr, pte);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mm->context.lock, flags);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|
|
|
|
|
|
|
|
#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
|
|
|
|
static void context_reload(void *__data)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = __data;
|
|
|
|
|
|
|
|
if (mm == current->mm)
|
|
|
|
load_secondary_context(mm);
|
|
|
|
}
|
|
|
|
|
2013-02-20 13:34:10 +07:00
|
|
|
void hugetlb_setup(struct pt_regs *regs)
|
2012-10-09 06:34:29 +07:00
|
|
|
{
|
2013-02-20 13:34:10 +07:00
|
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
struct tsb_config *tp;
|
2012-10-09 06:34:29 +07:00
|
|
|
|
2013-02-20 13:34:10 +07:00
|
|
|
if (in_atomic() || !mm) {
|
|
|
|
const struct exception_table_entry *entry;
|
|
|
|
|
|
|
|
entry = search_exception_tables(regs->tpc);
|
|
|
|
if (entry) {
|
|
|
|
regs->tpc = entry->fixup;
|
|
|
|
regs->tnpc = regs->tpc + 4;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pr_alert("Unexpected HugeTLB setup in atomic context.\n");
|
|
|
|
die_if_kernel("HugeTSB in atomic", regs);
|
|
|
|
}
|
|
|
|
|
|
|
|
tp = &mm->context.tsb_block[MM_TSB_HUGE];
|
|
|
|
if (likely(tp->tsb == NULL))
|
|
|
|
tsb_grow(mm, MM_TSB_HUGE, 0);
|
2012-10-09 06:34:29 +07:00
|
|
|
|
|
|
|
tsb_context_switch(mm);
|
|
|
|
smp_tsb_sync(mm);
|
|
|
|
|
|
|
|
/* On UltraSPARC-III+ and later, configure the second half of
|
|
|
|
* the Data-TLB for huge pages.
|
|
|
|
*/
|
|
|
|
if (tlb_type == cheetah_plus) {
|
|
|
|
unsigned long ctx;
|
|
|
|
|
|
|
|
spin_lock(&ctx_alloc_lock);
|
|
|
|
ctx = mm->context.sparc64_ctx_val;
|
|
|
|
ctx &= ~CTX_PGSZ_MASK;
|
|
|
|
ctx |= CTX_PGSZ_BASE << CTX_PGSZ0_SHIFT;
|
|
|
|
ctx |= CTX_PGSZ_HUGE << CTX_PGSZ1_SHIFT;
|
|
|
|
|
|
|
|
if (ctx != mm->context.sparc64_ctx_val) {
|
|
|
|
/* When changing the page size fields, we
|
|
|
|
* must perform a context flush so that no
|
|
|
|
* stale entries match. This flush must
|
|
|
|
* occur with the original context register
|
|
|
|
* settings.
|
|
|
|
*/
|
|
|
|
do_flush_tlb_mm(mm);
|
|
|
|
|
|
|
|
/* Reload the context register of all processors
|
|
|
|
* also executing in this address space.
|
|
|
|
*/
|
|
|
|
mm->context.sparc64_ctx_val = ctx;
|
|
|
|
on_each_cpu(context_reload, mm, 0);
|
|
|
|
}
|
|
|
|
spin_unlock(&ctx_alloc_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|