[PATCH] memcg: Keep socket_pressure fresh on 32-bit kernel.

[Kuniyuki Iwashima <kuniyu@google.com>]

memcg->socket_pressure is initialised with jiffies when the memcg
is created.

Once vmpressure detects that the cgroup is under memory pressure,
the field is updated with jiffies + HZ to signal the fact to the
socket layer and suppress memory allocation for one second.

Otherwise, the field is not updated.

mem_cgroup_under_socket_pressure() uses time_before() to check if
jiffies is less than memcg->socket_pressure, and this has a bug on
32-bit kernel.

  if (time_before(jiffies, memcg->socket_pressure))
          return true;

As time_before() casts the final result to long, the acceptable delta
between two timestamps is 2 ^ (BITS_PER_LONG - 1).

On 32-bit kernel with CONFIG_HZ=1000, this is about 24 days.

  >>> (2 ** 31) / 1000 / 60 / 60 / 24
  24.855134814814818

Once 24 days have passed since the last update of socket_pressure,
mem_cgroup_under_socket_pressure() starts to lie until the next
24 days pass.

Thus, we need to update socket_pressure to a recent timestamp
periodically on 32-bit kernel.

Let's do that every 24 hours, with a variation of about 0 to 4 hours.

The variation is to avoid bursting by cgroups created within a small
timeframe, like boot-up.

The work could be racy but does not take vmpr->sr_lock nor re-evaluate
vmpressure_calc_level() under the assumption that socket_pressure will
get updated soon if under memory pressure, because it persists only
for one second.

Note that we don't need to worry about 64-bit machines unless they
serve for 300 million years.

  >>> (2 ** 63) / 1000 / 60 / 60 / 24 / 365
  292471208.6775361

Fixes: 8e8ae645249b8 ("mm: memcontrol: hook up vmpressure to socket pressure")
Reported-by: Neal Cardwell <ncardwell@google.com>
Signed-off-by: Kuniyuki Iwashima <kuniyu@google.com>
---
 include/linux/vmpressure.h |  3 +++
 mm/vmpressure.c            | 52 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/include/linux/vmpressure.h b/include/linux/vmpressure.h
index 6a2f51ebbfd35..946c1b284d4d4 100644
--- a/include/linux/vmpressure.h
+++ b/include/linux/vmpressure.h
@@ -25,6 +25,9 @@ struct vmpressure {
 	struct mutex events_lock;
 
 	struct work_struct work;
+#if BITS_PER_LONG == 32
+	struct delayed_work delayed_work;
+#endif
 };
 
 struct mem_cgroup;
diff --git a/mm/vmpressure.c b/mm/vmpressure.c
index bd5183dfd8791..cd978d580d9a7 100644
--- a/mm/vmpressure.c
+++ b/mm/vmpressure.c
@@ -215,6 +215,51 @@ static void vmpressure_work_fn(struct work_struct *work)
 	} while ((vmpr = vmpressure_parent(vmpr)));
 }
 
+#if BITS_PER_LONG == 32
+static void vmpressure_update_socket_pressure(struct vmpressure *vmpr)
+{
+	struct mem_cgroup *memcg = vmpressure_to_memcg(vmpr);
+	unsigned long delay, variation;
+
+	/*
+	 * The acceptable delta for time_before() is up to 2 ^ (BITS_PER_LONG - 1),
+	 * which is 24 days with CONFIG_HZ=1000, so once-per-day is enough.
+	 */
+	delay = HZ * 60 * 60 * 24;
+
+	/*
+	 * Add variation (0 ~ 4 hours) to avoid bursting by cgourps created
+	 * during boot.
+	 */
+	variation = (unsigned long)memcg;
+	variation ^= variation >> 16;
+	variation ^= variation >> 8;
+	variation %= 256;
+
+	delay += HZ * 60 * variation;
+
+	mod_delayed_work(system_unbound_wq, &vmpr->delayed_work, delay);
+}
+
+static void vmpressure_update_socket_pressure_fn(struct work_struct *work)
+{
+	struct mem_cgroup *memcg;
+	struct vmpressure *vmpr;
+
+	vmpr = container_of(to_delayed_work(work), struct vmpressure, delayed_work);
+	memcg = vmpressure_to_memcg(vmpr);
+
+	/*
+	 * Update socket_pressure to a recent timestamp, but don't signal
+	 * false positive to mem_cgroup_under_socket_pressure(), thus -HZ.
+	 */
+	if (time_before(READ_ONCE(memcg->socket_pressure), jiffies))
+		WRITE_ONCE(memcg->socket_pressure, jiffies - HZ);
+
+	vmpressure_update_socket_pressure(vmpr);
+}
+#endif
+
 /**
  * vmpressure() - Account memory pressure through scanned/reclaimed ratio
  * @gfp:	reclaimer's gfp mask
@@ -462,6 +507,10 @@ void vmpressure_init(struct vmpressure *vmpr)
 	mutex_init(&vmpr->events_lock);
 	INIT_LIST_HEAD(&vmpr->events);
 	INIT_WORK(&vmpr->work, vmpressure_work_fn);
+#if BITS_PER_LONG == 32
+	INIT_DELAYED_WORK(&vmpr->delayed_work, vmpressure_update_socket_pressure_fn);
+	vmpressure_update_socket_pressure(vmpr);
+#endif
 }
 
 /**
@@ -478,4 +527,7 @@ void vmpressure_cleanup(struct vmpressure *vmpr)
 	 * goes away.
 	 */
 	flush_work(&vmpr->work);
+#if BITS_PER_LONG == 32
+	cancel_delayed_work_sync(&vmpr->delayed_work);
+#endif
 }
-- 
2.50.0.727.gbf7dc18ff4-goog