Re: [Lsf-pc] [LSF/MM/BPF TOPIC] Reclamation interactions with RCU

Matthew Wilcox
2024-03-04T00:35:24Z

On Mon, Mar 04, 2024 at 09:45:48AM +1100, NeilBrown wrote:
> I have in mind a more explicit statement of how much waiting is
> acceptable.
>
> GFP_NOFAIL - wait indefinitely
> GFP_KILLABLE - wait indefinitely unless fatal signal is pending.
> GFP_RETRY - may retry but deadlock, though unlikely, is possible. So
> don't wait indefinitely. May abort more quickly if fatal
> signal is pending.
> GFP_NO_RETRY - only try things once. This may sleep, but will give up
> fairly quickly. Either deadlock is a significant
> possibility, or alternate strategy is fairly cheap.
> GFP_ATOMIC - don't sleep - same as current.

I don't think these should be GFP flags. Rather, these should be
context flags (and indeed, they're mutually exclusive, so this is a
small integer to represent where we are on the spectrum). That is
we want code to do

void *alloc_foo(void)
{
return init_foo(kmalloc(256, GFP_MOVABLE));
}

void submit_foo(void)
{
spin_lock(&submit_lock);
flags = memalloc_set_atomic();
__submit_foo(alloc_foo());
memalloc_restore_flags(flags);
spin_unlock(&submit_lock);
}

struct foo *prealloc_foo(void)
{
return alloc_foo();
}

... for various degrees of complexity. That is, the _location_ of memory
is allocation site knowledge, but how hard to try is _path_ dependent,
and not known at the allocation site because it doesn't know what locks
are held.