/*
 * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Further, this software is distributed without any warranty that it is
 * free of the rightful claim of any third person regarding infringement
 * or the like.  Any license provided herein, whether implied or
 * otherwise, applies only to this software file.  Patent licenses, if
 * any, provided herein do not apply to combinations of this program with
 * other software, or any other product whatsoever.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 * Mountain View, CA  94043, or:
 *
 * http://www.sgi.com
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 *
 */
/* $Id: asyncio02.c,v 1.6 2009/08/28 11:17:39 vapier Exp $ */
/************************************************************
 * OS Test - Silicon Graphics, Inc.
 * Mendota Heights, Minnesota
 *
 * TEST IDENTIFIER:  aiotcs02:  write/close flushes data to the file
 *
 * PARENT DOCUMENT:  aiotds01:  kernel i/o
 *
 * AUTHOR: Barrie Kletscher
 *
 * CO-PILOT: Dave Baumgartner
 *
 * TEST ITEMS:
 * 	for each open flags set used:
 * 	1. Multiple writes to a file work as specified for
 * 	   more than BUFSIZ bytes.
 * 	2. Multiple writes to a file work as specified for
 * 	   BUFSIZ bytes.
 * 	3. Multiple writes to a file work as specified for
 * 	   lower than BUFSIZ bytes.
 *
 * INPUT SPECIFICATIONS:
 * 	Standard parse_opts supported options.
 *$
 * OUTPUT SPECIFICATIONS
 * 	Standard tst_res output format
 *
 * ENVIRONMENTAL NEEDS:
 * 	This program uses the environment variable TMPDIR for the location
 * 	of the temporary directory.
 *
 *
 * SPECIAL PROCEDURAL REQUIREMENTS:
 * 	The program must be linked with tst_*.o and parse_opts.o.
 *
 * INTERCASE DEPENDENCIES:
 * 	NONE.
 *
 * DETAILED DESCRIPTION:
 * 	Attempt to get some memory to work with.
 * 	Call testrun writing (BUFSIZ + 1) bytes
 * 	Call testrun writing BUFSIZ bytes
 * 	Repeated call to testrun() with decreasing write sizes
 * 		less than BUFSIZ
 * 	End
 *
 * 	Start testrun()
 * 	Attempt to open a temporary file.
 * 	Write the memory to the file.
 * 	Attempt to close the file which also flushes the buffers.
 * 	Now check to see if the number of bytes written is the
 * 		same as the number of bytes in the file.
 * 	Cleanup
 *
 * BUGS:
 * 	NONE.
 *
************************************************************/

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <errno.h>
#include <stdlib.h>
#include "test.h"

#define FLAG O_RDWR | O_CREAT | O_TRUNC	/* Flags used when opening temp tile */
#define MODE  0777		/* Mode to open file with */
#define WRITES 10		/* Number of times buffer is written */
#define DECR 1000		/* Number of bytes decremented between */
					/* Calls to testrun() */
#define OK -1			/* Return value from testrun() */

#define FNAME1	"aio02.1"
#define FNAME2	"aio02.2"
#define FNAME3	"aio02.3"

#define ERR_MSG1 "Bytes in file not equal to bytes written."
#define ERR_MSG2 "Bytes in file (%d) not equal to bytes written (%d)."

char *dp;			/* pointer to area of memory */

void setup();
void cleanup();
int testrun(int flag, int bytes, int ti);

char *TCID = "asyncio02";
int TST_TOTAL = 6;

char *filename;			/* name of the temporary file */

char *Progname;
int Open_flags;

int Flags[] = {
	O_RDWR | O_CREAT | O_TRUNC,
	O_RDWR | O_CREAT | O_TRUNC
};

int Num_flags;

/***********************************************************************
 * MAIN
 ***********************************************************************/
int main(int ac, char **av)
{

	int i;
	int ret_val;
	int eok;		/* everything is ok flag */
	int lc;
	const char *msg;
	int flag_cnt;

	Num_flags = sizeof(Flags) / sizeof(int);
	TST_TOTAL = 3 * Num_flags;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		tst_count = 0;

		for (flag_cnt = 0; flag_cnt < Num_flags; flag_cnt++) {

			/*
			 * call testrun writing (BUFSIZ + 1) byte chunks
			 */

			filename = FNAME1;
			if (testrun(Flags[flag_cnt], BUFSIZ + 1, 1) != OK) {
				tst_resm(TFAIL, ERR_MSG1);
			} else {
				tst_resm(TPASS,
					 "More than BUFSIZE bytes multiple synchronous writes to a file check out ok");
			}

			/*
			 * call testrun writing BUFSIZ byte chunks
			 */

			filename = FNAME2;
			if (testrun(Flags[flag_cnt], BUFSIZ, 2) != OK) {
				tst_resm(TFAIL, ERR_MSG1);
			} else {
				tst_resm(TPASS,
					 "BUFSIZE bytes multiple synchronous writes to a file checks out ok");
			}

			/*
			 * while the byte chunks are greater than 0
			 *      call testrun() with decreasing chunk sizes
			 */

			filename = FNAME3;
			eok = 1;
			for (i = BUFSIZ - 1; i >= 0; i -= DECR) {
				if ((ret_val =
				     testrun(Flags[flag_cnt], i, 3)) != OK) {
					tst_resm(TFAIL, ERR_MSG2, ret_val,
						 i * WRITES);
				}
			}

			if (eok) {
				tst_resm(TPASS,
					 "Less than BUFSIZE bytes multiple synchronous writes to a file checks out ok");
			}
		}
	}
	cleanup();
	tst_exit();
}				/* end main() */

int testrun(int flag, int bytes, int ti)
{

	int fildes, i, ret;

	struct stat buffer;	/* buffer of memory required for stat command */

	/*
	 *      Attempt to open a temporary file.
	 */

	if ((fildes = open(filename, flag, MODE)) == -1) {
		tst_brkm(TBROK | TERRNO, cleanup, "open(%s) failed", filename);
	}

	/*
	 *      Write the memory to the file.
	 */

	for (i = 0; i < WRITES; i++) {
		TEST(write(fildes, dp, (unsigned)bytes));

		if (TEST_RETURN == -1) {
			tst_brkm(TBROK | TTERRNO, cleanup, "write() failed");
		}
	}			/* end for () */

	/*
	 *      Attempt to close the file which also flushes the buffers.
	 */

	if (close(fildes) == -1) {
		tst_brkm(TBROK | TERRNO, cleanup, "close() failed");
	}

	ret = OK;

	/*
	 *  Now check to see if the number of bytes written is the
	 *  same as the number of bytes in the file.
	 */

	if (stat(filename, &buffer) == -1) {
		tst_brkm(TBROK | TERRNO, cleanup, "stat() failed");
	}

	if (buffer.st_size != (off_t) (bytes * WRITES)) {
		ret = (int)buffer.st_size;
	}

	if (unlink(filename) == -1) {
		tst_brkm(TBROK | TERRNO, cleanup, "unlink(%s) failed",
			 filename);
	}

	return ret;

}				/* end testrun() */

/***************************************************************
 * setup() - performs all ONE TIME setup for this test.
 ***************************************************************/
void setup(void)
{

	tst_sig(FORK, DEF_HANDLER, cleanup);

	TEST_PAUSE;

	/* create a temporary directory and go to it */
	tst_tmpdir();

	/*
	 *  Attempt to get some memory to work with.
	 */

	if ((dp = malloc((unsigned)BUFSIZ + 1)) == NULL) {
		tst_brkm(TBROK | TERRNO, cleanup, "malloc() failed");
	}

}

/***************************************************************
 * cleanup() - performs all ONE TIME cleanup for this test at
 *              completion or premature exit.
 ***************************************************************/
void cleanup(void)
{

	tst_rmdir();
}