On Fri, Feb 21, 2020 at 12:22:50PM -0800, Paul E. McKenney wrote:
> On Fri, Feb 21, 2020 at 02:14:55PM +0100, Uladzislau Rezki wrote:
> > On Thu, Feb 20, 2020 at 04:30:35PM -0800, Paul E. McKenney wrote:
> > > On Wed, Feb 19, 2020 at 11:52:33PM -0500, Theodore Y. Ts'o wrote:
> > > > On Tue, Feb 18, 2020 at 06:08:57PM +0100, Uladzislau Rezki wrote:
> > > > > now it becomes possible to use it like:
> > > > > ...
> > > > > void *p = kvmalloc(PAGE_SIZE);
> > > > > kvfree_rcu(p);
> > > > > ...
> > > > > also have a look at the example in the mm/list_lru.c diff.
> > > >
> > > > I certainly like the interface, thanks! I'm going to be pushing
> > > > patches to fix this using ext4_kvfree_array_rcu() since there are a
> > > > number of bugs in ext4's online resizing which appear to be hitting
> > > > multiple cloud providers (with reports from both AWS and GCP) and I
> > > > want something which can be easily backported to stable kernels.
> > > >
> > > > But once kvfree_rcu() hits mainline, I'll switch ext4 to use it, since
> > > > your kvfree_rcu() is definitely more efficient than my expedient
> > > > jury-rig.
> > > >
> > > > I don't feel entirely competent to review the implementation, but I do
> > > > have one question. It looks like the rcutiny implementation of
> > > > kfree_call_rcu() isn't going to do the right thing with kvfree_rcu(p).
> > > > Am I missing something?
> > >
> > > Good catch! I believe that rcu_reclaim_tiny() would need to do
> > > kvfree() instead of its current kfree().
> > >
> > > Vlad, anything I am missing here?
> > >
> > Yes something like that. There are some open questions about
> > realization, when it comes to tiny RCU. Since we are talking
> > about "headless" kvfree_rcu() interface, i mean we can not link
> > freed "objects" between each other, instead we should place a
> > pointer directly into array that will be drained later on.
> >
> > It would be much more easier to achieve that if we were talking
> > about the interface like: kvfree_rcu(p, rcu), but that is not our
> > case :)
> >
> > So, for CONFIG_TINY_RCU we should implement very similar what we
> > have done for CONFIG_TREE_RCU or just simply do like Ted has done
> > with his
> >
> > void ext4_kvfree_array_rcu(void *to_free)
> >
> > i mean:
> >
> > local_irq_save(flags);
> > struct foo *ptr = kzalloc(sizeof(*ptr), GFP_ATOMIC);
> >
> > if (ptr) {
> > ptr->ptr = to_free;
> > call_rcu(&ptr->rcu, kvfree_callback);
> > }
> > local_irq_restore(flags);
>
> We really do still need the emergency case, in this case for when
> kzalloc() returns NULL. Which does indeed mean an rcu_head in the thing
> being freed. Otherwise, you end up with an out-of-memory deadlock where
> you could free memory only if you had memor to allocate.
Can we rely on GFP_ATOMIC allocations for these? These have emergency memory
pools which are reserved.
I was thinking a 2 fold approach (just thinking out loud..):
If kfree_call_rcu() is called in atomic context or in any rcu reader, then
use GFP_ATOMIC to grow an rcu_head wrapper on the atomic memory pool and
queue that.
Otherwise, grow an rcu_head on the stack of kfree_call_rcu() and call
synchronize_rcu() inline with it.
Use preemptible() andr task_struct's rcu_read_lock_nesting to differentiate
between the 2 cases.
Thoughts?
> > Also there is one more open question what to do if GFP_ATOMIC
> > gets failed in case of having low memory condition. Probably
> > we can make use of "mempool interface" that allows to have
> > min_nr guaranteed pre-allocated pages.
>
> But we really do still need to handle the case where everything runs out,
> even the pre-allocated pages.
If *everything* runs out, you are pretty much going to OOM sooner or later
anyway :D. But I see what you mean. But the 'tradeoff' is RCU can free
head-less objects where possible.
thanks,
- Joel
