this repo has no description
Dispatch all mach traps through a syscall table to allow for easy tracing
+480
-52
+1
src/kernel/libsyscall/CMakeLists.txt
+1
src/kernel/libsyscall/CMakeLists.txt
src/kernel/libsyscall/mach/mach_traps.s
src/kernel/libsyscall/mach/mach_traps.S
src/kernel/libsyscall/mach/mach_traps.s
src/kernel/libsyscall/mach/mach_traps.S
+2
src/kernel/mach_server/client/CMakeLists.txt
+2
src/kernel/mach_server/client/CMakeLists.txt
+76
src/kernel/mach_server/client/darling_mach_syscall.S
+76
src/kernel/mach_server/client/darling_mach_syscall.S
···
1
+
.text
2
+
.globl __darling_mach_syscall
3
+
.private_extern __darling_mach_syscall
4
+
5
+
#if defined(__x86_64__)
6
+
7
+
__darling_mach_syscall:
8
+
cmpl $0, %eax
9
+
jnl Lpositive
10
+
negl %eax
11
+
Lpositive:
12
+
movq ___mach_syscall_table@GOTPCREL(%rip), %r10
13
+
movq (%r10,%rax,8), %r10
14
+
test %r10, %r10
15
+
jz .no_sys
16
+
# Re-push possible 7th and 8th arg
17
+
movq 24(%rsp), %r11
18
+
pushq %r11
19
+
movq 24(%rsp), %r11
20
+
pushq %r11
21
+
call *%r10
22
+
addq $16, %rsp
23
+
ret
24
+
.no_sys:
25
+
movq %rax, %rdi
26
+
call ___unknown_mach_syscall
27
+
ret
28
+
29
+
#elif defined(__i386__)
30
+
31
+
#define copy_arg(off) \
32
+
movl 8+off(%esp), %ecx ;\
33
+
movl %ecx, -24+off(%esp)
34
+
35
+
__darling_mach_syscall:
36
+
cmpl $0, %eax
37
+
jnl Lpositive
38
+
negl %eax
39
+
Lpositive:
40
+
calll 1f
41
+
1:
42
+
popl %ecx
43
+
2:
44
+
movl L___mach_syscall_table$non_lazy_ptr-1b(%ecx), %ecx
45
+
andl $0xffff, %eax // Because there is some extra stuff in upper bytes we don't need
46
+
movl (%ecx,%eax,4), %eax
47
+
test %eax, %eax
48
+
jz .no_sys
49
+
// Copy arguments
50
+
copy_arg(0)
51
+
copy_arg(4)
52
+
copy_arg(8)
53
+
copy_arg(12)
54
+
copy_arg(16)
55
+
copy_arg(20)
56
+
subl $24, %esp
57
+
call *%eax
58
+
addl $24, %esp
59
+
ret
60
+
.no_sys:
61
+
pushl %ecx
62
+
call ___unknown_mach_syscall
63
+
addl $4, %esp
64
+
ret
65
+
66
+
.section __IMPORT,__pointers,non_lazy_symbol_pointers
67
+
L___mach_syscall_table$non_lazy_ptr:
68
+
.indirect_symbol ___mach_syscall_table
69
+
.long 0
70
+
71
+
.subsections_via_symbols
72
+
73
+
#else
74
+
# error Missing assembly
75
+
#endif
76
+
+77
src/kernel/mach_server/client/mach-syscall.S
+77
src/kernel/mach_server/client/mach-syscall.S
···
1
+
.text
2
+
.globl _linux_syscall
3
+
.private_extern _linux_syscall
4
+
5
+
_linux_syscall:
6
+
7
+
#if defined(__x86_64__)
8
+
9
+
movl 8(%rsp), %eax
10
+
movq %rcx, %r10
11
+
syscall
12
+
ret
13
+
14
+
#elif defined(__i386__)
15
+
16
+
// With 32in64, we cannot use sysenter, because our process doesn't have a 32-bit VDSO mapped
17
+
// and sysenter needs that for returning to user space.
18
+
19
+
// eax, ecx and edx are caller saved, the rest is calee saved
20
+
push %ebx
21
+
push %esi
22
+
push %edi
23
+
push %ebp
24
+
25
+
mov 20(%esp), %ebx
26
+
mov 24(%esp), %ecx
27
+
mov 28(%esp), %edx
28
+
mov 32(%esp), %esi
29
+
mov 36(%esp), %edi
30
+
mov 40(%esp), %ebp
31
+
mov 44(%esp), %eax
32
+
33
+
int $0x80
34
+
35
+
pop %ebp
36
+
pop %edi
37
+
pop %esi
38
+
pop %ebx
39
+
ret
40
+
41
+
#elif 0 //defined(__i386__)
42
+
43
+
push %ebp
44
+
push %ebx
45
+
push %esi
46
+
push %edi
47
+
call 1f
48
+
1:
49
+
pop %ebp
50
+
addl $(2f-1b), %ebp
51
+
push %ebp
52
+
push %ecx
53
+
push %edx
54
+
movl 28+28(%esp), %eax
55
+
movl 4+28(%esp), %ebx
56
+
movl 8+28(%esp), %ecx
57
+
movl 12+28(%esp), %edx
58
+
movl 16+28(%esp), %esi
59
+
movl 20+28(%esp), %edi
60
+
push %ebp
61
+
movl 24+28(%esp), %ebp
62
+
movl %ebp, -4(%esp)
63
+
movl %esp, %ebp
64
+
sysenter
65
+
2:
66
+
pop %edi
67
+
pop %esi
68
+
pop %ebx
69
+
pop %ebp
70
+
ret
71
+
72
+
#else
73
+
74
+
# error Missing assembly!
75
+
76
+
#endif
77
+
+63
src/kernel/mach_server/client/mach_table.c
+63
src/kernel/mach_server/client/mach_table.c
···
1
+
#include "mach_time.h"
2
+
#include "mach_traps.h"
3
+
#include <mach/kern_return.h>
4
+
5
+
__attribute__((visibility("hidden")))
6
+
void* __mach_syscall_table[128] = {
7
+
[10] = _kernelrpc_mach_vm_allocate_trap_impl,
8
+
[12] = _kernelrpc_mach_vm_deallocate_trap_impl,
9
+
[14] = _kernelrpc_mach_vm_protect_trap_impl,
10
+
[15] = _kernelrpc_mach_vm_map_trap_impl,
11
+
[16] = _kernelrpc_mach_port_allocate_trap_impl,
12
+
[17] = _kernelrpc_mach_port_destroy_trap_impl,
13
+
[18] = _kernelrpc_mach_port_deallocate_trap_impl,
14
+
[19] = _kernelrpc_mach_port_mod_refs_trap_impl,
15
+
[20] = _kernelrpc_mach_port_move_member_trap_impl,
16
+
[21] = _kernelrpc_mach_port_insert_right_trap_impl,
17
+
[22] = _kernelrpc_mach_port_insert_member_trap_impl,
18
+
[23] = _kernelrpc_mach_port_extract_member_trap_impl,
19
+
[24] = _kernelrpc_mach_port_construct_trap_impl,
20
+
[25] = _kernelrpc_mach_port_destruct_trap_impl,
21
+
[26] = mach_reply_port_impl,
22
+
[27] = thread_self_trap_impl,
23
+
[28] = task_self_trap_impl,
24
+
[29] = host_self_trap_impl,
25
+
[31] = mach_msg_trap_impl,
26
+
[32] = mach_msg_overwrite_trap_impl,
27
+
[33] = semaphore_signal_trap_impl,
28
+
[34] = semaphore_signal_all_trap_impl,
29
+
[35] = semaphore_signal_thread_trap_impl,
30
+
[36] = semaphore_wait_trap_impl,
31
+
[37] = semaphore_wait_signal_trap_impl,
32
+
[38] = semaphore_timedwait_trap_impl,
33
+
[39] = semaphore_timedwait_signal_trap_impl,
34
+
[41] = _kernelrpc_mach_port_guard_trap_impl,
35
+
[42] = _kernelrpc_mach_port_unguard_trap_impl,
36
+
[43] = mach_generate_activity_id_impl,
37
+
[44] = task_name_for_pid_impl,
38
+
[45] = task_for_pid_impl,
39
+
[46] = pid_for_task_impl,
40
+
[48] = macx_swapon_impl,
41
+
[49] = macx_swapoff_impl,
42
+
[51] = macx_triggers_impl,
43
+
[52] = macx_backing_store_suspend_impl,
44
+
[53] = macx_backing_store_recovery_impl,
45
+
[59] = swtch_pri_impl,
46
+
[60] = swtch_impl,
47
+
[61] = syscall_thread_switch_impl,
48
+
[62] = clock_sleep_trap_impl,
49
+
[89] = mach_timebase_info_trap_impl,
50
+
[90] = mach_wait_until_impl,
51
+
[91] = mk_timer_create_impl,
52
+
[92] = mk_timer_destroy_impl,
53
+
[93] = mk_timer_arm_impl,
54
+
[94] = mk_timer_cancel_impl,
55
+
};
56
+
57
+
extern void __simple_printf(const char* format, ...);
58
+
long __unknown_mach_syscall(int nr, ...)
59
+
{
60
+
__simple_printf("Unimplemented mach trap (%d)\n", nr);
61
+
return KERN_FAILURE;
62
+
}
63
+
+2
-2
src/kernel/mach_server/client/mach_time.c
+2
-2
src/kernel/mach_server/client/mach_time.c
···
7
7
# define NSEC_PER_SEC 1000000000ull
8
8
#endif
9
9
10
-
kern_return_t mach_timebase_info_trap(
10
+
kern_return_t mach_timebase_info_trap_impl(
11
11
mach_timebase_info_t info)
12
12
{
13
13
info->numer = NSEC_PER_SEC;
···
15
15
return KERN_SUCCESS;
16
16
}
17
17
18
-
kern_return_t mach_wait_until(
18
+
kern_return_t mach_wait_until_impl(
19
19
uint64_t deadline)
20
20
{
21
21
struct timespec ts = { deadline / NSEC_PER_SEC, deadline % NSEC_PER_SEC };
+12
src/kernel/mach_server/client/mach_time.h
+12
src/kernel/mach_server/client/mach_time.h
+51
-50
src/kernel/mach_server/client/mach_traps.c
+51
-50
src/kernel/mach_server/client/mach_traps.c
···
7
7
#include <unistd.h>
8
8
#include "../../lkm/api.h"
9
9
#include "lkm.h"
10
+
#include "mach_traps.h"
10
11
11
12
#define UNIMPLEMENTED_TRAP() { char msg[] = "Called unimplemented Mach trap: "; write(2, msg, sizeof(msg)-1); write(2, __FUNCTION__, sizeof(__FUNCTION__)-1); write(2, "\n", 1); }
12
13
13
-
mach_port_name_t mach_reply_port(void)
14
+
mach_port_name_t mach_reply_port_impl(void)
14
15
{
15
16
return ioctl(driver_fd, NR_mach_reply_port, 0);
16
17
}
17
18
18
-
mach_port_name_t thread_self_trap(void)
19
+
mach_port_name_t thread_self_trap_impl(void)
19
20
{
20
21
return ioctl(driver_fd, NR_thread_self_trap, 0);
21
22
}
22
23
23
-
mach_port_name_t host_self_trap(void)
24
+
mach_port_name_t host_self_trap_impl(void)
24
25
{
25
26
return ioctl(driver_fd, NR_host_self_trap, 0);
26
27
}
27
28
28
-
mach_msg_return_t mach_msg_trap(
29
+
mach_msg_return_t mach_msg_trap_impl(
29
30
mach_msg_header_t *msg,
30
31
mach_msg_option_t option,
31
32
mach_msg_size_t send_size,
···
34
35
mach_msg_timeout_t timeout,
35
36
mach_port_name_t notify)
36
37
{
37
-
return mach_msg_overwrite_trap(msg,
38
+
return mach_msg_overwrite_trap_impl(msg,
38
39
option, send_size, rcv_size,
39
40
rcv_name, timeout, notify,
40
41
msg, 0);
41
42
}
42
43
43
-
mach_msg_return_t mach_msg_overwrite_trap(
44
+
mach_msg_return_t mach_msg_overwrite_trap_impl(
44
45
mach_msg_header_t *msg,
45
46
mach_msg_option_t option,
46
47
mach_msg_size_t send_size,
···
67
68
&args);
68
69
}
69
70
70
-
kern_return_t semaphore_signal_trap(
71
+
kern_return_t semaphore_signal_trap_impl(
71
72
mach_port_name_t signal_name)
72
73
{
73
74
struct semaphore_signal_args args = {
···
77
78
return ioctl(driver_fd, NR_semaphore_signal_trap, &args);
78
79
}
79
80
80
-
kern_return_t semaphore_signal_all_trap(
81
+
kern_return_t semaphore_signal_all_trap_impl(
81
82
mach_port_name_t signal_name)
82
83
{
83
84
struct semaphore_signal_all_args args = {
···
88
89
&args);
89
90
}
90
91
91
-
kern_return_t semaphore_signal_thread_trap(
92
+
kern_return_t semaphore_signal_thread_trap_impl(
92
93
mach_port_name_t signal_name,
93
94
mach_port_name_t thread_name)
94
95
{
···
96
97
return KERN_FAILURE;
97
98
}
98
99
99
-
kern_return_t semaphore_wait_trap(
100
+
kern_return_t semaphore_wait_trap_impl(
100
101
mach_port_name_t wait_name)
101
102
{
102
103
struct semaphore_wait_args args = {
···
106
107
return ioctl(driver_fd, NR_semaphore_wait_trap, &args);
107
108
}
108
109
109
-
kern_return_t semaphore_wait_signal_trap(
110
+
kern_return_t semaphore_wait_signal_trap_impl(
110
111
mach_port_name_t wait_name,
111
112
mach_port_name_t signal_name)
112
113
{
···
119
120
&args);
120
121
}
121
122
122
-
kern_return_t semaphore_timedwait_trap(
123
+
kern_return_t semaphore_timedwait_trap_impl(
123
124
mach_port_name_t wait_name,
124
125
unsigned int sec,
125
126
clock_res_t nsec)
···
134
135
&args);
135
136
}
136
137
137
-
kern_return_t semaphore_timedwait_signal_trap(
138
+
kern_return_t semaphore_timedwait_signal_trap_impl(
138
139
mach_port_name_t wait_name,
139
140
mach_port_name_t signal_name,
140
141
unsigned int sec,
···
151
152
&args);
152
153
}
153
154
154
-
kern_return_t clock_sleep_trap(
155
+
kern_return_t clock_sleep_trap_impl(
155
156
mach_port_name_t clock_name,
156
157
sleep_type_t sleep_type,
157
158
int sleep_sec,
···
162
163
return KERN_FAILURE;
163
164
}
164
165
165
-
kern_return_t _kernelrpc_mach_vm_allocate_trap(
166
+
kern_return_t _kernelrpc_mach_vm_allocate_trap_impl(
166
167
mach_port_name_t target,
167
168
mach_vm_offset_t *addr,
168
169
mach_vm_size_t size,
169
170
int flags)
170
171
{
171
-
return _kernelrpc_mach_vm_map_trap(target, addr,
172
+
return _kernelrpc_mach_vm_map_trap_impl(target, addr,
172
173
size, 0, flags, VM_PROT_READ | VM_PROT_WRITE);
173
174
}
174
175
175
-
kern_return_t _kernelrpc_mach_vm_deallocate_trap(
176
+
kern_return_t _kernelrpc_mach_vm_deallocate_trap_impl(
176
177
mach_port_name_t target,
177
178
mach_vm_address_t address,
178
179
mach_vm_size_t size
···
191
192
return KERN_SUCCESS;
192
193
}
193
194
194
-
kern_return_t _kernelrpc_mach_vm_protect_trap(
195
+
kern_return_t _kernelrpc_mach_vm_protect_trap_impl(
195
196
mach_port_name_t target,
196
197
mach_vm_address_t address,
197
198
mach_vm_size_t size,
···
219
220
return KERN_SUCCESS;
220
221
}
221
222
222
-
kern_return_t _kernelrpc_mach_vm_map_trap(
223
+
kern_return_t _kernelrpc_mach_vm_map_trap_impl(
223
224
mach_port_name_t target,
224
225
mach_vm_offset_t *address,
225
226
mach_vm_size_t size,
···
284
285
return KERN_SUCCESS;
285
286
}
286
287
287
-
kern_return_t _kernelrpc_mach_port_allocate_trap(
288
+
kern_return_t _kernelrpc_mach_port_allocate_trap_impl(
288
289
mach_port_name_t target,
289
290
mach_port_right_t right,
290
291
mach_port_name_t *name
···
310
311
}
311
312
312
313
313
-
kern_return_t _kernelrpc_mach_port_destroy_trap(
314
+
kern_return_t _kernelrpc_mach_port_destroy_trap_impl(
314
315
mach_port_name_t target,
315
316
mach_port_name_t name
316
317
)
···
324
325
&args);
325
326
}
326
327
327
-
kern_return_t _kernelrpc_mach_port_deallocate_trap(
328
+
kern_return_t _kernelrpc_mach_port_deallocate_trap_impl(
328
329
mach_port_name_t target,
329
330
mach_port_name_t name
330
331
)
···
338
339
&args);
339
340
}
340
341
341
-
kern_return_t _kernelrpc_mach_port_mod_refs_trap(
342
+
kern_return_t _kernelrpc_mach_port_mod_refs_trap_impl(
342
343
mach_port_name_t target,
343
344
mach_port_name_t name,
344
345
mach_port_right_t right,
···
355
356
return ioctl(driver_fd, NR__kernelrpc_mach_port_mod_refs, &args);
356
357
}
357
358
358
-
kern_return_t _kernelrpc_mach_port_move_member_trap(
359
+
kern_return_t _kernelrpc_mach_port_move_member_trap_impl(
359
360
mach_port_name_t target,
360
361
mach_port_name_t member,
361
362
mach_port_name_t after
···
369
370
return ioctl(driver_fd, NR__kernelrpc_mach_port_move_member_trap, &args);
370
371
}
371
372
372
-
kern_return_t _kernelrpc_mach_port_insert_right_trap(
373
+
kern_return_t _kernelrpc_mach_port_insert_right_trap_impl(
373
374
mach_port_name_t target,
374
375
mach_port_name_t name,
375
376
mach_port_name_t poly,
···
380
381
return KERN_FAILURE;
381
382
}
382
383
383
-
kern_return_t _kernelrpc_mach_port_insert_member_trap(
384
+
kern_return_t _kernelrpc_mach_port_insert_member_trap_impl(
384
385
mach_port_name_t target,
385
386
mach_port_name_t name,
386
387
mach_port_name_t pset
···
394
395
return ioctl(driver_fd, NR__kernelrpc_mach_port_insert_member_trap, &args);
395
396
}
396
397
397
-
kern_return_t _kernelrpc_mach_port_extract_member_trap(
398
+
kern_return_t _kernelrpc_mach_port_extract_member_trap_impl(
398
399
mach_port_name_t target,
399
400
mach_port_name_t name,
400
401
mach_port_name_t pset
···
408
409
return ioctl(driver_fd, NR__kernelrpc_mach_port_extract_member_trap, &args);
409
410
}
410
411
411
-
kern_return_t _kernelrpc_mach_port_construct_trap(
412
+
kern_return_t _kernelrpc_mach_port_construct_trap_impl(
412
413
mach_port_name_t target,
413
414
mach_port_options_t *options,
414
415
uint64_t context,
···
419
420
return KERN_FAILURE;
420
421
}
421
422
422
-
kern_return_t _kernelrpc_mach_port_destruct_trap(
423
+
kern_return_t _kernelrpc_mach_port_destruct_trap_impl(
423
424
mach_port_name_t target,
424
425
mach_port_name_t name,
425
426
mach_port_delta_t srdelta,
···
430
431
return KERN_FAILURE;
431
432
}
432
433
433
-
kern_return_t _kernelrpc_mach_port_guard_trap(
434
+
kern_return_t _kernelrpc_mach_port_guard_trap_impl(
434
435
mach_port_name_t target,
435
436
mach_port_name_t name,
436
437
uint64_t guard,
···
441
442
return KERN_FAILURE;
442
443
}
443
444
444
-
kern_return_t _kernelrpc_mach_port_unguard_trap(
445
+
kern_return_t _kernelrpc_mach_port_unguard_trap_impl(
445
446
mach_port_name_t target,
446
447
mach_port_name_t name,
447
448
uint64_t guard
···
451
452
return KERN_FAILURE;
452
453
}
453
454
454
-
kern_return_t macx_swapon(
455
+
kern_return_t macx_swapon_impl(
455
456
uint64_t filename,
456
457
int flags,
457
458
int size,
···
461
462
return KERN_FAILURE;
462
463
}
463
464
464
-
kern_return_t macx_swapoff(
465
+
kern_return_t macx_swapoff_impl(
465
466
uint64_t filename,
466
467
int flags)
467
468
{
···
469
470
return KERN_FAILURE;
470
471
}
471
472
472
-
kern_return_t macx_triggers(
473
+
kern_return_t macx_triggers_impl(
473
474
int hi_water,
474
475
int low_water,
475
476
int flags,
···
479
480
return KERN_FAILURE;
480
481
}
481
482
482
-
kern_return_t macx_backing_store_suspend(
483
+
kern_return_t macx_backing_store_suspend_impl(
483
484
boolean_t suspend)
484
485
{
485
486
UNIMPLEMENTED_TRAP();
486
487
return KERN_FAILURE;
487
488
}
488
489
489
-
kern_return_t macx_backing_store_recovery(
490
+
kern_return_t macx_backing_store_recovery_impl(
490
491
int pid)
491
492
{
492
493
UNIMPLEMENTED_TRAP();
···
494
495
}
495
496
496
497
extern void __linux_sched_yield();
497
-
boolean_t swtch_pri(int pri)
498
+
boolean_t swtch_pri_impl(int pri)
498
499
{
499
500
__linux_sched_yield();
500
501
return 0;
501
502
}
502
503
503
-
boolean_t swtch(void)
504
+
boolean_t swtch_impl(void)
504
505
{
505
506
__linux_sched_yield();
506
507
return 0;
507
508
}
508
509
509
-
kern_return_t syscall_thread_switch(
510
+
kern_return_t syscall_thread_switch_impl(
510
511
mach_port_name_t thread_name,
511
512
int option,
512
513
mach_msg_timeout_t option_time)
···
515
516
return KERN_FAILURE;
516
517
}
517
518
518
-
mach_port_name_t task_self_trap(void)
519
+
mach_port_name_t task_self_trap_impl(void)
519
520
{
520
521
return ioctl(driver_fd, NR_task_self_trap, 0);
521
522
}
···
524
525
* Obsolete interfaces.
525
526
*/
526
527
527
-
kern_return_t task_for_pid(
528
+
kern_return_t task_for_pid_impl(
528
529
mach_port_name_t target_tport,
529
530
int pid,
530
531
mach_port_name_t *t)
···
533
534
return KERN_FAILURE;
534
535
}
535
536
536
-
kern_return_t task_name_for_pid(
537
+
kern_return_t task_name_for_pid_impl(
537
538
mach_port_name_t target_tport,
538
539
int pid,
539
540
mach_port_name_t *tn)
···
542
543
return KERN_FAILURE;
543
544
}
544
545
545
-
kern_return_t pid_for_task(
546
+
kern_return_t pid_for_task_impl(
546
547
mach_port_name_t t,
547
548
int *x)
548
549
{
···
550
551
return KERN_FAILURE;
551
552
}
552
553
553
-
kern_return_t bsdthread_terminate_trap(
554
+
kern_return_t bsdthread_terminate_trap_impl(
554
555
uintptr_t stackaddr,
555
556
unsigned long freesize,
556
557
mach_port_name_t thread,
···
566
567
return ioctl(driver_fd, NR_bsdthread_terminate_trap, &args);
567
568
}
568
569
569
-
typedef struct voucher_mach_msg_state_s *voucher_mach_msg_state_t;
570
570
571
571
boolean_t voucher_mach_msg_set(mach_msg_header_t *msg)
572
572
{
···
585
585
return NULL;
586
586
}
587
587
588
-
kern_return_t mach_generate_activity_id(mach_port_name_t task, int i, uint64_t* id)
588
+
kern_return_t mach_generate_activity_id_impl(mach_port_name_t task, int i, uint64_t* id)
589
589
{
590
590
UNIMPLEMENTED_TRAP();
591
591
return KERN_FAILURE;
592
592
}
593
593
594
-
mach_port_name_t mk_timer_create(void)
594
+
mach_port_name_t mk_timer_create_impl(void)
595
595
{
596
596
return ioctl(driver_fd, NR_mk_timer_create_trap, NULL);
597
597
}
598
598
599
-
kern_return_t mk_timer_destroy(mach_port_name_t name)
599
+
kern_return_t mk_timer_destroy_impl(mach_port_name_t name)
600
600
{
601
601
struct mk_timer_destroy_args args = {
602
602
.timer_port = name
···
605
605
return ioctl(driver_fd, NR_mk_timer_destroy_trap, &args);
606
606
}
607
607
608
-
kern_return_t mk_timer_arm(mach_port_name_t name, uint64_t expire_time)
608
+
kern_return_t mk_timer_arm_impl(mach_port_name_t name, uint64_t expire_time)
609
609
{
610
610
struct mk_timer_arm_args args = {
611
611
.timer_port = name,
···
615
615
return ioctl(driver_fd, NR_mk_timer_arm_trap, &args);
616
616
}
617
617
618
-
kern_return_t mk_timer_cancel(mach_port_name_t name, uint64_t *result_time)
618
+
kern_return_t mk_timer_cancel_impl(mach_port_name_t name, uint64_t *result_time)
619
619
{
620
620
struct mk_timer_cancel_args args = {
621
621
.timer_port = name,
···
624
624
625
625
return ioctl(driver_fd, NR_mk_timer_cancel_trap, &args);
626
626
}
627
+
+196
src/kernel/mach_server/client/mach_traps.h
+196
src/kernel/mach_server/client/mach_traps.h
···
1
+
#ifndef _MACH_TRAPS_H
2
+
#define _MACH_TRAPS_H
3
+
4
+
#include <mach/mach_traps.h>
5
+
#include <mach/vm_statistics.h>
6
+
#include <mach/kern_return.h>
7
+
8
+
typedef struct voucher_mach_msg_state_s *voucher_mach_msg_state_t;
9
+
10
+
mach_port_name_t mach_reply_port_impl(void);
11
+
mach_port_name_t thread_self_trap_impl(void);
12
+
mach_port_name_t host_self_trap_impl(void);
13
+
mach_msg_return_t mach_msg_trap_impl(
14
+
mach_msg_header_t *msg,
15
+
mach_msg_option_t option,
16
+
mach_msg_size_t send_size,
17
+
mach_msg_size_t rcv_size,
18
+
mach_port_name_t rcv_name,
19
+
mach_msg_timeout_t timeout,
20
+
mach_port_name_t notify);
21
+
mach_msg_return_t mach_msg_overwrite_trap_impl(
22
+
mach_msg_header_t *msg,
23
+
mach_msg_option_t option,
24
+
mach_msg_size_t send_size,
25
+
mach_msg_size_t rcv_size,
26
+
mach_port_name_t rcv_name,
27
+
mach_msg_timeout_t timeout,
28
+
mach_port_name_t notify,
29
+
mach_msg_header_t *rcv_msg,
30
+
mach_msg_size_t rcv_limit);
31
+
kern_return_t semaphore_signal_trap_impl(
32
+
mach_port_name_t signal_name);
33
+
kern_return_t semaphore_signal_all_trap_impl(
34
+
mach_port_name_t signal_name);
35
+
kern_return_t semaphore_signal_thread_trap_impl(
36
+
mach_port_name_t signal_name,
37
+
mach_port_name_t thread_name);
38
+
kern_return_t semaphore_wait_trap_impl(
39
+
mach_port_name_t wait_name);
40
+
kern_return_t semaphore_wait_signal_trap_impl(
41
+
mach_port_name_t wait_name,
42
+
mach_port_name_t signal_name);
43
+
kern_return_t semaphore_timedwait_trap_impl(
44
+
mach_port_name_t wait_name,
45
+
unsigned int sec,
46
+
clock_res_t nsec);
47
+
kern_return_t semaphore_timedwait_signal_trap_impl(
48
+
mach_port_name_t wait_name,
49
+
mach_port_name_t signal_name,
50
+
unsigned int sec,
51
+
clock_res_t nsec);
52
+
kern_return_t clock_sleep_trap_impl(
53
+
mach_port_name_t clock_name,
54
+
sleep_type_t sleep_type,
55
+
int sleep_sec,
56
+
int sleep_nsec,
57
+
mach_timespec_t *wakeup_time);
58
+
kern_return_t _kernelrpc_mach_vm_allocate_trap_impl(
59
+
mach_port_name_t target,
60
+
mach_vm_offset_t *addr,
61
+
mach_vm_size_t size,
62
+
int flags);
63
+
kern_return_t _kernelrpc_mach_vm_deallocate_trap_impl(
64
+
mach_port_name_t target,
65
+
mach_vm_address_t address,
66
+
mach_vm_size_t size
67
+
);
68
+
kern_return_t _kernelrpc_mach_vm_protect_trap_impl(
69
+
mach_port_name_t target,
70
+
mach_vm_address_t address,
71
+
mach_vm_size_t size,
72
+
boolean_t set_maximum,
73
+
vm_prot_t new_protection
74
+
);
75
+
kern_return_t _kernelrpc_mach_vm_map_trap_impl(
76
+
mach_port_name_t target,
77
+
mach_vm_offset_t *address,
78
+
mach_vm_size_t size,
79
+
mach_vm_offset_t mask,
80
+
int flags,
81
+
vm_prot_t cur_protection
82
+
);
83
+
kern_return_t _kernelrpc_mach_port_allocate_trap_impl(
84
+
mach_port_name_t target,
85
+
mach_port_right_t right,
86
+
mach_port_name_t *name
87
+
);
88
+
kern_return_t _kernelrpc_mach_port_destroy_trap_impl(
89
+
mach_port_name_t target,
90
+
mach_port_name_t name
91
+
);
92
+
kern_return_t _kernelrpc_mach_port_deallocate_trap_impl(
93
+
mach_port_name_t target,
94
+
mach_port_name_t name
95
+
);
96
+
kern_return_t _kernelrpc_mach_port_mod_refs_trap_impl(
97
+
mach_port_name_t target,
98
+
mach_port_name_t name,
99
+
mach_port_right_t right,
100
+
mach_port_delta_t delta
101
+
);
102
+
kern_return_t _kernelrpc_mach_port_move_member_trap_impl(
103
+
mach_port_name_t target,
104
+
mach_port_name_t member,
105
+
mach_port_name_t after
106
+
);
107
+
kern_return_t _kernelrpc_mach_port_insert_right_trap_impl(
108
+
mach_port_name_t target,
109
+
mach_port_name_t name,
110
+
mach_port_name_t poly,
111
+
mach_msg_type_name_t polyPoly
112
+
);
113
+
kern_return_t _kernelrpc_mach_port_insert_member_trap_impl(
114
+
mach_port_name_t target,
115
+
mach_port_name_t name,
116
+
mach_port_name_t pset
117
+
);
118
+
kern_return_t _kernelrpc_mach_port_extract_member_trap_impl(
119
+
mach_port_name_t target,
120
+
mach_port_name_t name,
121
+
mach_port_name_t pset
122
+
);
123
+
kern_return_t _kernelrpc_mach_port_construct_trap_impl(
124
+
mach_port_name_t target,
125
+
mach_port_options_t *options,
126
+
uint64_t context,
127
+
mach_port_name_t *name
128
+
);
129
+
kern_return_t _kernelrpc_mach_port_destruct_trap_impl(
130
+
mach_port_name_t target,
131
+
mach_port_name_t name,
132
+
mach_port_delta_t srdelta,
133
+
uint64_t guard
134
+
);
135
+
kern_return_t _kernelrpc_mach_port_guard_trap_impl(
136
+
mach_port_name_t target,
137
+
mach_port_name_t name,
138
+
uint64_t guard,
139
+
boolean_t strict
140
+
);
141
+
kern_return_t _kernelrpc_mach_port_unguard_trap_impl(
142
+
mach_port_name_t target,
143
+
mach_port_name_t name,
144
+
uint64_t guard
145
+
);
146
+
kern_return_t macx_swapon_impl(
147
+
uint64_t filename,
148
+
int flags,
149
+
int size,
150
+
int priority);
151
+
kern_return_t macx_swapoff_impl(
152
+
uint64_t filename,
153
+
int flags);
154
+
kern_return_t macx_triggers_impl(
155
+
int hi_water,
156
+
int low_water,
157
+
int flags,
158
+
mach_port_t alert_port);
159
+
kern_return_t macx_backing_store_suspend_impl(
160
+
boolean_t suspend);
161
+
kern_return_t macx_backing_store_recovery_impl(
162
+
int pid);
163
+
boolean_t swtch_pri_impl(int pri);
164
+
boolean_t swtch_impl(void);
165
+
kern_return_t syscall_thread_switch_impl(
166
+
mach_port_name_t thread_name,
167
+
int option,
168
+
mach_msg_timeout_t option_time);
169
+
mach_port_name_t task_self_trap_impl(void);
170
+
kern_return_t task_for_pid_impl(
171
+
mach_port_name_t target_tport,
172
+
int pid,
173
+
mach_port_name_t *t);
174
+
kern_return_t task_name_for_pid_impl(
175
+
mach_port_name_t target_tport,
176
+
int pid,
177
+
mach_port_name_t *tn);
178
+
kern_return_t pid_for_task_impl(
179
+
mach_port_name_t t,
180
+
int *x);
181
+
kern_return_t bsdthread_terminate_trap_impl(
182
+
uintptr_t stackaddr,
183
+
unsigned long freesize,
184
+
mach_port_name_t thread,
185
+
mach_port_name_t sem);
186
+
boolean_t voucher_mach_msg_set(mach_msg_header_t *msg);
187
+
void voucher_mach_msg_revert(voucher_mach_msg_state_t state);
188
+
voucher_mach_msg_state_t voucher_mach_msg_adopt(mach_msg_header_t *msg);
189
+
kern_return_t mach_generate_activity_id_impl(mach_port_name_t task, int i, uint64_t* id);
190
+
mach_port_name_t mk_timer_create_impl(void);
191
+
kern_return_t mk_timer_destroy_impl(mach_port_name_t name);
192
+
kern_return_t mk_timer_arm_impl(mach_port_name_t name, uint64_t expire_time);
193
+
kern_return_t mk_timer_cancel_impl(mach_port_name_t name, uint64_t *result_time);
194
+
195
+
#endif
196
+