2005-09-26 00:04:21 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
|
|
|
|
*/
|
2005-09-26 21:51:59 -06:00
|
|
|
#ifndef _ASM_POWERPC_SYSTEM_H
|
|
|
|
#define _ASM_POWERPC_SYSTEM_H
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
|
|
|
#include <asm/hw_irq.h>
|
2005-10-10 06:50:37 -06:00
|
|
|
#include <asm/atomic.h>
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Memory barrier.
|
|
|
|
* The sync instruction guarantees that all memory accesses initiated
|
|
|
|
* by this processor have been performed (with respect to all other
|
|
|
|
* mechanisms that access memory). The eieio instruction is a barrier
|
|
|
|
* providing an ordering (separately) for (a) cacheable stores and (b)
|
|
|
|
* loads and stores to non-cacheable memory (e.g. I/O devices).
|
|
|
|
*
|
|
|
|
* mb() prevents loads and stores being reordered across this point.
|
|
|
|
* rmb() prevents loads being reordered across this point.
|
|
|
|
* wmb() prevents stores being reordered across this point.
|
|
|
|
* read_barrier_depends() prevents data-dependent loads being reordered
|
|
|
|
* across this point (nop on PPC).
|
|
|
|
*
|
|
|
|
* We have to use the sync instructions for mb(), since lwsync doesn't
|
|
|
|
* order loads with respect to previous stores. Lwsync is fine for
|
|
|
|
* rmb(), though. Note that lwsync is interpreted as sync by
|
|
|
|
* 32-bit and older 64-bit CPUs.
|
|
|
|
*
|
|
|
|
* For wmb(), we use sync since wmb is used in drivers to order
|
|
|
|
* stores to system memory with respect to writes to the device.
|
|
|
|
* However, smp_wmb() can be a lighter-weight eieio barrier on
|
|
|
|
* SMP since it is only used to order updates to system memory.
|
|
|
|
*/
|
|
|
|
#define mb() __asm__ __volatile__ ("sync" : : : "memory")
|
|
|
|
#define rmb() __asm__ __volatile__ ("lwsync" : : : "memory")
|
|
|
|
#define wmb() __asm__ __volatile__ ("sync" : : : "memory")
|
|
|
|
#define read_barrier_depends() do { } while(0)
|
|
|
|
|
|
|
|
#define set_mb(var, value) do { var = value; mb(); } while (0)
|
|
|
|
|
2005-12-16 14:43:46 -07:00
|
|
|
#ifdef __KERNEL__
|
2005-09-26 00:04:21 -06:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
#define smp_mb() mb()
|
|
|
|
#define smp_rmb() rmb()
|
|
|
|
#define smp_wmb() __asm__ __volatile__ ("eieio" : : : "memory")
|
|
|
|
#define smp_read_barrier_depends() read_barrier_depends()
|
|
|
|
#else
|
|
|
|
#define smp_mb() barrier()
|
|
|
|
#define smp_rmb() barrier()
|
|
|
|
#define smp_wmb() barrier()
|
|
|
|
#define smp_read_barrier_depends() do { } while(0)
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2006-08-22 19:36:05 -06:00
|
|
|
/*
|
|
|
|
* This is a barrier which prevents following instructions from being
|
|
|
|
* started until the value of the argument x is known. For example, if
|
|
|
|
* x is a variable loaded from memory, this prevents following
|
|
|
|
* instructions from being executed until the load has been performed.
|
|
|
|
*/
|
|
|
|
#define data_barrier(x) \
|
|
|
|
asm volatile("twi 0,%0,0; isync" : : "r" (x) : "memory");
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
struct task_struct;
|
|
|
|
struct pt_regs;
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUGGER
|
|
|
|
|
|
|
|
extern int (*__debugger)(struct pt_regs *regs);
|
|
|
|
extern int (*__debugger_ipi)(struct pt_regs *regs);
|
|
|
|
extern int (*__debugger_bpt)(struct pt_regs *regs);
|
|
|
|
extern int (*__debugger_sstep)(struct pt_regs *regs);
|
|
|
|
extern int (*__debugger_iabr_match)(struct pt_regs *regs);
|
|
|
|
extern int (*__debugger_dabr_match)(struct pt_regs *regs);
|
|
|
|
extern int (*__debugger_fault_handler)(struct pt_regs *regs);
|
|
|
|
|
|
|
|
#define DEBUGGER_BOILERPLATE(__NAME) \
|
|
|
|
static inline int __NAME(struct pt_regs *regs) \
|
|
|
|
{ \
|
|
|
|
if (unlikely(__ ## __NAME)) \
|
|
|
|
return __ ## __NAME(regs); \
|
|
|
|
return 0; \
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUGGER_BOILERPLATE(debugger)
|
|
|
|
DEBUGGER_BOILERPLATE(debugger_ipi)
|
|
|
|
DEBUGGER_BOILERPLATE(debugger_bpt)
|
|
|
|
DEBUGGER_BOILERPLATE(debugger_sstep)
|
|
|
|
DEBUGGER_BOILERPLATE(debugger_iabr_match)
|
|
|
|
DEBUGGER_BOILERPLATE(debugger_dabr_match)
|
|
|
|
DEBUGGER_BOILERPLATE(debugger_fault_handler)
|
|
|
|
|
|
|
|
#else
|
|
|
|
static inline int debugger(struct pt_regs *regs) { return 0; }
|
|
|
|
static inline int debugger_ipi(struct pt_regs *regs) { return 0; }
|
|
|
|
static inline int debugger_bpt(struct pt_regs *regs) { return 0; }
|
|
|
|
static inline int debugger_sstep(struct pt_regs *regs) { return 0; }
|
|
|
|
static inline int debugger_iabr_match(struct pt_regs *regs) { return 0; }
|
|
|
|
static inline int debugger_dabr_match(struct pt_regs *regs) { return 0; }
|
|
|
|
static inline int debugger_fault_handler(struct pt_regs *regs) { return 0; }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern int set_dabr(unsigned long dabr);
|
|
|
|
extern void print_backtrace(unsigned long *);
|
|
|
|
extern void show_regs(struct pt_regs * regs);
|
|
|
|
extern void flush_instruction_cache(void);
|
|
|
|
extern void hard_reset_now(void);
|
|
|
|
extern void poweroff_now(void);
|
|
|
|
|
|
|
|
#ifdef CONFIG_6xx
|
|
|
|
extern long _get_L2CR(void);
|
|
|
|
extern long _get_L3CR(void);
|
|
|
|
extern void _set_L2CR(unsigned long);
|
|
|
|
extern void _set_L3CR(unsigned long);
|
|
|
|
#else
|
|
|
|
#define _get_L2CR() 0L
|
|
|
|
#define _get_L3CR() 0L
|
|
|
|
#define _set_L2CR(val) do { } while(0)
|
|
|
|
#define _set_L3CR(val) do { } while(0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern void via_cuda_init(void);
|
|
|
|
extern void read_rtc_time(void);
|
|
|
|
extern void pmac_find_display(void);
|
|
|
|
extern void giveup_fpu(struct task_struct *);
|
2005-09-30 00:16:52 -06:00
|
|
|
extern void disable_kernel_fp(void);
|
2005-09-26 00:04:21 -06:00
|
|
|
extern void enable_kernel_fp(void);
|
|
|
|
extern void flush_fp_to_thread(struct task_struct *);
|
|
|
|
extern void enable_kernel_altivec(void);
|
|
|
|
extern void giveup_altivec(struct task_struct *);
|
|
|
|
extern void load_up_altivec(struct task_struct *);
|
2005-10-10 06:50:37 -06:00
|
|
|
extern int emulate_altivec(struct pt_regs *);
|
2005-09-26 00:04:21 -06:00
|
|
|
extern void giveup_spe(struct task_struct *);
|
|
|
|
extern void load_up_spe(struct task_struct *);
|
|
|
|
extern int fix_alignment(struct pt_regs *);
|
[PATCH] powerpc: Fix handling of fpscr on 64-bit
The recent merge of fpu.S broken the handling of fpscr for
ARCH=powerpc and CONFIG_PPC64=y. FP registers could be corrupted,
leading to strange random application crashes.
The confusion arises, because the thread_struct has (and requires) a
64-bit area to save the fpscr, because we use load/store double
instructions to get it in to/out of the FPU. However, only the low
32-bits are actually used, so we want to treat it as a 32-bit quantity
when manipulating its bits to avoid extra load/stores on 32-bit. This
patch replaces the current definition with a structure of two 32-bit
quantities (pad and val), to clarify things as much as is possible.
The 'val' field is used when manipulating bits, the structure itself
is used when obtaining the address for loading/unloading the value
from the FPU.
While we're at it, consolidate the 4 (!) almost identical versions of
cvt_fd() and cvt_df() (arch/ppc/kernel/misc.S,
arch/ppc64/kernel/misc.S, arch/powerpc/kernel/misc_32.S,
arch/powerpc/kernel/misc_64.S) into a single version in fpu.S. The
new version takes a pointer to thread_struct and applies the correct
offset itself, rather than a pointer to the fpscr field itself, again
to avoid confusion as to which is the correct field to use.
Finally, this patch makes ARCH=ppc64 also use the consolidated fpu.S
code, which it previously did not.
Built for G5 (ARCH=ppc64 and ARCH=powerpc), 32-bit powermac (ARCH=ppc
and ARCH=powerpc) and Walnut (ARCH=ppc, CONFIG_MATH_EMULATION=y).
Booted on G5 (ARCH=powerpc) and things which previously fell over no
longer do.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-10-27 00:27:25 -06:00
|
|
|
extern void cvt_fd(float *from, double *to, struct thread_struct *thread);
|
|
|
|
extern void cvt_df(double *from, float *to, struct thread_struct *thread);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-01-11 04:11:39 -07:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
extern void discard_lazy_cpu_state(void);
|
|
|
|
#else
|
|
|
|
static inline void discard_lazy_cpu_state(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
extern void flush_altivec_to_thread(struct task_struct *);
|
|
|
|
#else
|
|
|
|
static inline void flush_altivec_to_thread(struct task_struct *t)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
extern void flush_spe_to_thread(struct task_struct *);
|
|
|
|
#else
|
|
|
|
static inline void flush_spe_to_thread(struct task_struct *t)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern int call_rtas(const char *, int, int, unsigned long *, ...);
|
|
|
|
extern void cacheable_memzero(void *p, unsigned int nb);
|
|
|
|
extern void *cacheable_memcpy(void *, const void *, unsigned int);
|
|
|
|
extern int do_page_fault(struct pt_regs *, unsigned long, unsigned long);
|
|
|
|
extern void bad_page_fault(struct pt_regs *, unsigned long, int);
|
|
|
|
extern int die(const char *, struct pt_regs *, long);
|
|
|
|
extern void _exception(int, struct pt_regs *, int, unsigned long);
|
|
|
|
#ifdef CONFIG_BOOKE_WDT
|
|
|
|
extern u32 booke_wdt_enabled;
|
|
|
|
extern u32 booke_wdt_period;
|
|
|
|
#endif /* CONFIG_BOOKE_WDT */
|
|
|
|
|
|
|
|
struct device_node;
|
|
|
|
extern void note_scsi_host(struct device_node *, void *);
|
|
|
|
|
|
|
|
extern struct task_struct *__switch_to(struct task_struct *,
|
|
|
|
struct task_struct *);
|
|
|
|
#define switch_to(prev, next, last) ((last) = __switch_to((prev), (next)))
|
|
|
|
|
|
|
|
struct thread_struct;
|
|
|
|
extern struct task_struct *_switch(struct thread_struct *prev,
|
|
|
|
struct thread_struct *next);
|
|
|
|
|
2006-01-12 02:05:27 -07:00
|
|
|
/*
|
|
|
|
* On SMP systems, when the scheduler does migration-cost autodetection,
|
|
|
|
* it needs a way to flush as much of the CPU's caches as possible.
|
|
|
|
*
|
|
|
|
* TODO: fill this in!
|
|
|
|
*/
|
|
|
|
static inline void sched_cacheflush(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
extern unsigned int rtas_data;
|
2005-10-10 06:50:37 -06:00
|
|
|
extern int mem_init_done; /* set on boot once kmalloc can be called */
|
2005-10-30 19:07:02 -07:00
|
|
|
extern unsigned long memory_limit;
|
2005-11-09 21:53:40 -07:00
|
|
|
extern unsigned long klimit;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-10-20 05:10:09 -06:00
|
|
|
extern int powersave_nap; /* set if nap mode can be used in idle loop */
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/*
|
|
|
|
* Atomic exchange
|
|
|
|
*
|
|
|
|
* Changes the memory location '*ptr' to be val and returns
|
|
|
|
* the previous value stored there.
|
|
|
|
*/
|
|
|
|
static __inline__ unsigned long
|
|
|
|
__xchg_u32(volatile void *p, unsigned long val)
|
|
|
|
{
|
|
|
|
unsigned long prev;
|
|
|
|
|
|
|
|
__asm__ __volatile__(
|
2006-01-12 21:37:17 -07:00
|
|
|
LWSYNC_ON_SMP
|
2005-09-26 00:04:21 -06:00
|
|
|
"1: lwarx %0,0,%2 \n"
|
|
|
|
PPC405_ERR77(0,%2)
|
|
|
|
" stwcx. %3,0,%2 \n\
|
|
|
|
bne- 1b"
|
|
|
|
ISYNC_ON_SMP
|
2006-07-08 16:00:28 -06:00
|
|
|
: "=&r" (prev), "+m" (*(volatile unsigned int *)p)
|
|
|
|
: "r" (p), "r" (val)
|
2005-09-26 00:04:21 -06:00
|
|
|
: "cc", "memory");
|
|
|
|
|
|
|
|
return prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
static __inline__ unsigned long
|
|
|
|
__xchg_u64(volatile void *p, unsigned long val)
|
|
|
|
{
|
|
|
|
unsigned long prev;
|
|
|
|
|
|
|
|
__asm__ __volatile__(
|
2006-01-12 21:37:17 -07:00
|
|
|
LWSYNC_ON_SMP
|
2005-09-26 00:04:21 -06:00
|
|
|
"1: ldarx %0,0,%2 \n"
|
|
|
|
PPC405_ERR77(0,%2)
|
|
|
|
" stdcx. %3,0,%2 \n\
|
|
|
|
bne- 1b"
|
|
|
|
ISYNC_ON_SMP
|
2006-07-08 16:00:28 -06:00
|
|
|
: "=&r" (prev), "+m" (*(volatile unsigned long *)p)
|
|
|
|
: "r" (p), "r" (val)
|
2005-09-26 00:04:21 -06:00
|
|
|
: "cc", "memory");
|
|
|
|
|
|
|
|
return prev;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function doesn't exist, so you'll get a linker error
|
|
|
|
* if something tries to do an invalid xchg().
|
|
|
|
*/
|
|
|
|
extern void __xchg_called_with_bad_pointer(void);
|
|
|
|
|
|
|
|
static __inline__ unsigned long
|
|
|
|
__xchg(volatile void *ptr, unsigned long x, unsigned int size)
|
|
|
|
{
|
|
|
|
switch (size) {
|
|
|
|
case 4:
|
|
|
|
return __xchg_u32(ptr, x);
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
case 8:
|
|
|
|
return __xchg_u64(ptr, x);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
__xchg_called_with_bad_pointer();
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define xchg(ptr,x) \
|
|
|
|
({ \
|
|
|
|
__typeof__(*(ptr)) _x_ = (x); \
|
|
|
|
(__typeof__(*(ptr))) __xchg((ptr), (unsigned long)_x_, sizeof(*(ptr))); \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define tas(ptr) (xchg((ptr),1))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare and exchange - if *p == old, set it to new,
|
|
|
|
* and return the old value of *p.
|
|
|
|
*/
|
|
|
|
#define __HAVE_ARCH_CMPXCHG 1
|
|
|
|
|
|
|
|
static __inline__ unsigned long
|
|
|
|
__cmpxchg_u32(volatile unsigned int *p, unsigned long old, unsigned long new)
|
|
|
|
{
|
|
|
|
unsigned int prev;
|
|
|
|
|
|
|
|
__asm__ __volatile__ (
|
2006-01-12 21:37:17 -07:00
|
|
|
LWSYNC_ON_SMP
|
2005-09-26 00:04:21 -06:00
|
|
|
"1: lwarx %0,0,%2 # __cmpxchg_u32\n\
|
|
|
|
cmpw 0,%0,%3\n\
|
|
|
|
bne- 2f\n"
|
|
|
|
PPC405_ERR77(0,%2)
|
|
|
|
" stwcx. %4,0,%2\n\
|
|
|
|
bne- 1b"
|
|
|
|
ISYNC_ON_SMP
|
|
|
|
"\n\
|
|
|
|
2:"
|
2006-07-08 16:00:28 -06:00
|
|
|
: "=&r" (prev), "+m" (*p)
|
|
|
|
: "r" (p), "r" (old), "r" (new)
|
2005-09-26 00:04:21 -06:00
|
|
|
: "cc", "memory");
|
|
|
|
|
|
|
|
return prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
static __inline__ unsigned long
|
2005-11-06 17:06:55 -07:00
|
|
|
__cmpxchg_u64(volatile unsigned long *p, unsigned long old, unsigned long new)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
unsigned long prev;
|
|
|
|
|
|
|
|
__asm__ __volatile__ (
|
2006-01-12 21:37:17 -07:00
|
|
|
LWSYNC_ON_SMP
|
2005-09-26 00:04:21 -06:00
|
|
|
"1: ldarx %0,0,%2 # __cmpxchg_u64\n\
|
|
|
|
cmpd 0,%0,%3\n\
|
|
|
|
bne- 2f\n\
|
|
|
|
stdcx. %4,0,%2\n\
|
|
|
|
bne- 1b"
|
|
|
|
ISYNC_ON_SMP
|
|
|
|
"\n\
|
|
|
|
2:"
|
2006-07-08 16:00:28 -06:00
|
|
|
: "=&r" (prev), "+m" (*p)
|
|
|
|
: "r" (p), "r" (old), "r" (new)
|
2005-09-26 00:04:21 -06:00
|
|
|
: "cc", "memory");
|
|
|
|
|
|
|
|
return prev;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* This function doesn't exist, so you'll get a linker error
|
|
|
|
if something tries to do an invalid cmpxchg(). */
|
|
|
|
extern void __cmpxchg_called_with_bad_pointer(void);
|
|
|
|
|
|
|
|
static __inline__ unsigned long
|
|
|
|
__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
switch (size) {
|
|
|
|
case 4:
|
|
|
|
return __cmpxchg_u32(ptr, old, new);
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
case 8:
|
|
|
|
return __cmpxchg_u64(ptr, old, new);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
__cmpxchg_called_with_bad_pointer();
|
|
|
|
return old;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define cmpxchg(ptr,o,n) \
|
|
|
|
({ \
|
|
|
|
__typeof__(*(ptr)) _o_ = (o); \
|
|
|
|
__typeof__(*(ptr)) _n_ = (n); \
|
|
|
|
(__typeof__(*(ptr))) __cmpxchg((ptr), (unsigned long)_o_, \
|
|
|
|
(unsigned long)_n_, sizeof(*(ptr))); \
|
|
|
|
})
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
/*
|
|
|
|
* We handle most unaligned accesses in hardware. On the other hand
|
|
|
|
* unaligned DMA can be very expensive on some ppc64 IO chips (it does
|
|
|
|
* powers of 2 writes until it reaches sufficient alignment).
|
|
|
|
*
|
|
|
|
* Based on this we disable the IP header alignment in network drivers.
|
2006-03-31 03:27:06 -07:00
|
|
|
* We also modify NET_SKB_PAD to be a cacheline in size, thus maintaining
|
|
|
|
* cacheline alignment of buffers.
|
2005-09-26 00:04:21 -06:00
|
|
|
*/
|
2006-03-31 03:27:06 -07:00
|
|
|
#define NET_IP_ALIGN 0
|
|
|
|
#define NET_SKB_PAD L1_CACHE_BYTES
|
2005-09-26 00:04:21 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define arch_align_stack(x) (x)
|
|
|
|
|
2005-10-05 20:06:20 -06:00
|
|
|
/* Used in very early kernel initialization. */
|
2005-09-30 00:16:52 -06:00
|
|
|
extern unsigned long reloc_offset(void);
|
2005-10-05 20:06:20 -06:00
|
|
|
extern unsigned long add_reloc_offset(unsigned long);
|
|
|
|
extern void reloc_got2(unsigned long);
|
|
|
|
|
|
|
|
#define PTRRELOC(x) ((typeof(x)) add_reloc_offset((unsigned long)(x)))
|
2005-09-30 00:16:52 -06:00
|
|
|
|
2005-11-02 23:57:53 -07:00
|
|
|
static inline void create_instruction(unsigned long addr, unsigned int instr)
|
|
|
|
{
|
|
|
|
unsigned int *p;
|
|
|
|
p = (unsigned int *)addr;
|
|
|
|
*p = instr;
|
|
|
|
asm ("dcbst 0, %0; sync; icbi 0,%0; sync; isync" : : "r" (p));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Flags for create_branch:
|
|
|
|
* "b" == create_branch(addr, target, 0);
|
|
|
|
* "ba" == create_branch(addr, target, BRANCH_ABSOLUTE);
|
|
|
|
* "bl" == create_branch(addr, target, BRANCH_SET_LINK);
|
|
|
|
* "bla" == create_branch(addr, target, BRANCH_ABSOLUTE | BRANCH_SET_LINK);
|
|
|
|
*/
|
|
|
|
#define BRANCH_SET_LINK 0x1
|
|
|
|
#define BRANCH_ABSOLUTE 0x2
|
|
|
|
|
|
|
|
static inline void create_branch(unsigned long addr,
|
|
|
|
unsigned long target, int flags)
|
|
|
|
{
|
|
|
|
unsigned int instruction;
|
|
|
|
|
|
|
|
if (! (flags & BRANCH_ABSOLUTE))
|
|
|
|
target = target - addr;
|
|
|
|
|
|
|
|
/* Mask out the flags and target, so they don't step on each other. */
|
|
|
|
instruction = 0x48000000 | (flags & 0x3) | (target & 0x03FFFFFC);
|
|
|
|
|
|
|
|
create_instruction(addr, instruction);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void create_function_call(unsigned long addr, void * func)
|
|
|
|
{
|
|
|
|
unsigned long func_addr;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
/*
|
|
|
|
* On PPC64 the function pointer actually points to the function's
|
|
|
|
* descriptor. The first entry in the descriptor is the address
|
|
|
|
* of the function text.
|
|
|
|
*/
|
|
|
|
func_addr = *(unsigned long *)func;
|
|
|
|
#else
|
|
|
|
func_addr = (unsigned long)func;
|
|
|
|
#endif
|
|
|
|
create_branch(addr, func_addr, BRANCH_SET_LINK);
|
|
|
|
}
|
|
|
|
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-23 16:06:59 -07:00
|
|
|
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
|
|
|
extern void account_system_vtime(struct task_struct *);
|
|
|
|
#endif
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
#endif /* __KERNEL__ */
|
2005-09-26 21:51:59 -06:00
|
|
|
#endif /* _ASM_POWERPC_SYSTEM_H */
|