tools/regression/fifo/fifo_open/fifo_open.c

   1 /*-
   2  * Copyright (c) 2005 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <sys/wait.h>
  32
  33 #include <err.h>
  34 #include <errno.h>
  35 #include <fcntl.h>
  36 #include <limits.h>
  37 #include <signal.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <unistd.h>
  42
  43 /*
  44  * Regression test to exercise various POSIX-defined parts of fifo behavior
  45  * described for open(2):
  46  *
  47  * O_NONBLOCK
  48  * When opening a FIFO with O_RDONLY or O_WRONLY set:
  49  *
  50  * - If O_NONBLOCK is set, an open() for reading-only shall return without
  51  *   delay. An open() for writing-only shall return an error if no process
  52  *   currently has the file open for reading.
  53  *
  54  * - If O_NONBLOCK is clear, an open() for reading-only shall block the
  55  *   calling thread until a thread opens the file for writing. An open()
  56  *   for writing-only shall block the calling thread until a thread opens
  57  *   the file for reading.
  58  *
  59  * When opening a block special or character special file that supports
  60  * non-blocking opens:
  61  *
  62  * - If O_NONBLOCK is set, the open() function shall return without blocking
  63  *   for the device to be ready or available. Subsequent behavior of the
  64  *   device is device-specific.
  65  *
  66  * - If O_NONBLOCK is clear, the open() function shall block the calling
  67  *   thread until the device is ready or available before returning.
  68  *
  69  * Special errors:
  70  *
  71  * [ENXIO]
  72  * O_NONBLOCK is set, the named file is a FIFO, O_WRONLY is set, and no
  73  * process has the file open for reading.
  74  */
  75
  76 /*
  77  * In order to test blocking/non-blocking behavior, test processes must
  78  * potentially block themselves until released.  As bugs in blocking result
  79  * in processes that won't un-block, we must sacrifice a process to the task,
  80  * watching and potentially killing it after a time-out.  The main test
  81  * process is never used to open or act directly on a fifo (other than to
  82  * create or unlink it) in order to avoid the main test process being
  83  * blocked.
  84  */
  85
  86 /*
  87  * All activity occurs within a temporary directory created early in the
  88  * test.
  89  */
  90 char    temp_dir[PATH_MAX];
  91
  92 static void __unused
  93 atexit_temp_dir(void)
  94 {
  95
  96         rmdir(temp_dir);
  97 }
  98
  99 /*
 100  * Run a function in a particular test process.
 101  */
 102 static int
 103 run_in_process(int (*func)(void), pid_t *pidp, const char *errstr)
 104 {
 105         pid_t pid;
 106
 107         pid = fork();
 108         if (pid < 0) {
 109                 warn("%s: run_in_process: fork", errstr);
 110                 return (-1);
 111         }
 112
 113         if (pid == 0)
 114                 exit(func());
 115
 116         if (pidp != NULL)
 117                 *pidp = pid;
 118
 119         return (0);
 120 }
 121
 122 /*
 123  * Wait for a process on a timeout, and if the timeout expires, kill the
 124  * process.  Test each second rather than waiting the full timeout at once to
 125  * minimize the amount of time spent hanging around unnecessarily.
 126  */
 127 static int
 128 wait_and_timeout(pid_t pid, int timeout, int *status, const char *errstr)
 129 {
 130         pid_t wpid;
 131         int i;
 132
 133         /*
 134          * Count up to the timeout, but do a non-hanging waitpid() after each
 135          * second so we can avoid waiting a lot of extra time.
 136          */
 137         for (i = 0; i < timeout; i++) {
 138                 wpid = waitpid(pid, status, WNOHANG);
 139                 if (wpid < 0) {
 140                         warn("%s: wait_and_timeout: waitpid %d", errstr, pid);
 141                         return (-1);
 142                 }
 143
 144                 if (wpid == pid)
 145                         return (0);
 146
 147                 sleep(1);
 148         }
 149
 150         wpid = waitpid(pid, status, WNOHANG);
 151         if (wpid < 0) {
 152                 warn("%s: wait_and_timeout: waitpid %d", errstr, pid);
 153                 return (-1);
 154         }
 155
 156         if (wpid == pid)
 157                 return (0);
 158
 159         if (kill(pid, SIGTERM) < 0) {
 160                 warn("%s: wait_and_timeout: kill %d", errstr, pid);
 161                 return (-1);
 162         }
 163
 164         wpid = waitpid(pid, status, 0);
 165         if (wpid < 0) {
 166                 warn("%s: wait_and_timeout: waitpid %d", errstr, pid);
 167                 return (-1);
 168         }
 169
 170         if (wpid != pid) {
 171                 warn("%s: waitpid: returned %d not %d", errstr, wpid, pid);
 172                 return (-1);
 173         }
 174
 175         warnx("%s: process blocked", errstr);
 176         return (-1);
 177 }
 178
 179 static int
 180 non_blocking_open_reader(void)
 181 {
 182         int fd;
 183
 184         fd = open("testfifo", O_RDONLY | O_NONBLOCK);
 185         if (fd < 0)
 186                 return (errno);
 187         close(fd);
 188
 189         return (0);
 190 }
 191
 192 static int
 193 non_blocking_open_writer(void)
 194 {
 195         int fd;
 196
 197         fd = open("testfifo", O_WRONLY | O_NONBLOCK);
 198         if (fd < 0)
 199                 return (errno);
 200         close(fd);
 201
 202         return (0);
 203 }
 204
 205 static int
 206 blocking_open_reader(void)
 207 {
 208         int fd;
 209
 210         fd = open("testfifo", O_RDONLY);
 211         if (fd < 0)
 212                 return (errno);
 213         close(fd);
 214
 215         return (0);
 216 }
 217
 218 static int
 219 blocking_open_writer(void)
 220 {
 221         int fd;
 222
 223         fd = open("testfifo", O_WRONLY);
 224         if (fd < 0)
 225                 return (errno);
 226         close(fd);
 227
 228         return (0);
 229 }
 230
 231 static void
 232 test_blocking_reader(void)
 233 {
 234         pid_t reader_pid, writer_pid, wpid;
 235         int error, status;
 236
 237         if (mkfifo("testfifo", 0600) < 0)
 238                 err(-1, "test_blocking_reader: mkfifo: testfifo");
 239
 240         /*
 241          * Block a process in opening the fifo.
 242          */
 243         if (run_in_process(blocking_open_reader, &reader_pid,
 244             "test_blocking_reader: blocking_open_reader") < 0) {
 245                 (void)unlink("testfifo");
 246                 exit(-1);
 247         }
 248
 249         /*
 250          * Test that it blocked.
 251          */
 252         sleep(5);
 253         wpid = waitpid(reader_pid, &status, WNOHANG);
 254         if (wpid < 0) {
 255                 error = errno;
 256                 (void)unlink("testfifo");
 257                 errno = error;
 258                 err(-1, "test_blocking_reader: waitpid %d", reader_pid);
 259         }
 260
 261         if (wpid != 0 && wpid != reader_pid) {
 262                 (void)unlink("testfifo");
 263                 errx(-1, "test_blocking_reader: waitpid %d returned %d",
 264                     reader_pid, wpid);
 265         }
 266
 267         if (wpid == reader_pid) {
 268                 (void)unlink("testfifo");
 269                 errx(-1, "test_blocking_reader: blocking child didn't "
 270                     "block");
 271         }
 272
 273         /*
 274          * Unblock the blocking reader.
 275          */
 276         if (run_in_process(blocking_open_writer, &writer_pid,
 277             "test_blocking_reader: blocking_open_writer") < 0) {
 278                 (void)unlink("testfifo");
 279                 (void)kill(reader_pid, SIGTERM);
 280                 (void)waitpid(reader_pid, &status, 0);
 281                 exit(-1);
 282         }
 283
 284         /*
 285          * Make sure both processes exited quickly (<1 second) to make sure
 286          * they didn't block, and GC.
 287          */
 288         if (wait_and_timeout(reader_pid, 1, &status,
 289             "test_blocking_reader: blocking_open_reader") < 0) {
 290                 (void)unlink("testinfo");
 291                 (void)kill(reader_pid, SIGTERM);
 292                 (void)kill(writer_pid, SIGTERM);
 293                 exit(-1);
 294         }
 295
 296         if (wait_and_timeout(writer_pid, 1, &status,
 297             "test_blocking_reader: blocking_open_writer") < 0) {
 298                 (void)unlink("testinfo");
 299                 (void)kill(writer_pid, SIGTERM);
 300                 exit(-1);
 301         }
 302
 303         if (unlink("testfifo") < 0)
 304                 err(-1, "test_blocking_reader: unlink: testfifo");
 305 }
 306 static void
 307 test_blocking_writer(void)
 308 {
 309         pid_t reader_pid, writer_pid, wpid;
 310         int error, status;
 311
 312         if (mkfifo("testfifo", 0600) < 0)
 313                 err(-1, "test_blocking_writer: mkfifo: testfifo");
 314
 315         /*
 316          * Block a process in opening the fifo.
 317          */
 318         if (run_in_process(blocking_open_writer, &writer_pid,
 319             "test_blocking_writer: blocking_open_writer") < 0) {
 320                 (void)unlink("testfifo");
 321                 exit(-1);
 322         }
 323
 324         /*
 325          * Test that it blocked.
 326          */
 327         sleep(5);
 328         wpid = waitpid(writer_pid, &status, WNOHANG);
 329         if (wpid < 0) {
 330                 error = errno;
 331                 (void)unlink("testfifo");
 332                 errno = error;
 333                 err(-1, "test_blocking_writer: waitpid %d", writer_pid);
 334         }
 335
 336         if (wpid != 0 && wpid != writer_pid) {
 337                 (void)unlink("testfifo");
 338                 errx(-1, "test_blocking_writer: waitpid %d returned %d",
 339                     writer_pid, wpid);
 340         }
 341
 342         if (wpid == writer_pid) {
 343                 (void)unlink("testfifo");
 344                 errx(-1, "test_blocking_writer: blocking child didn't "
 345                     "block");
 346         }
 347
 348         /*
 349          * Unblock the blocking writer.
 350          */
 351         if (run_in_process(blocking_open_reader, &reader_pid,
 352             "test_blocking_writer: blocking_open_reader") < 0) {
 353                 (void)unlink("testfifo");
 354                 (void)kill(writer_pid, SIGTERM);
 355                 (void)waitpid(writer_pid, &status, 0);
 356                 exit(-1);
 357         }
 358
 359         /*
 360          * Make sure both processes exited quickly (<1 second) to make sure
 361          * they didn't block, and GC.
 362          */
 363         if (wait_and_timeout(writer_pid, 1, &status,
 364             "test_blocking_writer: blocking_open_writer") < 0) {
 365                 (void)unlink("testinfo");
 366                 (void)kill(writer_pid, SIGTERM);
 367                 (void)kill(reader_pid, SIGTERM);
 368                 (void)waitpid(writer_pid, &status, 0);
 369                 (void)waitpid(reader_pid, &status, 0);
 370                 exit(-1);
 371         }
 372
 373         if (wait_and_timeout(reader_pid, 1, &status,
 374             "test_blocking_writer: blocking_open_reader") < 0) {
 375                 (void)unlink("testinfo");
 376                 (void)kill(reader_pid, SIGTERM);
 377                 (void)waitpid(reader_pid, &status, 0);
 378                 exit(-1);
 379         }
 380
 381         if (unlink("testfifo") < 0)
 382                 err(-1, "test_blocking_writer: unlink: testfifo");
 383 }
 384
 385 static void
 386 test_non_blocking_reader(void)
 387 {
 388         int status;
 389         pid_t pid;
 390
 391         if (mkfifo("testfifo", 0600) < 0)
 392                 err(-1, "test_non_blocking_reader: mkfifo: testfifo");
 393
 394         if (run_in_process(non_blocking_open_reader, &pid,
 395             "test_non_blocking_reader: non_blocking_open_reader") < 0) {
 396                 (void)unlink("testfifo");
 397                 exit(-1);
 398         }
 399
 400         status = -1;
 401         if (wait_and_timeout(pid, 5, &status,
 402             "test_non_blocking_reader: non_blocking_open_reader") < 0) {
 403                 (void)unlink("testfifo");
 404                 exit(-1);
 405         }
 406
 407         if (WEXITSTATUS(status) != 0) {
 408                 (void)unlink("testfifo");
 409                 errno = WEXITSTATUS(status);
 410                 err(-1, "test_non_blocking_reader: "
 411                     "non_blocking_open_reader: open: testfifo");
 412         }
 413
 414         if (unlink("testfifo") < 0)
 415                 err(-1, "test_non_blocking_reader: unlink: testfifo");
 416 }
 417
 418 static void
 419 test_non_blocking_writer(void)
 420 {
 421         int status;
 422         pid_t pid;
 423
 424         if (mkfifo("testfifo", 0600) < 0)
 425                 err(-1, "test_non_blocking_writer: mkfifo: testfifo");
 426
 427         if (run_in_process(non_blocking_open_writer, &pid,
 428             "test_non_blocking_writer: non_blocking_open_writer") < 0) {
 429                 (void)unlink("testfifo");
 430                 exit(-1);
 431         }
 432
 433         status = -1;
 434         if (wait_and_timeout(pid, 5, &status,
 435             "test_non_blocking_writer: non_blocking_open_writer") < 0) {
 436                 (void)unlink("testfifo");
 437                 exit(-1);
 438         }
 439
 440         if (WEXITSTATUS(status) != ENXIO) {
 441                 (void)unlink("testfifo");
 442
 443                 errno = WEXITSTATUS(status);
 444                 if (errno == 0)
 445                         errx(-1, "test_non_blocking_writer: "
 446                             "non_blocking_open_writer: open succeeded");
 447                 err(-1, "test_non_blocking_writer: "
 448                     "non_blocking_open_writer: open: testfifo");
 449         }
 450
 451         if (unlink("testfifo") < 0)
 452                 err(-1, "test_non_blocking_writer: unlink: testfifo");
 453 }
 454
 455 int
 456 main(int argc, char *argv[])
 457 {
 458
 459         if (geteuid() != 0)
 460                 errx(-1, "must be run as root");
 461
 462         strcpy(temp_dir, "/tmp/fifo_open.XXXXXXXXXXX");
 463         if (mkdtemp(temp_dir) == NULL)
 464                 err(-1, "mkdtemp");
 465         if (chdir(temp_dir) < 0)
 466                 err(-1, "chdir: %s", temp_dir);
 467         atexit(atexit_temp_dir);
 468
 469         test_non_blocking_reader();
 470         test_non_blocking_writer();
 471
 472         test_blocking_reader();
 473         test_blocking_writer();
 474
 475         return (0);
 476 }