1 /* 2 * process related system call shims and definitions 3 * 4 * Copyright (c) 2013-14 Stacey D. Son 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #ifndef BSD_USER_FREEBSD_OS_PROC_H 21 #define BSD_USER_FREEBSD_OS_PROC_H 22 23 #include <sys/param.h> 24 #include <sys/procctl.h> 25 #include <sys/signal.h> 26 #include <sys/types.h> 27 #include <sys/procdesc.h> 28 #include <sys/wait.h> 29 #include <unistd.h> 30 31 #include "target_arch_cpu.h" 32 33 pid_t safe_wait4(pid_t wpid, int *status, int options, struct rusage *rusage); 34 pid_t safe_wait6(idtype_t idtype, id_t id, int *status, int options, 35 struct __wrusage *wrusage, siginfo_t *infop); 36 37 extern int __setugid(int flag); 38 39 /* execve(2) */ 40 static inline abi_long do_freebsd_execve(abi_ulong path_or_fd, abi_ulong argp, 41 abi_ulong envp) 42 { 43 44 return freebsd_exec_common(path_or_fd, argp, envp, 0); 45 } 46 47 /* fexecve(2) */ 48 static inline abi_long do_freebsd_fexecve(abi_ulong path_or_fd, abi_ulong argp, 49 abi_ulong envp) 50 { 51 52 return freebsd_exec_common(path_or_fd, argp, envp, 1); 53 } 54 55 /* wait4(2) */ 56 static inline abi_long do_freebsd_wait4(abi_long arg1, abi_ulong target_status, 57 abi_long arg3, abi_ulong target_rusage) 58 { 59 abi_long ret; 60 int status; 61 struct rusage rusage, *rusage_ptr = NULL; 62 63 if (target_rusage) { 64 rusage_ptr = &rusage; 65 } 66 ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr)); 67 68 if (ret < 0) { 69 return ret; 70 } 71 if (target_status != 0) { 72 status = host_to_target_waitstatus(status); 73 if (put_user_s32(status, target_status) != 0) { 74 return -TARGET_EFAULT; 75 } 76 } 77 if (target_rusage != 0) { 78 host_to_target_rusage(target_rusage, &rusage); 79 } 80 return ret; 81 } 82 83 /* wait6(2) */ 84 static inline abi_long do_freebsd_wait6(void *cpu_env, abi_long idtype, 85 abi_long id1, abi_long id2, 86 abi_ulong target_status, abi_long options, abi_ulong target_wrusage, 87 abi_ulong target_infop, abi_ulong pad1) 88 { 89 abi_long ret; 90 int status; 91 struct __wrusage wrusage, *wrusage_ptr = NULL; 92 siginfo_t info; 93 void *p; 94 95 if (regpairs_aligned(cpu_env) != 0) { 96 /* printf("shifting args\n"); */ 97 /* 64-bit id is aligned, so shift all the arguments over by one */ 98 id1 = id2; 99 id2 = target_status; 100 target_status = options; 101 options = target_wrusage; 102 target_wrusage = target_infop; 103 target_infop = pad1; 104 } 105 106 if (target_wrusage) { 107 wrusage_ptr = &wrusage; 108 } 109 ret = get_errno(safe_wait6(idtype, target_arg64(id1, id2), 110 &status, options, wrusage_ptr, &info)); 111 112 if (ret < 0) { 113 return ret; 114 } 115 if (target_status != 0) { 116 status = host_to_target_waitstatus(status); 117 if (put_user_s32(status, target_status) != 0) { 118 return -TARGET_EFAULT; 119 } 120 } 121 if (target_wrusage != 0) { 122 host_to_target_wrusage(target_wrusage, &wrusage); 123 } 124 if (target_infop != 0) { 125 p = lock_user(VERIFY_WRITE, target_infop, sizeof(target_siginfo_t), 0); 126 if (p == NULL) { 127 return -TARGET_EFAULT; 128 } 129 host_to_target_siginfo(p, &info); 130 unlock_user(p, target_infop, sizeof(target_siginfo_t)); 131 } 132 return ret; 133 } 134 135 /* setloginclass(2) */ 136 static inline abi_long do_freebsd_setloginclass(abi_ulong arg1) 137 { 138 abi_long ret; 139 void *p; 140 141 p = lock_user_string(arg1); 142 if (p == NULL) { 143 return -TARGET_EFAULT; 144 } 145 ret = get_errno(setloginclass(p)); 146 unlock_user(p, arg1, 0); 147 148 return ret; 149 } 150 151 /* getloginclass(2) */ 152 static inline abi_long do_freebsd_getloginclass(abi_ulong arg1, abi_ulong arg2) 153 { 154 abi_long ret; 155 void *p; 156 157 p = lock_user(VERIFY_WRITE, arg1, arg2, 0); 158 if (p == NULL) { 159 return -TARGET_EFAULT; 160 } 161 ret = get_errno(getloginclass(p, arg2)); 162 unlock_user(p, arg1, arg2); 163 164 return ret; 165 } 166 167 /* pdgetpid(2) */ 168 static inline abi_long do_freebsd_pdgetpid(abi_long fd, abi_ulong target_pidp) 169 { 170 abi_long ret; 171 pid_t pid; 172 173 ret = get_errno(pdgetpid(fd, &pid)); 174 if (!is_error(ret)) { 175 if (put_user_u32(pid, target_pidp)) { 176 return -TARGET_EFAULT; 177 } 178 } 179 return ret; 180 } 181 182 /* undocumented __setugid */ 183 static inline abi_long do_freebsd___setugid(abi_long arg1) 184 { 185 return -TARGET_ENOSYS; 186 } 187 188 /* fork(2) */ 189 static inline abi_long do_freebsd_fork(void *cpu_env) 190 { 191 abi_long ret; 192 abi_ulong child_flag; 193 194 fork_start(); 195 ret = fork(); 196 if (ret == 0) { 197 /* child */ 198 child_flag = 1; 199 target_cpu_clone_regs(cpu_env, 0); 200 } else { 201 /* parent */ 202 child_flag = 0; 203 } 204 205 /* 206 * The fork system call sets a child flag in the second return 207 * value: 0 for parent process, 1 for child process. 208 */ 209 set_second_rval(cpu_env, child_flag); 210 211 fork_end(child_flag); 212 213 return ret; 214 } 215 216 /* vfork(2) */ 217 static inline abi_long do_freebsd_vfork(void *cpu_env) 218 { 219 return do_freebsd_fork(cpu_env); 220 } 221 222 /* rfork(2) */ 223 static inline abi_long do_freebsd_rfork(void *cpu_env, abi_long flags) 224 { 225 abi_long ret; 226 abi_ulong child_flag; 227 228 /* 229 * XXX We need to handle RFMEM here, as well. Neither are safe to execute 230 * as-is on x86 hosts because they'll split memory but not the stack, 231 * wreaking havoc on host architectures that use the stack to store the 232 * return address as both threads try to pop it off. Rejecting RFSPAWN 233 * entirely for now is ok, the only consumer at the moment is posix_spawn 234 * and it will fall back to classic vfork(2) if we return EINVAL. 235 */ 236 if ((flags & TARGET_RFSPAWN) != 0) { 237 return -TARGET_EINVAL; 238 } 239 fork_start(); 240 ret = rfork(flags); 241 if (ret == 0) { 242 /* child */ 243 child_flag = 1; 244 target_cpu_clone_regs(cpu_env, 0); 245 } else { 246 /* parent */ 247 child_flag = 0; 248 } 249 250 /* 251 * The fork system call sets a child flag in the second return 252 * value: 0 for parent process, 1 for child process. 253 */ 254 set_second_rval(cpu_env, child_flag); 255 fork_end(child_flag); 256 257 return ret; 258 259 } 260 261 /* pdfork(2) */ 262 static inline abi_long do_freebsd_pdfork(void *cpu_env, abi_ulong target_fdp, 263 abi_long flags) 264 { 265 abi_long ret; 266 abi_ulong child_flag; 267 int fd; 268 269 fork_start(); 270 ret = pdfork(&fd, flags); 271 if (ret == 0) { 272 /* child */ 273 child_flag = 1; 274 target_cpu_clone_regs(cpu_env, 0); 275 } else { 276 /* parent */ 277 child_flag = 0; 278 if (put_user_s32(fd, target_fdp)) { 279 return -TARGET_EFAULT; 280 } 281 } 282 283 /* 284 * The fork system call sets a child flag in the second return 285 * value: 0 for parent process, 1 for child process. 286 */ 287 set_second_rval(cpu_env, child_flag); 288 fork_end(child_flag); 289 290 return ret; 291 } 292 293 #endif /* BSD_USER_FREEBSD_OS_PROC_H */ 294