Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 1994-1996 Rick Sladkey <jrs@world.std.com>
3 : : * Copyright (c) 1996-2000 Wichert Akkerman <wichert@cistron.nl>
4 : : * Copyright (c) 2005-2007 Roland McGrath <roland@redhat.com>
5 : : * Copyright (c) 2008-2015 Dmitry V. Levin <ldv@altlinux.org>
6 : : * All rights reserved.
7 : : *
8 : : * Redistribution and use in source and binary forms, with or without
9 : : * modification, are permitted provided that the following conditions
10 : : * are met:
11 : : * 1. Redistributions of source code must retain the above copyright
12 : : * notice, this list of conditions and the following disclaimer.
13 : : * 2. Redistributions in binary form must reproduce the above copyright
14 : : * notice, this list of conditions and the following disclaimer in the
15 : : * documentation and/or other materials provided with the distribution.
16 : : * 3. The name of the author may not be used to endorse or promote products
17 : : * derived from this software without specific prior written permission.
18 : : *
19 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 : : * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 : : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 : : * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 : : * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 : : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 : : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 : : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 : : * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 : : */
30 : :
31 : : #include "defs.h"
32 : :
33 : : #include <linux/prctl.h>
34 : :
35 : : #include "xlat/prctl_options.h"
36 : : #include "xlat/pr_cap_ambient.h"
37 : : #include "xlat/pr_dumpable.h"
38 : : #include "xlat/pr_fp_mode.h"
39 : : #include "xlat/pr_mce_kill.h"
40 : : #include "xlat/pr_mce_kill_policy.h"
41 : : #include "xlat/pr_set_mm.h"
42 : : #include "xlat/pr_tsc.h"
43 : : #include "xlat/pr_unalign_flags.h"
44 : :
45 : : #ifndef TASK_COMM_LEN
46 : : # define TASK_COMM_LEN 16
47 : : #endif
48 : :
49 : : #ifdef HAVE_LINUX_SECCOMP_H
50 : : # include <linux/seccomp.h>
51 : : #endif
52 : : #include "xlat/seccomp_mode.h"
53 : :
54 : : #ifdef HAVE_LINUX_SECUREBITS_H
55 : : # include <linux/securebits.h>
56 : : #endif
57 : : #include "xlat/secbits.h"
58 : :
59 : : /* these constants are the same as in <linux/capability.h> */
60 : : enum {
61 : : #include "caps0.h"
62 : : #include "caps1.h"
63 : : };
64 : :
65 : : #include "xlat/cap.h"
66 : :
67 : : static void
68 : 10 : print_prctl_args(struct tcb *tcp, const unsigned int first)
69 : : {
70 : : unsigned int i;
71 : :
72 [ + + ]: 40 : for (i = first; i < tcp->s_ent->nargs; ++i)
73 : 30 : tprintf(", %#" PRI_klx, tcp->u_arg[i]);
74 : 10 : }
75 : :
76 : 811 : SYS_FUNC(prctl)
77 : : {
78 : 811 : const unsigned int option = tcp->u_arg[0];
79 : 811 : const kernel_ulong_t arg2 = tcp->u_arg[1];
80 : 811 : const kernel_ulong_t arg3 = tcp->u_arg[2];
81 : : /*
82 : : * PR_SET_VMA is the only command which actually uses these arguments
83 : : * currently, and it is available only on Android for now.
84 : : */
85 : : #ifdef __ANDROID__
86 : : const kernel_ulong_t arg4 = tcp->u_arg[3];
87 : : const kernel_ulong_t arg5 = tcp->u_arg[4];
88 : : #endif
89 : : unsigned int i;
90 : :
91 [ + + ]: 811 : if (entering(tcp))
92 : 555 : printxval(prctl_options, option, "PR_???");
93 : :
94 [ + + + + : 811 : switch (option) {
+ + + + -
- + - + -
- - + - +
- + + - +
- + - -
- ]
95 : : case PR_GET_KEEPCAPS:
96 : : case PR_GET_SECCOMP:
97 : : case PR_GET_TIMERSLACK:
98 : : case PR_GET_TIMING:
99 : 20 : return RVAL_DECODED;
100 : :
101 : : case PR_GET_CHILD_SUBREAPER:
102 : : case PR_GET_ENDIAN:
103 : : case PR_GET_FPEMU:
104 : : case PR_GET_FPEXC:
105 [ + + ]: 192 : if (entering(tcp))
106 : 96 : tprints(", ");
107 : : else
108 : 96 : printnum_int(tcp, arg2, "%u");
109 : 192 : break;
110 : :
111 : : case PR_GET_DUMPABLE:
112 [ + + ]: 30 : if (entering(tcp))
113 : 15 : break;
114 [ - + ]: 15 : if (syserror(tcp))
115 : 0 : return 0;
116 : 15 : tcp->auxstr = xlookup(pr_dumpable, (kernel_ulong_t) tcp->u_rval);
117 : 15 : return RVAL_STR;
118 : :
119 : : case PR_GET_NAME:
120 [ + + ]: 180 : if (entering(tcp)) {
121 : 90 : tprints(", ");
122 : : } else {
123 [ + + ]: 90 : if (syserror(tcp))
124 : 85 : printaddr(arg2);
125 : : else
126 : 5 : printstr_ex(tcp, arg2, TASK_COMM_LEN,
127 : : QUOTE_0_TERMINATED);
128 : : }
129 : 180 : break;
130 : :
131 : : case PR_GET_PDEATHSIG:
132 [ + + ]: 30 : if (entering(tcp)) {
133 : 15 : tprints(", ");
134 [ + + ]: 15 : } else if (!umove_or_printaddr(tcp, arg2, &i)) {
135 : 5 : tprints("[");
136 : 5 : tprints(signame(i));
137 : 5 : tprints("]");
138 : : }
139 : 30 : break;
140 : :
141 : : case PR_GET_SECUREBITS:
142 [ + + ]: 10 : if (entering(tcp))
143 : 5 : break;
144 [ + - ][ + - ]: 5 : if (syserror(tcp) || tcp->u_rval == 0)
145 : 5 : return 0;
146 : 0 : tcp->auxstr = sprintflags("", secbits,
147 : 0 : (kernel_ulong_t) tcp->u_rval);
148 : 0 : return RVAL_STR;
149 : :
150 : : case PR_GET_TID_ADDRESS:
151 [ + + ]: 40 : if (entering(tcp))
152 : 20 : tprints(", ");
153 : : else
154 : 20 : printnum_kptr(tcp, arg2);
155 : 40 : break;
156 : :
157 : : case PR_GET_TSC:
158 [ + + ]: 30 : if (entering(tcp)) {
159 : 15 : tprints(", ");
160 [ + + ]: 15 : } else if (!umove_or_printaddr(tcp, arg2, &i)) {
161 : 5 : tprints("[");
162 : 5 : printxval(pr_tsc, i, "PR_TSC_???");
163 : 5 : tprints("]");
164 : : }
165 : 30 : break;
166 : :
167 : : case PR_GET_UNALIGN:
168 [ # # ]: 0 : if (entering(tcp)) {
169 : 0 : tprints(", ");
170 [ # # ]: 0 : } else if (!umove_or_printaddr(tcp, arg2, &i)) {
171 : 0 : tprints("[");
172 : 0 : printflags(pr_unalign_flags, i, "PR_UNALIGN_???");
173 : 0 : tprints("]");
174 : : }
175 : 0 : break;
176 : :
177 : : case PR_GET_FP_MODE:
178 [ # # ]: 0 : if (entering(tcp))
179 : 0 : break;
180 [ # # ][ # # ]: 0 : if (syserror(tcp) || tcp->u_rval == 0)
181 : 0 : return 0;
182 : 0 : tcp->auxstr = sprintflags("", pr_fp_mode,
183 : 0 : (kernel_ulong_t) tcp->u_rval);
184 : 0 : return RVAL_STR;
185 : :
186 : : /* PR_TASK_PERF_EVENTS_* take no arguments. */
187 : : case PR_TASK_PERF_EVENTS_DISABLE:
188 : : case PR_TASK_PERF_EVENTS_ENABLE:
189 : 10 : return RVAL_DECODED;
190 : :
191 : : case PR_SET_CHILD_SUBREAPER:
192 : : case PR_SET_ENDIAN:
193 : : case PR_SET_FPEMU:
194 : : case PR_SET_FPEXC:
195 : : case PR_SET_KEEPCAPS:
196 : : case PR_SET_TIMING:
197 : 0 : tprintf(", %" PRI_klu, arg2);
198 : 0 : return RVAL_DECODED;
199 : :
200 : : case PR_SET_DUMPABLE:
201 : 30 : tprints(", ");
202 : 30 : printxval64(pr_dumpable, arg2, "SUID_DUMP_???");
203 : 30 : return RVAL_DECODED;
204 : :
205 : : case PR_CAPBSET_DROP:
206 : : case PR_CAPBSET_READ:
207 : 0 : tprints(", ");
208 : 0 : printxval64(cap, arg2, "CAP_???");
209 : 0 : return RVAL_DECODED;
210 : :
211 : : case PR_CAP_AMBIENT:
212 : 0 : tprints(", ");
213 : 0 : printxval64(pr_cap_ambient, arg2,
214 : : "PR_CAP_AMBIENT_???");
215 [ # # ]: 0 : switch (arg2) {
216 : : case PR_CAP_AMBIENT_RAISE:
217 : : case PR_CAP_AMBIENT_LOWER:
218 : : case PR_CAP_AMBIENT_IS_SET:
219 : 0 : tprints(", ");
220 : 0 : printxval64(cap, arg3, "CAP_???");
221 : 0 : print_prctl_args(tcp, 3);
222 : 0 : break;
223 : : default:
224 : 0 : print_prctl_args(tcp, 2);
225 : 0 : break;
226 : : }
227 : 0 : return RVAL_DECODED;
228 : :
229 : : case PR_MCE_KILL:
230 : 0 : tprints(", ");
231 : 0 : printxval64(pr_mce_kill, arg2, "PR_MCE_KILL_???");
232 : 0 : tprints(", ");
233 [ # # ]: 0 : if (PR_MCE_KILL_SET == arg2)
234 : 0 : printxval64(pr_mce_kill_policy, arg3,
235 : : "PR_MCE_KILL_???");
236 : : else
237 : 0 : tprintf("%#" PRI_klx, arg3);
238 : 0 : print_prctl_args(tcp, 3);
239 : 0 : return RVAL_DECODED;
240 : :
241 : : case PR_SET_NAME:
242 : 175 : tprints(", ");
243 : 175 : printstr_ex(tcp, arg2, TASK_COMM_LEN - 1,
244 : : QUOTE_0_TERMINATED);
245 : 175 : return RVAL_DECODED;
246 : :
247 : : #ifdef __ANDROID__
248 : : # ifndef PR_SET_VMA_ANON_NAME
249 : : # define PR_SET_VMA_ANON_NAME 0
250 : : # endif
251 : : case PR_SET_VMA:
252 : : if (arg2 == PR_SET_VMA_ANON_NAME) {
253 : : tprintf(", PR_SET_VMA_ANON_NAME, %#" PRI_klx, arg3);
254 : : tprintf(", %" PRI_klu ", ", arg4);
255 : : printstr(tcp, arg5);
256 : : } else {
257 : : /* There are no other sub-options now, but there
258 : : * might be in future... */
259 : : print_prctl_args(tcp, 1);
260 : : }
261 : : return RVAL_DECODED;
262 : : #endif
263 : :
264 : : case PR_SET_MM:
265 : 0 : tprints(", ");
266 : 0 : printxval(pr_set_mm, arg2, "PR_SET_MM_???");
267 : 0 : print_prctl_args(tcp, 2);
268 : 0 : return RVAL_DECODED;
269 : :
270 : : case PR_SET_PDEATHSIG:
271 : 10 : tprints(", ");
272 [ + + ]: 10 : if (arg2 > 128)
273 : 5 : tprintf("%" PRI_klu, arg2);
274 : : else
275 : 5 : tprints(signame(arg2));
276 : 10 : return RVAL_DECODED;
277 : :
278 : : case PR_SET_PTRACER:
279 : 0 : tprints(", ");
280 [ # # ]: 0 : if ((int) arg2 == -1)
281 : 0 : tprints("PR_SET_PTRACER_ANY");
282 : : else
283 : 0 : tprintf("%" PRI_klu, arg2);
284 : 0 : return RVAL_DECODED;
285 : :
286 : : case PR_SET_SECCOMP:
287 : 15 : tprints(", ");
288 : 15 : printxval64(seccomp_mode, arg2,
289 : : "SECCOMP_MODE_???");
290 [ + + ]: 15 : if (SECCOMP_MODE_STRICT == arg2)
291 : 5 : return RVAL_DECODED;
292 [ + + ]: 10 : if (SECCOMP_MODE_FILTER == arg2) {
293 : 5 : tprints(", ");
294 : 5 : print_seccomp_filter(tcp, arg3);
295 : 5 : return RVAL_DECODED;
296 : : }
297 : 5 : print_prctl_args(tcp, 2);
298 : 5 : return RVAL_DECODED;
299 : :
300 : : case PR_SET_SECUREBITS:
301 : 19 : tprints(", ");
302 : 19 : printflags64(secbits, arg2, "SECBIT_???");
303 : 19 : return RVAL_DECODED;
304 : :
305 : : case PR_SET_TIMERSLACK:
306 : 0 : tprintf(", %" PRI_kld, arg2);
307 : 0 : return RVAL_DECODED;
308 : :
309 : : case PR_SET_TSC:
310 : 15 : tprints(", ");
311 : 15 : printxval(pr_tsc, arg2, "PR_TSC_???");
312 : 15 : return RVAL_DECODED;
313 : :
314 : : case PR_SET_UNALIGN:
315 : 0 : tprints(", ");
316 : 0 : printflags(pr_unalign_flags, arg2, "PR_UNALIGN_???");
317 : 0 : return RVAL_DECODED;
318 : :
319 : : case PR_SET_NO_NEW_PRIVS:
320 : : case PR_SET_THP_DISABLE:
321 : 5 : tprintf(", %" PRI_klu, arg2);
322 : 5 : print_prctl_args(tcp, 2);
323 : 5 : return RVAL_DECODED;
324 : :
325 : : case PR_MCE_KILL_GET:
326 [ # # ]: 0 : if (entering(tcp)) {
327 : 0 : print_prctl_args(tcp, 1);
328 : 0 : return 0;
329 : : }
330 [ # # ]: 0 : if (syserror(tcp))
331 : 0 : return 0;
332 : 0 : tcp->auxstr = xlookup(pr_mce_kill_policy,
333 : 0 : (kernel_ulong_t) tcp->u_rval);
334 [ # # ]: 0 : return tcp->auxstr ? RVAL_STR : RVAL_UDECIMAL;
335 : :
336 : : case PR_SET_FP_MODE:
337 : 0 : tprints(", ");
338 : 0 : printflags(pr_fp_mode, arg2, "PR_FP_MODE_???");
339 : 0 : return RVAL_DECODED;
340 : :
341 : : case PR_GET_NO_NEW_PRIVS:
342 : : case PR_GET_THP_DISABLE:
343 : : case PR_MPX_DISABLE_MANAGEMENT:
344 : : case PR_MPX_ENABLE_MANAGEMENT:
345 : : default:
346 : 0 : print_prctl_args(tcp, 1);
347 : 0 : return RVAL_DECODED;
348 : : }
349 : 811 : return 0;
350 : : }
351 : :
352 : : #if defined X86_64 || defined X32
353 : : # include <asm/prctl.h>
354 : : # include "xlat/archvals.h"
355 : :
356 : 12 : SYS_FUNC(arch_prctl)
357 : : {
358 : 12 : const unsigned int option = tcp->u_arg[0];
359 : 12 : const kernel_ulong_t addr = tcp->u_arg[1];
360 : :
361 [ + - ]: 12 : if (entering(tcp))
362 : 12 : printxval(archvals, option, "ARCH_???");
363 : :
364 [ - + ]: 12 : switch (option) {
365 : : case ARCH_GET_GS:
366 : : case ARCH_GET_FS:
367 [ # # ]: 0 : if (entering(tcp))
368 : 0 : tprints(", ");
369 : : else
370 : 0 : printnum_ptr(tcp, addr);
371 : 0 : return 0;
372 : : }
373 : :
374 : 12 : tprintf(", %#" PRI_klx, addr);
375 : 12 : return RVAL_DECODED;
376 : : }
377 : : #endif /* X86_64 || X32 */
|
