On Thu, Oct 28, 2021 at 03:32:23PM -0700, Linus Torvalds wrote: > The pointer color fault (or whatever some other architecture may do to > generate sub-page faults) is not only not recoverable in the sense > that we can't fix it up, it also ends up being a forced SIGSEGV (ie it > can't be blocked - it has to either be caught or cause the process to > be killed). > > And the thing is, I think we could just make the rule be that kernel > code that has this kind of retry loop with fault_in_pages() would > force an EFAULT on a pending SIGSEGV. > > IOW, the pending SIGSEGV could effectively be exactly that "thread flag". > > And that means that fault_in_xyz() wouldn't need to worry about this > situation at all: the regular copy_from_user() (or whatever flavor it > is - to/from/iter/whatever) would take the fault. And if it's a > regular page fault,. it would act exactly like it does now, so no > changes. > > If it's a sub-page fault, we'd just make the rule be that we send a > SIGSEGV even if the instruction in question has a user exception > fixup. > > Then we just need to add the logic somewhere that does "if active > pending SIGSEGV, return -EFAULT". > > Of course, that logic might be in fault_in_xyz(), but it migth also be > a separate function entirely. > > So this does effectively end up being a thread flag, but it's also > slightly more than that - it's that a sub-page fault from kernel mode > has semantics that a regular page fault does not. > > The whole "kernel access doesn't cause SIGSEGV, but returns -EFAULT > instead" has always been an odd and somewhat wrong-headed thing. Of > course it should cause a SIGSEGV, but that's not how Unix traditionall > worked. We would just say "color faults always raise a signal, even if > the color fault was triggered in a system call". It's doable and, at least for MTE, people have asked for a signal even when the fault was caused by a kernel uaccess. But there are some potentially confusing aspects to sort out: First of all, a uaccess in interrupt should not force such signal as it had nothing to do with the interrupted context. I guess we can do an in_task() check in the fault handler. Second, is there a chance that we enter the fault-in loop with a SIGSEGV already pending? Maybe it's not a problem, we just bail out of the loop early and deliver the signal, though unrelated to the actual uaccess in the loop. Third is the sigcontext.pc presented to the signal handler. Normally for SIGSEGV it points to the address of a load/store instruction and a handler could disable MTE and restart from that point. With a syscall we don't want it to point to the syscall place as it shouldn't be restarted in case it copied something. Pointing it to the next instruction after syscall is backwards-compatible but it may confuse the handler (if it does some reporting). I think we need add a new si_code that describes a fault in kernel mode to differentiate from the genuine user access. There was a discussion back in August on infinite loops with hwpoison and Tony said that Andy convinced him that the kernel should not send a SIGBUS for uaccess: https://lore.kernel.org/linux-edac/20210823152437.GA1637466@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/ I personally like the approach of a SIG{SEGV,BUS} on uaccess and I don't think the ABI change is significant but ideally we should have a unified approach that's not just for MTE. Adding Andy and Tony (the background is potentially infinite loops with faults at sub-page granularity: arm64 MTE, hwpoison, sparc ADI). Thanks. -- Catalin
