/******************************************************************************/
/*                                                                            */
/* Copyright (c) International Business Machines  Corp., 2007                 */
/* Copyright (c) Linux Test Project, 2016                                     */
/*                                                                            */
/* 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 3 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.                               */
/*                                                                            */
/* You should have received a copy of the GNU General Public License          */
/* along with this program. If not, see <http://www.gnu.org/licenses/>.       */
/*                                                                            */
/******************************************************************************/

/******************************************************************************/
/*                                                                            */
/* File:        support_numa.c                                                */
/*                                                                            */
/* Description: Allocates memory and touches it to verify numa                */
/*                                                                            */
/* Author:      Sivakumar Chinnaiah  Sivakumar.C@in.ibm.com                   */
/*                                                                            */
/******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <limits.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include "lapi/mmap.h"

/* Global Variables */
#define MB (1<<20)
#define PAGE_SIZE getpagesize()
#define barrier() __asm__ __volatile__("": : :"memory")
#define TEST_SFILE "ltp_numa_testfile"
#define STR "abcdefghijklmnopqrstuvwxyz12345\n"

static void help(void)
{
	printf("Input:	Describe input arguments to this program\n");
	printf("	argv[1] == \"alloc_1MB\" then allocate 1MB of memory\n");
	printf("	argv[1] == \"alloc_1MB_shared\" then allocate 1MB of share memory\n");
	printf("	argv[1] == \"alloc_2HPSZ_THP\" then allocate 2HUGE PAGE SIZE of THP memory\n");
	printf("        argv[1] == \"alloc_1huge_page\" then allocate 1HUGE PAGE SIZE of memory\n");
	printf("        argv[1] == \"pause\" then pause the program to catch sigint\n");
	printf("Exit:	On failure - Exits with non-zero value\n");
	printf("	On success - exits with 0 exit value\n");

	exit(1);
}

static int read_hugepagesize(void)
{
	FILE *fp;
	char line[BUFSIZ], buf[BUFSIZ];
	int val;

	fp = fopen("/proc/meminfo", "r");
	if (fp == NULL) {
		fprintf(stderr, "Failed to open /proc/meminfo");
		return 0;
	}

	while (fgets(line, BUFSIZ, fp) != NULL) {
		if (sscanf(line, "%64s %d", buf, &val) == 2)
			if (strcmp(buf, "Hugepagesize:") == 0) {
				fclose(fp);
				return 1024 * val;
			}
	}

	fclose(fp);
	fprintf(stderr, "can't find \"%s\" in %s", "Hugepagesize:", "/proc/meminfo");

	return 0;
}

int main(int argc, char *argv[])
{
	int i, fd, rc, hpsz;
	char *buf = NULL;
	struct stat sb;

	if (argc != 2) {
		fprintf(stderr, "Here expect only one number(i.e. 2) as the parameter\n");
		exit(1);
	}

	if (!strcmp(argv[1], "alloc_1MB")) {
		buf = malloc(MB);
		if (!buf) {
			fprintf(stderr, "Memory is not available\n");
			exit(1);
		}
		for (i = 0; i < MB; i += PAGE_SIZE) {
			buf[i] = 'a';
			barrier();
		}

		raise(SIGSTOP);

		free(buf);
	} else if (!strcmp(argv[1], "alloc_1MB_shared")) {
		fd = open(TEST_SFILE, O_RDWR | O_CREAT, 0666);
		/* Writing 1MB of random data into this file [32 * 32768 = 1024 * 1024] */
		for (i = 0; i < 32768; i++){
			rc = write(fd, STR, strlen(STR));
			if (rc == -1 || ((size_t)rc != strlen(STR)))
				fprintf(stderr, "write failed\n");
		}

		if ((fstat(fd, &sb)) == -1)
			fprintf(stderr, "fstat failed\n");

		buf = mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
		if (buf == MAP_FAILED){
			fprintf(stderr, "mmap failed\n");
			close(fd);
			exit(1);
		}

		memset(buf, 'a', sb.st_size);

		raise(SIGSTOP);

		munmap(buf, sb.st_size);
		close(fd);
		remove(TEST_SFILE);
	} else if (!strcmp(argv[1], "alloc_2HPSZ_THP")) {
		ssize_t size = 2 * read_hugepagesize();
		if (size == 0)
			exit(1);

		buf = mmap(NULL, size, PROT_READ | PROT_WRITE,
				MAP_PRIVATE | MAP_ANONYMOUS,
				-1, 0);
		if (buf == MAP_FAILED) {
			perror("mmap failed");
			exit(1);
		}

		memset(buf, 'a', size);

		raise(SIGSTOP);

		munmap(buf, size);
	} else if (!strcmp(argv[1], "alloc_1huge_page")) {
		hpsz = read_hugepagesize();
		if (hpsz == 0)
			exit(1);

		buf = mmap(NULL, hpsz, PROT_READ | PROT_WRITE,
				MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB,
				-1, 0);

		if (buf == MAP_FAILED) {
			perror("mmap failed");
			exit(1);
		}

		memset(buf, 'a', hpsz);

		raise(SIGSTOP);

		munmap(buf, hpsz);
	} else if (!strcmp(argv[1], "pause")) {
		raise(SIGSTOP);
	} else {
		help();
	}

	return 0;
}