1 /* 2 * FreeBSD process related emulation code 3 * 4 * Copyright (c) 2013-15 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 #include "qemu/osdep.h" 20 21 #include <sys/param.h> 22 #include <sys/queue.h> 23 #include <sys/sysctl.h> 24 struct kinfo_proc; 25 #include <libprocstat.h> 26 27 #include "qemu.h" 28 29 /* 30 * Get the filename for the given file descriptor. 31 * Note that this may return NULL (fail) if no longer cached in the kernel. 32 */ 33 static char * 34 get_filename_from_fd(pid_t pid, int fd, char *filename, size_t len) 35 { 36 char *ret = NULL; 37 unsigned int cnt; 38 struct procstat *procstat = NULL; 39 struct kinfo_proc *kp = NULL; 40 struct filestat_list *head = NULL; 41 struct filestat *fst; 42 43 procstat = procstat_open_sysctl(); 44 if (procstat == NULL) { 45 goto out; 46 } 47 48 kp = procstat_getprocs(procstat, KERN_PROC_PID, pid, &cnt); 49 if (kp == NULL) { 50 goto out; 51 } 52 53 head = procstat_getfiles(procstat, kp, 0); 54 if (head == NULL) { 55 goto out; 56 } 57 58 STAILQ_FOREACH(fst, head, next) { 59 if (fd == fst->fs_fd) { 60 if (fst->fs_path != NULL) { 61 (void)strlcpy(filename, fst->fs_path, len); 62 ret = filename; 63 } 64 break; 65 } 66 } 67 68 out: 69 if (head != NULL) { 70 procstat_freefiles(procstat, head); 71 } 72 if (kp != NULL) { 73 procstat_freeprocs(procstat, kp); 74 } 75 if (procstat != NULL) { 76 procstat_close(procstat); 77 } 78 return ret; 79 } 80 81 /* 82 * execve/fexecve 83 */ 84 abi_long freebsd_exec_common(abi_ulong path_or_fd, abi_ulong guest_argp, 85 abi_ulong guest_envp, int do_fexec) 86 { 87 char **argp, **envp, **qargp, **qarg1, **qarg0, **qargend; 88 int argc, envc; 89 abi_ulong gp; 90 abi_ulong addr; 91 char **q; 92 int total_size = 0; 93 void *p; 94 abi_long ret; 95 96 argc = 0; 97 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) { 98 if (get_user_ual(addr, gp)) { 99 return -TARGET_EFAULT; 100 } 101 if (!addr) { 102 break; 103 } 104 argc++; 105 } 106 envc = 0; 107 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) { 108 if (get_user_ual(addr, gp)) { 109 return -TARGET_EFAULT; 110 } 111 if (!addr) { 112 break; 113 } 114 envc++; 115 } 116 117 qarg0 = argp = g_new0(char *, argc + 9); 118 /* save the first argument for the emulator */ 119 *argp++ = (char *)getprogname(); 120 qargp = argp; 121 *argp++ = (char *)getprogname(); 122 qarg1 = argp; 123 envp = g_new0(char *, envc + 1); 124 for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) { 125 if (get_user_ual(addr, gp)) { 126 ret = -TARGET_EFAULT; 127 goto execve_end; 128 } 129 if (!addr) { 130 break; 131 } 132 *q = lock_user_string(addr); 133 if (*q == NULL) { 134 ret = -TARGET_EFAULT; 135 goto execve_end; 136 } 137 total_size += strlen(*q) + 1; 138 } 139 *q++ = NULL; 140 qargend = q; 141 142 for (gp = guest_envp, q = envp; gp; gp += sizeof(abi_ulong), q++) { 143 if (get_user_ual(addr, gp)) { 144 ret = -TARGET_EFAULT; 145 goto execve_end; 146 } 147 if (!addr) { 148 break; 149 } 150 *q = lock_user_string(addr); 151 if (*q == NULL) { 152 ret = -TARGET_EFAULT; 153 goto execve_end; 154 } 155 total_size += strlen(*q) + 1; 156 } 157 *q = NULL; 158 159 /* 160 * This case will not be caught by the host's execve() if its 161 * page size is bigger than the target's. 162 */ 163 if (total_size > MAX_ARG_PAGES * TARGET_PAGE_SIZE) { 164 ret = -TARGET_E2BIG; 165 goto execve_end; 166 } 167 168 if (do_fexec) { 169 if (((int)path_or_fd > 0 && 170 is_target_elf_binary((int)path_or_fd)) == 1) { 171 char execpath[PATH_MAX]; 172 173 /* 174 * The executable is an elf binary for the target 175 * arch. execve() it using the emulator if we can 176 * determine the filename path from the fd. 177 */ 178 if (get_filename_from_fd(getpid(), (int)path_or_fd, execpath, 179 sizeof(execpath)) != NULL) { 180 memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1)); 181 qarg1[1] = qarg1[0]; 182 qarg1[0] = (char *)"-0"; 183 qarg1 += 2; 184 qargend += 2; 185 *qarg1 = execpath; 186 #ifndef DONT_INHERIT_INTERP_PREFIX 187 memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1)); 188 *qarg1++ = (char *)"-L"; 189 *qarg1++ = (char *)interp_prefix; 190 #endif 191 ret = get_errno(execve(qemu_proc_pathname, qargp, envp)); 192 } else { 193 /* Getting the filename path failed. */ 194 ret = -TARGET_EBADF; 195 goto execve_end; 196 } 197 } else { 198 ret = get_errno(fexecve((int)path_or_fd, argp, envp)); 199 } 200 } else { 201 int fd; 202 203 p = lock_user_string(path_or_fd); 204 if (p == NULL) { 205 ret = -TARGET_EFAULT; 206 goto execve_end; 207 } 208 209 /* 210 * Check the header and see if it a target elf binary. If so 211 * then execute using qemu user mode emulator. 212 */ 213 fd = open(p, O_RDONLY | O_CLOEXEC); 214 if (fd > 0 && is_target_elf_binary(fd) == 1) { 215 close(fd); 216 /* execve() as a target binary using emulator. */ 217 memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1)); 218 qarg1[1] = qarg1[0]; 219 qarg1[0] = (char *)"-0"; 220 qarg1 += 2; 221 qargend += 2; 222 *qarg1 = (char *)p; 223 #ifndef DONT_INHERIT_INTERP_PREFIX 224 memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1)); 225 *qarg1++ = (char *)"-L"; 226 *qarg1++ = (char *)interp_prefix; 227 #endif 228 ret = get_errno(execve(qemu_proc_pathname, qargp, envp)); 229 } else { 230 close(fd); 231 /* Execve() as a host native binary. */ 232 ret = get_errno(execve(p, argp, envp)); 233 } 234 unlock_user(p, path_or_fd, 0); 235 } 236 237 execve_end: 238 for (gp = guest_argp, q = argp; *q; gp += sizeof(abi_ulong), q++) { 239 if (get_user_ual(addr, gp) || !addr) { 240 break; 241 } 242 unlock_user(*q, addr, 0); 243 } 244 245 for (gp = guest_envp, q = envp; *q; gp += sizeof(abi_ulong), q++) { 246 if (get_user_ual(addr, gp) || !addr) { 247 break; 248 } 249 unlock_user(*q, addr, 0); 250 } 251 252 g_free(qarg0); 253 g_free(envp); 254 255 return ret; 256 } 257 258 #include <sys/procctl.h> 259 260 static abi_long 261 t2h_procctl_cmd(int target_cmd, int *host_cmd) 262 { 263 switch (target_cmd) { 264 case TARGET_PROC_SPROTECT: 265 *host_cmd = PROC_SPROTECT; 266 break; 267 268 case TARGET_PROC_REAP_ACQUIRE: 269 *host_cmd = PROC_REAP_ACQUIRE; 270 break; 271 272 case TARGET_PROC_REAP_RELEASE: 273 *host_cmd = PROC_REAP_RELEASE; 274 break; 275 276 case TARGET_PROC_REAP_STATUS: 277 *host_cmd = PROC_REAP_STATUS; 278 break; 279 280 case TARGET_PROC_REAP_KILL: 281 *host_cmd = PROC_REAP_KILL; 282 break; 283 284 default: 285 return -TARGET_EINVAL; 286 } 287 288 return 0; 289 } 290 291 static abi_long 292 h2t_reaper_status(struct procctl_reaper_status *host_rs, 293 abi_ulong target_rs_addr) 294 { 295 struct target_procctl_reaper_status *target_rs; 296 297 if (!lock_user_struct(VERIFY_WRITE, target_rs, target_rs_addr, 0)) { 298 return -TARGET_EFAULT; 299 } 300 __put_user(host_rs->rs_flags, &target_rs->rs_flags); 301 __put_user(host_rs->rs_children, &target_rs->rs_children); 302 __put_user(host_rs->rs_descendants, &target_rs->rs_descendants); 303 __put_user(host_rs->rs_reaper, &target_rs->rs_reaper); 304 __put_user(host_rs->rs_pid, &target_rs->rs_pid); 305 unlock_user_struct(target_rs, target_rs_addr, 1); 306 307 return 0; 308 } 309 310 static abi_long 311 t2h_reaper_kill(abi_ulong target_rk_addr, struct procctl_reaper_kill *host_rk) 312 { 313 struct target_procctl_reaper_kill *target_rk; 314 315 if (!lock_user_struct(VERIFY_READ, target_rk, target_rk_addr, 1)) { 316 return -TARGET_EFAULT; 317 } 318 __get_user(host_rk->rk_sig, &target_rk->rk_sig); 319 __get_user(host_rk->rk_flags, &target_rk->rk_flags); 320 __get_user(host_rk->rk_subtree, &target_rk->rk_subtree); 321 __get_user(host_rk->rk_killed, &target_rk->rk_killed); 322 __get_user(host_rk->rk_fpid, &target_rk->rk_fpid); 323 unlock_user_struct(target_rk, target_rk_addr, 0); 324 325 return 0; 326 } 327 328 static abi_long 329 h2t_reaper_kill(struct procctl_reaper_kill *host_rk, abi_ulong target_rk_addr) 330 { 331 struct target_procctl_reaper_kill *target_rk; 332 333 if (!lock_user_struct(VERIFY_WRITE, target_rk, target_rk_addr, 0)) { 334 return -TARGET_EFAULT; 335 } 336 __put_user(host_rk->rk_sig, &target_rk->rk_sig); 337 __put_user(host_rk->rk_flags, &target_rk->rk_flags); 338 __put_user(host_rk->rk_subtree, &target_rk->rk_subtree); 339 __put_user(host_rk->rk_killed, &target_rk->rk_killed); 340 __put_user(host_rk->rk_fpid, &target_rk->rk_fpid); 341 unlock_user_struct(target_rk, target_rk_addr, 1); 342 343 return 0; 344 } 345 346 static abi_long 347 h2t_procctl_reaper_pidinfo(struct procctl_reaper_pidinfo *host_pi, 348 abi_ulong target_pi_addr) 349 { 350 struct target_procctl_reaper_pidinfo *target_pi; 351 352 if (!lock_user_struct(VERIFY_WRITE, target_pi, target_pi_addr, 0)) { 353 return -TARGET_EFAULT; 354 } 355 __put_user(host_pi->pi_pid, &target_pi->pi_pid); 356 __put_user(host_pi->pi_subtree, &target_pi->pi_subtree); 357 __put_user(host_pi->pi_flags, &target_pi->pi_flags); 358 unlock_user_struct(target_pi, target_pi_addr, 1); 359 360 return 0; 361 } 362 363 abi_long 364 do_freebsd_procctl(void *cpu_env, int idtype, abi_ulong arg2, abi_ulong arg3, 365 abi_ulong arg4, abi_ulong arg5, abi_ulong arg6) 366 { 367 abi_long error = 0, target_rp_pids; 368 void *data; 369 int host_cmd, flags; 370 uint32_t u, target_rp_count; 371 g_autofree union { 372 struct procctl_reaper_status rs; 373 struct procctl_reaper_pids rp; 374 struct procctl_reaper_kill rk; 375 } host; 376 struct target_procctl_reaper_pids *target_rp; 377 id_t id; /* 64-bit */ 378 int target_cmd; 379 abi_ulong target_arg; 380 381 #if TARGET_ABI_BITS == 32 382 /* See if we need to align the register pairs. */ 383 if (regpairs_aligned(cpu_env)) { 384 id = (id_t)target_arg64(arg3, arg4); 385 target_cmd = (int)arg5; 386 target_arg = arg6; 387 } else { 388 id = (id_t)target_arg64(arg2, arg3); 389 target_cmd = (int)arg4; 390 target_arg = arg5; 391 } 392 #else 393 id = (id_t)arg2; 394 target_cmd = (int)arg3; 395 target_arg = arg4; 396 #endif 397 398 error = t2h_procctl_cmd(target_cmd, &host_cmd); 399 if (error) { 400 return error; 401 } 402 switch (host_cmd) { 403 case PROC_SPROTECT: 404 data = &flags; 405 break; 406 407 case PROC_REAP_ACQUIRE: 408 case PROC_REAP_RELEASE: 409 if (target_arg == 0) { 410 data = NULL; 411 } else { 412 error = -TARGET_EINVAL; 413 } 414 break; 415 416 case PROC_REAP_STATUS: 417 data = &host.rs; 418 break; 419 420 case PROC_REAP_GETPIDS: 421 if (!lock_user_struct(VERIFY_READ, target_rp, target_arg, 1)) { 422 return -TARGET_EFAULT; 423 } 424 __get_user(target_rp_count, &target_rp->rp_count); 425 __get_user(target_rp_pids, &target_rp->rp_pids); 426 unlock_user_struct(target_rp, target_arg, 0); 427 host.rp.rp_count = target_rp_count; 428 host.rp.rp_pids = g_try_new(struct procctl_reaper_pidinfo, 429 target_rp_count); 430 431 if (host.rp.rp_pids == NULL) { 432 error = -TARGET_ENOMEM; 433 } else { 434 data = &host.rp; 435 } 436 break; 437 438 case PROC_REAP_KILL: 439 error = t2h_reaper_kill(target_arg, &host.rk); 440 break; 441 } 442 443 if (error) { 444 return error; 445 } 446 error = get_errno(procctl(idtype, id, host_cmd, data)); 447 448 if (error) { 449 return error; 450 } 451 switch (host_cmd) { 452 case PROC_SPROTECT: 453 if (put_user_s32(flags, target_arg)) { 454 return -TARGET_EFAULT; 455 } 456 break; 457 458 case PROC_REAP_STATUS: 459 error = h2t_reaper_status(&host.rs, target_arg); 460 break; 461 462 case PROC_REAP_GETPIDS: 463 /* copyout reaper pidinfo */ 464 for (u = 0; u < target_rp_count; u++) { 465 error = h2t_procctl_reaper_pidinfo(&host.rp.rp_pids[u], 466 target_rp_pids + 467 (u * sizeof(struct target_procctl_reaper_pidinfo))); 468 if (error) { 469 break; 470 } 471 } 472 break; 473 474 case PROC_REAP_KILL: 475 error = h2t_reaper_kill(&host.rk, target_arg); 476 break; 477 } 478 479 return error; 480 } 481