2 files changed, 10 insertions, 20 deletions

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index d5f3a62887cf..661f046ad318 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -5828,21 +5828,6 @@ void mem_cgroup_sk_alloc(struct sock *sk)
         if (!mem_cgroup_sockets_enabled)
                 return;
 
-        /*
-         * Socket cloning can throw us here with sk_memcg already
-         * filled. It won't however, necessarily happen from
-         * process context. So the test for root memcg given
-         * the current task's memcg won't help us in this case.
-         *
-         * Respecting the original socket's memcg is a better
-         * decision in this case.
-         */
-        if (sk->sk_memcg) {
-                BUG_ON(mem_cgroup_is_root(sk->sk_memcg));
-                css_get(&sk->sk_memcg->css);
-                return;
-        }
-
         rcu_read_lock();
         memcg = mem_cgroup_from_task(current);
         if (memcg == root_mem_cgroup)
diff --git a/mm/percpu.c b/mm/percpu.c
index aa121cef76de..a0e0c82c1e4c 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -1329,7 +1329,9 @@ static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
  * @gfp: allocation flags
  *
  * Allocate percpu area of @size bytes aligned at @align.  If @gfp doesn't
- * contain %GFP_KERNEL, the allocation is atomic.
+ * contain %GFP_KERNEL, the allocation is atomic. If @gfp has __GFP_NOWARN
+ * then no warning will be triggered on invalid or failed allocation
+ * requests.
  *
  * RETURNS:
  * Percpu pointer to the allocated area on success, NULL on failure.
@@ -1337,10 +1339,11 @@ static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
 static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
                                  gfp_t gfp)
 {
+        bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
+        bool do_warn = !(gfp & __GFP_NOWARN);
         static int warn_limit = 10;
         struct pcpu_chunk *chunk;
         const char *err;
-        bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
         int slot, off, cpu, ret;
         unsigned long flags;
         void __percpu *ptr;
@@ -1361,7 +1364,7 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
 
         if (unlikely(!size || size > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE ||
                      !is_power_of_2(align))) {
-                WARN(true, "illegal size (%zu) or align (%zu) for percpu allocation\n",
+                WARN(do_warn, "illegal size (%zu) or align (%zu) for percpu allocation\n",
                      size, align);
                 return NULL;
         }
@@ -1482,7 +1485,7 @@ fail_unlock:
 fail:
         trace_percpu_alloc_percpu_fail(reserved, is_atomic, size, align);
 
-        if (!is_atomic && warn_limit) {
+        if (!is_atomic && do_warn && warn_limit) {
                 pr_warn("allocation failed, size=%zu align=%zu atomic=%d, %s\n",
                         size, align, is_atomic, err);
                 dump_stack();
@@ -1507,7 +1510,9 @@ fail:
  *
  * Allocate zero-filled percpu area of @size bytes aligned at @align.  If
  * @gfp doesn't contain %GFP_KERNEL, the allocation doesn't block and can
- * be called from any context but is a lot more likely to fail.
+ * be called from any context but is a lot more likely to fail. If @gfp
+ * has __GFP_NOWARN then no warning will be triggered on invalid or failed
+ * allocation requests.
  *
  * RETURNS:
  * Percpu pointer to the allocated area on success, NULL on failure.