io_u.c revision c38e946828472daf5cd0450401a7aba06cda7f60
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 goto out; 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 */ 338out: 339 if (td->o.write_iolog_file) 340 write_iolog_put(td, io_u); 341 342 return 0; 343} 344 345void io_u_mark_depth(struct thread_data *td, struct io_u *io_u) 346{ 347 int index = 0; 348 349 if (io_u->ddir == DDIR_SYNC) 350 return; 351 352 switch (td->cur_depth) { 353 default: 354 index++; 355 case 32 ... 63: 356 index++; 357 case 16 ... 31: 358 index++; 359 case 8 ... 15: 360 index++; 361 case 4 ... 7: 362 index++; 363 case 2 ... 3: 364 index++; 365 case 1: 366 break; 367 } 368 369 td->ts.io_u_map[index]++; 370 td->ts.total_io_u[io_u->ddir]++; 371} 372 373static void io_u_mark_latency(struct thread_data *td, unsigned long msec) 374{ 375 int index = 0; 376 377 switch (msec) { 378 default: 379 index++; 380 case 1000 ... 1999: 381 index++; 382 case 750 ... 999: 383 index++; 384 case 500 ... 749: 385 index++; 386 case 250 ... 499: 387 index++; 388 case 100 ... 249: 389 index++; 390 case 50 ... 99: 391 index++; 392 case 20 ... 49: 393 index++; 394 case 10 ... 19: 395 index++; 396 case 4 ... 9: 397 index++; 398 case 2 ... 3: 399 index++; 400 case 0 ... 1: 401 break; 402 } 403 404 td->ts.io_u_lat[index]++; 405} 406 407/* 408 * Get next file to service by choosing one at random 409 */ 410static struct fio_file *get_next_file_rand(struct thread_data *td, int goodf, 411 int badf) 412{ 413 struct fio_file *f; 414 int fno; 415 416 do { 417 long r = os_random_long(&td->next_file_state); 418 419 fno = (unsigned int) ((double) td->o.nr_files * (r / (RAND_MAX + 1.0))); 420 f = &td->files[fno]; 421 422 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf)) 423 return f; 424 } while (1); 425} 426 427/* 428 * Get next file to service by doing round robin between all available ones 429 */ 430static struct fio_file *get_next_file_rr(struct thread_data *td, int goodf, 431 int badf) 432{ 433 unsigned int old_next_file = td->next_file; 434 struct fio_file *f; 435 436 do { 437 f = &td->files[td->next_file]; 438 439 td->next_file++; 440 if (td->next_file >= td->o.nr_files) 441 td->next_file = 0; 442 443 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf)) 444 break; 445 446 f = NULL; 447 } while (td->next_file != old_next_file); 448 449 return f; 450} 451 452static struct fio_file *get_next_file(struct thread_data *td) 453{ 454 struct fio_file *f; 455 456 assert(td->o.nr_files <= td->files_index); 457 458 if (!td->nr_open_files) 459 return NULL; 460 461 f = td->file_service_file; 462 if (f && (f->flags & FIO_FILE_OPEN) && td->file_service_left--) 463 return f; 464 465 if (td->o.file_service_type == FIO_FSERVICE_RR) 466 f = get_next_file_rr(td, FIO_FILE_OPEN, FIO_FILE_CLOSING); 467 else 468 f = get_next_file_rand(td, FIO_FILE_OPEN, FIO_FILE_CLOSING); 469 470 td->file_service_file = f; 471 td->file_service_left = td->file_service_nr - 1; 472 return f; 473} 474 475static struct fio_file *find_next_new_file(struct thread_data *td) 476{ 477 struct fio_file *f; 478 479 if (td->o.file_service_type == FIO_FSERVICE_RR) 480 f = get_next_file_rr(td, 0, FIO_FILE_OPEN); 481 else 482 f = get_next_file_rand(td, 0, FIO_FILE_OPEN); 483 484 return f; 485} 486 487struct io_u *__get_io_u(struct thread_data *td) 488{ 489 struct io_u *io_u = NULL; 490 491 if (!list_empty(&td->io_u_requeues)) 492 io_u = list_entry(td->io_u_requeues.next, struct io_u, list); 493 else if (!queue_full(td)) { 494 io_u = list_entry(td->io_u_freelist.next, struct io_u, list); 495 496 io_u->buflen = 0; 497 io_u->resid = 0; 498 io_u->file = NULL; 499 io_u->end_io = NULL; 500 } 501 502 if (io_u) { 503 assert(io_u->flags & IO_U_F_FREE); 504 io_u->flags &= ~IO_U_F_FREE; 505 506 io_u->error = 0; 507 list_del(&io_u->list); 508 list_add(&io_u->list, &td->io_u_busylist); 509 td->cur_depth++; 510 } 511 512 return io_u; 513} 514 515/* 516 * Return an io_u to be processed. Gets a buflen and offset, sets direction, 517 * etc. The returned io_u is fully ready to be prepped and submitted. 518 */ 519struct io_u *get_io_u(struct thread_data *td) 520{ 521 struct fio_file *f; 522 struct io_u *io_u; 523 int ret; 524 525 io_u = __get_io_u(td); 526 if (!io_u) 527 return NULL; 528 529 /* 530 * from a requeue, io_u already setup 531 */ 532 if (io_u->file) 533 goto out; 534 535 do { 536 f = get_next_file(td); 537 if (!f) { 538 put_io_u(td, io_u); 539 return NULL; 540 } 541 542set_file: 543 io_u->file = f; 544 545 if (!fill_io_u(td, io_u)) 546 break; 547 548 /* 549 * No more to do for this file, close it 550 */ 551 io_u->file = NULL; 552 td_io_close_file(td, f); 553 554 /* 555 * probably not the right place to do this, but see 556 * if we need to open a new file 557 */ 558 if (td->nr_open_files < td->o.open_files && 559 td->o.open_files != td->o.nr_files) { 560 f = find_next_new_file(td); 561 562 if (!f || (ret = td_io_open_file(td, f))) { 563 put_io_u(td, io_u); 564 return NULL; 565 } 566 goto set_file; 567 } 568 } while (1); 569 570 if (td->zone_bytes >= td->o.zone_size) { 571 td->zone_bytes = 0; 572 f->last_pos += td->o.zone_skip; 573 } 574 575 if (io_u->buflen + io_u->offset > f->real_file_size) { 576 if (td->io_ops->flags & FIO_RAWIO) { 577 put_io_u(td, io_u); 578 return NULL; 579 } 580 581 io_u->buflen = f->real_file_size - io_u->offset; 582 } 583 584 if (io_u->ddir != DDIR_SYNC) { 585 if (!io_u->buflen) { 586 put_io_u(td, io_u); 587 return NULL; 588 } 589 590 f->last_pos = io_u->offset + io_u->buflen; 591 592 if (td->o.verify != VERIFY_NONE) 593 populate_verify_io_u(td, io_u); 594 } 595 596 /* 597 * Set io data pointers. 598 */ 599out: 600 io_u->xfer_buf = io_u->buf; 601 io_u->xfer_buflen = io_u->buflen; 602 603 if (td_io_prep(td, io_u)) { 604 put_io_u(td, io_u); 605 return NULL; 606 } 607 608 fio_gettime(&io_u->start_time, NULL); 609 return io_u; 610} 611 612void io_u_log_error(struct thread_data *td, struct io_u *io_u) 613{ 614 const char *msg[] = { "read", "write", "sync" }; 615 616 log_err("fio: io_u error"); 617 618 if (io_u->file) 619 log_err(" on file %s", io_u->file->file_name); 620 621 log_err(": %s\n", strerror(io_u->error)); 622 623 log_err(" %s offset=%llu, buflen=%lu\n", msg[io_u->ddir], io_u->offset, io_u->xfer_buflen); 624 625 if (!td->error) 626 td_verror(td, io_u->error, "io_u error"); 627} 628 629static void io_completed(struct thread_data *td, struct io_u *io_u, 630 struct io_completion_data *icd) 631{ 632 unsigned long msec; 633 634 assert(io_u->flags & IO_U_F_FLIGHT); 635 io_u->flags &= ~IO_U_F_FLIGHT; 636 637 put_file(td, io_u->file); 638 639 if (io_u->ddir == DDIR_SYNC) { 640 td->last_was_sync = 1; 641 return; 642 } 643 644 td->last_was_sync = 0; 645 646 if (!io_u->error) { 647 unsigned int bytes = io_u->buflen - io_u->resid; 648 const enum fio_ddir idx = io_u->ddir; 649 int ret; 650 651 td->io_blocks[idx]++; 652 td->io_bytes[idx] += bytes; 653 td->zone_bytes += bytes; 654 td->this_io_bytes[idx] += bytes; 655 656 io_u->file->last_completed_pos = io_u->offset + io_u->buflen; 657 658 msec = mtime_since(&io_u->issue_time, &icd->time); 659 660 add_clat_sample(td, idx, msec); 661 add_bw_sample(td, idx, &icd->time); 662 io_u_mark_latency(td, msec); 663 664 if ((td_rw(td) || td_write(td)) && idx == DDIR_WRITE && 665 td->o.verify != VERIFY_NONE) 666 log_io_piece(td, io_u); 667 668 icd->bytes_done[idx] += bytes; 669 670 if (io_u->end_io) { 671 ret = io_u->end_io(td, io_u); 672 if (ret && !icd->error) 673 icd->error = ret; 674 } 675 } else { 676 icd->error = io_u->error; 677 io_u_log_error(td, io_u); 678 } 679} 680 681static void init_icd(struct io_completion_data *icd, int nr) 682{ 683 fio_gettime(&icd->time, NULL); 684 685 icd->nr = nr; 686 687 icd->error = 0; 688 icd->bytes_done[0] = icd->bytes_done[1] = 0; 689} 690 691static void ios_completed(struct thread_data *td, 692 struct io_completion_data *icd) 693{ 694 struct io_u *io_u; 695 int i; 696 697 for (i = 0; i < icd->nr; i++) { 698 io_u = td->io_ops->event(td, i); 699 700 io_completed(td, io_u, icd); 701 put_io_u(td, io_u); 702 } 703} 704 705/* 706 * Complete a single io_u for the sync engines. 707 */ 708long io_u_sync_complete(struct thread_data *td, struct io_u *io_u) 709{ 710 struct io_completion_data icd; 711 712 init_icd(&icd, 1); 713 io_completed(td, io_u, &icd); 714 put_io_u(td, io_u); 715 716 if (!icd.error) 717 return icd.bytes_done[0] + icd.bytes_done[1]; 718 719 td_verror(td, icd.error, "io_u_sync_complete"); 720 return -1; 721} 722 723/* 724 * Called to complete min_events number of io for the async engines. 725 */ 726long io_u_queued_complete(struct thread_data *td, int min_events) 727{ 728 struct io_completion_data icd; 729 struct timespec *tvp = NULL; 730 int ret; 731 struct timespec ts = { .tv_sec = 0, .tv_nsec = 0, }; 732 733 if (!min_events) 734 tvp = &ts; 735 736 ret = td_io_getevents(td, min_events, td->cur_depth, tvp); 737 if (ret < 0) { 738 td_verror(td, -ret, "td_io_getevents"); 739 return ret; 740 } else if (!ret) 741 return ret; 742 743 init_icd(&icd, ret); 744 ios_completed(td, &icd); 745 if (!icd.error) 746 return icd.bytes_done[0] + icd.bytes_done[1]; 747 748 td_verror(td, icd.error, "io_u_queued_complete"); 749 return -1; 750} 751 752/* 753 * Call when io_u is really queued, to update the submission latency. 754 */ 755void io_u_queued(struct thread_data *td, struct io_u *io_u) 756{ 757 unsigned long slat_time; 758 759 slat_time = mtime_since(&io_u->start_time, &io_u->issue_time); 760 add_slat_sample(td, io_u->ddir, slat_time); 761} 762 763#ifdef FIO_USE_TIMEOUT 764void io_u_set_timeout(struct thread_data *td) 765{ 766 assert(td->cur_depth); 767 768 td->timer.it_interval.tv_sec = 0; 769 td->timer.it_interval.tv_usec = 0; 770 td->timer.it_value.tv_sec = IO_U_TIMEOUT + IO_U_TIMEOUT_INC; 771 td->timer.it_value.tv_usec = 0; 772 setitimer(ITIMER_REAL, &td->timer, NULL); 773 fio_gettime(&td->timeout_end, NULL); 774} 775 776static void io_u_dump(struct io_u *io_u) 777{ 778 unsigned long t_start = mtime_since_now(&io_u->start_time); 779 unsigned long t_issue = mtime_since_now(&io_u->issue_time); 780 781 log_err("io_u=%p, t_start=%lu, t_issue=%lu\n", io_u, t_start, t_issue); 782 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); 783 log_err(" ddir=%d, fname=%s\n", io_u->ddir, io_u->file->file_name); 784} 785#else 786void io_u_set_timeout(struct thread_data fio_unused *td) 787{ 788} 789#endif 790 791#ifdef FIO_USE_TIMEOUT 792static void io_u_timeout_handler(int fio_unused sig) 793{ 794 struct thread_data *td, *__td; 795 pid_t pid = getpid(); 796 struct list_head *entry; 797 struct io_u *io_u; 798 int i; 799 800 log_err("fio: io_u timeout\n"); 801 802 /* 803 * TLS would be nice... 804 */ 805 td = NULL; 806 for_each_td(__td, i) { 807 if (__td->pid == pid) { 808 td = __td; 809 break; 810 } 811 } 812 813 if (!td) { 814 log_err("fio: io_u timeout, can't find job\n"); 815 exit(1); 816 } 817 818 if (!td->cur_depth) { 819 log_err("fio: timeout without pending work?\n"); 820 return; 821 } 822 823 log_err("fio: io_u timeout: job=%s, pid=%d\n", td->o.name, td->pid); 824 825 list_for_each(entry, &td->io_u_busylist) { 826 io_u = list_entry(entry, struct io_u, list); 827 828 io_u_dump(io_u); 829 } 830 831 td_verror(td, ETIMEDOUT, "io_u timeout"); 832 exit(1); 833} 834#endif 835 836void io_u_init_timeout(void) 837{ 838#ifdef FIO_USE_TIMEOUT 839 signal(SIGALRM, io_u_timeout_handler); 840#endif 841} 842