/*
 * Copyright (C) 2012-2017  Red Hat, Inc.
 *
 * This program is free software;  you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY;  without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 * the GNU General Public License for more details.
 */
/*
 * swapping01 - first time swap use results in heavy swapping
 *
 * This case is used for testing upstream commit: 50a1598
 *
 * The upstream commit fixed a issue on s390/x platform that heavy
 * swapping might occur in some condition, however since the patch
 * was quite general, this testcase will be run on all supported
 * platforms to ensure no regression been introduced.
 *
 * Details of the upstream fix:
 * On x86 a page without a mapper is by definition not referenced / old.
 * The s390 architecture keeps the reference bit in the storage key and
 * the current code will check the storage key for page without a mapper.
 * This leads to an interesting effect: the first time an s390 system
 * needs to write pages to swap it only finds referenced pages. This
 * causes a lot of pages to get added and written to the swap device.
 * To avoid this behaviour change page_referenced to query the storage
 * key only if there is a mapper of the page.
 *
 * Test Strategy:
 * Try to allocate memory which size is slightly larger than current
 * available memory. After allocation done, continue loop for a while
 * and calculate the used swap size. The used swap size should be small
 * enough, else it indicates that heavy swapping is occured unexpectedly.
 */

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "mem.h"

/* allow swapping 1 * phy_mem in maximum */
#define COE_DELTA       1
/* will try to alloc 1.3 * phy_mem */
#define COE_SLIGHT_OVER 0.3

static void init_meminfo(void);
static void do_alloc(void);
static void check_swapping(void);

static long mem_available_init;
static long swap_free_init;
static long mem_over;
static long mem_over_max;
static pid_t pid;

static void test_swapping(void)
{
#if __WORDSIZE == 32
	tst_brk(TCONF, "test is not designed for 32-bit system.");
#endif

	init_meminfo();

	switch (pid = SAFE_FORK()) {
		case 0:
			do_alloc();
			exit(0);
		default:
			check_swapping();
	}
}

static void init_meminfo(void)
{
	swap_free_init = SAFE_READ_MEMINFO("SwapFree:");
	if (FILE_LINES_SCANF("/proc/meminfo", "MemAvailable: %ld",
		&mem_available_init)) {
		mem_available_init = SAFE_READ_MEMINFO("MemFree:")
			+ SAFE_READ_MEMINFO("Cached:");
	}
	mem_over = mem_available_init * COE_SLIGHT_OVER;
	mem_over_max = mem_available_init * COE_DELTA;

	/* at least 10MB available physical memory needed */
	if (mem_available_init < 10240)
		tst_brk(TCONF, "Not enough available mem to test.");

	if (swap_free_init < mem_over_max)
		tst_brk(TCONF, "Not enough swap space to test.");
}

static void do_alloc(void)
{
	long mem_count;
	void *s;

	tst_res(TINFO, "available physical memory: %ld MB",
		mem_available_init / 1024);
	mem_count = mem_available_init + mem_over;
	tst_res(TINFO, "try to allocate: %ld MB", mem_count / 1024);
	s = SAFE_MALLOC(mem_count * 1024);
	memset(s, 1, mem_count * 1024);
	tst_res(TINFO, "memory allocated: %ld MB", mem_count / 1024);
	if (raise(SIGSTOP) == -1)
		tst_brk(TBROK | TERRNO, "kill");
	free(s);
}

static void check_swapping(void)
{
	int status, i;
	long swap_free_now, swapped;

	/* wait child stop */
	if (waitpid(pid, &status, WUNTRACED) == -1)
		tst_brk(TBROK | TERRNO, "waitpid");
	if (!WIFSTOPPED(status))
		tst_brk(TBROK, "child was not stopped.");

	/* Still occupying memory, loop for a while */
	i = 0;
	while (i < 10) {
		swap_free_now = SAFE_READ_MEMINFO("SwapFree:");
		sleep(1);
		if (abs(swap_free_now - SAFE_READ_MEMINFO("SwapFree:")) < 512)
			break;

		i++;
	}

	swap_free_now = SAFE_READ_MEMINFO("SwapFree:");
	swapped = swap_free_init - swap_free_now;
	if (swapped > mem_over_max) {
		kill(pid, SIGCONT);
		tst_brk(TFAIL, "heavy swapping detected: "
				"%ld MB swapped.", swapped / 1024);
	}

	tst_res(TPASS, "no heavy swapping detected, %ld MB swapped.",
		 swapped / 1024);
	kill(pid, SIGCONT);
	/* wait child exit */
	if (waitpid(pid, &status, 0) == -1)
		tst_brk(TBROK | TERRNO, "waitpid");
}

static struct tst_test test = {
	.needs_root = 1,
	.test_all = test_swapping,
};
