1 /*
2 * Copyright (c) 2015-2018 Apple Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24
25 #include <unistd.h>
26 #include <sys/ioctl.h>
27 #include <sys/types.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <util.h>
32 #include <syslog.h>
33 #include <termios.h>
34 #include <errno.h>
35 #include <fcntl.h>
36 #include <sys/socket.h>
37 #include <sys/stat.h>
38
39 #include <darwintest.h>
40 #include <darwintest_utils.h>
41 #include <darwintest_multiprocess.h>
42
43 #define TEST_TIMEOUT 10
44
45 /*
46 * Receiving SIGTTIN (from the blocked read) is the passing condition, we just
47 * catch it so that we don't get terminated when we receive this.
48 */
49 void
handle_sigttin(int signal)50 handle_sigttin(int signal)
51 {
52 return;
53 }
54
55 /*
56 * Because of the way dt_fork_helpers work, we have to ensure any children
57 * created by this function calls exit instead of getting the fork handlers exit
58 * handling
59 */
60 int
get_new_session_and_terminal_and_fork_child_to_read(char * pty_name)61 get_new_session_and_terminal_and_fork_child_to_read(char *pty_name)
62 {
63 int sock_fd[2];
64 int pty_fd;
65 pid_t pid;
66 char buf[10];
67
68 /*
69 * We use this to handshake certain actions between this process and its
70 * child.
71 */
72 T_ASSERT_POSIX_SUCCESS(socketpair(AF_UNIX, SOCK_STREAM, 0, sock_fd),
73 NULL);
74
75 /*
76 * New session, lose any existing controlling terminal and become
77 * session leader.
78 */
79 T_ASSERT_POSIX_SUCCESS(setsid(), NULL);
80
81 /* now open pty, become controlling terminal of new session */
82 T_ASSERT_POSIX_SUCCESS(pty_fd = open(pty_name, O_RDWR), NULL);
83
84 T_ASSERT_POSIX_SUCCESS(pid = fork(), NULL);
85
86 if (pid == 0) { /* child */
87 int pty_fd_child;
88 char buf[10];
89
90 T_ASSERT_POSIX_SUCCESS(close(sock_fd[0]), NULL);
91 T_ASSERT_POSIX_SUCCESS(close(pty_fd), NULL);
92
93 /* Make a new process group for ourselves */
94 T_ASSERT_POSIX_SUCCESS(setpgid(0, 0), NULL);
95
96 T_ASSERT_POSIX_SUCCESS(pty_fd_child = open(pty_name, O_RDWR),
97 NULL);
98
99 /* now let parent know we've done open and setpgid */
100 write(sock_fd[1], "done", sizeof("done"));
101
102 /* wait for parent to set us to the foreground process group */
103 read(sock_fd[1], buf, sizeof(buf));
104
105 /*
106 * We are the foreground process group now so we can read
107 * without getting a SIGTTIN.
108 *
109 * Once we are blocked though (we have a crude 1 second sleep on
110 * the parent to "detect" this), our parent is going to change
111 * us to be in the background.
112 *
113 * We'll be blocked until we get a signal and if that is signal
114 * is SIGTTIN, then the test has passed otherwise the test has
115 * failed.
116 */
117 signal(SIGTTIN, handle_sigttin);
118 (void)read(pty_fd_child, buf, sizeof(buf));
119 /*
120 * If we get here, we passed, if we get any other signal than
121 * SIGTTIN, we will not reach here.
122 */
123 exit(0);
124 }
125
126 T_ASSERT_POSIX_SUCCESS(close(sock_fd[1]), NULL);
127
128 /* wait for child to open slave side and set its pgid to its pid */
129 T_ASSERT_POSIX_SUCCESS(read(sock_fd[0], buf, sizeof(buf)), NULL);
130
131 /*
132 * We need this to happen and in the order shown
133 *
134 * parent (pgid = pid) child (child_pgid = child_pid)
135 *
136 * 1 - tcsetpgrp(child_pgid)
137 * 2 - block in read()
138 * 3 - tcsetpgrp(pgid)
139 *
140 * making sure 2 happens after 1 is easy, we use a sleep(1) in the
141 * parent to try and ensure 3 happens after 2.
142 */
143
144 T_ASSERT_POSIX_SUCCESS(tcsetpgrp(pty_fd, pid), NULL);
145
146 /* let child know you have set it to be the foreground process group */
147 T_ASSERT_POSIX_SUCCESS(write(sock_fd[0], "done", sizeof("done")), NULL);
148
149 /*
150 * give it a second to do the read of the terminal in response.
151 *
152 * XXX : Find a way to detect that the child is blocked in read(2).
153 */
154 sleep(1);
155
156 /*
157 * now change the foreground process group to ourselves -
158 * Note we are now in the background process group and we need to ignore
159 * SIGTTOU for this call to succeed.
160 *
161 * Hopefully the child has gotten to run and blocked for read on the
162 * terminal in the 1 second we slept.
163 */
164 signal(SIGTTOU, SIG_IGN);
165 T_ASSERT_POSIX_SUCCESS(tcsetpgrp(pty_fd, getpid()), NULL);
166
167 return 0;
168 }
169
170 /*
171 * We're running in a "fork helper", we can't do a waitpid on the child because
172 * the fork helper unhelpfully hides the pid of the child and in it kills itself.
173 * We will instead fork first and wait on the child. If it is
174 * able to emerge from the read of the terminal, the test passes and if it
175 * doesn't, the test fails.
176 * Since the test is testing for a deadlock in proc_exit of the child (caused
177 * by a background read in the "grandchild".
178 */
179 void
run_test(int do_revoke)180 run_test(int do_revoke)
181 {
182 int master_fd;
183 char *slave_pty;
184 pid_t pid;
185
186 T_WITH_ERRNO;
187 T_QUIET;
188
189 T_SETUPBEGIN;
190
191 slave_pty = NULL;
192 T_ASSERT_POSIX_SUCCESS(master_fd = posix_openpt(O_RDWR | O_NOCTTY),
193 NULL);
194 (void)fcntl(master_fd, F_SETFL, O_NONBLOCK);
195 T_ASSERT_POSIX_SUCCESS(grantpt(master_fd), NULL);
196 T_ASSERT_POSIX_SUCCESS(unlockpt(master_fd), NULL);
197 slave_pty = ptsname(master_fd);
198 T_ASSERT_NOTNULL(slave_pty, NULL);
199 T_LOG("slave pty is %s\n", slave_pty);
200
201 T_SETUPEND;
202
203 /*
204 * We get the stdin and stdout redirection but we don't have visibility
205 * into the child (nor can we wait for it). To get around that, we fork
206 * and only let the parent to the caller and the child exits before
207 * returning to the caller.
208 */
209 T_ASSERT_POSIX_SUCCESS(pid = fork(), NULL);
210
211 if (pid == 0) { /* child */
212 T_ASSERT_POSIX_SUCCESS(close(master_fd), NULL);
213 get_new_session_and_terminal_and_fork_child_to_read(slave_pty);
214
215 /*
216 * These tests are for testing revoke and read hangs. This
217 * revoke can be explicit by a revoke(2) system call (test 2)
218 * or as part of exit(2) of the session leader (test 1).
219 * The exit hang is the common hang and can be fixed
220 * independently but fixing the revoke(2) hang requires us make
221 * changes in the tcsetpgrp path ( which also fixes the exit
222 * hang). In essence, we have 2 fixes. One which only addresses
223 * the exit hang and one which fixes both.
224 */
225 if (do_revoke) {
226 /* This should not hang for the test to pass .. */
227 T_ASSERT_POSIX_SUCCESS(revoke(slave_pty), NULL);
228 }
229 /*
230 * This child has the same dt_helper variables as its parent
231 * The way dt_fork_helpers work if we don't exit() from here,
232 * we will be killing the parent. So we have to exit() and not
233 * let the dt_fork_helpers continue.
234 * If we didn't do the revoke(2), This test passes if this exit
235 * doesn't hang waiting for its child to finish reading.
236 */
237 exit(0);
238 }
239
240 int status;
241 int sig;
242
243 dt_waitpid(pid, &status, &sig, 0);
244 if (sig) {
245 T_FAIL("Test failed because child received signal %s\n",
246 strsignal(sig));
247 } else if (status) {
248 T_FAIL("Test failed because child exited with status %d\n",
249 status);
250 } else {
251 T_PASS("test_passed\n");
252 }
253 /*
254 * we can let this process proceed with the regular darwintest process
255 * termination and cleanup.
256 */
257 }
258
259
260 /*************************** TEST 1 ********************************/
261 T_HELPER_DECL(create_new_session_and_exit, "create_new_session_and_exit") {
262 run_test(0);
263 }
264
265 T_DECL(tty_exit_bgread_hang_test, "test for background read hang on ttys with proc exit", T_META_TAG_VM_PREFERRED)
266 {
267 dt_helper_t helpers[1];
268
269 helpers[0] = dt_fork_helper("create_new_session_and_exit");
270 dt_run_helpers(helpers, 1, TEST_TIMEOUT);
271 }
272 /*********************** END TEST 1 ********************************/
273
274 /************************** TEST 2 ***********************************/
275 T_HELPER_DECL(create_new_session_and_revoke_terminal, "create_new_session_and_revoke_terminal") {
276 run_test(1);
277 }
278
279 T_DECL(tty_revoke_bgread_hang_test, "test for background read hang on ttys with revoke", T_META_TAG_VM_PREFERRED)
280 {
281 dt_helper_t helpers[1];
282
283 helpers[0] = dt_fork_helper("create_new_session_and_revoke_terminal");
284 dt_run_helpers(helpers, 1, TEST_TIMEOUT);
285 }
286 /*********************** END TEST 2 *********************************/
287