3 files changed, 24 insertions, 4 deletions

diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index ea02ff970836..0108a56f814e 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -422,6 +422,12 @@ static inline void sock_release_memcg(struct sock *sk)
 extern struct static_key memcg_kmem_enabled_key;
 
 extern int memcg_limited_groups_array_size;
+
+/*
+ * Helper macro to loop through all memcg-specific caches. Callers must still
+ * check if the cache is valid (it is either valid or NULL).
+ * the slab_mutex must be held when looping through those caches
+ */
 #define for_each_memcg_cache_index(_idx)        \
         for ((_idx) = 0; i < memcg_limited_groups_array_size; (_idx)++)
 
diff --git a/mm/slab.c b/mm/slab.c
index 4dcbf96a77b4..e7667a3584bc 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -4099,6 +4099,7 @@ static int do_tune_cpucache(struct kmem_cache *cachep, int limit,
         if ((ret < 0) || !is_root_cache(cachep))
                 return ret;
 
+        VM_BUG_ON(!mutex_is_locked(&slab_mutex));
         for_each_memcg_cache_index(i) {
                 c = cache_from_memcg(cachep, i);
                 if (c)
diff --git a/mm/slub.c b/mm/slub.c
index 21c94d9695ec..efe2cffc29b0 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -5108,12 +5108,25 @@ static ssize_t slab_attr_store(struct kobject *kobj,
                 if (s->max_attr_size < len)
                         s->max_attr_size = len;
 
+                /*
+                 * This is a best effort propagation, so this function's return
+                 * value will be determined by the parent cache only. This is
+                 * basically because not all attributes will have a well
+                 * defined semantics for rollbacks - most of the actions will
+                 * have permanent effects.
+                 *
+                 * Returning the error value of any of the children that fail
+                 * is not 100 % defined, in the sense that users seeing the
+                 * error code won't be able to know anything about the state of
+                 * the cache.
+                 *
+                 * Only returning the error code for the parent cache at least
+                 * has well defined semantics. The cache being written to
+                 * directly either failed or succeeded, in which case we loop
+                 * through the descendants with best-effort propagation.
+                 */
                 for_each_memcg_cache_index(i) {
                         struct kmem_cache *c = cache_from_memcg(s, i);
-                        /*
-                         * This function's return value is determined by the
-                         * parent cache only
-                         */
                         if (c)
                                 attribute->store(c, buf, len);
                 }