X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=6222a4185c7105973b4080669e34a37303a7f281;hp=1c2748e06ee4483b0cdef5457757985140a133a6;hb=9cedf16704b71cec33138bb4cf524d3fc9ad338a;hpb=e916b390684ec1ca6247f98138fa9c1682701d29 diff --git a/fio.c b/fio.c index 1c2748e0..6222a418 100644 --- a/fio.c +++ b/fio.c @@ -43,10 +43,12 @@ static unsigned long page_mask; int groupid = 0; int thread_number = 0; +int nr_process = 0; +int nr_thread = 0; int shm_id = 0; int temp_stall_ts; -static volatile int startup_sem; +static struct fio_sem *startup_sem; static volatile int fio_abort; static int exit_value; @@ -60,17 +62,20 @@ static inline void td_set_runstate(struct thread_data *td, int runstate) td->runstate = runstate; } -static void terminate_threads(int group_id, int forced_kill) +static void terminate_threads(int group_id) { struct thread_data *td; int i; for_each_td(td, i) { if (group_id == TERMINATE_ALL || groupid == td->groupid) { + /* + * if the thread is running, just let it exit + */ + if (td->runstate < TD_RUNNING) + kill(td->pid, SIGQUIT); td->terminate = 1; td->start_delay = 0; - if (forced_kill) - td_set_runstate(td, TD_EXITED); } } } @@ -86,7 +91,7 @@ static void sig_handler(int sig) default: printf("\nfio: terminating on signal %d\n", sig); fflush(stdout); - terminate_threads(TERMINATE_ALL, 0); + terminate_threads(TERMINATE_ALL); break; } } @@ -96,9 +101,15 @@ static void sig_handler(int sig) */ static int check_min_rate(struct thread_data *td, struct timeval *now) { + unsigned long long bytes = 0; unsigned long spent; unsigned long rate; - int ddir = td->ddir; + + /* + * No minimum rate set, always ok + */ + if (!td->ratemin) + return 0; /* * allow a 2 second settle period in the beginning @@ -106,6 +117,11 @@ static int check_min_rate(struct thread_data *td, struct timeval *now) if (mtime_since(&td->start, now) < 2000) return 0; + if (td_read(td)) + bytes += td->this_io_bytes[DDIR_READ]; + if (td_write(td)) + bytes += td->this_io_bytes[DDIR_WRITE]; + /* * if rate blocks is set, sample is running */ @@ -114,14 +130,19 @@ static int check_min_rate(struct thread_data *td, struct timeval *now) if (spent < td->ratecycle) return 0; - rate = (td->this_io_bytes[ddir] - td->rate_bytes) / spent; - if (rate < td->ratemin) { - fprintf(f_out, "%s: min rate %u not met, got %luKiB/sec\n", td->name, td->ratemin, rate); + if (bytes < td->rate_bytes) { + fprintf(f_out, "%s: min rate %u not met\n", td->name, td->ratemin); return 1; + } else { + rate = (bytes - td->rate_bytes) / spent; + if (rate < td->ratemin || bytes < td->rate_bytes) { + fprintf(f_out, "%s: min rate %u not met, got %luKiB/sec\n", td->name, td->ratemin, rate); + return 1; + } } } - td->rate_bytes = td->this_io_bytes[ddir]; + td->rate_bytes = bytes; memcpy(&td->lastrate, now, sizeof(*now)); return 0; } @@ -149,7 +170,9 @@ static void cleanup_pending_aio(struct thread_data *td) /* * get immediately available events, if any */ - io_u_queued_complete(td, 0, NULL); + r = io_u_queued_complete(td, 0); + if (r < 0) + return; /* * now cancel remaining active events @@ -158,14 +181,24 @@ static void cleanup_pending_aio(struct thread_data *td) list_for_each_safe(entry, n, &td->io_u_busylist) { io_u = list_entry(entry, struct io_u, list); - r = td->io_ops->cancel(td, io_u); - if (!r) + /* + * if the io_u isn't in flight, then that generally + * means someone leaked an io_u. complain but fix + * it up, so we don't stall here. + */ + if ((io_u->flags & IO_U_F_FLIGHT) == 0) { + log_err("fio: non-busy IO on busy list\n"); put_io_u(td, io_u); + } else { + r = td->io_ops->cancel(td, io_u); + if (!r) + put_io_u(td, io_u); + } } } if (td->cur_depth) - io_u_queued_complete(td, td->cur_depth, NULL); + r = io_u_queued_complete(td, td->cur_depth); } /* @@ -191,19 +224,20 @@ static int fio_io_sync(struct thread_data *td, struct fio_file *f) requeue: ret = td_io_queue(td, io_u); if (ret < 0) { - td_verror(td, io_u->error); + td_verror(td, io_u->error, "td_io_queue"); put_io_u(td, io_u); return 1; } else if (ret == FIO_Q_QUEUED) { - if (io_u_queued_complete(td, 1, NULL)) + if (io_u_queued_complete(td, 1) < 0) return 1; } else if (ret == FIO_Q_COMPLETED) { if (io_u->error) { - td_verror(td, io_u->error); + td_verror(td, io_u->error, "td_io_queue"); return 1; } - io_u_sync_complete(td, io_u, NULL); + if (io_u_sync_complete(td, io_u) < 0) + return 1; } else if (ret == FIO_Q_BUSY) { if (td_io_commit(td)) return 1; @@ -214,7 +248,7 @@ requeue: } /* - * The main verify engine. Runs over the writes we previusly submitted, + * The main verify engine. Runs over the writes we previously submitted, * reads the blocks back in, and checks the crc/md5 of the data. */ static void do_verify(struct thread_data *td) @@ -228,54 +262,78 @@ static void do_verify(struct thread_data *td) * read from disk. */ for_each_file(td, f, i) { - fio_io_sync(td, f); - file_invalidate_cache(td, f); + if (fio_io_sync(td, f)) + break; + if (file_invalidate_cache(td, f)) + break; } + if (td->error) + return; + td_set_runstate(td, TD_VERIFYING); io_u = NULL; while (!td->terminate) { + int ret2; + io_u = __get_io_u(td); if (!io_u) break; - if (runtime_exceeded(td, &io_u->start_time)) + if (runtime_exceeded(td, &io_u->start_time)) { + put_io_u(td, io_u); break; + } - if (get_next_verify(td, io_u)) + if (get_next_verify(td, io_u)) { + put_io_u(td, io_u); break; + } - if (td_io_prep(td, io_u)) + if (td_io_prep(td, io_u)) { + put_io_u(td, io_u); break; + } -requeue: - ret = td_io_queue(td, io_u); + io_u->end_io = verify_io_u; + ret = td_io_queue(td, io_u); switch (ret) { case FIO_Q_COMPLETED: if (io_u->error) ret = -io_u->error; - if (io_u->xfer_buflen != io_u->resid && io_u->resid) { + else if (io_u->resid) { int bytes = io_u->xfer_buflen - io_u->resid; + /* + * zero read, fail + */ + if (!bytes) { + td_verror(td, ENODATA, "full resid"); + put_io_u(td, io_u); + break; + } io_u->xfer_buflen = io_u->resid; io_u->xfer_buf += bytes; - goto requeue; + requeue_io_u(td, &io_u); + } else { + ret = io_u_sync_complete(td, io_u); + if (ret < 0) + break; } - ret = io_u_sync_complete(td, io_u, verify_io_u); - if (ret) - break; continue; case FIO_Q_QUEUED: break; case FIO_Q_BUSY: requeue_io_u(td, &io_u); - ret = td_io_commit(td); + ret2 = td_io_commit(td); + if (ret2 < 0) + ret = ret2; break; default: assert(ret < 0); - td_verror(td, -ret); + td_verror(td, -ret, "td_io_queue"); break; } @@ -298,44 +356,21 @@ requeue: * Reap required number of io units, if any, and do the * verification on them through the callback handler */ - if (io_u_queued_complete(td, min_events, verify_io_u)) + if (io_u_queued_complete(td, min_events) < 0) break; } - if (io_u) - put_io_u(td, io_u); + if (!td->error) { + min_events = td->cur_depth; - if (td->cur_depth) + if (min_events) + ret = io_u_queued_complete(td, min_events); + } else cleanup_pending_aio(td); td_set_runstate(td, TD_RUNNING); } -/* - * Not really an io thread, all it does is burn CPU cycles in the specified - * manner. - */ -static void do_cpuio(struct thread_data *td) -{ - struct timeval e; - int split = 100 / td->cpuload; - int i = 0; - - while (!td->terminate) { - fio_gettime(&e, NULL); - - if (runtime_exceeded(td, &e)) - break; - - if (!(i % split)) - __usec_sleep(10000); - else - usec_sleep(td, 10000); - - i++; - } -} - /* * Main IO worker function. It retrieves io_u's to process and queues * and reaps them, checking for rate and errors along the way. @@ -353,6 +388,7 @@ static void do_io(struct thread_data *td) long bytes_done = 0; int min_evts = 0; struct io_u *io_u; + int ret2; if (td->terminate) break; @@ -367,26 +403,33 @@ static void do_io(struct thread_data *td) put_io_u(td, io_u); break; } -requeue: - ret = td_io_queue(td, io_u); + ret = td_io_queue(td, io_u); switch (ret) { case FIO_Q_COMPLETED: - if (io_u->error) { - ret = io_u->error; - break; - } - if (io_u->xfer_buflen != io_u->resid && io_u->resid) { + if (io_u->error) + ret = -io_u->error; + else if (io_u->resid) { int bytes = io_u->xfer_buflen - io_u->resid; + /* + * zero read, fail + */ + if (!bytes) { + td_verror(td, ENODATA, "full resid"); + put_io_u(td, io_u); + break; + } + io_u->xfer_buflen = io_u->resid; io_u->xfer_buf += bytes; - goto requeue; + requeue_io_u(td, &io_u); + } else { + fio_gettime(&comp_time, NULL); + bytes_done = io_u_sync_complete(td, io_u); + if (bytes_done < 0) + ret = bytes_done; } - fio_gettime(&comp_time, NULL); - bytes_done = io_u_sync_complete(td, io_u, NULL); - if (bytes_done < 0) - ret = bytes_done; break; case FIO_Q_QUEUED: /* @@ -399,7 +442,9 @@ requeue: break; case FIO_Q_BUSY: requeue_io_u(td, &io_u); - ret = td_io_commit(td); + ret2 = td_io_commit(td); + if (ret2 < 0) + ret = ret2; break; default: assert(ret < 0); @@ -423,7 +468,7 @@ requeue: } fio_gettime(&comp_time, NULL); - bytes_done = io_u_queued_complete(td, min_evts, NULL); + bytes_done = io_u_queued_complete(td, min_evts); if (bytes_done < 0) break; } @@ -438,12 +483,12 @@ requeue: */ usec = utime_since(&s, &comp_time); - rate_throttle(td, usec, bytes_done, td->ddir); + rate_throttle(td, usec, bytes_done); if (check_min_rate(td, &comp_time)) { if (exitall_on_terminate) - terminate_threads(td->groupid, 0); - td_verror(td, ENODATA); + terminate_threads(td->groupid); + td_verror(td, ENODATA, "check_min_rate"); break; } @@ -467,15 +512,17 @@ requeue: if (!td->error) { struct fio_file *f; - if (td->cur_depth) - cleanup_pending_aio(td); + i = td->cur_depth; + if (i) + ret = io_u_queued_complete(td, i); if (should_fsync(td) && td->end_fsync) { td_set_runstate(td, TD_FSYNCING); for_each_file(td, f, i) fio_io_sync(td, f); } - } + } else + cleanup_pending_aio(td); } static void cleanup_io_u(struct thread_data *td) @@ -513,9 +560,6 @@ static int init_io_u(struct thread_data *td) int i, max_units; char *p; - if (td->io_ops->flags & FIO_CPUIO) - return 0; - if (td->io_ops->flags & FIO_SYNCIO) max_units = 1; else @@ -543,9 +587,12 @@ static int init_io_u(struct thread_data *td) fill_rand_buf(io_u, max_bs); io_u->index = i; + io_u->flags = IO_U_F_FREE; list_add(&io_u->list, &td->io_u_freelist); } + io_u_init_timeout(); + return 0; } @@ -555,14 +602,14 @@ static int switch_ioscheduler(struct thread_data *td) FILE *f; int ret; - if (td->io_ops->flags & FIO_CPUIO) + if (td->io_ops->flags & FIO_DISKLESSIO) return 0; sprintf(tmp, "%s/queue/scheduler", td->sysfs_root); f = fopen(tmp, "r+"); if (!f) { - td_verror(td, errno); + td_verror(td, errno, "fopen"); return 1; } @@ -571,7 +618,7 @@ static int switch_ioscheduler(struct thread_data *td) */ ret = fwrite(td->ioscheduler, strlen(td->ioscheduler), 1, f); if (ferror(f) || ret != 1) { - td_verror(td, errno); + td_verror(td, errno, "fwrite"); fclose(f); return 1; } @@ -583,7 +630,7 @@ static int switch_ioscheduler(struct thread_data *td) */ ret = fread(tmp, 1, sizeof(tmp), f); if (ferror(f) || ret < 0) { - td_verror(td, errno); + td_verror(td, errno, "fread"); fclose(f); return 1; } @@ -591,7 +638,7 @@ static int switch_ioscheduler(struct thread_data *td) sprintf(tmp2, "[%s]", td->ioscheduler); if (!strstr(tmp, tmp2)) { log_err("fio: io scheduler %s not found\n", td->ioscheduler); - td_verror(td, EINVAL); + td_verror(td, EINVAL, "iosched_switch"); fclose(f); return 1; } @@ -600,27 +647,29 @@ static int switch_ioscheduler(struct thread_data *td) return 0; } -static void clear_io_state(struct thread_data *td) +static int clear_io_state(struct thread_data *td) { struct fio_file *f; - int i; + int i, ret; td->ts.stat_io_bytes[0] = td->ts.stat_io_bytes[1] = 0; td->this_io_bytes[0] = td->this_io_bytes[1] = 0; td->zone_bytes = 0; + td->rate_bytes = 0; td->last_was_sync = 0; - for_each_file(td, f, i) { - f->last_completed_pos = 0; - - f->last_pos = 0; - if (td->io_ops->flags & FIO_SYNCIO) - lseek(f->fd, SEEK_SET, 0); + for_each_file(td, f, i) + td_io_close_file(td, f); - if (f->file_map) - memset(f->file_map, 0, f->num_maps * sizeof(long)); + ret = 0; + for_each_file(td, f, i) { + ret = td_io_open_file(td, f); + if (ret) + break; } + + return ret; } /* @@ -631,6 +680,7 @@ static void *thread_main(void *data) { unsigned long long runtime[2]; struct thread_data *td = data; + int clear_state; if (!td->use_thread) setsid(); @@ -644,59 +694,64 @@ static void *thread_main(void *data) INIT_LIST_HEAD(&td->io_log_list); if (init_io_u(td)) - goto err; + goto err_sem; if (fio_setaffinity(td) == -1) { - td_verror(td, errno); - goto err; + td_verror(td, errno, "cpu_set_affinity"); + goto err_sem; } if (init_iolog(td)) - goto err; + goto err_sem; if (td->ioprio) { if (ioprio_set(IOPRIO_WHO_PROCESS, 0, td->ioprio) == -1) { - td_verror(td, errno); - goto err; + td_verror(td, errno, "ioprio_set"); + goto err_sem; } } if (nice(td->nice) == -1) { - td_verror(td, errno); - goto err; + td_verror(td, errno, "nice"); + goto err_sem; } if (init_random_state(td)) - goto err; + goto err_sem; if (td->ioscheduler && switch_ioscheduler(td)) - goto err; + goto err_sem; td_set_runstate(td, TD_INITIALIZED); - fio_sem_up(&startup_sem); - fio_sem_down(&td->mutex); + fio_sem_up(startup_sem); + fio_sem_down(td->mutex); + + /* + * the ->mutex semaphore is now no longer used, close it to avoid + * eating a file descriptor + */ + fio_sem_remove(td->mutex); if (!td->create_serialize && setup_files(td)) goto err; - if (open_files(td)) - goto err; - /* - * Do this late, as some IO engines would like to have the - * files setup prior to initializing structures. - */ if (td_io_init(td)) goto err; + if (open_files(td)) + goto err; + if (td->exec_prerun) { if (system(td->exec_prerun) < 0) goto err; } fio_gettime(&td->epoch, NULL); + memcpy(&td->timeout_end, &td->epoch, sizeof(td->epoch)); getrusage(RUSAGE_SELF, &td->ts.ru_start); runtime[0] = runtime[1] = 0; + clear_state = 0; while (td->loops--) { fio_gettime(&td->start, NULL); memcpy(&td->ts.stat_sample_time, &td->start, sizeof(td->start)); @@ -704,25 +759,29 @@ static void *thread_main(void *data) if (td->ratemin) memcpy(&td->lastrate, &td->ts.stat_sample_time, sizeof(td->lastrate)); - clear_io_state(td); + if (clear_state && clear_io_state(td)) + break; + prune_io_piece_log(td); - if (td->io_ops->flags & FIO_CPUIO) - do_cpuio(td); - else - do_io(td); + do_io(td); - runtime[td->ddir] += utime_since_now(&td->start); - if (td_rw(td) && td->io_bytes[td->ddir ^ 1]) - runtime[td->ddir ^ 1] = runtime[td->ddir]; + clear_state = 1; + if (td_read(td) && td->io_bytes[DDIR_READ]) + runtime[DDIR_READ] += utime_since_now(&td->start); + if (td_write(td) && td->io_bytes[DDIR_WRITE]) + runtime[DDIR_WRITE] += utime_since_now(&td->start); + if (td->error || td->terminate) break; if (td->verify == VERIFY_NONE) continue; - clear_io_state(td); + if (clear_io_state(td)) + break; + fio_gettime(&td->start, NULL); do_verify(td); @@ -734,9 +793,11 @@ static void *thread_main(void *data) } update_rusage_stat(td); - fio_gettime(&td->end_time, NULL); - td->runtime[0] = runtime[0] / 1000; - td->runtime[1] = runtime[1] / 1000; + td->ts.runtime[0] = runtime[0] / 1000; + td->ts.runtime[1] = runtime[1] / 1000; + td->ts.total_run_time = mtime_since_now(&td->epoch); + td->ts.io_bytes[0] = td->io_bytes[0]; + td->ts.io_bytes[1] = td->io_bytes[1]; if (td->ts.bw_log) finish_log(td, td->ts.bw_log, "bw"); @@ -752,7 +813,7 @@ static void *thread_main(void *data) } if (exitall_on_terminate) - terminate_threads(td->groupid, 0); + terminate_threads(td->groupid); err: if (td->error) @@ -761,7 +822,10 @@ err: close_ioengine(td); cleanup_io_u(td); td_set_runstate(td, TD_EXITED); - return (void *) td->error; + return (void *) (unsigned long) td->error; +err_sem: + fio_sem_up(startup_sem); + goto err; } /* @@ -784,7 +848,7 @@ static int fork_main(int shmid, int offset) td = data + offset * sizeof(struct thread_data); ret = thread_main(td); shmdt(data); - return (int) ret; + return (int) (unsigned long) ret; } /* @@ -800,66 +864,80 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) */ pending = cputhreads = 0; for_each_td(td, i) { + int flags = 0; + /* * ->io_ops is NULL for a thread that has closed its * io engine */ - if (td->io_ops && td->io_ops->flags & FIO_CPUIO) + if (td->io_ops && !strcmp(td->io_ops->name, "cpuio")) cputhreads++; - if (td->runstate < TD_EXITED) { - /* - * check if someone quit or got killed in an unusual way - */ - ret = waitpid(td->pid, &status, WNOHANG); - if (ret < 0) - perror("waitpid"); - else if ((ret == td->pid) && WIFSIGNALED(status)) { - int sig = WTERMSIG(status); - - log_err("fio: pid=%d, got signal=%d\n", td->pid, sig); + if (!td->pid || td->runstate == TD_REAPED) + continue; + if (td->use_thread) { + if (td->runstate == TD_EXITED) { td_set_runstate(td, TD_REAPED); goto reaped; } + continue; } - if (td->runstate != TD_EXITED) { - if (td->runstate < TD_RUNNING) - pending++; + flags = WNOHANG; + if (td->runstate == TD_EXITED) + flags = 0; - continue; - } + /* + * check if someone quit or got killed in an unusual way + */ + ret = waitpid(td->pid, &status, flags); + if (ret < 0) { + if (errno == ECHILD) { + log_err("fio: pid=%d disappeared %d\n", td->pid, td->runstate); + td_set_runstate(td, TD_REAPED); + goto reaped; + } + perror("waitpid"); + } else if (ret == td->pid) { + if (WIFSIGNALED(status)) { + int sig = WTERMSIG(status); - if (td->error) - exit_value++; + if (sig != SIGQUIT) + log_err("fio: pid=%d, got signal=%d\n", td->pid, sig); + td_set_runstate(td, TD_REAPED); + goto reaped; + } + if (WIFEXITED(status)) { + if (WEXITSTATUS(status) && !td->error) + td->error = WEXITSTATUS(status); - td_set_runstate(td, TD_REAPED); + td_set_runstate(td, TD_REAPED); + goto reaped; + } + } + /* + * thread is not dead, continue + */ + continue; +reaped: if (td->use_thread) { long ret; if (pthread_join(td->thread, (void *) &ret)) - perror("thread_join"); - } else { - int status; - - ret = waitpid(td->pid, &status, 0); - if (ret < 0) - perror("waitpid"); - else if (WIFEXITED(status) && WEXITSTATUS(status)) { - if (!exit_value) - exit_value++; - } + perror("pthread_join"); } -reaped: (*nr_running)--; (*m_rate) -= td->ratemin; (*t_rate) -= td->rate; + + if (td->error) + exit_value++; } if (*nr_running == cputhreads && !pending) - terminate_threads(TERMINATE_ALL, 0); + terminate_threads(TERMINATE_ALL); } /* @@ -875,7 +953,15 @@ static void run_threads(void) return; if (!terse_output) { - printf("Starting %d thread%s\n", thread_number, thread_number > 1 ? "s" : ""); + printf("Starting "); + if (nr_thread) + printf("%d thread%s", nr_thread, nr_thread > 1 ? "s" : ""); + if (nr_process) { + if (nr_thread) + printf(" and "); + printf("%d process%s", nr_process, nr_process > 1 ? "es" : ""); + } + printf("\n"); fflush(stdout); } @@ -911,6 +997,8 @@ static void run_threads(void) init_disk_util(td); } + set_genesis_time(); + while (todo) { struct thread_data *map[MAX_JOBS]; struct timeval this_start; @@ -948,23 +1036,22 @@ static void run_threads(void) */ td_set_runstate(td, TD_CREATED); map[this_jobs++] = td; - fio_sem_init(&startup_sem, 1); nr_started++; if (td->use_thread) { if (pthread_create(&td->thread, NULL, thread_main, td)) { perror("thread_create"); nr_started--; + break; } } else { - if (fork()) - fio_sem_down(&startup_sem); - else { + if (!fork()) { int ret = fork_main(shm_id, i); exit(ret); } } + fio_sem_down(startup_sem); } /* @@ -1019,7 +1106,7 @@ static void run_threads(void) m_rate += td->ratemin; t_rate += td->rate; todo--; - fio_sem_up(&td->mutex); + fio_sem_up(td->mutex); } reap_threads(&nr_running, &t_rate, &m_rate); @@ -1069,6 +1156,10 @@ int main(int argc, char *argv[]) setup_log(&agg_io_log[DDIR_WRITE]); } + startup_sem = fio_sem_init(0); + + set_genesis_time(); + disk_util_timer_arm(); run_threads(); @@ -1081,5 +1172,6 @@ int main(int argc, char *argv[]) } } + fio_sem_remove(startup_sem); return exit_value; }