this repo has no description
Update darlingserver and update code to use new calls
+85
-77
+51
-46
src/kernel/emulation/linux/misc/ptrace.c
+51
-46
src/kernel/emulation/linux/misc/ptrace.c
···
10
10
#include "../signal/duct_signals.h"
11
11
#include "../signal/sigexc.h"
12
12
#include "../process/wait4.h"
13
-
#include "../mach/lkm.h"
14
-
#include "../../../../external/lkm/api.h"
15
13
#include "../unistd/getppid.h"
14
+
15
+
#include <darlingserver/rpc.h>
16
16
17
17
// faster than sys_getpid(), because it caches the PID
18
18
extern int getpid(void);
···
31
31
// if (ret < 0)
32
32
// ret = errno_linux_to_bsd(ret);
33
33
34
-
// Use LKM mechanisms to set a tracing task (->disallow anyone else to attach)
35
-
struct set_tracer_args args = {
36
-
.target = 0,
37
-
.tracer = sys_getppid()
38
-
};
39
-
ret = lkm_call(NR_set_tracer, &args);
40
-
if (ret < 0)
41
-
ret = errno_linux_to_bsd(ret);
34
+
// Use darlingserver mechanisms to set a tracing task (->disallow anyone else to attach)
35
+
ret = dserver_rpc_set_tracer(0, sys_getppid());
36
+
if (ret < 0) {
37
+
__simple_printf("dserver_rpc_set_tracer failed internally: %d", ret);
38
+
__simple_abort();
39
+
}
40
+
ret = errno_linux_to_bsd(-ret);
42
41
43
42
//return ret;
44
43
cmd = "PT_PTRACE_ME"; break;
···
55
54
}
56
55
case PT_ATTACHEXC:
57
56
{
58
-
// Use LKM mechanisms to set a tracing task (->disallow anyone else to attach)
59
-
struct set_tracer_args args = {
60
-
.target = pid,
61
-
.tracer = getpid()
62
-
};
63
-
ret = lkm_call(NR_set_tracer, &args);
64
-
if (ret < 0)
65
-
ret = errno_linux_to_bsd(ret);
57
+
// Use darlingserver mechanisms to set a tracing task (->disallow anyone else to attach)
58
+
ret = dserver_rpc_set_tracer(pid, getpid());
59
+
if (ret < 0) {
60
+
__simple_printf("dserver_rpc_set_tracer failed internally: %d", ret);
61
+
__simple_abort();
62
+
}
63
+
ret = errno_linux_to_bsd(-ret);
66
64
67
65
sys_kill(pid, SIGSTOP, 1);
68
66
69
-
struct ptrace_sigexc_args args2;
70
-
args2.pid = pid;
71
-
args2.sigexc = 1;
72
-
73
-
ret = lkm_call(NR_ptrace_sigexc, &args2);
67
+
ret = dserver_rpc_ptrace_sigexc(pid, true);
68
+
if (ret < 0) {
69
+
__simple_printf("dserver_rpc_ptrace_sigexc failed internally: %d", ret);
70
+
__simple_abort();
71
+
}
72
+
ret = errno_linux_to_bsd(-ret);
74
73
75
74
cmd = "PT_ATTACHEXC";
76
75
break;
···
102
101
//linux_sigqueue(pid, SIGNAL_SIGEXC_TOGGLE, SIGRT_MAGIC_DISABLE_SIGEXC);
103
102
104
103
//ret = 0; //LINUX_SYSCALL(__NR_ptrace, LINUX_PTRACE_DETACH, pid, addr, data);
105
-
struct ptrace_sigexc_args args;
106
-
args.pid = pid;
107
-
args.sigexc = 0;
108
104
109
-
ret = lkm_call(NR_ptrace_sigexc, &args);
105
+
ret = dserver_rpc_ptrace_sigexc(pid, false);
106
+
if (ret < 0) {
107
+
__simple_printf("dserver_rpc_ptrace_sigexc failed internally: %d", ret);
108
+
__simple_abort();
109
+
}
110
+
ret = errno_linux_to_bsd(-ret);
110
111
111
112
// if (ret < 0)
112
113
// ret = errno_linux_to_bsd(ret);
···
118
119
{
119
120
__simple_kprintf("sigexc: self via ptrace\n");
120
121
121
-
struct ptrace_sigexc_args args;
122
-
args.pid = getpid();
123
-
args.sigexc = 1;
124
-
125
-
ret = lkm_call(NR_ptrace_sigexc, &args);
122
+
ret = dserver_rpc_ptrace_sigexc(getpid(), true);
123
+
if (ret < 0) {
124
+
__simple_printf("dserver_rpc_ptrace_sigexc failed internally: %d", ret);
125
+
__simple_abort();
126
+
}
127
+
ret = errno_linux_to_bsd(-ret);
126
128
127
129
// return ret;
128
130
cmd = "PT_SIGEXC"; break;
···
147
149
case PT_THUPDATE:
148
150
{
149
151
// Convert thread_t to process ID
150
-
int tid = lkm_call(NR_tid_for_thread, addr);
151
-
if (tid < 0)
152
-
return -ESRCH;
153
-
154
-
struct ptrace_thupdate_args args;
155
-
args.tid = tid;
156
-
args.signum = data;
152
+
int tid = -1;
153
+
ret = dserver_rpc_tid_for_thread(addr, &tid);
154
+
if (ret < 0) {
155
+
__simple_printf("dserver_rpc_tid_for_thread failed internally: %d", ret);
156
+
__simple_abort();
157
+
} else if (ret > 0) {
158
+
ret = errno_linux_to_bsd(-ret);
159
+
return ret;
160
+
}
157
161
158
-
ret = lkm_call(NR_ptrace_thupdate, &args);
159
-
if (ret < 0)
160
-
ret = errno_linux_to_bsd(ret);
162
+
ret = dserver_rpc_ptrace_thupdate(tid, data);
163
+
if (ret < 0) {
164
+
__simple_printf("dserver_rpc_ptrace_thupdate failed internally: %d", ret);
165
+
__simple_abort();
166
+
}
167
+
ret = errno_linux_to_bsd(-ret);
161
168
162
169
// return ret;
163
170
cmd = "PT_THUPDATE"; break;
164
171
}
165
172
}
166
173
167
-
char buf[128];
168
174
if (cmd != NULL)
169
-
__simple_sprintf(buf, "ptrace() req=%s, ret=%d\n", cmd, ret);
175
+
__simple_kprintf("ptrace() req=%s, ret=%d\n", cmd, ret);
170
176
else
171
-
__simple_sprintf(buf, "ptrace() req=%d\n", request);
172
-
__simple_kprintf(buf);
177
+
__simple_kprintf("ptrace() req=%d\n", request);
173
178
174
179
return ret;
175
180
}
+7
-2
src/kernel/emulation/linux/process/posix_spawn.c
+7
-2
src/kernel/emulation/linux/process/posix_spawn.c
···
19
19
#include "../signal/sigprocmask.h"
20
20
#include "../mach/lkm.h"
21
21
#include "../simple.h"
22
-
#include "lkm/api.h"
23
22
#include "fork.h"
24
23
#include <stddef.h>
25
24
#include <stdint.h>
···
32
31
// for debugging only; remove before committing
33
32
#include "../signal/kill.h"
34
33
#include "../unistd/getpid.h"
34
+
35
+
#include <darlingserver/rpc.h>
35
36
36
37
#ifndef _POSIX_SPAWN_DISABLE_ASLR
37
38
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
···
91
92
}
92
93
if (desc->attrp->psa_flags & POSIX_SPAWN_START_SUSPENDED)
93
94
{
94
-
lkm_call(NR_stop_after_exec, NULL);
95
+
int status = dserver_rpc_stop_after_exec();
96
+
if (status < 0) {
97
+
__simple_printf("Failed to tell darlingserver to stop us after exec: %d", status);
98
+
__simple_abort();
99
+
}
95
100
}
96
101
97
102
if (desc->attrp->psa_flags & POSIX_SPAWN_CLOEXEC_DEFAULT) {
+22
-28
src/kernel/emulation/linux/signal/sigexc.c
+22
-28
src/kernel/emulation/linux/signal/sigexc.c
···
7
7
#include <linux-syscalls/linux.h>
8
8
#include "sigaltstack.h"
9
9
#include "../mach/lkm.h"
10
-
#include "../../../../external/lkm/api.h"
11
10
#include "../../../libsyscall/wrappers/_libkernel_init.h"
12
11
#include <sys/mman.h>
13
12
#include "../mman/mman.h"
···
46
45
static void float_state_to_mcontext(const x86_float_state32_t* s, linux_fpregset_t fx);
47
46
#endif
48
47
49
-
static void state_from_kernel(struct linux_ucontext* ctxt, const struct thread_state* kernel_state);
50
-
static void state_to_kernel(struct linux_ucontext* ctxt, struct thread_state* kernel_state);
48
+
static void state_from_kernel(struct linux_ucontext* ctxt, const void* tstate, const void* fstate);
49
+
static void state_to_kernel(struct linux_ucontext* ctxt, void* tstate, void* fstate);
51
50
52
51
#define DEBUG_SIGEXC
53
52
#ifdef DEBUG_SIGEXC
···
117
116
task_suspend(mach_task_self());
118
117
kern_printf("sigexc: start_suspended -> wokenup (ret to %p)\n", __builtin_return_address(0));
119
118
} else {
120
-
uint32_t tracer;
119
+
int32_t tracer;
121
120
code = dserver_rpc_get_tracer(&tracer);
122
121
if (code < 0) {
123
122
__simple_printf("Failed to get tracer status: %d\n", code);
···
145
144
x86_float_state32_t fstate;
146
145
#endif
147
146
148
-
struct thread_suspended_args args;
149
-
args.state.tstate = &tstate;
150
-
args.state.fstate = &fstate;
151
-
152
147
kern_printf("sigexc: sigrt_handler SUSPEND\n");
153
148
154
149
thread_t thread = mach_thread_self();
155
-
state_to_kernel(ctxt, &args.state);
150
+
state_to_kernel(ctxt, &tstate, &fstate);
156
151
157
-
lkm_call(NR_thread_suspended, &args);
152
+
int ret = dserver_rpc_thread_suspended(&tstate, &fstate);
153
+
if (ret < 0) {
154
+
__simple_printf("dserver_rpc_thread_suspended failed internally: %d", ret);
155
+
__simple_abort();
156
+
}
158
157
159
-
state_from_kernel(ctxt, &args.state);
158
+
state_from_kernel(ctxt, &tstate, &fstate);
160
159
161
160
dserver_rpc_interrupt_exit();
162
161
}
···
194
193
}
195
194
196
195
197
-
static void state_to_kernel(struct linux_ucontext* ctxt, struct thread_state* kernel_state)
196
+
static void state_to_kernel(struct linux_ucontext* ctxt, void* tstate, void* fstate)
198
197
{
199
198
#if defined(__x86_64__)
200
199
201
200
dump_gregs(&ctxt->uc_mcontext.gregs);
202
-
mcontext_to_thread_state(&ctxt->uc_mcontext.gregs, (x86_thread_state64_t*) kernel_state->tstate);
203
-
mcontext_to_float_state(ctxt->uc_mcontext.fpregs, (x86_float_state64_t*) kernel_state->fstate);
201
+
mcontext_to_thread_state(&ctxt->uc_mcontext.gregs, (x86_thread_state64_t*) tstate);
202
+
mcontext_to_float_state(ctxt->uc_mcontext.fpregs, (x86_float_state64_t*) fstate);
204
203
205
204
#elif defined(__i386__)
206
-
mcontext_to_thread_state(&ctxt->uc_mcontext.gregs, (x86_thread_state32_t*) kernel_state->tstate);
207
-
mcontext_to_float_state(ctxt->uc_mcontext.fpregs, (x86_float_state32_t*) kernel_state->fstate);
205
+
mcontext_to_thread_state(&ctxt->uc_mcontext.gregs, (x86_thread_state32_t*) tstate);
206
+
mcontext_to_float_state(ctxt->uc_mcontext.fpregs, (x86_float_state32_t*) fstate);
208
207
#endif
209
208
210
209
}
211
210
212
-
static void state_from_kernel(struct linux_ucontext* ctxt, const struct thread_state* kernel_state)
211
+
static void state_from_kernel(struct linux_ucontext* ctxt, const void* tstate, const void* fstate)
213
212
{
214
213
#if defined(__x86_64__)
215
214
216
-
thread_state_to_mcontext((x86_thread_state64_t*) kernel_state->tstate, &ctxt->uc_mcontext.gregs);
217
-
float_state_to_mcontext((x86_float_state64_t*) kernel_state->fstate, ctxt->uc_mcontext.fpregs);
215
+
thread_state_to_mcontext((const x86_thread_state64_t*) tstate, &ctxt->uc_mcontext.gregs);
216
+
float_state_to_mcontext((const x86_float_state64_t*) fstate, ctxt->uc_mcontext.fpregs);
218
217
219
218
dump_gregs(&ctxt->uc_mcontext.gregs);
220
219
221
220
#elif defined(__i386__)
222
-
thread_state_to_mcontext((x86_thread_state32_t*) kernel_state->tstate, &ctxt->uc_mcontext.gregs);
223
-
float_state_to_mcontext((x86_float_state32_t*) kernel_state->fstate, ctxt->uc_mcontext.fpregs);
221
+
thread_state_to_mcontext((const x86_thread_state32_t*) tstate, &ctxt->uc_mcontext.gregs);
222
+
float_state_to_mcontext((const x86_float_state32_t*) fstate, ctxt->uc_mcontext.fpregs);
224
223
#endif
225
224
}
226
225
···
255
254
x86_float_state32_t fstate;
256
255
#endif
257
256
258
-
struct thread_state state = {
259
-
.tstate = &tstate,
260
-
.fstate = &fstate,
261
-
};
262
-
263
-
state_to_kernel(ctxt, &state);
257
+
state_to_kernel(ctxt, &tstate, &fstate);
264
258
int ret = dserver_rpc_sigprocess(bsd_signum, linux_signum, info->si_pid, info->si_code, info->si_addr, &tstate, &fstate, &bsd_signum);
265
259
if (ret < 0) {
266
260
__simple_printf("sigprocess failed internally while processing Linux signal %d: %d", linux_signum, ret);
267
261
__simple_abort();
268
262
}
269
-
state_from_kernel(ctxt, &state);
263
+
state_from_kernel(ctxt, &tstate, &fstate);
270
264
271
265
if (!bsd_signum)
272
266
{
+5
-1
src/startup/mldr/mldr.c
+5
-1
src/startup/mldr/mldr.c
···
182
182
abort();
183
183
#endif
184
184
185
-
// TODO: tell darlingserver about our dyld info
185
+
int status = dserver_rpc_set_dyld_info(mldr_load_results.dyld_all_image_location, mldr_load_results.dyld_all_image_size);
186
+
if (status < 0) {
187
+
fprintf(stderr, "Failed to tell darlingserver about our dyld info\n");
188
+
exit(1);
189
+
}
186
190
187
191
start_thread(&mldr_load_results);
188
192