[PATCH v6 2/3] selftests/cgroup: convert cg_read_key_*() helpers to s64

@@ -172,7 +172,7 @@ long cg_read_long_fd(int fd)
 	return atol(buf);
 }
 
-long cg_read_key_long(const char *cgroup, const char *control, const char *key)
+s64 cg_read_key_s64(const char *cgroup, const char *control, const char *key)
 {
 	char buf[BUF_SIZE];
 	char *ptr;

@@ -184,18 +184,18 @@ long cg_read_key_long(const char *cgroup, const char *control, const char *key)
 	if (!ptr)
 		return -1;
 
-	return atol(ptr + strlen(key));
+	return atoll(ptr + strlen(key));
 }
 
-long cg_read_key_long_poll(const char *cgroup, const char *control,
-			   const char *key, long expected, int retries,
-			   useconds_t wait_interval_us)
+s64 cg_read_key_s64_poll(const char *cgroup, const char *control,
+			 const char *key, s64 expected, int retries,
+			 useconds_t wait_interval_us)
 {
-	long val = -1;
+	s64 val = -1;
 	int i;
 
 	for (i = 0; i < retries; i++) {
-		val = cg_read_key_long(cgroup, control, key);
+		val = cg_read_key_s64(cgroup, control, key);
 		if (val < 0)
 			return val;
 

@@ -2,6 +2,8 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
+typedef signed long long s64;
+
 #ifndef BUF_SIZE
 #define BUF_SIZE 4096
 #endif

@@ -24,25 +26,25 @@
 /*
  * Checks if two given values differ by less than err% of their sum.
  */
-static inline int values_close(long a, long b, int err)
+static inline int values_close(s64 a, s64 b, int err)
 {
-	return labs(a - b) <= (a + b) / 100 * err;
+	return llabs(a - b) <= (a + b) / 100 * err;
 }
 
 /*
  * Checks if two given values differ by less than err% of their sum and assert
  * with detailed debug info if not.
  */
-static inline int values_close_report(long a, long b, int err)
+static inline int values_close_report(s64 a, s64 b, int err)
 {
-	long diff  = labs(a - b);
-	long limit = (a + b) / 100 * err;
+	s64 diff  = llabs(a - b);
+	s64 limit = (a + b) / 100 * err;
 	double actual_err = (a + b) ? (100.0 * diff / (a + b)) : 0.0;
 	int close = diff <= limit;
 
 	if (!close)
 		fprintf(stderr,
-			"[FAIL] actual=%ld expected=%ld | diff=%ld | limit=%ld | "
+			"[FAIL] actual=%lld expected=%lld | diff=%lld | limit=%lld | "
 			"tolerance=%d%% | actual_error=%.2f%%\n",
 			a, b, diff, limit, err, actual_err);
 

@@ -69,10 +71,10 @@ extern int cg_read_strstr(const char *cgroup, const char *control,
 			  const char *needle);
 extern long cg_read_long(const char *cgroup, const char *control);
 extern long cg_read_long_fd(int fd);
-long cg_read_key_long(const char *cgroup, const char *control, const char *key);
-long cg_read_key_long_poll(const char *cgroup, const char *control,
-			   const char *key, long expected, int retries,
-			   useconds_t wait_interval_us);
+s64 cg_read_key_s64(const char *cgroup, const char *control, const char *key);
+s64 cg_read_key_s64_poll(const char *cgroup, const char *control,
+			 const char *key, s64 expected, int retries,
+			 useconds_t wait_interval_us);
 extern long cg_read_lc(const char *cgroup, const char *control);
 extern int cg_write(const char *cgroup, const char *control, char *buf);
 extern int cg_open(const char *cgroup, const char *control, int flags);

@@ -24,7 +24,7 @@ enum hog_clock_type {
 struct cpu_hogger {
 	char *cgroup;
 	pid_t pid;
-	long usage;
+	s64 usage;
 };
 
 struct cpu_hog_func_param {

@@ -185,7 +185,7 @@ static int hog_cpus_timed(const char *cgroup, void *arg)
 static int test_cpucg_stats(const char *root)
 {
 	int ret = KSFT_FAIL;
-	long usage_usec, user_usec, system_usec;
+	s64 usage_usec, user_usec, system_usec;
 	long usage_seconds = 2;
 	long expected_usage_usec = usage_seconds * USEC_PER_SEC;
 	char *cpucg;

@@ -197,9 +197,9 @@ static int test_cpucg_stats(const char *root)
 	if (cg_create(cpucg))
 		goto cleanup;
 
-	usage_usec = cg_read_key_long(cpucg, "cpu.stat", "usage_usec");
-	user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
-	system_usec = cg_read_key_long(cpucg, "cpu.stat", "system_usec");
+	usage_usec = cg_read_key_s64(cpucg, "cpu.stat", "usage_usec");
+	user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
+	system_usec = cg_read_key_s64(cpucg, "cpu.stat", "system_usec");
 	if (usage_usec != 0 || user_usec != 0 || system_usec != 0)
 		goto cleanup;
 

@@ -214,8 +214,8 @@ static int test_cpucg_stats(const char *root)
 	if (cg_run(cpucg, hog_cpus_timed, (void *)&param))
 		goto cleanup;
 
-	usage_usec = cg_read_key_long(cpucg, "cpu.stat", "usage_usec");
-	user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
+	usage_usec = cg_read_key_s64(cpucg, "cpu.stat", "usage_usec");
+	user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
 	if (user_usec <= 0)
 		goto cleanup;
 

@@ -239,7 +239,7 @@ static int test_cpucg_nice(const char *root)
 {
 	int ret = KSFT_FAIL;
 	int status;
-	long user_usec, nice_usec;
+	s64 user_usec, nice_usec;
 	long usage_seconds = 2;
 	long expected_nice_usec = usage_seconds * USEC_PER_SEC;
 	char *cpucg;

@@ -252,8 +252,8 @@ static int test_cpucg_nice(const char *root)
 	if (cg_create(cpucg))
 		goto cleanup;
 
-	user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
-	nice_usec = cg_read_key_long(cpucg, "cpu.stat", "nice_usec");
+	user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
+	nice_usec = cg_read_key_s64(cpucg, "cpu.stat", "nice_usec");
 	if (nice_usec == -1)
 		ret = KSFT_SKIP;
 	if (user_usec != 0 || nice_usec != 0)

@@ -289,8 +289,8 @@ static int test_cpucg_nice(const char *root)
 		if (!WIFEXITED(status))
 			goto cleanup;
 
-		user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
-		nice_usec = cg_read_key_long(cpucg, "cpu.stat", "nice_usec");
+		user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
+		nice_usec = cg_read_key_s64(cpucg, "cpu.stat", "nice_usec");
 		if (user_usec <= 0)
 			goto cleanup;
 		if (!values_close_report(nice_usec, expected_nice_usec, 1))

@@ -357,8 +357,8 @@ run_cpucg_weight_test(
 	}
 
 	for (i = 0; i < ARRAY_SIZE(children); i++)
-		children[i].usage = cg_read_key_long(children[i].cgroup,
-				"cpu.stat", "usage_usec");
+		children[i].usage = cg_read_key_s64(children[i].cgroup,
+						    "cpu.stat", "usage_usec");
 
 	if (validate(children, ARRAY_SIZE(children)))
 		goto cleanup;

@@ -486,7 +486,7 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned)
 	int ret = KSFT_FAIL, i;
 	char *parent = NULL, *child = NULL;
 	struct cpu_hogger leaf[3] = {};
-	long nested_leaf_usage, child_usage;
+	s64 nested_leaf_usage, child_usage;
 	int nprocs = get_nprocs();
 
 	if (!overprovisioned) {

@@ -567,8 +567,8 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned)
 	}
 
 	for (i = 0; i < ARRAY_SIZE(leaf); i++) {
-		leaf[i].usage = cg_read_key_long(leaf[i].cgroup,
-				"cpu.stat", "usage_usec");
+		leaf[i].usage = cg_read_key_s64(leaf[i].cgroup, "cpu.stat",
+						"usage_usec");
 		if (leaf[i].usage <= 0)
 			goto cleanup;
 	}

@@ -580,8 +580,7 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned)
 	} else if (!values_close_report(leaf[0].usage * 2, nested_leaf_usage, 15))
 		goto cleanup;
 
-
-	child_usage = cg_read_key_long(child, "cpu.stat", "usage_usec");
+	child_usage = cg_read_key_s64(child, "cpu.stat", "usage_usec");
 	if (child_usage <= 0)
 		goto cleanup;
 	if (!values_close_report(child_usage, nested_leaf_usage, 1))

@@ -679,7 +678,8 @@ static int test_cpucg_max(const char *root)
 	long duration_seconds = 1;
 
 	long duration_usec;
-	long usage_usec, n_periods, remainder_usec, expected_usage_usec;
+	long n_periods, remainder_usec, expected_usage_usec;
+	s64 usage_usec;
 	char *cpucg;
 	char quota_buf[32];
 

@@ -708,7 +708,7 @@ static int test_cpucg_max(const char *root)
 	if (cg_run(cpucg, hog_cpus_timed, (void *)&param))
 		goto cleanup;
 
-	usage_usec = cg_read_key_long(cpucg, "cpu.stat", "usage_usec");
+	usage_usec = cg_read_key_s64(cpucg, "cpu.stat", "usage_usec");
 	if (usage_usec <= 0)
 		goto cleanup;
 

@@ -746,7 +746,8 @@ static int test_cpucg_max_nested(const char *root)
 	long duration_seconds = 1;
 
 	long duration_usec;
-	long usage_usec, n_periods, remainder_usec, expected_usage_usec;
+	long n_periods, remainder_usec, expected_usage_usec;
+	s64 usage_usec;
 	char *parent, *child;
 	char quota_buf[32];
 

@@ -782,7 +783,7 @@ static int test_cpucg_max_nested(const char *root)
 	if (cg_run(child, hog_cpus_timed, (void *)&param))
 		goto cleanup;
 
-	usage_usec = cg_read_key_long(child, "cpu.stat", "usage_usec");
+	usage_usec = cg_read_key_s64(child, "cpu.stat", "usage_usec");
 	if (usage_usec <= 0)
 		goto cleanup;
 

@@ -807,10 +807,9 @@ static int test_cgfreezer_vfork(const char *root)
 /*
  * Get the current frozen_usec for the cgroup.
  */
-static long cg_check_freezetime(const char *cgroup)
+static s64 cg_check_freezetime(const char *cgroup)
 {
-	return cg_read_key_long(cgroup, "cgroup.stat.local",
-				"frozen_usec ");
+	return cg_read_key_s64(cgroup, "cgroup.stat.local", "frozen_usec ");
 }
 
 /*

@@ -820,7 +819,7 @@ static int test_cgfreezer_time_empty(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *cgroup = NULL;
-	long prev, curr;
+	s64 prev, curr;
 
 	cgroup = cg_name(root, "cg_time_test_empty");
 	if (!cgroup)

@@ -839,7 +838,7 @@ static int test_cgfreezer_time_empty(const char *root)
 		goto cleanup;
 	}
 	if (curr > 0) {
-		debug("Expect time (%ld) to be 0\n", curr);
+		debug("Expect time (%lld) to be 0\n", curr);
 		goto cleanup;
 	}
 

@@ -853,8 +852,7 @@ static int test_cgfreezer_time_empty(const char *root)
 	usleep(1000);
 	curr = cg_check_freezetime(cgroup);
 	if (curr < 1000) {
-		debug("Expect time (%ld) to be at least 1000 us\n",
-		      curr);
+		debug("Expect time (%lld) to be at least 1000 us\n", curr);
 		goto cleanup;
 	}
 

@@ -867,7 +865,7 @@ static int test_cgfreezer_time_empty(const char *root)
 	prev = curr;
 	curr = cg_check_freezetime(cgroup);
 	if (curr <= prev) {
-		debug("Expect time (%ld) to be more than previous check (%ld)\n",
+		debug("Expect time (%lld) to be more than previous check (%lld)\n",
 		      curr, prev);
 		goto cleanup;
 	}

@@ -879,7 +877,7 @@ static int test_cgfreezer_time_empty(const char *root)
 	prev = curr;
 	curr = cg_check_freezetime(cgroup);
 	if (curr != prev) {
-		debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
+		debug("Expect time (%lld) to be unchanged from previous check (%lld)\n",
 		      curr, prev);
 		goto cleanup;
 	}

@@ -54,7 +54,8 @@ static int test_kmem_basic(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *cg = NULL;
-	long slab0, slab1, current;
+	s64 slab0, slab1;
+	long current;
 
 	cg = cg_name(root, "kmem_basic_test");
 	if (!cg)

@@ -66,7 +67,7 @@ static int test_kmem_basic(const char *root)
 	if (cg_run(cg, alloc_dcache, (void *)100000))
 		goto cleanup;
 
-	slab0 = cg_read_key_long(cg, "memory.stat", "slab ");
+	slab0 = cg_read_key_s64(cg, "memory.stat", "slab ");
 	if (slab0 < (1 << 20))
 		goto cleanup;
 

@@ -75,7 +76,7 @@ static int test_kmem_basic(const char *root)
 	/* wait for RCU freeing */
 	sleep(1);
 
-	slab1 = cg_read_key_long(cg, "memory.stat", "slab ");
+	slab1 = cg_read_key_s64(cg, "memory.stat", "slab ");
 	if (slab1 < 0)
 		goto cleanup;
 

@@ -167,7 +168,8 @@ static int cg_run_in_subcgroups(const char *parent,
  */
 static int test_kmem_memcg_deletion(const char *root)
 {
-	long current, anon, file, kernel, sock, sum;
+	long current;
+	s64 anon, file, kernel, sock, sum;
 	int ret = KSFT_FAIL;
 	char *parent;
 

@@ -185,23 +187,23 @@ static int test_kmem_memcg_deletion(const char *root)
 		goto cleanup;
 
 	current = cg_read_long(parent, "memory.current");
-	anon = cg_read_key_long(parent, "memory.stat", "anon ");
-	file = cg_read_key_long(parent, "memory.stat", "file ");
-	kernel = cg_read_key_long(parent, "memory.stat", "kernel ");
-	sock = cg_read_key_long(parent, "memory.stat", "sock ");
+	anon = cg_read_key_s64(parent, "memory.stat", "anon ");
+	file = cg_read_key_s64(parent, "memory.stat", "file ");
+	kernel = cg_read_key_s64(parent, "memory.stat", "kernel ");
+	sock = cg_read_key_s64(parent, "memory.stat", "sock ");
 	if (current < 0 || anon < 0 || file < 0 || kernel < 0 || sock < 0)
 		goto cleanup;
 
 	sum = anon + file + kernel + sock;
-	if (labs(sum - current) < MAX_VMSTAT_ERROR) {
+	if (llabs(sum - current) < MAX_VMSTAT_ERROR) {
 		ret = KSFT_PASS;
 	} else {
 		printf("memory.current = %ld\n", current);
-		printf("anon + file + kernel + sock = %ld\n", sum);
-		printf("anon = %ld\n", anon);
-		printf("file = %ld\n", file);
-		printf("kernel = %ld\n", kernel);
-		printf("sock = %ld\n", sock);
+		printf("anon + file + kernel + sock = %lld\n", sum);
+		printf("anon = %lld\n", anon);
+		printf("file = %lld\n", file);
+		printf("kernel = %lld\n", kernel);
+		printf("sock = %lld\n", sock);
 	}
 
 cleanup:

@@ -248,7 +250,7 @@ static int spawn_1000_threads(const char *cgroup, void *arg)
 	int nr_threads = 1000;
 	pthread_t *tinfo;
 	unsigned long i;
-	long stack;
+	s64 stack;
 	int ret = -1;
 
 	tinfo = calloc(nr_threads, sizeof(pthread_t));

@@ -263,7 +265,7 @@ static int spawn_1000_threads(const char *cgroup, void *arg)
 		}
 	}
 
-	stack = cg_read_key_long(cgroup, "memory.stat", "kernel_stack ");
+	stack = cg_read_key_s64(cgroup, "memory.stat", "kernel_stack ");
 	if (stack >= 4096 * 1000)
 		ret = 0;
 

@@ -307,7 +309,7 @@ static int test_kmem_dead_cgroups(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *parent;
-	long dead = -1;
+	s64 dead = -1;
 
 	parent = cg_name(root, "kmem_dead_cgroups_test");
 	if (!parent)

@@ -328,9 +330,10 @@ static int test_kmem_dead_cgroups(const char *root)
 	 * from a specific kernel constant, and can be adjusted if reclaim
 	 * behavior changes in the future.
 	 */
-	dead = cg_read_key_long_poll(parent, "cgroup.stat",
-					"nr_dying_descendants ", 0, KMEM_DEAD_WAIT_RETRIES,
-					DEFAULT_WAIT_INTERVAL_US);
+	dead = cg_read_key_s64_poll(parent, "cgroup.stat",
+				    "nr_dying_descendants ", 0,
+				    KMEM_DEAD_WAIT_RETRIES,
+				    DEFAULT_WAIT_INTERVAL_US);
 	if (dead)
 		goto cleanup;
 

@@ -353,7 +356,8 @@ static int test_percpu_basic(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *parent, *child;
-	long current, percpu, slab;
+	long current;
+	s64 percpu, slab;
 	int i;
 
 	parent = cg_name(root, "percpu_basic_test");

@@ -382,15 +386,15 @@ static int test_percpu_basic(const char *root)
 	}
 
 	current = cg_read_long(parent, "memory.current");
-	percpu = cg_read_key_long(parent, "memory.stat", "percpu ");
-	slab = cg_read_key_long(parent, "memory.stat", "slab ");
+	percpu = cg_read_key_s64(parent, "memory.stat", "percpu ");
+	slab = cg_read_key_s64(parent, "memory.stat", "slab ");
 
 	if (current > 0 && percpu > 0 && slab >= 0 &&
-			labs(current - (percpu + slab)) < MAX_VMSTAT_ERROR)
+	    llabs(current - (percpu + slab)) < MAX_VMSTAT_ERROR)
 		ret = KSFT_PASS;
 	else
-		printf("memory.current %ld\npercpu %ld\nslab %ld\ndelta %ld\n",
-			current, percpu, slab, current - (percpu + slab));
+		printf("memory.current %ld\npercpu %lld\nslab %lld\ndelta %lld\n",
+		       current, percpu, slab, current - (percpu + slab));
 
 cleanup_children:
 	for (i = 0; i < 1000; i++) {

@@ -192,7 +192,8 @@ static int alloc_anon_50M_check(const char *cgroup, void *arg)
 {
 	size_t size = MB(50);
 	char *buf;
-	long anon, current;
+	s64 anon;
+	long current;
 	int ret = -1;
 
 	buf = alloc_and_populate_anon(size);

@@ -206,7 +207,7 @@ static int alloc_anon_50M_check(const char *cgroup, void *arg)
 	if (!values_close(size, current, 3))
 		goto cleanup;
 
-	anon = cg_read_key_long(cgroup, "memory.stat", "anon ");
+	anon = cg_read_key_s64(cgroup, "memory.stat", "anon ");
 	if (anon < 0)
 		goto cleanup;
 

@@ -223,7 +224,8 @@ static int alloc_pagecache_50M_check(const char *cgroup, void *arg)
 {
 	size_t size = MB(50);
 	int ret = -1;
-	long current, file;
+	long current;
+	s64 file;
 	int fd;
 
 	fd = get_temp_fd();

@@ -237,7 +239,7 @@ static int alloc_pagecache_50M_check(const char *cgroup, void *arg)
 	if (current < size)
 		goto cleanup;
 
-	file = cg_read_key_long(cgroup, "memory.stat", "file ");
+	file = cg_read_key_s64(cgroup, "memory.stat", "file ");
 	if (file < 0)
 		goto cleanup;
 

@@ -623,10 +625,10 @@ static int test_memcg_protection(const char *root, bool min)
 	for (i = 0; i < ARRAY_SIZE(children); i++) {
 		int ignore_low_events_index = has_recursiveprot ? 2 : -1;
 		int no_low_events_index = 1;
-		long low, oom;
+		s64 low, oom;
 
-		oom = cg_read_key_long(children[i], "memory.events", "oom ");
-		low = cg_read_key_long(children[i], "memory.events", "low ");
+		oom = cg_read_key_s64(children[i], "memory.events", "oom ");
+		low = cg_read_key_s64(children[i], "memory.events", "low ");
 
 		if (oom)
 			goto cleanup;

@@ -711,7 +713,7 @@ static int test_memcg_high(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *memcg;
-	long high;
+	s64 high;
 
 	memcg = cg_name(root, "memcg_test");
 	if (!memcg)

@@ -738,7 +740,7 @@ static int test_memcg_high(const char *root)
 	if (cg_run(memcg, alloc_pagecache_max_30M, NULL))
 		goto cleanup;
 
-	high = cg_read_key_long(memcg, "memory.events", "high ");
+	high = cg_read_key_s64(memcg, "memory.events", "high ");
 	if (high <= 0)
 		goto cleanup;
 

@@ -774,8 +776,8 @@ static int test_memcg_high_sync(const char *root)
 {
 	int ret = KSFT_FAIL, pid, fd = -1;
 	char *memcg;
-	long pre_high, pre_max;
-	long post_high, post_max;
+	s64 pre_high, pre_max;
+	s64 post_high, post_max;
 
 	memcg = cg_name(root, "memcg_test");
 	if (!memcg)

@@ -784,8 +786,8 @@ static int test_memcg_high_sync(const char *root)
 	if (cg_create(memcg))
 		goto cleanup;
 
-	pre_high = cg_read_key_long(memcg, "memory.events", "high ");
-	pre_max = cg_read_key_long(memcg, "memory.events", "max ");
+	pre_high = cg_read_key_s64(memcg, "memory.events", "high ");
+	pre_max = cg_read_key_s64(memcg, "memory.events", "max ");
 	if (pre_high < 0 || pre_max < 0)
 		goto cleanup;
 

@@ -808,8 +810,8 @@ static int test_memcg_high_sync(const char *root)
 
 	cg_wait_for(fd);
 
-	post_high = cg_read_key_long(memcg, "memory.events", "high ");
-	post_max = cg_read_key_long(memcg, "memory.events", "max ");
+	post_high = cg_read_key_s64(memcg, "memory.events", "high ");
+	post_max = cg_read_key_s64(memcg, "memory.events", "max ");
 	if (post_high < 0 || post_max < 0)
 		goto cleanup;
 

@@ -836,7 +838,8 @@ static int test_memcg_max(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *memcg;
-	long current, max;
+	long current;
+	s64 max;
 
 	memcg = cg_name(root, "memcg_test");
 	if (!memcg)

@@ -865,7 +868,7 @@ static int test_memcg_max(const char *root)
 	if (current > MB(30) || !current)
 		goto cleanup;
 
-	max = cg_read_key_long(memcg, "memory.events", "max ");
+	max = cg_read_key_s64(memcg, "memory.events", "max ");
 	if (max <= 0)
 		goto cleanup;
 

@@ -1029,7 +1032,8 @@ static int test_memcg_swap_max_peak(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *memcg;
-	long max, peak;
+	s64 max;
+	long peak;
 	struct stat ss;
 	int swap_peak_fd = -1, mem_peak_fd = -1;
 

@@ -1122,10 +1126,10 @@ static int test_memcg_swap_max_peak(const char *root)
 	if (!cg_run(memcg, alloc_anon, (void *)MB(100)))
 		goto cleanup;
 
-	if (cg_read_key_long(memcg, "memory.events", "oom ") != 1)
+	if (cg_read_key_s64(memcg, "memory.events", "oom ") != 1)
 		goto cleanup;
 
-	if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 1)
+	if (cg_read_key_s64(memcg, "memory.events", "oom_kill ") != 1)
 		goto cleanup;
 
 	peak = cg_read_long(memcg, "memory.peak");

@@ -1186,7 +1190,7 @@ static int test_memcg_swap_max_peak(const char *root)
 	if (cg_run(memcg, alloc_anon_50M_check_swap, (void *)MB(30)))
 		goto cleanup;
 
-	max = cg_read_key_long(memcg, "memory.events", "max ");
+	max = cg_read_key_s64(memcg, "memory.events", "max ");
 	if (max <= 0)
 		goto cleanup;
 

@@ -1248,10 +1252,10 @@ static int test_memcg_oom_events(const char *root)
 	if (cg_read_strcmp(memcg, "cgroup.procs", ""))
 		goto cleanup;
 
-	if (cg_read_key_long(memcg, "memory.events", "oom ") != 1)
+	if (cg_read_key_s64(memcg, "memory.events", "oom ") != 1)
 		goto cleanup;
 
-	if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 1)
+	if (cg_read_key_s64(memcg, "memory.events", "oom_kill ") != 1)
 		goto cleanup;
 
 	ret = KSFT_PASS;

@@ -1354,13 +1358,14 @@ static int tcp_client(const char *cgroup, unsigned short port)
 	ret = KSFT_FAIL;
 	while (retries--) {
 		uint8_t buf[0x100000];
-		long current, sock;
+		long current;
+		s64 sock;
 
 		if (read(sk, buf, sizeof(buf)) <= 0)
 			goto close_sk;
 
 		current = cg_read_long(cgroup, "memory.current");
-		sock = cg_read_key_long(cgroup, "memory.stat", "sock ");
+		sock = cg_read_key_s64(cgroup, "memory.stat", "sock ");
 
 		if (current < 0 || sock < 0)
 			goto close_sk;

@@ -1392,7 +1397,7 @@ static int test_memcg_sock(const char *root)
 	int bind_retries = 5, ret = KSFT_FAIL, pid, err;
 	unsigned short port;
 	char *memcg;
-	long sock_post = -1;
+	s64 sock_post = -1;
 
 	memcg = cg_name(root, "memcg_test");
 	if (!memcg)

@@ -1459,7 +1464,7 @@ static int test_memcg_sock(const char *root)
 	 * scheduling slack) and require that the "sock " counter
 	 * eventually drops to zero.
 	 */
-	sock_post = cg_read_key_long_poll(memcg, "memory.stat", "sock ", 0,
+	sock_post = cg_read_key_s64_poll(memcg, "memory.stat", "sock ", 0,
 					 MEMCG_SOCKSTAT_WAIT_RETRIES,
 					 DEFAULT_WAIT_INTERVAL_US);
 	if (sock_post)

@@ -1484,7 +1489,7 @@ static int test_memcg_oom_group_leaf_events(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *parent, *child;
-	long parent_oom_events;
+	s64 parent_oom_events;
 
 	parent = cg_name(root, "memcg_test_0");
 	child = cg_name(root, "memcg_test_0/memcg_test_1");

@@ -1519,11 +1524,11 @@ static int test_memcg_oom_group_leaf_events(const char *root)
 	if (cg_test_proc_killed(child))
 		goto cleanup;
 
-	if (cg_read_key_long(child, "memory.events", "oom_kill ") <= 0)
+	if (cg_read_key_s64(child, "memory.events", "oom_kill ") <= 0)
 		goto cleanup;
 
-	parent_oom_events = cg_read_key_long(
-			parent, "memory.events", "oom_kill ");
+	parent_oom_events =
+		cg_read_key_s64(parent, "memory.events", "oom_kill ");
 	/*
 	 * If memory_localevents is not enabled (the default), the parent should
 	 * count OOM events in its children groups. Otherwise, it should not

@@ -1639,7 +1644,7 @@ static int test_memcg_oom_group_score_events(const char *root)
 	if (!cg_run(memcg, alloc_anon, (void *)MB(100)))
 		goto cleanup;
 
-	if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 3)
+	if (cg_read_key_s64(memcg, "memory.events", "oom_kill ") != 3)
 		goto cleanup;
 
 	if (kill(safe_pid, SIGKILL))

@@ -111,12 +111,11 @@ static int test_pids_events(const char *root)
 	if (kill(pid, SIGINT))
 		goto cleanup;
 
-	if (cg_read_key_long(cg_child, "pids.events", "max ") != 0)
+	if (cg_read_key_s64(cg_child, "pids.events", "max ") != 0)
 		goto cleanup;
-	if (cg_read_key_long(cg_parent, "pids.events", "max ") != 1)
+	if (cg_read_key_s64(cg_parent, "pids.events", "max ") != 1)
 		goto cleanup;
 
-
 	ret = KSFT_PASS;
 
 cleanup:

@@ -59,14 +59,14 @@ static int get_zswap_stored_pages(size_t *value)
 	return read_int(PATH_ZSWAP_STORED_PAGES, value);
 }
 
-static long get_cg_wb_count(const char *cg)
+static s64 get_cg_wb_count(const char *cg)
 {
-	return cg_read_key_long(cg, "memory.stat", "zswpwb");
+	return cg_read_key_s64(cg, "memory.stat", "zswpwb");
 }
 
-static long get_zswpout(const char *cgroup)
+static s64 get_zswpout(const char *cgroup)
 {
-	return cg_read_key_long(cgroup, "memory.stat", "zswpout ");
+	return cg_read_key_s64(cgroup, "memory.stat", "zswpout ");
 }
 
 static int allocate_and_read_bytes(const char *cgroup, void *arg)

@@ -125,9 +125,10 @@ static char *setup_test_group_1M(const char *root, const char *name)
  * Writeback is asynchronous; poll until at least one writeback has
  * been recorded for @cg, or until @timeout_ms has elapsed.
  */
-static long wait_for_writeback(const char *cg, int timeout_ms)
+static s64 wait_for_writeback(const char *cg, int timeout_ms)
 {
-	long elapsed, count;
+	long elapsed;
+	s64 count;
 	for (elapsed = 0; elapsed < timeout_ms; elapsed += 100) {
 		count = get_cg_wb_count(cg);
 

@@ -147,7 +148,7 @@ static long wait_for_writeback(const char *cg, int timeout_ms)
  */
 static int test_zswap_usage(const char *root)
 {
-	long zswpout_before, zswpout_after;
+	s64 zswpout_before, zswpout_after;
 	int ret = KSFT_FAIL;
 	char *test_group;
 

@@ -191,7 +192,8 @@ static int test_swapin_nozswap(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *test_group, mem_max_buf[32];
-	long swap_peak, zswpout, min_swap;
+	long swap_peak, min_swap;
+	s64 zswpout;
 	size_t allocation_size = page_size * 512;
 
 	min_swap = allocation_size / 4;

@@ -248,7 +250,7 @@ static int test_zswapin(const char *root)
 {
 	int ret = KSFT_FAIL;
 	char *test_group;
-	long zswpin;
+	s64 zswpin;
 
 	test_group = cg_name(root, "zswapin_test");
 	if (!test_group)

@@ -264,7 +266,7 @@ static int test_zswapin(const char *root)
 	if (cg_run(test_group, allocate_and_read_bytes, (void *)MB(32)))
 		goto out;
 
-	zswpin = cg_read_key_long(test_group, "memory.stat", "zswpin ");
+	zswpin = cg_read_key_s64(test_group, "memory.stat", "zswpin ");
 	if (zswpin < 0) {
 		ksft_print_msg("failed to get zswpin\n");
 		goto out;

@@ -355,11 +357,11 @@ static int attempt_writeback(const char *cgroup, void *arg)
 
 static int test_zswap_writeback_one(const char *cgroup, bool wb)
 {
-	long zswpwb_before, zswpwb_after;
+	s64 zswpwb_before, zswpwb_after;
 
 	zswpwb_before = get_cg_wb_count(cgroup);
 	if (zswpwb_before != 0) {
-		ksft_print_msg("zswpwb_before = %ld instead of 0\n", zswpwb_before);
+		ksft_print_msg("zswpwb_before = %lld instead of 0\n", zswpwb_before);
 		return -1;
 	}
 

@@ -375,7 +377,7 @@ static int test_zswap_writeback_one(const char *cgroup, bool wb)
 		return -1;
 
 	if (wb != !!zswpwb_after) {
-		ksft_print_msg("zswpwb_after is %ld while wb is %s\n",
+		ksft_print_msg("zswpwb_after is %lld while wb is %s\n",
 				zswpwb_after, wb ? "enabled" : "disabled");
 		return -1;
 	}

@@ -487,7 +489,7 @@ static int test_no_invasive_cgroup_shrink(const char *root)
 		memset(&zw_allocation[off], 0, page_size);
 		memset(&zw_allocation[off], 'a', page_size/4);
 	}
-	if (cg_read_key_long(zw_group, "memory.stat", "zswapped") < 1)
+	if (cg_read_key_s64(zw_group, "memory.stat", "zswapped") < 1)
 		goto out;
 
 	/* Push wb_group memory into zswap with hard-to-compress data to trigger wb */

@@ -630,7 +632,7 @@ static int test_no_kmem_bypass(const char *root)
 			break;
 		/* If memory was pushed to zswap, verify it belongs to memcg */
 		if (stored_pages > stored_pages_threshold) {
-			int zswapped = cg_read_key_long(test_group, "memory.stat", "zswapped ");
+			s64 zswapped = cg_read_key_s64(test_group, "memory.stat", "zswapped ");
 			int delta = stored_pages * page_size - zswapped;
 			int result_ok = delta < stored_pages * page_size / 4;
 

@@ -703,9 +705,9 @@ static int allocate_random_and_wait(const char *cgroup, void *arg)
 	return 0;
 }
 
-static long get_zswap_incomp(const char *cgroup)
+static s64 get_zswap_incomp(const char *cgroup)
 {
-	return cg_read_key_long(cgroup, "memory.stat", "zswap_incomp ");
+	return cg_read_key_s64(cgroup, "memory.stat", "zswap_incomp ");
 }
 
 /*

@@ -721,7 +723,7 @@ static int test_zswap_incompressible(const char *root)
 	int ret = KSFT_FAIL;
 	struct incomp_child_args *values;
 	char *test_group;
-	long zswap_incomp;
+	s64 zswap_incomp;
 	pid_t child_pid;
 	int child_status;
 	char buf;

@@ -757,13 +759,15 @@ static int test_zswap_incompressible(const char *root)
 
 	zswap_incomp = get_zswap_incomp(test_group);
 	if (zswap_incomp <= 0) {
-		long zswpout = get_zswpout(test_group);
-		long zswapped = cg_read_key_long(test_group, "memory.stat", "zswapped ");
-		long zswap_b = cg_read_key_long(test_group, "memory.stat", "zswap ");
-
-		ksft_print_msg("zswap_incomp not increased: %ld\n", zswap_incomp);
-		ksft_print_msg("debug: zswpout=%ld zswapped=%ld zswap_b=%ld\n",
-			       zswpout, zswapped, zswap_b);
+		s64 zswpout = get_zswpout(test_group);
+		s64 zswapped =
+			cg_read_key_s64(test_group, "memory.stat", "zswapped ");
+		s64 zswap_b =
+			cg_read_key_s64(test_group, "memory.stat", "zswap ");
+
+		ksft_print_msg("zswap_incomp not increased: %lld\n", zswap_incomp);
+		ksft_print_msg("debug: zswpout=%lld zswapped=%lld zswap_b=%lld\n",
+				zswpout, zswapped, zswap_b);
 		ksft_print_msg("debug: madvise ret=%d errno=%d\n",
 			       values->madvise_ret, values->madvise_errno);
 		goto out_kill;