Make SH port work for packagers that don't differentiate between SH4 and SH4A

[fio.git] / fio.c

diff --git a/fio.c b/fio.c
index 5ea1a2c32fc3d44edda83d910c8d11f8015cc1c9..9c1bed379df586ba8f3efea187aaaf319ce2d387 100644 (file)
--- a/fio.c
+++ b/fio.c
@@ -70,6 +70,8 @@ static pthread_t disk_util_thread;
 static struct flist_head *cgroup_list;
 static char *cgroup_mnt;
 
+unsigned long arch_flags = 0;
+
 struct io_log *agg_io_log[2];
 
 #define TERMINATE_ALL          (-1)
@@ -102,7 +104,9 @@ static void terminate_threads(int group_id)
                        /*
                         * if the thread is running, just let it exit
                         */
-                       if (td->runstate < TD_RUNNING)
+                       if (!td->pid)
+                               continue;
+                       else if (td->runstate < TD_RAMP)
                                kill(td->pid, SIGTERM);
                        else {
                                struct ioengine_ops *ops = td->io_ops;
@@ -372,10 +376,15 @@ requeue:
        return 0;
 }
 
+static inline void __update_tv_cache(struct thread_data *td)
+{
+       fio_gettime(&td->tv_cache, NULL);
+}
+
 static inline void update_tv_cache(struct thread_data *td)
 {
        if ((++td->tv_cache_nr & td->tv_cache_mask) == td->tv_cache_mask)
-               fio_gettime(&td->tv_cache, NULL);
+               __update_tv_cache(td);
 }
 
 static int break_on_this_error(struct thread_data *td, int *retptr)
@@ -461,8 +470,11 @@ static void do_verify(struct thread_data *td)
                update_tv_cache(td);
 
                if (runtime_exceeded(td, &td->tv_cache)) {
-                       td->terminate = 1;
-                       break;
+                       __update_tv_cache(td);
+                       if (runtime_exceeded(td, &td->tv_cache)) {
+                               td->terminate = 1;
+                               break;
+                       }
                }
 
                io_u = __get_io_u(td);
@@ -540,13 +552,14 @@ sync_done:
 
                /*
                 * if we can queue more, do so. but check if there are
-                * completed io_u's first.
+                * completed io_u's first. Note that we can get BUSY even
+                * without IO queued, if the system is resource starved.
                 */
-               full = queue_full(td) || ret == FIO_Q_BUSY;
+               full = queue_full(td) || (ret == FIO_Q_BUSY && td->cur_depth);
                if (full || !td->o.iodepth_batch_complete) {
                        min_events = min(td->o.iodepth_batch_complete,
                                         td->cur_depth);
-                       if (full && !min_events)
+                       if (full && !min_events && td->o.iodepth_batch_complete != 0)
                                min_events = 1;
 
                        do {
@@ -607,8 +620,11 @@ static void do_io(struct thread_data *td)
                update_tv_cache(td);
 
                if (runtime_exceeded(td, &td->tv_cache)) {
-                       td->terminate = 1;
-                       break;
+                       __update_tv_cache(td);
+                       if (runtime_exceeded(td, &td->tv_cache)) {
+                               td->terminate = 1;
+                               break;
+                       }
                }
 
                io_u = get_io_u(td);
@@ -697,13 +713,15 @@ sync_done:
                        break;
 
                /*
-                * See if we need to complete some commands
+                * See if we need to complete some commands. Note that we
+                * can get BUSY even without IO queued, if the system is
+                * resource starved.
                 */
-               full = queue_full(td) || ret == FIO_Q_BUSY;
+               full = queue_full(td) || (ret == FIO_Q_BUSY && td->cur_depth);
                if (full || !td->o.iodepth_batch_complete) {
                        min_evts = min(td->o.iodepth_batch_complete,
                                        td->cur_depth);
-                       if (full && !min_evts)
+                       if (full && !min_evts && td->o.iodepth_batch_complete != 0)
                                min_evts = 1;
 
                        if (__should_check_rate(td, 0) ||
@@ -967,11 +985,6 @@ static void reset_io_counters(struct thread_data *td)
         */
        if (td->o.time_based || td->o.loops)
                td->nr_done_files = 0;
-
-       /*
-        * Set the same seed to get repeatable runs
-        */
-       td_fill_rand_seeds(td);
 }
 
 void reset_all_stats(struct thread_data *td)
@@ -1005,6 +1018,11 @@ static void clear_io_state(struct thread_data *td)
        close_files(td);
        for_each_file(td, f, i)
                fio_file_clear_done(f);
+
+       /*
+        * Set the same seed to get repeatable runs
+        */
+       td_fill_rand_seeds(td);
 }
 
 static int exec_string(const char *string)
@@ -1034,10 +1052,11 @@ static void *thread_main(void *data)
        pthread_condattr_t attr;
        int clear_state;
 
-       if (!td->o.use_thread)
+       if (!td->o.use_thread) {
                setsid();
-
-       td->pid = getpid();
+               td->pid = getpid();
+       } else
+               td->pid = gettid();
 
        dprint(FD_PROCESS, "jobs pid=%d started\n", (int) td->pid);
 
@@ -1081,6 +1100,22 @@ static void *thread_main(void *data)
                goto err;
        }
 
+       /*
+        * If we have a gettimeofday() thread, make sure we exclude that
+        * thread from this job
+        */
+       if (td->o.gtod_cpu)
+               fio_cpu_clear(&td->o.cpumask, td->o.gtod_cpu);
+
+       /*
+        * Set affinity first, in case it has an impact on the memory
+        * allocations.
+        */
+       if (td->o.cpumask_set && fio_setaffinity(td->pid, td->o.cpumask) == -1) {
+               td_verror(td, errno, "cpu_set_affinity");
+               goto err;
+       }
+
        /*
         * May alter parameters that init_io_u() will use, so we need to
         * do this first.
@@ -1094,23 +1129,6 @@ static void *thread_main(void *data)
        if (td->o.verify_async && verify_async_init(td))
                goto err;
 
-       if (td->o.cpumask_set && fio_setaffinity(td->pid, td->o.cpumask) == -1) {
-               td_verror(td, errno, "cpu_set_affinity");
-               goto err;
-       }
-
-       /*
-        * If we have a gettimeofday() thread, make sure we exclude that
-        * thread from this job
-        */
-       if (td->o.gtod_cpu) {
-               fio_cpu_clear(&td->o.cpumask, td->o.gtod_cpu);
-               if (fio_setaffinity(td->pid, td->o.cpumask) == -1) {
-                       td_verror(td, errno, "cpu_set_affinity");
-                       goto err;
-               }
-       }
-
        if (td->ioprio_set) {
                if (ioprio_set(IOPRIO_WHO_PROCESS, 0, td->ioprio) == -1) {
                        td_verror(td, errno, "ioprio_set");
@@ -1284,6 +1302,7 @@ static int fork_main(int shmid, int offset)
        struct thread_data *td;
        void *data, *ret;
 
+#ifndef __hpux
        data = shmat(shmid, NULL, 0);
        if (data == (void *) -1) {
                int __err = errno;
@@ -1291,6 +1310,12 @@ static int fork_main(int shmid, int offset)
                perror("shmat");
                return __err;
        }
+#else
+       /*
+        * HP-UX inherits shm mappings?
+        */
+       data = threads;
+#endif
 
        td = data + offset * sizeof(struct thread_data);
        ret = thread_main(td);
@@ -1515,7 +1540,7 @@ static void run_threads(void)
        set_genesis_time();
 
        while (todo) {
-               struct thread_data *map[MAX_JOBS];
+               struct thread_data *map[REAL_MAX_JOBS];
                struct timeval this_start;
                int this_jobs = 0, left;
 
@@ -1667,10 +1692,12 @@ static void run_threads(void)
        fio_unpin_memory();
 }
 
-int main(int argc, char *argv[])
+int main(int argc, char *argv[], char *envp[])
 {
        long ps;
 
+       arch_init(envp);
+
        sinit();
        init_rand(&__fio_rand_state);