Home | History | Annotate | Line # | Download | only in sys 
      1 /* $NetBSD: t_pipe2.c,v 1.10 2025/07/17 19:50:40 kre Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2011 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Christos Zoulas.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 #include <sys/cdefs.h>
     39 __RCSID("$NetBSD: t_pipe2.c,v 1.10 2025/07/17 19:50:40 kre Exp $");
     40 
     41 #include <atf-c.h>
     42 #include <fcntl.h>
     43 #include <unistd.h>
     44 #include <stdlib.h>
     45 #include <errno.h>
     46 #include <sys/resource.h>
     47 
     48 #ifndef	FD_CLOFORK
     49 #define	FD_CLOFORK 0
     50 #endif
     51 #ifndef O_CLOFORK
     52 #define	O_CLOFORK 0
     53 #endif
     54 
     55 static void
     56 run(int flags)
     57 {
     58 	int fd[2], i;
     59 
     60 	while ((i = open("/", O_RDONLY)) < 3)
     61 		ATF_REQUIRE(i != -1);
     62 
     63 	ATF_REQUIRE_MSG(closefrom(3) != -1, "closefrom failed: %s",
     64 	    strerror(errno));
     65 
     66 	ATF_REQUIRE(pipe2(fd, flags) == 0);
     67 
     68 	ATF_REQUIRE(fd[0] == 3);
     69 	ATF_REQUIRE(fd[1] == 4);
     70 
     71 	if (flags & O_CLOEXEC) {
     72 		ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOEXEC) != 0);
     73 		ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOEXEC) != 0);
     74 	} else {
     75 		ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOEXEC) == 0);
     76 		ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOEXEC) == 0);
     77 	}
     78 
     79 	if (flags & O_CLOFORK) {
     80 		ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOFORK) != 0);
     81 		ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOFORK) != 0);
     82 	} else {
     83 		ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOFORK) == 0);
     84 		ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOFORK) == 0);
     85 	}
     86 
     87 	if (flags & O_NONBLOCK) {
     88 		ATF_REQUIRE((fcntl(fd[0], F_GETFL) & O_NONBLOCK) != 0);
     89 		ATF_REQUIRE((fcntl(fd[1], F_GETFL) & O_NONBLOCK) != 0);
     90 	} else {
     91 		ATF_REQUIRE((fcntl(fd[0], F_GETFL) & O_NONBLOCK) == 0);
     92 		ATF_REQUIRE((fcntl(fd[1], F_GETFL) & O_NONBLOCK) == 0);
     93 	}
     94 
     95 	if (flags & O_NOSIGPIPE) {
     96 		ATF_REQUIRE(fcntl(fd[0], F_GETNOSIGPIPE) != 0);
     97 		ATF_REQUIRE(fcntl(fd[1], F_GETNOSIGPIPE) != 0);
     98 	} else {
     99 		ATF_REQUIRE(fcntl(fd[0], F_GETNOSIGPIPE) == 0);
    100 		ATF_REQUIRE(fcntl(fd[1], F_GETNOSIGPIPE) == 0);
    101 	}
    102 
    103 	ATF_REQUIRE(close(fd[0]) != -1);
    104 	ATF_REQUIRE(close(fd[1]) != -1);
    105 }
    106 
    107 ATF_TC(pipe2_basic);
    108 ATF_TC_HEAD(pipe2_basic, tc)
    109 {
    110 	atf_tc_set_md_var(tc, "descr", "A basic test of pipe2(2)");
    111 }
    112 
    113 ATF_TC_BODY(pipe2_basic, tc)
    114 {
    115 	run(0);
    116 }
    117 
    118 ATF_TC(pipe2_consume);
    119 ATF_TC_HEAD(pipe2_consume, tc)
    120 {
    121 	atf_tc_set_md_var(tc, "descr", "Test that consuming file descriptors "
    122 	    "with pipe2(2) does not crash the system (PR kern/46457)");
    123 }
    124 
    125 ATF_TC_BODY(pipe2_consume, tc)
    126 {
    127 	struct rlimit rl;
    128 	int err, filedes[2];
    129 	int old;
    130 
    131 	ATF_REQUIRE_MSG(closefrom(4) != -1, "closefrom failed: %s",
    132 	    strerror(errno));
    133 
    134 	err = getrlimit(RLIMIT_NOFILE, &rl);
    135 	ATF_REQUIRE(err == 0);
    136 	/*
    137 	 * The heart of this test is to run against the number of open
    138 	 * file descriptor limit in the middle of a pipe2() call - i.e.
    139 	 * before the call only a single descriptor may be openend.
    140 	 */
    141 	old = rl.rlim_cur;
    142 	rl.rlim_cur = 4;
    143 	err = setrlimit(RLIMIT_NOFILE, &rl);
    144 	ATF_REQUIRE(err == 0);
    145 
    146 	err = pipe2(filedes, O_CLOEXEC);
    147 	ATF_REQUIRE(err == -1);
    148 	rl.rlim_cur = old;
    149 	err = setrlimit(RLIMIT_NOFILE, &rl);
    150 }
    151 
    152 ATF_TC(pipe2_nonblock);
    153 ATF_TC_HEAD(pipe2_nonblock, tc)
    154 {
    155 	atf_tc_set_md_var(tc, "descr", "A non-blocking test of pipe2(2)");
    156 }
    157 
    158 ATF_TC_BODY(pipe2_nonblock, tc)
    159 {
    160 	run(O_NONBLOCK);
    161 }
    162 
    163 ATF_TC(pipe2_cloexec);
    164 ATF_TC_HEAD(pipe2_cloexec, tc)
    165 {
    166 	atf_tc_set_md_var(tc, "descr", "A close-on-exec test of pipe2(2)");
    167 }
    168 
    169 ATF_TC_BODY(pipe2_cloexec, tc)
    170 {
    171 	run(O_CLOEXEC);
    172 }
    173 
    174 ATF_TC(pipe2_clofork);
    175 ATF_TC_HEAD(pipe2_clofork, tc)
    176 {
    177 	atf_tc_set_md_var(tc, "descr", "A close-on-fork test of pipe2(2)");
    178 }
    179 
    180 ATF_TC_BODY(pipe2_clofork, tc)
    181 {
    182 #if defined(O_CLOFORK) && O_CLOFORK != 0
    183 	run(O_CLOFORK);
    184 #else
    185 	atf_tc_skip("O_CLOFORK not yet implemented");
    186 #endif
    187 }
    188 
    189 ATF_TC(pipe2_nosigpipe);
    190 ATF_TC_HEAD(pipe2_nosigpipe, tc)
    191 {
    192 	atf_tc_set_md_var(tc, "descr", "A no sigpipe test of pipe2(2)");
    193 }
    194 
    195 ATF_TC_BODY(pipe2_nosigpipe, tc)
    196 {
    197 	run(O_NOSIGPIPE);
    198 }
    199 
    200 ATF_TC(pipe2_einval);
    201 ATF_TC_HEAD(pipe2_einval, tc)
    202 {
    203 	atf_tc_set_md_var(tc, "descr", "A error check of pipe2(2)");
    204 }
    205 
    206 ATF_TC_BODY(pipe2_einval, tc)
    207 {
    208 	int fd[2];
    209 	ATF_REQUIRE_ERRNO(EINVAL, pipe2(fd, O_ASYNC) == -1);
    210 }
    211 
    212 ATF_TP_ADD_TCS(tp)
    213 {
    214 
    215 	ATF_TP_ADD_TC(tp, pipe2_basic);
    216 	ATF_TP_ADD_TC(tp, pipe2_consume);
    217 	ATF_TP_ADD_TC(tp, pipe2_nonblock);
    218 	ATF_TP_ADD_TC(tp, pipe2_cloexec);
    219 	ATF_TP_ADD_TC(tp, pipe2_clofork);
    220 	ATF_TP_ADD_TC(tp, pipe2_nosigpipe);
    221 	ATF_TP_ADD_TC(tp, pipe2_einval);
    222 
    223 	return atf_no_error();
    224 }
    225