xref: /third_party/ltp/testcases/kernel/sched/sched_stress/sched_tc6.c

/*
 *   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
 */
/*
 * FUNCTIONS: Scheduler Test Suite
 */

/*---------------------------------------------------------------------+
|                               sched_tc6                              |
| ==================================================================== |
|                                                                      |
| Description:  Creates short-term disk I/O bound process              |
|                                                                      |
|		Creates a situation where a real time process is       |
|		waiting on a file lock owned by a user process.  The   |
|		scheduler should elevate the user process priority to  |
|		the same level as the real time process to avoid       |
|		deadlock situations and to decrease wait time          |
|		required of the real time process.                     |
|                                                                      |
| Algorithm:    o  Set process priority                                |
|               o  Continuously multiply matrices together until       |
|                  interrupted.                                        |
|                                                                      |
| To compile:   cc -o sched_tc6 sched_tc6.c -L. -lpsc                  |
|                                                                      |
| Usage:        sched_tc6 [-t priority_type] [-p priority]             |
|                         [-l log] [-f] [-v] [-d]                      |
|                                                                      |
| Last update:   Ver. 1.3, 4/10/94 23:05:03                           |
|                                                                      |
| Change Activity                                                      |
|                                                                      |
|   Version  Date    Name  Reason                                      |
|    0.1     050689  CTU   Initial version                             |
|    0.2     010402  Manoj Iyer Ported to Linux			       |
|                                                                      |
+---------------------------------------------------------------------*/

#include <fcntl.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include <sys/resource.h>
#include "sched.h"

/*
 * Defines:
 *
 * USAGE: usage statement
 *
 * DEFAULT_PRIORITY_TYPE: default priority
 *
 * BLOCK_SIZE: block size (in bytes) for raw I/O
 *
 * TIMES: number of times to read raw I/O device (~25MB)
 *
 */
#define DEFAULT_PRIORITY_TYPE	"variable"
#define DEFAULT_LOGFILE		"sched_tc6.log"
#define BLOCK_SIZE		512
#define TIMES			10
#define MAX_TRIES		20
#define NAPTIME			1
#define REAL_TIME		"1"
#define NO_FORK			"0"
#define USAGE "Usage:  %s  [-l log] [-t type] [-p priority] [-f] [-v] [-d]\n" \
              "        -l log      log file                             \n" \
              "        -t type     priority type 'variable' or 'fixed'  \n" \
              "        -p priority priority value                       \n" \
              "        -f          fork child                           \n" \
              "        -v          verbose                              \n" \
              "        -d          enable debugging messages            \n"

/*
 * Function prototypes:
 *
 * process_file: reads data file
 *
 * parse_args: parse command line arguments
 */
void parse_args(int, char **);
int fork_realtime(char **);
int read_file(int, char *);
int lock_file(int, short, char *);
int unlock_file(int, char *);
int lock_error(int, char *);

/*
 * Global variables:
 *
 * verbose: enable normal messages
 *
 * debug: enable debugging messages
 *
 * priority: process type (fixed priority, variable priority)
 */
int verbose = 0;
int debug = 0;
int fork_flag = 0;
int priority = DEFAULT_PRIORITY;
char *logfile = DEFAULT_LOGFILE;
char *priority_type = DEFAULT_PRIORITY_TYPE;
struct flock flock_struct;
struct flock *flock_ptr = &flock_struct;

int open_file(char *, int);

/*---------------------------------------------------------------------+
|                                 main                                 |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int main(int argc, char **argv)
{
	char *filename = NULL;
	FILE *statfile;
	pid_t pid = 0;
	int fd;
	int rc;
	clock_t start_time;	/* start & stop times */
	clock_t stop_time;
	float elapsed_time;
#ifdef __linux__
	time_t timer_info;
#else
	struct tms timer_info;	/* time accounting info */
#endif

	if ((filename = getenv("KERNEL")) == NULL) {
		errno = ENODATA;
		sys_error("environment variable KERNEL not set", __FILE__,
			  __LINE__);
	}

	/* Process command line arguments...  */
	parse_args(argc, argv);
	if (verbose)
		printf("%s: Scheduler TestSuite program\n\n", *argv);
	if (debug) {
		printf("\tpriority type:  %s\n", priority_type);
		printf("\tpriority:       %d\n", priority);
		printf("\tlogfile:        %s\n", logfile);
	}

	/* Adjust the priority of this process if the real time flag is set */
	if (!strcmp(priority_type, "fixed")) {
#ifndef __linux__
		if (setpri(0, DEFAULT_PRIORITY) < 0)
			sys_error("setpri failed", __FILE__, __LINE__);
#else
		if (setpriority(PRIO_PROCESS, 0, 0) < 0)
			sys_error("setpri failed", __FILE__, __LINE__);
#endif
	} else {
		if (nice((priority - 50) - (nice(0) + 20)) < 0 && errno != 0)
			sys_error("nice failed", __FILE__, __LINE__);
	}

	/* Read from raw I/O device and record elapsed time...  */
	start_time = time(&timer_info);

	/* Open and lock file file...  */
	fd = open_file(filename, O_RDWR);
	if (!lock_file(fd, F_WRLCK, filename))	/* set exclusive lock */
		error("lock_file failed", __FILE__, __LINE__);

	/* If fork flag set, fork a real process */
	if (fork_flag)
		pid = fork_realtime(argv);

	/* Read file */
	if (debug) {
		printf("\tprocess id %d successfully locked %s\n",
		       getpid(), filename);
		printf("\tprocess id %d starting to read %s\n",
		       getpid(), filename);
	}

	if (!read_file(fd, filename))
		error("read_file failed", __FILE__, __LINE__);

	/* Stop the timer and calculate the elapsed time */
	stop_time = time(&timer_info);
	elapsed_time = (float)(stop_time - start_time) / 100.0;

	/* Write the elapsed time to the temporary file...  */
	if ((statfile = fopen(logfile, "w")) == NULL)
		sys_error("fopen failed", __FILE__, __LINE__);

	fprintf(statfile, "%f\n", elapsed_time);
	if (debug)
		printf("\n\telapsed time: %f\n", elapsed_time);

	if (fclose(statfile) < 0)
		sys_error("fclose failed", __FILE__, __LINE__);

	/* Unlock file at latest possible time to prevent real time child from
	 * writing throughput results before user process parent */
	unlock_file(fd, filename);
	close(fd);

	if (debug)
		printf("\tprocess id %d completed read and unlocked file\n",
		       getpid());

	/* The parent waits for child process to complete before exiting
	 * so the driver will not read the throughput results file before
	 * child writes to the file */
	if (pid != 0) {		/* if parent process ... *//* wait for child process */
		if (debug)
			printf
			    ("parent waiting on child process %d to complete\n",
			     pid);

		while ((rc = wait(NULL)) != pid)
			if (rc == -1)
				sys_error("wait failed", __FILE__, __LINE__);
/*
DARA: which one to use
1st -- hangs
2nd -- ERROR message

	    while (wait((void *) 0) != pid) ;
	    while ((rc=wait ((void *) 0)) != pid)
	       if (rc == -1)
	          sys_error ("wait failed", __FILE__, __LINE__);
*/
	}

	/* Exit with success! */
	if (verbose)
		printf("\nsuccessful!\n");
	return (0);
}

/*---------------------------------------------------------------------+
|                             open_file ()                             |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int open_file(char *file, int open_mode)
{
	int file_desc;

	if ((file_desc = open(file, open_mode)) < 0)
		sys_error("open failed", __FILE__, __LINE__);
	return (file_desc);
}

/*---------------------------------------------------------------------+
|                           fork_realtime ()                           |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int fork_realtime(char **args)
{
	int pid;
	char *results_file = args[2];
	char *priority = args[3];

	/* fork process then determine if process is parent or child */
	pid = fork();
	switch (pid) {
		/* fork failed  */
	case -1:
		sys_error("fork failed", __FILE__, __LINE__);

		/* child process */
	case 0:
		if (execl(*args, *args, REAL_TIME, results_file, priority,
			  NO_FORK, NULL) < 0)
			sys_error("execl failed", __FILE__, __LINE__);

		/* parent process */
	default:
#ifdef DEBUG
		printf("\tparent process id = %d\n", getpid());
		printf("\tchild process id = %d\n\n", pid);
#endif

		break;
	}
	return (pid);
}

/*---------------------------------------------------------------------+
|                             read_file ()                             |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int read_file(int fd, char *filename)
{
	int bytes_read;
	int loop_count;
	long total_bytes;
	off_t lseek();
	off_t file_offset = 0;
	int whence = 0;

	char buf[BLOCK_SIZE];

	/* read file for "TIMES" number of times */
	total_bytes = 0;
	if (debug)
		printf("\n");
	for (loop_count = 1; loop_count <= TIMES; loop_count++) {
		while ((bytes_read = read(fd, buf, BLOCK_SIZE)) > 0) {
			if (bytes_read == -1) {
				sys_error("read failed", __FILE__, __LINE__);
			} else
				total_bytes = total_bytes + bytes_read;
		}
		if (lseek(fd, file_offset, whence) < 0)
			sys_error("lseek failed", __FILE__, __LINE__);

		if (debug) {
			printf("\r\ttotal bytes read = %ld", total_bytes);
			fflush(stdout);
		}
		total_bytes = 0;
	}
	if (debug)
		printf("\n");
	return 1;
}

/*---------------------------------------------------------------------+
|                             lock_file ()                             |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int lock_file(int fd, short lock_type, char *file)
{
	int lock_attempt = 1;
	int lock_mode;

#ifdef DEBUG
	lock_mode = F_SETLK;	/* return if lock fails        */
#else
	lock_mode = F_SETLKW;	/* set lock and use system wait */
#endif

	/* file segment locking set data type flock - information
	 * passed to system by user --
	 *   l_whence:  starting point of relative offset of file
	 *   l_start:   defines relative offset in bytes from l_whence
	 *   l_len:     number of consecutive bytes to be locked
	 */
	flock_ptr->l_whence = 0;
	flock_ptr->l_start = 0;
	flock_ptr->l_len = 0;
	flock_ptr->l_type = lock_type;

	while (fcntl(fd, lock_mode, flock_ptr) == -1) {
		if (lock_error(fd, file)) {
			sleep(NAPTIME);
			if (++lock_attempt > MAX_TRIES) {
				printf
				    ("ERROR: max lock attempts of %d reached\n",
				     MAX_TRIES);
				return (0);
			}
		} else
			return (0);
	}
	return (1);
}

/*---------------------------------------------------------------------+
|                            unlock_file ()                            |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int unlock_file(int fd, char *file)
{
	flock_ptr->l_type = F_UNLCK;

	if (fcntl(fd, F_SETLK, flock_ptr) < 0)
		sys_error("fcntl failed", __FILE__, __LINE__);

	return 1;
}

/*---------------------------------------------------------------------+
|                                 main                                 |
| ==================================================================== |
|                                                                      |
| Function:  ...                                                       |
|                                                                      |
+---------------------------------------------------------------------*/
int lock_error(int fd, char *file)
{
	int ret = 1;

	printf("ERROR:  lock failed: %s\n", file);
	switch (errno) {
	case EACCES:		/* access not allowed */
		fcntl(fd, F_GETLK, flock_ptr);
#ifndef __linux__
		printf("ERROR: lock exists - nid: %lX pid: %ld\n",
		       flock_ptr->l_sysid, flock_ptr->l_pid);
#else
		printf("ERROR: lock exists - nid:\n");
#endif
		break;

		/*
		 * This was a DS error code, and DS does not exist V3.1
		 */
#ifndef __linux__
	case EDIST:		/* DS file server blocking requests */
		printf("ERROR: errno == EDIST\n");
		printf("The server has blocked new inbound requests\n");
		printf("or outbound requests are currently blocked.\n");
		break;
#endif

	case EAGAIN:		/* server too busy */
		printf("ERROR:  Server too busy to accept the request\n");
		break;

	case EDEADLK:		/* only when F_SETLKW cmd is used */
		printf("ERROR:  Putting the calling process to sleep\n");
		printf("would cause a dead lock\n");
		ret = 0;
		break;

	case ENOLCK:		/* out of locks */
		printf("ERROR: No more file locks available\n");
		ret = 0;
		break;

	case ENOMEM:		/* out of memory */
		printf("ERROR: The server or client does not have enough\n");
		printf("memory to service the request.\n");
		ret = 0;
		break;

	default:		/* miscellaneous errors */
		printf("ERROR: Unknown lock error\n");
		perror("reason");
		ret = 0;
		break;
	}

	printf("errno = %d\n", errno);	/* log the errno value */
	sleep(10);

	return (ret);
}

/*---------------------------------------------------------------------+
|                             parse_args ()                            |
| ==================================================================== |
|                                                                      |
| Function:  Parse the command line arguments & initialize global      |
|            variables.                                                |
|                                                                      |
| Updates:   (command line options)                                    |
|                                                                      |
|            [-t] type:     priority type "fixed" or "variable"        |
|            [-p] priority: priority value                             |
|            [-l] logfile:  log file name                              |
|            [-v]           verbose                                    |
|            [-d]           enable debugging messages                  |
|                                                                      |
+---------------------------------------------------------------------*/
void parse_args(int argc, char **argv)
{
	int opt;
	int lflg = 0, pflg = 0, tflg = 0;
	int errflag = 0;
	char *program_name = *argv;
	extern char *optarg;	/* Command line option */

	/*
	 * Parse command line options.
	 */
	while ((opt = getopt(argc, argv, "fl:t:p:vd")) != EOF) {
		switch (opt) {
		case 'f':	/* fork flag */
			fork_flag++;
			break;
		case 'l':	/* log file */
			lflg++;
			logfile = optarg;
			break;
		case 't':	/* process type */
			tflg++;
			priority_type = optarg;
			break;
		case 'p':	/* process priority */
			pflg++;
			priority = atoi(optarg);
			break;
		case 'v':	/* verbose */
			verbose++;
			break;
		case 'd':	/* enable debugging messages */
			verbose++;
			debug++;
			break;
		default:
			errflag++;
			break;
		}
	}

	/*
	 * Check percentage and process slots...
	 */
	if (tflg) {
		if (strcmp(priority_type, "fixed") &&
		    strcmp(priority_type, "variable")) {
			errflag++;
			fprintf(stderr, "Error: priority type must be: "
				"\'fixed\' or \'variable\'\n");
		}
	}
	if (pflg) {
		if (priority < 50 || priority > 100) {
			errflag++;
			fprintf(stderr, "Error: priority range [50..100]\n");
		}
	}
	if (errflag) {
		fprintf(stderr, USAGE, program_name);
		exit(2);
	}
}