* [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 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
* 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
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.