tree 3e5055a7ed0f34f9b3350162ae968da5865d4c9d
parent 8b1d72395635af45410b66cc4c4ab37a12c4a831
author Helge Deller <deller@gmx.de> 1706704645 +0100
committer Helge Deller <deller@gmx.de> 1706705486 +0100

parisc: BTLB: Fix crash when setting up BTLB at CPU bringup

When using hotplug and bringing up a 32-bit CPU, ask the firmware about the
BTLB information to set up the static (block) TLB entries.

For that write access to the static btlb_info struct is needed, but
since it is marked __ro_after_init the kernel segfaults with missing
write permissions.

Fix the crash by dropping the __ro_after_init annotation.

Fixes: e5ef93d02d6c ("parisc: BTLB: Initialize BTLB tables at CPU startup")
Signed-off-by: Helge Deller <deller@gmx.de>
Cc: <stable@vger.kernel.org> # v6.6+
