/*
 * Copyright (c) 2017 Red Hat, Inc.
 * 01/02/2003	Port to LTP avenkat@us.ibm.com
 * 06/30/2001	Port to Linux	nsharoff@us.ibm.com
 *
 * 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/>.
 */
/*
 * Mmap parts of a file, and then write to the file causing single
 * write requests to jump back and forth between mmaped io and regular io.
 */

#define _GNU_SOURCE
#include <stdlib.h>
#include "tst_test.h"
#include "tst_safe_macros.h"

#define NUM_PAGES (192)
#define TEST_FILE "mmapstress04-testfile"

static int page_size;
static unsigned char *mmap_area;

static void setup(void)
{
	page_size = getpagesize();

	/*
	 * Pick large enough area, PROT_NONE doesn't matter,
	 * because we remap it later.
	 */
	mmap_area = SAFE_MMAP(NULL, page_size * NUM_PAGES, PROT_NONE,
		MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
}

static void write_fully(int fd, void *buf, int len)
{
	int ret;

	do {
		ret = SAFE_WRITE(0, fd, buf, len);
		buf += ret;
		len -= ret;
	} while (len > 0);
}

static void mmapstress04(void)
{
	int i, j, rofd, rwfd;
	char *buf;
	int mapped_pages = 0;

	if (tst_fill_file(TEST_FILE, 'b', page_size, 1))
		tst_brk(TBROK | TERRNO, "fill_file");

	rofd = SAFE_OPEN(TEST_FILE, O_RDONLY | O_CREAT, 0777);
	/*
	 * Assuming disk blocks are 8k, and logical pages are 4k, there are
	 * two maps per block. In order to test mapping at the beginning and
	 * ends of the block, mapping the whole block, or none of the block
	 * with different mappings on preceding and following blocks, each
	 * 3 blocks with 6 pages can be thought of as a binary number from 0 to
	 * 64 with a bit set for mapped or cleared for unmapped. This number
	 * is represented by i. The value j is used to look at the bits of i
	 * and decided to map the page or not.
	 * NOTE: None of the above assumptions are critical.
	 */
	for (i = 0; i < 64; i++) {
		for (j = 0; j < 6; j++) {
			off_t mapoff;

			if (!(i & (1 << j)))
				continue;

			mapoff = page_size * (off_t)(6 * i + j);
			SAFE_MMAP(mmap_area + page_size * mapped_pages++,
				 page_size, PROT_READ,
				 MAP_FILE | MAP_PRIVATE | MAP_FIXED,
				 rofd, mapoff);
		}
	}
	SAFE_CLOSE(rofd);

	/* write out 6 pages of stuff into each of the 64 six page sections */
	rwfd = SAFE_OPEN(TEST_FILE, O_RDWR);
	buf = SAFE_MALLOC(page_size);
	memset(buf, 'a', page_size);
	for (i = 0; i < 6 * 64; i++)
		write_fully(rwfd, buf, page_size);
	free(buf);
	SAFE_CLOSE(rwfd);

	/*
	 * Just finished scribbling all over interwoven mmapped and unmapped
	 * regions. Check the data.
	 */
	for (i = 0; i < mapped_pages * page_size; i++) {
		unsigned char val = *(mmap_area + i);

		if (val != 'a') {
			tst_res(TFAIL, "unexpected value in map, "
				"i=%d,val=0x%x", i, val);
			goto done;
		}
	}
	tst_res(TPASS, "blocks have expected data");
done:
	SAFE_UNLINK(TEST_FILE);
}

static struct tst_test test = {
	.needs_tmpdir = 1,
	.test_all = mmapstress04,
	.setup = setup,
};
