xref: /external/ltp/testcases/kernel/fs/scsi/ltpfs/main.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <time.h>
#include <ftw.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/kd.h>
#include <linux/errno.h>

#include "Ltpfs.h"

#define M_2PI (M_PI*2)
#define MAXN 4096
#define MAXFSIZE 1024 * 192
#define FILE_CREATE_COUNT 256
#define FAIL 0
#define SUCCESS 1
#define MAXNUM   5000
#define BUFFSIZE 8192
#define AVEFSIZE (MAXFSIZE/2)
#define POOLDISKSPACE (AVEFSIZE*128)
#define MAXERROR  1024
#define FILES_ONLY 0x01
#define ALL        0x00

// Globals

char wbuf[MAXFSIZE];
int startc = 0;
int showchar[] = { 124, 47, 45, 92, 124, 47, 45, 92 };

int nullFileHandle;
int openlog[2] = { 0, 0 };

int cFileCount, dFileCount, errorCount;
static int disk_space_pool = 0;
char rootPath[BUFFSIZE];

int LTP_fs_open_block_device(void);
int do_fs_thump_tests(char *path);
int do_create_file_test(char *path);
int makedir(char *dir1);
int changedir(char *dir);
int do_random_access_test(int maxNum);
int do_random_create_delete(int maxNum);
int create_file(char *filename);
int delete_file(char *filename);
int gen_random_file_size(int min, int max);
int open_read_close(char *fname);
int create_or_delete(char *fname);
int do_tree_cleanup(char *path, int flag);
int cleanup_files(char *file, struct stat *statBuff, int flag);
int cleanup_dirs(char *file, struct stat *statBuff, int flag);

int ltp_block_dev_handle = 0;	/* handle to LTP Test block device */
int ltp_fileHandle = 0;
char *fileBuf;

int main(int argc, char **argv)
{

	ltpdev_cmd_t cmd = { 0, 0 };
	int rc, i, tmpHandle;
	struct stat statBuf;

	printf("[%s] - Running test program\n", argv[0]);

	rc = LTP_fs_open_block_device();

	if (!rc) {

		ltp_block_dev_handle = open(LTP_FS_DEVICE_NAME, O_RDWR);

		if (ltp_block_dev_handle < 0) {
			printf
			    ("ERROR: Open of device %s failed %d errno = %d\n",
			     LTP_FS_DEVICE_NAME, ltp_block_dev_handle, errno);
		} else {
			rc = ioctl(ltp_block_dev_handle, LTPAIODEV_CMD, &cmd);

			printf("return from AIO ioctl %d \n", rc);

			rc = ioctl(ltp_block_dev_handle, LTPBIODEV_CMD, &cmd);

			printf("return from BIO ioctl %d \n", rc);
		}

	} else {
		printf("ERROR: Create/open block device failed\n");
	}

	ltp_fileHandle =
	    open("/tmp/testfile", O_CREAT | O_RDWR | O_SYNC | FASYNC,
		 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

	if (ltp_fileHandle > 0) {

		tmpHandle = open("/usr/include/ctype.h", O_RDONLY);

		if (tmpHandle > 0) {

			rc = fstat(tmpHandle, &statBuf);

			if (!rc) {
				fileBuf = malloc(statBuf.st_size);

				if (fileBuf) {

					read(tmpHandle, fileBuf,
					     statBuf.st_size);
					close(tmpHandle);
					write(ltp_fileHandle, fileBuf,
					      statBuf.st_size);

					for (i = 0; i < 100; i++) {
						read(ltp_fileHandle, fileBuf,
						     statBuf.st_size * i);
						write(ltp_fileHandle, fileBuf,
						      statBuf.st_size * i);
					}
				}

			}

		} else {
			printf("ERROR: Create/open file failed\n");
		}
	}

	printf("*** Starting FileSystem thump tests....****\n");
	printf("*** Please be patient, this may take a little while... ***\n");

	for (i = 1; i < argc; i++) {
		printf("Running test %d of %d on FileSystem %s \n", i, argc - 1,
		       argv[i]);
		if (strcmp(argv[i], "|") != 0) {
			strcpy(rootPath, argv[i]);
			rc = do_fs_thump_tests(argv[i]);
			if (rc != 0 && rc != ENOSPC) {
				printf
				    ("ERROR: Failed on FileSystem %s with errno %d \n",
				     argv[i], rc);
			}
		} else {
			printf("Test Program complete..\n");
			break;
		}

	}

	printf("Test Program complete..\n");

	return 0;
}

int do_fs_thump_tests(char *path)
{
	int rc = 0;

	printf("Changing to directory %s \n", path);

	changedir(path);

	cFileCount = 0;
	dFileCount = 0;

	rc |= do_create_file_test(path);
	rc |= do_random_access_test(MAXNUM);
	rc |= do_tree_cleanup(path, FILES_ONLY);
	rc |= do_random_create_delete(MAXNUM);
	rc |= do_tree_cleanup(path, ALL);

	return rc;

}

int do_tree_cleanup(char *path, int flag)
{

	if (flag == FILES_ONLY) {
		printf("Cleaning up test files...\n");
		ftw(path, (void *)cleanup_files, MAXNUM);
	} else {
		printf("Cleaning up everything in the test directory...\n");
		ftw(path, (void *)cleanup_files, MAXNUM);
		ftw(path, (void *)cleanup_dirs, MAXNUM);
	}

	return 0;
}

int cleanup_files(char *file, struct stat *statBuff, int flag)
{
	int rc = 0;

	if (flag == FTW_F) {
		if (unlink(file)) {
			printf("ERROR:%d removing file %s\n", errno, file);
		}
	}

	return rc;
}

int cleanup_dirs(char *file, struct stat *statBuff, int flag)
{
	int rc = 0;

	//printf("%s:Cleaning up directory %s \n", __FUNCTION__, file);

	if (strcmp(rootPath, file) == 0) {
		return 0;
	}

	if (flag == FTW_F) {
		if (unlink(file)) {
			printf("ERROR:%d removing file %s\n", errno, file);
		}
	} else if (flag == FTW_D) {
		changedir(file);
		ftw(file, (void *)cleanup_dirs, MAXNUM);
		rmdir(file);

	} else {
		printf("No idea what we found here\n");
	}

	return rc;
}

int do_create_file_test(char *path)
{
	int i = 0;
	int j = 0;
	int k = 0;
	int l = 0;
	int rc = 0;

	char dir1[MAXN];
	char dir2[MAXN];
	char dir3[MAXN];
	char filename[MAXN];

	time_t t;

	int maxfiles = 0xFFFFFF;

	time(&t);

	srandom((unsigned int)getpid() ^
		(((unsigned int)t << 16) | (unsigned int)t >> 16));

	printf("Creating files...\n");

	for (i = 0; i < FILE_CREATE_COUNT; i++) {

		sprintf(dir1, "%2.2x", i);

		makedir(dir1);

		changedir(dir1);

		for (j = 0; j < FILE_CREATE_COUNT; j++) {

			sprintf(dir2, "%2.2x", j);

			makedir(dir2);

			changedir(dir2);

			for (k = 0; k < FILE_CREATE_COUNT; k++) {

				sprintf(dir3, "%2.2x", k);
				makedir(dir3);
				changedir(dir3);

				for (l = 0; l < FILE_CREATE_COUNT; l++) {
					sprintf(filename, "%s%s%s%2.2x", dir1,
						dir2, dir3, l);
					rc = create_file(filename);
					if (rc != 0 || maxfiles < dFileCount++) {
						if (rc != ENOSPC) {
							printf
							    ("ERROR: failed error:%d creating all the test files ! \n",
							     errno);
							printf
							    ("ERROR2: rc:%d -- dFileCount:%d \n",
							     rc, dFileCount);
						}
						goto end;
					}
				}
				changedir("../");
			}
			changedir("../");
		}
		changedir("../");
	}
end:
	fprintf(stderr, "\nTotal create files: %d\n", cFileCount);
	printf("Done\n");
	return rc;
}

int makedir(char *dir1)
{
	if (mkdir(dir1, S_IRWXU) < 0) {
		perror(dir1);
		return (errno);
	}
	return 0;
}

int changedir(char *dir)
{
	if (chdir(dir) < 0) {
		perror(dir);
		return (errno);
	}

	return 0;
}

int create_file(char *filename)
{
	int fileHandle;
	int randomsize;

	if ((fileHandle = creat(filename, S_IRWXU)) < 0) {

		fprintf(stderr, "\nERROR line %d: Total create files: %d\n",
			__LINE__, cFileCount);
		perror(filename);
		return (errno);
	}

	if ((randomsize = gen_random_file_size(0, MAXFSIZE)) < 0) {
		randomsize = MAXFSIZE;
	}
	if (write(fileHandle, wbuf, randomsize) < 0) {

		fprintf(stderr, "\nERROR:%d line%d: Total create files: %d\n",
			errno, __LINE__, cFileCount);
		close(fileHandle);

		perror(filename);
		return (errno);
	}

	cFileCount++;
	close(fileHandle);
	return 0;
}

int delete_file(char *filename)
{
	struct stat buf;
	int st;

	st = stat(filename, &buf);

	if (st < 0) {
		errorCount++;
		printf("ERROR line %d: Getting file stats %s \n", __LINE__,
		       filename);
		return (-1);
	}

	disk_space_pool += buf.st_size;

	if (unlink(filename) < 0) {
		errorCount++;
		printf("ERROR line %d: Removing file %s \n", __LINE__,
		       filename);
		return (-1);
	}

	dFileCount++;
	return 0;
}

int LTP_fs_open_block_device()
{
	dev_t devt;
	struct stat statbuf;
	int rc;

	if (ltp_block_dev_handle == 0) {

		/* check for the /dev/LTPFSTest subdir, and create if it does not exist.
		 *
		 * If devfs is running and mounted on /dev, these checks will all pass,
		 * so a new node will not be created.
		 */
		devt = makedev(LTPMAJOR, 0);

		rc = stat(LTP_FS_DEV_NODE_PATH, &statbuf);

		if (rc) {
			if (errno == ENOENT) {
				/* dev node does not exist. */
				rc = mkdir(LTP_FS_DEV_NODE_PATH,
					   (S_IFDIR | S_IRWXU | S_IRGRP |
					    S_IXGRP | S_IROTH | S_IXOTH));
			} else {
				printf
				    ("ERROR: Problem with LTP FS dev directory.  Error code from stat() is %d\n\n",
				     errno);
			}

		} else {
			if (!(statbuf.st_mode & S_IFDIR)) {
				rc = unlink(LTP_FS_DEV_NODE_PATH);
				if (!rc) {
					rc = mkdir(LTP_FS_DEV_NODE_PATH,
						   (S_IFDIR | S_IRWXU | S_IRGRP
						    | S_IXGRP | S_IROTH |
						    S_IXOTH));
				}
			}
		}

		/*
		 * Check for the /dev/ltp-fs/block_device node, and create if it does not
		 * exist.
		 */
		rc = stat(LTP_FS_DEVICE_NAME, &statbuf);
		if (rc) {
			if (errno == ENOENT) {
				/* dev node does not exist */
				rc = mknod(LTP_FS_DEVICE_NAME,
					   (S_IFBLK | S_IRUSR | S_IWUSR |
					    S_IRGRP | S_IWGRP), devt);
			} else {
				printf
				    ("ERROR:Problem with LTP FS block device node directory.  Error code form stat() is %d\n\n",
				     errno);
			}

		} else {
			/*
			 * /dev/ltp-fs/block_device exists.  Check to make sure it is for a
			 * block device and that it has the right major and minor.
			 */
			if ((!(statbuf.st_mode & S_IFBLK)) ||
			    (statbuf.st_rdev != devt)) {

				/* Recreate the dev node. */
				rc = unlink(LTP_FS_DEVICE_NAME);
				if (!rc) {
					rc = mknod(LTP_FS_DEVICE_NAME,
						   (S_IFBLK | S_IRUSR | S_IWUSR
						    | S_IRGRP | S_IWGRP), devt);
				}
			}
		}

	}

	return rc;
}

int gen_random_file_size(int min, int max)
{
	double u1, u2, z;
	int i;
	int ave;
	int range;
	int ZZ;
	if (min >= max) {
		return (-1);
	}
	range = max - min;
	ave = range / 2;
	for (i = 0; i < 10; i++) {
		u1 = ((double)(random() % 1000000)) / 1000000;
		u2 = ((double)(random() % 1000000)) / 1000000;
		z = sqrt(-2.0 * log(u1)) * cos(M_2PI * u2);
		ZZ = min + (ave + (z * (ave / 4)));
		if (ZZ >= min && ZZ < max) {
			return (ZZ);
		}
	}
	return (-1);
}

int do_random_access_test(int maxNum)
{
	int r;
	char fname[1024];
	time_t t;
	int i;

	printf("Running random access test...\n");
	changedir(rootPath);

	if (maxNum < 1 || maxNum > MAXNUM) {
		printf("out of size %d\n", maxNum);
		return 1;
	}

	time(&t);
	srandom((unsigned int)getpid() ^
		(((unsigned int)t << 16) | (unsigned int)t >> 16));

	if ((nullFileHandle = open("/dev/null", O_WRONLY)) < 0) {
		perror("/dev/null");
		return (errno);
	}

	/* 00/00/00/00 */
	for (i = 0; i < maxNum; i++) {

		r = random() % maxNum;

		sprintf(fname, "00/%2.2x/%2.2x/00%2.2x%2.2x%2.2x",
			((r >> 16) & 0xFF),
			((r >> 8) & 0xFF),
			((r >> 16) & 0xFF), ((r >> 8) & 0xFF), (r & 0xFF));

		open_read_close(fname);
	}
	close(nullFileHandle);
	printf("Success:\t%d\nFail:\t%d\n", openlog[SUCCESS], openlog[FAIL]);
	return 0;
}

int open_read_close(char *fname)
{
	int fileHandle, fileHandle2;
	char buffer[BUFFSIZE];
	int c;

	if ((fileHandle = open(fname, O_RDONLY | O_SYNC | O_ASYNC)) < 0) {
		openlog[FAIL]++;
		printf("ERROR:opening file %s failed %d \n", fname, errno);
		return (errno);
	}

	if ((fileHandle2 = open(fname, O_RDONLY | O_SYNC | O_ASYNC)) < 0) {
		openlog[FAIL]++;
		printf("ERROR:2nd opening file %s failed %d \n", fname, errno);
		return (errno);
	}

	openlog[SUCCESS]++;

	while ((c = read(fileHandle, buffer, BUFFSIZE)) > 0) {
		if (write(nullFileHandle, buffer, c) < 0) {
			perror("/dev/null");
			printf("Opened\t %d\nUnopend:\t%d\n", openlog[SUCCESS],
			       openlog[FAIL]);
			close(fileHandle2);
			close(fileHandle);
			return (errno);
		}
		if ((c = read(fileHandle2, buffer, BUFFSIZE)) > 0) {
			if (write(nullFileHandle, buffer, c) < 0) {
				perror("/dev/null");
				printf("Opened\t %d\nUnopend:\t%d\n",
				       openlog[SUCCESS], openlog[FAIL]);
				close(fileHandle2);
				close(fileHandle);
				return (errno);
			}
		}
	}

	if (c < 0) {
		perror(fname);
		printf("Opened\t %d\nUnopend:\t%d\n", openlog[SUCCESS],
		       openlog[FAIL]);
		return (errno);
	}

	close(fileHandle2);
	close(fileHandle);
	return 0;
}

int create_or_delete(char *fname)
{
	int r, rc;

	r = (random() & 1);

	/* create */
	if ((create_file(fname) == 0)) {
		rc = delete_file(fname);
	} else {
		printf("Error: %d creating random file \n", errno);
	}

	if ((errorCount > dFileCount || errorCount > cFileCount)
	    && (errorCount > MAXERROR)) {
		fprintf(stderr, "Too many errors -- Aborting test\n");
		fprintf(stderr, "Total create files: %d\n", cFileCount);
		fprintf(stderr, "Total delete files: %d\n", dFileCount);
		fprintf(stderr, "Total error       : %d\n", errorCount);
		return (MAXERROR);
	}

	return 0;
}

int do_random_create_delete(int maxNum)
{
	int r, rc = 0;
	char fname[1024];
	time_t t;
	int i;

	printf("Running random create/delete test...\n");

	if (maxNum < 1 || maxNum > MAXNUM) {
		printf("MAX out of size %d\n", maxNum);
		return (maxNum);
	}

	time(&t);
	srandom((unsigned int)getpid() ^
		(((unsigned int)t << 16) | (unsigned int)t >> 16));

	/* 00/00/00/00 */
	for (i = 0; i < maxNum && rc != MAXERROR; i++) {
		r = random() % maxNum;
		sprintf(fname, "00/%2.2x/%2.2x/00%2.2x%2.2x%2.2x",
			((r >> 16) & 0xFF),
			((r >> 8) & 0xFF),
			((r >> 16) & 0xFF), ((r >> 8) & 0xFF), (r & 0xFF));

		rc = create_or_delete(fname);
	}

	fprintf(stderr, "Total create files: %d\n", cFileCount);
	fprintf(stderr, "Total delete files: %d\n", dFileCount);
	fprintf(stderr, "Total error       : %d\n", errorCount);
	return (rc);
}