fifo_app.c

来自「fsmlabs的real time linux的内核」· C语言 代码 · 共 684 行 · 第 1/2 页

/*
 * (C) Finite State Machine Labs Inc. 2000 [e-mail]
 *
 * Released under the terms of GPL 2.
 * Open RTLinux makes use of a patented process described in
 * US Patent 5,995,745. Use of this process is governed
 * by the Open RTLinux Patent License which can be obtained from
 * www.fsmlabs.com/PATENT or by sending email to
 * [e-mail]
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <signal.h>

#include "fifo_test.h"

/* module unload and loading commands */
#define	MODULE_LOAD	"/sbin/insmod regression/fifo_module.o fifo_size=%d fifo_nr=%d"
#define MODULE_UNLOAD	"/sbin/rmmod fifo_module"

/* fifo size params */
#define	MIN_SIZE	1
#define	MAX_SIZE	65536
/* this is set to 32 to make the test go faster; it will test fifos of size 1,
 * 32, 1024 and 32768 (even though the MAX_SIZE is 65536).  Set this number to
 * 2 or any other multiple of 2 smaller than 32 to make it be more thorough
 * and slow; set it to any multiple higher than 32 to make it go faster, but
 * be less thorough. */
#define	MUL_SIZE	2

char *construct_filename(int);
int stat_test(const char *);
int open_test_fail(const char *);
int load_module();
int over_write_test(const char *, int);
int over_read_test(const char *, int);
char *read_test(const char *, int, int);
int unload_module();
int write_test(const char *, const char *, int, int);
int write_read_test(const char *, int);
char *get_random_str(int);
int sig_handler_setup(void);
void my_sahandler(int);
int big_fifo_test(int);

int main(void)
{
	int i;
	int retval;
	int test_nr, fifo_size, buf_size;
	char *filename, *teststr, *resstr;

	/* set up handler to unload module if we get ^C or similar */
	if ((retval = sig_handler_setup()) != 0) {
		return (retval);
	}

	/* attempt to unload the module because the signal handler doesn't
	 * always manage to do it when we get ^C */
	unload_module();

	/* outer loop to test ALL the FIFOs */
	/* instead of looping through any arbitrary FIFOs, just do the
	 * important ones */

	if ((retval = big_fifo_test(1)) != 0) {
		return retval;
	}

	if ((retval = big_fifo_test(32)) != 0) {
		return retval;
	}

	if ((retval = big_fifo_test(63)) != 0) {
		return retval;
	}

	if ((retval = big_fifo_test(10)) != 0) {
		return retval;
	}

	if ((retval = big_fifo_test(11)) != 0) {
		return retval;
	}

	if ((retval = big_fifo_test(12)) != 0) {
		return retval;
	}

	/* now try testing to see how big a FIFO we can make */
	/* don't do this -Nathan
	   i = 1;
	   retval = 0;
	   while (retval == 0) {
	   retval = load_module(1, i);
	   unload_module();
	   i *= 2;
	   }
	 */
	return (0);
}

char *construct_filename(int i)
{
	char *filename;

	if ((filename = (char *) calloc(11, sizeof(char))) == NULL) {
		fprintf(stderr, "calloc (11, sizeof (char)): %s\n",
			strerror(errno));
		return (NULL);
	}

	if ((snprintf(filename, 11, "/dev/rtf%d", i)) < 0) {
		fprintf(stderr, "snprintf (filename, 11, /dev/rtf%d): %s",
			i, strerror(errno));
		free(filename);
		return (NULL);
	}

	return (filename);
}

int stat_test(const char *filename)
{
	struct stat file_stats;

	if (stat(filename, &file_stats) != 0) {
		fprintf(stderr, "stat (%s, &file_stats): %s\n", filename,
			strerror(errno));
		return (errno);
	}

	if (!(S_ISCHR(file_stats.st_mode))) {
		fprintf(stderr, "%s is not a character device.\n",
			filename);
		return (-1);
	}

	return (0);
}

/* this function assumes the module is not already loaded */
int open_test_fail(const char *filename)
{
	int filedes;

	if ((filedes = open(filename, O_RDONLY)) > 0) {
		fprintf(stderr,
			"Opened %s for read without module loaded!\n",
			filename);
		if ((close(filedes)) != 0) {
			fprintf(stderr, "close (%d): %s\n", filedes,
				strerror(errno));
			return (errno);
		}
		return (-1);
	}

	if ((filedes = open(filename, O_WRONLY | O_NONBLOCK)) > 0) {
		fprintf(stderr,
			"Opened %s for write without module loaded!\n",
			filename);
		if ((close(filedes)) != 0) {
			fprintf(stderr, "close (%d): %s\n", filedes,
				strerror(errno));
			return (errno);
		}
		return (-1);
	}

	if ((filedes = open(filename, O_RDWR)) > 0) {
		fprintf(stderr,
			"Opened %s for read/write without module loaded!\n",
			filename);
		if ((close(filedes)) != 0) {
			fprintf(stderr, "close (%d): %s\n", filedes,
				strerror(errno));
			return (errno);
		}
		return (-1);
	}

	return (0);
}

int load_module(int fifo_size, int fifo_nr)
{
	int i = strlen(MODULE_LOAD) + 4;
	char command[i];

	if ((snprintf(command, i, MODULE_LOAD, fifo_size, fifo_nr)) < 0) {
		fprintf(stderr, "snprintf (): %s", strerror(errno));
		return (errno);
	}

	i = system(command);
	if ((i == 127) || (i == -1)) {
		fprintf(stderr, "system (%s): %d %s\n", command, i,
			strerror(errno));
		return (errno);
	}

	return (0);
}

int unload_module()
{
	int i;

	i = system(MODULE_UNLOAD);
	if ((i == 127) || (i == -1)) {
		fprintf(stderr, "system (%s): %d %s\n", MODULE_UNLOAD, i,
			strerror(errno));
		return (errno);
	}

	return (0);
}

int over_read_test(const char *filename, int size)
{
	int filedes;
	int read_size;
	char *inbuf;

	if ((inbuf = (char *) calloc(size + 1, sizeof(char))) == NULL) {
		fprintf(stderr, "calloc (1, %d): %s\n", sizeof(char),
			strerror(errno));
		return (errno);
	}

	if ((filedes = open(filename, O_RDONLY | O_NONBLOCK)) < 0) {
		fprintf(stderr, "open (%s, O_RDONLY): %s\n", filename,
			strerror(errno));
		free(inbuf);
		return (errno);
	}

	if ((read_size = read(filedes, inbuf, size + 1)) > size) {
		fprintf(stderr, "read %d bytes from %d size FIFO!\n",
			read_size, size);
		close(filedes);
		free(inbuf);
		return (-1);
	}

	free(inbuf);

	if ((close(filedes)) != 0) {
		fprintf(stderr, "close (%d): %s\n", filedes,
			strerror(errno));
		return (errno);
	}

	return (0);
}

char *read_test(const char *filename, int buf_size, int size)
{
	int filedes;
	int read_size;
	int inbuf_size;
	char *inbuf;
	struct pollfd fifo_poll;

	read_size = 1;
	inbuf_size = 0;

	if ((inbuf = (char *) calloc(size, sizeof(char))) == NULL) {
		fprintf(stderr, "calloc (1, %d): %s\n", sizeof(char),
			strerror(errno));
		return (NULL);
	}

	if ((filedes = open(filename, O_RDONLY | O_NONBLOCK)) < 0) {
		fprintf(stderr, "open (%s, O_RDONLY): %s\n", filename,
			strerror(errno));
		free(inbuf);
		return (NULL);
	}

	/* wait for data to arrive in FIFO */
	fifo_poll.fd = filedes;
	fifo_poll.events = POLLIN;
	if ((poll(&fifo_poll, 1, 5000)) <= 0) {
		fprintf(stderr, "poll (&fifo_poll, 1, 5000): %s\n",
			strerror(errno));
		free(inbuf);
		close(filedes);
		return (NULL);
	}
	/* attempt to empty the FIFO buf_size blocks at a time */
	while (inbuf_size < size) {
		if (
		    (read_size =
		     read(filedes, inbuf + inbuf_size, buf_size)) < 0) {
			fprintf(stderr, "read (%d, inbuf, %d): %s\n",
				filedes, buf_size, strerror(errno));
			close(filedes);
			free(inbuf);
			return (NULL);
		}
		inbuf_size += read_size;
	}

	if ((close(filedes)) != 0) {
		fprintf(stderr, "close (%d): %s\n", filedes,
			strerror(errno));
		free(inbuf);
		return (NULL);
	}

	return (inbuf);
}

int over_write_test(const char *filename, int size)
{
	int filedes;
	int write_size;
	char *outbuf;

	if ((outbuf = (char *) calloc(size + 1, sizeof(char))) == NULL) {
		fprintf(stderr, "calloc (%d, %d): %s\n", 2 * size,
			sizeof(char), strerror(errno));
		return (errno);
	}

	if ((filedes = open(filename, O_WRONLY | O_NONBLOCK)) < 0) {
		fprintf(stderr, "open (%s, O_RDONLY): %s\n", filename,
			strerror(errno));
		free(outbuf);
		return (errno);
	}