On Sat, Apr 14, 2018 at 1:02 AM, Al Viro <viro@xxxxxxxxxxxxxxxxxx> wrote:
>
> "Bail out" is definitely a bad idea, "sleep"... what on? Especially
> since there might be several evictions we are overlapping with...
Well, one thing that should be looked at is the return condition from
select_collect() that shrink_dcache_parent() uses.
Because I think that return condition is somewhat insane.
The logic there seems to be:
- if we have found something, stop walking. Either NOW (if somebody
is waiting) or after you've hit a rename (if nobody is)
Now, this actually makes perfect sense for the whole rename situation:
if there's nobody waiting for us, but we hit a rename, we probably
should stop anyway just to let whoever is doing that rename continue,
and we might as well try to get rid of the dentries we have found so
far.
But it does *not* make sense for the case where we've hit a dentry
that is already on the shrink list. Sure, we'll continue to gather all
the other dentries, but if there is concurrent shrinking, shouldn't we
give up the CPU more eagerly - *particularly* if somebody else is
waiting (it might be the other process that actually gets rid of the
shrinking dentries!)?
So my gut feel is that we should at least try doing something like
this in select_collect():
- if (!list_empty(&data->dispose))
+ if (data->found)
ret = need_resched() ? D_WALK_QUIT : D_WALK_NORETRY;
because even if we haven't actually been able to shrink something, if
we hit an already shrinking entry we should probably at least not do
the "retry for rename". And if we actually are going to reschedule, we
might as well start from the beginning.
I realize that *this* thread might not be making any actual progress
(because it didn't find any dentries to shrink), but since it did find
_a_ dentry that is being shrunk, we know the operation itself - on a
bigger scale - is making progress.
Hmm?
Now, this is independent of the fact that we probably do need a
cond_resched() in shrink_dcache_parent(), to actually do the
reschedule if we're not preemptible. The "need_resched()" in
select_collect() is obviously done while holding
HOWEVER. Even in that case, I don't think shrink_dcache_parent() is
the right point. I'd rather just do it differently in
shrink_dentry_list(): do it even for the empty list case by just doing
it at the top of the loop:
static void shrink_dentry_list(struct list_head *list)
{
- while (!list_empty(list)) {
+ while (cond_resched(), !list_empty(list)) {
struct dentry *dentry, *parent;
- cond_resched();
so my full patch that I would suggest might be TheRightThing(tm) is
attached (but it should be committed as two patches, since the two
issues are independent - I'm just attaching it as one for testing in
case somebody wants to run some nasty workloads on it)
Comments?
Side note: I think we might want to make that
while (cond_resched(), <condition>) {
....
}
thing a pattern for doing cond_resched() in loops, instead of having
the cond_resched() inside the loop itself.
It not only handles the "zero iterations" case, it also ends up being
neutral location-waise wrt 'continue' statements, and potentially
generates *better* code.
For example, in this case, doing the cond_resched() at the very top of
the loop means that the loop itself then does that
dentry = list_entry(list->prev, struct dentry, d_lru);
right after the "list_empty()" test - which means that register
allocation etc might be easier, because it doesn't have a function
call (with associated register clobbers) in between the two accesses
to "list".
And I think that might be a fairly common pattern - the loop
conditional uses the same values as the loop itself then uses.
I don't know. Maybe I'm just making excuses for the somewhat unusual syntax.
Anybody want to test this out?
Linus
fs/dcache.c | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/fs/dcache.c b/fs/dcache.c
index 86d2de63461e..76507109cbcd 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1049,11 +1049,9 @@ static bool shrink_lock_dentry(struct dentry *dentry)
static void shrink_dentry_list(struct list_head *list)
{
- while (!list_empty(list)) {
+ while (cond_resched(), !list_empty(list)) {
struct dentry *dentry, *parent;
- cond_resched();
-
dentry = list_entry(list->prev, struct dentry, d_lru);
spin_lock(&dentry->d_lock);
rcu_read_lock();
@@ -1462,7 +1460,7 @@ static enum d_walk_ret select_collect(void *_data, struct dentry *dentry)
* ensures forward progress). We'll be coming back to find
* the rest.
*/
- if (!list_empty(&data->dispose))
+ if (data->found)
ret = need_resched() ? D_WALK_QUIT : D_WALK_NORETRY;
out:
return ret;
