io_u.c revision 8fd15a9a8d64deae4c2f13b02e1df7e23ea3cafb
1#include <unistd.h> 2#include <fcntl.h> 3#include <string.h> 4#include <signal.h> 5#include <time.h> 6#include <assert.h> 7 8#include "fio.h" 9#include "os.h" 10 11/* 12 * Change this define to play with the timeout handling 13 */ 14#undef FIO_USE_TIMEOUT 15 16struct io_completion_data { 17 int nr; /* input */ 18 19 int error; /* output */ 20 unsigned long bytes_done[2]; /* output */ 21 struct timeval time; /* output */ 22}; 23 24/* 25 * The ->file_map[] contains a map of blocks we have or have not done io 26 * to yet. Used to make sure we cover the entire range in a fair fashion. 27 */ 28static int random_map_free(struct thread_data *td, struct fio_file *f, 29 unsigned long long block) 30{ 31 unsigned int idx = RAND_MAP_IDX(td, f, block); 32 unsigned int bit = RAND_MAP_BIT(td, f, block); 33 34 return (f->file_map[idx] & (1UL << bit)) == 0; 35} 36 37/* 38 * Mark a given offset as used in the map. 39 */ 40static void mark_random_map(struct thread_data *td, struct io_u *io_u) 41{ 42 unsigned int min_bs = td->o.rw_min_bs; 43 struct fio_file *f = io_u->file; 44 unsigned long long block; 45 unsigned int blocks; 46 unsigned int nr_blocks; 47 48 block = io_u->offset / (unsigned long long) min_bs; 49 blocks = 0; 50 nr_blocks = (io_u->buflen + min_bs - 1) / min_bs; 51 52 while (blocks < nr_blocks) { 53 unsigned int idx, bit; 54 55 /* 56 * If we have a mixed random workload, we may 57 * encounter blocks we already did IO to. 58 */ 59 if (!td->o.ddir_nr && !random_map_free(td, f, block)) 60 break; 61 62 idx = RAND_MAP_IDX(td, f, block); 63 bit = RAND_MAP_BIT(td, f, block); 64 65 fio_assert(td, idx < f->num_maps); 66 67 f->file_map[idx] |= (1UL << bit); 68 block++; 69 blocks++; 70 } 71 72 if ((blocks * min_bs) < io_u->buflen) 73 io_u->buflen = blocks * min_bs; 74} 75 76/* 77 * Return the next free block in the map. 78 */ 79static int get_next_free_block(struct thread_data *td, struct fio_file *f, 80 unsigned long long *b) 81{ 82 int i; 83 84 i = f->last_free_lookup; 85 *b = (i * BLOCKS_PER_MAP); 86 while ((*b) * td->o.rw_min_bs < f->real_file_size) { 87 if (f->file_map[i] != -1UL) { 88 *b += ffz(f->file_map[i]); 89 f->last_free_lookup = i; 90 return 0; 91 } 92 93 *b += BLOCKS_PER_MAP; 94 i++; 95 } 96 97 return 1; 98} 99 100static int get_next_rand_offset(struct thread_data *td, struct fio_file *f, 101 int ddir, unsigned long long *b) 102{ 103 unsigned long long max_blocks = f->file_size / td->o.min_bs[ddir]; 104 unsigned long long r, rb; 105 int loops = 5; 106 107 do { 108 r = os_random_long(&td->random_state); 109 if (!max_blocks) 110 *b = 0; 111 else 112 *b = ((max_blocks - 1) * r / (unsigned long long) (RAND_MAX+1.0)); 113 if (td->o.norandommap) 114 break; 115 rb = *b + (f->file_offset / td->o.min_bs[ddir]); 116 loops--; 117 } while (!random_map_free(td, f, rb) && loops); 118 119 /* 120 * if we failed to retrieve a truly random offset within 121 * the loops assigned, see if there are free ones left at all 122 */ 123 if (!loops && get_next_free_block(td, f, b)) 124 return 1; 125 126 return 0; 127} 128 129/* 130 * For random io, generate a random new block and see if it's used. Repeat 131 * until we find a free one. For sequential io, just return the end of 132 * the last io issued. 133 */ 134static int get_next_offset(struct thread_data *td, struct io_u *io_u) 135{ 136 struct fio_file *f = io_u->file; 137 const int ddir = io_u->ddir; 138 unsigned long long b; 139 140 if (td_random(td) && (td->o.ddir_nr && !--td->ddir_nr)) { 141 td->ddir_nr = td->o.ddir_nr; 142 143 if (get_next_rand_offset(td, f, ddir, &b)) 144 return 1; 145 } else 146 b = f->last_pos / td->o.min_bs[ddir]; 147 148 io_u->offset = (b * td->o.min_bs[ddir]) + f->file_offset; 149 if (io_u->offset >= f->real_file_size) 150 return 1; 151 152 return 0; 153} 154 155static unsigned int get_next_buflen(struct thread_data *td, struct io_u *io_u) 156{ 157 struct fio_file *f = io_u->file; 158 const int ddir = io_u->ddir; 159 unsigned int buflen; 160 long r; 161 162 if (td->o.min_bs[ddir] == td->o.max_bs[ddir]) 163 buflen = td->o.min_bs[ddir]; 164 else { 165 r = os_random_long(&td->bsrange_state); 166 buflen = (unsigned int) (1 + (double) (td->o.max_bs[ddir] - 1) * r / (RAND_MAX + 1.0)); 167 if (!td->o.bs_unaligned) 168 buflen = (buflen + td->o.min_bs[ddir] - 1) & ~(td->o.min_bs[ddir] - 1); 169 } 170 171 while (buflen + io_u->offset > f->real_file_size) { 172 if (buflen == td->o.min_bs[ddir]) { 173 if (!td->o.odirect) { 174 assert(io_u->offset <= f->real_file_size); 175 buflen = f->real_file_size - io_u->offset; 176 return buflen; 177 } 178 return 0; 179 } 180 181 buflen = td->o.min_bs[ddir]; 182 } 183 184 return buflen; 185} 186 187static void set_rwmix_bytes(struct thread_data *td) 188{ 189 unsigned long long rbytes; 190 unsigned int diff; 191 192 /* 193 * we do time or byte based switch. this is needed because 194 * buffered writes may issue a lot quicker than they complete, 195 * whereas reads do not. 196 */ 197 rbytes = td->io_bytes[td->rwmix_ddir] - td->rwmix_bytes; 198 diff = td->o.rwmix[td->rwmix_ddir ^ 1]; 199 200 td->rwmix_bytes = td->io_bytes[td->rwmix_ddir] + (rbytes * ((100 - diff)) / diff); 201} 202 203static inline enum fio_ddir get_rand_ddir(struct thread_data *td) 204{ 205 unsigned int v; 206 long r; 207 208 r = os_random_long(&td->rwmix_state); 209 v = 1 + (int) (100.0 * (r / (RAND_MAX + 1.0))); 210 if (v < td->o.rwmix[DDIR_READ]) 211 return DDIR_READ; 212 213 return DDIR_WRITE; 214} 215 216/* 217 * Return the data direction for the next io_u. If the job is a 218 * mixed read/write workload, check the rwmix cycle and switch if 219 * necessary. 220 */ 221static enum fio_ddir get_rw_ddir(struct thread_data *td) 222{ 223 if (td_rw(td)) { 224 struct timeval now; 225 unsigned long elapsed; 226 unsigned int cycle; 227 228 fio_gettime(&now, NULL); 229 elapsed = mtime_since_now(&td->rwmix_switch); 230 231 /* 232 * if this is the first cycle, make it shorter 233 */ 234 cycle = td->o.rwmixcycle; 235 if (!td->rwmix_bytes) 236 cycle /= 10; 237 238 /* 239 * Check if it's time to seed a new data direction. 240 */ 241 if (elapsed >= cycle || 242 td->io_bytes[td->rwmix_ddir] >= td->rwmix_bytes) { 243 unsigned long long max_bytes; 244 enum fio_ddir ddir; 245 246 /* 247 * Put a top limit on how many bytes we do for 248 * one data direction, to avoid overflowing the 249 * ranges too much 250 */ 251 ddir = get_rand_ddir(td); 252 max_bytes = td->this_io_bytes[ddir]; 253 if (max_bytes >= (td->io_size * td->o.rwmix[ddir] / 100)) { 254 if (!td->rw_end_set[ddir]) { 255 td->rw_end_set[ddir] = 1; 256 memcpy(&td->rw_end[ddir], &now, sizeof(now)); 257 } 258 ddir ^= 1; 259 } 260 261 if (ddir != td->rwmix_ddir) 262 set_rwmix_bytes(td); 263 264 td->rwmix_ddir = ddir; 265 memcpy(&td->rwmix_switch, &now, sizeof(now)); 266 } 267 return td->rwmix_ddir; 268 } else if (td_read(td)) 269 return DDIR_READ; 270 else 271 return DDIR_WRITE; 272} 273 274void put_io_u(struct thread_data *td, struct io_u *io_u) 275{ 276 assert((io_u->flags & IO_U_F_FREE) == 0); 277 io_u->flags |= IO_U_F_FREE; 278 279 io_u->file = NULL; 280 list_del(&io_u->list); 281 list_add(&io_u->list, &td->io_u_freelist); 282 td->cur_depth--; 283} 284 285void requeue_io_u(struct thread_data *td, struct io_u **io_u) 286{ 287 struct io_u *__io_u = *io_u; 288 289 __io_u->flags |= IO_U_F_FREE; 290 __io_u->flags &= ~IO_U_F_FLIGHT; 291 292 list_del(&__io_u->list); 293 list_add_tail(&__io_u->list, &td->io_u_requeues); 294 td->cur_depth--; 295 *io_u = NULL; 296} 297 298static int fill_io_u(struct thread_data *td, struct io_u *io_u) 299{ 300 /* 301 * If using an iolog, grab next piece if any available. 302 */ 303 if (td->o.read_iolog) 304 return read_iolog_get(td, io_u); 305 306 /* 307 * see if it's time to sync 308 */ 309 if (td->o.fsync_blocks && 310 !(td->io_issues[DDIR_WRITE] % td->o.fsync_blocks) && 311 td->io_issues[DDIR_WRITE] && should_fsync(td)) { 312 io_u->ddir = DDIR_SYNC; 313 return 0; 314 } 315 316 io_u->ddir = get_rw_ddir(td); 317 318 /* 319 * No log, let the seq/rand engine retrieve the next buflen and 320 * position. 321 */ 322 if (get_next_offset(td, io_u)) 323 return 1; 324 325 io_u->buflen = get_next_buflen(td, io_u); 326 if (!io_u->buflen) 327 return 1; 328 329 /* 330 * mark entry before potentially trimming io_u 331 */ 332 if (td_random(td) && !td->o.norandommap) 333 mark_random_map(td, io_u); 334 335 /* 336 * If using a write iolog, store this entry. 337 */ 338 if (td->o.write_iolog_file) 339 write_iolog_put(td, io_u); 340 341 return 0; 342} 343 344void io_u_mark_depth(struct thread_data *td, struct io_u *io_u) 345{ 346 int index = 0; 347 348 if (io_u->ddir == DDIR_SYNC) 349 return; 350 351 switch (td->cur_depth) { 352 default: 353 index++; 354 case 32 ... 63: 355 index++; 356 case 16 ... 31: 357 index++; 358 case 8 ... 15: 359 index++; 360 case 4 ... 7: 361 index++; 362 case 2 ... 3: 363 index++; 364 case 1: 365 break; 366 } 367 368 td->ts.io_u_map[index]++; 369 td->ts.total_io_u[io_u->ddir]++; 370} 371 372static void io_u_mark_latency(struct thread_data *td, unsigned long msec) 373{ 374 int index = 0; 375 376 switch (msec) { 377 default: 378 index++; 379 case 1000 ... 1999: 380 index++; 381 case 750 ... 999: 382 index++; 383 case 500 ... 749: 384 index++; 385 case 250 ... 499: 386 index++; 387 case 100 ... 249: 388 index++; 389 case 50 ... 99: 390 index++; 391 case 20 ... 49: 392 index++; 393 case 10 ... 19: 394 index++; 395 case 4 ... 9: 396 index++; 397 case 2 ... 3: 398 index++; 399 case 0 ... 1: 400 break; 401 } 402 403 td->ts.io_u_lat[index]++; 404} 405 406/* 407 * Get next file to service by choosing one at random 408 */ 409static struct fio_file *get_next_file_rand(struct thread_data *td, int goodf, 410 int badf) 411{ 412 struct fio_file *f; 413 int fno; 414 415 do { 416 long r = os_random_long(&td->next_file_state); 417 418 fno = (unsigned int) ((double) td->o.nr_files * (r / (RAND_MAX + 1.0))); 419 f = &td->files[fno]; 420 421 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf)) 422 return f; 423 } while (1); 424} 425 426/* 427 * Get next file to service by doing round robin between all available ones 428 */ 429static struct fio_file *get_next_file_rr(struct thread_data *td, int goodf, 430 int badf) 431{ 432 unsigned int old_next_file = td->next_file; 433 struct fio_file *f; 434 435 do { 436 f = &td->files[td->next_file]; 437 438 td->next_file++; 439 if (td->next_file >= td->o.nr_files) 440 td->next_file = 0; 441 442 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf)) 443 break; 444 445 f = NULL; 446 } while (td->next_file != old_next_file); 447 448 return f; 449} 450 451static struct fio_file *get_next_file(struct thread_data *td) 452{ 453 struct fio_file *f; 454 455 assert(td->o.nr_files <= td->files_index); 456 457 if (!td->nr_open_files) 458 return NULL; 459 460 f = td->file_service_file; 461 if (f && (f->flags & FIO_FILE_OPEN) && td->file_service_left--) 462 return f; 463 464 if (td->o.file_service_type == FIO_FSERVICE_RR) 465 f = get_next_file_rr(td, FIO_FILE_OPEN, FIO_FILE_CLOSING); 466 else 467 f = get_next_file_rand(td, FIO_FILE_OPEN, FIO_FILE_CLOSING); 468 469 td->file_service_file = f; 470 td->file_service_left = td->file_service_nr - 1; 471 return f; 472} 473 474static struct fio_file *find_next_new_file(struct thread_data *td) 475{ 476 struct fio_file *f; 477 478 if (td->o.file_service_type == FIO_FSERVICE_RR) 479 f = get_next_file_rr(td, 0, FIO_FILE_OPEN); 480 else 481 f = get_next_file_rand(td, 0, FIO_FILE_OPEN); 482 483 return f; 484} 485 486struct io_u *__get_io_u(struct thread_data *td) 487{ 488 struct io_u *io_u = NULL; 489 490 if (!list_empty(&td->io_u_requeues)) 491 io_u = list_entry(td->io_u_requeues.next, struct io_u, list); 492 else if (!queue_full(td)) { 493 io_u = list_entry(td->io_u_freelist.next, struct io_u, list); 494 495 io_u->buflen = 0; 496 io_u->resid = 0; 497 io_u->file = NULL; 498 io_u->end_io = NULL; 499 } 500 501 if (io_u) { 502 assert(io_u->flags & IO_U_F_FREE); 503 io_u->flags &= ~IO_U_F_FREE; 504 505 io_u->error = 0; 506 list_del(&io_u->list); 507 list_add(&io_u->list, &td->io_u_busylist); 508 td->cur_depth++; 509 } 510 511 return io_u; 512} 513 514/* 515 * Return an io_u to be processed. Gets a buflen and offset, sets direction, 516 * etc. The returned io_u is fully ready to be prepped and submitted. 517 */ 518struct io_u *get_io_u(struct thread_data *td) 519{ 520 struct fio_file *f; 521 struct io_u *io_u; 522 int ret; 523 524 io_u = __get_io_u(td); 525 if (!io_u) 526 return NULL; 527 528 /* 529 * from a requeue, io_u already setup 530 */ 531 if (io_u->file) 532 goto out; 533 534 do { 535 f = get_next_file(td); 536 if (!f) { 537 put_io_u(td, io_u); 538 return NULL; 539 } 540 541set_file: 542 io_u->file = f; 543 544 if (!fill_io_u(td, io_u)) 545 break; 546 547 /* 548 * No more to do for this file, close it 549 */ 550 io_u->file = NULL; 551 td_io_close_file(td, f); 552 553 /* 554 * probably not the right place to do this, but see 555 * if we need to open a new file 556 */ 557 if (td->nr_open_files < td->o.open_files && 558 td->o.open_files != td->o.nr_files) { 559 f = find_next_new_file(td); 560 561 if (!f || (ret = td_io_open_file(td, f))) { 562 put_io_u(td, io_u); 563 return NULL; 564 } 565 goto set_file; 566 } 567 } while (1); 568 569 if (td->zone_bytes >= td->o.zone_size) { 570 td->zone_bytes = 0; 571 f->last_pos += td->o.zone_skip; 572 } 573 574 if (io_u->buflen + io_u->offset > f->real_file_size) { 575 if (td->io_ops->flags & FIO_RAWIO) { 576 put_io_u(td, io_u); 577 return NULL; 578 } 579 580 io_u->buflen = f->real_file_size - io_u->offset; 581 } 582 583 if (io_u->ddir != DDIR_SYNC) { 584 if (!io_u->buflen) { 585 put_io_u(td, io_u); 586 return NULL; 587 } 588 589 f->last_pos = io_u->offset + io_u->buflen; 590 591 if (td->o.verify != VERIFY_NONE) 592 populate_verify_io_u(td, io_u); 593 } 594 595 /* 596 * Set io data pointers. 597 */ 598out: 599 io_u->xfer_buf = io_u->buf; 600 io_u->xfer_buflen = io_u->buflen; 601 602 if (td_io_prep(td, io_u)) { 603 put_io_u(td, io_u); 604 return NULL; 605 } 606 607 fio_gettime(&io_u->start_time, NULL); 608 return io_u; 609} 610 611void io_u_log_error(struct thread_data *td, struct io_u *io_u) 612{ 613 const char *msg[] = { "read", "write", "sync" }; 614 615 log_err("fio: io_u error"); 616 617 if (io_u->file) 618 log_err(" on file %s", io_u->file->file_name); 619 620 log_err(": %s\n", strerror(io_u->error)); 621 622 log_err(" %s offset=%llu, buflen=%lu\n", msg[io_u->ddir], io_u->offset, io_u->xfer_buflen); 623 624 if (!td->error) 625 td_verror(td, io_u->error, "io_u error"); 626} 627 628static void io_completed(struct thread_data *td, struct io_u *io_u, 629 struct io_completion_data *icd) 630{ 631 unsigned long msec; 632 633 assert(io_u->flags & IO_U_F_FLIGHT); 634 io_u->flags &= ~IO_U_F_FLIGHT; 635 636 put_file(td, io_u->file); 637 638 if (io_u->ddir == DDIR_SYNC) { 639 td->last_was_sync = 1; 640 return; 641 } 642 643 td->last_was_sync = 0; 644 645 if (!io_u->error) { 646 unsigned int bytes = io_u->buflen - io_u->resid; 647 const enum fio_ddir idx = io_u->ddir; 648 int ret; 649 650 td->io_blocks[idx]++; 651 td->io_bytes[idx] += bytes; 652 td->zone_bytes += bytes; 653 td->this_io_bytes[idx] += bytes; 654 655 io_u->file->last_completed_pos = io_u->offset + io_u->buflen; 656 657 msec = mtime_since(&io_u->issue_time, &icd->time); 658 659 add_clat_sample(td, idx, msec); 660 add_bw_sample(td, idx, &icd->time); 661 io_u_mark_latency(td, msec); 662 663 if ((td_rw(td) || td_write(td)) && idx == DDIR_WRITE && 664 td->o.verify != VERIFY_NONE) 665 log_io_piece(td, io_u); 666 667 icd->bytes_done[idx] += bytes; 668 669 if (io_u->end_io) { 670 ret = io_u->end_io(td, io_u); 671 if (ret && !icd->error) 672 icd->error = ret; 673 } 674 } else { 675 icd->error = io_u->error; 676 io_u_log_error(td, io_u); 677 } 678} 679 680static void init_icd(struct io_completion_data *icd, int nr) 681{ 682 fio_gettime(&icd->time, NULL); 683 684 icd->nr = nr; 685 686 icd->error = 0; 687 icd->bytes_done[0] = icd->bytes_done[1] = 0; 688} 689 690static void ios_completed(struct thread_data *td, 691 struct io_completion_data *icd) 692{ 693 struct io_u *io_u; 694 int i; 695 696 for (i = 0; i < icd->nr; i++) { 697 io_u = td->io_ops->event(td, i); 698 699 io_completed(td, io_u, icd); 700 put_io_u(td, io_u); 701 } 702} 703 704/* 705 * Complete a single io_u for the sync engines. 706 */ 707long io_u_sync_complete(struct thread_data *td, struct io_u *io_u) 708{ 709 struct io_completion_data icd; 710 711 init_icd(&icd, 1); 712 io_completed(td, io_u, &icd); 713 put_io_u(td, io_u); 714 715 if (!icd.error) 716 return icd.bytes_done[0] + icd.bytes_done[1]; 717 718 td_verror(td, icd.error, "io_u_sync_complete"); 719 return -1; 720} 721 722/* 723 * Called to complete min_events number of io for the async engines. 724 */ 725long io_u_queued_complete(struct thread_data *td, int min_events) 726{ 727 struct io_completion_data icd; 728 struct timespec *tvp = NULL; 729 int ret; 730 struct timespec ts = { .tv_sec = 0, .tv_nsec = 0, }; 731 732 if (!min_events) 733 tvp = &ts; 734 735 ret = td_io_getevents(td, min_events, td->cur_depth, tvp); 736 if (ret < 0) { 737 td_verror(td, -ret, "td_io_getevents"); 738 return ret; 739 } else if (!ret) 740 return ret; 741 742 init_icd(&icd, ret); 743 ios_completed(td, &icd); 744 if (!icd.error) 745 return icd.bytes_done[0] + icd.bytes_done[1]; 746 747 td_verror(td, icd.error, "io_u_queued_complete"); 748 return -1; 749} 750 751/* 752 * Call when io_u is really queued, to update the submission latency. 753 */ 754void io_u_queued(struct thread_data *td, struct io_u *io_u) 755{ 756 unsigned long slat_time; 757 758 slat_time = mtime_since(&io_u->start_time, &io_u->issue_time); 759 add_slat_sample(td, io_u->ddir, slat_time); 760} 761 762#ifdef FIO_USE_TIMEOUT 763void io_u_set_timeout(struct thread_data *td) 764{ 765 assert(td->cur_depth); 766 767 td->timer.it_interval.tv_sec = 0; 768 td->timer.it_interval.tv_usec = 0; 769 td->timer.it_value.tv_sec = IO_U_TIMEOUT + IO_U_TIMEOUT_INC; 770 td->timer.it_value.tv_usec = 0; 771 setitimer(ITIMER_REAL, &td->timer, NULL); 772 fio_gettime(&td->timeout_end, NULL); 773} 774 775static void io_u_dump(struct io_u *io_u) 776{ 777 unsigned long t_start = mtime_since_now(&io_u->start_time); 778 unsigned long t_issue = mtime_since_now(&io_u->issue_time); 779 780 log_err("io_u=%p, t_start=%lu, t_issue=%lu\n", io_u, t_start, t_issue); 781 log_err(" buf=%p/%p, len=%lu/%lu, offset=%llu\n", io_u->buf, io_u->xfer_buf, io_u->buflen, io_u->xfer_buflen, io_u->offset); 782 log_err(" ddir=%d, fname=%s\n", io_u->ddir, io_u->file->file_name); 783} 784#else 785void io_u_set_timeout(struct thread_data fio_unused *td) 786{ 787} 788#endif 789 790#ifdef FIO_USE_TIMEOUT 791static void io_u_timeout_handler(int fio_unused sig) 792{ 793 struct thread_data *td, *__td; 794 pid_t pid = getpid(); 795 struct list_head *entry; 796 struct io_u *io_u; 797 int i; 798 799 log_err("fio: io_u timeout\n"); 800 801 /* 802 * TLS would be nice... 803 */ 804 td = NULL; 805 for_each_td(__td, i) { 806 if (__td->pid == pid) { 807 td = __td; 808 break; 809 } 810 } 811 812 if (!td) { 813 log_err("fio: io_u timeout, can't find job\n"); 814 exit(1); 815 } 816 817 if (!td->cur_depth) { 818 log_err("fio: timeout without pending work?\n"); 819 return; 820 } 821 822 log_err("fio: io_u timeout: job=%s, pid=%d\n", td->o.name, td->pid); 823 824 list_for_each(entry, &td->io_u_busylist) { 825 io_u = list_entry(entry, struct io_u, list); 826 827 io_u_dump(io_u); 828 } 829 830 td_verror(td, ETIMEDOUT, "io_u timeout"); 831 exit(1); 832} 833#endif 834 835void io_u_init_timeout(void) 836{ 837#ifdef FIO_USE_TIMEOUT 838 signal(SIGALRM, io_u_timeout_handler); 839#endif 840} 841