1 /* 2 * process related system call shims and definitions 3 * 4 * Copyright (c) 2013-2014 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_PROC_H_ 21 #define BSD_PROC_H_ 22 23 #include <sys/resource.h> 24 25 #include "qemu-bsd.h" 26 #include "gdbstub/syscalls.h" 27 #include "qemu/plugin.h" 28 29 extern int _getlogin(char*, int); 30 int bsd_get_ncpu(void); 31 32 /* exit(2) */ 33 static inline abi_long do_bsd_exit(void *cpu_env, abi_long arg1) 34 { 35 gdb_exit(arg1); 36 qemu_plugin_user_exit(); 37 _exit(arg1); 38 39 return 0; 40 } 41 42 /* getgroups(2) */ 43 static inline abi_long do_bsd_getgroups(abi_long gidsetsize, abi_long arg2) 44 { 45 abi_long ret; 46 uint32_t *target_grouplist; 47 g_autofree gid_t *grouplist; 48 int i; 49 50 grouplist = g_try_new(gid_t, gidsetsize); 51 ret = get_errno(getgroups(gidsetsize, grouplist)); 52 if (gidsetsize != 0) { 53 if (!is_error(ret)) { 54 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0); 55 if (!target_grouplist) { 56 return -TARGET_EFAULT; 57 } 58 for (i = 0; i < ret; i++) { 59 target_grouplist[i] = tswap32(grouplist[i]); 60 } 61 unlock_user(target_grouplist, arg2, gidsetsize * 2); 62 } 63 } 64 return ret; 65 } 66 67 /* setgroups(2) */ 68 static inline abi_long do_bsd_setgroups(abi_long gidsetsize, abi_long arg2) 69 { 70 uint32_t *target_grouplist; 71 g_autofree gid_t *grouplist; 72 int i; 73 74 grouplist = g_try_new(gid_t, gidsetsize); 75 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1); 76 if (!target_grouplist) { 77 return -TARGET_EFAULT; 78 } 79 for (i = 0; i < gidsetsize; i++) { 80 grouplist[i] = tswap32(target_grouplist[i]); 81 } 82 unlock_user(target_grouplist, arg2, 0); 83 return get_errno(setgroups(gidsetsize, grouplist)); 84 } 85 86 /* umask(2) */ 87 static inline abi_long do_bsd_umask(abi_long arg1) 88 { 89 return get_errno(umask(arg1)); 90 } 91 92 /* setlogin(2) */ 93 static inline abi_long do_bsd_setlogin(abi_long arg1) 94 { 95 abi_long ret; 96 void *p; 97 98 p = lock_user_string(arg1); 99 if (p == NULL) { 100 return -TARGET_EFAULT; 101 } 102 ret = get_errno(setlogin(p)); 103 unlock_user(p, arg1, 0); 104 105 return ret; 106 } 107 108 /* getlogin(2) */ 109 static inline abi_long do_bsd_getlogin(abi_long arg1, abi_long arg2) 110 { 111 abi_long ret; 112 void *p; 113 114 p = lock_user(VERIFY_WRITE, arg1, arg2, 0); 115 if (p == NULL) { 116 return -TARGET_EFAULT; 117 } 118 ret = get_errno(_getlogin(p, arg2)); 119 unlock_user(p, arg1, arg2); 120 121 return ret; 122 } 123 124 /* getrusage(2) */ 125 static inline abi_long do_bsd_getrusage(abi_long who, abi_ulong target_addr) 126 { 127 abi_long ret; 128 struct rusage rusage; 129 130 ret = get_errno(getrusage(who, &rusage)); 131 if (!is_error(ret)) { 132 host_to_target_rusage(target_addr, &rusage); 133 } 134 return ret; 135 } 136 137 /* getrlimit(2) */ 138 static inline abi_long do_bsd_getrlimit(abi_long arg1, abi_ulong arg2) 139 { 140 abi_long ret; 141 int resource = target_to_host_resource(arg1); 142 struct target_rlimit *target_rlim; 143 struct rlimit rlim; 144 145 switch (resource) { 146 case RLIMIT_STACK: 147 rlim.rlim_cur = target_dflssiz; 148 rlim.rlim_max = target_maxssiz; 149 ret = 0; 150 break; 151 152 case RLIMIT_DATA: 153 rlim.rlim_cur = target_dfldsiz; 154 rlim.rlim_max = target_maxdsiz; 155 ret = 0; 156 break; 157 158 default: 159 ret = get_errno(getrlimit(resource, &rlim)); 160 break; 161 } 162 if (!is_error(ret)) { 163 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) { 164 return -TARGET_EFAULT; 165 } 166 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur); 167 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max); 168 unlock_user_struct(target_rlim, arg2, 1); 169 } 170 return ret; 171 } 172 173 /* setrlimit(2) */ 174 static inline abi_long do_bsd_setrlimit(abi_long arg1, abi_ulong arg2) 175 { 176 abi_long ret; 177 int resource = target_to_host_resource(arg1); 178 struct target_rlimit *target_rlim; 179 struct rlimit rlim; 180 181 if (RLIMIT_STACK == resource) { 182 /* XXX We should, maybe, allow the stack size to shrink */ 183 ret = -TARGET_EPERM; 184 } else { 185 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) { 186 return -TARGET_EFAULT; 187 } 188 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur); 189 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max); 190 unlock_user_struct(target_rlim, arg2, 0); 191 ret = get_errno(setrlimit(resource, &rlim)); 192 } 193 return ret; 194 } 195 196 /* getpid(2) */ 197 static inline abi_long do_bsd_getpid(void) 198 { 199 return get_errno(getpid()); 200 } 201 202 /* getppid(2) */ 203 static inline abi_long do_bsd_getppid(void) 204 { 205 return get_errno(getppid()); 206 } 207 208 /* getuid(2) */ 209 static inline abi_long do_bsd_getuid(void) 210 { 211 return get_errno(getuid()); 212 } 213 214 /* geteuid(2) */ 215 static inline abi_long do_bsd_geteuid(void) 216 { 217 return get_errno(geteuid()); 218 } 219 220 /* getgid(2) */ 221 static inline abi_long do_bsd_getgid(void) 222 { 223 return get_errno(getgid()); 224 } 225 226 /* getegid(2) */ 227 static inline abi_long do_bsd_getegid(void) 228 { 229 return get_errno(getegid()); 230 } 231 232 /* setuid(2) */ 233 static inline abi_long do_bsd_setuid(abi_long arg1) 234 { 235 return get_errno(setuid(arg1)); 236 } 237 238 /* seteuid(2) */ 239 static inline abi_long do_bsd_seteuid(abi_long arg1) 240 { 241 return get_errno(seteuid(arg1)); 242 } 243 244 /* setgid(2) */ 245 static inline abi_long do_bsd_setgid(abi_long arg1) 246 { 247 return get_errno(setgid(arg1)); 248 } 249 250 /* setegid(2) */ 251 static inline abi_long do_bsd_setegid(abi_long arg1) 252 { 253 return get_errno(setegid(arg1)); 254 } 255 256 /* getpgid(2) */ 257 static inline abi_long do_bsd_getpgid(pid_t pid) 258 { 259 return get_errno(getpgid(pid)); 260 } 261 262 /* setpgid(2) */ 263 static inline abi_long do_bsd_setpgid(int pid, int pgrp) 264 { 265 return get_errno(setpgid(pid, pgrp)); 266 } 267 268 /* getpgrp(2) */ 269 static inline abi_long do_bsd_getpgrp(void) 270 { 271 return get_errno(getpgrp()); 272 } 273 274 /* setreuid(2) */ 275 static inline abi_long do_bsd_setreuid(abi_long arg1, abi_long arg2) 276 { 277 return get_errno(setreuid(arg1, arg2)); 278 } 279 280 /* setregid(2) */ 281 static inline abi_long do_bsd_setregid(abi_long arg1, abi_long arg2) 282 { 283 return get_errno(setregid(arg1, arg2)); 284 } 285 286 /* setresgid(2) */ 287 static inline abi_long do_bsd_setresgid(gid_t rgid, gid_t egid, gid_t sgid) 288 { 289 return get_errno(setresgid(rgid, egid, sgid)); 290 } 291 292 /* setresuid(2) */ 293 static inline abi_long do_bsd_setresuid(uid_t ruid, uid_t euid, uid_t suid) 294 { 295 return get_errno(setresuid(ruid, euid, suid)); 296 } 297 298 /* getresuid(2) */ 299 static inline abi_long do_bsd_getresuid(abi_ulong arg1, abi_ulong arg2, 300 abi_ulong arg3) 301 { 302 abi_long ret; 303 uid_t ruid, euid, suid; 304 305 ret = get_errno(getresuid(&ruid, &euid, &suid)); 306 if (is_error(ret)) { 307 return ret; 308 } 309 if (put_user_s32(ruid, arg1)) { 310 return -TARGET_EFAULT; 311 } 312 if (put_user_s32(euid, arg2)) { 313 return -TARGET_EFAULT; 314 } 315 if (put_user_s32(suid, arg3)) { 316 return -TARGET_EFAULT; 317 } 318 return ret; 319 } 320 321 /* getresgid(2) */ 322 static inline abi_long do_bsd_getresgid(abi_ulong arg1, abi_ulong arg2, 323 abi_ulong arg3) 324 { 325 abi_long ret; 326 uid_t ruid, euid, suid; 327 328 ret = get_errno(getresgid(&ruid, &euid, &suid)); 329 if (is_error(ret)) { 330 return ret; 331 } 332 if (put_user_s32(ruid, arg1)) { 333 return -TARGET_EFAULT; 334 } 335 if (put_user_s32(euid, arg2)) { 336 return -TARGET_EFAULT; 337 } 338 if (put_user_s32(suid, arg3)) { 339 return -TARGET_EFAULT; 340 } 341 return ret; 342 } 343 344 /* getsid(2) */ 345 static inline abi_long do_bsd_getsid(abi_long arg1) 346 { 347 return get_errno(getsid(arg1)); 348 } 349 350 /* setsid(2) */ 351 static inline abi_long do_bsd_setsid(void) 352 { 353 return get_errno(setsid()); 354 } 355 356 /* issetugid(2) */ 357 static inline abi_long do_bsd_issetugid(void) 358 { 359 return get_errno(issetugid()); 360 } 361 362 /* profil(2) */ 363 static inline abi_long do_bsd_profil(abi_long arg1, abi_long arg2, 364 abi_long arg3, abi_long arg4) 365 { 366 return -TARGET_ENOSYS; 367 } 368 369 /* ktrace(2) */ 370 static inline abi_long do_bsd_ktrace(abi_long arg1, abi_long arg2, 371 abi_long arg3, abi_long arg4) 372 { 373 return -TARGET_ENOSYS; 374 } 375 376 /* utrace(2) */ 377 static inline abi_long do_bsd_utrace(abi_long arg1, abi_long arg2) 378 { 379 return -TARGET_ENOSYS; 380 } 381 382 383 /* ptrace(2) */ 384 static inline abi_long do_bsd_ptrace(abi_long arg1, abi_long arg2, 385 abi_long arg3, abi_long arg4) 386 { 387 return -TARGET_ENOSYS; 388 } 389 390 /* getpriority(2) */ 391 static inline abi_long do_bsd_getpriority(abi_long which, abi_long who) 392 { 393 abi_long ret; 394 /* 395 * Note that negative values are valid for getpriority, so we must 396 * differentiate based on errno settings. 397 */ 398 errno = 0; 399 ret = getpriority(which, who); 400 if (ret == -1 && errno != 0) { 401 return -host_to_target_errno(errno); 402 } 403 404 return ret; 405 } 406 407 /* setpriority(2) */ 408 static inline abi_long do_bsd_setpriority(abi_long which, abi_long who, 409 abi_long prio) 410 { 411 return get_errno(setpriority(which, who, prio)); 412 } 413 414 #endif /* !BSD_PROC_H_ */ 415