1 /* $NetBSD: t_clone.c,v 1.2 2011/07/07 16:31:11 jruoho Exp $ */ 2 3 /*- 4 * Copyright (c) 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 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 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __COPYRIGHT("@(#) Copyright (c) 2008\ 34 The NetBSD Foundation, inc. All rights reserved."); 35 __RCSID("$NetBSD: t_clone.c,v 1.2 2011/07/07 16:31:11 jruoho Exp $"); 36 37 #include <sys/mman.h> 38 #include <sys/resource.h> 39 #include <sys/types.h> 40 #include <sys/wait.h> 41 42 #include <errno.h> 43 #include <sched.h> 44 #include <signal.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 50 #include <atf-c.h> 51 52 #define STACKSIZE (8 * 1024) 53 #define FROBVAL 41973 54 #define CHILDEXIT 0xa5 55 56 /* 57 * return 1 if the stack grows down, 0 if it grows up. 58 */ 59 static int 60 stackdir(void *p) 61 { 62 int val; 63 void *q = &val; 64 65 return p < q ? 0 : 1; 66 } 67 68 static int 69 dummy(void *arg) 70 { 71 72 return 0; 73 } 74 75 static int 76 clone_func(void *arg) 77 { 78 long *frobp = arg, diff; 79 80 printf("child: stack ~= %p, frobme = %p\n", &frobp, frobp); 81 fflush(stdout); 82 83 if (frobp[0] != getppid()) 84 return 1; 85 86 if (frobp[0] == getpid()) 87 return 2; 88 89 diff = labs(frobp[1] - (long) &frobp); 90 91 if (diff > 1024) 92 return 3; 93 94 frobp[1] = FROBVAL; 95 96 return (CHILDEXIT); 97 } 98 99 ATF_TC(clone_basic); 100 ATF_TC_HEAD(clone_basic, tc) 101 { 102 103 atf_tc_set_md_var(tc, "descr", "Checks clone(2)"); 104 } 105 106 ATF_TC_BODY(clone_basic, tc) 107 { 108 sigset_t mask; 109 void *allocstack, *stack; 110 pid_t pid; 111 volatile long frobme[2]; 112 int stat; 113 114 allocstack = mmap(NULL, STACKSIZE, PROT_READ|PROT_WRITE|PROT_EXEC, 115 MAP_PRIVATE|MAP_ANON, -1, (off_t) 0); 116 117 ATF_REQUIRE_ERRNO(errno, allocstack != MAP_FAILED); 118 119 stack = (caddr_t) allocstack + STACKSIZE * stackdir(&stat); 120 121 printf("parent: stack = %p, frobme = %p\n", stack, frobme); 122 fflush(stdout); 123 124 frobme[0] = (long)getpid(); 125 frobme[1] = (long)stack; 126 127 sigemptyset(&mask); 128 sigaddset(&mask, SIGUSR1); 129 130 ATF_REQUIRE_ERRNO(errno, sigprocmask(SIG_BLOCK, &mask, NULL) != -1); 131 132 switch (pid = __clone(clone_func, stack, 133 CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|SIGUSR1, 134 __UNVOLATILE(frobme))) { 135 case 0: 136 atf_tc_fail("clone() returned 0"); 137 /*NOTREACHED*/ 138 case -1: 139 atf_tc_fail("clone() failed: %s", strerror(errno)); 140 /*NOTREACHED*/ 141 default: 142 while (waitpid(pid, &stat, __WCLONE) != pid) 143 continue; 144 } 145 146 ATF_REQUIRE_MSG(WIFEXITED(stat) != 0, "child didn't exit"); 147 148 printf("parent: childexit = 0x%x, frobme = %ld\n", 149 WEXITSTATUS(stat), frobme[1]); 150 151 switch (WEXITSTATUS(stat)) { 152 case CHILDEXIT: 153 ATF_REQUIRE_EQ(frobme[1], FROBVAL); 154 break; 155 case 1: 156 atf_tc_fail("child: argument does not contain parent's pid"); 157 /*NOTREACHED*/ 158 case 2: 159 atf_tc_fail("child: called in parent's pid"); 160 /*NOTREACHED*/ 161 case 3: 162 atf_tc_fail("child: called with bad stack"); 163 /*NOTREACHED*/ 164 default: 165 atf_tc_fail("child returned unknown code: %d", 166 WEXITSTATUS(stat)); 167 /*NOTREACHED*/ 168 } 169 170 ATF_REQUIRE_ERRNO(errno, munmap(allocstack, STACKSIZE) != -1); 171 } 172 173 ATF_TC(clone_null_stack); 174 ATF_TC_HEAD(clone_null_stack, tc) 175 { 176 177 atf_tc_set_md_var(tc, "descr", 178 "Checks that clone(2) fails when stack pointer is NULL"); 179 } 180 181 ATF_TC_BODY(clone_null_stack, tc) 182 { 183 int rv; 184 185 rv = __clone(dummy, NULL, 186 CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|SIGCHLD, NULL); 187 188 ATF_REQUIRE_EQ(rv, -1); 189 ATF_REQUIRE_EQ(errno, EINVAL); 190 } 191 192 ATF_TC(clone_null_func); 193 ATF_TC_HEAD(clone_null_func, tc) 194 { 195 196 atf_tc_set_md_var(tc, "descr", 197 "Checks that clone(2) fails when function pointer is NULL"); 198 } 199 200 ATF_TC_BODY(clone_null_func, tc) 201 { 202 void *allocstack, *stack; 203 int rv, stat; 204 205 allocstack = mmap(NULL, STACKSIZE, PROT_READ|PROT_WRITE|PROT_EXEC, 206 MAP_PRIVATE|MAP_ANON, -1, (off_t) 0); 207 ATF_REQUIRE_ERRNO(errno, allocstack != MAP_FAILED); 208 stack = (caddr_t) allocstack + STACKSIZE * stackdir(&stat); 209 210 errno = 0; 211 rv = __clone(0, stack, 212 CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|SIGCHLD, NULL); 213 214 ATF_REQUIRE_EQ(rv, -1); 215 ATF_REQUIRE_EQ(errno, EINVAL); 216 217 ATF_REQUIRE_ERRNO(errno, munmap(allocstack, STACKSIZE) != -1); 218 } 219 220 ATF_TC(clone_out_of_proc); 221 ATF_TC_HEAD(clone_out_of_proc, tc) 222 { 223 224 atf_tc_set_md_var(tc, "descr", 225 "Checks that clone(2) fails when running out of processes"); 226 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 227 } 228 229 ATF_TC_BODY(clone_out_of_proc, tc) 230 { 231 struct rlimit rl; 232 int rv; 233 234 ATF_REQUIRE_ERRNO(errno, getrlimit(RLIMIT_NPROC, &rl) != -1); 235 236 rl.rlim_cur = 0; 237 rl.rlim_max = 0; 238 239 ATF_REQUIRE_ERRNO(errno, setrlimit(RLIMIT_NPROC, &rl) != -1); 240 241 errno = 0; 242 rv = __clone(dummy, malloc(10240), 243 CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|SIGCHLD, (void *)&rl); 244 245 ATF_REQUIRE_EQ(rv, -1); 246 ATF_REQUIRE_EQ(errno, EAGAIN); 247 } 248 249 ATF_TP_ADD_TCS(tp) 250 { 251 252 ATF_TP_ADD_TC(tp, clone_basic); 253 ATF_TP_ADD_TC(tp, clone_null_stack); 254 ATF_TP_ADD_TC(tp, clone_null_func); 255 ATF_TP_ADD_TC(tp, clone_out_of_proc); 256 257 return atf_no_error(); 258 } 259