source: mainline/uspace/app/tmon/tests.c

/*
 * Copyright (c) 2017 Petr Manek
 * 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 tmon
 * @{
 */
/**
 * @file
 * USB tests.
 */

#include <stdio.h>
#include <errno.h>
#include <str.h>
#include <str_error.h>
#include <getopt.h>
#include <usb/usb.h>
#include <usbdiag_iface.h>
#include "commands.h"
#include "tf.h"

#define NAME   "tmon"
#define INDENT "      "

/** Static array of long options, from which test parameters are parsed. */
static struct option long_options[] = {
        { "duration", required_argument, NULL, 't' },
        { "size", required_argument, NULL, 's' },
        { "validate", required_argument, NULL, 'v' },
        { 0, 0, NULL, 0 }
};

/** String of short options, from which test parameters are parsed. */
static const char *short_options = "t:s:v";

/** Common option parser for all tests.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 * @param[out] params Parsed test parameters (if successful).
 *
 * @return EOK if successful (in such case caller becomes the owner of `params`).
 */
static errno_t read_params(int argc, char *argv[], void **params)
{
        errno_t rc;
        usbdiag_test_params_t *p = (usbdiag_test_params_t *) malloc(sizeof(usbdiag_test_params_t));
        if (!p)
                return ENOMEM;

        // Default values.
        p->transfer_size = 0;
        p->min_duration = 5000;
        p->validate_data = false;

        // Parse other than default values.
        int c;
        uint32_t duration_uint;
        c = 0;
        optreset = 1;
        optind = 0;
        while (c != -1) {
                c = getopt_long(argc, argv, short_options, long_options, NULL);
                switch (c) {
                case -1:
                        break;
                case 'v':
                        p->validate_data = true;
                        break;
                case 't':
                        if (!optarg || str_uint32_t(optarg, NULL, 10, false, &duration_uint) != EOK) {
                                puts(NAME ": Invalid duration.");
                                rc = EINVAL;
                                goto err_malloc;
                        }
                        p->min_duration = (usbdiag_dur_t) duration_uint * 1000;
                        break;
                case 's':
                        if (!optarg || str_size_t(optarg, NULL, 10, false, &p->transfer_size) != EOK) {
                                puts(NAME ": Invalid data size.");
                                rc = EINVAL;
                                goto err_malloc;
                        }
                        break;
                }
        }

        *params = (void *) p;
        return EOK;

err_malloc:
        free(p);
        *params = NULL;
        return rc;
}

/** Print test parameters.
 * @param[in] params Test parameters to print.
 */
static void print_params(const usbdiag_test_params_t *params)
{
        printf("Endpoint type: %s\n", usb_str_transfer_type(params->transfer_type));
        char *str_min_duration = tmon_format_duration(params->min_duration, "%.3f %s");
        printf("Min. duration: %s\n", str_min_duration);
        free(str_min_duration);

        if (params->transfer_size) {
                char *str_size = tmon_format_size(params->transfer_size, "%.3f %s");
                printf("Transfer size: %s\n", str_size);
                free(str_size);
        } else {
                printf("Transfer size: (max. transfer size)\n");
        }

        printf("Validate data: %s\n", params->validate_data ? "yes" : "no");
}

/** Print test results.
 * @param[in] params Test parameters.
 * @param[in] results Test results.
 */
static void print_results(const usbdiag_test_params_t *params, const usbdiag_test_results_t *results)
{
        printf("Transfers performed: %u\n", results->transfer_count);

        char *str_total_duration = tmon_format_duration(results->act_duration, "%.3f %s");
        printf("Total duration: %s\n", str_total_duration);
        free(str_total_duration);

        char *str_size_per_transfer = tmon_format_size(results->transfer_size, "%.3f %s");
        printf("Transfer size: %s\n", str_size_per_transfer);
        free(str_size_per_transfer);

        const size_t total_size = results->transfer_size * results->transfer_count;
        char *str_total_size = tmon_format_size(total_size, "%.3f %s");
        printf("Total size: %s\n", str_total_size);
        free(str_total_size);

        const double dur_per_transfer = (double) results->act_duration / (double) results->transfer_count;
        char *str_dur_per_transfer = tmon_format_duration(dur_per_transfer, "%.3f %s");
        printf("Avg. transfer duration: %s\n", str_dur_per_transfer);
        free(str_dur_per_transfer);

        const double speed = 1000.0 * (double) total_size / (double) results->act_duration;
        char *str_speed = tmon_format_size(speed, "%.3f %s/s");
        printf("Avg. speed: %s\n", str_speed);
        free(str_speed);
}

/** Run test on "in" endpoint.
 * @param[in] exch Open async exchange with the diagnostic device.
 * @param[in] generic_params Test parameters. Must point to 'usbdiag_test_params_t'.
 *
 * @return Exit code
 */
static int test_in(async_exch_t *exch, const void *generic_params)
{
        const usbdiag_test_params_t *params = (usbdiag_test_params_t *) generic_params;
        print_params(params);
        fputs("\nTesting... ", stdout);

        usbdiag_test_results_t results;
        errno_t rc = usbdiag_test_in(exch, params, &results);
        if (rc != EOK) {
                puts("failed");
                printf(NAME ": %s\n", str_error(rc));
                return 1;
        }

        puts("succeeded\n");
        print_results(params, &results);
        return 0;
}

/** Run test on "out" endpoint.
 * @param[in] exch Open async exchange with the diagnostic device.
 * @param[in] generic_params Test parameters. Must point to 'usbdiag_test_params_t'.
 *
 * @return Exit code
 */
static int test_out(async_exch_t *exch, const void *generic_params)
{
        const usbdiag_test_params_t *params = (usbdiag_test_params_t *) generic_params;
        print_params(params);
        fputs("\nTesting... ", stdout);

        usbdiag_test_results_t results;
        errno_t rc = usbdiag_test_out(exch, params, &results);
        if (rc) {
                puts("failed");
                printf(NAME ": %s\n", str_error(rc));
                return 1;
        }

        puts("succeeded\n");
        print_results(params, &results);
        return 0;
}

#define GEN_PRE_RUN(FN, TYPE) \
        static int pre_run_##FN(void *generic_params) \
        { \
                usbdiag_test_params_t *params = (usbdiag_test_params_t *) generic_params; \
                params->transfer_type = USB_TRANSFER_##TYPE; \
                return EOK; \
        }

GEN_PRE_RUN(intr, INTERRUPT);
GEN_PRE_RUN(bulk, BULK);
GEN_PRE_RUN(isoch, ISOCHRONOUS);

#undef GEN_PRE_RUN

/** Interrupt in test command handler.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 *
 * @return Exit code
 */
int tmon_test_intr_in(int argc, char *argv[])
{
        static const tmon_test_ops_t ops = {
                .pre_run = pre_run_intr,
                .run = test_in,
                .read_params = read_params
        };

        return tmon_test_main(argc, argv, &ops);
}

/** Interrupt out test command handler.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 *
 * @return Exit code
 */
int tmon_test_intr_out(int argc, char *argv[])
{
        static const tmon_test_ops_t ops = {
                .pre_run = pre_run_intr,
                .run = test_out,
                .read_params = read_params
        };

        return tmon_test_main(argc, argv, &ops);
}

/** Interrupt bulk test command handler.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 *
 * @return Exit code
 */
int tmon_test_bulk_in(int argc, char *argv[])
{
        static const tmon_test_ops_t ops = {
                .pre_run = pre_run_bulk,
                .run = test_in,
                .read_params = read_params
        };

        return tmon_test_main(argc, argv, &ops);
}

/** Bulk out test command handler.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 *
 * @return Exit code
 */
int tmon_test_bulk_out(int argc, char *argv[])
{
        static const tmon_test_ops_t ops = {
                .pre_run = pre_run_bulk,
                .run = test_out,
                .read_params = read_params
        };

        return tmon_test_main(argc, argv, &ops);
}

/** Isochronous in test command handler.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 *
 * @return Exit code
 */
int tmon_test_isoch_in(int argc, char *argv[])
{
        static const tmon_test_ops_t ops = {
                .pre_run = pre_run_isoch,
                .run = test_in,
                .read_params = read_params
        };

        return tmon_test_main(argc, argv, &ops);
}

/** Isochronous out test command handler.
 * @param[in] argc Number of arguments.
 * @param[in] argv Argument values. Must point to exactly `argc` strings.
 *
 * @return Exit code
 */
int tmon_test_isoch_out(int argc, char *argv[])
{
        static const tmon_test_ops_t ops = {
                .pre_run = pre_run_isoch,
                .run = test_out,
                .read_params = read_params
        };

        return tmon_test_main(argc, argv, &ops);
}

/** @}
 */