blob: 997d01944f91d5c84e4778c59b1ac429c814b4bb [file] [log] [blame]
Gennady Sharapov60d339f2005-09-03 15:57:47 -07001/*
Jeff Dikeba180fd2007-10-16 01:27:00 -07002 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Licensed under the GPL
4 */
5
6#include <stdio.h>
Jeff Dike0f80bc82005-09-16 19:27:50 -07007#include <stdlib.h>
Jeff Dikeba180fd2007-10-16 01:27:00 -07008#include <stdarg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <unistd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <errno.h>
Jeff Dikeba180fd2007-10-16 01:27:00 -070011#include <fcntl.h>
12#include <sched.h>
13#include <signal.h>
14#include <string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <sys/mman.h>
Jeff Dikeba180fd2007-10-16 01:27:00 -070016#include <sys/ptrace.h>
17#include <sys/stat.h>
18#include <sys/wait.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/unistd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "init.h"
Jeff Dike0f80bc82005-09-16 19:27:50 -070021#include "kern_constants.h"
Jeff Dikeba180fd2007-10-16 01:27:00 -070022#include "os.h"
23#include "mem_user.h"
24#include "ptrace_user.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "registers.h"
Jeff Dikeba180fd2007-10-16 01:27:00 -070026#include "skas_ptrace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
WANG Cong626c59f2008-04-28 02:13:53 -070028static void ptrace_child(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070029{
30 int ret;
Jeff Dike512b6fb2007-10-16 01:27:11 -070031 /* Calling os_getpid because some libcs cached getpid incorrectly */
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 int pid = os_getpid(), ppid = getppid();
33 int sc_result;
34
WANG Cong626c59f2008-04-28 02:13:53 -070035 if (change_sig(SIGWINCH, 0) < 0 ||
36 ptrace(PTRACE_TRACEME, 0, 0, 0) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 perror("ptrace");
Jeff Dike512b6fb2007-10-16 01:27:11 -070038 kill(pid, SIGKILL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 }
Jeff Dike73c8f442007-02-10 01:44:20 -080040 kill(pid, SIGSTOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Jeff Dikeba180fd2007-10-16 01:27:00 -070042 /*
43 * This syscall will be intercepted by the parent. Don't call more than
44 * once, please.
45 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 sc_result = os_getpid();
47
48 if (sc_result == pid)
Jeff Dikeba180fd2007-10-16 01:27:00 -070049 /* Nothing modified by the parent, we are running normally. */
50 ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 else if (sc_result == ppid)
Jeff Dikeba180fd2007-10-16 01:27:00 -070052 /*
53 * Expected in check_ptrace and check_sysemu when they succeed
54 * in modifying the stack frame
55 */
56 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 else
Jeff Dikeba180fd2007-10-16 01:27:00 -070058 /* Serious trouble! This could be caused by a bug in host 2.6
59 * SKAS3/2.6 patch before release -V6, together with a bug in
60 * the UML code itself.
61 */
62 ret = 2;
Jeff Dikebf8fde72008-02-04 22:31:04 -080063
64 exit(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065}
66
WANG Congc9a30722008-02-04 22:30:35 -080067static void fatal_perror(const char *str)
Jeff Dike3a150e12007-02-10 01:44:28 -080068{
69 perror(str);
70 exit(1);
71}
72
73static void fatal(char *fmt, ...)
74{
75 va_list list;
76
77 va_start(list, fmt);
WANG Cong626c59f2008-04-28 02:13:53 -070078 vfprintf(stderr, fmt, list);
Jeff Dike3a150e12007-02-10 01:44:28 -080079 va_end(list);
Jeff Dike3a150e12007-02-10 01:44:28 -080080
81 exit(1);
82}
83
84static void non_fatal(char *fmt, ...)
85{
86 va_list list;
87
88 va_start(list, fmt);
WANG Cong626c59f2008-04-28 02:13:53 -070089 vfprintf(stderr, fmt, list);
Jeff Dike3a150e12007-02-10 01:44:28 -080090 va_end(list);
Jeff Dike3a150e12007-02-10 01:44:28 -080091}
92
Jeff Dike3cdaf452007-10-16 01:27:09 -070093static int start_ptraced_child(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 int pid, n, status;
Gennady Sharapov60d339f2005-09-03 15:57:47 -070096
Jeff Dike3cdaf452007-10-16 01:27:09 -070097 pid = fork();
98 if (pid == 0)
99 ptrace_child();
100 else if (pid < 0)
101 fatal_perror("start_ptraced_child : fork failed");
Jeff Dikeba180fd2007-10-16 01:27:00 -0700102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
Jeff Dikeba180fd2007-10-16 01:27:00 -0700104 if (n < 0)
Jeff Dike3cdaf452007-10-16 01:27:09 -0700105 fatal_perror("check_ptrace : waitpid failed");
Jeff Dikeba180fd2007-10-16 01:27:00 -0700106 if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
Jeff Dike3a150e12007-02-10 01:44:28 -0800107 fatal("check_ptrace : expected SIGSTOP, got status = %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 status);
109
Jeff Dike9eae9b12007-02-10 01:44:20 -0800110 return pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700113/* When testing for SYSEMU support, if it is one of the broken versions, we
114 * must just avoid using sysemu, not panic, but only if SYSEMU features are
115 * broken.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 * So only for SYSEMU features we test mustpanic, while normal host features
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700117 * must work anyway!
118 */
Jeff Dike3cdaf452007-10-16 01:27:09 -0700119static int stop_ptraced_child(int pid, int exitcode, int mustexit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
121 int status, n, ret = 0;
122
Jeff Dikeba180fd2007-10-16 01:27:00 -0700123 if (ptrace(PTRACE_CONT, pid, 0, 0) < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800124 fatal_perror("stop_ptraced_child : ptrace failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 CATCH_EINTR(n = waitpid(pid, &status, 0));
Jeff Dikeba180fd2007-10-16 01:27:00 -0700126 if (!WIFEXITED(status) || (WEXITSTATUS(status) != exitcode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 int exit_with = WEXITSTATUS(status);
128 if (exit_with == 2)
Jeff Dike3a150e12007-02-10 01:44:28 -0800129 non_fatal("check_ptrace : child exited with status 2. "
Jeff Dikecf6aced2007-05-23 13:57:40 -0700130 "\nDisabling SYSEMU support.\n");
Jeff Dike3a150e12007-02-10 01:44:28 -0800131 non_fatal("check_ptrace : child exited with exitcode %d, while "
132 "expecting %d; status 0x%x\n", exit_with,
133 exitcode, status);
134 if (mustexit)
135 exit(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 ret = -1;
137 }
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 return ret;
140}
141
Jeff Dike7242a402007-02-10 01:44:19 -0800142/* Changed only during early boot */
Paolo 'Blaisorblade' Giarrussocb665042005-07-27 11:43:31 -0700143int ptrace_faultinfo = 1;
Bodo Stroesser858259c2005-11-07 00:58:55 -0800144int ptrace_ldt = 1;
Paolo 'Blaisorblade' Giarrussocb665042005-07-27 11:43:31 -0700145int proc_mm = 1;
Bodo Stroesser858259c2005-11-07 00:58:55 -0800146int skas_needs_stub = 0;
Paolo 'Blaisorblade' Giarrussocb665042005-07-27 11:43:31 -0700147
148static int __init skas0_cmd_param(char *str, int* add)
149{
150 ptrace_faultinfo = proc_mm = 0;
151 return 0;
152}
153
Paolo 'Blaisorblade' Giarrusso9e3d8622005-10-09 21:37:18 +0200154/* The two __uml_setup would conflict, without this stupid alias. */
155
156static int __init mode_skas0_cmd_param(char *str, int* add)
157 __attribute__((alias("skas0_cmd_param")));
158
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700159__uml_setup("skas0", skas0_cmd_param,
160 "skas0\n"
161 " Disables SKAS3 usage, so that SKAS0 is used, unless \n"
162 " you specify mode=tt.\n\n");
163
Paolo 'Blaisorblade' Giarrusso9e3d8622005-10-09 21:37:18 +0200164__uml_setup("mode=skas0", mode_skas0_cmd_param,
165 "mode=skas0\n"
166 " Disables SKAS3 usage, so that SKAS0 is used, unless you \n"
167 " specify mode=tt. Note that this was recently added - on \n"
168 " older kernels you must use simply \"skas0\".\n\n");
169
Jeff Dike7242a402007-02-10 01:44:19 -0800170/* Changed only during early boot */
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700171static int force_sysemu_disabled = 0;
172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173static int __init nosysemu_cmd_param(char *str, int* add)
174{
175 force_sysemu_disabled = 1;
176 return 0;
177}
178
179__uml_setup("nosysemu", nosysemu_cmd_param,
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700180"nosysemu\n"
181" Turns off syscall emulation patch for ptrace (SYSEMU) on.\n"
182" SYSEMU is a performance-patch introduced by Laurent Vivier. It changes\n"
183" behaviour of ptrace() and helps reducing host context switch rate.\n"
184" To make it working, you need a kernel patch for your host, too.\n"
185" See http://perso.wanadoo.fr/laurent.vivier/UML/ for further \n"
186" information.\n\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188static void __init check_sysemu(void)
189{
Jeff Dikecf6aced2007-05-23 13:57:40 -0700190 unsigned long regs[MAX_REG_NR];
Jeff Dike9eae9b12007-02-10 01:44:20 -0800191 int pid, n, status, count=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Jeff Dike3a150e12007-02-10 01:44:28 -0800193 non_fatal("Checking syscall emulation patch for ptrace...");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 sysemu_supported = 0;
Jeff Dike3cdaf452007-10-16 01:27:09 -0700195 pid = start_ptraced_child();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Jeff Dikeba180fd2007-10-16 01:27:00 -0700197 if (ptrace(PTRACE_SYSEMU, pid, 0, 0) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 goto fail;
199
200 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
201 if (n < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800202 fatal_perror("check_sysemu : wait failed");
Jeff Dikeba180fd2007-10-16 01:27:00 -0700203 if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP))
Jeff Dike3a150e12007-02-10 01:44:28 -0800204 fatal("check_sysemu : expected SIGTRAP, got status = %d",
205 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Jeff Dikeba180fd2007-10-16 01:27:00 -0700207 if (ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
Jeff Dikecf6aced2007-05-23 13:57:40 -0700208 fatal_perror("check_sysemu : PTRACE_GETREGS failed");
Jeff Dikeba180fd2007-10-16 01:27:00 -0700209 if (PT_SYSCALL_NR(regs) != __NR_getpid) {
Jeff Dikecf6aced2007-05-23 13:57:40 -0700210 non_fatal("check_sysemu got system call number %d, "
211 "expected %d...", PT_SYSCALL_NR(regs), __NR_getpid);
212 goto fail;
213 }
214
215 n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET, os_getpid());
Jeff Dikeba180fd2007-10-16 01:27:00 -0700216 if (n < 0) {
Jeff Dikecf6aced2007-05-23 13:57:40 -0700217 non_fatal("check_sysemu : failed to modify system call "
218 "return");
219 goto fail;
220 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Jeff Dike3cdaf452007-10-16 01:27:09 -0700222 if (stop_ptraced_child(pid, 0, 0) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 goto fail_stopped;
224
225 sysemu_supported = 1;
Jeff Dike3a150e12007-02-10 01:44:28 -0800226 non_fatal("OK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 set_using_sysemu(!force_sysemu_disabled);
228
Jeff Dike3a150e12007-02-10 01:44:28 -0800229 non_fatal("Checking advanced syscall emulation patch for ptrace...");
Jeff Dike3cdaf452007-10-16 01:27:09 -0700230 pid = start_ptraced_child();
Bodo Stroesserf9dfefe2005-09-03 15:57:51 -0700231
Jeff Dikeba180fd2007-10-16 01:27:00 -0700232 if ((ptrace(PTRACE_OLDSETOPTIONS, pid, 0,
Jeff Dike3a150e12007-02-10 01:44:28 -0800233 (void *) PTRACE_O_TRACESYSGOOD) < 0))
234 fatal_perror("check_ptrace: PTRACE_OLDSETOPTIONS failed");
Bodo Stroesserf9dfefe2005-09-03 15:57:51 -0700235
Jeff Dikeba180fd2007-10-16 01:27:00 -0700236 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 count++;
Jeff Dikeba180fd2007-10-16 01:27:00 -0700238 if (ptrace(PTRACE_SYSEMU_SINGLESTEP, pid, 0, 0) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 goto fail;
240 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
Jeff Dikeba180fd2007-10-16 01:27:00 -0700241 if (n < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800242 fatal_perror("check_ptrace : wait failed");
243
Jeff Dikeba180fd2007-10-16 01:27:00 -0700244 if (WIFSTOPPED(status) &&
245 (WSTOPSIG(status) == (SIGTRAP|0x80))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 if (!count)
Jeff Dike3a150e12007-02-10 01:44:28 -0800247 fatal("check_ptrace : SYSEMU_SINGLESTEP "
Bodo Stroesserf9dfefe2005-09-03 15:57:51 -0700248 "doesn't singlestep");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET,
250 os_getpid());
Jeff Dikeba180fd2007-10-16 01:27:00 -0700251 if (n < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800252 fatal_perror("check_sysemu : failed to modify "
253 "system call return");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 break;
255 }
Jeff Dikeba180fd2007-10-16 01:27:00 -0700256 else if (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGTRAP))
Bodo Stroesserf9dfefe2005-09-03 15:57:51 -0700257 count++;
258 else
Jeff Dike3a150e12007-02-10 01:44:28 -0800259 fatal("check_ptrace : expected SIGTRAP or "
260 "(SIGTRAP | 0x80), got status = %d", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 }
Jeff Dike3cdaf452007-10-16 01:27:09 -0700262 if (stop_ptraced_child(pid, 0, 0) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 goto fail_stopped;
264
265 sysemu_supported = 2;
Jeff Dike3a150e12007-02-10 01:44:28 -0800266 non_fatal("OK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Jeff Dikeba180fd2007-10-16 01:27:00 -0700268 if (!force_sysemu_disabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 set_using_sysemu(sysemu_supported);
270 return;
271
272fail:
Jeff Dike3cdaf452007-10-16 01:27:09 -0700273 stop_ptraced_child(pid, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274fail_stopped:
Jeff Dike3a150e12007-02-10 01:44:28 -0800275 non_fatal("missing\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700278static void __init check_ptrace(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 int pid, syscall, n, status;
281
Jeff Dike3a150e12007-02-10 01:44:28 -0800282 non_fatal("Checking that ptrace can change system call numbers...");
Jeff Dike3cdaf452007-10-16 01:27:09 -0700283 pid = start_ptraced_child();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Jeff Dikeba180fd2007-10-16 01:27:00 -0700285 if ((ptrace(PTRACE_OLDSETOPTIONS, pid, 0,
Jeff Dike3a150e12007-02-10 01:44:28 -0800286 (void *) PTRACE_O_TRACESYSGOOD) < 0))
287 fatal_perror("check_ptrace: PTRACE_OLDSETOPTIONS failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Jeff Dikeba180fd2007-10-16 01:27:00 -0700289 while (1) {
290 if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800291 fatal_perror("check_ptrace : ptrace failed");
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
Jeff Dikeba180fd2007-10-16 01:27:00 -0700294 if (n < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800295 fatal_perror("check_ptrace : wait failed");
296
Jeff Dikeba180fd2007-10-16 01:27:00 -0700297 if (!WIFSTOPPED(status) ||
Jeff Dike3a150e12007-02-10 01:44:28 -0800298 (WSTOPSIG(status) != (SIGTRAP | 0x80)))
299 fatal("check_ptrace : expected (SIGTRAP|0x80), "
300 "got status = %d", status);
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 syscall = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_NR_OFFSET,
303 0);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700304 if (syscall == __NR_getpid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
306 __NR_getppid);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700307 if (n < 0)
Jeff Dike3a150e12007-02-10 01:44:28 -0800308 fatal_perror("check_ptrace : failed to modify "
309 "system call");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 break;
311 }
312 }
Jeff Dike3cdaf452007-10-16 01:27:09 -0700313 stop_ptraced_child(pid, 0, 1);
Jeff Dike3a150e12007-02-10 01:44:28 -0800314 non_fatal("OK\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 check_sysemu();
316}
317
Rob Landley966a0822006-04-18 22:21:43 -0700318extern void check_tmpexec(void);
Jeff Dike0f80bc82005-09-16 19:27:50 -0700319
Jeff Dike36e45462007-05-06 14:51:11 -0700320static void __init check_coredump_limit(void)
Jeff Dike1d94cda2007-05-06 14:51:00 -0700321{
322 struct rlimit lim;
323 int err = getrlimit(RLIMIT_CORE, &lim);
324
Jeff Dikeba180fd2007-10-16 01:27:00 -0700325 if (err) {
Jeff Dike1d94cda2007-05-06 14:51:00 -0700326 perror("Getting core dump limit");
327 return;
328 }
329
330 printf("Core dump limits :\n\tsoft - ");
Jeff Dikeba180fd2007-10-16 01:27:00 -0700331 if (lim.rlim_cur == RLIM_INFINITY)
Jeff Dike1d94cda2007-05-06 14:51:00 -0700332 printf("NONE\n");
333 else printf("%lu\n", lim.rlim_cur);
334
335 printf("\thard - ");
Jeff Dikeba180fd2007-10-16 01:27:00 -0700336 if (lim.rlim_max == RLIM_INFINITY)
Jeff Dike1d94cda2007-05-06 14:51:00 -0700337 printf("NONE\n");
338 else printf("%lu\n", lim.rlim_max);
339}
340
Jeff Dike36e45462007-05-06 14:51:11 -0700341void __init os_early_checks(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
Jeff Dike576c0132008-02-04 22:31:22 -0800343 int pid;
344
Jeff Dike1d94cda2007-05-06 14:51:00 -0700345 /* Print out the core dump limits early */
346 check_coredump_limit();
347
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700348 check_ptrace();
Jeff Dike0f80bc82005-09-16 19:27:50 -0700349
350 /* Need to check this early because mmapping happens before the
351 * kernel is running.
352 */
353 check_tmpexec();
Jeff Dike576c0132008-02-04 22:31:22 -0800354
355 pid = start_ptraced_child();
356 if (init_registers(pid))
357 fatal("Failed to initialize default registers");
358 stop_ptraced_child(pid, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
Bodo Stroesserd9838d82005-09-03 15:57:51 -0700361static int __init noprocmm_cmd_param(char *str, int* add)
362{
363 proc_mm = 0;
364 return 0;
365}
366
367__uml_setup("noprocmm", noprocmm_cmd_param,
368"noprocmm\n"
369" Turns off usage of /proc/mm, even if host supports it.\n"
370" To support /proc/mm, the host needs to be patched using\n"
371" the current skas3 patch.\n\n");
372
373static int __init noptracefaultinfo_cmd_param(char *str, int* add)
374{
375 ptrace_faultinfo = 0;
376 return 0;
377}
378
379__uml_setup("noptracefaultinfo", noptracefaultinfo_cmd_param,
380"noptracefaultinfo\n"
381" Turns off usage of PTRACE_FAULTINFO, even if host supports\n"
382" it. To support PTRACE_FAULTINFO, the host needs to be patched\n"
383" using the current skas3 patch.\n\n");
384
Bodo Stroesser858259c2005-11-07 00:58:55 -0800385static int __init noptraceldt_cmd_param(char *str, int* add)
386{
387 ptrace_ldt = 0;
388 return 0;
389}
390
391__uml_setup("noptraceldt", noptraceldt_cmd_param,
392"noptraceldt\n"
393" Turns off usage of PTRACE_LDT, even if host supports it.\n"
394" To support PTRACE_LDT, the host needs to be patched using\n"
395" the current skas3 patch.\n\n");
396
Bodo Stroesser858259c2005-11-07 00:58:55 -0800397static inline void check_skas3_ptrace_faultinfo(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398{
399 struct ptrace_faultinfo fi;
Jeff Diked67b5692005-07-07 17:56:49 -0700400 int pid, n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Jeff Dike3a150e12007-02-10 01:44:28 -0800402 non_fatal(" - PTRACE_FAULTINFO...");
Jeff Dike3cdaf452007-10-16 01:27:09 -0700403 pid = start_ptraced_child();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 n = ptrace(PTRACE_FAULTINFO, pid, 0, &fi);
406 if (n < 0) {
Paolo 'Blaisorblade' Giarrussocb665042005-07-27 11:43:31 -0700407 ptrace_faultinfo = 0;
Jeff Dikeba180fd2007-10-16 01:27:00 -0700408 if (errno == EIO)
Jeff Dike3a150e12007-02-10 01:44:28 -0800409 non_fatal("not found\n");
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700410 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 perror("not found");
Jeff Diked67b5692005-07-07 17:56:49 -0700412 }
413 else {
Paolo 'Blaisorblade' Giarrussocb665042005-07-27 11:43:31 -0700414 if (!ptrace_faultinfo)
Jeff Dike3a150e12007-02-10 01:44:28 -0800415 non_fatal("found but disabled on command line\n");
Paolo 'Blaisorblade' Giarrussocb665042005-07-27 11:43:31 -0700416 else
Jeff Dike3a150e12007-02-10 01:44:28 -0800417 non_fatal("found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
419
Jeff Dike3cdaf452007-10-16 01:27:09 -0700420 stop_ptraced_child(pid, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421}
422
Bodo Stroesser858259c2005-11-07 00:58:55 -0800423static inline void check_skas3_ptrace_ldt(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Bodo Stroesser858259c2005-11-07 00:58:55 -0800425#ifdef PTRACE_LDT
Bodo Stroesser858259c2005-11-07 00:58:55 -0800426 int pid, n;
427 unsigned char ldtbuf[40];
428 struct ptrace_ldt ldt_op = (struct ptrace_ldt) {
429 .func = 2, /* read default ldt */
430 .ptr = ldtbuf,
431 .bytecount = sizeof(ldtbuf)};
432
Jeff Dike3a150e12007-02-10 01:44:28 -0800433 non_fatal(" - PTRACE_LDT...");
Jeff Dike3cdaf452007-10-16 01:27:09 -0700434 pid = start_ptraced_child();
Bodo Stroesser858259c2005-11-07 00:58:55 -0800435
436 n = ptrace(PTRACE_LDT, pid, 0, (unsigned long) &ldt_op);
437 if (n < 0) {
Jeff Dikeba180fd2007-10-16 01:27:00 -0700438 if (errno == EIO)
Jeff Dike3a150e12007-02-10 01:44:28 -0800439 non_fatal("not found\n");
Bodo Stroesser858259c2005-11-07 00:58:55 -0800440 else {
441 perror("not found");
442 }
443 ptrace_ldt = 0;
444 }
445 else {
Jeff Dikeba180fd2007-10-16 01:27:00 -0700446 if (ptrace_ldt)
Jeff Dike3a150e12007-02-10 01:44:28 -0800447 non_fatal("found\n");
Bodo Stroesser858259c2005-11-07 00:58:55 -0800448 else
Jeff Dike3a150e12007-02-10 01:44:28 -0800449 non_fatal("found, but use is disabled\n");
Bodo Stroesser858259c2005-11-07 00:58:55 -0800450 }
451
Jeff Dike3cdaf452007-10-16 01:27:09 -0700452 stop_ptraced_child(pid, 1, 1);
Bodo Stroesser858259c2005-11-07 00:58:55 -0800453#else
454 /* PTRACE_LDT might be disabled via cmdline option.
455 * We want to override this, else we might use the stub
456 * without real need
457 */
458 ptrace_ldt = 1;
459#endif
460}
461
462static inline void check_skas3_proc_mm(void)
463{
Jeff Dike3a150e12007-02-10 01:44:28 -0800464 non_fatal(" - /proc/mm...");
Jeff Dike73c8f442007-02-10 01:44:20 -0800465 if (access("/proc/mm", W_OK) < 0) {
Jeff Dike9eae9b12007-02-10 01:44:20 -0800466 proc_mm = 0;
Jeff Dike3a150e12007-02-10 01:44:28 -0800467 perror("not found");
Gennady Sharapov60d339f2005-09-03 15:57:47 -0700468 }
Jeff Dikeba180fd2007-10-16 01:27:00 -0700469 else if (!proc_mm)
470 non_fatal("found but disabled on command line\n");
471 else non_fatal("found\n");
Bodo Stroesser858259c2005-11-07 00:58:55 -0800472}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Karol Swietlicki6b7e9672008-02-04 22:30:50 -0800474void can_do_skas(void)
Bodo Stroesser858259c2005-11-07 00:58:55 -0800475{
Jeff Dike3a150e12007-02-10 01:44:28 -0800476 non_fatal("Checking for the skas3 patch in the host:\n");
Bodo Stroesser858259c2005-11-07 00:58:55 -0800477
478 check_skas3_proc_mm();
479 check_skas3_ptrace_faultinfo();
480 check_skas3_ptrace_ldt();
481
Jeff Dikeba180fd2007-10-16 01:27:00 -0700482 if (!proc_mm || !ptrace_faultinfo || !ptrace_ldt)
Bodo Stroesser858259c2005-11-07 00:58:55 -0800483 skas_needs_stub = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484}
Jeff Dike0f80bc82005-09-16 19:27:50 -0700485
Jeff Dike0f80bc82005-09-16 19:27:50 -0700486int __init parse_iomem(char *str, int *add)
487{
488 struct iomem_region *new;
Jeff Dike73c8f442007-02-10 01:44:20 -0800489 struct stat64 buf;
Jeff Dike0f80bc82005-09-16 19:27:50 -0700490 char *file, *driver;
Jeff Dike73c8f442007-02-10 01:44:20 -0800491 int fd, size;
Jeff Dike0f80bc82005-09-16 19:27:50 -0700492
493 driver = str;
494 file = strchr(str,',');
Jeff Dikeba180fd2007-10-16 01:27:00 -0700495 if (file == NULL) {
WANG Cong626c59f2008-04-28 02:13:53 -0700496 fprintf(stderr, "parse_iomem : failed to parse iomem\n");
Jeff Dike0f80bc82005-09-16 19:27:50 -0700497 goto out;
498 }
499 *file = '\0';
500 file++;
Jeff Dike73c8f442007-02-10 01:44:20 -0800501 fd = open(file, O_RDWR, 0);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700502 if (fd < 0) {
Jeff Dike512b6fb2007-10-16 01:27:11 -0700503 perror("parse_iomem - Couldn't open io file");
Jeff Dike0f80bc82005-09-16 19:27:50 -0700504 goto out;
505 }
506
Jeff Dikeba180fd2007-10-16 01:27:00 -0700507 if (fstat64(fd, &buf) < 0) {
Jeff Dike73c8f442007-02-10 01:44:20 -0800508 perror("parse_iomem - cannot stat_fd file");
Jeff Dike0f80bc82005-09-16 19:27:50 -0700509 goto out_close;
510 }
511
512 new = malloc(sizeof(*new));
Jeff Dikeba180fd2007-10-16 01:27:00 -0700513 if (new == NULL) {
Jeff Dike0f80bc82005-09-16 19:27:50 -0700514 perror("Couldn't allocate iomem_region struct");
515 goto out_close;
516 }
517
Jeff Dike73c8f442007-02-10 01:44:20 -0800518 size = (buf.st_size + UM_KERN_PAGE_SIZE) & ~(UM_KERN_PAGE_SIZE - 1);
Jeff Dike0f80bc82005-09-16 19:27:50 -0700519
520 *new = ((struct iomem_region) { .next = iomem_regions,
521 .driver = driver,
522 .fd = fd,
523 .size = size,
524 .phys = 0,
525 .virt = 0 });
526 iomem_regions = new;
527 iomem_size += new->size + UM_KERN_PAGE_SIZE;
528
Jeff Dike9eae9b12007-02-10 01:44:20 -0800529 return 0;
Jeff Dike0f80bc82005-09-16 19:27:50 -0700530 out_close:
Jeff Dike73c8f442007-02-10 01:44:20 -0800531 close(fd);
Jeff Dike0f80bc82005-09-16 19:27:50 -0700532 out:
Jeff Dike9eae9b12007-02-10 01:44:20 -0800533 return 1;
Jeff Dike0f80bc82005-09-16 19:27:50 -0700534}