Pull pvops into release branch
This commit is contained in:
Tony Luck
@@ -5,7 +5,7 @@
|
||||
extra-y := head.o init_task.o vmlinux.lds
|
||||
|
||||
obj-y := acpi.o entry.o efi.o efi_stub.o gate-data.o fsys.o ia64_ksyms.o irq.o irq_ia64.o \
|
||||
irq_lsapic.o ivt.o machvec.o pal.o patch.o process.o perfmon.o ptrace.o sal.o \
|
||||
irq_lsapic.o ivt.o machvec.o pal.o paravirt_patchlist.o patch.o process.o perfmon.o ptrace.o sal.o \
|
||||
salinfo.o setup.o signal.o sys_ia64.o time.o traps.o unaligned.o \
|
||||
unwind.o mca.o mca_asm.o topology.o dma-mapping.o
|
||||
|
||||
@@ -36,7 +36,8 @@ obj-$(CONFIG_PCI_MSI) += msi_ia64.o
|
||||
mca_recovery-y += mca_drv.o mca_drv_asm.o
|
||||
obj-$(CONFIG_IA64_MC_ERR_INJECT)+= err_inject.o
|
||||
|
||||
obj-$(CONFIG_PARAVIRT) += paravirt.o paravirtentry.o
|
||||
obj-$(CONFIG_PARAVIRT) += paravirt.o paravirtentry.o \
|
||||
paravirt_patch.o
|
||||
|
||||
obj-$(CONFIG_IA64_ESI) += esi.o
|
||||
ifneq ($(CONFIG_IA64_ESI),)
|
||||
@@ -45,35 +46,13 @@ endif
|
||||
obj-$(CONFIG_DMAR) += pci-dma.o
|
||||
obj-$(CONFIG_SWIOTLB) += pci-swiotlb.o
|
||||
|
||||
# The gate DSO image is built using a special linker script.
|
||||
targets += gate.so gate-syms.o
|
||||
|
||||
extra-y += gate.so gate-syms.o gate.lds gate.o
|
||||
|
||||
# fp_emulate() expects f2-f5,f16-f31 to contain the user-level state.
|
||||
CFLAGS_traps.o += -mfixed-range=f2-f5,f16-f31
|
||||
|
||||
CPPFLAGS_gate.lds := -P -C -U$(ARCH)
|
||||
|
||||
quiet_cmd_gate = GATE $@
|
||||
cmd_gate = $(CC) -nostdlib $(GATECFLAGS_$(@F)) -Wl,-T,$(filter-out FORCE,$^) -o $@
|
||||
|
||||
GATECFLAGS_gate.so = -shared -s -Wl,-soname=linux-gate.so.1 \
|
||||
$(call ld-option, -Wl$(comma)--hash-style=sysv)
|
||||
$(obj)/gate.so: $(obj)/gate.lds $(obj)/gate.o FORCE
|
||||
$(call if_changed,gate)
|
||||
|
||||
$(obj)/built-in.o: $(obj)/gate-syms.o
|
||||
$(obj)/built-in.o: ld_flags += -R $(obj)/gate-syms.o
|
||||
|
||||
GATECFLAGS_gate-syms.o = -r
|
||||
$(obj)/gate-syms.o: $(obj)/gate.lds $(obj)/gate.o FORCE
|
||||
$(call if_changed,gate)
|
||||
|
||||
# gate-data.o contains the gate DSO image as data in section .data.gate.
|
||||
# We must build gate.so before we can assemble it.
|
||||
# Note: kbuild does not track this dependency due to usage of .incbin
|
||||
$(obj)/gate-data.o: $(obj)/gate.so
|
||||
# The gate DSO image is built using a special linker script.
|
||||
include $(srctree)/arch/ia64/kernel/Makefile.gate
|
||||
# tell compiled for native
|
||||
CPPFLAGS_gate.lds += -D__IA64_GATE_PARAVIRTUALIZED_NATIVE
|
||||
|
||||
# Calculate NR_IRQ = max(IA64_NATIVE_NR_IRQS, XEN_NR_IRQS, ...) based on config
|
||||
define sed-y
|
||||
@@ -109,9 +88,9 @@ include/asm-ia64/nr-irqs.h: arch/$(SRCARCH)/kernel/nr-irqs.s
|
||||
clean-files += $(objtree)/include/asm-ia64/nr-irqs.h
|
||||
|
||||
#
|
||||
# native ivt.S and entry.S
|
||||
# native ivt.S, entry.S and fsys.S
|
||||
#
|
||||
ASM_PARAVIRT_OBJS = ivt.o entry.o
|
||||
ASM_PARAVIRT_OBJS = ivt.o entry.o fsys.o
|
||||
define paravirtualized_native
|
||||
AFLAGS_$(1) += -D__IA64_ASM_PARAVIRTUALIZED_NATIVE
|
||||
AFLAGS_pvchk-sed-$(1) += -D__IA64_ASM_PARAVIRTUALIZED_PVCHECK
|
||||
|
||||
27
arch/ia64/kernel/Makefile.gate
Normal file
27
arch/ia64/kernel/Makefile.gate
Normal file
@@ -0,0 +1,27 @@
|
||||
# The gate DSO image is built using a special linker script.
|
||||
|
||||
targets += gate.so gate-syms.o
|
||||
|
||||
extra-y += gate.so gate-syms.o gate.lds gate.o
|
||||
|
||||
CPPFLAGS_gate.lds := -P -C -U$(ARCH)
|
||||
|
||||
quiet_cmd_gate = GATE $@
|
||||
cmd_gate = $(CC) -nostdlib $(GATECFLAGS_$(@F)) -Wl,-T,$(filter-out FORCE,$^) -o $@
|
||||
|
||||
GATECFLAGS_gate.so = -shared -s -Wl,-soname=linux-gate.so.1 \
|
||||
$(call ld-option, -Wl$(comma)--hash-style=sysv)
|
||||
$(obj)/gate.so: $(obj)/gate.lds $(obj)/gate.o FORCE
|
||||
$(call if_changed,gate)
|
||||
|
||||
$(obj)/built-in.o: $(obj)/gate-syms.o
|
||||
$(obj)/built-in.o: ld_flags += -R $(obj)/gate-syms.o
|
||||
|
||||
GATECFLAGS_gate-syms.o = -r
|
||||
$(obj)/gate-syms.o: $(obj)/gate.lds $(obj)/gate.o FORCE
|
||||
$(call if_changed,gate)
|
||||
|
||||
# gate-data.o contains the gate DSO image as data in section .data.gate.
|
||||
# We must build gate.so before we can assemble it.
|
||||
# Note: kbuild does not track this dependency due to usage of .incbin
|
||||
$(obj)/gate-data.o: $(obj)/gate.so
|
||||
@@ -316,5 +316,7 @@ void foo(void)
|
||||
DEFINE_MAPPED_REG_OFS(XSI_BANK1_R16_OFS, bank1_regs[0]);
|
||||
DEFINE_MAPPED_REG_OFS(XSI_B0NATS_OFS, vbnat);
|
||||
DEFINE_MAPPED_REG_OFS(XSI_B1NATS_OFS, vnat);
|
||||
DEFINE_MAPPED_REG_OFS(XSI_ITC_OFFSET_OFS, itc_offset);
|
||||
DEFINE_MAPPED_REG_OFS(XSI_ITC_LAST_OFS, itc_last);
|
||||
#endif /* CONFIG_XEN */
|
||||
}
|
||||
|
||||
@@ -456,6 +456,7 @@ efi_map_pal_code (void)
|
||||
GRANULEROUNDDOWN((unsigned long) pal_vaddr),
|
||||
pte_val(pfn_pte(__pa(pal_vaddr) >> PAGE_SHIFT, PAGE_KERNEL)),
|
||||
IA64_GRANULE_SHIFT);
|
||||
paravirt_dv_serialize_data();
|
||||
ia64_set_psr(psr); /* restore psr */
|
||||
}
|
||||
|
||||
|
||||
@@ -735,7 +735,7 @@ GLOBAL_ENTRY(__paravirt_leave_syscall)
|
||||
__paravirt_work_processed_syscall:
|
||||
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
||||
adds r2=PT(LOADRS)+16,r12
|
||||
(pUStk) mov.m r22=ar.itc // fetch time at leave
|
||||
MOV_FROM_ITC(pUStk, p9, r22, r19) // fetch time at leave
|
||||
adds r18=TI_FLAGS+IA64_TASK_SIZE,r13
|
||||
;;
|
||||
(p6) ld4 r31=[r18] // load current_thread_info()->flags
|
||||
@@ -984,7 +984,7 @@ GLOBAL_ENTRY(__paravirt_leave_kernel)
|
||||
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
||||
.pred.rel.mutex pUStk,pKStk
|
||||
MOV_FROM_PSR(pKStk, r22, r29) // M2 read PSR now that interrupts are disabled
|
||||
(pUStk) mov.m r22=ar.itc // M fetch time at leave
|
||||
MOV_FROM_ITC(pUStk, p9, r22, r29) // M fetch time at leave
|
||||
nop.i 0
|
||||
;;
|
||||
#else
|
||||
|
||||
@@ -25,6 +25,7 @@
|
||||
#include <asm/unistd.h>
|
||||
|
||||
#include "entry.h"
|
||||
#include "paravirt_inst.h"
|
||||
|
||||
/*
|
||||
* See Documentation/ia64/fsys.txt for details on fsyscalls.
|
||||
@@ -279,7 +280,7 @@ ENTRY(fsys_gettimeofday)
|
||||
(p9) cmp.eq p13,p0 = 0,r30 // if mmio_ptr, clear p13 jitter control
|
||||
;;
|
||||
.pred.rel.mutex p8,p9
|
||||
(p8) mov r2 = ar.itc // CPU_TIMER. 36 clocks latency!!!
|
||||
MOV_FROM_ITC(p8, p6, r2, r10) // CPU_TIMER. 36 clocks latency!!!
|
||||
(p9) ld8 r2 = [r30] // MMIO_TIMER. Could also have latency issues..
|
||||
(p13) ld8 r25 = [r19] // get itc_lastcycle value
|
||||
ld8 r9 = [r22],IA64_TIMESPEC_TV_NSEC_OFFSET // tv_sec
|
||||
@@ -418,7 +419,7 @@ EX(.fail_efault, ld8 r14=[r33]) // r14 <- *set
|
||||
mov r17=(1 << (SIGKILL - 1)) | (1 << (SIGSTOP - 1))
|
||||
;;
|
||||
|
||||
rsm psr.i // mask interrupt delivery
|
||||
RSM_PSR_I(p0, r18, r19) // mask interrupt delivery
|
||||
mov ar.ccv=0
|
||||
andcm r14=r14,r17 // filter out SIGKILL & SIGSTOP
|
||||
|
||||
@@ -491,7 +492,7 @@ EX(.fail_efault, ld8 r14=[r33]) // r14 <- *set
|
||||
#ifdef CONFIG_SMP
|
||||
st4.rel [r31]=r0 // release the lock
|
||||
#endif
|
||||
ssm psr.i
|
||||
SSM_PSR_I(p0, p9, r31)
|
||||
;;
|
||||
|
||||
srlz.d // ensure psr.i is set again
|
||||
@@ -513,7 +514,7 @@ EX(.fail_efault, (p15) st8 [r34]=r3)
|
||||
#ifdef CONFIG_SMP
|
||||
st4.rel [r31]=r0 // release the lock
|
||||
#endif
|
||||
ssm psr.i
|
||||
SSM_PSR_I(p0, p9, r17)
|
||||
;;
|
||||
srlz.d
|
||||
br.sptk.many fsys_fallback_syscall // with signal pending, do the heavy-weight syscall
|
||||
@@ -521,7 +522,7 @@ EX(.fail_efault, (p15) st8 [r34]=r3)
|
||||
#ifdef CONFIG_SMP
|
||||
.lock_contention:
|
||||
/* Rather than spinning here, fall back on doing a heavy-weight syscall. */
|
||||
ssm psr.i
|
||||
SSM_PSR_I(p0, p9, r17)
|
||||
;;
|
||||
srlz.d
|
||||
br.sptk.many fsys_fallback_syscall
|
||||
@@ -592,17 +593,17 @@ ENTRY(fsys_fallback_syscall)
|
||||
adds r17=-1024,r15
|
||||
movl r14=sys_call_table
|
||||
;;
|
||||
rsm psr.i
|
||||
RSM_PSR_I(p0, r26, r27)
|
||||
shladd r18=r17,3,r14
|
||||
;;
|
||||
ld8 r18=[r18] // load normal (heavy-weight) syscall entry-point
|
||||
mov r29=psr // read psr (12 cyc load latency)
|
||||
MOV_FROM_PSR(p0, r29, r26) // read psr (12 cyc load latency)
|
||||
mov r27=ar.rsc
|
||||
mov r21=ar.fpsr
|
||||
mov r26=ar.pfs
|
||||
END(fsys_fallback_syscall)
|
||||
/* FALL THROUGH */
|
||||
GLOBAL_ENTRY(fsys_bubble_down)
|
||||
GLOBAL_ENTRY(paravirt_fsys_bubble_down)
|
||||
.prologue
|
||||
.altrp b6
|
||||
.body
|
||||
@@ -640,7 +641,7 @@ GLOBAL_ENTRY(fsys_bubble_down)
|
||||
*
|
||||
* PSR.BE : already is turned off in __kernel_syscall_via_epc()
|
||||
* PSR.AC : don't care (kernel normally turns PSR.AC on)
|
||||
* PSR.I : already turned off by the time fsys_bubble_down gets
|
||||
* PSR.I : already turned off by the time paravirt_fsys_bubble_down gets
|
||||
* invoked
|
||||
* PSR.DFL: always 0 (kernel never turns it on)
|
||||
* PSR.DFH: don't care --- kernel never touches f32-f127 on its own
|
||||
@@ -650,7 +651,7 @@ GLOBAL_ENTRY(fsys_bubble_down)
|
||||
* PSR.DB : don't care --- kernel never enables kernel-level
|
||||
* breakpoints
|
||||
* PSR.TB : must be 0 already; if it wasn't zero on entry to
|
||||
* __kernel_syscall_via_epc, the branch to fsys_bubble_down
|
||||
* __kernel_syscall_via_epc, the branch to paravirt_fsys_bubble_down
|
||||
* will trigger a taken branch; the taken-trap-handler then
|
||||
* converts the syscall into a break-based system-call.
|
||||
*/
|
||||
@@ -683,7 +684,7 @@ GLOBAL_ENTRY(fsys_bubble_down)
|
||||
;;
|
||||
mov ar.rsc=0 // M2 set enforced lazy mode, pl 0, LE, loadrs=0
|
||||
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
||||
mov.m r30=ar.itc // M get cycle for accounting
|
||||
MOV_FROM_ITC(p0, p6, r30, r23) // M get cycle for accounting
|
||||
#else
|
||||
nop.m 0
|
||||
#endif
|
||||
@@ -734,21 +735,21 @@ GLOBAL_ENTRY(fsys_bubble_down)
|
||||
mov rp=r14 // I0 set the real return addr
|
||||
and r3=_TIF_SYSCALL_TRACEAUDIT,r3 // A
|
||||
;;
|
||||
ssm psr.i // M2 we're on kernel stacks now, reenable irqs
|
||||
SSM_PSR_I(p0, p6, r22) // M2 we're on kernel stacks now, reenable irqs
|
||||
cmp.eq p8,p0=r3,r0 // A
|
||||
(p10) br.cond.spnt.many ia64_ret_from_syscall // B return if bad call-frame or r15 is a NaT
|
||||
|
||||
nop.m 0
|
||||
(p8) br.call.sptk.many b6=b6 // B (ignore return address)
|
||||
br.cond.spnt ia64_trace_syscall // B
|
||||
END(fsys_bubble_down)
|
||||
END(paravirt_fsys_bubble_down)
|
||||
|
||||
.rodata
|
||||
.align 8
|
||||
.globl fsyscall_table
|
||||
.globl paravirt_fsyscall_table
|
||||
|
||||
data8 fsys_bubble_down
|
||||
fsyscall_table:
|
||||
data8 paravirt_fsys_bubble_down
|
||||
paravirt_fsyscall_table:
|
||||
data8 fsys_ni_syscall
|
||||
data8 0 // exit // 1025
|
||||
data8 0 // read
|
||||
@@ -1033,4 +1034,4 @@ fsyscall_table:
|
||||
|
||||
// fill in zeros for the remaining entries
|
||||
.zero:
|
||||
.space fsyscall_table + 8*NR_syscalls - .zero, 0
|
||||
.space paravirt_fsyscall_table + 8*NR_syscalls - .zero, 0
|
||||
|
||||
@@ -13,6 +13,7 @@
|
||||
#include <asm/sigcontext.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/unistd.h>
|
||||
#include "paravirt_inst.h"
|
||||
|
||||
/*
|
||||
* We can't easily refer to symbols inside the kernel. To avoid full runtime relocation,
|
||||
@@ -48,87 +49,6 @@ GLOBAL_ENTRY(__kernel_syscall_via_break)
|
||||
}
|
||||
END(__kernel_syscall_via_break)
|
||||
|
||||
/*
|
||||
* On entry:
|
||||
* r11 = saved ar.pfs
|
||||
* r15 = system call #
|
||||
* b0 = saved return address
|
||||
* b6 = return address
|
||||
* On exit:
|
||||
* r11 = saved ar.pfs
|
||||
* r15 = system call #
|
||||
* b0 = saved return address
|
||||
* all other "scratch" registers: undefined
|
||||
* all "preserved" registers: same as on entry
|
||||
*/
|
||||
|
||||
GLOBAL_ENTRY(__kernel_syscall_via_epc)
|
||||
.prologue
|
||||
.altrp b6
|
||||
.body
|
||||
{
|
||||
/*
|
||||
* Note: the kernel cannot assume that the first two instructions in this
|
||||
* bundle get executed. The remaining code must be safe even if
|
||||
* they do not get executed.
|
||||
*/
|
||||
adds r17=-1024,r15 // A
|
||||
mov r10=0 // A default to successful syscall execution
|
||||
epc // B causes split-issue
|
||||
}
|
||||
;;
|
||||
rsm psr.be | psr.i // M2 (5 cyc to srlz.d)
|
||||
LOAD_FSYSCALL_TABLE(r14) // X
|
||||
;;
|
||||
mov r16=IA64_KR(CURRENT) // M2 (12 cyc)
|
||||
shladd r18=r17,3,r14 // A
|
||||
mov r19=NR_syscalls-1 // A
|
||||
;;
|
||||
lfetch [r18] // M0|1
|
||||
mov r29=psr // M2 (12 cyc)
|
||||
// If r17 is a NaT, p6 will be zero
|
||||
cmp.geu p6,p7=r19,r17 // A (sysnr > 0 && sysnr < 1024+NR_syscalls)?
|
||||
;;
|
||||
mov r21=ar.fpsr // M2 (12 cyc)
|
||||
tnat.nz p10,p9=r15 // I0
|
||||
mov.i r26=ar.pfs // I0 (would stall anyhow due to srlz.d...)
|
||||
;;
|
||||
srlz.d // M0 (forces split-issue) ensure PSR.BE==0
|
||||
(p6) ld8 r18=[r18] // M0|1
|
||||
nop.i 0
|
||||
;;
|
||||
nop.m 0
|
||||
(p6) tbit.z.unc p8,p0=r18,0 // I0 (dual-issues with "mov b7=r18"!)
|
||||
nop.i 0
|
||||
;;
|
||||
(p8) ssm psr.i
|
||||
(p6) mov b7=r18 // I0
|
||||
(p8) br.dptk.many b7 // B
|
||||
|
||||
mov r27=ar.rsc // M2 (12 cyc)
|
||||
/*
|
||||
* brl.cond doesn't work as intended because the linker would convert this branch
|
||||
* into a branch to a PLT. Perhaps there will be a way to avoid this with some
|
||||
* future version of the linker. In the meantime, we just use an indirect branch
|
||||
* instead.
|
||||
*/
|
||||
#ifdef CONFIG_ITANIUM
|
||||
(p6) add r14=-8,r14 // r14 <- addr of fsys_bubble_down entry
|
||||
;;
|
||||
(p6) ld8 r14=[r14] // r14 <- fsys_bubble_down
|
||||
;;
|
||||
(p6) mov b7=r14
|
||||
(p6) br.sptk.many b7
|
||||
#else
|
||||
BRL_COND_FSYS_BUBBLE_DOWN(p6)
|
||||
#endif
|
||||
ssm psr.i
|
||||
mov r10=-1
|
||||
(p10) mov r8=EINVAL
|
||||
(p9) mov r8=ENOSYS
|
||||
FSYS_RETURN
|
||||
END(__kernel_syscall_via_epc)
|
||||
|
||||
# define ARG0_OFF (16 + IA64_SIGFRAME_ARG0_OFFSET)
|
||||
# define ARG1_OFF (16 + IA64_SIGFRAME_ARG1_OFFSET)
|
||||
# define ARG2_OFF (16 + IA64_SIGFRAME_ARG2_OFFSET)
|
||||
@@ -374,3 +294,92 @@ restore_rbs:
|
||||
// invala not necessary as that will happen when returning to user-mode
|
||||
br.cond.sptk back_from_restore_rbs
|
||||
END(__kernel_sigtramp)
|
||||
|
||||
/*
|
||||
* On entry:
|
||||
* r11 = saved ar.pfs
|
||||
* r15 = system call #
|
||||
* b0 = saved return address
|
||||
* b6 = return address
|
||||
* On exit:
|
||||
* r11 = saved ar.pfs
|
||||
* r15 = system call #
|
||||
* b0 = saved return address
|
||||
* all other "scratch" registers: undefined
|
||||
* all "preserved" registers: same as on entry
|
||||
*/
|
||||
|
||||
GLOBAL_ENTRY(__kernel_syscall_via_epc)
|
||||
.prologue
|
||||
.altrp b6
|
||||
.body
|
||||
{
|
||||
/*
|
||||
* Note: the kernel cannot assume that the first two instructions in this
|
||||
* bundle get executed. The remaining code must be safe even if
|
||||
* they do not get executed.
|
||||
*/
|
||||
adds r17=-1024,r15 // A
|
||||
mov r10=0 // A default to successful syscall execution
|
||||
epc // B causes split-issue
|
||||
}
|
||||
;;
|
||||
RSM_PSR_BE_I(r20, r22) // M2 (5 cyc to srlz.d)
|
||||
LOAD_FSYSCALL_TABLE(r14) // X
|
||||
;;
|
||||
mov r16=IA64_KR(CURRENT) // M2 (12 cyc)
|
||||
shladd r18=r17,3,r14 // A
|
||||
mov r19=NR_syscalls-1 // A
|
||||
;;
|
||||
lfetch [r18] // M0|1
|
||||
MOV_FROM_PSR(p0, r29, r8) // M2 (12 cyc)
|
||||
// If r17 is a NaT, p6 will be zero
|
||||
cmp.geu p6,p7=r19,r17 // A (sysnr > 0 && sysnr < 1024+NR_syscalls)?
|
||||
;;
|
||||
mov r21=ar.fpsr // M2 (12 cyc)
|
||||
tnat.nz p10,p9=r15 // I0
|
||||
mov.i r26=ar.pfs // I0 (would stall anyhow due to srlz.d...)
|
||||
;;
|
||||
srlz.d // M0 (forces split-issue) ensure PSR.BE==0
|
||||
(p6) ld8 r18=[r18] // M0|1
|
||||
nop.i 0
|
||||
;;
|
||||
nop.m 0
|
||||
(p6) tbit.z.unc p8,p0=r18,0 // I0 (dual-issues with "mov b7=r18"!)
|
||||
nop.i 0
|
||||
;;
|
||||
SSM_PSR_I(p8, p14, r25)
|
||||
(p6) mov b7=r18 // I0
|
||||
(p8) br.dptk.many b7 // B
|
||||
|
||||
mov r27=ar.rsc // M2 (12 cyc)
|
||||
/*
|
||||
* brl.cond doesn't work as intended because the linker would convert this branch
|
||||
* into a branch to a PLT. Perhaps there will be a way to avoid this with some
|
||||
* future version of the linker. In the meantime, we just use an indirect branch
|
||||
* instead.
|
||||
*/
|
||||
#ifdef CONFIG_ITANIUM
|
||||
(p6) add r14=-8,r14 // r14 <- addr of fsys_bubble_down entry
|
||||
;;
|
||||
(p6) ld8 r14=[r14] // r14 <- fsys_bubble_down
|
||||
;;
|
||||
(p6) mov b7=r14
|
||||
(p6) br.sptk.many b7
|
||||
#else
|
||||
BRL_COND_FSYS_BUBBLE_DOWN(p6)
|
||||
#endif
|
||||
SSM_PSR_I(p0, p14, r10)
|
||||
mov r10=-1
|
||||
(p10) mov r8=EINVAL
|
||||
(p9) mov r8=ENOSYS
|
||||
FSYS_RETURN
|
||||
|
||||
#ifdef CONFIG_PARAVIRT
|
||||
/*
|
||||
* padd to make the size of this symbol constant
|
||||
* independent of paravirtualization.
|
||||
*/
|
||||
.align PAGE_SIZE / 8
|
||||
#endif
|
||||
END(__kernel_syscall_via_epc)
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
|
||||
|
||||
#include <asm/system.h>
|
||||
#include "paravirt_patchlist.h"
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
@@ -33,21 +34,21 @@ SECTIONS
|
||||
. = GATE_ADDR + 0x600;
|
||||
|
||||
.data.patch : {
|
||||
__start_gate_mckinley_e9_patchlist = .;
|
||||
__paravirt_start_gate_mckinley_e9_patchlist = .;
|
||||
*(.data.patch.mckinley_e9)
|
||||
__end_gate_mckinley_e9_patchlist = .;
|
||||
__paravirt_end_gate_mckinley_e9_patchlist = .;
|
||||
|
||||
__start_gate_vtop_patchlist = .;
|
||||
__paravirt_start_gate_vtop_patchlist = .;
|
||||
*(.data.patch.vtop)
|
||||
__end_gate_vtop_patchlist = .;
|
||||
__paravirt_end_gate_vtop_patchlist = .;
|
||||
|
||||
__start_gate_fsyscall_patchlist = .;
|
||||
__paravirt_start_gate_fsyscall_patchlist = .;
|
||||
*(.data.patch.fsyscall_table)
|
||||
__end_gate_fsyscall_patchlist = .;
|
||||
__paravirt_end_gate_fsyscall_patchlist = .;
|
||||
|
||||
__start_gate_brl_fsys_bubble_down_patchlist = .;
|
||||
__paravirt_start_gate_brl_fsys_bubble_down_patchlist = .;
|
||||
*(.data.patch.brl_fsys_bubble_down)
|
||||
__end_gate_brl_fsys_bubble_down_patchlist = .;
|
||||
__paravirt_end_gate_brl_fsys_bubble_down_patchlist = .;
|
||||
} :readable
|
||||
|
||||
.IA_64.unwind_info : { *(.IA_64.unwind_info*) }
|
||||
|
||||
@@ -1050,7 +1050,7 @@ END(ia64_delay_loop)
|
||||
* except that the multiplication and the shift are done with 128-bit
|
||||
* intermediate precision so that we can produce a full 64-bit result.
|
||||
*/
|
||||
GLOBAL_ENTRY(sched_clock)
|
||||
GLOBAL_ENTRY(ia64_native_sched_clock)
|
||||
addl r8=THIS_CPU(cpu_info) + IA64_CPUINFO_NSEC_PER_CYC_OFFSET,r0
|
||||
mov.m r9=ar.itc // fetch cycle-counter (35 cyc)
|
||||
;;
|
||||
@@ -1066,7 +1066,13 @@ GLOBAL_ENTRY(sched_clock)
|
||||
;;
|
||||
shrp r8=r9,r8,IA64_NSEC_PER_CYC_SHIFT
|
||||
br.ret.sptk.many rp
|
||||
END(sched_clock)
|
||||
END(ia64_native_sched_clock)
|
||||
#ifndef CONFIG_PARAVIRT
|
||||
//unsigned long long
|
||||
//sched_clock(void) __attribute__((alias("ia64_native_sched_clock")));
|
||||
.global sched_clock
|
||||
sched_clock = ia64_native_sched_clock
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
||||
GLOBAL_ENTRY(cycle_to_cputime)
|
||||
|
||||
@@ -804,7 +804,7 @@ ENTRY(break_fault)
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
st1 [r16]=r0 // M2|3 clear current->thread.on_ustack flag
|
||||
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
||||
mov.m r30=ar.itc // M get cycle for accounting
|
||||
MOV_FROM_ITC(p0, p14, r30, r18) // M get cycle for accounting
|
||||
#else
|
||||
mov b6=r30 // I0 setup syscall handler branch reg early
|
||||
#endif
|
||||
|
||||
@@ -446,6 +446,14 @@ module_frob_arch_sections (Elf_Ehdr *ehdr, Elf_Shdr *sechdrs, char *secstrings,
|
||||
mod->arch.opd = s;
|
||||
else if (strcmp(".IA_64.unwind", secstrings + s->sh_name) == 0)
|
||||
mod->arch.unwind = s;
|
||||
#ifdef CONFIG_PARAVIRT
|
||||
else if (strcmp(".paravirt_bundles",
|
||||
secstrings + s->sh_name) == 0)
|
||||
mod->arch.paravirt_bundles = s;
|
||||
else if (strcmp(".paravirt_insts",
|
||||
secstrings + s->sh_name) == 0)
|
||||
mod->arch.paravirt_insts = s;
|
||||
#endif
|
||||
|
||||
if (!mod->arch.core_plt || !mod->arch.init_plt || !mod->arch.got || !mod->arch.opd) {
|
||||
printk(KERN_ERR "%s: sections missing\n", mod->name);
|
||||
@@ -921,6 +929,30 @@ module_finalize (const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mo
|
||||
DEBUGP("%s: init: entry=%p\n", __func__, mod->init);
|
||||
if (mod->arch.unwind)
|
||||
register_unwind_table(mod);
|
||||
#ifdef CONFIG_PARAVIRT
|
||||
if (mod->arch.paravirt_bundles) {
|
||||
struct paravirt_patch_site_bundle *start =
|
||||
(struct paravirt_patch_site_bundle *)
|
||||
mod->arch.paravirt_bundles->sh_addr;
|
||||
struct paravirt_patch_site_bundle *end =
|
||||
(struct paravirt_patch_site_bundle *)
|
||||
(mod->arch.paravirt_bundles->sh_addr +
|
||||
mod->arch.paravirt_bundles->sh_size);
|
||||
|
||||
paravirt_patch_apply_bundle(start, end);
|
||||
}
|
||||
if (mod->arch.paravirt_insts) {
|
||||
struct paravirt_patch_site_inst *start =
|
||||
(struct paravirt_patch_site_inst *)
|
||||
mod->arch.paravirt_insts->sh_addr;
|
||||
struct paravirt_patch_site_inst *end =
|
||||
(struct paravirt_patch_site_inst *)
|
||||
(mod->arch.paravirt_insts->sh_addr +
|
||||
mod->arch.paravirt_insts->sh_size);
|
||||
|
||||
paravirt_patch_apply_inst(start, end);
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -46,13 +46,23 @@ struct pv_info pv_info = {
|
||||
* initialization hooks.
|
||||
*/
|
||||
|
||||
struct pv_init_ops pv_init_ops;
|
||||
static void __init
|
||||
ia64_native_patch_branch(unsigned long tag, unsigned long type);
|
||||
|
||||
struct pv_init_ops pv_init_ops =
|
||||
{
|
||||
#ifdef ASM_SUPPORTED
|
||||
.patch_bundle = ia64_native_patch_bundle,
|
||||
#endif
|
||||
.patch_branch = ia64_native_patch_branch,
|
||||
};
|
||||
|
||||
/***************************************************************************
|
||||
* pv_cpu_ops
|
||||
* intrinsics hooks.
|
||||
*/
|
||||
|
||||
#ifndef ASM_SUPPORTED
|
||||
/* ia64_native_xxx are macros so that we have to make them real functions */
|
||||
|
||||
#define DEFINE_VOID_FUNC1(name) \
|
||||
@@ -60,7 +70,14 @@ struct pv_init_ops pv_init_ops;
|
||||
ia64_native_ ## name ## _func(unsigned long arg) \
|
||||
{ \
|
||||
ia64_native_ ## name(arg); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define DEFINE_VOID_FUNC1_VOID(name) \
|
||||
static void \
|
||||
ia64_native_ ## name ## _func(void *arg) \
|
||||
{ \
|
||||
ia64_native_ ## name(arg); \
|
||||
}
|
||||
|
||||
#define DEFINE_VOID_FUNC2(name) \
|
||||
static void \
|
||||
@@ -68,7 +85,7 @@ struct pv_init_ops pv_init_ops;
|
||||
unsigned long arg1) \
|
||||
{ \
|
||||
ia64_native_ ## name(arg0, arg1); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define DEFINE_FUNC0(name) \
|
||||
static unsigned long \
|
||||
@@ -84,7 +101,7 @@ struct pv_init_ops pv_init_ops;
|
||||
return ia64_native_ ## name(arg); \
|
||||
} \
|
||||
|
||||
DEFINE_VOID_FUNC1(fc);
|
||||
DEFINE_VOID_FUNC1_VOID(fc);
|
||||
DEFINE_VOID_FUNC1(intrin_local_irq_restore);
|
||||
|
||||
DEFINE_VOID_FUNC2(ptcga);
|
||||
@@ -274,6 +291,266 @@ ia64_native_setreg_func(int regnum, unsigned long val)
|
||||
break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
|
||||
#define __DEFINE_FUNC(name, code) \
|
||||
extern const char ia64_native_ ## name ## _direct_start[]; \
|
||||
extern const char ia64_native_ ## name ## _direct_end[]; \
|
||||
asm (".align 32\n" \
|
||||
".proc ia64_native_" #name "_func\n" \
|
||||
"ia64_native_" #name "_func:\n" \
|
||||
"ia64_native_" #name "_direct_start:\n" \
|
||||
code \
|
||||
"ia64_native_" #name "_direct_end:\n" \
|
||||
"br.cond.sptk.many b6\n" \
|
||||
".endp ia64_native_" #name "_func\n")
|
||||
|
||||
#define DEFINE_VOID_FUNC0(name, code) \
|
||||
extern void \
|
||||
ia64_native_ ## name ## _func(void); \
|
||||
__DEFINE_FUNC(name, code)
|
||||
|
||||
#define DEFINE_VOID_FUNC1(name, code) \
|
||||
extern void \
|
||||
ia64_native_ ## name ## _func(unsigned long arg); \
|
||||
__DEFINE_FUNC(name, code)
|
||||
|
||||
#define DEFINE_VOID_FUNC1_VOID(name, code) \
|
||||
extern void \
|
||||
ia64_native_ ## name ## _func(void *arg); \
|
||||
__DEFINE_FUNC(name, code)
|
||||
|
||||
#define DEFINE_VOID_FUNC2(name, code) \
|
||||
extern void \
|
||||
ia64_native_ ## name ## _func(unsigned long arg0, \
|
||||
unsigned long arg1); \
|
||||
__DEFINE_FUNC(name, code)
|
||||
|
||||
#define DEFINE_FUNC0(name, code) \
|
||||
extern unsigned long \
|
||||
ia64_native_ ## name ## _func(void); \
|
||||
__DEFINE_FUNC(name, code)
|
||||
|
||||
#define DEFINE_FUNC1(name, type, code) \
|
||||
extern unsigned long \
|
||||
ia64_native_ ## name ## _func(type arg); \
|
||||
__DEFINE_FUNC(name, code)
|
||||
|
||||
DEFINE_VOID_FUNC1_VOID(fc,
|
||||
"fc r8\n");
|
||||
DEFINE_VOID_FUNC1(intrin_local_irq_restore,
|
||||
";;\n"
|
||||
" cmp.ne p6, p7 = r8, r0\n"
|
||||
";;\n"
|
||||
"(p6) ssm psr.i\n"
|
||||
"(p7) rsm psr.i\n"
|
||||
";;\n"
|
||||
"(p6) srlz.d\n");
|
||||
|
||||
DEFINE_VOID_FUNC2(ptcga,
|
||||
"ptc.ga r8, r9\n");
|
||||
DEFINE_VOID_FUNC2(set_rr,
|
||||
"mov rr[r8] = r9\n");
|
||||
|
||||
/* ia64_native_getreg(_IA64_REG_PSR) & IA64_PSR_I */
|
||||
DEFINE_FUNC0(get_psr_i,
|
||||
"mov r2 = " __stringify(1 << IA64_PSR_I_BIT) "\n"
|
||||
"mov r8 = psr\n"
|
||||
";;\n"
|
||||
"and r8 = r2, r8\n");
|
||||
|
||||
DEFINE_FUNC1(thash, unsigned long,
|
||||
"thash r8 = r8\n");
|
||||
DEFINE_FUNC1(get_cpuid, int,
|
||||
"mov r8 = cpuid[r8]\n");
|
||||
DEFINE_FUNC1(get_pmd, int,
|
||||
"mov r8 = pmd[r8]\n");
|
||||
DEFINE_FUNC1(get_rr, unsigned long,
|
||||
"mov r8 = rr[r8]\n");
|
||||
|
||||
DEFINE_VOID_FUNC0(ssm_i,
|
||||
"ssm psr.i\n");
|
||||
DEFINE_VOID_FUNC0(rsm_i,
|
||||
"rsm psr.i\n");
|
||||
|
||||
extern void
|
||||
ia64_native_set_rr0_to_rr4_func(unsigned long val0, unsigned long val1,
|
||||
unsigned long val2, unsigned long val3,
|
||||
unsigned long val4);
|
||||
__DEFINE_FUNC(set_rr0_to_rr4,
|
||||
"mov rr[r0] = r8\n"
|
||||
"movl r2 = 0x2000000000000000\n"
|
||||
";;\n"
|
||||
"mov rr[r2] = r9\n"
|
||||
"shl r3 = r2, 1\n" /* movl r3 = 0x4000000000000000 */
|
||||
";;\n"
|
||||
"add r2 = r2, r3\n" /* movl r2 = 0x6000000000000000 */
|
||||
"mov rr[r3] = r10\n"
|
||||
";;\n"
|
||||
"mov rr[r2] = r11\n"
|
||||
"shl r3 = r3, 1\n" /* movl r3 = 0x8000000000000000 */
|
||||
";;\n"
|
||||
"mov rr[r3] = r14\n");
|
||||
|
||||
extern unsigned long ia64_native_getreg_func(int regnum);
|
||||
asm(".global ia64_native_getreg_func\n");
|
||||
#define __DEFINE_GET_REG(id, reg) \
|
||||
"mov r2 = " __stringify(_IA64_REG_ ## id) "\n" \
|
||||
";;\n" \
|
||||
"cmp.eq p6, p0 = r2, r8\n" \
|
||||
";;\n" \
|
||||
"(p6) mov r8 = " #reg "\n" \
|
||||
"(p6) br.cond.sptk.many b6\n" \
|
||||
";;\n"
|
||||
#define __DEFINE_GET_AR(id, reg) __DEFINE_GET_REG(AR_ ## id, ar.reg)
|
||||
#define __DEFINE_GET_CR(id, reg) __DEFINE_GET_REG(CR_ ## id, cr.reg)
|
||||
|
||||
__DEFINE_FUNC(getreg,
|
||||
__DEFINE_GET_REG(GP, gp)
|
||||
/*__DEFINE_GET_REG(IP, ip)*/ /* returned ip value shouldn't be constant */
|
||||
__DEFINE_GET_REG(PSR, psr)
|
||||
__DEFINE_GET_REG(TP, tp)
|
||||
__DEFINE_GET_REG(SP, sp)
|
||||
|
||||
__DEFINE_GET_REG(AR_KR0, ar0)
|
||||
__DEFINE_GET_REG(AR_KR1, ar1)
|
||||
__DEFINE_GET_REG(AR_KR2, ar2)
|
||||
__DEFINE_GET_REG(AR_KR3, ar3)
|
||||
__DEFINE_GET_REG(AR_KR4, ar4)
|
||||
__DEFINE_GET_REG(AR_KR5, ar5)
|
||||
__DEFINE_GET_REG(AR_KR6, ar6)
|
||||
__DEFINE_GET_REG(AR_KR7, ar7)
|
||||
__DEFINE_GET_AR(RSC, rsc)
|
||||
__DEFINE_GET_AR(BSP, bsp)
|
||||
__DEFINE_GET_AR(BSPSTORE, bspstore)
|
||||
__DEFINE_GET_AR(RNAT, rnat)
|
||||
__DEFINE_GET_AR(FCR, fcr)
|
||||
__DEFINE_GET_AR(EFLAG, eflag)
|
||||
__DEFINE_GET_AR(CSD, csd)
|
||||
__DEFINE_GET_AR(SSD, ssd)
|
||||
__DEFINE_GET_REG(AR_CFLAG, ar27)
|
||||
__DEFINE_GET_AR(FSR, fsr)
|
||||
__DEFINE_GET_AR(FIR, fir)
|
||||
__DEFINE_GET_AR(FDR, fdr)
|
||||
__DEFINE_GET_AR(CCV, ccv)
|
||||
__DEFINE_GET_AR(UNAT, unat)
|
||||
__DEFINE_GET_AR(FPSR, fpsr)
|
||||
__DEFINE_GET_AR(ITC, itc)
|
||||
__DEFINE_GET_AR(PFS, pfs)
|
||||
__DEFINE_GET_AR(LC, lc)
|
||||
__DEFINE_GET_AR(EC, ec)
|
||||
|
||||
__DEFINE_GET_CR(DCR, dcr)
|
||||
__DEFINE_GET_CR(ITM, itm)
|
||||
__DEFINE_GET_CR(IVA, iva)
|
||||
__DEFINE_GET_CR(PTA, pta)
|
||||
__DEFINE_GET_CR(IPSR, ipsr)
|
||||
__DEFINE_GET_CR(ISR, isr)
|
||||
__DEFINE_GET_CR(IIP, iip)
|
||||
__DEFINE_GET_CR(IFA, ifa)
|
||||
__DEFINE_GET_CR(ITIR, itir)
|
||||
__DEFINE_GET_CR(IIPA, iipa)
|
||||
__DEFINE_GET_CR(IFS, ifs)
|
||||
__DEFINE_GET_CR(IIM, iim)
|
||||
__DEFINE_GET_CR(IHA, iha)
|
||||
__DEFINE_GET_CR(LID, lid)
|
||||
__DEFINE_GET_CR(IVR, ivr)
|
||||
__DEFINE_GET_CR(TPR, tpr)
|
||||
__DEFINE_GET_CR(EOI, eoi)
|
||||
__DEFINE_GET_CR(IRR0, irr0)
|
||||
__DEFINE_GET_CR(IRR1, irr1)
|
||||
__DEFINE_GET_CR(IRR2, irr2)
|
||||
__DEFINE_GET_CR(IRR3, irr3)
|
||||
__DEFINE_GET_CR(ITV, itv)
|
||||
__DEFINE_GET_CR(PMV, pmv)
|
||||
__DEFINE_GET_CR(CMCV, cmcv)
|
||||
__DEFINE_GET_CR(LRR0, lrr0)
|
||||
__DEFINE_GET_CR(LRR1, lrr1)
|
||||
|
||||
"mov r8 = -1\n" /* unsupported case */
|
||||
);
|
||||
|
||||
extern void ia64_native_setreg_func(int regnum, unsigned long val);
|
||||
asm(".global ia64_native_setreg_func\n");
|
||||
#define __DEFINE_SET_REG(id, reg) \
|
||||
"mov r2 = " __stringify(_IA64_REG_ ## id) "\n" \
|
||||
";;\n" \
|
||||
"cmp.eq p6, p0 = r2, r9\n" \
|
||||
";;\n" \
|
||||
"(p6) mov " #reg " = r8\n" \
|
||||
"(p6) br.cond.sptk.many b6\n" \
|
||||
";;\n"
|
||||
#define __DEFINE_SET_AR(id, reg) __DEFINE_SET_REG(AR_ ## id, ar.reg)
|
||||
#define __DEFINE_SET_CR(id, reg) __DEFINE_SET_REG(CR_ ## id, cr.reg)
|
||||
__DEFINE_FUNC(setreg,
|
||||
"mov r2 = " __stringify(_IA64_REG_PSR_L) "\n"
|
||||
";;\n"
|
||||
"cmp.eq p6, p0 = r2, r9\n"
|
||||
";;\n"
|
||||
"(p6) mov psr.l = r8\n"
|
||||
#ifdef HAVE_SERIALIZE_DIRECTIVE
|
||||
".serialize.data\n"
|
||||
#endif
|
||||
"(p6) br.cond.sptk.many b6\n"
|
||||
__DEFINE_SET_REG(GP, gp)
|
||||
__DEFINE_SET_REG(SP, sp)
|
||||
|
||||
__DEFINE_SET_REG(AR_KR0, ar0)
|
||||
__DEFINE_SET_REG(AR_KR1, ar1)
|
||||
__DEFINE_SET_REG(AR_KR2, ar2)
|
||||
__DEFINE_SET_REG(AR_KR3, ar3)
|
||||
__DEFINE_SET_REG(AR_KR4, ar4)
|
||||
__DEFINE_SET_REG(AR_KR5, ar5)
|
||||
__DEFINE_SET_REG(AR_KR6, ar6)
|
||||
__DEFINE_SET_REG(AR_KR7, ar7)
|
||||
__DEFINE_SET_AR(RSC, rsc)
|
||||
__DEFINE_SET_AR(BSP, bsp)
|
||||
__DEFINE_SET_AR(BSPSTORE, bspstore)
|
||||
__DEFINE_SET_AR(RNAT, rnat)
|
||||
__DEFINE_SET_AR(FCR, fcr)
|
||||
__DEFINE_SET_AR(EFLAG, eflag)
|
||||
__DEFINE_SET_AR(CSD, csd)
|
||||
__DEFINE_SET_AR(SSD, ssd)
|
||||
__DEFINE_SET_REG(AR_CFLAG, ar27)
|
||||
__DEFINE_SET_AR(FSR, fsr)
|
||||
__DEFINE_SET_AR(FIR, fir)
|
||||
__DEFINE_SET_AR(FDR, fdr)
|
||||
__DEFINE_SET_AR(CCV, ccv)
|
||||
__DEFINE_SET_AR(UNAT, unat)
|
||||
__DEFINE_SET_AR(FPSR, fpsr)
|
||||
__DEFINE_SET_AR(ITC, itc)
|
||||
__DEFINE_SET_AR(PFS, pfs)
|
||||
__DEFINE_SET_AR(LC, lc)
|
||||
__DEFINE_SET_AR(EC, ec)
|
||||
|
||||
__DEFINE_SET_CR(DCR, dcr)
|
||||
__DEFINE_SET_CR(ITM, itm)
|
||||
__DEFINE_SET_CR(IVA, iva)
|
||||
__DEFINE_SET_CR(PTA, pta)
|
||||
__DEFINE_SET_CR(IPSR, ipsr)
|
||||
__DEFINE_SET_CR(ISR, isr)
|
||||
__DEFINE_SET_CR(IIP, iip)
|
||||
__DEFINE_SET_CR(IFA, ifa)
|
||||
__DEFINE_SET_CR(ITIR, itir)
|
||||
__DEFINE_SET_CR(IIPA, iipa)
|
||||
__DEFINE_SET_CR(IFS, ifs)
|
||||
__DEFINE_SET_CR(IIM, iim)
|
||||
__DEFINE_SET_CR(IHA, iha)
|
||||
__DEFINE_SET_CR(LID, lid)
|
||||
__DEFINE_SET_CR(IVR, ivr)
|
||||
__DEFINE_SET_CR(TPR, tpr)
|
||||
__DEFINE_SET_CR(EOI, eoi)
|
||||
__DEFINE_SET_CR(IRR0, irr0)
|
||||
__DEFINE_SET_CR(IRR1, irr1)
|
||||
__DEFINE_SET_CR(IRR2, irr2)
|
||||
__DEFINE_SET_CR(IRR3, irr3)
|
||||
__DEFINE_SET_CR(ITV, itv)
|
||||
__DEFINE_SET_CR(PMV, pmv)
|
||||
__DEFINE_SET_CR(CMCV, cmcv)
|
||||
__DEFINE_SET_CR(LRR0, lrr0)
|
||||
__DEFINE_SET_CR(LRR1, lrr1)
|
||||
);
|
||||
#endif
|
||||
|
||||
struct pv_cpu_ops pv_cpu_ops = {
|
||||
.fc = ia64_native_fc_func,
|
||||
@@ -366,4 +643,258 @@ ia64_native_do_steal_accounting(unsigned long *new_itm)
|
||||
|
||||
struct pv_time_ops pv_time_ops = {
|
||||
.do_steal_accounting = ia64_native_do_steal_accounting,
|
||||
.sched_clock = ia64_native_sched_clock,
|
||||
};
|
||||
|
||||
/***************************************************************************
|
||||
* binary pacthing
|
||||
* pv_init_ops.patch_bundle
|
||||
*/
|
||||
|
||||
#ifdef ASM_SUPPORTED
|
||||
#define IA64_NATIVE_PATCH_DEFINE_GET_REG(name, reg) \
|
||||
__DEFINE_FUNC(get_ ## name, \
|
||||
";;\n" \
|
||||
"mov r8 = " #reg "\n" \
|
||||
";;\n")
|
||||
|
||||
#define IA64_NATIVE_PATCH_DEFINE_SET_REG(name, reg) \
|
||||
__DEFINE_FUNC(set_ ## name, \
|
||||
";;\n" \
|
||||
"mov " #reg " = r8\n" \
|
||||
";;\n")
|
||||
|
||||
#define IA64_NATIVE_PATCH_DEFINE_REG(name, reg) \
|
||||
IA64_NATIVE_PATCH_DEFINE_GET_REG(name, reg); \
|
||||
IA64_NATIVE_PATCH_DEFINE_SET_REG(name, reg) \
|
||||
|
||||
#define IA64_NATIVE_PATCH_DEFINE_AR(name, reg) \
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(ar_ ## name, ar.reg)
|
||||
|
||||
#define IA64_NATIVE_PATCH_DEFINE_CR(name, reg) \
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(cr_ ## name, cr.reg)
|
||||
|
||||
|
||||
IA64_NATIVE_PATCH_DEFINE_GET_REG(psr, psr);
|
||||
IA64_NATIVE_PATCH_DEFINE_GET_REG(tp, tp);
|
||||
|
||||
/* IA64_NATIVE_PATCH_DEFINE_SET_REG(psr_l, psr.l); */
|
||||
__DEFINE_FUNC(set_psr_l,
|
||||
";;\n"
|
||||
"mov psr.l = r8\n"
|
||||
#ifdef HAVE_SERIALIZE_DIRECTIVE
|
||||
".serialize.data\n"
|
||||
#endif
|
||||
";;\n");
|
||||
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(gp, gp);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(sp, sp);
|
||||
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr0, ar0);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr1, ar1);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr2, ar2);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr3, ar3);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr4, ar4);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr5, ar5);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr6, ar6);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(kr7, ar7);
|
||||
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(rsc, rsc);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(bsp, bsp);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(bspstore, bspstore);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(rnat, rnat);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(fcr, fcr);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(eflag, eflag);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(csd, csd);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(ssd, ssd);
|
||||
IA64_NATIVE_PATCH_DEFINE_REG(ar27, ar27);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(fsr, fsr);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(fir, fir);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(fdr, fdr);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(ccv, ccv);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(unat, unat);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(fpsr, fpsr);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(itc, itc);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(pfs, pfs);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(lc, lc);
|
||||
IA64_NATIVE_PATCH_DEFINE_AR(ec, ec);
|
||||
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(dcr, dcr);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(itm, itm);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(iva, iva);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(pta, pta);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(ipsr, ipsr);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(isr, isr);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(iip, iip);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(ifa, ifa);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(itir, itir);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(iipa, iipa);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(ifs, ifs);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(iim, iim);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(iha, iha);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(lid, lid);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(ivr, ivr);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(tpr, tpr);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(eoi, eoi);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(irr0, irr0);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(irr1, irr1);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(irr2, irr2);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(irr3, irr3);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(itv, itv);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(pmv, pmv);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(cmcv, cmcv);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(lrr0, lrr0);
|
||||
IA64_NATIVE_PATCH_DEFINE_CR(lrr1, lrr1);
|
||||
|
||||
static const struct paravirt_patch_bundle_elem ia64_native_patch_bundle_elems[]
|
||||
__initdata_or_module =
|
||||
{
|
||||
#define IA64_NATIVE_PATCH_BUNDLE_ELEM(name, type) \
|
||||
{ \
|
||||
(void*)ia64_native_ ## name ## _direct_start, \
|
||||
(void*)ia64_native_ ## name ## _direct_end, \
|
||||
PARAVIRT_PATCH_TYPE_ ## type, \
|
||||
}
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(fc, FC),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(thash, THASH),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(get_cpuid, GET_CPUID),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(get_pmd, GET_PMD),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(ptcga, PTCGA),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(get_rr, GET_RR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(set_rr, SET_RR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(set_rr0_to_rr4, SET_RR0_TO_RR4),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(ssm_i, SSM_I),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(rsm_i, RSM_I),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(get_psr_i, GET_PSR_I),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM(intrin_local_irq_restore,
|
||||
INTRIN_LOCAL_IRQ_RESTORE),
|
||||
|
||||
#define IA64_NATIVE_PATCH_BUNDLE_ELEM_GETREG(name, reg) \
|
||||
{ \
|
||||
(void*)ia64_native_get_ ## name ## _direct_start, \
|
||||
(void*)ia64_native_get_ ## name ## _direct_end, \
|
||||
PARAVIRT_PATCH_TYPE_GETREG + _IA64_REG_ ## reg, \
|
||||
}
|
||||
|
||||
#define IA64_NATIVE_PATCH_BUNDLE_ELEM_SETREG(name, reg) \
|
||||
{ \
|
||||
(void*)ia64_native_set_ ## name ## _direct_start, \
|
||||
(void*)ia64_native_set_ ## name ## _direct_end, \
|
||||
PARAVIRT_PATCH_TYPE_SETREG + _IA64_REG_ ## reg, \
|
||||
}
|
||||
|
||||
#define IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(name, reg) \
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_GETREG(name, reg), \
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_SETREG(name, reg) \
|
||||
|
||||
#define IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(name, reg) \
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(ar_ ## name, AR_ ## reg)
|
||||
|
||||
#define IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(name, reg) \
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(cr_ ## name, CR_ ## reg)
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_GETREG(psr, PSR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_GETREG(tp, TP),
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_SETREG(psr_l, PSR_L),
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(gp, GP),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(sp, SP),
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr0, AR_KR0),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr1, AR_KR1),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr2, AR_KR2),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr3, AR_KR3),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr4, AR_KR4),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr5, AR_KR5),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr6, AR_KR6),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(kr7, AR_KR7),
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(rsc, RSC),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(bsp, BSP),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(bspstore, BSPSTORE),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(rnat, RNAT),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(fcr, FCR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(eflag, EFLAG),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(csd, CSD),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(ssd, SSD),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_REG(ar27, AR_CFLAG),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(fsr, FSR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(fir, FIR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(fdr, FDR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(ccv, CCV),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(unat, UNAT),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(fpsr, FPSR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(itc, ITC),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(pfs, PFS),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(lc, LC),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_AR(ec, EC),
|
||||
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(dcr, DCR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(itm, ITM),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(iva, IVA),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(pta, PTA),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(ipsr, IPSR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(isr, ISR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(iip, IIP),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(ifa, IFA),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(itir, ITIR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(iipa, IIPA),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(ifs, IFS),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(iim, IIM),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(iha, IHA),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(lid, LID),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(ivr, IVR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(tpr, TPR),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(eoi, EOI),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(irr0, IRR0),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(irr1, IRR1),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(irr2, IRR2),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(irr3, IRR3),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(itv, ITV),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(pmv, PMV),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(cmcv, CMCV),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(lrr0, LRR0),
|
||||
IA64_NATIVE_PATCH_BUNDLE_ELEM_CR(lrr1, LRR1),
|
||||
};
|
||||
|
||||
unsigned long __init_or_module
|
||||
ia64_native_patch_bundle(void *sbundle, void *ebundle, unsigned long type)
|
||||
{
|
||||
const unsigned long nelems = sizeof(ia64_native_patch_bundle_elems) /
|
||||
sizeof(ia64_native_patch_bundle_elems[0]);
|
||||
|
||||
return __paravirt_patch_apply_bundle(sbundle, ebundle, type,
|
||||
ia64_native_patch_bundle_elems,
|
||||
nelems, NULL);
|
||||
}
|
||||
#endif /* ASM_SUPPOTED */
|
||||
|
||||
extern const char ia64_native_switch_to[];
|
||||
extern const char ia64_native_leave_syscall[];
|
||||
extern const char ia64_native_work_processed_syscall[];
|
||||
extern const char ia64_native_leave_kernel[];
|
||||
|
||||
const struct paravirt_patch_branch_target ia64_native_branch_target[]
|
||||
__initconst = {
|
||||
#define PARAVIRT_BR_TARGET(name, type) \
|
||||
{ \
|
||||
ia64_native_ ## name, \
|
||||
PARAVIRT_PATCH_TYPE_BR_ ## type, \
|
||||
}
|
||||
PARAVIRT_BR_TARGET(switch_to, SWITCH_TO),
|
||||
PARAVIRT_BR_TARGET(leave_syscall, LEAVE_SYSCALL),
|
||||
PARAVIRT_BR_TARGET(work_processed_syscall, WORK_PROCESSED_SYSCALL),
|
||||
PARAVIRT_BR_TARGET(leave_kernel, LEAVE_KERNEL),
|
||||
};
|
||||
|
||||
static void __init
|
||||
ia64_native_patch_branch(unsigned long tag, unsigned long type)
|
||||
{
|
||||
const unsigned long nelem =
|
||||
sizeof(ia64_native_branch_target) /
|
||||
sizeof(ia64_native_branch_target[0]);
|
||||
__paravirt_patch_apply_branch(tag, type,
|
||||
ia64_native_branch_target, nelem);
|
||||
}
|
||||
|
||||
514
arch/ia64/kernel/paravirt_patch.c
Normal file
514
arch/ia64/kernel/paravirt_patch.c
Normal file
@@ -0,0 +1,514 @@
|
||||
/******************************************************************************
|
||||
* linux/arch/ia64/xen/paravirt_patch.c
|
||||
*
|
||||
* Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
|
||||
* VA Linux Systems Japan K.K.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <asm/intrinsics.h>
|
||||
#include <asm/kprobes.h>
|
||||
#include <asm/paravirt.h>
|
||||
#include <asm/paravirt_patch.h>
|
||||
|
||||
typedef union ia64_inst {
|
||||
struct {
|
||||
unsigned long long qp : 6;
|
||||
unsigned long long : 31;
|
||||
unsigned long long opcode : 4;
|
||||
unsigned long long reserved : 23;
|
||||
} generic;
|
||||
unsigned long long l;
|
||||
} ia64_inst_t;
|
||||
|
||||
/*
|
||||
* flush_icache_range() can't be used here.
|
||||
* we are here before cpu_init() which initializes
|
||||
* ia64_i_cache_stride_shift. flush_icache_range() uses it.
|
||||
*/
|
||||
void __init_or_module
|
||||
paravirt_flush_i_cache_range(const void *instr, unsigned long size)
|
||||
{
|
||||
extern void paravirt_fc_i(const void *addr);
|
||||
unsigned long i;
|
||||
|
||||
for (i = 0; i < size; i += sizeof(bundle_t))
|
||||
paravirt_fc_i(instr + i);
|
||||
}
|
||||
|
||||
bundle_t* __init_or_module
|
||||
paravirt_get_bundle(unsigned long tag)
|
||||
{
|
||||
return (bundle_t *)(tag & ~3UL);
|
||||
}
|
||||
|
||||
unsigned long __init_or_module
|
||||
paravirt_get_slot(unsigned long tag)
|
||||
{
|
||||
return tag & 3UL;
|
||||
}
|
||||
|
||||
unsigned long __init_or_module
|
||||
paravirt_get_num_inst(unsigned long stag, unsigned long etag)
|
||||
{
|
||||
bundle_t *sbundle = paravirt_get_bundle(stag);
|
||||
unsigned long sslot = paravirt_get_slot(stag);
|
||||
bundle_t *ebundle = paravirt_get_bundle(etag);
|
||||
unsigned long eslot = paravirt_get_slot(etag);
|
||||
|
||||
return (ebundle - sbundle) * 3 + eslot - sslot + 1;
|
||||
}
|
||||
|
||||
unsigned long __init_or_module
|
||||
paravirt_get_next_tag(unsigned long tag)
|
||||
{
|
||||
unsigned long slot = paravirt_get_slot(tag);
|
||||
|
||||
switch (slot) {
|
||||
case 0:
|
||||
case 1:
|
||||
return tag + 1;
|
||||
case 2: {
|
||||
bundle_t *bundle = paravirt_get_bundle(tag);
|
||||
return (unsigned long)(bundle + 1);
|
||||
}
|
||||
default:
|
||||
BUG();
|
||||
}
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
ia64_inst_t __init_or_module
|
||||
paravirt_read_slot0(const bundle_t *bundle)
|
||||
{
|
||||
ia64_inst_t inst;
|
||||
inst.l = bundle->quad0.slot0;
|
||||
return inst;
|
||||
}
|
||||
|
||||
ia64_inst_t __init_or_module
|
||||
paravirt_read_slot1(const bundle_t *bundle)
|
||||
{
|
||||
ia64_inst_t inst;
|
||||
inst.l = bundle->quad0.slot1_p0 |
|
||||
((unsigned long long)bundle->quad1.slot1_p1 << 18UL);
|
||||
return inst;
|
||||
}
|
||||
|
||||
ia64_inst_t __init_or_module
|
||||
paravirt_read_slot2(const bundle_t *bundle)
|
||||
{
|
||||
ia64_inst_t inst;
|
||||
inst.l = bundle->quad1.slot2;
|
||||
return inst;
|
||||
}
|
||||
|
||||
ia64_inst_t __init_or_module
|
||||
paravirt_read_inst(unsigned long tag)
|
||||
{
|
||||
bundle_t *bundle = paravirt_get_bundle(tag);
|
||||
unsigned long slot = paravirt_get_slot(tag);
|
||||
|
||||
switch (slot) {
|
||||
case 0:
|
||||
return paravirt_read_slot0(bundle);
|
||||
case 1:
|
||||
return paravirt_read_slot1(bundle);
|
||||
case 2:
|
||||
return paravirt_read_slot2(bundle);
|
||||
default:
|
||||
BUG();
|
||||
}
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
void __init_or_module
|
||||
paravirt_write_slot0(bundle_t *bundle, ia64_inst_t inst)
|
||||
{
|
||||
bundle->quad0.slot0 = inst.l;
|
||||
}
|
||||
|
||||
void __init_or_module
|
||||
paravirt_write_slot1(bundle_t *bundle, ia64_inst_t inst)
|
||||
{
|
||||
bundle->quad0.slot1_p0 = inst.l;
|
||||
bundle->quad1.slot1_p1 = inst.l >> 18UL;
|
||||
}
|
||||
|
||||
void __init_or_module
|
||||
paravirt_write_slot2(bundle_t *bundle, ia64_inst_t inst)
|
||||
{
|
||||
bundle->quad1.slot2 = inst.l;
|
||||
}
|
||||
|
||||
void __init_or_module
|
||||
paravirt_write_inst(unsigned long tag, ia64_inst_t inst)
|
||||
{
|
||||
bundle_t *bundle = paravirt_get_bundle(tag);
|
||||
unsigned long slot = paravirt_get_slot(tag);
|
||||
|
||||
switch (slot) {
|
||||
case 0:
|
||||
paravirt_write_slot0(bundle, inst);
|
||||
break;
|
||||
case 1:
|
||||
paravirt_write_slot1(bundle, inst);
|
||||
break;
|
||||
case 2:
|
||||
paravirt_write_slot2(bundle, inst);
|
||||
break;
|
||||
default:
|
||||
BUG();
|
||||
break;
|
||||
}
|
||||
paravirt_flush_i_cache_range(bundle, sizeof(*bundle));
|
||||
}
|
||||
|
||||
/* for debug */
|
||||
void
|
||||
paravirt_print_bundle(const bundle_t *bundle)
|
||||
{
|
||||
const unsigned long *quad = (const unsigned long *)bundle;
|
||||
ia64_inst_t slot0 = paravirt_read_slot0(bundle);
|
||||
ia64_inst_t slot1 = paravirt_read_slot1(bundle);
|
||||
ia64_inst_t slot2 = paravirt_read_slot2(bundle);
|
||||
|
||||
printk(KERN_DEBUG
|
||||
"bundle 0x%p 0x%016lx 0x%016lx\n", bundle, quad[0], quad[1]);
|
||||
printk(KERN_DEBUG
|
||||
"bundle template 0x%x\n",
|
||||
bundle->quad0.template);
|
||||
printk(KERN_DEBUG
|
||||
"slot0 0x%lx slot1_p0 0x%lx slot1_p1 0x%lx slot2 0x%lx\n",
|
||||
(unsigned long)bundle->quad0.slot0,
|
||||
(unsigned long)bundle->quad0.slot1_p0,
|
||||
(unsigned long)bundle->quad1.slot1_p1,
|
||||
(unsigned long)bundle->quad1.slot2);
|
||||
printk(KERN_DEBUG
|
||||
"slot0 0x%016llx slot1 0x%016llx slot2 0x%016llx\n",
|
||||
slot0.l, slot1.l, slot2.l);
|
||||
}
|
||||
|
||||
static int noreplace_paravirt __init_or_module = 0;
|
||||
|
||||
static int __init setup_noreplace_paravirt(char *str)
|
||||
{
|
||||
noreplace_paravirt = 1;
|
||||
return 1;
|
||||
}
|
||||
__setup("noreplace-paravirt", setup_noreplace_paravirt);
|
||||
|
||||
#ifdef ASM_SUPPORTED
|
||||
static void __init_or_module
|
||||
fill_nop_bundle(void *sbundle, void *ebundle)
|
||||
{
|
||||
extern const char paravirt_nop_bundle[];
|
||||
extern const unsigned long paravirt_nop_bundle_size;
|
||||
|
||||
void *bundle = sbundle;
|
||||
|
||||
BUG_ON((((unsigned long)sbundle) % sizeof(bundle_t)) != 0);
|
||||
BUG_ON((((unsigned long)ebundle) % sizeof(bundle_t)) != 0);
|
||||
|
||||
while (bundle < ebundle) {
|
||||
memcpy(bundle, paravirt_nop_bundle, paravirt_nop_bundle_size);
|
||||
|
||||
bundle += paravirt_nop_bundle_size;
|
||||
}
|
||||
}
|
||||
|
||||
/* helper function */
|
||||
unsigned long __init_or_module
|
||||
__paravirt_patch_apply_bundle(void *sbundle, void *ebundle, unsigned long type,
|
||||
const struct paravirt_patch_bundle_elem *elems,
|
||||
unsigned long nelems,
|
||||
const struct paravirt_patch_bundle_elem **found)
|
||||
{
|
||||
unsigned long used = 0;
|
||||
unsigned long i;
|
||||
|
||||
BUG_ON((((unsigned long)sbundle) % sizeof(bundle_t)) != 0);
|
||||
BUG_ON((((unsigned long)ebundle) % sizeof(bundle_t)) != 0);
|
||||
|
||||
found = NULL;
|
||||
for (i = 0; i < nelems; i++) {
|
||||
const struct paravirt_patch_bundle_elem *p = &elems[i];
|
||||
if (p->type == type) {
|
||||
unsigned long need = p->ebundle - p->sbundle;
|
||||
unsigned long room = ebundle - sbundle;
|
||||
|
||||
if (found != NULL)
|
||||
*found = p;
|
||||
|
||||
if (room < need) {
|
||||
/* no room to replace. skip it */
|
||||
printk(KERN_DEBUG
|
||||
"the space is too small to put "
|
||||
"bundles. type %ld need %ld room %ld\n",
|
||||
type, need, room);
|
||||
break;
|
||||
}
|
||||
|
||||
used = need;
|
||||
memcpy(sbundle, p->sbundle, used);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return used;
|
||||
}
|
||||
|
||||
void __init_or_module
|
||||
paravirt_patch_apply_bundle(const struct paravirt_patch_site_bundle *start,
|
||||
const struct paravirt_patch_site_bundle *end)
|
||||
{
|
||||
const struct paravirt_patch_site_bundle *p;
|
||||
|
||||
if (noreplace_paravirt)
|
||||
return;
|
||||
if (pv_init_ops.patch_bundle == NULL)
|
||||
return;
|
||||
|
||||
for (p = start; p < end; p++) {
|
||||
unsigned long used;
|
||||
|
||||
used = (*pv_init_ops.patch_bundle)(p->sbundle, p->ebundle,
|
||||
p->type);
|
||||
if (used == 0)
|
||||
continue;
|
||||
|
||||
fill_nop_bundle(p->sbundle + used, p->ebundle);
|
||||
paravirt_flush_i_cache_range(p->sbundle,
|
||||
p->ebundle - p->sbundle);
|
||||
}
|
||||
ia64_sync_i();
|
||||
ia64_srlz_i();
|
||||
}
|
||||
|
||||
/*
|
||||
* nop.i, nop.m, nop.f instruction are same format.
|
||||
* but nop.b has differennt format.
|
||||
* This doesn't support nop.b for now.
|
||||
*/
|
||||
static void __init_or_module
|
||||
fill_nop_inst(unsigned long stag, unsigned long etag)
|
||||
{
|
||||
extern const bundle_t paravirt_nop_mfi_inst_bundle[];
|
||||
unsigned long tag;
|
||||
const ia64_inst_t nop_inst =
|
||||
paravirt_read_slot0(paravirt_nop_mfi_inst_bundle);
|
||||
|
||||
for (tag = stag; tag < etag; tag = paravirt_get_next_tag(tag))
|
||||
paravirt_write_inst(tag, nop_inst);
|
||||
}
|
||||
|
||||
void __init_or_module
|
||||
paravirt_patch_apply_inst(const struct paravirt_patch_site_inst *start,
|
||||
const struct paravirt_patch_site_inst *end)
|
||||
{
|
||||
const struct paravirt_patch_site_inst *p;
|
||||
|
||||
if (noreplace_paravirt)
|
||||
return;
|
||||
if (pv_init_ops.patch_inst == NULL)
|
||||
return;
|
||||
|
||||
for (p = start; p < end; p++) {
|
||||
unsigned long tag;
|
||||
bundle_t *sbundle;
|
||||
bundle_t *ebundle;
|
||||
|
||||
tag = (*pv_init_ops.patch_inst)(p->stag, p->etag, p->type);
|
||||
if (tag == p->stag)
|
||||
continue;
|
||||
|
||||
fill_nop_inst(tag, p->etag);
|
||||
sbundle = paravirt_get_bundle(p->stag);
|
||||
ebundle = paravirt_get_bundle(p->etag) + 1;
|
||||
paravirt_flush_i_cache_range(sbundle, (ebundle - sbundle) *
|
||||
sizeof(bundle_t));
|
||||
}
|
||||
ia64_sync_i();
|
||||
ia64_srlz_i();
|
||||
}
|
||||
#endif /* ASM_SUPPOTED */
|
||||
|
||||
/* brl.cond.sptk.many <target64> X3 */
|
||||
typedef union inst_x3_op {
|
||||
ia64_inst_t inst;
|
||||
struct {
|
||||
unsigned long qp: 6;
|
||||
unsigned long btyp: 3;
|
||||
unsigned long unused: 3;
|
||||
unsigned long p: 1;
|
||||
unsigned long imm20b: 20;
|
||||
unsigned long wh: 2;
|
||||
unsigned long d: 1;
|
||||
unsigned long i: 1;
|
||||
unsigned long opcode: 4;
|
||||
};
|
||||
unsigned long l;
|
||||
} inst_x3_op_t;
|
||||
|
||||
typedef union inst_x3_imm {
|
||||
ia64_inst_t inst;
|
||||
struct {
|
||||
unsigned long unused: 2;
|
||||
unsigned long imm39: 39;
|
||||
};
|
||||
unsigned long l;
|
||||
} inst_x3_imm_t;
|
||||
|
||||
void __init_or_module
|
||||
paravirt_patch_reloc_brl(unsigned long tag, const void *target)
|
||||
{
|
||||
unsigned long tag_op = paravirt_get_next_tag(tag);
|
||||
unsigned long tag_imm = tag;
|
||||
bundle_t *bundle = paravirt_get_bundle(tag);
|
||||
|
||||
ia64_inst_t inst_op = paravirt_read_inst(tag_op);
|
||||
ia64_inst_t inst_imm = paravirt_read_inst(tag_imm);
|
||||
|
||||
inst_x3_op_t inst_x3_op = { .l = inst_op.l };
|
||||
inst_x3_imm_t inst_x3_imm = { .l = inst_imm.l };
|
||||
|
||||
unsigned long imm60 =
|
||||
((unsigned long)target - (unsigned long)bundle) >> 4;
|
||||
|
||||
BUG_ON(paravirt_get_slot(tag) != 1); /* MLX */
|
||||
BUG_ON(((unsigned long)target & (sizeof(bundle_t) - 1)) != 0);
|
||||
|
||||
/* imm60[59] 1bit */
|
||||
inst_x3_op.i = (imm60 >> 59) & 1;
|
||||
/* imm60[19:0] 20bit */
|
||||
inst_x3_op.imm20b = imm60 & ((1UL << 20) - 1);
|
||||
/* imm60[58:20] 39bit */
|
||||
inst_x3_imm.imm39 = (imm60 >> 20) & ((1UL << 39) - 1);
|
||||
|
||||
inst_op.l = inst_x3_op.l;
|
||||
inst_imm.l = inst_x3_imm.l;
|
||||
|
||||
paravirt_write_inst(tag_op, inst_op);
|
||||
paravirt_write_inst(tag_imm, inst_imm);
|
||||
}
|
||||
|
||||
/* br.cond.sptk.many <target25> B1 */
|
||||
typedef union inst_b1 {
|
||||
ia64_inst_t inst;
|
||||
struct {
|
||||
unsigned long qp: 6;
|
||||
unsigned long btype: 3;
|
||||
unsigned long unused: 3;
|
||||
unsigned long p: 1;
|
||||
unsigned long imm20b: 20;
|
||||
unsigned long wh: 2;
|
||||
unsigned long d: 1;
|
||||
unsigned long s: 1;
|
||||
unsigned long opcode: 4;
|
||||
};
|
||||
unsigned long l;
|
||||
} inst_b1_t;
|
||||
|
||||
void __init
|
||||
paravirt_patch_reloc_br(unsigned long tag, const void *target)
|
||||
{
|
||||
bundle_t *bundle = paravirt_get_bundle(tag);
|
||||
ia64_inst_t inst = paravirt_read_inst(tag);
|
||||
unsigned long target25 = (unsigned long)target - (unsigned long)bundle;
|
||||
inst_b1_t inst_b1;
|
||||
|
||||
BUG_ON(((unsigned long)target & (sizeof(bundle_t) - 1)) != 0);
|
||||
|
||||
inst_b1.l = inst.l;
|
||||
if (target25 & (1UL << 63))
|
||||
inst_b1.s = 1;
|
||||
else
|
||||
inst_b1.s = 0;
|
||||
|
||||
inst_b1.imm20b = target25 >> 4;
|
||||
inst.l = inst_b1.l;
|
||||
|
||||
paravirt_write_inst(tag, inst);
|
||||
}
|
||||
|
||||
void __init
|
||||
__paravirt_patch_apply_branch(
|
||||
unsigned long tag, unsigned long type,
|
||||
const struct paravirt_patch_branch_target *entries,
|
||||
unsigned int nr_entries)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; i < nr_entries; i++) {
|
||||
if (entries[i].type == type) {
|
||||
paravirt_patch_reloc_br(tag, entries[i].entry);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void __init
|
||||
paravirt_patch_apply_branch(const struct paravirt_patch_site_branch *start,
|
||||
const struct paravirt_patch_site_branch *end)
|
||||
{
|
||||
const struct paravirt_patch_site_branch *p;
|
||||
|
||||
if (noreplace_paravirt)
|
||||
return;
|
||||
if (pv_init_ops.patch_branch == NULL)
|
||||
return;
|
||||
|
||||
for (p = start; p < end; p++)
|
||||
(*pv_init_ops.patch_branch)(p->tag, p->type);
|
||||
|
||||
ia64_sync_i();
|
||||
ia64_srlz_i();
|
||||
}
|
||||
|
||||
void __init
|
||||
paravirt_patch_apply(void)
|
||||
{
|
||||
extern const char __start_paravirt_bundles[];
|
||||
extern const char __stop_paravirt_bundles[];
|
||||
extern const char __start_paravirt_insts[];
|
||||
extern const char __stop_paravirt_insts[];
|
||||
extern const char __start_paravirt_branches[];
|
||||
extern const char __stop_paravirt_branches[];
|
||||
|
||||
paravirt_patch_apply_bundle((const struct paravirt_patch_site_bundle *)
|
||||
__start_paravirt_bundles,
|
||||
(const struct paravirt_patch_site_bundle *)
|
||||
__stop_paravirt_bundles);
|
||||
paravirt_patch_apply_inst((const struct paravirt_patch_site_inst *)
|
||||
__start_paravirt_insts,
|
||||
(const struct paravirt_patch_site_inst *)
|
||||
__stop_paravirt_insts);
|
||||
paravirt_patch_apply_branch((const struct paravirt_patch_site_branch *)
|
||||
__start_paravirt_branches,
|
||||
(const struct paravirt_patch_site_branch *)
|
||||
__stop_paravirt_branches);
|
||||
}
|
||||
|
||||
/*
|
||||
* Local variables:
|
||||
* mode: C
|
||||
* c-set-style: "linux"
|
||||
* c-basic-offset: 8
|
||||
* tab-width: 8
|
||||
* indent-tabs-mode: t
|
||||
* End:
|
||||
*/
|
||||
79
arch/ia64/kernel/paravirt_patchlist.c
Normal file
79
arch/ia64/kernel/paravirt_patchlist.c
Normal file
@@ -0,0 +1,79 @@
|
||||
/******************************************************************************
|
||||
* Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
|
||||
* VA Linux Systems Japan K.K.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/bug.h>
|
||||
#include <asm/paravirt.h>
|
||||
|
||||
#define DECLARE(name) \
|
||||
extern unsigned long \
|
||||
__ia64_native_start_gate_##name##_patchlist[]; \
|
||||
extern unsigned long \
|
||||
__ia64_native_end_gate_##name##_patchlist[]
|
||||
|
||||
DECLARE(fsyscall);
|
||||
DECLARE(brl_fsys_bubble_down);
|
||||
DECLARE(vtop);
|
||||
DECLARE(mckinley_e9);
|
||||
|
||||
extern unsigned long __start_gate_section[];
|
||||
|
||||
#define ASSIGN(name) \
|
||||
.start_##name##_patchlist = \
|
||||
(unsigned long)__ia64_native_start_gate_##name##_patchlist, \
|
||||
.end_##name##_patchlist = \
|
||||
(unsigned long)__ia64_native_end_gate_##name##_patchlist
|
||||
|
||||
struct pv_patchdata pv_patchdata __initdata = {
|
||||
ASSIGN(fsyscall),
|
||||
ASSIGN(brl_fsys_bubble_down),
|
||||
ASSIGN(vtop),
|
||||
ASSIGN(mckinley_e9),
|
||||
|
||||
.gate_section = (void*)__start_gate_section,
|
||||
};
|
||||
|
||||
|
||||
unsigned long __init
|
||||
paravirt_get_gate_patchlist(enum pv_gate_patchlist type)
|
||||
{
|
||||
|
||||
#define CASE(NAME, name) \
|
||||
case PV_GATE_START_##NAME: \
|
||||
return pv_patchdata.start_##name##_patchlist; \
|
||||
case PV_GATE_END_##NAME: \
|
||||
return pv_patchdata.end_##name##_patchlist; \
|
||||
|
||||
switch (type) {
|
||||
CASE(FSYSCALL, fsyscall);
|
||||
CASE(BRL_FSYS_BUBBLE_DOWN, brl_fsys_bubble_down);
|
||||
CASE(VTOP, vtop);
|
||||
CASE(MCKINLEY_E9, mckinley_e9);
|
||||
default:
|
||||
BUG();
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void * __init
|
||||
paravirt_get_gate_section(void)
|
||||
{
|
||||
return pv_patchdata.gate_section;
|
||||
}
|
||||
28
arch/ia64/kernel/paravirt_patchlist.h
Normal file
28
arch/ia64/kernel/paravirt_patchlist.h
Normal file
@@ -0,0 +1,28 @@
|
||||
/******************************************************************************
|
||||
* linux/arch/ia64/xen/paravirt_patchlist.h
|
||||
*
|
||||
* Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
|
||||
* VA Linux Systems Japan K.K.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#if defined(__IA64_GATE_PARAVIRTUALIZED_XEN)
|
||||
#include <asm/xen/patchlist.h>
|
||||
#else
|
||||
#include <asm/native/patchlist.h>
|
||||
#endif
|
||||
|
||||
@@ -20,8 +20,11 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <asm/asmmacro.h>
|
||||
#include <asm/asm-offsets.h>
|
||||
#include <asm/paravirt_privop.h>
|
||||
#include <asm/paravirt_patch.h>
|
||||
#include "entry.h"
|
||||
|
||||
#define DATA8(sym, init_value) \
|
||||
@@ -32,29 +35,87 @@
|
||||
data8 init_value ; \
|
||||
.popsection
|
||||
|
||||
#define BRANCH(targ, reg, breg) \
|
||||
movl reg=targ ; \
|
||||
;; \
|
||||
ld8 reg=[reg] ; \
|
||||
;; \
|
||||
mov breg=reg ; \
|
||||
#define BRANCH(targ, reg, breg, type) \
|
||||
PARAVIRT_PATCH_SITE_BR(PARAVIRT_PATCH_TYPE_BR_ ## type) ; \
|
||||
;; \
|
||||
movl reg=targ ; \
|
||||
;; \
|
||||
ld8 reg=[reg] ; \
|
||||
;; \
|
||||
mov breg=reg ; \
|
||||
br.cond.sptk.many breg
|
||||
|
||||
#define BRANCH_PROC(sym, reg, breg) \
|
||||
DATA8(paravirt_ ## sym ## _targ, ia64_native_ ## sym) ; \
|
||||
GLOBAL_ENTRY(paravirt_ ## sym) ; \
|
||||
BRANCH(paravirt_ ## sym ## _targ, reg, breg) ; \
|
||||
#define BRANCH_PROC(sym, reg, breg, type) \
|
||||
DATA8(paravirt_ ## sym ## _targ, ia64_native_ ## sym) ; \
|
||||
GLOBAL_ENTRY(paravirt_ ## sym) ; \
|
||||
BRANCH(paravirt_ ## sym ## _targ, reg, breg, type) ; \
|
||||
END(paravirt_ ## sym)
|
||||
|
||||
#define BRANCH_PROC_UNWINFO(sym, reg, breg) \
|
||||
DATA8(paravirt_ ## sym ## _targ, ia64_native_ ## sym) ; \
|
||||
GLOBAL_ENTRY(paravirt_ ## sym) ; \
|
||||
PT_REGS_UNWIND_INFO(0) ; \
|
||||
BRANCH(paravirt_ ## sym ## _targ, reg, breg) ; \
|
||||
#define BRANCH_PROC_UNWINFO(sym, reg, breg, type) \
|
||||
DATA8(paravirt_ ## sym ## _targ, ia64_native_ ## sym) ; \
|
||||
GLOBAL_ENTRY(paravirt_ ## sym) ; \
|
||||
PT_REGS_UNWIND_INFO(0) ; \
|
||||
BRANCH(paravirt_ ## sym ## _targ, reg, breg, type) ; \
|
||||
END(paravirt_ ## sym)
|
||||
|
||||
|
||||
BRANCH_PROC(switch_to, r22, b7)
|
||||
BRANCH_PROC_UNWINFO(leave_syscall, r22, b7)
|
||||
BRANCH_PROC(work_processed_syscall, r2, b7)
|
||||
BRANCH_PROC_UNWINFO(leave_kernel, r22, b7)
|
||||
BRANCH_PROC(switch_to, r22, b7, SWITCH_TO)
|
||||
BRANCH_PROC_UNWINFO(leave_syscall, r22, b7, LEAVE_SYSCALL)
|
||||
BRANCH_PROC(work_processed_syscall, r2, b7, WORK_PROCESSED_SYSCALL)
|
||||
BRANCH_PROC_UNWINFO(leave_kernel, r22, b7, LEAVE_KERNEL)
|
||||
|
||||
|
||||
#ifdef CONFIG_MODULES
|
||||
#define __INIT_OR_MODULE .text
|
||||
#define __INITDATA_OR_MODULE .data
|
||||
#else
|
||||
#define __INIT_OR_MODULE __INIT
|
||||
#define __INITDATA_OR_MODULE __INITDATA
|
||||
#endif /* CONFIG_MODULES */
|
||||
|
||||
__INIT_OR_MODULE
|
||||
GLOBAL_ENTRY(paravirt_fc_i)
|
||||
fc.i r32
|
||||
br.ret.sptk.many rp
|
||||
END(paravirt_fc_i)
|
||||
__FINIT
|
||||
|
||||
__INIT_OR_MODULE
|
||||
.align 32
|
||||
GLOBAL_ENTRY(paravirt_nop_b_inst_bundle)
|
||||
{
|
||||
nop.b 0
|
||||
nop.b 0
|
||||
nop.b 0
|
||||
}
|
||||
END(paravirt_nop_b_inst_bundle)
|
||||
__FINIT
|
||||
|
||||
/* NOTE: nop.[mfi] has same format */
|
||||
__INIT_OR_MODULE
|
||||
GLOBAL_ENTRY(paravirt_nop_mfi_inst_bundle)
|
||||
{
|
||||
nop.m 0
|
||||
nop.f 0
|
||||
nop.i 0
|
||||
}
|
||||
END(paravirt_nop_mfi_inst_bundle)
|
||||
__FINIT
|
||||
|
||||
__INIT_OR_MODULE
|
||||
GLOBAL_ENTRY(paravirt_nop_bundle)
|
||||
paravirt_nop_bundle_start:
|
||||
{
|
||||
nop 0
|
||||
nop 0
|
||||
nop 0
|
||||
}
|
||||
paravirt_nop_bundle_end:
|
||||
END(paravirt_nop_bundle)
|
||||
__FINIT
|
||||
|
||||
__INITDATA_OR_MODULE
|
||||
.align 8
|
||||
.global paravirt_nop_bundle_size
|
||||
paravirt_nop_bundle_size:
|
||||
data8 paravirt_nop_bundle_end - paravirt_nop_bundle_start
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#include <linux/init.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
#include <asm/paravirt.h>
|
||||
#include <asm/patch.h>
|
||||
#include <asm/processor.h>
|
||||
#include <asm/sections.h>
|
||||
@@ -169,16 +170,35 @@ ia64_patch_mckinley_e9 (unsigned long start, unsigned long end)
|
||||
ia64_srlz_i();
|
||||
}
|
||||
|
||||
extern unsigned long ia64_native_fsyscall_table[NR_syscalls];
|
||||
extern char ia64_native_fsys_bubble_down[];
|
||||
struct pv_fsys_data pv_fsys_data __initdata = {
|
||||
.fsyscall_table = (unsigned long *)ia64_native_fsyscall_table,
|
||||
.fsys_bubble_down = (void *)ia64_native_fsys_bubble_down,
|
||||
};
|
||||
|
||||
unsigned long * __init
|
||||
paravirt_get_fsyscall_table(void)
|
||||
{
|
||||
return pv_fsys_data.fsyscall_table;
|
||||
}
|
||||
|
||||
char * __init
|
||||
paravirt_get_fsys_bubble_down(void)
|
||||
{
|
||||
return pv_fsys_data.fsys_bubble_down;
|
||||
}
|
||||
|
||||
static void __init
|
||||
patch_fsyscall_table (unsigned long start, unsigned long end)
|
||||
{
|
||||
extern unsigned long fsyscall_table[NR_syscalls];
|
||||
u64 fsyscall_table = (u64)paravirt_get_fsyscall_table();
|
||||
s32 *offp = (s32 *) start;
|
||||
u64 ip;
|
||||
|
||||
while (offp < (s32 *) end) {
|
||||
ip = (u64) ia64_imva((char *) offp + *offp);
|
||||
ia64_patch_imm64(ip, (u64) fsyscall_table);
|
||||
ia64_patch_imm64(ip, fsyscall_table);
|
||||
ia64_fc((void *) ip);
|
||||
++offp;
|
||||
}
|
||||
@@ -189,7 +209,7 @@ patch_fsyscall_table (unsigned long start, unsigned long end)
|
||||
static void __init
|
||||
patch_brl_fsys_bubble_down (unsigned long start, unsigned long end)
|
||||
{
|
||||
extern char fsys_bubble_down[];
|
||||
u64 fsys_bubble_down = (u64)paravirt_get_fsys_bubble_down();
|
||||
s32 *offp = (s32 *) start;
|
||||
u64 ip;
|
||||
|
||||
@@ -207,13 +227,13 @@ patch_brl_fsys_bubble_down (unsigned long start, unsigned long end)
|
||||
void __init
|
||||
ia64_patch_gate (void)
|
||||
{
|
||||
# define START(name) ((unsigned long) __start_gate_##name##_patchlist)
|
||||
# define END(name) ((unsigned long)__end_gate_##name##_patchlist)
|
||||
# define START(name) paravirt_get_gate_patchlist(PV_GATE_START_##name)
|
||||
# define END(name) paravirt_get_gate_patchlist(PV_GATE_END_##name)
|
||||
|
||||
patch_fsyscall_table(START(fsyscall), END(fsyscall));
|
||||
patch_brl_fsys_bubble_down(START(brl_fsys_bubble_down), END(brl_fsys_bubble_down));
|
||||
ia64_patch_vtop(START(vtop), END(vtop));
|
||||
ia64_patch_mckinley_e9(START(mckinley_e9), END(mckinley_e9));
|
||||
patch_fsyscall_table(START(FSYSCALL), END(FSYSCALL));
|
||||
patch_brl_fsys_bubble_down(START(BRL_FSYS_BUBBLE_DOWN), END(BRL_FSYS_BUBBLE_DOWN));
|
||||
ia64_patch_vtop(START(VTOP), END(VTOP));
|
||||
ia64_patch_mckinley_e9(START(MCKINLEY_E9), END(MCKINLEY_E9));
|
||||
}
|
||||
|
||||
void ia64_patch_phys_stack_reg(unsigned long val)
|
||||
@@ -229,7 +249,7 @@ void ia64_patch_phys_stack_reg(unsigned long val)
|
||||
while (offp < end) {
|
||||
ip = (u64) offp + *offp;
|
||||
ia64_patch(ip, mask, imm);
|
||||
ia64_fc(ip);
|
||||
ia64_fc((void *)ip);
|
||||
++offp;
|
||||
}
|
||||
ia64_sync_i();
|
||||
|
||||
@@ -52,6 +52,7 @@
|
||||
#include <asm/meminit.h>
|
||||
#include <asm/page.h>
|
||||
#include <asm/paravirt.h>
|
||||
#include <asm/paravirt_patch.h>
|
||||
#include <asm/patch.h>
|
||||
#include <asm/pgtable.h>
|
||||
#include <asm/processor.h>
|
||||
@@ -537,6 +538,7 @@ setup_arch (char **cmdline_p)
|
||||
paravirt_arch_setup_early();
|
||||
|
||||
ia64_patch_vtop((u64) __start___vtop_patchlist, (u64) __end___vtop_patchlist);
|
||||
paravirt_patch_apply();
|
||||
|
||||
*cmdline_p = __va(ia64_boot_param->command_line);
|
||||
strlcpy(boot_command_line, *cmdline_p, COMMAND_LINE_SIZE);
|
||||
|
||||
@@ -49,6 +49,15 @@ EXPORT_SYMBOL(last_cli_ip);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_PARAVIRT
|
||||
/* We need to define a real function for sched_clock, to override the
|
||||
weak default version */
|
||||
unsigned long long sched_clock(void)
|
||||
{
|
||||
return paravirt_sched_clock();
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_PARAVIRT
|
||||
static void
|
||||
paravirt_clocksource_resume(void)
|
||||
|
||||
@@ -169,6 +169,30 @@ SECTIONS
|
||||
__end___mckinley_e9_bundles = .;
|
||||
}
|
||||
|
||||
#if defined(CONFIG_PARAVIRT)
|
||||
. = ALIGN(16);
|
||||
.paravirt_bundles : AT(ADDR(.paravirt_bundles) - LOAD_OFFSET)
|
||||
{
|
||||
__start_paravirt_bundles = .;
|
||||
*(.paravirt_bundles)
|
||||
__stop_paravirt_bundles = .;
|
||||
}
|
||||
. = ALIGN(16);
|
||||
.paravirt_insts : AT(ADDR(.paravirt_insts) - LOAD_OFFSET)
|
||||
{
|
||||
__start_paravirt_insts = .;
|
||||
*(.paravirt_insts)
|
||||
__stop_paravirt_insts = .;
|
||||
}
|
||||
. = ALIGN(16);
|
||||
.paravirt_branches : AT(ADDR(.paravirt_branches) - LOAD_OFFSET)
|
||||
{
|
||||
__start_paravirt_branches = .;
|
||||
*(.paravirt_branches)
|
||||
__stop_paravirt_branches = .;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(CONFIG_IA64_GENERIC)
|
||||
/* Machine Vector */
|
||||
. = ALIGN(16);
|
||||
@@ -201,6 +225,12 @@ SECTIONS
|
||||
__start_gate_section = .;
|
||||
*(.data.gate)
|
||||
__stop_gate_section = .;
|
||||
#ifdef CONFIG_XEN
|
||||
. = ALIGN(PAGE_SIZE);
|
||||
__xen_start_gate_section = .;
|
||||
*(.data.gate.xen)
|
||||
__xen_stop_gate_section = .;
|
||||
#endif
|
||||
}
|
||||
. = ALIGN(PAGE_SIZE); /* make sure the gate page doesn't expose
|
||||
* kernel data
|
||||
|
||||
Reference in New Issue
Block a user