On Mon, Aug 05, 2019 at 01:42:26PM -0400, Brian Foster wrote: > On Sun, Aug 04, 2019 at 11:49:30AM +1000, Dave Chinner wrote: > > On Fri, Aug 02, 2019 at 11:27:09AM -0400, Brian Foster wrote: > > > On Thu, Aug 01, 2019 at 12:17:29PM +1000, Dave Chinner wrote: > > > > }; > > > > > > > > #define SHRINK_STOP (~0UL) > > > > diff --git a/mm/vmscan.c b/mm/vmscan.c > > > > index 44df66a98f2a..ae3035fe94bc 100644 > > > > --- a/mm/vmscan.c > > > > +++ b/mm/vmscan.c > > > > @@ -541,6 +541,13 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl, > > > > trace_mm_shrink_slab_start(shrinker, shrinkctl, nr, > > > > freeable, delta, total_scan, priority); > > > > > > > > + /* > > > > + * If the shrinker can't run (e.g. due to gfp_mask constraints), then > > > > + * defer the work to a context that can scan the cache. > > > > + */ > > > > + if (shrinkctl->will_defer) > > > > + goto done; > > > > + > > > > > > Who's responsible for clearing the flag? Perhaps we should do so here > > > once it's acted upon since we don't call into the shrinker again? > > > > Each shrinker invocation has it's own shrink_control context - they > > are not shared between shrinkers - the higher level is responsible > > for setting up the control state of each individual shrinker > > invocation... > > > > Yes, but more specifically, it appears to me that each level is > responsible for setting up control state managed by that level. E.g., > shrink_slab_memcg() initializes the unchanging state per iteration and > do_shrink_slab() (re)sets the scan state prior to ->scan_objects(). do_shrink_slab() is responsible for iterating the scan in shrinker->batch sizes, that's all it's doing there. We have to do some accounting work from scan to scan. However, if ->will_defer is set, we skip that entire loop, so it's largely irrelevant IMO. > > > Granted the deferred state likely hasn't > > > changed, but the fact that we'd call back into the count callback to set > > > it again implies the logic could be a bit more explicit, particularly if > > > this will eventually be used for more dynamic shrinker state that might > > > change call to call (i.e., object dirty state, etc.). > > > > > > BTW, do we need to care about the ->nr_cached_objects() call from the > > > generic superblock shrinker (super_cache_scan())? > > > > No, and we never had to because it is inside the superblock shrinker > > and the superblock shrinker does the GFP_NOFS context checks. > > > > Ok. Though tbh this topic has me wondering whether a shrink_control > boolean is the right approach here. Do you envision ->will_defer being > used for anything other than allocation context restrictions? If not, Not at this point. If there are other control flags needed, we can ad them in future - I don't like the idea of having a single control flag mean different things in different contexts. > perhaps we should do something like optionally set alloc flags required > for direct scanning in the struct shrinker itself and let the core > shrinker code decide when to defer to kswapd based on the shrink_control > flags and the current shrinker. That way an arbitrary shrinker can't > muck around with core behavior in unintended ways. Hm? Arbitrary shrinkers can't "muck about" with the core behaviour any more than they already could with this code. If you want to screw up the core reclaim by always returning SHRINK_STOP to ->scan_objects instead of doing work, then there is nothing stopping you from doing that right now. Formalising there work deferral into a flag in the shrink_control doesn't really change that at all, adn as such I don't see any need for over-complicating the mechanism here.... Cheers, Dave. -- Dave Chinner david@xxxxxxxxxxxxx
