libfio.c

   1 /*
   2  * fio - the flexible io tester
   3  *
   4  * Copyright (C) 2005 Jens Axboe <axboe@suse.de>
   5  * Copyright (C) 2006-2012 Jens Axboe <axboe@kernel.dk>
   6  *
   7  * The license below covers all files distributed with fio unless otherwise
   8  * noted in the file itself.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2 as
  12  *  published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 #include <string.h>
  26 #include <sys/types.h>
  27 #include <signal.h>
  28 #include "fio.h"
  29
  30 /*
  31  * Just expose an empty list, if the OS does not support disk util stats
  32  */
  33 #ifndef FIO_HAVE_DISK_UTIL
  34 FLIST_HEAD(disk_list);
  35 #endif
  36
  37 unsigned long arch_flags = 0;
  38
  39 static const char *fio_os_strings[os_nr] = {
  40         "Invalid",
  41         "Linux",
  42         "AIX",
  43         "FreeBSD",
  44         "HP-UX",
  45         "OSX",
  46         "NetBSD",
  47         "Solaris",
  48         "Windows"
  49 };
  50
  51 static const char *fio_arch_strings[arch_nr] = {
  52         "Invalid",
  53         "x86-64",
  54         "x86",
  55         "ppc",
  56         "ia64",
  57         "s390",
  58         "alpha",
  59         "sparc",
  60         "sparc64",
  61         "arm",
  62         "sh",
  63         "hppa",
  64         "generic"
  65 };
  66
  67 static void reset_io_counters(struct thread_data *td)
  68 {
  69         int ddir;
  70
  71         for (ddir = 0; ddir < DDIR_RWDIR_CNT; ddir++) {
  72                 td->stat_io_bytes[ddir] = 0;
  73                 td->this_io_bytes[ddir] = 0;
  74                 td->stat_io_blocks[ddir] = 0;
  75                 td->this_io_blocks[ddir] = 0;
  76                 td->rate_bytes[ddir] = 0;
  77                 td->rate_blocks[ddir] = 0;
  78                 td->io_issues[ddir] = 0;
  79         }
  80         td->zone_bytes = 0;
  81
  82         td->last_was_sync = 0;
  83         td->rwmix_issues = 0;
  84
  85         /*
  86          * reset file done count if we are to start over
  87          */
  88         if (td->o.time_based || td->o.loops || td->o.do_verify)
  89                 td->nr_done_files = 0;
  90 }
  91
  92 void clear_io_state(struct thread_data *td)
  93 {
  94         struct fio_file *f;
  95         unsigned int i;
  96
  97         reset_io_counters(td);
  98
  99         close_files(td);
 100         for_each_file(td, f, i)
 101                 fio_file_clear_done(f);
 102
 103         /*
 104          * Set the same seed to get repeatable runs
 105          */
 106         td_fill_rand_seeds(td);
 107 }
 108
 109 void reset_all_stats(struct thread_data *td)
 110 {
 111         struct timeval tv;
 112         int i;
 113
 114         reset_io_counters(td);
 115
 116         for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 117                 td->io_bytes[i] = 0;
 118                 td->io_blocks[i] = 0;
 119                 td->io_issues[i] = 0;
 120                 td->ts.total_io_u[i] = 0;
 121                 td->ts.runtime[i] = 0;
 122                 td->rwmix_issues = 0;
 123         }
 124
 125         fio_gettime(&tv, NULL);
 126         memcpy(&td->epoch, &tv, sizeof(tv));
 127         memcpy(&td->start, &tv, sizeof(tv));
 128 }
 129
 130 void reset_fio_state(void)
 131 {
 132         groupid = 0;
 133         thread_number = 0;
 134         stat_number = 0;
 135         nr_process = 0;
 136         nr_thread = 0;
 137         done_secs = 0;
 138 }
 139
 140 const char *fio_get_os_string(int nr)
 141 {
 142         if (nr < os_nr)
 143                 return fio_os_strings[nr];
 144
 145         return NULL;
 146 }
 147
 148 const char *fio_get_arch_string(int nr)
 149 {
 150         if (nr < arch_nr)
 151                 return fio_arch_strings[nr];
 152
 153         return NULL;
 154 }
 155
 156 void td_set_runstate(struct thread_data *td, int runstate)
 157 {
 158         if (td->runstate == runstate)
 159                 return;
 160
 161         dprint(FD_PROCESS, "pid=%d: runstate %d -> %d\n", (int) td->pid,
 162                                                 td->runstate, runstate);
 163         td->runstate = runstate;
 164 }
 165
 166 void fio_terminate_threads(int group_id)
 167 {
 168         struct thread_data *td;
 169         pid_t pid = getpid();
 170         int i;
 171
 172         dprint(FD_PROCESS, "terminate group_id=%d\n", group_id);
 173
 174         for_each_td(td, i) {
 175                 if (group_id == TERMINATE_ALL || groupid == td->groupid) {
 176                         dprint(FD_PROCESS, "setting terminate on %s/%d\n",
 177                                                 td->o.name, (int) td->pid);
 178                         td->terminate = 1;
 179                         td->o.start_delay = 0;
 180
 181                         /*
 182                          * if the thread is running, just let it exit
 183                          */
 184                         if (!td->pid || pid == td->pid)
 185                                 continue;
 186                         else if (td->runstate < TD_RAMP)
 187                                 kill(td->pid, SIGTERM);
 188                         else {
 189                                 struct ioengine_ops *ops = td->io_ops;
 190
 191                                 if (ops && ops->terminate)
 192                                         ops->terminate(td);
 193                         }
 194                 }
 195         }
 196 }
 197
 198