1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 1994-1996 Søren Schmidt
5 * Copyright (c) 2006 Roman Divacky
6 * Copyright (c) 2013 Dmitry Chagin
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/fcntl.h>
37 #include <sys/imgact.h>
38 #include <sys/kernel.h>
39 #include <sys/ktr.h>
40 #include <sys/lock.h>
41 #include <sys/malloc.h>
42 #include <sys/mutex.h>
43 #include <sys/sx.h>
44 #include <sys/proc.h>
45 #include <sys/syscallsubr.h>
46 #include <sys/sysent.h>
47
48 #include <compat/linux/linux_emul.h>
49 #include <compat/linux/linux_misc.h>
50 #include <compat/linux/linux_persona.h>
51 #include <compat/linux/linux_util.h>
52
53 #if BYTE_ORDER == LITTLE_ENDIAN
54 #define SHELLMAGIC 0x2123 /* #! */
55 #else
56 #define SHELLMAGIC 0x2321
57 #endif
58
59 /*
60 * This returns reference to the thread emuldata entry (if found)
61 *
62 * Hold PROC_LOCK when referencing emuldata from other threads.
63 */
64 struct linux_emuldata *
65 em_find(struct thread *td)
66 {
67 struct linux_emuldata *em;
68
69 em = td->td_emuldata;
70
71 return (em);
72 }
73
74 /*
75 * This returns reference to the proc pemuldata entry (if found)
76 *
77 * Hold PROC_LOCK when referencing proc pemuldata from other threads.
78 * Hold LINUX_PEM_LOCK wher referencing pemuldata members.
79 */
80 struct linux_pemuldata *
81 pem_find(struct proc *p)
82 {
83 struct linux_pemuldata *pem;
84
85 pem = p->p_emuldata;
86
87 return (pem);
88 }
89
90 void
91 linux_proc_init(struct thread *td, struct thread *newtd, int flags)
92 {
93 struct linux_emuldata *em;
94 struct linux_pemuldata *pem;
95 struct epoll_emuldata *emd;
96 struct proc *p;
97
98 if (newtd != NULL) {
99 p = newtd->td_proc;
100
101 /* non-exec call */
102 em = malloc(sizeof(*em), M_TEMP, M_WAITOK | M_ZERO);
103 if (flags & LINUX_CLONE_THREAD) {
104 LINUX_CTR1(proc_init, "thread newtd(%d)",
105 newtd->td_tid);
106
107 em->em_tid = newtd->td_tid;
108 } else {
109 LINUX_CTR1(proc_init, "fork newtd(%d)", p->p_pid);
110
111 em->em_tid = p->p_pid;
112
113 pem = malloc(sizeof(*pem), M_LINUX, M_WAITOK | M_ZERO);
114 sx_init(&pem->pem_sx, "lpemlk");
115 p->p_emuldata = pem;
116 }
117 newtd->td_emuldata = em;
118 } else {
119 p = td->td_proc;
120
121 /* exec */
122 LINUX_CTR1(proc_init, "exec newtd(%d)", p->p_pid);
123
124 /* lookup the old one */
125 em = em_find(td);
126 KASSERT(em != NULL, ("proc_init: emuldata not found in exec case.\n"));
127
128 em->em_tid = p->p_pid;
129 em->flags = 0;
130 em->robust_futexes = NULL;
131 em->child_clear_tid = NULL;
132 em->child_set_tid = NULL;
133
134 /* epoll should be destroyed in a case of exec. */
135 pem = pem_find(p);
136 KASSERT(pem != NULL, ("proc_exit: proc emuldata not found.\n"));
137 pem->persona = 0;
138 if (pem->epoll != NULL) {
139 emd = pem->epoll;
140 pem->epoll = NULL;
141 free(emd, M_EPOLL);
142 }
143 }
144
145 }
146
147 void
148 linux_proc_exit(void *arg __unused, struct proc *p)
149 {
150 struct linux_pemuldata *pem;
151 struct epoll_emuldata *emd;
152 struct thread *td = curthread;
153
154 if (__predict_false(SV_CURPROC_ABI() != SV_ABI_LINUX))
155 return;
156
157 LINUX_CTR3(proc_exit, "thread(%d) proc(%d) p %p",
158 td->td_tid, p->p_pid, p);
159
160 pem = pem_find(p);
161 if (pem == NULL)
162 return;
163 (p->p_sysent->sv_thread_detach)(td);
164
165 p->p_emuldata = NULL;
166
167 if (pem->epoll != NULL) {
168 emd = pem->epoll;
169 pem->epoll = NULL;
170 free(emd, M_EPOLL);
171 }
172
173 sx_destroy(&pem->pem_sx);
174 free(pem, M_LINUX);
175 }
176
177 /*
178 * If a Linux binary is exec'ing something, try this image activator
179 * first. We override standard shell script execution in order to
180 * be able to modify the interpreter path. We only do this if a Linux
181 * binary is doing the exec, so we do not create an EXEC module for it.
182 */
183 int
184 linux_exec_imgact_try(struct image_params *imgp)
185 {
186 const char *head = (const char *)imgp->image_header;
187 char *rpath;
188 int error = -1;
189
190 /*
191 * The interpreter for shell scripts run from a Linux binary needs
192 * to be located in /compat/linux if possible in order to recursively
193 * maintain Linux path emulation.
194 */
195 if (((const short *)head)[0] == SHELLMAGIC) {
196 /*
197 * Run our normal shell image activator. If it succeeds attempt
198 * to use the alternate path for the interpreter. If an
199 * alternate path is found, use our stringspace to store it.
200 */
201 if ((error = exec_shell_imgact(imgp)) == 0) {
202 linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
203 imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0,
204 AT_FDCWD);
205 if (rpath != NULL)
206 imgp->args->fname_buf =
207 imgp->interpreter_name = rpath;
208 }
209 }
210 return (error);
211 }
212
213 int
214 linux_common_execve(struct thread *td, struct image_args *eargs)
215 {
216 struct linux_pemuldata *pem;
217 struct epoll_emuldata *emd;
218 struct vmspace *oldvmspace;
219 struct linux_emuldata *em;
220 struct proc *p;
221 int error;
222
223 p = td->td_proc;
224
225 error = pre_execve(td, &oldvmspace);
226 if (error != 0)
227 return (error);
228
229 error = kern_execve(td, eargs, NULL, oldvmspace);
230 post_execve(td, error, oldvmspace);
231 if (error != 0)
232 return (error);
233
234 /*
235 * In a case of transition from Linux binary execing to
236 * FreeBSD binary we destroy Linux emuldata thread & proc entries.
237 */
238 if (SV_CURPROC_ABI() != SV_ABI_LINUX) {
239 PROC_LOCK(p);
240 em = em_find(td);
241 KASSERT(em != NULL, ("proc_exec: thread emuldata not found.\n"));
242 td->td_emuldata = NULL;
243
244 pem = pem_find(p);
245 KASSERT(pem != NULL, ("proc_exec: proc pemuldata not found.\n"));
246 p->p_emuldata = NULL;
247 PROC_UNLOCK(p);
248
249 if (pem->epoll != NULL) {
250 emd = pem->epoll;
251 pem->epoll = NULL;
252 free(emd, M_EPOLL);
253 }
254
255 free(em, M_TEMP);
256 free(pem, M_LINUX);
257 }
258 return (0);
259 }
260
261 void
262 linux_proc_exec(void *arg __unused, struct proc *p, struct image_params *imgp)
263 {
264 struct thread *td;
265 struct thread *othertd;
266 #if defined(__amd64__)
267 struct linux_pemuldata *pem;
268 #endif
269
270 td = curthread;
271
272 /*
273 * In a case of execing to Linux binary we create Linux
274 * emuldata thread entry.
275 */
276 if (__predict_false((imgp->sysent->sv_flags & SV_ABI_MASK) ==
277 SV_ABI_LINUX)) {
278 if (SV_PROC_ABI(p) == SV_ABI_LINUX) {
279 /*
280 * Process already was under Linuxolator
281 * before exec. Update emuldata to reflect
282 * single-threaded cleaned state after exec.
283 */
284 linux_proc_init(td, NULL, 0);
285 } else {
286 /*
287 * We are switching the process to Linux emulator.
288 */
289 linux_proc_init(td, td, 0);
290
291 /*
292 * Create a transient td_emuldata for all suspended
293 * threads, so that p->p_sysent->sv_thread_detach() ==
294 * linux_thread_detach() can find expected but unused
295 * emuldata.
296 */
297 FOREACH_THREAD_IN_PROC(td->td_proc, othertd) {
298 if (othertd != td) {
299 linux_proc_init(td, othertd,
300 LINUX_CLONE_THREAD);
301 }
302 }
303 }
304 #if defined(__amd64__)
305 /*
306 * An IA32 executable which has executable stack will have the
307 * READ_IMPLIES_EXEC personality flag set automatically.
308 */
309 if (SV_PROC_FLAG(td->td_proc, SV_ILP32) &&
310 imgp->stack_prot & VM_PROT_EXECUTE) {
311 pem = pem_find(p);
312 pem->persona |= LINUX_READ_IMPLIES_EXEC;
313 }
314 #endif
315 }
316 }
317
318 void
319 linux_thread_dtor(void *arg __unused, struct thread *td)
320 {
321 struct linux_emuldata *em;
322
323 em = em_find(td);
324 if (em == NULL)
325 return;
326 td->td_emuldata = NULL;
327
328 LINUX_CTR1(thread_dtor, "thread(%d)", em->em_tid);
329
330 free(em, M_TEMP);
331 }
332
333 void
334 linux_schedtail(struct thread *td)
335 {
336 struct linux_emuldata *em;
337 struct proc *p;
338 int error = 0;
339 int *child_set_tid;
340
341 p = td->td_proc;
342
343 em = em_find(td);
344 KASSERT(em != NULL, ("linux_schedtail: thread emuldata not found.\n"));
345 child_set_tid = em->child_set_tid;
346
347 if (child_set_tid != NULL) {
348 error = copyout(&em->em_tid, child_set_tid,
349 sizeof(em->em_tid));
350 LINUX_CTR4(schedtail, "thread(%d) %p stored %d error %d",
351 td->td_tid, child_set_tid, em->em_tid, error);
352 } else
353 LINUX_CTR1(schedtail, "thread(%d)", em->em_tid);
354 }
Cache object: cb4ccb7ab3667a586afe56a29f4c56c8
|