tools/tools/syscall_timing/syscall_timing.c

   1 /*-
   2  * Copyright (c) 2003-2004, 2010 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * Portions of this software were developed at the University of Cambridge
   6  * Computer Laboratory with support from a grant from Google, Inc.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/mman.h>
  34 #include <sys/resource.h>
  35 #include <sys/socket.h>
  36 #include <sys/stat.h>
  37 #include <sys/time.h>
  38 #include <sys/wait.h>
  39
  40 #include <assert.h>
  41 #include <err.h>
  42 #include <errno.h>
  43 #include <fcntl.h>
  44 #include <inttypes.h>
  45 #include <limits.h>
  46 #include <signal.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <unistd.h>
  51
  52 static struct timespec ts_start, ts_end;
  53 static int alarm_timeout;
  54 static volatile int alarm_fired;
  55
  56 #define timespecsub(vvp, uvp)                                           \
  57         do {                                                            \
  58                 (vvp)->tv_sec -= (uvp)->tv_sec;                         \
  59                 (vvp)->tv_nsec -= (uvp)->tv_nsec;                       \
  60                 if ((vvp)->tv_nsec < 0) {                               \
  61                         (vvp)->tv_sec--;                                \
  62                         (vvp)->tv_nsec += 1000000000;                   \
  63                 }                                                       \
  64         } while (0)
  65
  66 static void
  67 alarm_handler(int signum)
  68 {
  69
  70         alarm_fired = 1;
  71 }
  72
  73 static void
  74 benchmark_start(void)
  75 {
  76         int error;
  77
  78         alarm_fired = 0;
  79         if (alarm_timeout) {
  80                 signal(SIGALRM, alarm_handler);
  81                 alarm(alarm_timeout);
  82         }
  83         error = clock_gettime(CLOCK_REALTIME, &ts_start);
  84         assert(error == 0);
  85 }
  86
  87 static void
  88 benchmark_stop(void)
  89 {
  90         int error;
  91
  92         error = clock_gettime(CLOCK_REALTIME, &ts_end);
  93         assert(error == 0);
  94 }
  95
  96 uintmax_t
  97 test_getuid(uintmax_t num, uintmax_t int_arg, const char *path)
  98 {
  99         uintmax_t i;
 100
 101         /*
 102          * Thread-local data should require no locking if system
 103          * call is MPSAFE.
 104          */
 105         benchmark_start();
 106         for (i = 0; i < num; i++) {
 107                 if (alarm_fired)
 108                         break;
 109                 getuid();
 110         }
 111         benchmark_stop();
 112         return (i);
 113 }
 114
 115 uintmax_t
 116 test_getppid(uintmax_t num, uintmax_t int_arg, const char *path)
 117 {
 118         uintmax_t i;
 119
 120         /*
 121          * This is process-local, but can change, so will require a
 122          * lock.
 123          */
 124         benchmark_start();
 125         for (i = 0; i < num; i++) {
 126                 if (alarm_fired)
 127                         break;
 128                 getppid();
 129         }
 130         benchmark_stop();
 131         return (i);
 132 }
 133
 134 uintmax_t
 135 test_getresuid(uintmax_t num, uintmax_t int_arg, const char *path)
 136 {
 137         uid_t ruid, euid, suid;
 138         uintmax_t i;
 139
 140         benchmark_start();
 141         for (i = 0; i < num; i++) {
 142                 if (alarm_fired)
 143                         break;
 144                 (void)getresuid(&ruid, &euid, &suid);
 145         }
 146         benchmark_stop();
 147         return (i);
 148 }
 149
 150 uintmax_t
 151 test_clock_gettime(uintmax_t num, uintmax_t int_arg, const char *path)
 152 {
 153         struct timespec ts;
 154         uintmax_t i;
 155
 156         benchmark_start();
 157         for (i = 0; i < num; i++) {
 158                 if (alarm_fired)
 159                         break;
 160                 (void)clock_gettime(CLOCK_REALTIME, &ts);
 161         }
 162         benchmark_stop();
 163         return (i);
 164 }
 165
 166 uintmax_t
 167 test_gettimeofday(uintmax_t num, uintmax_t int_arg, const char *path)
 168 {
 169         struct timeval tv;
 170         uintmax_t i;
 171
 172         benchmark_start();
 173         for (i = 0; i < num; i++) {
 174                 if (alarm_fired)
 175                         break;
 176                 (void)gettimeofday(&tv, NULL);
 177         }
 178         benchmark_stop();
 179         return (i);
 180 }
 181
 182 uintmax_t
 183 test_getpriority(uintmax_t num, uintmax_t int_arg, const char *path)
 184 {
 185         uintmax_t i;
 186
 187         benchmark_start();
 188         for (i = 0; i < num; i++) {
 189                 if (alarm_fired)
 190                         break;
 191                 (void)getpriority(PRIO_PROCESS, 0);
 192         }
 193         benchmark_stop();
 194         return (i);
 195 }
 196
 197 uintmax_t
 198 test_pipe(uintmax_t num, uintmax_t int_arg, const char *path)
 199 {
 200         int fd[2], i;
 201
 202         /*
 203          * pipe creation is expensive, as it will allocate a new file
 204          * descriptor, allocate a new pipe, hook it all up, and return.
 205          * Destroying is also expensive, as we now have to free up
 206          * the file descriptors and return the pipe.
 207          */
 208         if (pipe(fd) < 0)
 209                 err(-1, "test_pipe: pipe");
 210         close(fd[0]);
 211         close(fd[1]);
 212         benchmark_start();
 213         for (i = 0; i < num; i++) {
 214                 if (alarm_fired)
 215                         break;
 216                 if (pipe(fd) == -1)
 217                         err(-1, "test_pipe: pipe");
 218                 close(fd[0]);
 219                 close(fd[1]);
 220         }
 221         benchmark_stop();
 222         return (i);
 223 }
 224
 225 uintmax_t
 226 test_select(uintmax_t num, uintmax_t int_arg, const char *path)
 227 {
 228         fd_set readfds, writefds, exceptfds;
 229         struct timeval tv;
 230         uintmax_t i;
 231         int error;
 232
 233         FD_ZERO(&readfds);
 234         FD_ZERO(&writefds);
 235         FD_ZERO(&exceptfds);
 236
 237         tv.tv_sec = 0;
 238         tv.tv_usec = 0;
 239
 240         benchmark_start();
 241         for (i = 0; i < num; i++) {
 242                 if (alarm_fired)
 243                         break;
 244                 (void)select(0, &readfds, &writefds, &exceptfds, &tv);
 245         }
 246         benchmark_stop();
 247         return (i);
 248 }
 249
 250 uintmax_t
 251 test_socket_stream(uintmax_t num, uintmax_t int_arg, const char *path)
 252 {
 253         uintmax_t i;
 254         int so;
 255
 256         so = socket(int_arg, SOCK_STREAM, 0);
 257         if (so < 0)
 258                 err(-1, "test_socket_stream: socket");
 259         close(so);
 260         benchmark_start();
 261         for (i = 0; i < num; i++) {
 262                 if (alarm_fired)
 263                         break;
 264                 so = socket(int_arg, SOCK_STREAM, 0);
 265                 if (so == -1)
 266                         err(-1, "test_socket_stream: socket");
 267                 close(so);
 268         }
 269         benchmark_stop();
 270         return (i);
 271 }
 272
 273 uintmax_t
 274 test_socket_dgram(uintmax_t num, uintmax_t int_arg, const char *path)
 275 {
 276         uintmax_t i;
 277         int so;
 278
 279         so = socket(int_arg, SOCK_DGRAM, 0);
 280         if (so < 0)
 281                 err(-1, "test_socket_dgram: socket");
 282         close(so);
 283         benchmark_start();
 284         for (i = 0; i < num; i++) {
 285                 if (alarm_fired)
 286                         break;
 287                 so = socket(int_arg, SOCK_DGRAM, 0);
 288                 if (so == -1)
 289                         err(-1, "test_socket_dgram: socket");
 290                 close(so);
 291         }
 292         benchmark_stop();
 293         return (i);
 294 }
 295
 296 uintmax_t
 297 test_socketpair_stream(uintmax_t num, uintmax_t int_arg, const char *path)
 298 {
 299         uintmax_t i;
 300         int so[2];
 301
 302         if (socketpair(PF_LOCAL, SOCK_STREAM, 0, so) == -1)
 303                 err(-1, "test_socketpair_stream: socketpair");
 304         close(so[0]);
 305         close(so[1]);
 306         benchmark_start();
 307         for (i = 0; i < num; i++) {
 308                 if (alarm_fired)
 309                         break;
 310                 if (socketpair(PF_LOCAL, SOCK_STREAM, 0, so) == -1)
 311                         err(-1, "test_socketpair_stream: socketpair");
 312                 close(so[0]);
 313                 close(so[1]);
 314         }
 315         benchmark_stop();
 316         return (i);
 317 }
 318
 319 uintmax_t
 320 test_socketpair_dgram(uintmax_t num, uintmax_t int_arg, const char *path)
 321 {
 322         uintmax_t i;
 323         int so[2];
 324
 325         if (socketpair(PF_LOCAL, SOCK_DGRAM, 0, so) == -1)
 326                 err(-1, "test_socketpair_dgram: socketpair");
 327         close(so[0]);
 328         close(so[1]);
 329         benchmark_start();
 330         for (i = 0; i < num; i++) {
 331                 if (alarm_fired)
 332                         break;
 333                 if (socketpair(PF_LOCAL, SOCK_DGRAM, 0, so) == -1)
 334                         err(-1, "test_socketpair_dgram: socketpair");
 335                 close(so[0]);
 336                 close(so[1]);
 337         }
 338         benchmark_stop();
 339         return (i);
 340 }
 341
 342 uintmax_t
 343 test_access(uintmax_t num, uintmax_t int_arg, const char *path)
 344 {
 345         uintmax_t i;
 346         int fd;
 347
 348         fd = access(path, O_RDONLY);
 349         if (fd < 0)
 350                 err(-1, "test_access: %s", path);
 351         close(fd);
 352
 353         benchmark_start();
 354         for (i = 0; i < num; i++) {
 355                 if (alarm_fired)
 356                         break;
 357                 access(path, O_RDONLY);
 358                 close(fd);
 359         }
 360         benchmark_stop();
 361         return (i);
 362 }
 363
 364 uintmax_t
 365 test_create_unlink(uintmax_t num, uintmax_t int_arg, const char *path)
 366 {
 367         uintmax_t i;
 368         int fd;
 369
 370         (void)unlink(path);
 371         fd = open(path, O_RDWR | O_CREAT, 0600);
 372         if (fd < 0)
 373                 err(-1, "test_create_unlink: create: %s", path);
 374         close(fd);
 375         if (unlink(path) < 0)
 376                 err(-1, "test_create_unlink: unlink: %s", path);
 377         benchmark_start();
 378         for (i = 0; i < num; i++) {
 379                 if (alarm_fired)
 380                         break;
 381                 fd = open(path, O_RDWR | O_CREAT, 0600);
 382                 if (fd < 0)
 383                         err(-1, "test_create_unlink: create: %s", path);
 384                 close(fd);
 385                 if (unlink(path) < 0)
 386                         err(-1, "test_create_unlink: unlink: %s", path);
 387         }
 388         benchmark_stop();
 389         return (i);
 390 }
 391
 392 uintmax_t
 393 test_open_close(uintmax_t num, uintmax_t int_arg, const char *path)
 394 {
 395         uintmax_t i;
 396         int fd;
 397
 398         fd = open(path, O_RDONLY);
 399         if (fd < 0)
 400                 err(-1, "test_open_close: %s", path);
 401         close(fd);
 402
 403         benchmark_start();
 404         for (i = 0; i < num; i++) {
 405                 if (alarm_fired)
 406                         break;
 407                 fd = open(path, O_RDONLY);
 408                 if (fd < 0)
 409                         err(-1, "test_open_close: %s", path);
 410                 close(fd);
 411         }
 412         benchmark_stop();
 413         return (i);
 414 }
 415
 416 uintmax_t
 417 test_bad_open(uintmax_t num, uintmax_t int_arg, const char *path)
 418 {
 419         uintmax_t i;
 420
 421         benchmark_start();
 422         for (i = 0; i < num; i++) {
 423                 if (alarm_fired)
 424                         break;
 425                 open("", O_RDONLY);
 426         }
 427         benchmark_stop();
 428         return (i);
 429 }
 430
 431 uintmax_t
 432 test_read(uintmax_t num, uintmax_t int_arg, const char *path)
 433 {
 434         char buf[int_arg];
 435         uintmax_t i;
 436         int fd;
 437
 438         fd = open(path, O_RDONLY);
 439         if (fd < 0)
 440                 err(-1, "test_open_read: %s", path);
 441         (void)pread(fd, buf, int_arg, 0);
 442
 443         benchmark_start();
 444         for (i = 0; i < num; i++) {
 445                 if (alarm_fired)
 446                         break;
 447                 (void)pread(fd, buf, int_arg, 0);
 448         }
 449         benchmark_stop();
 450         close(fd);
 451         return (i);
 452 }
 453
 454 uintmax_t
 455 test_open_read_close(uintmax_t num, uintmax_t int_arg, const char *path)
 456 {
 457         char buf[int_arg];
 458         uintmax_t i;
 459         int fd;
 460
 461         fd = open(path, O_RDONLY);
 462         if (fd < 0)
 463                 err(-1, "test_open_read_close: %s", path);
 464         (void)read(fd, buf, int_arg);
 465         close(fd);
 466
 467         benchmark_start();
 468         for (i = 0; i < num; i++) {
 469                 if (alarm_fired)
 470                         break;
 471                 fd = open(path, O_RDONLY);
 472                 if (fd < 0)
 473                         err(-1, "test_open_read_close: %s", path);
 474                 (void)read(fd, buf, int_arg);
 475                 close(fd);
 476         }
 477         benchmark_stop();
 478         return (i);
 479 }
 480
 481 uintmax_t
 482 test_dup(uintmax_t num, uintmax_t int_arg, const char *path)
 483 {
 484         int fd, i, shmfd;
 485
 486         shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 487         if (shmfd < 0)
 488                 err(-1, "test_dup: shm_open");
 489         fd = dup(shmfd);
 490         if (fd >= 0)
 491                 close(fd);
 492         benchmark_start();
 493         for (i = 0; i < num; i++) {
 494                 if (alarm_fired)
 495                         break;
 496                 fd = dup(shmfd);
 497                 if (fd >= 0)
 498                         close(fd);
 499         }
 500         benchmark_stop();
 501         close(shmfd);
 502         return (i);
 503 }
 504
 505 uintmax_t
 506 test_shmfd(uintmax_t num, uintmax_t int_arg, const char *path)
 507 {
 508         uintmax_t i;
 509         int shmfd;
 510
 511         shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 512         if (shmfd < 0)
 513                 err(-1, "test_shmfd: shm_open");
 514         close(shmfd);
 515         benchmark_start();
 516         for (i = 0; i < num; i++) {
 517                 if (alarm_fired)
 518                         break;
 519                 shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 520                 if (shmfd < 0)
 521                         err(-1, "test_shmfd: shm_open");
 522                 close(shmfd);
 523         }
 524         benchmark_stop();
 525         return (i);
 526 }
 527
 528 uintmax_t
 529 test_fstat_shmfd(uintmax_t num, uintmax_t int_arg, const char *path)
 530 {
 531         struct stat sb;
 532         uintmax_t i;
 533         int shmfd;
 534
 535         shmfd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
 536         if (shmfd < 0)
 537                 err(-1, "test_fstat_shmfd: shm_open");
 538         if (fstat(shmfd, &sb) < 0)
 539                 err(-1, "test_fstat_shmfd: fstat");
 540         benchmark_start();
 541         for (i = 0; i < num; i++) {
 542                 if (alarm_fired)
 543                         break;
 544                 (void)fstat(shmfd, &sb);
 545         }
 546         benchmark_stop();
 547         close(shmfd);
 548         return (i);
 549 }
 550
 551 uintmax_t
 552 test_fork(uintmax_t num, uintmax_t int_arg, const char *path)
 553 {
 554         pid_t pid;
 555         uintmax_t i;
 556
 557         pid = fork();
 558         if (pid < 0)
 559                 err(-1, "test_fork: fork");
 560         if (pid == 0)
 561                 _exit(0);
 562         if (waitpid(pid, NULL, 0) < 0)
 563                 err(-1, "test_fork: waitpid");
 564         benchmark_start();
 565         for (i = 0; i < num; i++) {
 566                 if (alarm_fired)
 567                         break;
 568                 pid = fork();
 569                 if (pid < 0)
 570                         err(-1, "test_fork: fork");
 571                 if (pid == 0)
 572                         _exit(0);
 573                 if (waitpid(pid, NULL, 0) < 0)
 574                         err(-1, "test_fork: waitpid");
 575         }
 576         benchmark_stop();
 577         return (i);
 578 }
 579
 580 uintmax_t
 581 test_vfork(uintmax_t num, uintmax_t int_arg, const char *path)
 582 {
 583         pid_t pid;
 584         uintmax_t i;
 585
 586         pid = vfork();
 587         if (pid < 0)
 588                 err(-1, "test_vfork: vfork");
 589         if (pid == 0)
 590                 _exit(0);
 591         if (waitpid(pid, NULL, 0) < 0)
 592                 err(-1, "test_vfork: waitpid");
 593         benchmark_start();
 594         for (i = 0; i < num; i++) {
 595                 if (alarm_fired)
 596                         break;
 597                 pid = vfork();
 598                 if (pid < 0)
 599                         err(-1, "test_vfork: vfork");
 600                 if (pid == 0)
 601                         _exit(0);
 602                 if (waitpid(pid, NULL, 0) < 0)
 603                         err(-1, "test_vfork: waitpid");
 604         }
 605         benchmark_stop();
 606         return (i);
 607 }
 608
 609 #define USR_BIN_TRUE    "/usr/bin/true"
 610 static char *execve_args[] = { USR_BIN_TRUE, NULL};
 611 extern char **environ;
 612
 613 uintmax_t
 614 test_fork_exec(uintmax_t num, uintmax_t int_arg, const char *path)
 615 {
 616         pid_t pid;
 617         uintmax_t i;
 618
 619         pid = fork();
 620         if (pid < 0)
 621                 err(-1, "test_fork_exec: fork");
 622         if (pid == 0) {
 623                 (void)execve(USR_BIN_TRUE, execve_args, environ);
 624                 err(-1, "execve");
 625         }
 626         if (waitpid(pid, NULL, 0) < 0)
 627                 err(-1, "test_fork: waitpid");
 628         benchmark_start();
 629         for (i = 0; i < num; i++) {
 630                 if (alarm_fired)
 631                         break;
 632                 pid = fork();
 633                 if (pid < 0)
 634                         err(-1, "test_fork_exec: fork");
 635                 if (pid == 0) {
 636                         (void)execve(USR_BIN_TRUE, execve_args, environ);
 637                         err(-1, "test_fork_exec: execve");
 638                 }
 639                 if (waitpid(pid, NULL, 0) < 0)
 640                         err(-1, "test_fork_exec: waitpid");
 641         }
 642         benchmark_stop();
 643         return (i);
 644 }
 645
 646 uintmax_t
 647 test_vfork_exec(uintmax_t num, uintmax_t int_arg, const char *path)
 648 {
 649         pid_t pid;
 650         uintmax_t i;
 651
 652         pid = vfork();
 653         if (pid < 0)
 654                 err(-1, "test_vfork_exec: vfork");
 655         if (pid == 0) {
 656                 (void)execve(USR_BIN_TRUE, execve_args, environ);
 657                 err(-1, "test_vfork_exec: execve");
 658         }
 659         if (waitpid(pid, NULL, 0) < 0)
 660                 err(-1, "test_vfork_exec: waitpid");
 661         benchmark_start();
 662         for (i = 0; i < num; i++) {
 663                 if (alarm_fired)
 664                         break;
 665                 pid = vfork();
 666                 if (pid < 0)
 667                         err(-1, "test_vfork_exec: vfork");
 668                 if (pid == 0) {
 669                         (void)execve(USR_BIN_TRUE, execve_args, environ);
 670                         err(-1, "execve");
 671                 }
 672                 if (waitpid(pid, NULL, 0) < 0)
 673                         err(-1, "test_vfork_exec: waitpid");
 674         }
 675         benchmark_stop();
 676         return (i);
 677 }
 678
 679 uintmax_t
 680 test_chroot(uintmax_t num, uintmax_t int_arg, const char *path)
 681 {
 682         uintmax_t i;
 683
 684         if (chroot("/") < 0)
 685                 err(-1, "test_chroot: chroot");
 686         benchmark_start();
 687         for (i = 0; i < num; i++) {
 688                 if (alarm_fired)
 689                         break;
 690                 if (chroot("/") < 0)
 691                         err(-1, "test_chroot: chroot");
 692         }
 693         benchmark_stop();
 694         return (i);
 695 }
 696
 697 uintmax_t
 698 test_setuid(uintmax_t num, uintmax_t int_arg, const char *path)
 699 {
 700         uid_t uid;
 701         uintmax_t i;
 702
 703         uid = getuid();
 704         if (setuid(uid) < 0)
 705                 err(-1, "test_setuid: setuid");
 706         benchmark_start();
 707         for (i = 0; i < num; i++) {
 708                 if (alarm_fired)
 709                         break;
 710                 if (setuid(uid) < 0)
 711                         err(-1, "test_setuid: setuid");
 712         }
 713         benchmark_stop();
 714         return (i);
 715 }
 716
 717 struct test {
 718         const char      *t_name;
 719         uintmax_t       (*t_func)(uintmax_t, uintmax_t, const char *);
 720         int              t_flags;
 721         uintmax_t        t_int;
 722 };
 723
 724 #define FLAG_PATH       0x00000001
 725
 726 static const struct test tests[] = {
 727         { "getuid", test_getuid },
 728         { "getppid", test_getppid },
 729         { "getresuid", test_getresuid },
 730         { "clock_gettime", test_clock_gettime },
 731         { "gettimeofday", test_gettimeofday },
 732         { "getpriority", test_getpriority },
 733         { "pipe", test_pipe },
 734         { "select", test_select },
 735         { "socket_local_stream", test_socket_stream, .t_int = PF_LOCAL },
 736         { "socket_local_dgram", test_socket_dgram, .t_int = PF_LOCAL },
 737         { "socketpair_stream", test_socketpair_stream },
 738         { "socketpair_dgram", test_socketpair_dgram },
 739         { "socket_tcp", test_socket_stream, .t_int = PF_INET },
 740         { "socket_udp", test_socket_dgram, .t_int = PF_INET },
 741         { "access", test_access, .t_flags = FLAG_PATH },
 742         { "create_unlink", test_create_unlink, .t_flags = FLAG_PATH },
 743         { "bad_open", test_bad_open },
 744         { "open_close", test_open_close, .t_flags = FLAG_PATH },
 745         { "open_read_close_1", test_open_read_close, .t_flags = FLAG_PATH,
 746             .t_int = 1 },
 747         { "open_read_close_10", test_open_read_close, .t_flags = FLAG_PATH,
 748             .t_int = 10 },
 749         { "open_read_close_100", test_open_read_close, .t_flags = FLAG_PATH,
 750             .t_int = 100 },
 751         { "open_read_close_1000", test_open_read_close, .t_flags = FLAG_PATH,
 752             .t_int = 1000 },
 753         { "open_read_close_10000", test_open_read_close,
 754             .t_flags = FLAG_PATH, .t_int = 10000 },
 755         { "open_read_close_100000", test_open_read_close,
 756             .t_flags = FLAG_PATH, .t_int = 100000 },
 757         { "open_read_close_1000000", test_open_read_close,
 758             .t_flags = FLAG_PATH, .t_int = 1000000 },
 759         { "read_1", test_read, .t_flags = FLAG_PATH, .t_int = 1 },
 760         { "read_10", test_read, .t_flags = FLAG_PATH, .t_int = 10 },
 761         { "read_100", test_read, .t_flags = FLAG_PATH, .t_int = 100 },
 762         { "read_1000", test_read, .t_flags = FLAG_PATH, .t_int = 1000 },
 763         { "read_10000", test_read, .t_flags = FLAG_PATH, .t_int = 10000 },
 764         { "read_100000", test_read, .t_flags = FLAG_PATH, .t_int = 100000 },
 765         { "read_1000000", test_read, .t_flags = FLAG_PATH, .t_int = 1000000 },
 766         { "dup", test_dup },
 767         { "shmfd", test_shmfd },
 768         { "fstat_shmfd", test_fstat_shmfd },
 769         { "fork", test_fork },
 770         { "vfork", test_vfork },
 771         { "fork_exec", test_fork_exec },
 772         { "vfork_exec", test_vfork_exec },
 773         { "chroot", test_chroot },
 774         { "setuid", test_setuid },
 775 };
 776 static const int tests_count = sizeof(tests) / sizeof(tests[0]);
 777
 778 static void
 779 usage(void)
 780 {
 781         int i;
 782
 783         fprintf(stderr, "syscall_timing [-i iterations] [-l loops] "
 784             "[-p path] [-s seconds] test\n");
 785         for (i = 0; i < tests_count; i++)
 786                 fprintf(stderr, "  %s\n", tests[i].t_name);
 787         exit(-1);
 788 }
 789
 790 int
 791 main(int argc, char *argv[])
 792 {
 793         struct timespec ts_res;
 794         const struct test *the_test;
 795         const char *path;
 796         char *tmp_dir, *tmp_path;
 797         long long ll;
 798         char *endp;
 799         int ch, fd, error, i, j, k, rv;
 800         uintmax_t iterations, loops;
 801
 802         alarm_timeout = 1;
 803         iterations = 0;
 804         loops = 10;
 805         path = NULL;
 806         tmp_path = NULL;
 807         while ((ch = getopt(argc, argv, "i:l:p:s:")) != -1) {
 808                 switch (ch) {
 809                 case 'i':
 810                         ll = strtol(optarg, &endp, 10);
 811                         if (*endp != 0 || ll < 1)
 812                                 usage();
 813                         iterations = ll;
 814                         break;
 815
 816                 case 'l':
 817                         ll = strtol(optarg, &endp, 10);
 818                         if (*endp != 0 || ll < 1 || ll > 100000)
 819                                 usage();
 820                         loops = ll;
 821                         break;
 822
 823                 case 'p':
 824                         path = optarg;
 825                         break;
 826
 827                 case 's':
 828                         ll = strtol(optarg, &endp, 10);
 829                         if (*endp != 0 || ll < 1 || ll > 60*60)
 830                                 usage();
 831                         alarm_timeout = ll;
 832                         break;
 833
 834                 case '?':
 835                 default:
 836                         usage();
 837                 }
 838         }
 839         argc -= optind;
 840         argv += optind;
 841
 842         if (iterations < 1 && alarm_timeout < 1)
 843                 usage();
 844         if (iterations < 1)
 845                 iterations = UINT64_MAX;
 846         if (loops < 1)
 847                 loops = 1;
 848
 849         if (argc < 1)
 850                 usage();
 851
 852         /*
 853          * Validate test list and that, if a path is required, it is
 854          * defined.
 855          */
 856         for (j = 0; j < argc; j++) {
 857                 the_test = NULL;
 858                 for (i = 0; i < tests_count; i++) {
 859                         if (strcmp(argv[j], tests[i].t_name) == 0)
 860                                 the_test = &tests[i];
 861                 }
 862                 if (the_test == NULL)
 863                         usage();
 864                 if ((the_test->t_flags & FLAG_PATH) && (path == NULL)) {
 865                         tmp_dir = strdup("/tmp/syscall_timing.XXXXXXXX");
 866                         if (tmp_dir == NULL)
 867                                 err(1, "strdup");
 868                         tmp_dir = mkdtemp(tmp_dir);
 869                         if (tmp_dir == NULL)
 870                                 err(1, "mkdtemp");
 871                         rv = asprintf(&tmp_path, "%s/testfile", tmp_dir);
 872                         if (rv <= 0)
 873                                 err(1, "asprintf");
 874                 }
 875         }
 876
 877         error = clock_getres(CLOCK_REALTIME, &ts_res);
 878         assert(error == 0);
 879         printf("Clock resolution: %ju.%09ju\n", (uintmax_t)ts_res.tv_sec,
 880             (uintmax_t)ts_res.tv_nsec);
 881         printf("test\tloop\ttime\titerations\tperiteration\n");
 882
 883         for (j = 0; j < argc; j++) {
 884                 uintmax_t calls, nsecsperit;
 885
 886                 the_test = NULL;
 887                 for (i = 0; i < tests_count; i++) {
 888                         if (strcmp(argv[j], tests[i].t_name) == 0)
 889                                 the_test = &tests[i];
 890                 }
 891
 892                 if (tmp_path != NULL) {
 893                         fd = open(tmp_path, O_WRONLY | O_CREAT, 0700);
 894                         if (fd < 0)
 895                                 err(1, "cannot open %s", tmp_path);
 896                         error = ftruncate(fd, 1000000);
 897                         if (error != 0)
 898                                 err(1, "ftruncate");
 899                         error = close(fd);
 900                         if (error != 0)
 901                                 err(1, "close");
 902                         path = tmp_path;
 903                 }
 904
 905                 /*
 906                  * Run one warmup, then do the real thing (loops) times.
 907                  */
 908                 the_test->t_func(iterations, the_test->t_int, path);
 909                 calls = 0;
 910                 for (k = 0; k < loops; k++) {
 911                         calls = the_test->t_func(iterations, the_test->t_int,
 912                             path);
 913                         timespecsub(&ts_end, &ts_start);
 914                         printf("%s\t%d\t", the_test->t_name, k);
 915                         printf("%ju.%09ju\t%ju\t", (uintmax_t)ts_end.tv_sec,
 916                             (uintmax_t)ts_end.tv_nsec, calls);
 917
 918                 /*
 919                  * Note.  This assumes that each iteration takes less than
 920                  * a second, and that our total nanoseconds doesn't exceed
 921                  * the room in our arithmetic unit.  Fine for system calls,
 922                  * but not for long things.
 923                  */
 924                         nsecsperit = ts_end.tv_sec * 1000000000;
 925                         nsecsperit += ts_end.tv_nsec;
 926                         nsecsperit /= calls;
 927                         printf("0.%09ju\n", (uintmax_t)nsecsperit);
 928                 }
 929         }
 930
 931         if (tmp_path != NULL) {
 932                 error = unlink(tmp_path);
 933                 if (error != 0 && errno != ENOENT)
 934                         warn("cannot unlink %s", tmp_path);
 935                 error = rmdir(tmp_dir);
 936                 if (error != 0)
 937                         warn("cannot rmdir %s", tmp_dir);
 938         }
 939
 940         return (0);
 941 }