2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* TLB support routines.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1998-2001, 2003 Hewlett-Packard Co
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
*
|
|
|
|
* 08/02/00 A. Mallick <asit.k.mallick@intel.com>
|
|
|
|
* Modified RID allocation for SMP
|
|
|
|
* Goutham Rao <goutham.rao@intel.com>
|
|
|
|
* IPI based ptc implementation and A-step IPI implementation.
|
2005-10-31 22:44:47 +01:00
|
|
|
* Rohit Seth <rohit.seth@intel.com>
|
|
|
|
* Ken Chen <kenneth.w.chen@intel.com>
|
2007-12-13 16:03:07 +01:00
|
|
|
* Christophe de Dinechin <ddd@hp.com>: Avoid ptc.e on memory allocation
|
2008-04-04 20:05:59 +02:00
|
|
|
* Copyright (C) 2007 Intel Corp
|
|
|
|
* Fenghua Yu <fenghua.yu@intel.com>
|
|
|
|
* Add multiple ptc.g/ptc.ga instruction support in global tlb purge.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/mm.h>
|
2005-10-31 22:44:47 +01:00
|
|
|
#include <linux/bootmem.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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/delay.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include <asm/pal.h>
|
|
|
|
#include <asm/tlbflush.h>
|
2005-10-31 22:44:47 +01:00
|
|
|
#include <asm/dma.h>
|
2008-04-03 20:02:58 +02:00
|
|
|
#include <asm/processor.h>
|
2008-04-04 20:05:59 +02:00
|
|
|
#include <asm/sal.h>
|
2008-04-03 20:02:58 +02:00
|
|
|
#include <asm/tlb.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static struct {
|
2009-05-22 22:49:49 +02:00
|
|
|
u64 mask; /* mask of supported purge page-sizes */
|
2005-10-30 02:47:04 +01:00
|
|
|
unsigned long max_bits; /* log2 of largest supported purge page-size */
|
2005-04-17 00:20:36 +02:00
|
|
|
} purge;
|
|
|
|
|
|
|
|
struct ia64_ctx ia64_ctx = {
|
2007-04-15 19:21:23 +02:00
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(ia64_ctx.lock),
|
|
|
|
.next = 1,
|
|
|
|
.max_ctx = ~0U
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_PER_CPU(u8, ia64_need_tlb_flush);
|
2008-04-03 20:02:58 +02:00
|
|
|
DEFINE_PER_CPU(u8, ia64_tr_num); /*Number of TR slots in current processor*/
|
|
|
|
DEFINE_PER_CPU(u8, ia64_tr_used); /*Max Slot number used by kernel*/
|
|
|
|
|
2010-01-08 01:10:57 +01:00
|
|
|
struct ia64_tr_entry *ia64_idtrs[NR_CPUS];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-31 22:44:47 +01:00
|
|
|
/*
|
|
|
|
* Initializes the ia64_ctx.bitmap array based on max_ctx+1.
|
|
|
|
* Called after cpu_init() has setup ia64_ctx.max_ctx based on
|
|
|
|
* maximum RID that is supported by boot CPU.
|
|
|
|
*/
|
|
|
|
void __init
|
|
|
|
mmu_context_init (void)
|
|
|
|
{
|
|
|
|
ia64_ctx.bitmap = alloc_bootmem((ia64_ctx.max_ctx+1)>>3);
|
|
|
|
ia64_ctx.flushmap = alloc_bootmem((ia64_ctx.max_ctx+1)>>3);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Acquire the ia64_ctx.lock before calling this function!
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
wrap_mmu_context (struct mm_struct *mm)
|
|
|
|
{
|
2005-10-30 02:47:04 +01:00
|
|
|
int i, cpu;
|
2005-10-31 22:44:47 +01:00
|
|
|
unsigned long flush_bit;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-31 22:44:47 +01:00
|
|
|
for (i=0; i <= ia64_ctx.max_ctx / BITS_PER_LONG; i++) {
|
|
|
|
flush_bit = xchg(&ia64_ctx.flushmap[i], 0);
|
|
|
|
ia64_ctx.bitmap[i] ^= flush_bit;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-10-31 22:44:47 +01:00
|
|
|
|
|
|
|
/* use offset at 300 to skip daemons */
|
|
|
|
ia64_ctx.next = find_next_zero_bit(ia64_ctx.bitmap,
|
|
|
|
ia64_ctx.max_ctx, 300);
|
|
|
|
ia64_ctx.limit = find_next_bit(ia64_ctx.bitmap,
|
|
|
|
ia64_ctx.max_ctx, ia64_ctx.next);
|
|
|
|
|
2005-10-30 02:47:04 +01:00
|
|
|
/*
|
|
|
|
* can't call flush_tlb_all() here because of race condition
|
|
|
|
* with O(1) scheduler [EF]
|
|
|
|
*/
|
|
|
|
cpu = get_cpu(); /* prevent preemption/migration */
|
|
|
|
for_each_online_cpu(i)
|
|
|
|
if (i != cpu)
|
|
|
|
per_cpu(ia64_need_tlb_flush, i) = 1;
|
|
|
|
put_cpu();
|
2005-04-17 00:20:36 +02:00
|
|
|
local_flush_tlb_all();
|
|
|
|
}
|
|
|
|
|
2008-04-04 20:05:59 +02:00
|
|
|
/*
|
|
|
|
* Implement "spinaphores" ... like counting semaphores, but they
|
|
|
|
* spin instead of sleeping. If there are ever any other users for
|
|
|
|
* this primitive it can be moved up to a spinaphore.h header.
|
|
|
|
*/
|
|
|
|
struct spinaphore {
|
2009-10-09 19:52:39 +02:00
|
|
|
unsigned long ticket;
|
|
|
|
unsigned long serve;
|
2008-04-04 20:05:59 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline void spinaphore_init(struct spinaphore *ss, int val)
|
|
|
|
{
|
2009-10-09 19:52:39 +02:00
|
|
|
ss->ticket = 0;
|
|
|
|
ss->serve = val;
|
2008-04-04 20:05:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void down_spin(struct spinaphore *ss)
|
|
|
|
{
|
2009-10-09 19:52:39 +02:00
|
|
|
unsigned long t = ia64_fetchadd(1, &ss->ticket, acq), serve;
|
|
|
|
|
|
|
|
if (time_before(t, ss->serve))
|
|
|
|
return;
|
|
|
|
|
|
|
|
ia64_invala();
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
asm volatile ("ld4.c.nc %0=[%1]" : "=r"(serve) : "r"(&ss->serve) : "memory");
|
|
|
|
if (time_before(t, serve))
|
|
|
|
return;
|
|
|
|
cpu_relax();
|
|
|
|
}
|
2008-04-04 20:05:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void up_spin(struct spinaphore *ss)
|
|
|
|
{
|
2009-10-09 19:52:39 +02:00
|
|
|
ia64_fetchadd(1, &ss->serve, rel);
|
2008-04-04 20:05:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct spinaphore ptcg_sem;
|
|
|
|
static u16 nptcg = 1;
|
|
|
|
static int need_ptcg_sem = 1;
|
|
|
|
static int toolatetochangeptcgsem = 0;
|
|
|
|
|
2008-03-14 21:57:08 +01:00
|
|
|
/*
|
|
|
|
* Kernel parameter "nptcg=" overrides max number of concurrent global TLB
|
|
|
|
* purges which is reported from either PAL or SAL PALO.
|
|
|
|
*
|
|
|
|
* We don't have sanity checking for nptcg value. It's the user's responsibility
|
|
|
|
* for valid nptcg value on the platform. Otherwise, kernel may hang in some
|
|
|
|
* cases.
|
|
|
|
*/
|
|
|
|
static int __init
|
|
|
|
set_nptcg(char *str)
|
|
|
|
{
|
|
|
|
int value = 0;
|
|
|
|
|
|
|
|
get_option(&str, &value);
|
|
|
|
setup_ptcg_sem(value, NPTCG_FROM_KERNEL_PARAMETER);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("nptcg=", set_nptcg);
|
|
|
|
|
2008-04-04 20:05:59 +02:00
|
|
|
/*
|
|
|
|
* Maximum number of simultaneous ptc.g purges in the system can
|
|
|
|
* be defined by PAL_VM_SUMMARY (in which case we should take
|
|
|
|
* the smallest value for any cpu in the system) or by the PAL
|
|
|
|
* override table (in which case we should ignore the value from
|
|
|
|
* PAL_VM_SUMMARY).
|
|
|
|
*
|
2008-03-14 21:57:08 +01:00
|
|
|
* Kernel parameter "nptcg=" overrides maximum number of simultanesous ptc.g
|
|
|
|
* purges defined in either PAL_VM_SUMMARY or PAL override table. In this case,
|
|
|
|
* we should ignore the value from either PAL_VM_SUMMARY or PAL override table.
|
|
|
|
*
|
2008-04-04 20:05:59 +02:00
|
|
|
* Complicating the logic here is the fact that num_possible_cpus()
|
|
|
|
* isn't fully setup until we start bringing cpus online.
|
|
|
|
*/
|
|
|
|
void
|
2008-03-14 21:57:08 +01:00
|
|
|
setup_ptcg_sem(int max_purges, int nptcg_from)
|
2008-04-04 20:05:59 +02:00
|
|
|
{
|
2008-03-14 21:57:08 +01:00
|
|
|
static int kp_override;
|
|
|
|
static int palo_override;
|
2008-04-04 20:05:59 +02:00
|
|
|
static int firstcpu = 1;
|
|
|
|
|
|
|
|
if (toolatetochangeptcgsem) {
|
2008-04-25 16:13:09 +02:00
|
|
|
if (nptcg_from == NPTCG_FROM_PAL && max_purges == 0)
|
|
|
|
BUG_ON(1 < nptcg);
|
|
|
|
else
|
|
|
|
BUG_ON(max_purges < nptcg);
|
2008-04-04 20:05:59 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-03-14 21:57:08 +01:00
|
|
|
if (nptcg_from == NPTCG_FROM_KERNEL_PARAMETER) {
|
|
|
|
kp_override = 1;
|
|
|
|
nptcg = max_purges;
|
|
|
|
goto resetsema;
|
|
|
|
}
|
|
|
|
if (kp_override) {
|
|
|
|
need_ptcg_sem = num_possible_cpus() > nptcg;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nptcg_from == NPTCG_FROM_PALO) {
|
|
|
|
palo_override = 1;
|
2008-04-04 20:05:59 +02:00
|
|
|
|
|
|
|
/* In PALO max_purges == 0 really means it! */
|
|
|
|
if (max_purges == 0)
|
|
|
|
panic("Whoa! Platform does not support global TLB purges.\n");
|
|
|
|
nptcg = max_purges;
|
|
|
|
if (nptcg == PALO_MAX_TLB_PURGES) {
|
|
|
|
need_ptcg_sem = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
goto resetsema;
|
|
|
|
}
|
2008-03-14 21:57:08 +01:00
|
|
|
if (palo_override) {
|
2008-04-04 20:05:59 +02:00
|
|
|
if (nptcg != PALO_MAX_TLB_PURGES)
|
|
|
|
need_ptcg_sem = (num_possible_cpus() > nptcg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* In PAL_VM_SUMMARY max_purges == 0 actually means 1 */
|
|
|
|
if (max_purges == 0) max_purges = 1;
|
|
|
|
|
|
|
|
if (firstcpu) {
|
|
|
|
nptcg = max_purges;
|
|
|
|
firstcpu = 0;
|
|
|
|
}
|
|
|
|
if (max_purges < nptcg)
|
|
|
|
nptcg = max_purges;
|
|
|
|
if (nptcg == PAL_MAX_PURGES) {
|
|
|
|
need_ptcg_sem = 0;
|
|
|
|
return;
|
|
|
|
} else
|
|
|
|
need_ptcg_sem = (num_possible_cpus() > nptcg);
|
|
|
|
|
|
|
|
resetsema:
|
|
|
|
spinaphore_init(&ptcg_sem, max_purges);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void
|
2005-10-30 02:47:04 +01:00
|
|
|
ia64_global_tlb_purge (struct mm_struct *mm, unsigned long start,
|
|
|
|
unsigned long end, unsigned long nbits)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-12-13 16:03:07 +01:00
|
|
|
struct mm_struct *active_mm = current->active_mm;
|
|
|
|
|
2008-04-04 20:05:59 +02:00
|
|
|
toolatetochangeptcgsem = 1;
|
|
|
|
|
2007-12-13 16:03:07 +01:00
|
|
|
if (mm != active_mm) {
|
|
|
|
/* Restore region IDs for mm */
|
|
|
|
if (mm && active_mm) {
|
|
|
|
activate_context(mm);
|
|
|
|
} else {
|
|
|
|
flush_tlb_all();
|
|
|
|
return;
|
|
|
|
}
|
2005-10-27 22:41:04 +02:00
|
|
|
}
|
|
|
|
|
2008-04-04 20:05:59 +02:00
|
|
|
if (need_ptcg_sem)
|
|
|
|
down_spin(&ptcg_sem);
|
|
|
|
|
|
|
|
do {
|
|
|
|
/*
|
|
|
|
* Flush ALAT entries also.
|
|
|
|
*/
|
|
|
|
ia64_ptcga(start, (nbits << 2));
|
|
|
|
ia64_srlz_i();
|
|
|
|
start += (1UL << nbits);
|
|
|
|
} while (start < end);
|
|
|
|
|
|
|
|
if (need_ptcg_sem)
|
|
|
|
up_spin(&ptcg_sem);
|
2007-12-13 16:03:07 +01:00
|
|
|
|
|
|
|
if (mm != active_mm) {
|
|
|
|
activate_context(active_mm);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
local_flush_tlb_all (void)
|
|
|
|
{
|
|
|
|
unsigned long i, j, flags, count0, count1, stride0, stride1, addr;
|
|
|
|
|
|
|
|
addr = local_cpu_data->ptce_base;
|
|
|
|
count0 = local_cpu_data->ptce_count[0];
|
|
|
|
count1 = local_cpu_data->ptce_count[1];
|
|
|
|
stride0 = local_cpu_data->ptce_stride[0];
|
|
|
|
stride1 = local_cpu_data->ptce_stride[1];
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
for (i = 0; i < count0; ++i) {
|
|
|
|
for (j = 0; j < count1; ++j) {
|
|
|
|
ia64_ptce(addr);
|
|
|
|
addr += stride1;
|
|
|
|
}
|
|
|
|
addr += stride0;
|
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
ia64_srlz_i(); /* srlz.i implies srlz.d */
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-10-30 02:47:04 +01:00
|
|
|
flush_tlb_range (struct vm_area_struct *vma, unsigned long start,
|
|
|
|
unsigned long end)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct mm_struct *mm = vma->vm_mm;
|
|
|
|
unsigned long size = end - start;
|
|
|
|
unsigned long nbits;
|
|
|
|
|
2005-10-27 22:41:04 +02:00
|
|
|
#ifndef CONFIG_SMP
|
2005-04-17 00:20:36 +02:00
|
|
|
if (mm != current->active_mm) {
|
|
|
|
mm->context = 0;
|
|
|
|
return;
|
|
|
|
}
|
2005-10-27 22:41:04 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nbits = ia64_fls(size + 0xfff);
|
2005-10-30 02:47:04 +01:00
|
|
|
while (unlikely (((1UL << nbits) & purge.mask) == 0) &&
|
|
|
|
(nbits < purge.max_bits))
|
2005-04-17 00:20:36 +02:00
|
|
|
++nbits;
|
|
|
|
if (nbits > purge.max_bits)
|
|
|
|
nbits = purge.max_bits;
|
|
|
|
start &= ~((1UL << nbits) - 1);
|
|
|
|
|
2005-10-30 02:16:28 +01:00
|
|
|
preempt_disable();
|
2006-03-06 23:12:54 +01:00
|
|
|
#ifdef CONFIG_SMP
|
2009-03-16 04:42:48 +01:00
|
|
|
if (mm != current->active_mm || cpumask_weight(mm_cpumask(mm)) != 1) {
|
2006-03-06 23:12:54 +01:00
|
|
|
platform_global_tlb_purge(mm, start, end, nbits);
|
|
|
|
preempt_enable();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
do {
|
|
|
|
ia64_ptcl(start, (nbits<<2));
|
|
|
|
start += (1UL << nbits);
|
|
|
|
} while (start < end);
|
2005-10-30 02:16:28 +01:00
|
|
|
preempt_enable();
|
2005-04-17 00:20:36 +02:00
|
|
|
ia64_srlz_i(); /* srlz.i implies srlz.d */
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(flush_tlb_range);
|
|
|
|
|
|
|
|
void __devinit
|
|
|
|
ia64_tlb_init (void)
|
|
|
|
{
|
2007-07-11 17:26:30 +02:00
|
|
|
ia64_ptce_info_t uninitialized_var(ptce_info); /* GCC be quiet */
|
2009-05-22 22:49:49 +02:00
|
|
|
u64 tr_pgbits;
|
2005-04-17 00:20:36 +02:00
|
|
|
long status;
|
2008-04-03 20:02:58 +02:00
|
|
|
pal_vm_info_1_u_t vm_info_1;
|
|
|
|
pal_vm_info_2_u_t vm_info_2;
|
|
|
|
int cpu = smp_processor_id();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if ((status = ia64_pal_vm_page_size(&tr_pgbits, &purge.mask)) != 0) {
|
2007-11-20 02:47:53 +01:00
|
|
|
printk(KERN_ERR "PAL_VM_PAGE_SIZE failed with status=%ld; "
|
2005-04-17 00:20:36 +02:00
|
|
|
"defaulting to architected purge page-sizes.\n", status);
|
|
|
|
purge.mask = 0x115557000UL;
|
|
|
|
}
|
|
|
|
purge.max_bits = ia64_fls(purge.mask);
|
|
|
|
|
|
|
|
ia64_get_ptce(&ptce_info);
|
|
|
|
local_cpu_data->ptce_base = ptce_info.base;
|
|
|
|
local_cpu_data->ptce_count[0] = ptce_info.count[0];
|
|
|
|
local_cpu_data->ptce_count[1] = ptce_info.count[1];
|
|
|
|
local_cpu_data->ptce_stride[0] = ptce_info.stride[0];
|
|
|
|
local_cpu_data->ptce_stride[1] = ptce_info.stride[1];
|
|
|
|
|
2005-10-30 02:47:04 +01:00
|
|
|
local_flush_tlb_all(); /* nuke left overs from bootstrapping... */
|
2008-04-03 20:02:58 +02:00
|
|
|
status = ia64_pal_vm_summary(&vm_info_1, &vm_info_2);
|
|
|
|
|
|
|
|
if (status) {
|
|
|
|
printk(KERN_ERR "ia64_pal_vm_summary=%ld\n", status);
|
|
|
|
per_cpu(ia64_tr_num, cpu) = 8;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
per_cpu(ia64_tr_num, cpu) = vm_info_1.pal_vm_info_1_s.max_itr_entry+1;
|
|
|
|
if (per_cpu(ia64_tr_num, cpu) >
|
|
|
|
(vm_info_1.pal_vm_info_1_s.max_dtr_entry+1))
|
|
|
|
per_cpu(ia64_tr_num, cpu) =
|
|
|
|
vm_info_1.pal_vm_info_1_s.max_dtr_entry+1;
|
|
|
|
if (per_cpu(ia64_tr_num, cpu) > IA64_TR_ALLOC_MAX) {
|
2008-10-17 22:47:53 +02:00
|
|
|
static int justonce = 1;
|
2008-04-03 20:02:58 +02:00
|
|
|
per_cpu(ia64_tr_num, cpu) = IA64_TR_ALLOC_MAX;
|
2008-10-17 22:47:53 +02:00
|
|
|
if (justonce) {
|
|
|
|
justonce = 0;
|
|
|
|
printk(KERN_DEBUG "TR register number exceeds "
|
|
|
|
"IA64_TR_ALLOC_MAX!\n");
|
|
|
|
}
|
2008-04-03 20:02:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* is_tr_overlap
|
|
|
|
*
|
|
|
|
* Check overlap with inserted TRs.
|
|
|
|
*/
|
|
|
|
static int is_tr_overlap(struct ia64_tr_entry *p, u64 va, u64 log_size)
|
|
|
|
{
|
|
|
|
u64 tr_log_size;
|
|
|
|
u64 tr_end;
|
|
|
|
u64 va_rr = ia64_get_rr(va);
|
|
|
|
u64 va_rid = RR_TO_RID(va_rr);
|
|
|
|
u64 va_end = va + (1<<log_size) - 1;
|
|
|
|
|
|
|
|
if (va_rid != RR_TO_RID(p->rr))
|
|
|
|
return 0;
|
|
|
|
tr_log_size = (p->itir & 0xff) >> 2;
|
|
|
|
tr_end = p->ifa + (1<<tr_log_size) - 1;
|
|
|
|
|
|
|
|
if (va > tr_end || p->ifa > va_end)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ia64_insert_tr in virtual mode. Allocate a TR slot
|
|
|
|
*
|
|
|
|
* target_mask : 0x1 : itr, 0x2 : dtr, 0x3 : idtr
|
|
|
|
*
|
|
|
|
* va : virtual address.
|
|
|
|
* pte : pte entries inserted.
|
|
|
|
* log_size: range to be covered.
|
|
|
|
*
|
|
|
|
* Return value: <0 : error No.
|
|
|
|
*
|
|
|
|
* >=0 : slot number allocated for TR.
|
|
|
|
* Must be called with preemption disabled.
|
|
|
|
*/
|
|
|
|
int ia64_itr_entry(u64 target_mask, u64 va, u64 pte, u64 log_size)
|
|
|
|
{
|
|
|
|
int i, r;
|
|
|
|
unsigned long psr;
|
|
|
|
struct ia64_tr_entry *p;
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
2010-01-08 01:10:57 +01:00
|
|
|
if (!ia64_idtrs[cpu]) {
|
|
|
|
ia64_idtrs[cpu] = kmalloc(2 * IA64_TR_ALLOC_MAX *
|
|
|
|
sizeof (struct ia64_tr_entry), GFP_KERNEL);
|
|
|
|
if (!ia64_idtrs[cpu])
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-04-03 20:02:58 +02:00
|
|
|
r = -EINVAL;
|
|
|
|
/*Check overlap with existing TR entries*/
|
|
|
|
if (target_mask & 0x1) {
|
2010-01-08 01:10:57 +01:00
|
|
|
p = ia64_idtrs[cpu];
|
2008-04-03 20:02:58 +02:00
|
|
|
for (i = IA64_TR_ALLOC_BASE; i <= per_cpu(ia64_tr_used, cpu);
|
|
|
|
i++, p++) {
|
|
|
|
if (p->pte & 0x1)
|
|
|
|
if (is_tr_overlap(p, va, log_size)) {
|
|
|
|
printk(KERN_DEBUG "Overlapped Entry"
|
|
|
|
"Inserted for TR Reigster!!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (target_mask & 0x2) {
|
2010-01-08 01:10:57 +01:00
|
|
|
p = ia64_idtrs[cpu] + IA64_TR_ALLOC_MAX;
|
2008-04-03 20:02:58 +02:00
|
|
|
for (i = IA64_TR_ALLOC_BASE; i <= per_cpu(ia64_tr_used, cpu);
|
|
|
|
i++, p++) {
|
|
|
|
if (p->pte & 0x1)
|
|
|
|
if (is_tr_overlap(p, va, log_size)) {
|
|
|
|
printk(KERN_DEBUG "Overlapped Entry"
|
|
|
|
"Inserted for TR Reigster!!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = IA64_TR_ALLOC_BASE; i < per_cpu(ia64_tr_num, cpu); i++) {
|
|
|
|
switch (target_mask & 0x3) {
|
|
|
|
case 1:
|
2010-01-08 01:10:57 +01:00
|
|
|
if (!((ia64_idtrs[cpu] + i)->pte & 0x1))
|
2008-04-03 20:02:58 +02:00
|
|
|
goto found;
|
|
|
|
continue;
|
|
|
|
case 2:
|
2010-01-08 01:10:57 +01:00
|
|
|
if (!((ia64_idtrs[cpu] + IA64_TR_ALLOC_MAX + i)->pte & 0x1))
|
2008-04-03 20:02:58 +02:00
|
|
|
goto found;
|
|
|
|
continue;
|
|
|
|
case 3:
|
2010-01-08 01:10:57 +01:00
|
|
|
if (!((ia64_idtrs[cpu] + i)->pte & 0x1) &&
|
|
|
|
!((ia64_idtrs[cpu] + IA64_TR_ALLOC_MAX + i)->pte & 0x1))
|
2008-04-03 20:02:58 +02:00
|
|
|
goto found;
|
|
|
|
continue;
|
|
|
|
default:
|
|
|
|
r = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
found:
|
|
|
|
if (i >= per_cpu(ia64_tr_num, cpu))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/*Record tr info for mca hander use!*/
|
|
|
|
if (i > per_cpu(ia64_tr_used, cpu))
|
|
|
|
per_cpu(ia64_tr_used, cpu) = i;
|
|
|
|
|
|
|
|
psr = ia64_clear_ic();
|
|
|
|
if (target_mask & 0x1) {
|
|
|
|
ia64_itr(0x1, i, va, pte, log_size);
|
|
|
|
ia64_srlz_i();
|
2010-01-08 01:10:57 +01:00
|
|
|
p = ia64_idtrs[cpu] + i;
|
2008-04-03 20:02:58 +02:00
|
|
|
p->ifa = va;
|
|
|
|
p->pte = pte;
|
|
|
|
p->itir = log_size << 2;
|
|
|
|
p->rr = ia64_get_rr(va);
|
|
|
|
}
|
|
|
|
if (target_mask & 0x2) {
|
|
|
|
ia64_itr(0x2, i, va, pte, log_size);
|
|
|
|
ia64_srlz_i();
|
2010-01-08 01:10:57 +01:00
|
|
|
p = ia64_idtrs[cpu] + IA64_TR_ALLOC_MAX + i;
|
2008-04-03 20:02:58 +02:00
|
|
|
p->ifa = va;
|
|
|
|
p->pte = pte;
|
|
|
|
p->itir = log_size << 2;
|
|
|
|
p->rr = ia64_get_rr(va);
|
|
|
|
}
|
|
|
|
ia64_set_psr(psr);
|
|
|
|
r = i;
|
|
|
|
out:
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ia64_itr_entry);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ia64_purge_tr
|
|
|
|
*
|
|
|
|
* target_mask: 0x1: purge itr, 0x2 : purge dtr, 0x3 purge idtr.
|
|
|
|
* slot: slot number to be freed.
|
|
|
|
*
|
|
|
|
* Must be called with preemption disabled.
|
|
|
|
*/
|
|
|
|
void ia64_ptr_entry(u64 target_mask, int slot)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
int i;
|
|
|
|
struct ia64_tr_entry *p;
|
|
|
|
|
|
|
|
if (slot < IA64_TR_ALLOC_BASE || slot >= per_cpu(ia64_tr_num, cpu))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (target_mask & 0x1) {
|
2010-01-08 01:10:57 +01:00
|
|
|
p = ia64_idtrs[cpu] + slot;
|
2008-04-03 20:02:58 +02:00
|
|
|
if ((p->pte&0x1) && is_tr_overlap(p, p->ifa, p->itir>>2)) {
|
|
|
|
p->pte = 0;
|
|
|
|
ia64_ptr(0x1, p->ifa, p->itir>>2);
|
|
|
|
ia64_srlz_i();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (target_mask & 0x2) {
|
2010-01-08 01:10:57 +01:00
|
|
|
p = ia64_idtrs[cpu] + IA64_TR_ALLOC_MAX + slot;
|
2008-04-03 20:02:58 +02:00
|
|
|
if ((p->pte & 0x1) && is_tr_overlap(p, p->ifa, p->itir>>2)) {
|
|
|
|
p->pte = 0;
|
|
|
|
ia64_ptr(0x2, p->ifa, p->itir>>2);
|
|
|
|
ia64_srlz_i();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = per_cpu(ia64_tr_used, cpu); i >= IA64_TR_ALLOC_BASE; i--) {
|
2010-01-08 01:10:57 +01:00
|
|
|
if (((ia64_idtrs[cpu] + i)->pte & 0x1) ||
|
|
|
|
((ia64_idtrs[cpu] + IA64_TR_ALLOC_MAX + i)->pte & 0x1))
|
2008-04-03 20:02:58 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
per_cpu(ia64_tr_used, cpu) = i;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-03 20:02:58 +02:00
|
|
|
EXPORT_SYMBOL_GPL(ia64_ptr_entry);
|