2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 1995-1999 Gary Thomas, Paul Mackerras, Cort Dougan.
|
|
|
|
|
*/
|
2005-09-09 16:02:25 -04:00
|
|
|
#ifndef _ASM_POWERPC_PPC_ASM_H
|
|
|
|
|
#define _ASM_POWERPC_PPC_ASM_H
|
|
|
|
|
|
2005-10-10 08:50:37 -04:00
|
|
|
#include <linux/stringify.h>
|
[PATCH] powerpc: Consolidate asm compatibility macros
This patch consolidates macros used to generate assembly for
compatibility across different CPUs or configs. A new header,
asm-powerpc/asm-compat.h contains the main compatibility macros. It
uses some preprocessor magic to make the macros suitable both for use
in .S files, and in inline asm in .c files. Headers (bitops.h,
uaccess.h, atomic.h, bug.h) which had their own such compatibility
macros are changed to use asm-compat.h.
ppc_asm.h is now for use in .S files *only*, and a #error enforces
that. As such, we're a lot more careless about namespace pollution
here than in asm-compat.h.
While we're at it, this patch adds a call to the PPC405_ERR77 macro in
futex.h which should have had it already, but didn't.
Built and booted on pSeries, Maple and iSeries (ARCH=powerpc). Built
for 32-bit powermac (ARCH=powerpc) and Walnut (ARCH=ppc).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-09 20:56:55 -05:00
|
|
|
#include <asm/asm-compat.h>
|
2008-06-26 03:07:48 -04:00
|
|
|
#include <asm/processor.h>
|
2009-02-10 15:10:44 -05:00
|
|
|
#include <asm/ppc-opcode.h>
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
#include <asm/firmware.h>
|
2018-07-05 12:25:01 -04:00
|
|
|
#include <asm/feature-fixups.h>
|
2005-10-10 08:50:37 -04:00
|
|
|
|
2016-10-14 00:58:28 -04:00
|
|
|
#ifdef __ASSEMBLY__
|
[PATCH] powerpc: Consolidate asm compatibility macros
This patch consolidates macros used to generate assembly for
compatibility across different CPUs or configs. A new header,
asm-powerpc/asm-compat.h contains the main compatibility macros. It
uses some preprocessor magic to make the macros suitable both for use
in .S files, and in inline asm in .c files. Headers (bitops.h,
uaccess.h, atomic.h, bug.h) which had their own such compatibility
macros are changed to use asm-compat.h.
ppc_asm.h is now for use in .S files *only*, and a #error enforces
that. As such, we're a lot more careless about namespace pollution
here than in asm-compat.h.
While we're at it, this patch adds a call to the PPC405_ERR77 macro in
futex.h which should have had it already, but didn't.
Built and booted on pSeries, Maple and iSeries (ARCH=powerpc). Built
for 32-bit powermac (ARCH=powerpc) and Walnut (ARCH=ppc).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-09 20:56:55 -05:00
|
|
|
|
|
|
|
|
#define SZL (BITS_PER_LONG/8)
|
2005-04-16 18:20:36 -04:00
|
|
|
|
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 18:06:59 -05:00
|
|
|
/*
|
|
|
|
|
* Stuff for accurate CPU time accounting.
|
|
|
|
|
* These macros handle transitions between user and system state
|
|
|
|
|
* in exception entry and exit and accumulate time to the
|
|
|
|
|
* user_time and system_time fields in the paca.
|
|
|
|
|
*/
|
|
|
|
|
|
2012-07-25 01:56:04 -04:00
|
|
|
#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
|
2016-05-17 02:33:46 -04:00
|
|
|
#define ACCOUNT_CPU_USER_ENTRY(ptr, ra, rb)
|
|
|
|
|
#define ACCOUNT_CPU_USER_EXIT(ptr, ra, rb)
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
#define ACCOUNT_STOLEN_TIME
|
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 18:06:59 -05:00
|
|
|
#else
|
2016-05-17 02:33:46 -04:00
|
|
|
#define ACCOUNT_CPU_USER_ENTRY(ptr, ra, rb) \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
MFTB(ra); /* get timebase */ \
|
2016-05-17 02:33:46 -04:00
|
|
|
PPC_LL rb, ACCOUNT_STARTTIME_USER(ptr); \
|
|
|
|
|
PPC_STL ra, ACCOUNT_STARTTIME(ptr); \
|
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 18:06:59 -05:00
|
|
|
subf rb,rb,ra; /* subtract start value */ \
|
2016-05-17 02:33:46 -04:00
|
|
|
PPC_LL ra, ACCOUNT_USER_TIME(ptr); \
|
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 18:06:59 -05:00
|
|
|
add ra,ra,rb; /* add on to user time */ \
|
2016-05-17 02:33:46 -04:00
|
|
|
PPC_STL ra, ACCOUNT_USER_TIME(ptr); \
|
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 18:06:59 -05:00
|
|
|
|
2016-05-17 02:33:46 -04:00
|
|
|
#define ACCOUNT_CPU_USER_EXIT(ptr, ra, rb) \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
MFTB(ra); /* get timebase */ \
|
2016-05-17 02:33:46 -04:00
|
|
|
PPC_LL rb, ACCOUNT_STARTTIME(ptr); \
|
|
|
|
|
PPC_STL ra, ACCOUNT_STARTTIME_USER(ptr); \
|
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 18:06:59 -05:00
|
|
|
subf rb,rb,ra; /* subtract start value */ \
|
2016-05-17 02:33:46 -04:00
|
|
|
PPC_LL ra, ACCOUNT_SYSTEM_TIME(ptr); \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
add ra,ra,rb; /* add on to system time */ \
|
2016-05-17 02:33:46 -04:00
|
|
|
PPC_STL ra, ACCOUNT_SYSTEM_TIME(ptr)
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_SPLPAR
|
|
|
|
|
#define ACCOUNT_STOLEN_TIME \
|
|
|
|
|
BEGIN_FW_FTR_SECTION; \
|
|
|
|
|
beq 33f; \
|
|
|
|
|
/* from user - see if there are any DTL entries to process */ \
|
|
|
|
|
ld r10,PACALPPACAPTR(r13); /* get ptr to VPA */ \
|
|
|
|
|
ld r11,PACA_DTL_RIDX(r13); /* get log read index */ \
|
2013-08-06 12:01:46 -04:00
|
|
|
addi r10,r10,LPPACA_DTLIDX; \
|
|
|
|
|
LDX_BE r10,0,r10; /* get log write index */ \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
cmpd cr1,r11,r10; \
|
|
|
|
|
beq+ cr1,33f; \
|
2014-02-04 00:04:35 -05:00
|
|
|
bl accumulate_stolen_time; \
|
2012-03-01 19:01:31 -05:00
|
|
|
ld r12,_MSR(r1); \
|
|
|
|
|
andi. r10,r12,MSR_PR; /* Restore cr0 (coming from user) */ \
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 15:56:43 -04:00
|
|
|
33: \
|
|
|
|
|
END_FW_FTR_SECTION_IFSET(FW_FEATURE_SPLPAR)
|
|
|
|
|
|
|
|
|
|
#else /* CONFIG_PPC_SPLPAR */
|
|
|
|
|
#define ACCOUNT_STOLEN_TIME
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_PPC_SPLPAR */
|
|
|
|
|
|
2012-07-25 01:56:04 -04:00
|
|
|
#endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
|
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 18:06:59 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
|
* Macros for storing registers into and loading registers from
|
|
|
|
|
* exception frames.
|
|
|
|
|
*/
|
2005-09-09 16:02:25 -04:00
|
|
|
#ifdef __powerpc64__
|
|
|
|
|
#define SAVE_GPR(n, base) std n,GPR0+8*(n)(base)
|
|
|
|
|
#define REST_GPR(n, base) ld n,GPR0+8*(n)(base)
|
|
|
|
|
#define SAVE_NVGPRS(base) SAVE_8GPRS(14, base); SAVE_10GPRS(22, base)
|
|
|
|
|
#define REST_NVGPRS(base) REST_8GPRS(14, base); REST_10GPRS(22, base)
|
|
|
|
|
#else
|
2005-04-16 18:20:36 -04:00
|
|
|
#define SAVE_GPR(n, base) stw n,GPR0+4*(n)(base)
|
2005-09-09 16:02:25 -04:00
|
|
|
#define REST_GPR(n, base) lwz n,GPR0+4*(n)(base)
|
2018-04-17 13:08:18 -04:00
|
|
|
#define SAVE_NVGPRS(base) stmw 13, GPR0+4*13(base)
|
|
|
|
|
#define REST_NVGPRS(base) lmw 13, GPR0+4*13(base)
|
2005-09-09 16:02:25 -04:00
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#define SAVE_2GPRS(n, base) SAVE_GPR(n, base); SAVE_GPR(n+1, base)
|
|
|
|
|
#define SAVE_4GPRS(n, base) SAVE_2GPRS(n, base); SAVE_2GPRS(n+2, base)
|
|
|
|
|
#define SAVE_8GPRS(n, base) SAVE_4GPRS(n, base); SAVE_4GPRS(n+4, base)
|
|
|
|
|
#define SAVE_10GPRS(n, base) SAVE_8GPRS(n, base); SAVE_2GPRS(n+8, base)
|
|
|
|
|
#define REST_2GPRS(n, base) REST_GPR(n, base); REST_GPR(n+1, base)
|
|
|
|
|
#define REST_4GPRS(n, base) REST_2GPRS(n, base); REST_2GPRS(n+2, base)
|
|
|
|
|
#define REST_8GPRS(n, base) REST_4GPRS(n, base); REST_4GPRS(n+4, base)
|
|
|
|
|
#define REST_10GPRS(n, base) REST_8GPRS(n, base); REST_2GPRS(n+8, base)
|
|
|
|
|
|
2013-09-10 06:20:42 -04:00
|
|
|
#define SAVE_FPR(n, base) stfd n,8*TS_FPRWIDTH*(n)(base)
|
2005-04-16 18:20:36 -04:00
|
|
|
#define SAVE_2FPRS(n, base) SAVE_FPR(n, base); SAVE_FPR(n+1, base)
|
|
|
|
|
#define SAVE_4FPRS(n, base) SAVE_2FPRS(n, base); SAVE_2FPRS(n+2, base)
|
|
|
|
|
#define SAVE_8FPRS(n, base) SAVE_4FPRS(n, base); SAVE_4FPRS(n+4, base)
|
|
|
|
|
#define SAVE_16FPRS(n, base) SAVE_8FPRS(n, base); SAVE_8FPRS(n+8, base)
|
|
|
|
|
#define SAVE_32FPRS(n, base) SAVE_16FPRS(n, base); SAVE_16FPRS(n+16, base)
|
2013-09-10 06:20:42 -04:00
|
|
|
#define REST_FPR(n, base) lfd n,8*TS_FPRWIDTH*(n)(base)
|
2005-04-16 18:20:36 -04:00
|
|
|
#define REST_2FPRS(n, base) REST_FPR(n, base); REST_FPR(n+1, base)
|
|
|
|
|
#define REST_4FPRS(n, base) REST_2FPRS(n, base); REST_2FPRS(n+2, base)
|
|
|
|
|
#define REST_8FPRS(n, base) REST_4FPRS(n, base); REST_4FPRS(n+4, base)
|
|
|
|
|
#define REST_16FPRS(n, base) REST_8FPRS(n, base); REST_8FPRS(n+8, base)
|
|
|
|
|
#define REST_32FPRS(n, base) REST_16FPRS(n, base); REST_16FPRS(n+16, base)
|
|
|
|
|
|
2013-09-10 06:20:42 -04:00
|
|
|
#define SAVE_VR(n,b,base) li b,16*(n); stvx n,base,b
|
2005-09-09 16:02:25 -04:00
|
|
|
#define SAVE_2VRS(n,b,base) SAVE_VR(n,b,base); SAVE_VR(n+1,b,base)
|
|
|
|
|
#define SAVE_4VRS(n,b,base) SAVE_2VRS(n,b,base); SAVE_2VRS(n+2,b,base)
|
|
|
|
|
#define SAVE_8VRS(n,b,base) SAVE_4VRS(n,b,base); SAVE_4VRS(n+4,b,base)
|
|
|
|
|
#define SAVE_16VRS(n,b,base) SAVE_8VRS(n,b,base); SAVE_8VRS(n+8,b,base)
|
|
|
|
|
#define SAVE_32VRS(n,b,base) SAVE_16VRS(n,b,base); SAVE_16VRS(n+16,b,base)
|
2013-09-10 06:20:42 -04:00
|
|
|
#define REST_VR(n,b,base) li b,16*(n); lvx n,base,b
|
2005-09-09 16:02:25 -04:00
|
|
|
#define REST_2VRS(n,b,base) REST_VR(n,b,base); REST_VR(n+1,b,base)
|
|
|
|
|
#define REST_4VRS(n,b,base) REST_2VRS(n,b,base); REST_2VRS(n+2,b,base)
|
|
|
|
|
#define REST_8VRS(n,b,base) REST_4VRS(n,b,base); REST_4VRS(n+4,b,base)
|
|
|
|
|
#define REST_16VRS(n,b,base) REST_8VRS(n,b,base); REST_8VRS(n+8,b,base)
|
|
|
|
|
#define REST_32VRS(n,b,base) REST_16VRS(n,b,base); REST_16VRS(n+16,b,base)
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2013-09-22 22:04:39 -04:00
|
|
|
#ifdef __BIG_ENDIAN__
|
|
|
|
|
#define STXVD2X_ROT(n,b,base) STXVD2X(n,b,base)
|
|
|
|
|
#define LXVD2X_ROT(n,b,base) LXVD2X(n,b,base)
|
|
|
|
|
#else
|
|
|
|
|
#define STXVD2X_ROT(n,b,base) XXSWAPD(n,n); \
|
|
|
|
|
STXVD2X(n,b,base); \
|
|
|
|
|
XXSWAPD(n,n)
|
|
|
|
|
|
|
|
|
|
#define LXVD2X_ROT(n,b,base) LXVD2X(n,b,base); \
|
|
|
|
|
XXSWAPD(n,n)
|
|
|
|
|
#endif
|
2008-06-25 00:07:18 -04:00
|
|
|
/* Save the lower 32 VSRs in the thread VSR region */
|
2013-10-11 03:23:53 -04:00
|
|
|
#define SAVE_VSR(n,b,base) li b,16*(n); STXVD2X_ROT(n,R##base,R##b)
|
2008-06-25 00:07:18 -04:00
|
|
|
#define SAVE_2VSRS(n,b,base) SAVE_VSR(n,b,base); SAVE_VSR(n+1,b,base)
|
|
|
|
|
#define SAVE_4VSRS(n,b,base) SAVE_2VSRS(n,b,base); SAVE_2VSRS(n+2,b,base)
|
|
|
|
|
#define SAVE_8VSRS(n,b,base) SAVE_4VSRS(n,b,base); SAVE_4VSRS(n+4,b,base)
|
|
|
|
|
#define SAVE_16VSRS(n,b,base) SAVE_8VSRS(n,b,base); SAVE_8VSRS(n+8,b,base)
|
|
|
|
|
#define SAVE_32VSRS(n,b,base) SAVE_16VSRS(n,b,base); SAVE_16VSRS(n+16,b,base)
|
2013-10-11 03:23:53 -04:00
|
|
|
#define REST_VSR(n,b,base) li b,16*(n); LXVD2X_ROT(n,R##base,R##b)
|
2008-06-25 00:07:18 -04:00
|
|
|
#define REST_2VSRS(n,b,base) REST_VSR(n,b,base); REST_VSR(n+1,b,base)
|
|
|
|
|
#define REST_4VSRS(n,b,base) REST_2VSRS(n,b,base); REST_2VSRS(n+2,b,base)
|
|
|
|
|
#define REST_8VSRS(n,b,base) REST_4VSRS(n,b,base); REST_4VSRS(n+4,b,base)
|
|
|
|
|
#define REST_16VSRS(n,b,base) REST_8VSRS(n,b,base); REST_8VSRS(n+8,b,base)
|
|
|
|
|
#define REST_32VSRS(n,b,base) REST_16VSRS(n,b,base); REST_16VSRS(n+16,b,base)
|
|
|
|
|
|
2011-06-14 19:34:27 -04:00
|
|
|
/*
|
|
|
|
|
* b = base register for addressing, o = base offset from register of 1st EVR
|
|
|
|
|
* n = first EVR, s = scratch
|
|
|
|
|
*/
|
|
|
|
|
#define SAVE_EVR(n,s,b,o) evmergehi s,s,n; stw s,o+4*(n)(b)
|
|
|
|
|
#define SAVE_2EVRS(n,s,b,o) SAVE_EVR(n,s,b,o); SAVE_EVR(n+1,s,b,o)
|
|
|
|
|
#define SAVE_4EVRS(n,s,b,o) SAVE_2EVRS(n,s,b,o); SAVE_2EVRS(n+2,s,b,o)
|
|
|
|
|
#define SAVE_8EVRS(n,s,b,o) SAVE_4EVRS(n,s,b,o); SAVE_4EVRS(n+4,s,b,o)
|
|
|
|
|
#define SAVE_16EVRS(n,s,b,o) SAVE_8EVRS(n,s,b,o); SAVE_8EVRS(n+8,s,b,o)
|
|
|
|
|
#define SAVE_32EVRS(n,s,b,o) SAVE_16EVRS(n,s,b,o); SAVE_16EVRS(n+16,s,b,o)
|
|
|
|
|
#define REST_EVR(n,s,b,o) lwz s,o+4*(n)(b); evmergelo n,s,n
|
|
|
|
|
#define REST_2EVRS(n,s,b,o) REST_EVR(n,s,b,o); REST_EVR(n+1,s,b,o)
|
|
|
|
|
#define REST_4EVRS(n,s,b,o) REST_2EVRS(n,s,b,o); REST_2EVRS(n+2,s,b,o)
|
|
|
|
|
#define REST_8EVRS(n,s,b,o) REST_4EVRS(n,s,b,o); REST_4EVRS(n+4,s,b,o)
|
|
|
|
|
#define REST_16EVRS(n,s,b,o) REST_8EVRS(n,s,b,o); REST_8EVRS(n+8,s,b,o)
|
|
|
|
|
#define REST_32EVRS(n,s,b,o) REST_16EVRS(n,s,b,o); REST_16EVRS(n+16,s,b,o)
|
2005-09-09 16:02:25 -04:00
|
|
|
|
2005-10-24 01:07:27 -04:00
|
|
|
/* Macros to adjust thread priority for hardware multithreading */
|
|
|
|
|
#define HMT_VERY_LOW or 31,31,31 # very low priority
|
|
|
|
|
#define HMT_LOW or 1,1,1
|
|
|
|
|
#define HMT_MEDIUM_LOW or 6,6,6 # medium low priority
|
|
|
|
|
#define HMT_MEDIUM or 2,2,2
|
|
|
|
|
#define HMT_MEDIUM_HIGH or 5,5,5 # medium high priority
|
|
|
|
|
#define HMT_HIGH or 3,3,3
|
2011-01-12 01:41:28 -05:00
|
|
|
#define HMT_EXTRA_HIGH or 7,7,7 # power7 only
|
2005-09-09 16:02:25 -04:00
|
|
|
|
2012-06-25 09:33:15 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
#define ULONG_SIZE 8
|
|
|
|
|
#else
|
|
|
|
|
#define ULONG_SIZE 4
|
|
|
|
|
#endif
|
2012-06-25 09:33:23 -04:00
|
|
|
#define __VCPU_GPR(n) (VCPU_GPRS + (n * ULONG_SIZE))
|
|
|
|
|
#define VCPU_GPR(n) __VCPU_GPR(__REG_##n)
|
2012-06-25 09:33:15 -04:00
|
|
|
|
2005-12-16 16:43:46 -05:00
|
|
|
#ifdef __KERNEL__
|
2005-10-10 08:50:37 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
|
2012-06-25 09:33:14 -04:00
|
|
|
#define STACKFRAMESIZE 256
|
2012-06-25 09:33:23 -04:00
|
|
|
#define __STK_REG(i) (112 + ((i)-14)*8)
|
|
|
|
|
#define STK_REG(i) __STK_REG(__REG_##i)
|
2012-06-25 09:33:14 -04:00
|
|
|
|
2016-06-06 12:56:10 -04:00
|
|
|
#ifdef PPC64_ELF_ABI_v2
|
2014-03-09 19:52:17 -04:00
|
|
|
#define STK_GOT 24
|
2014-02-04 00:09:02 -05:00
|
|
|
#define __STK_PARAM(i) (32 + ((i)-3)*8)
|
|
|
|
|
#else
|
2014-03-09 19:52:17 -04:00
|
|
|
#define STK_GOT 40
|
2012-06-25 09:33:23 -04:00
|
|
|
#define __STK_PARAM(i) (48 + ((i)-3)*8)
|
2014-02-04 00:09:02 -05:00
|
|
|
#endif
|
2012-06-25 09:33:23 -04:00
|
|
|
#define STK_PARAM(i) __STK_PARAM(__REG_##i)
|
2012-06-25 09:33:14 -04:00
|
|
|
|
2016-06-06 12:56:10 -04:00
|
|
|
#ifdef PPC64_ELF_ABI_v2
|
2014-02-04 00:07:20 -05:00
|
|
|
|
|
|
|
|
#define _GLOBAL(name) \
|
|
|
|
|
.align 2 ; \
|
|
|
|
|
.type name,@function; \
|
|
|
|
|
.globl name; \
|
|
|
|
|
name:
|
|
|
|
|
|
2014-04-03 01:01:11 -04:00
|
|
|
#define _GLOBAL_TOC(name) \
|
|
|
|
|
.align 2 ; \
|
|
|
|
|
.type name,@function; \
|
|
|
|
|
.globl name; \
|
|
|
|
|
name: \
|
|
|
|
|
0: addis r2,r12,(.TOC.-0b)@ha; \
|
|
|
|
|
addi r2,r2,(.TOC.-0b)@l; \
|
|
|
|
|
.localentry name,.-name
|
|
|
|
|
|
2014-02-04 00:07:20 -05:00
|
|
|
#define DOTSYM(a) a
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
2005-10-10 08:50:37 -04:00
|
|
|
#define XGLUE(a,b) a##b
|
|
|
|
|
#define GLUE(a,b) XGLUE(a,b)
|
|
|
|
|
|
|
|
|
|
#define _GLOBAL(name) \
|
|
|
|
|
.align 2 ; \
|
|
|
|
|
.globl name; \
|
|
|
|
|
.globl GLUE(.,name); \
|
2016-09-14 20:40:20 -04:00
|
|
|
.pushsection ".opd","aw"; \
|
2005-10-10 08:50:37 -04:00
|
|
|
name: \
|
|
|
|
|
.quad GLUE(.,name); \
|
|
|
|
|
.quad .TOC.@tocbase; \
|
|
|
|
|
.quad 0; \
|
2016-09-14 20:40:20 -04:00
|
|
|
.popsection; \
|
2005-10-10 08:50:37 -04:00
|
|
|
.type GLUE(.,name),@function; \
|
|
|
|
|
GLUE(.,name):
|
|
|
|
|
|
2014-04-03 01:01:11 -04:00
|
|
|
#define _GLOBAL_TOC(name) _GLOBAL(name)
|
|
|
|
|
|
2014-02-04 00:07:01 -05:00
|
|
|
#define DOTSYM(a) GLUE(.,a)
|
|
|
|
|
|
2014-02-04 00:07:20 -05:00
|
|
|
#endif
|
|
|
|
|
|
2005-10-10 08:50:37 -04:00
|
|
|
#else /* 32-bit */
|
|
|
|
|
|
2007-09-13 16:42:35 -04:00
|
|
|
#define _ENTRY(n) \
|
|
|
|
|
.globl n; \
|
|
|
|
|
n:
|
|
|
|
|
|
2005-10-10 08:50:37 -04:00
|
|
|
#define _GLOBAL(n) \
|
|
|
|
|
.stabs __stringify(n:F-1),N_FUN,0,0,n;\
|
|
|
|
|
.globl n; \
|
|
|
|
|
n:
|
|
|
|
|
|
2014-06-26 07:19:40 -04:00
|
|
|
#define _GLOBAL_TOC(name) _GLOBAL(name)
|
|
|
|
|
|
2005-10-10 08:50:37 -04:00
|
|
|
#endif
|
|
|
|
|
|
2016-09-16 06:48:17 -04:00
|
|
|
/*
|
|
|
|
|
* __kprobes (the C annotation) puts the symbol into the .kprobes.text
|
|
|
|
|
* section, which gets emitted at the end of regular text.
|
|
|
|
|
*
|
|
|
|
|
* _ASM_NOKPROBE_SYMBOL and NOKPROBE_SYMBOL just adds the symbol to
|
|
|
|
|
* a blacklist. The former is for core kprobe functions/data, the
|
|
|
|
|
* latter is for those that incdentially must be excluded from probing
|
|
|
|
|
* and allows them to be linked at more optimal location within text.
|
|
|
|
|
*/
|
2016-10-12 22:07:14 -04:00
|
|
|
#ifdef CONFIG_KPROBES
|
2016-09-16 06:48:17 -04:00
|
|
|
#define _ASM_NOKPROBE_SYMBOL(entry) \
|
|
|
|
|
.pushsection "_kprobe_blacklist","aw"; \
|
|
|
|
|
PPC_LONG (entry) ; \
|
|
|
|
|
.popsection
|
2016-10-12 22:07:14 -04:00
|
|
|
#else
|
|
|
|
|
#define _ASM_NOKPROBE_SYMBOL(entry)
|
|
|
|
|
#endif
|
2016-09-16 06:48:17 -04:00
|
|
|
|
2016-06-30 18:19:44 -04:00
|
|
|
#define FUNC_START(name) _GLOBAL(name)
|
|
|
|
|
#define FUNC_END(name)
|
|
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
/*
|
2006-01-12 22:56:25 -05:00
|
|
|
* LOAD_REG_IMMEDIATE(rn, expr)
|
|
|
|
|
* Loads the value of the constant expression 'expr' into register 'rn'
|
|
|
|
|
* using immediate instructions only. Use this when it's important not
|
|
|
|
|
* to reference other data (i.e. on ppc64 when the TOC pointer is not
|
2008-08-29 21:41:12 -04:00
|
|
|
* valid) and when 'expr' is a constant or absolute address.
|
2005-09-09 16:02:25 -04:00
|
|
|
*
|
2006-01-12 22:56:25 -05:00
|
|
|
* LOAD_REG_ADDR(rn, name)
|
|
|
|
|
* Loads the address of label 'name' into register 'rn'. Use this when
|
|
|
|
|
* you don't particularly need immediate instructions only, but you need
|
|
|
|
|
* the whole address in one register (e.g. it's a structure address and
|
|
|
|
|
* you want to access various offsets within it). On ppc32 this is
|
|
|
|
|
* identical to LOAD_REG_IMMEDIATE.
|
|
|
|
|
*
|
2013-12-24 02:12:05 -05:00
|
|
|
* LOAD_REG_ADDR_PIC(rn, name)
|
|
|
|
|
* Loads the address of label 'name' into register 'run'. Use this when
|
|
|
|
|
* the kernel doesn't run at the linked or relocated address. Please
|
|
|
|
|
* note that this macro will clobber the lr register.
|
|
|
|
|
*
|
2006-01-12 22:56:25 -05:00
|
|
|
* LOAD_REG_ADDRBASE(rn, name)
|
|
|
|
|
* ADDROFF(name)
|
|
|
|
|
* LOAD_REG_ADDRBASE loads part of the address of label 'name' into
|
|
|
|
|
* register 'rn'. ADDROFF(name) returns the remainder of the address as
|
|
|
|
|
* a constant expression. ADDROFF(name) is a signed expression < 16 bits
|
|
|
|
|
* in size, so is suitable for use directly as an offset in load and store
|
|
|
|
|
* instructions. Use this when loading/storing a single word or less as:
|
|
|
|
|
* LOAD_REG_ADDRBASE(rX, name)
|
|
|
|
|
* ld rY,ADDROFF(name)(rX)
|
2005-09-09 16:02:25 -04:00
|
|
|
*/
|
2013-12-24 02:12:05 -05:00
|
|
|
|
|
|
|
|
/* Be careful, this will clobber the lr register. */
|
|
|
|
|
#define LOAD_REG_ADDR_PIC(reg, name) \
|
|
|
|
|
bl 0f; \
|
|
|
|
|
0: mflr reg; \
|
|
|
|
|
addis reg,reg,(name - 0b)@ha; \
|
|
|
|
|
addi reg,reg,(name - 0b)@l;
|
|
|
|
|
|
powerpc: rewrite LOAD_REG_IMMEDIATE() as an intelligent macro
Today LOAD_REG_IMMEDIATE() is a basic #define which loads all
parts on a value into a register, including the parts that are NUL.
This means always 2 instructions on PPC32 and always 5 instructions
on PPC64. And those instructions cannot run in parallele as they are
updating the same register.
Ex: LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
3c 20 00 00 lis r1,0
60 21 00 00 ori r1,r1,0
78 21 07 c6 rldicr r1,r1,32,31
64 21 00 00 oris r1,r1,0
60 21 40 00 ori r1,r1,16384
Rewrite LOAD_REG_IMMEDIATE() with GAS macro in order to skip
the parts that are NUL.
Rename existing LOAD_REG_IMMEDIATE() as LOAD_REG_IMMEDIATE_SYM()
and use that one for loading value of symbols which are not known
at compile time.
Now LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
38 20 40 00 li r1,16384
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/d60ce8dd3a383c7adbfc322bf1d53d81724a6000.1566311636.git.christophe.leroy@c-s.fr
2019-08-20 10:34:12 -04:00
|
|
|
#if defined(__powerpc64__) && defined(HAVE_AS_ATHIGH)
|
2014-05-15 12:33:42 -04:00
|
|
|
#define __AS_ATHIGH high
|
|
|
|
|
#else
|
|
|
|
|
#define __AS_ATHIGH h
|
|
|
|
|
#endif
|
powerpc: rewrite LOAD_REG_IMMEDIATE() as an intelligent macro
Today LOAD_REG_IMMEDIATE() is a basic #define which loads all
parts on a value into a register, including the parts that are NUL.
This means always 2 instructions on PPC32 and always 5 instructions
on PPC64. And those instructions cannot run in parallele as they are
updating the same register.
Ex: LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
3c 20 00 00 lis r1,0
60 21 00 00 ori r1,r1,0
78 21 07 c6 rldicr r1,r1,32,31
64 21 00 00 oris r1,r1,0
60 21 40 00 ori r1,r1,16384
Rewrite LOAD_REG_IMMEDIATE() with GAS macro in order to skip
the parts that are NUL.
Rename existing LOAD_REG_IMMEDIATE() as LOAD_REG_IMMEDIATE_SYM()
and use that one for loading value of symbols which are not known
at compile time.
Now LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
38 20 40 00 li r1,16384
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/d60ce8dd3a383c7adbfc322bf1d53d81724a6000.1566311636.git.christophe.leroy@c-s.fr
2019-08-20 10:34:12 -04:00
|
|
|
|
|
|
|
|
.macro __LOAD_REG_IMMEDIATE_32 r, x
|
|
|
|
|
.if (\x) >= 0x8000 || (\x) < -0x8000
|
|
|
|
|
lis \r, (\x)@__AS_ATHIGH
|
|
|
|
|
.if (\x) & 0xffff != 0
|
|
|
|
|
ori \r, \r, (\x)@l
|
|
|
|
|
.endif
|
|
|
|
|
.else
|
|
|
|
|
li \r, (\x)@l
|
|
|
|
|
.endif
|
|
|
|
|
.endm
|
|
|
|
|
|
|
|
|
|
.macro __LOAD_REG_IMMEDIATE r, x
|
|
|
|
|
.if (\x) >= 0x80000000 || (\x) < -0x80000000
|
|
|
|
|
__LOAD_REG_IMMEDIATE_32 \r, (\x) >> 32
|
|
|
|
|
sldi \r, \r, 32
|
|
|
|
|
.if (\x) & 0xffff0000 != 0
|
|
|
|
|
oris \r, \r, (\x)@__AS_ATHIGH
|
|
|
|
|
.endif
|
|
|
|
|
.if (\x) & 0xffff != 0
|
|
|
|
|
ori \r, \r, (\x)@l
|
|
|
|
|
.endif
|
|
|
|
|
.else
|
|
|
|
|
__LOAD_REG_IMMEDIATE_32 \r, \x
|
|
|
|
|
.endif
|
|
|
|
|
.endm
|
|
|
|
|
|
|
|
|
|
#ifdef __powerpc64__
|
|
|
|
|
|
|
|
|
|
#define LOAD_REG_IMMEDIATE(reg, expr) __LOAD_REG_IMMEDIATE reg, expr
|
|
|
|
|
|
2019-08-20 10:34:14 -04:00
|
|
|
#define LOAD_REG_IMMEDIATE_SYM(reg, tmp, expr) \
|
|
|
|
|
lis tmp, (expr)@highest; \
|
|
|
|
|
lis reg, (expr)@__AS_ATHIGH; \
|
|
|
|
|
ori tmp, tmp, (expr)@higher; \
|
|
|
|
|
ori reg, reg, (expr)@l; \
|
|
|
|
|
rldimi reg, tmp, 32, 0
|
2006-01-12 22:56:25 -05:00
|
|
|
|
|
|
|
|
#define LOAD_REG_ADDR(reg,name) \
|
2012-06-25 09:33:09 -04:00
|
|
|
ld reg,name@got(r2)
|
2006-01-12 22:56:25 -05:00
|
|
|
|
|
|
|
|
#define LOAD_REG_ADDRBASE(reg,name) LOAD_REG_ADDR(reg,name)
|
|
|
|
|
#define ADDROFF(name) 0
|
2005-10-05 20:59:19 -04:00
|
|
|
|
2005-10-28 08:53:37 -04:00
|
|
|
/* offsets for stack frame layout */
|
|
|
|
|
#define LRSAVE 16
|
2005-10-05 20:59:19 -04:00
|
|
|
|
|
|
|
|
#else /* 32-bit */
|
2005-10-12 03:44:55 -04:00
|
|
|
|
powerpc: rewrite LOAD_REG_IMMEDIATE() as an intelligent macro
Today LOAD_REG_IMMEDIATE() is a basic #define which loads all
parts on a value into a register, including the parts that are NUL.
This means always 2 instructions on PPC32 and always 5 instructions
on PPC64. And those instructions cannot run in parallele as they are
updating the same register.
Ex: LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
3c 20 00 00 lis r1,0
60 21 00 00 ori r1,r1,0
78 21 07 c6 rldicr r1,r1,32,31
64 21 00 00 oris r1,r1,0
60 21 40 00 ori r1,r1,16384
Rewrite LOAD_REG_IMMEDIATE() with GAS macro in order to skip
the parts that are NUL.
Rename existing LOAD_REG_IMMEDIATE() as LOAD_REG_IMMEDIATE_SYM()
and use that one for loading value of symbols which are not known
at compile time.
Now LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
38 20 40 00 li r1,16384
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/d60ce8dd3a383c7adbfc322bf1d53d81724a6000.1566311636.git.christophe.leroy@c-s.fr
2019-08-20 10:34:12 -04:00
|
|
|
#define LOAD_REG_IMMEDIATE(reg, expr) __LOAD_REG_IMMEDIATE_32 reg, expr
|
|
|
|
|
|
|
|
|
|
#define LOAD_REG_IMMEDIATE_SYM(reg,expr) \
|
2012-06-25 09:33:09 -04:00
|
|
|
lis reg,(expr)@ha; \
|
|
|
|
|
addi reg,reg,(expr)@l;
|
2006-01-12 22:56:25 -05:00
|
|
|
|
powerpc: rewrite LOAD_REG_IMMEDIATE() as an intelligent macro
Today LOAD_REG_IMMEDIATE() is a basic #define which loads all
parts on a value into a register, including the parts that are NUL.
This means always 2 instructions on PPC32 and always 5 instructions
on PPC64. And those instructions cannot run in parallele as they are
updating the same register.
Ex: LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
3c 20 00 00 lis r1,0
60 21 00 00 ori r1,r1,0
78 21 07 c6 rldicr r1,r1,32,31
64 21 00 00 oris r1,r1,0
60 21 40 00 ori r1,r1,16384
Rewrite LOAD_REG_IMMEDIATE() with GAS macro in order to skip
the parts that are NUL.
Rename existing LOAD_REG_IMMEDIATE() as LOAD_REG_IMMEDIATE_SYM()
and use that one for loading value of symbols which are not known
at compile time.
Now LOAD_REG_IMMEDIATE(r1,THREAD_SIZE) in head_64.S results in:
38 20 40 00 li r1,16384
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/d60ce8dd3a383c7adbfc322bf1d53d81724a6000.1566311636.git.christophe.leroy@c-s.fr
2019-08-20 10:34:12 -04:00
|
|
|
#define LOAD_REG_ADDR(reg,name) LOAD_REG_IMMEDIATE_SYM(reg, name)
|
2005-10-05 20:59:19 -04:00
|
|
|
|
2012-06-25 09:33:09 -04:00
|
|
|
#define LOAD_REG_ADDRBASE(reg, name) lis reg,name@ha
|
2006-01-12 22:56:25 -05:00
|
|
|
#define ADDROFF(name) name@l
|
2005-10-05 20:59:19 -04:00
|
|
|
|
2005-10-28 08:53:37 -04:00
|
|
|
/* offsets for stack frame layout */
|
|
|
|
|
#define LRSAVE 4
|
2005-10-05 20:59:19 -04:00
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
/* various errata or part fixups */
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef CONFIG_PPC601_SYNC_FIX
|
2019-08-26 11:52:14 -04:00
|
|
|
#define SYNC sync; isync
|
|
|
|
|
#define SYNC_601 sync
|
|
|
|
|
#define ISYNC_601 isync
|
2005-04-16 18:20:36 -04:00
|
|
|
#else
|
|
|
|
|
#define SYNC
|
|
|
|
|
#define SYNC_601
|
|
|
|
|
#define ISYNC_601
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-07-23 21:21:11 -04:00
|
|
|
#if defined(CONFIG_PPC_CELL) || defined(CONFIG_PPC_FSL_BOOK3E)
|
2006-10-20 00:37:05 -04:00
|
|
|
#define MFTB(dest) \
|
2013-08-20 20:33:12 -04:00
|
|
|
90: mfspr dest, SPRN_TBRL; \
|
2006-10-20 00:37:05 -04:00
|
|
|
BEGIN_FTR_SECTION_NESTED(96); \
|
|
|
|
|
cmpwi dest,0; \
|
|
|
|
|
beq- 90b; \
|
|
|
|
|
END_FTR_SECTION_NESTED(CPU_FTR_CELL_TB_BUG, CPU_FTR_CELL_TB_BUG, 96)
|
|
|
|
|
#else
|
2017-08-08 07:58:50 -04:00
|
|
|
#define MFTB(dest) MFTBL(dest)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_8xx
|
|
|
|
|
#define MFTBL(dest) mftb dest
|
|
|
|
|
#define MFTBU(dest) mftbu dest
|
|
|
|
|
#else
|
|
|
|
|
#define MFTBL(dest) mfspr dest, SPRN_TBRL
|
|
|
|
|
#define MFTBU(dest) mfspr dest, SPRN_TBRU
|
2006-10-20 00:37:05 -04:00
|
|
|
#endif
|
2005-09-09 16:02:25 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* tlbsync is not implemented on 601 */
|
2019-08-26 11:52:14 -04:00
|
|
|
#if !defined(CONFIG_SMP) || defined(CONFIG_PPC_BOOK3S_601)
|
|
|
|
|
#define TLBSYNC
|
|
|
|
|
#else
|
|
|
|
|
#define TLBSYNC tlbsync; sync
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
|
|
|
|
|
2012-04-17 22:21:52 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
#define MTOCRF(FXM, RS) \
|
|
|
|
|
BEGIN_FTR_SECTION_NESTED(848); \
|
2012-06-25 09:33:16 -04:00
|
|
|
mtcrf (FXM), RS; \
|
2012-04-17 22:21:52 -04:00
|
|
|
FTR_SECTION_ELSE_NESTED(848); \
|
2012-06-25 09:33:16 -04:00
|
|
|
mtocrf (FXM), RS; \
|
2012-04-17 22:21:52 -04:00
|
|
|
ALT_FTR_SECTION_END_NESTED_IFCLR(CPU_FTR_NOEXECUTE, 848)
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
|
* This instruction is not implemented on the PPC 603 or 601; however, on
|
|
|
|
|
* the 403GCX and 405GP tlbia IS defined and tlbie is not.
|
|
|
|
|
* All of these instructions exist in the 8xx, they have magical powers,
|
|
|
|
|
* and they must be used.
|
|
|
|
|
*/
|
|
|
|
|
|
2017-08-08 07:58:54 -04:00
|
|
|
#if !defined(CONFIG_4xx) && !defined(CONFIG_PPC_8xx)
|
2005-04-16 18:20:36 -04:00
|
|
|
#define tlbia \
|
|
|
|
|
li r4,1024; \
|
|
|
|
|
mtctr r4; \
|
|
|
|
|
lis r4,KERNELBASE@h; \
|
2016-03-02 01:12:45 -05:00
|
|
|
.machine push; \
|
|
|
|
|
.machine "power4"; \
|
2005-04-16 18:20:36 -04:00
|
|
|
0: tlbie r4; \
|
2016-03-02 01:12:45 -05:00
|
|
|
.machine pop; \
|
2005-04-16 18:20:36 -04:00
|
|
|
addi r4,r4,0x1000; \
|
|
|
|
|
bdnz 0b
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_IBM440EP_ERR42
|
|
|
|
|
#define PPC440EP_ERR42 isync
|
|
|
|
|
#else
|
|
|
|
|
#define PPC440EP_ERR42
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-05-29 15:34:27 -04:00
|
|
|
/* The following stops all load and store data streams associated with stream
|
|
|
|
|
* ID (ie. streams created explicitly). The embedded and server mnemonics for
|
2018-02-20 14:08:26 -05:00
|
|
|
* dcbt are different so this must only be used for server.
|
2013-05-29 15:34:27 -04:00
|
|
|
*/
|
2018-02-20 14:08:26 -05:00
|
|
|
#define DCBT_BOOK3S_STOP_ALL_STREAM_IDS(scratch) \
|
|
|
|
|
lis scratch,0x60000000@h; \
|
|
|
|
|
dcbt 0,scratch,0b01010
|
2013-05-29 15:34:27 -04:00
|
|
|
|
2009-07-23 19:15:20 -04:00
|
|
|
/*
|
|
|
|
|
* toreal/fromreal/tophys/tovirt macros. 32-bit BookE makes them
|
|
|
|
|
* keep the address intact to be compatible with code shared with
|
|
|
|
|
* 32-bit classic.
|
|
|
|
|
*
|
|
|
|
|
* On the other hand, I find it useful to have them behave as expected
|
|
|
|
|
* by their name (ie always do the addition) on 64-bit BookE
|
|
|
|
|
*/
|
|
|
|
|
#if defined(CONFIG_BOOKE) && !defined(CONFIG_PPC64)
|
2005-10-27 08:44:39 -04:00
|
|
|
#define toreal(rd)
|
|
|
|
|
#define fromreal(rd)
|
|
|
|
|
|
2008-05-10 20:40:47 -04:00
|
|
|
/*
|
|
|
|
|
* We use addis to ensure compatibility with the "classic" ppc versions of
|
|
|
|
|
* these macros, which use rs = 0 to get the tophys offset in rd, rather than
|
|
|
|
|
* converting the address in r0, and so this version has to do that too
|
|
|
|
|
* (i.e. set register rd to 0 when rs == 0).
|
|
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
#define tophys(rd,rs) \
|
|
|
|
|
addis rd,rs,0
|
|
|
|
|
|
|
|
|
|
#define tovirt(rd,rs) \
|
|
|
|
|
addis rd,rs,0
|
|
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
#elif defined(CONFIG_PPC64)
|
2005-10-27 08:44:39 -04:00
|
|
|
#define toreal(rd) /* we can access c000... in real mode */
|
|
|
|
|
#define fromreal(rd)
|
|
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
#define tophys(rd,rs) \
|
2005-10-27 08:44:39 -04:00
|
|
|
clrldi rd,rs,2
|
2005-09-09 16:02:25 -04:00
|
|
|
|
|
|
|
|
#define tovirt(rd,rs) \
|
2005-10-27 08:44:39 -04:00
|
|
|
rotldi rd,rs,16; \
|
|
|
|
|
ori rd,rd,((KERNELBASE>>48)&0xFFFF);\
|
|
|
|
|
rotldi rd,rd,48
|
2005-09-09 16:02:25 -04:00
|
|
|
#else
|
2005-10-27 08:44:39 -04:00
|
|
|
#define toreal(rd) tophys(rd,rd)
|
|
|
|
|
#define fromreal(rd) tovirt(rd,rd)
|
|
|
|
|
|
2018-12-04 12:59:15 -05:00
|
|
|
#define tophys(rd, rs) addis rd, rs, -PAGE_OFFSET@h
|
|
|
|
|
#define tovirt(rd, rs) addis rd, rs, PAGE_OFFSET@h
|
2005-09-09 16:02:25 -04:00
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2009-07-23 19:15:20 -04:00
|
|
|
#ifdef CONFIG_PPC_BOOK3S_64
|
2005-10-10 08:50:37 -04:00
|
|
|
#define RFI rfid
|
|
|
|
|
#define MTMSRD(r) mtmsrd r
|
2012-07-04 00:49:12 -04:00
|
|
|
#define MTMSR_EERI(reg) mtmsrd reg,1
|
2005-04-16 18:20:36 -04:00
|
|
|
#else
|
|
|
|
|
#ifndef CONFIG_40x
|
|
|
|
|
#define RFI rfi
|
|
|
|
|
#else
|
|
|
|
|
#define RFI rfi; b . /* Prevent prefetch past rfi */
|
|
|
|
|
#endif
|
|
|
|
|
#define MTMSRD(r) mtmsr r
|
2012-07-04 00:49:12 -04:00
|
|
|
#define MTMSR_EERI(reg) mtmsr reg
|
2005-08-01 01:34:52 -04:00
|
|
|
#endif
|
|
|
|
|
|
2005-12-16 16:43:46 -05:00
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* The boring bits... */
|
|
|
|
|
|
|
|
|
|
/* Condition Register Bit Fields */
|
|
|
|
|
|
|
|
|
|
#define cr0 0
|
|
|
|
|
#define cr1 1
|
|
|
|
|
#define cr2 2
|
|
|
|
|
#define cr3 3
|
|
|
|
|
#define cr4 4
|
|
|
|
|
#define cr5 5
|
|
|
|
|
#define cr6 6
|
|
|
|
|
#define cr7 7
|
|
|
|
|
|
|
|
|
|
|
2012-06-25 09:33:12 -04:00
|
|
|
/*
|
|
|
|
|
* General Purpose Registers (GPRs)
|
|
|
|
|
*
|
|
|
|
|
* The lower case r0-r31 should be used in preference to the upper
|
|
|
|
|
* case R0-R31 as they provide more error checking in the assembler.
|
|
|
|
|
* Use R0-31 only when really nessesary.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define r0 %r0
|
|
|
|
|
#define r1 %r1
|
|
|
|
|
#define r2 %r2
|
|
|
|
|
#define r3 %r3
|
|
|
|
|
#define r4 %r4
|
|
|
|
|
#define r5 %r5
|
|
|
|
|
#define r6 %r6
|
|
|
|
|
#define r7 %r7
|
|
|
|
|
#define r8 %r8
|
|
|
|
|
#define r9 %r9
|
|
|
|
|
#define r10 %r10
|
|
|
|
|
#define r11 %r11
|
|
|
|
|
#define r12 %r12
|
|
|
|
|
#define r13 %r13
|
|
|
|
|
#define r14 %r14
|
|
|
|
|
#define r15 %r15
|
|
|
|
|
#define r16 %r16
|
|
|
|
|
#define r17 %r17
|
|
|
|
|
#define r18 %r18
|
|
|
|
|
#define r19 %r19
|
|
|
|
|
#define r20 %r20
|
|
|
|
|
#define r21 %r21
|
|
|
|
|
#define r22 %r22
|
|
|
|
|
#define r23 %r23
|
|
|
|
|
#define r24 %r24
|
|
|
|
|
#define r25 %r25
|
|
|
|
|
#define r26 %r26
|
|
|
|
|
#define r27 %r27
|
|
|
|
|
#define r28 %r28
|
|
|
|
|
#define r29 %r29
|
|
|
|
|
#define r30 %r30
|
|
|
|
|
#define r31 %r31
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Floating Point Registers (FPRs) */
|
|
|
|
|
|
|
|
|
|
#define fr0 0
|
|
|
|
|
#define fr1 1
|
|
|
|
|
#define fr2 2
|
|
|
|
|
#define fr3 3
|
|
|
|
|
#define fr4 4
|
|
|
|
|
#define fr5 5
|
|
|
|
|
#define fr6 6
|
|
|
|
|
#define fr7 7
|
|
|
|
|
#define fr8 8
|
|
|
|
|
#define fr9 9
|
|
|
|
|
#define fr10 10
|
|
|
|
|
#define fr11 11
|
|
|
|
|
#define fr12 12
|
|
|
|
|
#define fr13 13
|
|
|
|
|
#define fr14 14
|
|
|
|
|
#define fr15 15
|
|
|
|
|
#define fr16 16
|
|
|
|
|
#define fr17 17
|
|
|
|
|
#define fr18 18
|
|
|
|
|
#define fr19 19
|
|
|
|
|
#define fr20 20
|
|
|
|
|
#define fr21 21
|
|
|
|
|
#define fr22 22
|
|
|
|
|
#define fr23 23
|
|
|
|
|
#define fr24 24
|
|
|
|
|
#define fr25 25
|
|
|
|
|
#define fr26 26
|
|
|
|
|
#define fr27 27
|
|
|
|
|
#define fr28 28
|
|
|
|
|
#define fr29 29
|
|
|
|
|
#define fr30 30
|
|
|
|
|
#define fr31 31
|
|
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
/* AltiVec Registers (VPRs) */
|
|
|
|
|
|
2015-02-09 17:51:22 -05:00
|
|
|
#define v0 0
|
|
|
|
|
#define v1 1
|
|
|
|
|
#define v2 2
|
|
|
|
|
#define v3 3
|
|
|
|
|
#define v4 4
|
|
|
|
|
#define v5 5
|
|
|
|
|
#define v6 6
|
|
|
|
|
#define v7 7
|
|
|
|
|
#define v8 8
|
|
|
|
|
#define v9 9
|
|
|
|
|
#define v10 10
|
|
|
|
|
#define v11 11
|
|
|
|
|
#define v12 12
|
|
|
|
|
#define v13 13
|
|
|
|
|
#define v14 14
|
|
|
|
|
#define v15 15
|
|
|
|
|
#define v16 16
|
|
|
|
|
#define v17 17
|
|
|
|
|
#define v18 18
|
|
|
|
|
#define v19 19
|
|
|
|
|
#define v20 20
|
|
|
|
|
#define v21 21
|
|
|
|
|
#define v22 22
|
|
|
|
|
#define v23 23
|
|
|
|
|
#define v24 24
|
|
|
|
|
#define v25 25
|
|
|
|
|
#define v26 26
|
|
|
|
|
#define v27 27
|
|
|
|
|
#define v28 28
|
|
|
|
|
#define v29 29
|
|
|
|
|
#define v30 30
|
|
|
|
|
#define v31 31
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-06-25 00:07:18 -04:00
|
|
|
/* VSX Registers (VSRs) */
|
|
|
|
|
|
2015-02-09 17:51:23 -05:00
|
|
|
#define vs0 0
|
|
|
|
|
#define vs1 1
|
|
|
|
|
#define vs2 2
|
|
|
|
|
#define vs3 3
|
|
|
|
|
#define vs4 4
|
|
|
|
|
#define vs5 5
|
|
|
|
|
#define vs6 6
|
|
|
|
|
#define vs7 7
|
|
|
|
|
#define vs8 8
|
|
|
|
|
#define vs9 9
|
|
|
|
|
#define vs10 10
|
|
|
|
|
#define vs11 11
|
|
|
|
|
#define vs12 12
|
|
|
|
|
#define vs13 13
|
|
|
|
|
#define vs14 14
|
|
|
|
|
#define vs15 15
|
|
|
|
|
#define vs16 16
|
|
|
|
|
#define vs17 17
|
|
|
|
|
#define vs18 18
|
|
|
|
|
#define vs19 19
|
|
|
|
|
#define vs20 20
|
|
|
|
|
#define vs21 21
|
|
|
|
|
#define vs22 22
|
|
|
|
|
#define vs23 23
|
|
|
|
|
#define vs24 24
|
|
|
|
|
#define vs25 25
|
|
|
|
|
#define vs26 26
|
|
|
|
|
#define vs27 27
|
|
|
|
|
#define vs28 28
|
|
|
|
|
#define vs29 29
|
|
|
|
|
#define vs30 30
|
|
|
|
|
#define vs31 31
|
|
|
|
|
#define vs32 32
|
|
|
|
|
#define vs33 33
|
|
|
|
|
#define vs34 34
|
|
|
|
|
#define vs35 35
|
|
|
|
|
#define vs36 36
|
|
|
|
|
#define vs37 37
|
|
|
|
|
#define vs38 38
|
|
|
|
|
#define vs39 39
|
|
|
|
|
#define vs40 40
|
|
|
|
|
#define vs41 41
|
|
|
|
|
#define vs42 42
|
|
|
|
|
#define vs43 43
|
|
|
|
|
#define vs44 44
|
|
|
|
|
#define vs45 45
|
|
|
|
|
#define vs46 46
|
|
|
|
|
#define vs47 47
|
|
|
|
|
#define vs48 48
|
|
|
|
|
#define vs49 49
|
|
|
|
|
#define vs50 50
|
|
|
|
|
#define vs51 51
|
|
|
|
|
#define vs52 52
|
|
|
|
|
#define vs53 53
|
|
|
|
|
#define vs54 54
|
|
|
|
|
#define vs55 55
|
|
|
|
|
#define vs56 56
|
|
|
|
|
#define vs57 57
|
|
|
|
|
#define vs58 58
|
|
|
|
|
#define vs59 59
|
|
|
|
|
#define vs60 60
|
|
|
|
|
#define vs61 61
|
|
|
|
|
#define vs62 62
|
|
|
|
|
#define vs63 63
|
2008-06-25 00:07:18 -04:00
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
/* SPE Registers (EVPRs) */
|
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#define evr0 0
|
|
|
|
|
#define evr1 1
|
|
|
|
|
#define evr2 2
|
|
|
|
|
#define evr3 3
|
|
|
|
|
#define evr4 4
|
|
|
|
|
#define evr5 5
|
|
|
|
|
#define evr6 6
|
|
|
|
|
#define evr7 7
|
|
|
|
|
#define evr8 8
|
|
|
|
|
#define evr9 9
|
|
|
|
|
#define evr10 10
|
|
|
|
|
#define evr11 11
|
|
|
|
|
#define evr12 12
|
|
|
|
|
#define evr13 13
|
|
|
|
|
#define evr14 14
|
|
|
|
|
#define evr15 15
|
|
|
|
|
#define evr16 16
|
|
|
|
|
#define evr17 17
|
|
|
|
|
#define evr18 18
|
|
|
|
|
#define evr19 19
|
|
|
|
|
#define evr20 20
|
|
|
|
|
#define evr21 21
|
|
|
|
|
#define evr22 22
|
|
|
|
|
#define evr23 23
|
|
|
|
|
#define evr24 24
|
|
|
|
|
#define evr25 25
|
|
|
|
|
#define evr26 26
|
|
|
|
|
#define evr27 27
|
|
|
|
|
#define evr28 28
|
|
|
|
|
#define evr29 29
|
|
|
|
|
#define evr30 30
|
|
|
|
|
#define evr31 31
|
|
|
|
|
|
|
|
|
|
/* some stab codes */
|
|
|
|
|
#define N_FUN 36
|
|
|
|
|
#define N_RSYM 64
|
|
|
|
|
#define N_SLINE 68
|
|
|
|
|
#define N_SO 100
|
2005-09-09 16:02:25 -04:00
|
|
|
|
2013-09-22 22:04:45 -04:00
|
|
|
/*
|
|
|
|
|
* Create an endian fixup trampoline
|
|
|
|
|
*
|
|
|
|
|
* This starts with a "tdi 0,0,0x48" instruction which is
|
|
|
|
|
* essentially a "trap never", and thus akin to a nop.
|
|
|
|
|
*
|
|
|
|
|
* The opcode for this instruction read with the wrong endian
|
|
|
|
|
* however results in a b . + 8
|
|
|
|
|
*
|
|
|
|
|
* So essentially we use that trick to execute the following
|
|
|
|
|
* trampoline in "reverse endian" if we are running with the
|
|
|
|
|
* MSR_LE bit set the "wrong" way for whatever endianness the
|
|
|
|
|
* kernel is built for.
|
|
|
|
|
*/
|
2005-09-09 16:02:25 -04:00
|
|
|
|
2013-09-22 22:04:45 -04:00
|
|
|
#ifdef CONFIG_PPC_BOOK3E
|
|
|
|
|
#define FIXUP_ENDIAN
|
|
|
|
|
#else
|
2017-10-23 03:08:14 -04:00
|
|
|
/*
|
|
|
|
|
* This version may be used in in HV or non-HV context.
|
|
|
|
|
* MSR[EE] must be disabled.
|
|
|
|
|
*/
|
2013-09-22 22:04:45 -04:00
|
|
|
#define FIXUP_ENDIAN \
|
|
|
|
|
tdi 0,0,0x48; /* Reverse endian of b . + 8 */ \
|
2017-10-23 03:08:13 -04:00
|
|
|
b 191f; /* Skip trampoline if endian is good */ \
|
2013-09-22 22:04:45 -04:00
|
|
|
.long 0xa600607d; /* mfmsr r11 */ \
|
|
|
|
|
.long 0x01006b69; /* xori r11,r11,1 */ \
|
2017-05-01 08:01:09 -04:00
|
|
|
.long 0x00004039; /* li r10,0 */ \
|
|
|
|
|
.long 0x6401417d; /* mtmsrd r10,1 */ \
|
|
|
|
|
.long 0x05009f42; /* bcl 20,31,$+4 */ \
|
|
|
|
|
.long 0xa602487d; /* mflr r10 */ \
|
|
|
|
|
.long 0x14004a39; /* addi r10,r10,20 */ \
|
2013-09-22 22:04:45 -04:00
|
|
|
.long 0xa6035a7d; /* mtsrr0 r10 */ \
|
|
|
|
|
.long 0xa6037b7d; /* mtsrr1 r11 */ \
|
2017-10-23 03:08:13 -04:00
|
|
|
.long 0x2400004c; /* rfid */ \
|
|
|
|
|
191:
|
2017-05-01 08:01:09 -04:00
|
|
|
|
2017-10-23 03:08:14 -04:00
|
|
|
/*
|
|
|
|
|
* This version that may only be used with MSR[HV]=1
|
|
|
|
|
* - Does not clear MSR[RI], so more robust.
|
|
|
|
|
* - Slightly smaller and faster.
|
|
|
|
|
*/
|
|
|
|
|
#define FIXUP_ENDIAN_HV \
|
|
|
|
|
tdi 0,0,0x48; /* Reverse endian of b . + 8 */ \
|
|
|
|
|
b 191f; /* Skip trampoline if endian is good */ \
|
|
|
|
|
.long 0xa600607d; /* mfmsr r11 */ \
|
|
|
|
|
.long 0x01006b69; /* xori r11,r11,1 */ \
|
|
|
|
|
.long 0x05009f42; /* bcl 20,31,$+4 */ \
|
|
|
|
|
.long 0xa602487d; /* mflr r10 */ \
|
|
|
|
|
.long 0x14004a39; /* addi r10,r10,20 */ \
|
|
|
|
|
.long 0xa64b5a7d; /* mthsrr0 r10 */ \
|
|
|
|
|
.long 0xa64b7b7d; /* mthsrr1 r11 */ \
|
|
|
|
|
.long 0x2402004c; /* hrfid */ \
|
|
|
|
|
191:
|
|
|
|
|
|
2013-09-22 22:04:45 -04:00
|
|
|
#endif /* !CONFIG_PPC_BOOK3E */
|
2016-10-14 00:58:28 -04:00
|
|
|
|
2013-09-22 22:04:45 -04:00
|
|
|
#endif /* __ASSEMBLY__ */
|
2016-10-14 00:58:28 -04:00
|
|
|
|
2016-10-13 01:42:53 -04:00
|
|
|
/*
|
|
|
|
|
* Helper macro for exception table entries
|
|
|
|
|
*/
|
|
|
|
|
#define EX_TABLE(_fault, _target) \
|
|
|
|
|
stringify_in_c(.section __ex_table,"a";)\
|
2016-10-14 01:47:31 -04:00
|
|
|
stringify_in_c(.balign 4;) \
|
|
|
|
|
stringify_in_c(.long (_fault) - . ;) \
|
|
|
|
|
stringify_in_c(.long (_target) - . ;) \
|
2016-10-13 01:42:53 -04:00
|
|
|
stringify_in_c(.previous)
|
|
|
|
|
|
2018-12-12 09:03:01 -05:00
|
|
|
#ifdef CONFIG_PPC_FSL_BOOK3E
|
|
|
|
|
#define BTB_FLUSH(reg) \
|
|
|
|
|
lis reg,BUCSR_INIT@h; \
|
|
|
|
|
ori reg,reg,BUCSR_INIT@l; \
|
|
|
|
|
mtspr SPRN_BUCSR,reg; \
|
|
|
|
|
isync;
|
|
|
|
|
#else
|
|
|
|
|
#define BTB_FLUSH(reg)
|
|
|
|
|
#endif /* CONFIG_PPC_FSL_BOOK3E */
|
|
|
|
|
|
2005-09-09 16:02:25 -04:00
|
|
|
#endif /* _ASM_POWERPC_PPC_ASM_H */
|
