path: root/testsuite/media01/pattern-test.c

/**
 * @file
 *
 * @brief Command to fill a file with a pattern.
 *
 * The written pattern is a simple 32 bit counter which makes it easy to find
 * problems where buffers are not written to the correct location or where some
 * blocks are missing.
 *
 * This file can be either compiled as part of RTEMS or as a stand alone Linux
 * or (most likely) FreeBSD application. To compile it as stand alone, just use
 * "gcc pattern-test.c"
 */

/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (C) 2020 embedded brains GmbH.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifdef __rtems__
#include "pattern-test.h"
#endif /* __rtems__ */

#include <arpa/inet.h>
#include <err.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))

static const char * const usage =
	"Fill a file or a device file with a simple incrementing 32 bit pattern.\n"
	"Use with:\n"
	"    pattern [fill|check] <file> <size> <block_size> [<start_value> [<output>]]\n"
	"Arguments:\n"
	"    All numbers can be decimal (e.g. 256) or hex (e.g. 0x100)\n"
	"    <size> and <block_size> is in bytes\n"
	"    <start_value> start with this counter value\n"
	"    <output>: Only relevant for check. Can be: \n"
	"              <nr>: print the first <nr> errors\n"
	"              \"short\": Print all errors but short form\n";

static int
check_and_process_params(
	int argc,
	char *argv[],
	int open_flags,
	int *fd,
	size_t *size,
	size_t *block_size,
	uint8_t **block,
	uint8_t **read_block,
	int *max_errors,
	bool *short_output,
	uint32_t *start_value
)
{
	if (argc < 4) {
		printf(usage);
		return -1;
	}

	if (argc > 4) {
		*start_value = strtoul(argv[4], NULL, 0);
	} else {
		*start_value = 0;
	}

	if (short_output != NULL && max_errors != NULL) {
		*short_output = false;
		*max_errors = 1;
		if (argc > 5) {
			if (strcmp("short", argv[5]) == 0) {
				*max_errors = -1;
				*short_output = true;
			} else {
				*max_errors = strtol(argv[5], NULL, 0);
				if (*max_errors <= 0) {
					warn("Can't use <output> parameter.");
					return -1;
				}
			}
		}
	}

	*size = strtoul(argv[2], NULL, 0);
	if (size == 0) {
		warn("Couldn't convert size or size set to 0");
		return -1;
	}

	*block_size = strtoul(argv[3], NULL, 0);
	if (block_size == 0) {
		warn("Couldn't convert block_size or block_size set to 0");
		return -1;
	}

	if (block != NULL) {
		*block = malloc(*block_size);
		if (*block == NULL) {
			warn("Couldn't allocate block");
			return -1;
		}
	}

	if (read_block != NULL) {
		*read_block = malloc(*block_size);
		if (*read_block == NULL) {
			warn("Couldn't allocate read_block");
			if (block != NULL) {
				free(*block);
			}
			return -1;
		}
	}

	*fd = open(argv[1], open_flags, 0666);
	if (*fd < 0) {
		warn("Couldn't open file");
		if (block != NULL) {
			free(*block);
		}
		if (read_block != NULL) {
			free(*read_block);
		}
		return -1;
	}

	printf("File: %s\nSize: 0x%x\nBlock size: 0x%x\n",
	    argv[1], *size, *block_size);

	return 0;
}

/* Write addresses to the block. Keep word boundaries intact. */
static void
fill_block(uint8_t *block, size_t size, uint32_t start)
{
	uint32_t pattern_size = sizeof(start);
	uint32_t start_offset = start % pattern_size;
	uint32_t value_h = start & ~(pattern_size - 1);
	uint32_t value_n = htonl(value_h);
	uint8_t *val = (uint8_t *) &value_n;

	if (start_offset != 0) {
		size_t to_write = MIN(pattern_size - start_offset, size);
		memcpy(block, val + start_offset, to_write);
		block += to_write;
		size -= to_write;
		value_h += pattern_size;
		value_n = htonl(value_h);
	}

	while (size >= pattern_size) {
		memcpy(block, val, pattern_size);
		value_h += pattern_size;
		value_n = htonl(value_h);
		block += pattern_size;
		size -= pattern_size;
	}

	if (size > 0) {
		memcpy(block, val, size);
	}
}

static int
command_pattern_fill(int argc, char *argv[])
{
	int fd;
	size_t size;
	size_t block_size;
	uint8_t *block;
	uint32_t start_value;
	int rv;

	rv = check_and_process_params(argc, argv, O_WRONLY | O_CREAT,
	    &fd, &size, &block_size, &block, NULL, NULL, NULL, &start_value);
	if (rv != 0) {
		warnx("Error while processing parameters.\n");
		return rv;
	}

	for (size_t current = start_value;
	    current < start_value + size;
	    current += block_size) {
		size_t write_size = MIN(block_size, size-current);
		ssize_t written;
		fill_block(block, write_size, current);
		written = write(fd, block, write_size);
		if (written != (ssize_t)write_size) {
			warn("Writing failed on block at 0x%x", current);
			break;
		}
	}

	free(block);
	close(fd);

	return 0;
}

static void
print_block(uint8_t *block, size_t size)
{
	for (size_t i = 0; i < size; ++i) {
		if (i > 0 && i % 0x10 == 0) {
			printf("\n");
		}
		printf("%02x ", block[i]);
	}
	printf("\n");
}

static int
command_pattern_check(int argc, char *argv[])
{
	int fd;
	size_t size;
	size_t block_size;
	uint8_t *block;
	uint8_t *read_block;
	int rv;
	int errors = 0;
	int max_errors;
	bool short_output;
	bool last_was_error = false;
	uint32_t start_value;

	rv = check_and_process_params(argc, argv, O_RDONLY,
	    &fd, &size, &block_size, &block, &read_block,
	    &max_errors, &short_output, &start_value);
	if (rv != 0) {
		warnx("Error while processing parameters.\n");
		return rv;
	}

	for (size_t current = start_value;
	    current < size + start_value;
	    current += block_size) {
		size_t read_size = MIN(block_size, size-current);
		ssize_t received;
		fill_block(block, read_size, current);
		received = read(fd, read_block, read_size);
		if (received != (ssize_t)read_size) {
			warn("Reading failed on block at 0x%x", current);
			break;
		}
		rv = memcmp(block, read_block, read_size);
		if (short_output) {
			bool is_error = (rv != 0);
			if (last_was_error != is_error) {
				warnx("%s: 0x%x",
				    is_error ? "ERR" : "OK ",
				    current);
			}
			last_was_error = is_error;
		} else if (rv != 0) {
			warnx("Pattern wrong in block at 0x%x", current);
			warnx("Expected:");
			print_block(block, read_size);
			warnx("Got:");
			print_block(read_block, read_size);
			++errors;
			if (errors >= max_errors) {
				warnx("Too many errors. Refusing to continue.");
				break;
			}
		}
	}

	free(read_block);
	free(block);
	close(fd);

	return 0;
}

static int
command_pattern(int argc, char *argv[])
{
	if (argc < 2) {
		printf(usage);
		return -1;
	} else if (strcmp(argv[1], "fill") == 0) {
		return command_pattern_fill(argc-1, &argv[1]);
	} else if (strcmp(argv[1], "check") == 0) {
		return command_pattern_check(argc-1, &argv[1]);
	} else {
		printf(usage);
		return -1;
	}
}

#ifdef __rtems__
rtems_shell_cmd_t shell_PATTERN_Command = {
	.name = "pattern",
	.usage = usage,
	.topic = "files",
	.command = command_pattern,
};
#else /* __rtems__ */

int
main(int argc, char *argv[])
{
	return command_pattern(argc, argv);
}
#endif /* __rtems__ */