* [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier
@ 2021-05-04 13:42 Michael Ellerman
2021-05-04 13:42 ` [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier Michael Ellerman
` (2 more replies)
0 siblings, 3 replies; 7+ messages in thread
From: Michael Ellerman @ 2021-05-04 13:42 UTC (permalink / raw)
To: linuxppc-dev; +Cc: nathanl, anton, npiggin, dja
The STF (store-to-load forwarding) barrier mitigation can be
enabled/disabled at runtime via a debugfs file (stf_barrier), which
causes the kernel to patch itself to enable/disable the relevant
mitigations.
However depending on which mitigation we're using, it may not be safe to
do that patching while other CPUs are active. For example the following
crash:
User access of kernel address (c00000003fff5af0) - exploit attempt? (uid: 0)
segfault (11) at c00000003fff5af0 nip 7fff8ad12198 lr 7fff8ad121f8 code 1
code: 40820128 e93c00d0 e9290058 7c292840 40810058 38600000 4bfd9a81 e8410018
code: 2c030006 41810154 3860ffb6 e9210098 <e94d8ff0> 7d295279 39400000 40820a3c
Shows that we returned to userspace without restoring the user r13
value, due to executing the partially patched STF exit code.
Fix it by doing the patching under stop machine. The CPUs that aren't
doing the patching will be spinning in the core of the stop machine
logic. That is currently sufficient for our purposes, because none of
the patching we do is to that code or anywhere in the vicinity.
Fixes: a048a07d7f45 ("powerpc/64s: Add support for a store forwarding barrier at kernel entry/exit")
Cc: stable@vger.kernel.org # v4.17+
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
---
arch/powerpc/lib/feature-fixups.c | 19 +++++++++++++++++--
1 file changed, 17 insertions(+), 2 deletions(-)
diff --git a/arch/powerpc/lib/feature-fixups.c b/arch/powerpc/lib/feature-fixups.c
index 1fd31b4b0e13..8f8c8c98a6ac 100644
--- a/arch/powerpc/lib/feature-fixups.c
+++ b/arch/powerpc/lib/feature-fixups.c
@@ -14,6 +14,7 @@
#include <linux/string.h>
#include <linux/init.h>
#include <linux/sched/mm.h>
+#include <linux/stop_machine.h>
#include <asm/cputable.h>
#include <asm/code-patching.h>
#include <asm/page.h>
@@ -227,11 +228,25 @@ static void do_stf_exit_barrier_fixups(enum stf_barrier_type types)
: "unknown");
}
-
-void do_stf_barrier_fixups(enum stf_barrier_type types)
+static int __do_stf_barrier_fixups(void *data)
{
+ enum stf_barrier_type types = (enum stf_barrier_type)data;
+
do_stf_entry_barrier_fixups(types);
do_stf_exit_barrier_fixups(types);
+
+ return 0;
+}
+
+void do_stf_barrier_fixups(enum stf_barrier_type types)
+{
+ /*
+ * The call to the fallback entry flush, and the fallback/sync-ori exit
+ * flush can not be safely patched in/out while other CPUs are executing
+ * them. So call __do_stf_barrier_fixups() on one CPU while all other CPUs
+ * spin in the stop machine core with interrupts hard disabled.
+ */
+ stop_machine_cpuslocked(__do_stf_barrier_fixups, (void *)types, NULL);
}
void do_uaccess_flush_fixups(enum l1d_flush_type types)
--
2.25.1
^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier
2021-05-04 13:42 [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Michael Ellerman
@ 2021-05-04 13:42 ` Michael Ellerman
2021-05-05 20:44 ` kernel test robot
2021-05-04 22:44 ` [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Nathan Lynch
2021-05-05 19:37 ` kernel test robot
2 siblings, 1 reply; 7+ messages in thread
From: Michael Ellerman @ 2021-05-04 13:42 UTC (permalink / raw)
To: linuxppc-dev; +Cc: nathanl, anton, npiggin, dja
The entry flush mitigation can be enabled/disabled at runtime via a
debugfs file (entry_flush), which causes the kernel to patch itself to
enable/disable the relevant mitigations.
However depending on which mitigation we're using, it may not be safe to
do that patching while other CPUs are active. For example the following
crash:
sleeper[15639]: segfault (11) at c000000000004c20 nip c000000000004c20 lr c000000000004c20
Shows that we returned to userspace with a corrupted LR that points into
the kernel, due to executing the partially patched call to the fallback
entry flush (ie. we missed the LR restore).
Fix it by doing the patching under stop machine. The CPUs that aren't
doing the patching will be spinning in the core of the stop machine
logic. That is currently sufficient for our purposes, because none of
the patching we do is to that code or anywhere in the vicinity.
Fixes: f79643787e0a ("powerpc/64s: flush L1D on kernel entry")
Cc: stable@vger.kernel.org # v5.10+
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
---
arch/powerpc/lib/feature-fixups.c | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/lib/feature-fixups.c b/arch/powerpc/lib/feature-fixups.c
index 8f8c8c98a6ac..679833564e19 100644
--- a/arch/powerpc/lib/feature-fixups.c
+++ b/arch/powerpc/lib/feature-fixups.c
@@ -299,8 +299,9 @@ void do_uaccess_flush_fixups(enum l1d_flush_type types)
: "unknown");
}
-void do_entry_flush_fixups(enum l1d_flush_type types)
+static int __do_entry_flush_fixups(void *data)
{
+ enum l1d_flush_type types = (enum l1d_flush_type)data;
unsigned int instrs[3], *dest;
long *start, *end;
int i;
@@ -369,6 +370,19 @@ void do_entry_flush_fixups(enum l1d_flush_type types)
: "ori type" :
(types & L1D_FLUSH_MTTRIG) ? "mttrig type"
: "unknown");
+
+ return 0;
+}
+
+void do_entry_flush_fixups(enum l1d_flush_type types)
+{
+ /*
+ * The call to the fallback flush can not be safely patched in/out while
+ * other CPUs are executing it. So call __do_entry_flush_fixups() on one
+ * CPU while all other CPUs spin in the stop machine core with interrupts
+ * hard disabled.
+ */
+ stop_machine_cpuslocked(__do_entry_flush_fixups, (void *)types, NULL);
}
void do_rfi_flush_fixups(enum l1d_flush_type types)
--
2.25.1
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier
2021-05-04 13:42 [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Michael Ellerman
2021-05-04 13:42 ` [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier Michael Ellerman
@ 2021-05-04 22:44 ` Nathan Lynch
2021-05-05 2:48 ` Michael Ellerman
2021-05-05 19:37 ` kernel test robot
2 siblings, 1 reply; 7+ messages in thread
From: Nathan Lynch @ 2021-05-04 22:44 UTC (permalink / raw)
To: Michael Ellerman; +Cc: linuxppc-dev, anton, npiggin, dja
Michael Ellerman <mpe@ellerman.id.au> writes:
> -void do_stf_barrier_fixups(enum stf_barrier_type types)
> +static int __do_stf_barrier_fixups(void *data)
> {
> + enum stf_barrier_type types = (enum stf_barrier_type)data;
> +
> do_stf_entry_barrier_fixups(types);
> do_stf_exit_barrier_fixups(types);
> +
> + return 0;
> +}
> +
> +void do_stf_barrier_fixups(enum stf_barrier_type types)
> +{
> + /*
> + * The call to the fallback entry flush, and the fallback/sync-ori exit
> + * flush can not be safely patched in/out while other CPUs are executing
> + * them. So call __do_stf_barrier_fixups() on one CPU while all other CPUs
> + * spin in the stop machine core with interrupts hard disabled.
> + */
> + stop_machine_cpuslocked(__do_stf_barrier_fixups, (void *)types, NULL);
Would it be preferable to avoid the explicit casts:
stop_machine_cpuslocked(__do_stf_barrier_fixups, &types, NULL);
...
static int __do_stf_barrier_fixups(void *data)
{
enum stf_barrier_type *types = data;
do_stf_entry_barrier_fixups(*types);
do_stf_exit_barrier_fixups(*types);
?
post_mobility_fixup() does cpus_read_unlock() before calling
pseries_setup_security_mitigations(), I think that will need to be
changed?
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier
2021-05-04 22:44 ` [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Nathan Lynch
@ 2021-05-05 2:48 ` Michael Ellerman
2021-05-05 2:55 ` Nathan Lynch
0 siblings, 1 reply; 7+ messages in thread
From: Michael Ellerman @ 2021-05-05 2:48 UTC (permalink / raw)
To: Nathan Lynch; +Cc: linuxppc-dev, anton, npiggin, dja
Nathan Lynch <nathanl@linux.ibm.com> writes:
> Michael Ellerman <mpe@ellerman.id.au> writes:
>> -void do_stf_barrier_fixups(enum stf_barrier_type types)
>> +static int __do_stf_barrier_fixups(void *data)
>> {
>> + enum stf_barrier_type types = (enum stf_barrier_type)data;
>> +
>> do_stf_entry_barrier_fixups(types);
>> do_stf_exit_barrier_fixups(types);
>> +
>> + return 0;
>> +}
>> +
>> +void do_stf_barrier_fixups(enum stf_barrier_type types)
>> +{
>> + /*
>> + * The call to the fallback entry flush, and the fallback/sync-ori exit
>> + * flush can not be safely patched in/out while other CPUs are executing
>> + * them. So call __do_stf_barrier_fixups() on one CPU while all other CPUs
>> + * spin in the stop machine core with interrupts hard disabled.
>> + */
>> + stop_machine_cpuslocked(__do_stf_barrier_fixups, (void *)types, NULL);
>
> Would it be preferable to avoid the explicit casts:
>
> stop_machine_cpuslocked(__do_stf_barrier_fixups, &types, NULL);
>
> ...
>
> static int __do_stf_barrier_fixups(void *data)
> {
> enum stf_barrier_type *types = data;
>
> do_stf_entry_barrier_fixups(*types);
> do_stf_exit_barrier_fixups(*types);
>
> ?
Yes.
That will also avoid the pesky issue of undefined behaviour :facepalm:
> post_mobility_fixup() does cpus_read_unlock() before calling
> pseries_setup_security_mitigations(), I think that will need to be
> changed?
I don't think so.
I'm using stop_machine_cpuslocked() but that's because I'm a goose and
forgot to switch to stop_machine() after I reworked the code to not take
cpus_read_lock() by hand. I really shouldn't send patches after 11pm.
I don't think it's important to keep the cpus lock held from where we
take it in post_mobility_fixup(). If some CPUs come or go between there
and here that's fine.
I'll send a v2.
cheers
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier
2021-05-05 2:48 ` Michael Ellerman
@ 2021-05-05 2:55 ` Nathan Lynch
0 siblings, 0 replies; 7+ messages in thread
From: Nathan Lynch @ 2021-05-05 2:55 UTC (permalink / raw)
To: Michael Ellerman; +Cc: linuxppc-dev, anton, npiggin, dja
Michael Ellerman <mpe@ellerman.id.au> writes:
> Nathan Lynch <nathanl@linux.ibm.com> writes:
>> post_mobility_fixup() does cpus_read_unlock() before calling
>> pseries_setup_security_mitigations(), I think that will need to be
>> changed?
>
> I don't think so.
>
> I'm using stop_machine_cpuslocked() but that's because I'm a goose and
> forgot to switch to stop_machine() after I reworked the code to not take
> cpus_read_lock() by hand. I really shouldn't send patches after 11pm.
>
> I don't think it's important to keep the cpus lock held from where we
> take it in post_mobility_fixup(). If some CPUs come or go between there
> and here that's fine.
Yes, agreed.
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier
2021-05-04 13:42 [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Michael Ellerman
2021-05-04 13:42 ` [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier Michael Ellerman
2021-05-04 22:44 ` [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Nathan Lynch
@ 2021-05-05 19:37 ` kernel test robot
2 siblings, 0 replies; 7+ messages in thread
From: kernel test robot @ 2021-05-05 19:37 UTC (permalink / raw)
To: kbuild-all
[-- Attachment #1: Type: text/plain, Size: 2473 bytes --]
Hi Michael,
I love your patch! Perhaps something to improve:
[auto build test WARNING on powerpc/next]
[also build test WARNING on linus/master v5.12 next-20210505]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Michael-Ellerman/powerpc-64s-Fix-crashes-when-toggling-stf-barrier/20210504-214718
base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next
config: powerpc-randconfig-r022-20210505 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 8f5a2a5836cc8e4c1def2bdeb022e7b496623439)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install powerpc cross compiling tool for clang build
# apt-get install binutils-powerpc-linux-gnu
# https://github.com/0day-ci/linux/commit/da6ffcce096961322b6eef8bea33bb1e4c4d1bbf
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Michael-Ellerman/powerpc-64s-Fix-crashes-when-toggling-stf-barrier/20210504-214718
git checkout da6ffcce096961322b6eef8bea33bb1e4c4d1bbf
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 ARCH=powerpc
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All warnings (new ones prefixed by >>):
>> arch/powerpc/lib/feature-fixups.c:233:32: warning: cast to smaller integer type 'enum stf_barrier_type' from 'void *' [-Wvoid-pointer-to-enum-cast]
enum stf_barrier_type types = (enum stf_barrier_type)data;
^~~~~~~~~~~~~~~~~~~~~~~~~~~
1 warning generated.
vim +233 arch/powerpc/lib/feature-fixups.c
230
231 static int __do_stf_barrier_fixups(void *data)
232 {
> 233 enum stf_barrier_type types = (enum stf_barrier_type)data;
234
235 do_stf_entry_barrier_fixups(types);
236 do_stf_exit_barrier_fixups(types);
237
238 return 0;
239 }
240
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 37716 bytes --]
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier
2021-05-04 13:42 ` [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier Michael Ellerman
@ 2021-05-05 20:44 ` kernel test robot
0 siblings, 0 replies; 7+ messages in thread
From: kernel test robot @ 2021-05-05 20:44 UTC (permalink / raw)
To: kbuild-all
[-- Attachment #1: Type: text/plain, Size: 8086 bytes --]
Hi Michael,
I love your patch! Perhaps something to improve:
[auto build test WARNING on powerpc/next]
[also build test WARNING on linus/master v5.12 next-20210505]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Michael-Ellerman/powerpc-64s-Fix-crashes-when-toggling-stf-barrier/20210504-214718
base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next
config: powerpc-randconfig-r022-20210505 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 8f5a2a5836cc8e4c1def2bdeb022e7b496623439)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install powerpc cross compiling tool for clang build
# apt-get install binutils-powerpc-linux-gnu
# https://github.com/0day-ci/linux/commit/416c4a71342ea7c46c85d8c415489f75635785f1
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Michael-Ellerman/powerpc-64s-Fix-crashes-when-toggling-stf-barrier/20210504-214718
git checkout 416c4a71342ea7c46c85d8c415489f75635785f1
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 ARCH=powerpc
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All warnings (new ones prefixed by >>):
arch/powerpc/lib/feature-fixups.c:233:32: warning: cast to smaller integer type 'enum stf_barrier_type' from 'void *' [-Wvoid-pointer-to-enum-cast]
enum stf_barrier_type types = (enum stf_barrier_type)data;
^~~~~~~~~~~~~~~~~~~~~~~~~~~
>> arch/powerpc/lib/feature-fixups.c:304:30: warning: cast to smaller integer type 'enum l1d_flush_type' from 'void *' [-Wvoid-pointer-to-enum-cast]
enum l1d_flush_type types = (enum l1d_flush_type)data;
^~~~~~~~~~~~~~~~~~~~~~~~~
2 warnings generated.
vim +304 arch/powerpc/lib/feature-fixups.c
230
231 static int __do_stf_barrier_fixups(void *data)
232 {
> 233 enum stf_barrier_type types = (enum stf_barrier_type)data;
234
235 do_stf_entry_barrier_fixups(types);
236 do_stf_exit_barrier_fixups(types);
237
238 return 0;
239 }
240
241 void do_stf_barrier_fixups(enum stf_barrier_type types)
242 {
243 /*
244 * The call to the fallback entry flush, and the fallback/sync-ori exit
245 * flush can not be safely patched in/out while other CPUs are executing
246 * them. So call __do_stf_barrier_fixups() on one CPU while all other CPUs
247 * spin in the stop machine core with interrupts hard disabled.
248 */
249 stop_machine_cpuslocked(__do_stf_barrier_fixups, (void *)types, NULL);
250 }
251
252 void do_uaccess_flush_fixups(enum l1d_flush_type types)
253 {
254 unsigned int instrs[4], *dest;
255 long *start, *end;
256 int i;
257
258 start = PTRRELOC(&__start___uaccess_flush_fixup);
259 end = PTRRELOC(&__stop___uaccess_flush_fixup);
260
261 instrs[0] = 0x60000000; /* nop */
262 instrs[1] = 0x60000000; /* nop */
263 instrs[2] = 0x60000000; /* nop */
264 instrs[3] = 0x4e800020; /* blr */
265
266 i = 0;
267 if (types == L1D_FLUSH_FALLBACK) {
268 instrs[3] = 0x60000000; /* nop */
269 /* fallthrough to fallback flush */
270 }
271
272 if (types & L1D_FLUSH_ORI) {
273 instrs[i++] = 0x63ff0000; /* ori 31,31,0 speculation barrier */
274 instrs[i++] = 0x63de0000; /* ori 30,30,0 L1d flush*/
275 }
276
277 if (types & L1D_FLUSH_MTTRIG)
278 instrs[i++] = 0x7c12dba6; /* mtspr TRIG2,r0 (SPR #882) */
279
280 for (i = 0; start < end; start++, i++) {
281 dest = (void *)start + *start;
282
283 pr_devel("patching dest %lx\n", (unsigned long)dest);
284
285 patch_instruction((struct ppc_inst *)dest, ppc_inst(instrs[0]));
286
287 patch_instruction((struct ppc_inst *)(dest + 1), ppc_inst(instrs[1]));
288 patch_instruction((struct ppc_inst *)(dest + 2), ppc_inst(instrs[2]));
289 patch_instruction((struct ppc_inst *)(dest + 3), ppc_inst(instrs[3]));
290 }
291
292 printk(KERN_DEBUG "uaccess-flush: patched %d locations (%s flush)\n", i,
293 (types == L1D_FLUSH_NONE) ? "no" :
294 (types == L1D_FLUSH_FALLBACK) ? "fallback displacement" :
295 (types & L1D_FLUSH_ORI) ? (types & L1D_FLUSH_MTTRIG)
296 ? "ori+mttrig type"
297 : "ori type" :
298 (types & L1D_FLUSH_MTTRIG) ? "mttrig type"
299 : "unknown");
300 }
301
302 static int __do_entry_flush_fixups(void *data)
303 {
> 304 enum l1d_flush_type types = (enum l1d_flush_type)data;
305 unsigned int instrs[3], *dest;
306 long *start, *end;
307 int i;
308
309 instrs[0] = 0x60000000; /* nop */
310 instrs[1] = 0x60000000; /* nop */
311 instrs[2] = 0x60000000; /* nop */
312
313 i = 0;
314 if (types == L1D_FLUSH_FALLBACK) {
315 instrs[i++] = 0x7d4802a6; /* mflr r10 */
316 instrs[i++] = 0x60000000; /* branch patched below */
317 instrs[i++] = 0x7d4803a6; /* mtlr r10 */
318 }
319
320 if (types & L1D_FLUSH_ORI) {
321 instrs[i++] = 0x63ff0000; /* ori 31,31,0 speculation barrier */
322 instrs[i++] = 0x63de0000; /* ori 30,30,0 L1d flush*/
323 }
324
325 if (types & L1D_FLUSH_MTTRIG)
326 instrs[i++] = 0x7c12dba6; /* mtspr TRIG2,r0 (SPR #882) */
327
328 start = PTRRELOC(&__start___entry_flush_fixup);
329 end = PTRRELOC(&__stop___entry_flush_fixup);
330 for (i = 0; start < end; start++, i++) {
331 dest = (void *)start + *start;
332
333 pr_devel("patching dest %lx\n", (unsigned long)dest);
334
335 patch_instruction((struct ppc_inst *)dest, ppc_inst(instrs[0]));
336
337 if (types == L1D_FLUSH_FALLBACK)
338 patch_branch((struct ppc_inst *)(dest + 1), (unsigned long)&entry_flush_fallback,
339 BRANCH_SET_LINK);
340 else
341 patch_instruction((struct ppc_inst *)(dest + 1), ppc_inst(instrs[1]));
342
343 patch_instruction((struct ppc_inst *)(dest + 2), ppc_inst(instrs[2]));
344 }
345
346 start = PTRRELOC(&__start___scv_entry_flush_fixup);
347 end = PTRRELOC(&__stop___scv_entry_flush_fixup);
348 for (; start < end; start++, i++) {
349 dest = (void *)start + *start;
350
351 pr_devel("patching dest %lx\n", (unsigned long)dest);
352
353 patch_instruction((struct ppc_inst *)dest, ppc_inst(instrs[0]));
354
355 if (types == L1D_FLUSH_FALLBACK)
356 patch_branch((struct ppc_inst *)(dest + 1), (unsigned long)&scv_entry_flush_fallback,
357 BRANCH_SET_LINK);
358 else
359 patch_instruction((struct ppc_inst *)(dest + 1), ppc_inst(instrs[1]));
360
361 patch_instruction((struct ppc_inst *)(dest + 2), ppc_inst(instrs[2]));
362 }
363
364
365 printk(KERN_DEBUG "entry-flush: patched %d locations (%s flush)\n", i,
366 (types == L1D_FLUSH_NONE) ? "no" :
367 (types == L1D_FLUSH_FALLBACK) ? "fallback displacement" :
368 (types & L1D_FLUSH_ORI) ? (types & L1D_FLUSH_MTTRIG)
369 ? "ori+mttrig type"
370 : "ori type" :
371 (types & L1D_FLUSH_MTTRIG) ? "mttrig type"
372 : "unknown");
373
374 return 0;
375 }
376
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 37716 bytes --]
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2021-05-05 20:44 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-05-04 13:42 [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Michael Ellerman
2021-05-04 13:42 ` [PATCH 2/2] powerpc/64s: Fix crashes when toggling entry flush barrier Michael Ellerman
2021-05-05 20:44 ` kernel test robot
2021-05-04 22:44 ` [PATCH 1/2] powerpc/64s: Fix crashes when toggling stf barrier Nathan Lynch
2021-05-05 2:48 ` Michael Ellerman
2021-05-05 2:55 ` Nathan Lynch
2021-05-05 19:37 ` kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.