On Wed, May 15, 2024 at 12:19:16PM -0700, Axel Rasmussen wrote:
> An unprivileged process can allocate a VMA, use the userfaultfd API to
> install one of these PTE markers, and then register a no-op SIGBUS
> handler. Now it can access that address in a tight loop,
Maybe the userfaultfd should not allow this, I dunno. You made me look
at this thing and to me it all sounds weird. One thread does page fault
handling for the other and that helps with live migration somehow. OMG,
whaaat?
Maybe I don't understand it and probably never will...
But, for example, membarrier used do to a stupid thing of allowing one
thread to hammer another with an IPI storm. Bad bad idea. So it got
fixed.
All I'm saying is, if unprivileged processes can do crap, they should be
prevented from doing crap. Like ratelimiting the pagefaults or whatnot.
One of the recovery action strategies from memory poison is, well, you
kill the process. If you can detect the hammering process which
installed that page marker, you kill it. Problem solved.
But again, this userfaultfd thing sounds really weird so I could very
well be way wrong.
> Even in a non-contrived / non-malicious case, use of this API could
> have similar effects. If nothing else, the log message can be
> confusing to administrators: they state that an MCE occurred, whereas
> with the simulated poison API, this is not the case; it isn't a "real"
> MCE / hardware error.
Yeah, I read that part in
Documentation/admin-guide/mm/userfaultfd.rst
Simulated poison huh? Another WTF.
> In the KVM use case, the host can't just allocate a new page, because
> it doesn't know what the guest might have had stored there. Best we
Ok, let's think of real hw poison.
When doing the recovery, you don't care what's stored there because as
far as the hardware is concerned, if you consume that poison the *whole*
machine might go down.
So you lose the page. Plain and simple. And the guest can go visit the
bureau of complaints and grievances.
Still better than killing the guest or even the whole host with other
guests running on it.
> can do is propagate the poison into the guest, and let the guest OS
> deal with it as it sees fit, and mark the page poisoned on the host.
You mark the page as poison on the host and you yank it from under the
guest. That physical frame is gone and the faster all the actors
involved understand that, the better.
> I don't disagree the guest *shouldn't* reaccess it in this case. :)
> But if it did, it should get another poison event just as you say.
Yes, it shouldn't. Look at memory_failure(). This will kill whole
processes if it has to, depending on what the page is used for.
> And, live migration between physical hosts should be transparent to
> the guest. So if the guest gets a poison, and then we live migrate it,
So if I were to design this, I'd do it this way:
0. guest gets hw poison injected
1. it runs memory_failure() and it kills the processes using the page.
2. page is marked poisoned on the host so no other guest gets it.
That's it. No second accesses whatsoever. At least this is how it works
on baremetal.
This hw poisoning emulation is just silly and unnecessary.
But again, I probably am missing some aspects. It all just sounded
really weird to me that's why I thought I should ask what's behind all
that.
Thx.
--
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette
