tests/sys/file/closefrom_test.c

   1 /*-
   2  * Copyright (c) 2009 Hudson River Trading LLC
   3  * Written by: John H. Baldwin <jhb@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 /*
  32  * Regression tests for the closefrom(2) system call.
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/mman.h>
  37 #include <sys/user.h>
  38 #include <sys/wait.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <libutil.h>
  42 #include <paths.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48
  49 struct shared_info {
  50         int     failed;
  51         char    tag[64];
  52         char    message[0];
  53 };
  54
  55 static int test = 1;
  56
  57 static void
  58 ok(const char *descr)
  59 {
  60
  61         printf("ok %d - %s\n", test, descr);
  62         test++;
  63 }
  64
  65 static void
  66 fail(const char *descr, const char *fmt, ...)
  67 {
  68         va_list ap;
  69
  70         printf("not ok %d - %s", test, descr);
  71         test++;
  72         if (fmt) {
  73                 va_start(ap, fmt);
  74                 printf(" # ");
  75                 vprintf(fmt, ap);
  76                 va_end(ap);
  77         }
  78         printf("\n");
  79         exit(1);
  80 }
  81
  82 #define fail_err(descr)         fail((descr), "%s", strerror(errno))
  83
  84 static void
  85 cok(struct shared_info *info, const char *descr)
  86 {
  87
  88         info->failed = 0;
  89         strlcpy(info->tag, descr, sizeof(info->tag));
  90         exit(0);
  91 }
  92
  93 static void
  94 cfail(struct shared_info *info, const char *descr, const char *fmt, ...)
  95 {
  96         va_list ap;
  97
  98         info->failed = 1;
  99         strlcpy(info->tag, descr, sizeof(info->tag));
 100         if (fmt) {
 101                 va_start(ap, fmt);
 102                 vsprintf(info->message, fmt, ap);
 103                 va_end(ap);
 104         }
 105         exit(0);
 106 }
 107
 108 #define cfail_err(info, descr)  cfail((info), (descr), "%s", strerror(errno))
 109
 110 /*
 111  * Use kinfo_getfile() to fetch the list of file descriptors and figure out
 112  * the highest open file descriptor.
 113  */
 114 static int
 115 highest_fd(void)
 116 {
 117         struct kinfo_file *kif;
 118         int cnt, i, highest;
 119
 120         kif = kinfo_getfile(getpid(), &cnt);
 121         if (kif == NULL)
 122                 fail_err("kinfo_getfile");
 123         highest = INT_MIN;
 124         for (i = 0; i < cnt; i++)
 125                 if (kif[i].kf_fd > highest)
 126                         highest = kif[i].kf_fd;
 127         free(kif);
 128         return (highest);
 129 }
 130
 131 static int
 132 devnull(void)
 133 {
 134         int fd;
 135
 136         fd = open(_PATH_DEVNULL, O_RDONLY);
 137         if (fd < 0)
 138                 fail_err("open(\" "_PATH_DEVNULL" \")");
 139         return (fd);
 140 }
 141
 142 int
 143 main(void)
 144 {
 145         struct shared_info *info;
 146         pid_t pid;
 147         int fd, i, start;
 148
 149         printf("1..15\n");
 150
 151         /* We better start up with fd's 0, 1, and 2 open. */
 152         start = devnull();
 153         if (start == -1)
 154                 fail("open", "bad descriptor %d", start);
 155         ok("open");
 156
 157         /* Make sure highest_fd() works. */
 158         fd = highest_fd();
 159         if (start != fd)
 160                 fail("highest_fd", "bad descriptor %d != %d", start, fd);
 161         ok("highest_fd");
 162
 163         /* Try to use closefrom() for just closing fd 3. */
 164         closefrom(start + 1);
 165         fd = highest_fd();
 166         if (fd != start)
 167                 fail("closefrom", "highest fd %d", fd);
 168         ok("closefrom");
 169
 170         /* Eat up 16 descriptors. */
 171         for (i = 0; i < 16; i++)
 172                 (void)devnull();
 173         fd = highest_fd();
 174         if (fd != start + 16)
 175                 fail("open 16", "highest fd %d", fd);
 176         ok("open 16");
 177
 178         /* Close half of them. */
 179         closefrom(11);
 180         fd = highest_fd();
 181         if (fd != 10)
 182                 fail("closefrom", "highest fd %d", fd);
 183         ok("closefrom");
 184
 185         /* Explicitly close descriptors 6 and 8 to create holes. */
 186         if (close(6) < 0 || close(8) < 0)
 187                 fail_err("close2 ");
 188         ok("close 2");
 189
 190         /* Verify that close on 6 and 8 fails with EBADF. */
 191         if (close(6) == 0)
 192                 fail("close(6)", "did not fail");
 193         if (errno != EBADF)
 194                 fail_err("close(6)");
 195         ok("close(6)");
 196         if (close(8) == 0)
 197                 fail("close(8)", "did not fail");
 198         if (errno != EBADF)
 199                 fail_err("close(8)");
 200         ok("close(8)");
 201
 202         /* Close from 4 on. */
 203         closefrom(4);
 204         fd = highest_fd();
 205         if (fd != 3)
 206                 fail("closefrom", "highest fd %d", fd);
 207         ok("closefrom");
 208
 209         /* Allocate a small SHM region for IPC with our child. */
 210         info = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, MAP_ANON |
 211             MAP_SHARED, -1, 0);
 212         if (info == MAP_FAILED)
 213                 fail_err("mmap");
 214         ok("mmap");
 215
 216         /* Fork a child process to test closefrom(0). */
 217         pid = fork();
 218         if (pid < 0)
 219                 fail_err("fork");
 220         if (pid == 0) {
 221                 /* Child. */
 222                 closefrom(0);
 223                 fd = highest_fd();
 224                 if (fd >= 0)
 225                         cfail(info, "closefrom(0)", "highest fd %d", fd);
 226                 cok(info, "closefrom(0)");
 227         }
 228         if (wait(NULL) < 0)
 229                 fail_err("wait");
 230         if (info->failed)
 231                 fail(info->tag, "%s", info->message);
 232         ok(info->tag);
 233
 234         /* Fork a child process to test closefrom(-1). */
 235         pid = fork();
 236         if (pid < 0)
 237                 fail_err("fork");
 238         if (pid == 0) {
 239                 /* Child. */
 240                 closefrom(-1);
 241                 fd = highest_fd();
 242                 if (fd >= 0)
 243                         cfail(info, "closefrom(-1)", "highest fd %d", fd);
 244                 cok(info, "closefrom(-1)");
 245         }
 246         if (wait(NULL) < 0)
 247                 fail_err("wait");
 248         if (info->failed)
 249                 fail(info->tag, "%s", info->message);
 250         ok(info->tag);
 251
 252         /* Dup stdout to 6. */
 253         if (dup2(1, 6) < 0)
 254                 fail_err("dup2");
 255         fd = highest_fd();
 256         if (fd != 6)
 257                 fail("dup2", "highest fd %d", fd);
 258         ok("dup2");
 259
 260         /* Do a closefrom() starting in a hole. */
 261         closefrom(4);
 262         fd = highest_fd();
 263         if (fd != 3)
 264                 fail("closefrom", "highest fd %d", fd);
 265         ok("closefrom");
 266
 267         /* Do a closefrom() beyond our highest open fd. */
 268         closefrom(32);
 269         fd = highest_fd();
 270         if (fd != 3)
 271                 fail("closefrom", "highest fd %d", fd);
 272         ok("closefrom");
 273
 274         return (0);
 275 }