diff options
Diffstat (limited to 'proc_proxy/process_ops.c')
| -rw-r--r-- | proc_proxy/process_ops.c | 453 |
1 files changed, 453 insertions, 0 deletions
diff --git a/proc_proxy/process_ops.c b/proc_proxy/process_ops.c new file mode 100644 index 00000000..ed6b2f76 --- /dev/null +++ b/proc_proxy/process_ops.c @@ -0,0 +1,453 @@ +/* Copyright (C) 2008 Free Software Foundation, Inc. + Written by Zheng Da. + + This file is part of the GNU Hurd. + + The GNU Hurd is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + The GNU Hurd is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with the GNU Hurd; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <error.h> + +#include "process_S.h" + +kern_return_t +S_proc_getprivports (vpstruct_t process, mach_port_t *host_priv, + mach_port_t *device_master) +{ + extern mach_port_t master_port; + kern_return_t ret = 0; + debug ("task id: %d\n", process->task_id); + if (host_priv) + { + mach_port_t orig_device_master; + ret = proc_getprivports (process->proc, host_priv, + &orig_device_master); + if (ret) + { + error (0, ret, "proc_getprivports"); + return ret; + } + mach_port_deallocate (mach_task_self (), orig_device_master); + } + + if (device_master) + *device_master = master_port; + return ret; +} + +kern_return_t +S_proc_getallpids (vpstruct_t process, pidarray_t *pidarray, + mach_msg_type_number_t *pidarrayCnt) +{ + debug ("task id: %d\n", process->task_id); + return proc_getallpids (getproc (), pidarray, pidarrayCnt); +} + +kern_return_t +S_proc_setexecdata (vpstruct_t process, portarray_t ports, + mach_msg_type_number_t portsCnt, intarray_t ints, + mach_msg_type_number_t intsCnt) +{ + debug ("task id: %d\n", process->task_id); + return proc_setexecdata (process->proc, ports, MACH_MSG_TYPE_COPY_SEND, + portsCnt, ints, intsCnt); +} + +kern_return_t +S_proc_getexecdata (vpstruct_t process, portarray_t *ports, + mach_msg_type_name_t *portsPoly, + mach_msg_type_number_t *portsCnt, + intarray_t *ints, mach_msg_type_number_t *intsCnt) +{ + kern_return_t ret; + debug ("task id: %d\n", process->task_id); + ret = proc_getexecdata (process->proc, ports, portsCnt, ints, intsCnt); + if (ret == 0) + *portsPoly = MACH_MSG_TYPE_MOVE_SEND; + return ret; +} + +kern_return_t +S_proc_execdata_notify (vpstruct_t process, mach_port_t notify) +{ + debug ("task id: %d\n", process->task_id); + return proc_execdata_notify (process->proc, notify, MACH_MSG_TYPE_MOVE_SEND); +} + +kern_return_t +S_proc_uname (vpstruct_t process, utsname_t *uname) +{ + debug ("task id: %d\n", process->task_id); + return proc_uname (process->proc, uname); +} + +kern_return_t +S_proc_register_version (vpstruct_t process, mach_port_t credential, + string_t name, string_t release, string_t version) +{ + debug ("task id: %d\n", process->task_id); + return proc_register_version (process->proc, credential, + name, release, version); +} + +kern_return_t +S_proc_reauthenticate (vpstruct_t process, mach_port_t rendezvous2) +{ + debug ("task id: %d\n", process->task_id); + return proc_reauthenticate (process->proc, rendezvous2, + MACH_MSG_TYPE_MOVE_SEND); +} + +kern_return_t +S_proc_child (vpstruct_t process, mach_port_t child) +{ + debug ("task id: %d, child task: %d\n", process->task_id, child); + return proc_child (process->proc, child); +} + +kern_return_t +S_proc_setmsgport (vpstruct_t process, mach_port_t reply_port, + mach_msg_type_name_t reply_portPoly, mach_port_t newmsgport, + mach_port_t *oldmsgport, mach_msg_type_name_t *oldmsgportPoly) +{ + kern_return_t ret=0; + debug ("task id: %d\n", process->task_id); + ret = proc_setmsgport (process->proc, newmsgport, oldmsgport); + if (ret == 0){ + *oldmsgportPoly = MACH_MSG_TYPE_MOVE_SEND; + } + return ret; +} + +kern_return_t +S_proc_getmsgport (vpstruct_t process, mach_port_t reply_port, + mach_msg_type_name_t reply_portPoly, pid_t pid, + mach_port_t *msgport) +{ + debug ("task id: %d\n", process->task_id); + return proc_getmsgport (getproc(), pid, msgport); +} + +kern_return_t +S_proc_reassign (vpstruct_t process, mach_port_t newtask) +{ + debug ("task id: %d\n", process->task_id); + return proc_reassign (process->proc, newtask); +} + +kern_return_t +S_proc_setowner (vpstruct_t process, uid_t owner, int clear) +{ + debug ("task id: %d\n", process->task_id); + return proc_setowner (process->proc, owner, clear); +} + +kern_return_t +S_proc_getpids (vpstruct_t process, pid_t *pid, + pid_t *ppid, int *orphaned) +{ + debug ("task id: %d\n", process->task_id); + return proc_getpids (process->proc, pid, ppid, orphaned); +} + +kern_return_t +S_proc_set_arg_locations (vpstruct_t process, vm_address_t argv, + vm_address_t envp) +{ + kern_return_t ret; + debug ("task id: %d\n", process->task_id); + ret = proc_set_arg_locations(process->proc , argv , envp); + if (ret) + error (4, ret, "proc_set_arg_locations"); + return ret; +} + +kern_return_t +S_proc_get_arg_locations (vpstruct_t process, vm_address_t *argv, + vm_address_t *envp) +{ + debug ("task id: %d\n", process->task_id); + return proc_get_arg_locations (process->proc, argv, envp); +} + +kern_return_t +S_proc_wait (vpstruct_t process, mach_port_t reply_port, + mach_msg_type_name_t reply_portPoly, pid_t pid, int options, + int *status, int *sigcode, rusage_t *rusage, pid_t *pid_status) +{ + debug ("task id: %d\n", process->task_id); + return proc_wait (process->proc, pid, options, status, sigcode, + rusage, pid_status); +} + +kern_return_t +S_proc_dostop (vpstruct_t process, mach_port_t contthread) +{ + kern_return_t ret; + + debug ("task id: %d\n", process->task_id); + ret = proc_dostop(process->proc, contthread); + if (ret) + error (4, ret, "proc_dostop"); + return ret; +} + +kern_return_t +S_proc_handle_exceptions (vpstruct_t process, mach_port_t msgport, + mach_port_t forwardport, int flavor, + thread_state_t new_state, + mach_msg_type_number_t new_stateCnt) +{ + debug ("task id: %d\n", process->task_id); + return proc_handle_exceptions (process->proc, msgport, forwardport, + MACH_MSG_TYPE_MOVE_SEND, flavor, + new_state, new_stateCnt); +} + +kern_return_t +S_proc_mark_stop (vpstruct_t process, int signo, int sigcode) +{ + debug ("task id: %d\n", process->task_id); + return proc_mark_stop (process->proc, signo, sigcode); +} + +kern_return_t +S_proc_mark_cont (vpstruct_t process) +{ + debug ("task id: %d\n", process->task_id); + return proc_mark_cont (process->proc); +} + +kern_return_t +S_proc_mark_exit (vpstruct_t process, int status, int sigcode) +{ + debug ("task id: %d\n", process->task_id); + return proc_mark_exit (process->proc, status, sigcode); +} + +kern_return_t +S_proc_mark_traced (vpstruct_t process) +{ + debug ("task id: %d\n", process->task_id); + return proc_mark_traced (process->proc); +} + +kern_return_t +S_proc_mark_exec (vpstruct_t process) +{ + debug ("task id: %d\n", process->task_id); + return proc_mark_exec (process->proc); +} + +kern_return_t +S_proc_mod_stopchild (vpstruct_t process, int doit) +{ + debug ("task id: %d\n", process->task_id); + return proc_mod_stopchild (process->proc , doit); +} + +kern_return_t +S_proc_pid2task (vpstruct_t process, pid_t pid, mach_port_t *task) +{ + kern_return_t ret; + ret = proc_pid2task (getproc (), pid, task); + debug ("pid: %d, task: %d\n", pid, *task); + return ret; +} + +kern_return_t +S_proc_task2pid (vpstruct_t process, mach_port_t task, pid_t *pid) +{ + debug ("task id: %d\n", task); + return proc_task2pid (getproc (), task, pid); +} + +kern_return_t +S_proc_task2proc (vpstruct_t callerp, mach_port_t task, + mach_port_t *proc) +{ + kern_return_t err; + process_t actual_proc; + + debug ("task id: %d\n", task); + vpstruct_t process = find_task (task); + *proc = ports_get_right (process); + + /* Get the actuall port to the proc server. */ + err = proc_task2proc (getproc (), task, &actual_proc); + if (err) + error (3, err, "proc_task2proc"); + process->proc = actual_proc; + + /* TODO Do I always need to deallocate task? */ + mach_port_deallocate (mach_task_self (), task); + return 0; +} + +kern_return_t +S_proc_proc2task (vpstruct_t process, mach_port_t *task) +{ + debug ("task id: %d\n", process->task_id); + *task = process->task_id; + return 0; +} + +kern_return_t +S_proc_pid2proc (vpstruct_t process, pid_t pid, mach_port_t *proc) +{ + debug ("pid id: %d\n", pid); + return proc_pid2proc (getproc (), pid, proc); +} + +kern_return_t +S_proc_getprocinfo (vpstruct_t process, pid_t which, int *flags, + procinfo_t *procinfo, mach_msg_type_number_t *procinfoCnt, + data_t *threadwaits, mach_msg_type_number_t *threadwaitsCnt) +{ + debug ("pid id: %d\n", which); + return proc_getprocinfo (getproc (), which, flags, procinfo, + procinfoCnt, threadwaits, threadwaitsCnt); +} + +kern_return_t +S_proc_getprocargs (vpstruct_t process, pid_t which, + data_t *procargs, mach_msg_type_number_t *procargsCnt) +{ + debug ("pid id: %d\n", which); + return proc_getprocargs (getproc (), which, procargs, procargsCnt); +} + +kern_return_t +S_proc_getprocenv (vpstruct_t process, pid_t which, + data_t *procenv, mach_msg_type_number_t *procenvCnt) +{ + debug ("pid id: %d\n", which); + return proc_getprocenv (getproc (), which, procenv, procenvCnt); +} + +kern_return_t +S_proc_make_login_coll (vpstruct_t process) +{ + debug ("task id: %d\n", process->task_id); + return proc_make_login_coll (process->proc); +} + +kern_return_t +S_proc_getloginid (vpstruct_t process, pid_t pid, pid_t *login_id) +{ + debug ("pid id: %d\n", pid); + return proc_getloginid (getproc (), pid, login_id); +} + +kern_return_t +S_proc_getloginpids (vpstruct_t process, pid_t id, + pidarray_t *pids, mach_msg_type_number_t *pidsCnt) +{ + debug ("pid id: %d\n", id); + return proc_getloginpids (getproc (), id, pids, pidsCnt); +} + +kern_return_t +S_proc_setlogin (vpstruct_t process, string_t logname) +{ + debug ("task id: %d\n", process->task_id); + return proc_setlogin (process->proc, logname); +} + +kern_return_t +S_proc_getlogin (vpstruct_t process, string_t logname) +{ + debug ("task id: %d\n", process->task_id); + return proc_getlogin (process->proc, logname); +} + +kern_return_t +S_proc_setsid (vpstruct_t process) +{ + debug ("task id: %d\n", process->task_id); + return proc_setsid (process->proc); +} + +kern_return_t +S_proc_getsid (vpstruct_t process, pid_t pid, pid_t *sid) +{ + debug ("pid id: %d\n", pid); + return proc_getsid (getproc (), pid, sid); +} + +kern_return_t +S_proc_getsessionpgids (vpstruct_t process, pid_t sid, + pidarray_t *pgidset, mach_msg_type_number_t *pgidsetCnt) +{ + debug ("pid id: %d\n", sid); + return proc_getsessionpgids (getproc (), sid, pgidset, pgidsetCnt); +} + +kern_return_t +S_proc_getsessionpids (vpstruct_t process, pid_t sid, + pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt) +{ + debug ("pid id: %d\n", sid); + return proc_getsessionpids (getproc (), sid, pidset, pidsetCnt); +} + +kern_return_t +S_proc_getsidport (vpstruct_t process, mach_port_t *sessport, + mach_msg_type_name_t *sessportPoly) +{ + kern_return_t ret; + debug ("task id: %d\n", process->task_id); + ret = proc_getsidport (process->proc, sessport); + if (ret == 0) + *sessportPoly = MACH_MSG_TYPE_MOVE_SEND; + return ret; +} + +kern_return_t +S_proc_setpgrp (vpstruct_t process, pid_t pid, pid_t pgrp) +{ + debug ("pid id: %d\n", pid); + return proc_setpgrp (getproc (), pid, pgrp); +} + +kern_return_t +S_proc_getpgrp (vpstruct_t process, pid_t pid, pid_t *pgrp) +{ + kern_return_t ret; + debug ("pid id: %d\n", pid); + ret = proc_getpgrp(getproc(), pid, pgrp); + if (ret) + error (0, ret, "proc_proxy: proc_getpgrp"); + return ret; +} + +kern_return_t +S_proc_getpgrppids (vpstruct_t process, pid_t pgrp, + pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt) +{ + debug ("pgrp id: %d\n", pgrp); + return proc_getpgrppids (getproc (), pgrp, pidset, pidsetCnt); +} + +kern_return_t +S_proc_get_tty (vpstruct_t calling_process, pid_t target_process, + mach_port_t *tty, mach_msg_type_name_t *ttyPoly) +{ + kern_return_t ret; + debug (""); + ret = proc_get_tty (getproc (), target_process, tty); + if (ret == 0) + *ttyPoly = MACH_MSG_TYPE_MOVE_SEND; + return ret; +} |