uspace/app/tmon/tf.c

   1 /*
   2  * Copyright (c) 2017 Petr Manek
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup tmon
  30  * @{
  31  */
  32 /**
  33  * @file
  34  * Testing framework.
  35  */
  36
  37 #include <stdio.h>
  38 #include <macros.h>
  39 #include <devman.h>
  40 #include <str_error.h>
  41 #include <usbdiag_iface.h>
  42 #include "resolve.h"
  43 #include "tf.h"
  44
  45 #define NAME "tmon"
  46 #define MAX_PATH_LENGTH 1024
  47
  48 /** Common command handler for all test commands.
  49  * @param[in] argc Number of arguments.
  50  * @param[in] argv Argument values. Must point to exactly `argc` strings.
  51  *
  52  * @return Exit code
  53  */
  54 int tmon_test_main(int argc, char *argv[], const tmon_test_ops_t *ops)
  55 {
  56         // Resolve device function.
  57         devman_handle_t fun = -1;
  58
  59         if (argc >= 2 && *argv[1] != '-') {
  60                 // Assume that the first argument is device path.
  61                 if (tmon_resolve_named(argv[1], &fun))
  62                         return 1;
  63         } else {
  64                 // The first argument is either an option or not present.
  65                 if (tmon_resolve_default(&fun))
  66                         return 1;
  67         }
  68
  69         errno_t rc;
  70         int ec;
  71         char path[MAX_PATH_LENGTH];
  72         if ((rc = devman_fun_get_path(fun, path, sizeof(path)))) {
  73                 printf(NAME ": Error resolving path of device with handle "
  74                     "%" PRIun ". %s\n", fun, str_error(rc));
  75                 return 1;
  76         }
  77
  78         printf("Device: %s\n", path);
  79
  80         // Read test parameters from options.
  81         void *params = NULL;
  82         if ((rc = ops->read_params(argc, argv, &params))) {
  83                 printf(NAME ": Reading test parameters failed. %s\n", str_error(rc));
  84                 return 1;
  85         }
  86
  87         if ((rc = ops->pre_run(params))) {
  88                 printf(NAME ": Pre-run hook failed. %s\n", str_error(rc));
  89                 return 1;
  90         }
  91
  92         // Run the test body.
  93         async_sess_t *sess = usbdiag_connect(fun);
  94         if (!sess) {
  95                 printf(NAME ": Could not connect to the device.\n");
  96                 return 1;
  97         }
  98
  99         async_exch_t *exch = async_exchange_begin(sess);
 100         if (!exch) {
 101                 printf(NAME ": Could not start exchange with the device.\n");
 102                 ec = 1;
 103                 goto err_sess;
 104         }
 105
 106         ec = ops->run(exch, params);
 107         async_exchange_end(exch);
 108
 109 err_sess:
 110         usbdiag_disconnect(sess);
 111         free(params);
 112         return ec;
 113 }
 114
 115 /** Unit of quantity used for pretty formatting. */
 116 typedef struct tmon_unit {
 117         /** Prefix letter, which is printed before the actual unit. */
 118         const char *unit;
 119         /** Factor of the unit. */
 120         double factor;
 121 } tmon_unit_t;
 122
 123 /** Format a value for human reading.
 124  * @param[in] val The value to format.
 125  * @param[in] fmt Format string. Must include one double and char.
 126  *
 127  * @return Heap-allocated string if successful (caller becomes its owner), NULL otherwise.
 128  */
 129 static char *format_unit(double val, const char *fmt, const tmon_unit_t *units, size_t len)
 130 {
 131         // Figure out the "tightest" unit.
 132         unsigned i;
 133         for (i = 0; i < len; ++i) {
 134                 if (units[i].factor <= val)
 135                         break;
 136         }
 137
 138         if (i == len)
 139                 --i;
 140         const char *unit = units[i].unit;
 141         double factor = units[i].factor;
 142
 143         // Format the size.
 144         const double div_size = val / factor;
 145
 146         char *out = NULL;
 147         asprintf(&out, fmt, div_size, unit);
 148
 149         return out;
 150 }
 151
 152 /** Static array of size units with decreasing factors. */
 153 static const tmon_unit_t size_units[] = {
 154         { .unit = "EB", .factor = 1ULL << 60 },
 155         { .unit = "PB", .factor = 1ULL << 50 },
 156         { .unit = "TB", .factor = 1ULL << 40 },
 157         { .unit = "GB", .factor = 1ULL << 30 },
 158         { .unit = "MB", .factor = 1ULL << 20 },
 159         { .unit = "kB", .factor = 1ULL << 10 },
 160         { .unit = "B",  .factor = 1ULL },
 161 };
 162
 163 char *tmon_format_size(double val, const char *fmt)
 164 {
 165         return format_unit(val, fmt, size_units, ARRAY_SIZE(size_units));
 166 }
 167
 168 /** Static array of duration units with decreasing factors. */
 169 static const tmon_unit_t dur_units[] = {
 170         { .unit = "d",   .factor = 60 * 60 * 24 },
 171         { .unit = "h",   .factor = 60 * 60 },
 172         { .unit = "min", .factor = 60 },
 173         { .unit = "s",   .factor = 1 },
 174         { .unit = "ms",  .factor = 1e-3 },
 175         { .unit = "us",  .factor = 1e-6 },
 176         { .unit = "ns",  .factor = 1e-9 },
 177         { .unit = "ps",  .factor = 1e-12 },
 178 };
 179
 180 char *tmon_format_duration(usbdiag_dur_t val, const char *fmt)
 181 {
 182         return format_unit(val / 1000.0, fmt, dur_units, ARRAY_SIZE(dur_units));
 183 }
 184
 185 /** @}
 186  */