// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright 2020 Google LLC
 */
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <unistd.h>

#include "utils.h"

#define err_msg(...)                                                           \
	do {                                                                   \
		fprintf(stderr, "%s: (%d) ", TAG, __LINE__);                   \
		fprintf(stderr, __VA_ARGS__);                                  \
		fprintf(stderr, " (%s)\n", strerror(errno));                   \
	} while (false)

#define TAG "incfs_stress"

struct options {
	bool no_cleanup; /* -c */
	const char *test_dir; /* -d */
	unsigned int rng_seed; /* -g */
	int num_reads; /* -n */
	int readers; /* -r */
	int size; /* -s */
	int timeout; /* -t */
};

struct read_data {
	const char *filename;
	int dir_fd;
	size_t filesize;
	int num_reads;
	unsigned int rng_seed;
};

int cancel_threads;

int parse_options(int argc, char *const *argv, struct options *options)
{
	signed char c;

	/* Set defaults here */
	*options = (struct options){
		.test_dir = ".",
		.num_reads = 1000,
		.readers = 10,
		.size = 10,
	};

	/* Load options from command line here */
	while ((c = getopt(argc, argv, "cd:g:n:r:s:t:")) != -1) {
		switch (c) {
		case 'c':
			options->no_cleanup = true;
			break;

		case 'd':
			options->test_dir = optarg;
			break;

		case 'g':
			options->rng_seed = strtol(optarg, NULL, 10);
			break;

		case 'n':
			options->num_reads = strtol(optarg, NULL, 10);
			break;

		case 'r':
			options->readers = strtol(optarg, NULL, 10);
			break;

		case 's':
			options->size = strtol(optarg, NULL, 10);
			break;

		case 't':
			options->timeout = strtol(optarg, NULL, 10);
			break;
		}
	}

	return 0;
}

void *reader(void *data)
{
	struct read_data *read_data = (struct read_data *)data;
	int i;
	int fd = -1;
	void *buffer = malloc(read_data->filesize);

	if (!buffer) {
		err_msg("Failed to alloc read buffer");
		goto out;
	}

	fd = openat(read_data->dir_fd, read_data->filename,
		    O_RDONLY | O_CLOEXEC);
	if (fd == -1) {
		err_msg("Failed to open file");
		goto out;
	}

	for (i = 0; i < read_data->num_reads && !cancel_threads; ++i) {
		off_t offset = rnd(read_data->filesize, &read_data->rng_seed);
		size_t count =
			rnd(read_data->filesize - offset, &read_data->rng_seed);
		ssize_t err = pread(fd, buffer, count, offset);

		if (err != count)
			err_msg("failed to read with value %lu", err);
	}

out:
	close(fd);
	free(read_data);
	free(buffer);
	return NULL;
}

int write_data(int cmd_fd, int dir_fd, const char *name, size_t size)
{
	int fd = openat(dir_fd, name, O_RDWR | O_CLOEXEC);
	struct incfs_permit_fill permit_fill = {
		.file_descriptor = fd,
	};
	int error = 0;
	int i;
	int block_count = 1 + (size - 1) / INCFS_DATA_FILE_BLOCK_SIZE;

	if (fd == -1) {
		err_msg("Could not open file for writing %s", name);
		return -errno;
	}

	if (ioctl(cmd_fd, INCFS_IOC_PERMIT_FILL, &permit_fill)) {
		err_msg("Failed to call PERMIT_FILL");
		error = -errno;
		goto out;
	}

	for (i = 0; i < block_count; ++i) {
		uint8_t data[INCFS_DATA_FILE_BLOCK_SIZE] = {};
		size_t block_size =
			size > i * INCFS_DATA_FILE_BLOCK_SIZE ?
				INCFS_DATA_FILE_BLOCK_SIZE :
				size - (i * INCFS_DATA_FILE_BLOCK_SIZE);
		struct incfs_fill_block fill_block = {
			.compression = COMPRESSION_NONE,
			.block_index = i,
			.data_len = block_size,
			.data = ptr_to_u64(data),
		};
		struct incfs_fill_blocks fill_blocks = {
			.count = 1,
			.fill_blocks = ptr_to_u64(&fill_block),
		};
		int written = ioctl(fd, INCFS_IOC_FILL_BLOCKS, &fill_blocks);

		if (written != 1) {
			error = -errno;
			err_msg("Failed to write block %d in file %s", i, name);
			break;
		}
	}
out:
	close(fd);
	return error;
}

int test_files(int src_dir, int dst_dir, struct options const *options)
{
	unsigned int seed = options->rng_seed;
	int cmd_file = openat(dst_dir, INCFS_PENDING_READS_FILENAME,
			      O_RDONLY | O_CLOEXEC);
	int err;
	const char *name = "001";
	incfs_uuid_t id;
	size_t size;
	int i;
	pthread_t *threads = NULL;

	size = 1 << (rnd(options->size, &seed) + 12);
	size += rnd(size, &seed);

	if (cmd_file == -1) {
		err_msg("Could not open command file");
		return -errno;
	}

	err = emit_file(cmd_file, NULL, name, &id, size, NULL);
	if (err) {
		err_msg("Failed to create file %s", name);
		return err;
	}

	threads = malloc(sizeof(pthread_t) * options->readers);
	if (!threads) {
		err_msg("Could not allocate memory for threads");
		return -ENOMEM;
	}

	for (i = 0; i < options->readers; ++i) {
		struct read_data *read_data = malloc(sizeof(*read_data));

		if (!read_data) {
			err_msg("Failed to allocate read_data");
			err = -ENOMEM;
			break;
		}

		*read_data = (struct read_data){
			.filename = name,
			.dir_fd = dst_dir,
			.filesize = size,
			.num_reads = options->num_reads,
			.rng_seed = seed,
		};

		rnd(0, &seed);

		err = pthread_create(threads + i, 0, reader, read_data);
		if (err) {
			err_msg("Failed to create thread");
			free(read_data);
			break;
		}
	}

	if (err)
		cancel_threads = 1;
	else
		err = write_data(cmd_file, dst_dir, name, size);

	for (; i > 0; --i) {
		if (pthread_join(threads[i - 1], NULL)) {
			err_msg("FATAL: failed to join thread");
			exit(-errno);
		}
	}

	free(threads);
	close(cmd_file);
	return err;
}

int main(int argc, char *const *argv)
{
	struct options options;
	int err;
	const char *src_dir = "src";
	const char *dst_dir = "dst";
	int src_dir_fd = -1;
	int dst_dir_fd = -1;

	err = parse_options(argc, argv, &options);
	if (err)
		return err;

	err = chdir(options.test_dir);
	if (err) {
		err_msg("Failed to change to %s", options.test_dir);
		return -errno;
	}

	err = remove_dir(src_dir) || remove_dir(dst_dir);
	if (err)
		return err;

	err = mkdir(src_dir, 0700);
	if (err) {
		err_msg("Failed to make directory %s", src_dir);
		err = -errno;
		goto cleanup;
	}

	err = mkdir(dst_dir, 0700);
	if (err) {
		err_msg("Failed to make directory %s", src_dir);
		err = -errno;
		goto cleanup;
	}

	err = mount_fs(dst_dir, src_dir, options.timeout);
	if (err) {
		err_msg("Failed to mount incfs");
		goto cleanup;
	}

	src_dir_fd = open(src_dir, O_RDONLY | O_CLOEXEC);
	dst_dir_fd = open(dst_dir, O_RDONLY | O_CLOEXEC);
	if (src_dir_fd == -1 || dst_dir_fd == -1) {
		err_msg("Failed to open src or dst dir");
		err = -errno;
		goto cleanup;
	}

	err = test_files(src_dir_fd, dst_dir_fd, &options);

cleanup:
	close(src_dir_fd);
	close(dst_dir_fd);
	if (!options.no_cleanup) {
		umount(dst_dir);
		remove_dir(dst_dir);
		remove_dir(src_dir);
	}

	return err;
}