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 "fio.h"
  27
  28 static const char *fio_os_strings[os_nr] = {
  29         "Invalid",
  30         "Linux",
  31         "AIX",
  32         "FreeBSD",
  33         "HP-UX",
  34         "OSX",
  35         "NetBSD",
  36         "Solaris",
  37         "Windows"
  38 };
  39
  40 static const char *fio_arch_strings[arch_nr] = {
  41         "Invalid",
  42         "x86-64",
  43         "x86",
  44         "ppc",
  45         "ia64",
  46         "s390",
  47         "alpha",
  48         "sparc",
  49         "sparc64",
  50         "arm",
  51         "sh",
  52         "hppa",
  53         "generic"
  54 };
  55
  56 static void reset_io_counters(struct thread_data *td)
  57 {
  58         td->stat_io_bytes[0] = td->stat_io_bytes[1] = 0;
  59         td->this_io_bytes[0] = td->this_io_bytes[1] = 0;
  60         td->stat_io_blocks[0] = td->stat_io_blocks[1] = 0;
  61         td->this_io_blocks[0] = td->this_io_blocks[1] = 0;
  62         td->zone_bytes = 0;
  63         td->rate_bytes[0] = td->rate_bytes[1] = 0;
  64         td->rate_blocks[0] = td->rate_blocks[1] = 0;
  65
  66         td->last_was_sync = 0;
  67
  68         /*
  69          * reset file done count if we are to start over
  70          */
  71         if (td->o.time_based || td->o.loops)
  72                 td->nr_done_files = 0;
  73 }
  74
  75 void clear_io_state(struct thread_data *td)
  76 {
  77         struct fio_file *f;
  78         unsigned int i;
  79
  80         reset_io_counters(td);
  81
  82         close_files(td);
  83         for_each_file(td, f, i)
  84                 fio_file_clear_done(f);
  85
  86         /*
  87          * Set the same seed to get repeatable runs
  88          */
  89         td_fill_rand_seeds(td);
  90 }
  91
  92 void reset_all_stats(struct thread_data *td)
  93 {
  94         struct timeval tv;
  95         int i;
  96
  97         reset_io_counters(td);
  98
  99         for (i = 0; i < 2; i++) {
 100                 td->io_bytes[i] = 0;
 101                 td->io_blocks[i] = 0;
 102                 td->io_issues[i] = 0;
 103                 td->ts.total_io_u[i] = 0;
 104         }
 105
 106         fio_gettime(&tv, NULL);
 107         td->ts.runtime[0] = 0;
 108         td->ts.runtime[1] = 0;
 109         memcpy(&td->epoch, &tv, sizeof(tv));
 110         memcpy(&td->start, &tv, sizeof(tv));
 111 }
 112
 113 void reset_fio_state(void)
 114 {
 115         groupid = 0;
 116         thread_number = 0;
 117         nr_process = 0;
 118         nr_thread = 0;
 119         done_secs = 0;
 120 }
 121
 122 const char *fio_get_os_string(int nr)
 123 {
 124         if (nr < os_nr)
 125                 return fio_os_strings[nr];
 126
 127         return NULL;
 128 }
 129
 130 const char *fio_get_arch_string(int nr)
 131 {
 132         if (nr < arch_nr)
 133                 return fio_arch_strings[nr];
 134
 135         return NULL;
 136 }
 137
 138 void td_set_runstate(struct thread_data *td, int runstate)
 139 {
 140         if (td->runstate == runstate)
 141                 return;
 142
 143         dprint(FD_PROCESS, "pid=%d: runstate %d -> %d\n", (int) td->pid,
 144                                                 td->runstate, runstate);
 145         td->runstate = runstate;
 146 }
 147
 148 void fio_terminate_threads(int group_id)
 149 {
 150         struct thread_data *td;
 151         int i;
 152
 153         dprint(FD_PROCESS, "terminate group_id=%d\n", group_id);
 154
 155         for_each_td(td, i) {
 156                 if (group_id == TERMINATE_ALL || groupid == td->groupid) {
 157                         dprint(FD_PROCESS, "setting terminate on %s/%d\n",
 158                                                 td->o.name, (int) td->pid);
 159                         td->terminate = 1;
 160                         td->o.start_delay = 0;
 161
 162                         /*
 163                          * if the thread is running, just let it exit
 164                          */
 165                         if (!td->pid)
 166                                 continue;
 167                         else if (td->runstate < TD_RAMP)
 168                                 kill(td->pid, SIGTERM);
 169                         else {
 170                                 struct ioengine_ops *ops = td->io_ops;
 171
 172                                 if (ops && (ops->flags & FIO_SIGTERM))
 173                                         kill(td->pid, SIGTERM);
 174                         }
 175                 }
 176         }
 177 }
 178
 179