/*
 *
 *   Copyright (c) International Business Machines  Corp., 2001
 *
 *   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.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program;  if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
 * NAME
 *	fcntl11.c
 *
 * DESCRIPTION
 *	Testcase to check locking of regions of a file
 *
 * ALGORITHM
 *	Test changing lock sections around a write lock
 *
 * USAGE
 *	fcntl11
 *
 * HISTORY
 *	07/2001 Ported by Wayne Boyer
 *
 * RESTRICTIONS
 *	None
 */

#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <inttypes.h>
#include "test.h"
#include "safe_macros.h"

#define STRINGSIZE	27
#define STRING		"abcdefghijklmnopqrstuvwxyz\n"
#define STOP		0xFFF0

int parent_pipe[2];
int child_pipe[2];
int fd;
pid_t parent_pid, child_pid;

void parent_put();
void parent_get();
void child_put();
void child_get();
void stop_child();
void compare_lock(struct flock *, short, short, int, int, pid_t);
void unlock_file();
void do_test(struct flock *, short, short, int, int);
void catch_child();
char *str_type();
int do_lock(int, short, short, int, int);

char *TCID = "fcntl11";
int TST_TOTAL = 1;

int fail;

void cleanup(void)
{
	tst_rmdir();

}

void setup(void)
{
	char *buf = STRING;
	char template[PATH_MAX];
	struct sigaction act;

	tst_sig(FORK, DEF_HANDLER, cleanup);
	tst_tmpdir();

	umask(0);

	TEST_PAUSE;

	SAFE_PIPE(cleanup, parent_pipe);
	SAFE_PIPE(cleanup, child_pipe);
	parent_pid = getpid();
	snprintf(template, PATH_MAX, "fcntl11XXXXXX");

	if ((fd = mkstemp(template)) < 0)
		tst_resm(TFAIL, "Couldn't open temp file! errno = %d", errno);

	SAFE_WRITE(cleanup, 0, fd, buf, STRINGSIZE);

	memset(&act, 0, sizeof(act));
	act.sa_handler = catch_child;
	sigemptyset(&act.sa_mask);
	sigaddset(&act.sa_mask, SIGCHLD);
	if ((sigaction(SIGCHLD, &act, NULL)) < 0)
		tst_brkm(TBROK | TERRNO, cleanup,
			 "sigaction(SIGCHLD, ..) failed");
}

void do_child(void)
{
	struct flock fl;

	close(parent_pipe[1]);
	close(child_pipe[0]);
	while (1) {
		child_get(&fl);
		if (fcntl(fd, F_GETLK, &fl) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");
		child_put(&fl);
	}
}

int do_lock(int cmd, short type, short whence, int start, int len)
{
	struct flock fl;

	fl.l_type = type;
	fl.l_whence = whence;
	fl.l_start = start;
	fl.l_len = len;
	return (fcntl(fd, cmd, &fl));
}

void do_test(struct flock *fl, short type, short whence, int start, int len)
{
	fl->l_type = type;
	fl->l_whence = whence;
	fl->l_start = start;
	fl->l_len = len;
	fl->l_pid = (short)0;

	parent_put(fl);
	parent_get(fl);
}

void
compare_lock(struct flock *fl, short type, short whence, int start, int len,
	     pid_t pid)
{
	if (fl->l_type != type)
		tst_resm(TFAIL, "lock type is wrong should be %s is %s",
			 str_type(type), str_type(fl->l_type));

	if (fl->l_whence != whence)
		tst_resm(TFAIL, "lock whence is wrong should be %d is %d",
			 whence, fl->l_whence);

	if (fl->l_start != start)
		tst_resm(TFAIL, "region starts in wrong place, should be "
			 "%d is %" PRId64, start, (int64_t) fl->l_start);

	if (fl->l_len != len)
		tst_resm(TFAIL,
			 "region length is wrong, should be %d is %" PRId64,
			 len, (int64_t) fl->l_len);

	if (fl->l_pid != pid)
		tst_resm(TFAIL, "locking pid is wrong, should be %d is %d",
			 pid, fl->l_pid);
}

void unlock_file(void)
{
	struct flock fl;

	if (do_lock(F_SETLK, (short)F_UNLCK, (short)0, 0, 0) < 0)
		tst_resm(TFAIL | TERRNO, "fcntl on file failed");
	do_test(&fl, F_WRLCK, 0, 0, 0);
	compare_lock(&fl, (short)F_UNLCK, (short)0, 0, 0, (pid_t) 0);
}

char *str_type(int type)
{
	static char buf[20];

	switch (type) {
	case 0:
		return ("F_RDLCK");
	case 1:
		return ("F_WRLCK");
	case 2:
		return ("F_UNLCK");
	default:
		sprintf(buf, "BAD VALUE: %d", type);
		return (buf);
	}
}

void parent_put(struct flock *l)
{
	SAFE_WRITE(cleanup, 1, parent_pipe[1], l, sizeof(*l));
}

void parent_get(struct flock *l)
{
	SAFE_READ(cleanup, 1, child_pipe[0], l, sizeof(*l));
}

void child_put(struct flock *l)
{
	SAFE_WRITE(NULL, 1, child_pipe[1], l, sizeof(*l));
}

void child_get(struct flock *l)
{
	SAFE_READ(NULL, 1, parent_pipe[0], l, sizeof(*l));
	if (l->l_type == (short)STOP)
		exit(0);
}

void stop_child(void)
{
	struct flock fl;

	signal(SIGCHLD, SIG_DFL);
	fl.l_type = STOP;
	parent_put(&fl);
	wait(0);
}

void catch_child(void)
{
	tst_brkm(TFAIL, cleanup, "Unexpected death of child process");
}

int main(int ac, char **av)
{
	struct flock tl;

	int lc;

	tst_parse_opts(ac, av, NULL, NULL);
#ifdef UCLINUX
	maybe_run_child(&do_child, "ddddd", &parent_pipe[0],
			&parent_pipe[1], &child_pipe[0], &child_pipe[1], &fd);
#endif

	setup();		/* global setup */

	/* Check for looping state if -i option is given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* reset tst_count in case we are looping */
		tst_count = 0;

		if ((child_pid = FORK_OR_VFORK()) == 0) {	/* parent */
#ifdef UCLINUX
			if (self_exec(av[0], "ddddd", parent_pipe[0],
				      parent_pipe[1], child_pipe[0],
				      child_pipe[1], fd) < 0)
				tst_brkm(TBROK | TERRNO, cleanup,
					 "self_exec failed");
#else
			do_child();
#endif
		} else if (child_pid == -1)
			tst_brkm(TBROK | TERRNO, cleanup, "fork failed");

		SAFE_CLOSE(cleanup, parent_pipe[0]);
		SAFE_CLOSE(cleanup, child_pipe[1]);

/* //block1: */
		tst_resm(TINFO, "Enter block 1");

		/*
		 * Add a write lock to the middle of the file and a read
		 * at the begining
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 1, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test read lock
		 */
		do_test(&tl, F_WRLCK, 0, 0, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 1, 5, parent_pid);

		/*
		 * Test write lock
		 */
		do_test(&tl, F_WRLCK, 0, 6, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);

		/*
		 * Test that the rest of the file is unlocked
		 */
		do_test(&tl, F_WRLCK, 0, 15, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 1");

/* //block2: */
		tst_resm(TINFO, "Enter block 2");

		/*
		 * Set a write lock at the middle of the file and a
		 * read lock just before
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 5, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 5, 5, parent_pid);

		/*
		 * Test the write lock.
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 10, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked.
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 2");

/* //block3: */
		tst_resm(TINFO, "Enter block 3");

		/*
		 * Set a write lock in the middle and a read lock that
		 * ends at the first byte of the write lock
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 5, 6) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 5, 6, parent_pid);

		/*
		 * Test write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 11, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 11, 4, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked.
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 3");

/* //block4: */
		tst_resm(TINFO, "Enter block 4");

		/*
		 * Set a write lock on the middle of the file and a read
		 * lock that overlaps the front of the write.
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 5, 8) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 5, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 5, 8, parent_pid);

		/*
		 * Test the write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 13, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 13, 2, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked.
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 4");

/* //block5: */
		tst_resm(TINFO, "Enter block 5");

		/*
		 * Set a write lock in the middle of a file and a read
		 * lock in the middle of it
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 10) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 13, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test the first write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 3, parent_pid);

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 13, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 13, 5, parent_pid);

		/*
		 * Test the second write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 18, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 18, 2, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 20, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 20, 0, 0);

		/*
		 * remove all the locks set above.
		 */
		unlock_file();
		tst_resm(TINFO, "Exit block 5");

/* //block6: */
		tst_resm(TINFO, "Enter block 6");
		/*
		 * Set a write lock in the middle of the file and a read
		 * lock that overlaps the end
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Set a read lock on the whole file
		 */
		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 13, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test the write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 3, parent_pid);

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 13, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 13, 5, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 18, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 18, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 6");

/* //block7: */
		tst_resm(TINFO, "Enter block 7");

		/*
		 * Set a write lock in the middle of the file and a read
		 * lock starting at the last byte of the write lock
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Set a read lock on the whole file.
		 */
		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 14, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 4, parent_pid);

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 14, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 14, 5, parent_pid);

		/*
		 * Test to make sure the end of the file is unlocked
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 19, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 19, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 7");

/* //block8: */
		tst_resm(TINFO, "Enter block 8");

		/*
		 * Set a write lock in the middle of the file and a read
		 * lock that starts just after the last byte of the
		 * write lock.
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Set a read lock on the whole file
		 */
		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 15, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test the write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 15, 5, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 20, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 20, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 8");

/* //block9: */
		tst_resm(TINFO, "Enter block 9");

		/*
		 * Set a write lock at the middle of the file and a read
		 * lock that starts past the end of the write lock.
		 */
		if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 16, 5) < 0)
			tst_resm(TFAIL | TERRNO, "fcntl on file failed");

		/*
		 * Test the write lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
		compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);

		/*
		 * Test that byte in between is unlocked
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 15, 1);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 1, 0);

		/*
		 * Test the read lock
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 16, 0);
		compare_lock(&tl, (short)F_RDLCK, (short)0, 16, 5, parent_pid);

		/*
		 * Test to make sure the rest of the file is unlocked
		 */
		do_test(&tl, (short)F_WRLCK, (short)0, 21, 0);
		compare_lock(&tl, (short)F_UNLCK, (short)0, 21, 0, 0);

		/*
		 * remove all the locks set above
		 */
		unlock_file();

		tst_resm(TINFO, "Exit block 9");

		stop_child();
		SAFE_CLOSE(cleanup, fd);
	}
	cleanup();
	tst_exit();
}