X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=5358af2c8a8dc7bea5234c329bdf39087679a15f;hp=84819d9f51e996b2a25c35f1da29a62772b99e8b;hb=36167d82e5f49dee91c6d2cd426068edee90e36f;hpb=6ce15a32b28f359b3753ef65d883ab2d824e19f2 diff --git a/fio.c b/fio.c index 84819d9f..5358af2c 100644 --- a/fio.c +++ b/fio.c @@ -26,20 +26,20 @@ #include #include #include +#include #include #include #include #include #include -#include #include #include "fio.h" #include "os.h" -#define MASK (4095) - -#define ALIGN(buf) (char *) (((unsigned long) (buf) + MASK) & ~(MASK)) +static unsigned long page_mask; +#define ALIGN(buf) \ + (char *) (((unsigned long) (buf) + page_mask) & ~page_mask) int groupid = 0; int thread_number = 0; @@ -48,6 +48,9 @@ int temp_stall_ts; static volatile int startup_sem; static volatile int fio_abort; +static int exit_value; + +struct io_log *agg_io_log[2]; #define TERMINATE_ALL (-1) #define JOB_START_TIMEOUT (5 * 1000) @@ -80,11 +83,6 @@ static void sig_handler(int sig) disk_util_timer_arm(); print_thread_status(); break; - case SIGSEGV: - fprintf(stderr, "fio: got segfault, aborting\n"); - terminate_threads(TERMINATE_ALL, 1); - fio_abort = 1; - exit(0); default: printf("\nfio: terminating on signal %d\n", sig); fflush(stdout); @@ -224,23 +222,32 @@ static int fio_io_sync(struct thread_data *td, struct fio_file *f) } ret = td_io_queue(td, io_u); - if (ret) { + if (ret < 0) { td_verror(td, io_u->error); put_io_u(td, io_u); return 1; - } + } else if (ret == FIO_Q_QUEUED) { + ret = td_io_getevents(td, 1, td->cur_depth, NULL); + if (ret < 0) { + td_verror(td, ret); + return 1; + } - ret = td_io_getevents(td, 1, td->cur_depth, NULL); - if (ret < 0) { - td_verror(td, ret); - return 1; - } + icd.nr = ret; + ios_completed(td, &icd); + if (icd.error) { + td_verror(td, icd.error); + return 1; + } + } else if (ret == FIO_Q_COMPLETED) { + if (io_u->error) { + td_verror(td, io_u->error); + return 1; + } - icd.nr = ret; - ios_completed(td, &icd); - if (icd.error) { - td_verror(td, icd.error); - return 1; + init_icd(&icd); + io_completed(td, io_u, &icd); + put_io_u(td, io_u); } return 0; @@ -252,9 +259,8 @@ static int fio_io_sync(struct thread_data *td, struct fio_file *f) */ static void do_verify(struct thread_data *td) { - struct io_u *io_u, *v_io_u = NULL; - struct io_completion_data icd; struct fio_file *f; + struct io_u *io_u; int ret, i; /* @@ -268,78 +274,66 @@ static void do_verify(struct thread_data *td) td_set_runstate(td, TD_VERIFYING); - do { - if (td->terminate) - break; - + io_u = NULL; + while (!td->terminate) { io_u = __get_io_u(td); if (!io_u) break; - if (runtime_exceeded(td, &io_u->start_time)) { - put_io_u(td, io_u); + if (runtime_exceeded(td, &io_u->start_time)) break; - } - if (get_next_verify(td, io_u)) { - put_io_u(td, io_u); + if (get_next_verify(td, io_u)) break; - } - f = get_next_file(td); - if (!f) + if (td_io_prep(td, io_u)) break; - io_u->file = f; +requeue: + ret = td_io_queue(td, io_u); - if (td_io_prep(td, io_u)) { - put_io_u(td, io_u); - break; - } + 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) { + int bytes = io_u->xfer_buflen - io_u->resid; - ret = td_io_queue(td, io_u); - if (ret) { - td_verror(td, io_u->error); - put_io_u(td, io_u); + io_u->xfer_buflen = io_u->resid; + io_u->xfer_buf += bytes; + goto requeue; + } + if (do_io_u_verify(td, &io_u)) { + ret = -EIO; + break; + } + continue; + case FIO_Q_QUEUED: + break; + default: + assert(ret < 0); + td_verror(td, ret); break; } /* - * we have one pending to verify, do that while - * we are doing io on the next one + * We get here for a queued request, in the future we + * want to later make this take full advantage of + * keeping IO in flight while verifying others. */ - if (do_io_u_verify(td, &v_io_u)) - break; - ret = td_io_getevents(td, 1, 1, NULL); - if (ret != 1) { - if (ret < 0) - td_verror(td, ret); + if (ret < 0) break; - } - v_io_u = td->io_ops->event(td, 0); - icd.nr = 1; - icd.error = 0; - fio_gettime(&icd.time, NULL); - io_completed(td, v_io_u, &icd); + assert(ret == 1); + io_u = td->io_ops->event(td, 0); - if (icd.error) { - td_verror(td, icd.error); - put_io_u(td, v_io_u); - v_io_u = NULL; + if (do_io_u_verify(td, &io_u)) break; - } - - /* - * if we can't submit more io, we need to verify now - */ - if (queue_full(td) && do_io_u_verify(td, &v_io_u)) - break; - - } while (1); + } - do_io_u_verify(td, &v_io_u); + if (io_u) + put_io_u(td, io_u); if (td->cur_depth) cleanup_pending_aio(td); @@ -386,7 +380,7 @@ static void do_io(struct thread_data *td) td_set_runstate(td, TD_RUNNING); - while (td->this_io_bytes[td->ddir] < td->io_size) { + while ((td->this_io_bytes[0] + td->this_io_bytes[1]) < td->io_size) { struct timespec *timeout; int min_evts = 0; struct io_u *io_u; @@ -403,38 +397,65 @@ static void do_io(struct thread_data *td) break; memcpy(&s, &io_u->start_time, sizeof(s)); - +requeue: ret = td_io_queue(td, io_u); - if (ret) { - td_verror(td, io_u->error); + + 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) { + int bytes = io_u->xfer_buflen - io_u->resid; + + io_u->xfer_buflen = io_u->resid; + io_u->xfer_buf += bytes; + goto requeue; + } + init_icd(&icd); + io_completed(td, io_u, &icd); + put_io_u(td, io_u); + break; + case FIO_Q_QUEUED: + break; + default: + assert(ret < 0); put_io_u(td, io_u); break; } + if (ret < 0) + break; + add_slat_sample(td, io_u->ddir, mtime_since(&io_u->start_time, &io_u->issue_time)); - if (td->cur_depth < td->iodepth) { - struct timespec ts = { .tv_sec = 0, .tv_nsec = 0}; + if (ret == FIO_Q_QUEUED) { + if (td->cur_depth < td->iodepth) { + struct timespec ts; - timeout = &ts; - min_evts = 0; - } else { - timeout = NULL; - min_evts = 1; - } + ts.tv_sec = 0; + ts.tv_nsec = 0; + timeout = &ts; + min_evts = 0; + } else { + timeout = NULL; + min_evts = 1; + } - ret = td_io_getevents(td, min_evts, td->cur_depth, timeout); - if (ret < 0) { - td_verror(td, ret); - break; - } else if (!ret) - continue; + ret = td_io_getevents(td, min_evts, td->cur_depth, timeout); + if (ret < 0) { + td_verror(td, ret); + break; + } else if (!ret) + continue; - icd.nr = ret; - ios_completed(td, &icd); - if (icd.error) { - td_verror(td, icd.error); - break; + icd.nr = ret; + ios_completed(td, &icd); + if (icd.error) { + td_verror(td, icd.error); + break; + } } /* @@ -449,7 +470,7 @@ static void do_io(struct thread_data *td) if (check_min_rate(td, &icd.time)) { if (exitall_on_terminate) terminate_threads(td->groupid, 0); - td_verror(td, ENOMEM); + td_verror(td, ENODATA); break; } @@ -460,8 +481,16 @@ static void do_io(struct thread_data *td) unsigned long long b; b = td->io_blocks[0] + td->io_blocks[1]; - if (!(b % td->thinktime_blocks)) - usec_sleep(td, td->thinktime); + if (!(b % td->thinktime_blocks)) { + int left; + + if (td->thinktime_spin) + __usec_sleep(td->thinktime_spin); + + left = td->thinktime - td->thinktime_spin; + if (left) + usec_sleep(td, left); + } } } @@ -526,7 +555,7 @@ static int init_io_u(struct thread_data *td) if (td->mem_type == MEM_SHMHUGE || td->mem_type == MEM_MMAPHUGE) td->orig_buffer_size = (td->orig_buffer_size + td->hugepage_size - 1) & ~(td->hugepage_size - 1); else - td->orig_buffer_size += MASK; + td->orig_buffer_size += page_mask; if (allocate_io_mem(td)) return 1; @@ -645,9 +674,6 @@ static void *thread_main(void *data) goto err; } - if (td_io_init(td)) - goto err; - if (init_iolog(td)) goto err; @@ -678,8 +704,17 @@ static void *thread_main(void *data) if (open_files(td)) goto err; - if (td->exec_prerun) - system(td->exec_prerun); + /* + * 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 (td->exec_prerun) { + if (system(td->exec_prerun) < 0) + goto err; + } fio_gettime(&td->epoch, NULL); getrusage(RUSAGE_SELF, &td->ru_start); @@ -734,40 +769,45 @@ static void *thread_main(void *data) finish_log(td, td->clat_log, "clat"); if (td->write_iolog_file) write_iolog_close(td); - if (td->exec_postrun) - system(td->exec_postrun); + if (td->exec_postrun) { + if (system(td->exec_postrun) < 0) + log_err("fio: postrun %s failed\n", td->exec_postrun); + } if (exitall_on_terminate) terminate_threads(td->groupid, 0); err: + if (td->error) + printf("fio: pid=%d, err=%d/%s\n", td->pid, td->error, td->verror); close_files(td); close_ioengine(td); cleanup_io_u(td); td_set_runstate(td, TD_EXITED); - return NULL; - + return (void *) td->error; } /* * We cannot pass the td data into a forked process, so attach the td and * pass it to the thread worker. */ -static void *fork_main(int shmid, int offset) +static int fork_main(int shmid, int offset) { struct thread_data *td; - void *data; + void *data, *ret; data = shmat(shmid, NULL, 0); if (data == (void *) -1) { + int __err = errno; + perror("shmat"); - return NULL; + return __err; } td = data + offset * sizeof(struct thread_data); - thread_main(td); + ret = thread_main(td); shmdt(data); - return NULL; + return (int) ret; } /* @@ -776,7 +816,7 @@ static void *fork_main(int shmid, int offset) static void reap_threads(int *nr_running, int *t_rate, int *m_rate) { struct thread_data *td; - int i, cputhreads, pending; + int i, cputhreads, pending, status, ret; /* * reap exited threads (TD_EXITED -> TD_REAPED) @@ -790,6 +830,22 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) if (td->io_ops && td->io_ops->flags & FIO_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); + td_set_runstate(td, TD_REAPED); + goto reaped; + } + } + if (td->runstate != TD_EXITED) { if (td->runstate < TD_RUNNING) pending++; @@ -797,6 +853,9 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) continue; } + if (td->error) + exit_value++; + td_set_runstate(td, TD_REAPED); if (td->use_thread) { @@ -804,9 +863,19 @@ static void reap_threads(int *nr_running, int *t_rate, int *m_rate) if (pthread_join(td->thread, (void *) &ret)) perror("thread_join"); - } else - waitpid(td->pid, NULL, 0); + } 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++; + } + } +reaped: (*nr_running)--; (*m_rate) -= td->ratemin; (*t_rate) -= td->rate; @@ -835,7 +904,6 @@ static void run_threads(void) signal(SIGINT, sig_handler); signal(SIGALRM, sig_handler); - signal(SIGSEGV, sig_handler); todo = thread_number; nr_running = 0; @@ -856,6 +924,9 @@ static void run_threads(void) * client data interspersed on disk */ if (setup_files(td)) { + exit_value++; + if (td->error) + log_err("fio: pid=%d, err=%d/%s\n", td->pid, td->error, td->verror); td_set_runstate(td, TD_REAPED); todo--; } @@ -912,8 +983,9 @@ static void run_threads(void) if (fork()) fio_sem_down(&startup_sem); else { - fork_main(shm_id, i); - exit(0); + int ret = fork_main(shm_id, i); + + exit(ret); } } } @@ -990,6 +1062,15 @@ static void run_threads(void) int main(int argc, char *argv[]) { + long ps; + + /* + * We need locale for number printing, if it isn't set then just + * go with the US format. + */ + if (!getenv("LC_NUMERIC")) + setlocale(LC_NUMERIC, "en_US"); + if (parse_options(argc, argv)) return 1; @@ -998,12 +1079,30 @@ int main(int argc, char *argv[]) return 1; } + ps = sysconf(_SC_PAGESIZE); + if (ps < 0) { + log_err("Failed to get page size\n"); + return 1; + } + + page_mask = ps - 1; + + if (write_bw_log) { + setup_log(&agg_io_log[DDIR_READ]); + setup_log(&agg_io_log[DDIR_WRITE]); + } + disk_util_timer_arm(); run_threads(); - if (!fio_abort) + if (!fio_abort) { show_run_stats(); + if (write_bw_log) { + __finish_log(agg_io_log[DDIR_READ],"agg-read_bw.log"); + __finish_log(agg_io_log[DDIR_WRITE],"agg-write_bw.log"); + } + } - return 0; + return exit_value; }