source: mainline/uspace/app/testread/testread.c@ a85d5c6

/*
 * Copyright (c) 2011 Martin Sucha
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - 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.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/** @addtogroup testread
 * @{
 */

/**
 * @file        testread.c
 * This program checks if the file contains a pattern of increasing
 * 64 bit unsigned integers (that may overflow at some point)
 * stored in little endian byte order.
 * This is to verify that the filesystem reads
 * the files correctly.
 * If the file does not contain specified pattern, it stops
 * at the point where the file does not match and prints
 * the byte offset at which the error occured.
 * While checking the file, the program displays how many megabytes
 * it has already read, how long it took to read the last megabyte
 * and current and average read speed.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#include <mem.h>
#include <loc.h>
#include <byteorder.h>
#include <inttypes.h>
#include <errno.h>
#include <time.h>
#include <offset.h>
#include <str.h>

#define NAME    "testread"
#define BUFELEMS 1024
#define MBYTE (1024*1024)

static void syntax_print(void);

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

        FILE *file;
        char *file_name;
        uint64_t *buf;
        uint64_t expected;
        aoff64_t offset;
        aoff64_t next_mark;
        aoff64_t last_mark;
        unsigned int i;
        bool check_enabled = true;
        bool progress = true;

        if (argc < 2) {
                printf(NAME ": Error, argument missing.\n");
                syntax_print();
                return 1;
        }

        /* Skip program name */
        --argc;
        ++argv;

        if (argc > 0 && str_cmp(*argv, "--no-check") == 0) {
                check_enabled = false;
                --argc;
                ++argv;
        }

        if (argc > 0 && str_cmp(*argv, "--no-progress") == 0) {
                progress = false;
                --argc;
                ++argv;
        }

        if (argc != 1) {
                printf(NAME ": Error, unexpected argument.\n");
                syntax_print();
                return 1;
        }

        file_name = *argv;

        buf = calloc(BUFELEMS, sizeof(uint64_t));
        if (buf == NULL) {
                printf("Failed allocating buffer\n");
                return 1;
        }

        file = fopen(file_name, "r");
        if (file == NULL) {
                printf("Failed opening file\n");
                return 1;
        }

        expected = 0;
        offset = 0;
        next_mark = 0;
        last_mark = 0;
        struct timespec prev_time;
        struct timespec start_time;
        getuptime(&start_time);
        prev_time = start_time;

        while (!feof(file)) {
                size_t elems = fread(buf, sizeof(uint64_t), BUFELEMS, file);
                if (ferror(file)) {
                        printf("Failed reading file\n");
                        fclose(file);
                        free(buf);
                        return 1;
                }

                for (i = 0; i < elems; i++) {
                        if (check_enabled && uint64_t_le2host(buf[i]) != expected) {
                                printf("Unexpected value at offset %" PRIuOFF64 "\n", offset);
                                fclose(file);
                                free(buf);
                                return 2;
                        }
                        expected++;
                        offset += sizeof(uint64_t);
                }

                if (progress && offset >= next_mark) {
                        struct timespec cur_time;
                        getuptime(&cur_time);

                        uint32_t last_run = cur_time.tv_sec - prev_time.tv_sec;
                        uint32_t total_time = cur_time.tv_sec - start_time.tv_sec;
                        if (last_run > 0 && total_time > 0) {
                                printf("%" PRIuOFF64 "M - time: %u s, "
                                    "cur: %" PRIuOFF64 " B/s, avg: %" PRIuOFF64 " B/s\n",
                                    offset / MBYTE, last_run,
                                    (offset - last_mark) / last_run,
                                    offset / total_time);
                                prev_time = cur_time;
                                last_mark = offset;
                        }
                        next_mark += MBYTE;
                }
        }

        struct timespec final_time;
        getuptime(&final_time);

        uint32_t total_run_time = final_time.tv_sec - start_time.tv_sec;
        if (total_run_time > 0) {
                printf("total bytes: %" PRIuOFF64
                    ", total time: %u s, avg speed: %" PRIuOFF64 " B/s\n",
                    offset,
                    total_run_time,
                    offset / total_run_time);
        }

        fclose(file);
        free(buf);

        return 0;
}

static void syntax_print(void)
{
        printf("syntax: testread <filename>\n");
}

/**
 * @}
 */