Changeset 58

User picture

Author: zhengda

(2008/08/16 14:58) Almost 4 years ago

Use the GNU coding style.

Affected files

Updated proc_proxy/proc_proxy.c Download diff

5758
47
  return p;
47
  return p;
48
}
48
}
49
49



50
void task_clean_routine (void *port)
50
void



51
task_clean_routine (void *port)



51
{
52
{



52
  vpstruct_t proc = port;
53
  vpstruct_t proc = port;



53
  hurd_ihash_locp_remove (&proc_ht, proc->p_task_hashloc);
54
  hurd_ihash_locp_remove (&proc_ht, proc->p_task_hashloc);


...
...
55
  mach_port_deallocate (mach_task_self (), proc->task_id);
56
  mach_port_deallocate (mach_task_self (), proc->task_id);



56
}
57
}



57
58



58
vpstruct_t create_task (task_t task)
59
vpstruct_t



60
create_task (task_t task)



59
{
61
{



60
  vpstruct_t proc;
62
  vpstruct_t proc;



61
  error_t err = ports_create_port (proc_class, proc_bucket,
63
  error_t err = ports_create_port (proc_class, proc_bucket,


...
...
69
  return proc;
71
  return proc;



70
}
72
}



71
73



72
vpstruct_t find_task (task_t task)
74
vpstruct_t



75
find_task (task_t task)



73
{
76
{



74
  return hurd_ihash_find (&proc_ht, task) ? : create_task (task);
77
  return hurd_ihash_find (&proc_ht, task) ? : create_task (task);



75
}
78
}



76
79



77
int request_server (mach_msg_header_t *inp, mach_msg_header_t *outp)
80
int



81
request_server (mach_msg_header_t *inp, mach_msg_header_t *outp)



78
{
82
{



79
  extern boolean_t process_server (mach_msg_header_t *, mach_msg_header_t *);
83
  extern boolean_t process_server (mach_msg_header_t *, mach_msg_header_t *);



80
  return process_server (inp, outp);
84
  return process_server (inp, outp);



81
}
85
}



82
86



83
void print_cmd(int argc , char *argv[])
87
void



88
print_cmd (int argc, char *argv[])



84
{
89
{



85
  int i;
90
  int i;



86
  for(i=0 ; i < argc ; i++){
91
  for (i = 0; i < argc; i++)



87
      debug("%s " , argv[i]);
92
    {



88
  }
93
      debug ("%s ", argv[i]);



89
  debug("\n");
94
    }



95
  debug ("\n");



90
}
96
}



91
97



92
int main (int argc, char *argv[])
98
int



99
main (int argc, char *argv[])



93
{
100
{



94
  error_t err;
101
  error_t err;



95
  vpstruct_t child_proc;
102
  vpstruct_t child_proc;


...
...
100
  pid_t child_pid;
107
  pid_t child_pid;



101
  task_t child_task;
108
  task_t child_task;



102
109



103
  if(argc <= 1){
110
  if (argc <= 1)



104
      fprintf(stderr , "%s command\n" , argv[0]);
111
    error (1, 0, "%s command\n" , argv[0]);



105
      exit(1);



106
  }



107
  if(pipe(pipe_fd1s) < 0){



108
      perror("pipe");



109
      exit(2);



110
  }



111
  if(pipe(pipe_fd2s) < 0){



112
      perror("pipe");



113
      exit(2);



114
  }



115
112



116
  err=mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_DEAD_NAME,
113
  if (pipe (pipe_fd1s) < 0)



117
			  &proc_port);
114
    error (2, errno, "pipe");



118
  if(err != KERN_SUCCESS)
115
  if (pipe (pipe_fd2s) < 0)



119
    error (2 , err , "mach_port_allocate");
116
    error (2, errno, "pipe");



120
117



121
  child_pid=fork();
118
  err = mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_DEAD_NAME,



122
  if(child_pid < 0)
119
			    &proc_port);



123
    error(2 , errno , "fork");
120
  if (err != KERN_SUCCESS)



124
  else if(child_pid == 0){
121
    error (2, err, "mach_port_allocate");



122



123
  child_pid = fork ();



124
  if (child_pid < 0)



125
    error (2, errno, "fork");



126
  else if (child_pid == 0)



127
    {



125
      /* generate a new process group for child process,
128
      /* generate a new process group for child process,



126
       * it's needed to set the child process group to foreground */
129
       * it's needed to set the child process group to foreground */



127
      setpgid(getpid() , getpid());
130
      setpgid (getpid (), getpid ());



128
131



129
      close(pipe_fd1s[1]);
132
      close (pipe_fd1s[1]);



130
      close(pipe_fd2s[0]);
133
      close (pipe_fd2s[0]);



131
134



132
      debug("child process starts\n");
135
      debug ("child process starts\n");



133
      read(pipe_fd1s[0] , &proc_port , sizeof(proc_port));
136
      read (pipe_fd1s[0], &proc_port, sizeof (proc_port));



134
      print_cmd(argc-1 , &argv[1]);
137
      print_cmd (argc-1, &argv[1]);



135
      write(pipe_fd2s[1] , &proc_port, sizeof(proc_port));
138
      write (pipe_fd2s[1], &proc_port, sizeof (proc_port));



136
139



137
      setproc(proc_port);
140
      setproc (proc_port);



138
      debug("child: current proc is %d\n" , getproc());
141
      debug ("child: current proc is %d\n", getproc ());



139
      if(execvp(argv[1] , &argv[1]) < 0)
142
      if (execvp (argv[1], &argv[1]) < 0)



140
	error(2 , errno , "execvp");
143
	error (2, errno, "execvp");



141
  }
144
    }



142
145



143
  debug("create a child process %d\n" , child_pid);
146
  debug ("create a child process %d\n", child_pid);



144
147



145
  /* Set the child process group as the foreground group. */
148
  /* Set the child process group as the foreground group. */



146
  tcsetpgrp(fileno(stdout) , child_pid);
149
  tcsetpgrp (fileno (stdout), child_pid);



147
150



148
  close(pipe_fd1s[0]);
151
  close (pipe_fd1s[0]);



149
  close(pipe_fd2s[1]);
152
  close (pipe_fd2s[1]);



150
153



151
  proc_bucket = ports_create_bucket ();
154
  proc_bucket = ports_create_bucket ();



152
  proc_class = ports_create_class (task_clean_routine, 0);
155
  proc_class = ports_create_class (task_clean_routine, 0);



153
156



154
  /* Make the send right to the proc porxy in the child process. */
157
  /* Make the send right to the proc porxy in the child process. */



155
  child_task=pid2task(child_pid);
158
  child_task = pid2task (child_pid);



156
  err=mach_port_destroy(child_task , proc_port);
159
  err = mach_port_destroy (child_task, proc_port);



157
  if(err != KERN_SUCCESS)
160
  if (err != KERN_SUCCESS)



158
    error (2 , err , "mach_port_destroy");
161
    error (2, err, "mach_port_destroy");



159
  child_proc = create_task (child_task);
162
  child_proc = create_task (child_task);



160
  receive_port = ports_get_right (child_proc);
163
  receive_port = ports_get_right (child_proc);



161
  err=mach_port_insert_right(child_task , proc_port , receive_port ,
164
  err = mach_port_insert_right (child_task, proc_port, receive_port,



162
			     MACH_MSG_TYPE_MAKE_SEND);
165
				MACH_MSG_TYPE_MAKE_SEND);



163
  if(err != KERN_SUCCESS)
166
  if (err != KERN_SUCCESS)



164
    error (2 , err , "mach_port_insert_right");
167
    error (2, err, "mach_port_insert_right");



165
168



166
  /* Tell the child the send right. */
169
  /* Tell the child the send right. */



167
  write(pipe_fd1s[1] , &proc_port , sizeof(proc_port));
170
  write (pipe_fd1s[1], &proc_port, sizeof(proc_port));



168
  /* Synchronize. The child process should run first. */
171
  /* Synchronize. The child process should run first. */



169
  read(pipe_fd2s[0] , &proc_port, sizeof(proc_port));
172
  read (pipe_fd2s[0], &proc_port, sizeof(proc_port));



170
173



171
  proc_task2proc (getproc(), child_task, &child_proc->proc);
174
  proc_task2proc (getproc(), child_task, &child_proc->proc);



172
175



173
  while(1)
176
  while (1)



174
    {
177
    {



175
      int status;
178
      int status;



176
      int ret;
179
      int ret;


...
...
179
					       request_server, 500);
182
					       request_server, 500);



180
      ret = waitpid (child_pid, &status, WNOHANG);
183
      ret = waitpid (child_pid, &status, WNOHANG);



181
      if (ret < 0)
184
      if (ret < 0)



182
	  error (1, errno, "waitpid");
185
	error (1, errno, "waitpid");



183
186



184
      /* if the child process exits */
187
      /* if the child process exits */



185
      if (ret == 1 && WIFEXITED (status))
188
      if (ret == 1 && WIFEXITED (status))



186
	break;
189
	break;



187
190



188
    }
191
    }



189
  debug("proc proxy exits\n");
192
  debug ("proc proxy exits\n");



190
193



191
  return 0;
194
  return 0;



192
}
195
}





          

  Updated
proc_proxy/proc_proxy.h  Download diff




      
      
5758
64
64



65
vpstruct_t reqport_find (mach_port_t port);
65
vpstruct_t reqport_find (mach_port_t port);



66
vpstruct_t find_task (task_t task);
66
vpstruct_t find_task (task_t task);



67
mach_port_t my_get_reply_port(void);
67
mach_port_t my_get_reply_port (void);



68
68



69
#endif
69
#endif





          

  Updated
proc_proxy/process_ops.c  Download diff




      
      
5758
21
21



22
#include "process_S.h"
22
#include "process_S.h"



23
23



24
kern_return_t p_proc_getprivports(vpstruct_t process, mach_port_t *host_priv,
24
kern_return_t 



25
				  mach_port_t *device_master)
25
p_proc_getprivports (vpstruct_t process, mach_port_t *host_priv,



26
		     mach_port_t *device_master)



26
{
27
{



27
  kern_return_t ret;
28
  kern_return_t ret;



28
  debug ("task id: %d\n", process->task_id);
29
  debug ("task id: %d\n", process->task_id);


...
...
37
  return ret;
38
  return ret;



38
}
39
}



39
40



40
kern_return_t p_proc_getallpids (vpstruct_t process, pidarray_t *pidarray,
41
kern_return_t 



41
				 mach_msg_type_number_t *pidarrayCnt)
42
p_proc_getallpids (vpstruct_t process, pidarray_t *pidarray,



43
		   mach_msg_type_number_t *pidarrayCnt)



42
{
44
{



43
  debug ("task id: %d\n", process->task_id);
45
  debug ("task id: %d\n", process->task_id);



44
  return proc_getallpids(getproc(), pidarray, pidarrayCnt);
46
  return proc_getallpids (getproc (), pidarray, pidarrayCnt);



45
}
47
}



46
48



47
kern_return_t p_proc_setexecdata (vpstruct_t process, portarray_t ports,
49
kern_return_t 



48
				  mach_msg_type_number_t portsCnt, intarray_t ints,
50
p_proc_setexecdata (vpstruct_t process, portarray_t ports,



49
				  mach_msg_type_number_t intsCnt)
51
		    mach_msg_type_number_t portsCnt, intarray_t ints,



52
		    mach_msg_type_number_t intsCnt)



50
{
53
{



51
  debug ("task id: %d\n", process->task_id);
54
  debug ("task id: %d\n", process->task_id);



52
  return proc_setexecdata(process->proc, ports , MACH_MSG_TYPE_COPY_SEND ,
55
  return proc_setexecdata (process->proc, ports, MACH_MSG_TYPE_COPY_SEND,



53
			  portsCnt, ints, intsCnt);
56
			   portsCnt, ints, intsCnt);



54
}
57
}



55
58



56
kern_return_t p_proc_getexecdata (vpstruct_t process, portarray_t *ports,
59
kern_return_t 



57
				  mach_msg_type_name_t *portsPoly, mach_msg_type_number_t *portsCnt,
60
p_proc_getexecdata (vpstruct_t process, portarray_t *ports,



58
				  intarray_t *ints, mach_msg_type_number_t *intsCnt)
61
		    mach_msg_type_name_t *portsPoly,



62
		    mach_msg_type_number_t *portsCnt,



63
		    intarray_t *ints, mach_msg_type_number_t *intsCnt)



59
{
64
{



60
  kern_return_t ret;
65
  kern_return_t ret;



61
  debug ("task id: %d\n", process->task_id);
66
  debug ("task id: %d\n", process->task_id);



62
  ret=proc_getexecdata(process->proc, ports, portsCnt, ints, intsCnt);
67
  ret = proc_getexecdata (process->proc, ports, portsCnt, ints, intsCnt);



63
  if(ret == 0)
68
  if (ret == 0)



64
    *portsPoly=MACH_MSG_TYPE_MOVE_SEND;
69
    *portsPoly = MACH_MSG_TYPE_MOVE_SEND;



65
  return ret;
70
  return ret;



66
}
71
}



67
72



68
kern_return_t p_proc_execdata_notify (vpstruct_t process, mach_port_t notify)
73
kern_return_t



74
p_proc_execdata_notify (vpstruct_t process, mach_port_t notify)



69
{
75
{



70
  debug ("task id: %d\n", process->task_id);
76
  debug ("task id: %d\n", process->task_id);



71
  return proc_execdata_notify(process->proc, notify , MACH_MSG_TYPE_MOVE_SEND);
77
  return proc_execdata_notify (process->proc, notify, MACH_MSG_TYPE_MOVE_SEND);



72
}
78
}



73
79



74
kern_return_t p_proc_uname (vpstruct_t process, utsname_t *uname)
80
kern_return_t 



81
p_proc_uname (vpstruct_t process, utsname_t *uname)



75
{
82
{



76
  debug ("task id: %d\n", process->task_id);
83
  debug ("task id: %d\n", process->task_id);



77
  return proc_uname(process->proc, uname);
84
  return proc_uname (process->proc, uname);



78
}
85
}



79
86



80
kern_return_t p_proc_register_version (vpstruct_t process, mach_port_t credential,
87
kern_return_t 



81
				       string_t name, string_t release, string_t version)
88
p_proc_register_version (vpstruct_t process, mach_port_t credential,



89
			 string_t name, string_t release, string_t version)



82
{
90
{



83
  debug ("task id: %d\n", process->task_id);
91
  debug ("task id: %d\n", process->task_id);



84
  return proc_register_version(process->proc, credential, name, release, version);
92
  return proc_register_version (process->proc, credential,



93
				name, release, version);



85
}
94
}



86
95



87
kern_return_t p_proc_reauthenticate (vpstruct_t process, mach_port_t rendezvous2)
96
kern_return_t 



97
p_proc_reauthenticate (vpstruct_t process, mach_port_t rendezvous2)



88
{
98
{



89
  debug ("task id: %d\n", process->task_id);
99
  debug ("task id: %d\n", process->task_id);



90
  return proc_reauthenticate(process->proc, rendezvous2 , MACH_MSG_TYPE_MOVE_SEND);
100
  return proc_reauthenticate (process->proc, rendezvous2,



101
			      MACH_MSG_TYPE_MOVE_SEND);



91
}
102
}



92
103



93
kern_return_t p_proc_child (vpstruct_t process, mach_port_t child)
104
kern_return_t



105
p_proc_child (vpstruct_t process, mach_port_t child)



94
{
106
{



95
  debug ("task id: %d, child task: %d\n", process->task_id, child);
107
  debug ("task id: %d, child task: %d\n", process->task_id, child);



96
  return proc_child(process->proc, child);
108
  return proc_child (process->proc, child);



97
}
109
}



98
110



99
kern_return_t p_proc_setmsgport (vpstruct_t process, mach_port_t reply_port,
111
kern_return_t



100
				 mach_msg_type_name_t reply_portPoly, mach_port_t newmsgport,
112
p_proc_setmsgport (vpstruct_t process, mach_port_t reply_port,



101
				 mach_port_t *oldmsgport, mach_msg_type_name_t *oldmsgportPoly)
113
		   mach_msg_type_name_t reply_portPoly, mach_port_t newmsgport,



114
		   mach_port_t *oldmsgport, mach_msg_type_name_t *oldmsgportPoly)



102
{
115
{



103
  kern_return_t ret=0;
116
  kern_return_t ret=0;



104
  debug ("task id: %d\n", process->task_id);
117
  debug ("task id: %d\n", process->task_id);



105
  ret=proc_setmsgport(process->proc, newmsgport, oldmsgport);
118
  ret = proc_setmsgport (process->proc, newmsgport, oldmsgport);



106
  if(ret == 0){
119
  if (ret == 0){



107
      *oldmsgportPoly=MACH_MSG_TYPE_MOVE_SEND;
120
      *oldmsgportPoly = MACH_MSG_TYPE_MOVE_SEND;



108
      debug("p_proc_setmsgport succeeds\n");
121
      debug ("p_proc_setmsgport succeeds\n");



109
  }
122
  }



110
  return ret;
123
  return ret;



111
}
124
}



112
125



113
kern_return_t p_proc_getmsgport (vpstruct_t process, mach_port_t reply_port,
126
kern_return_t 



114
				 mach_msg_type_name_t reply_portPoly, pid_t pid, mach_port_t *msgport)
127
p_proc_getmsgport (vpstruct_t process, mach_port_t reply_port,



128
		   mach_msg_type_name_t reply_portPoly, pid_t pid,



129
		   mach_port_t *msgport)



115
{
130
{



116
  debug ("task id: %d\n", process->task_id);
131
  debug ("task id: %d\n", process->task_id);



117
  return proc_getmsgport(getproc(), pid , msgport);
132
  return proc_getmsgport (getproc(), pid, msgport);



118
}
133
}



119
134



120
kern_return_t p_proc_reassign (vpstruct_t process, mach_port_t newtask)
135
kern_return_t 



136
p_proc_reassign (vpstruct_t process, mach_port_t newtask)



121
{
137
{



122
  debug ("task id: %d\n", process->task_id);
138
  debug ("task id: %d\n", process->task_id);



123
  return proc_reassign(process->proc , newtask);
139
  return proc_reassign (process->proc, newtask);



124
  return 0;



125
}
140
}



126
141



127
kern_return_t p_proc_setowner (vpstruct_t process, uid_t owner, int clear)
142
kern_return_t 



143
p_proc_setowner (vpstruct_t process, uid_t owner, int clear)



128
{
144
{



129
  debug ("task id: %d\n", process->task_id);
145
  debug ("task id: %d\n", process->task_id);



130
  return proc_setowner(process->proc, owner, clear);
146
  return proc_setowner (process->proc, owner, clear);



131
}
147
}



132
148



133
kern_return_t p_proc_getpids (vpstruct_t process, pid_t *pid,
149
kern_return_t



134
			      pid_t *ppid, int *orphaned)
150
p_proc_getpids (vpstruct_t process, pid_t *pid,



151
		pid_t *ppid, int *orphaned)



135
{
152
{



136
  debug ("task id: %d\n", process->task_id);
153
  debug ("task id: %d\n", process->task_id);



137
  return proc_getpids(process->proc , pid , ppid , orphaned);
154
  return proc_getpids (process->proc, pid, ppid, orphaned);



138
}
155
}



139
156



140
kern_return_t p_proc_set_arg_locations (vpstruct_t process, vm_address_t argv,
157
kern_return_t 



141
					vm_address_t envp)
158
p_proc_set_arg_locations (vpstruct_t process, vm_address_t argv,



159
			  vm_address_t envp)



142
{
160
{



143
  kern_return_t ret;
161
  kern_return_t ret;



144
  debug ("task id: %d\n", process->task_id);
162
  debug ("task id: %d\n", process->task_id);


...
...
148
  return ret;
166
  return ret;



149
}
167
}



150
168



151
kern_return_t p_proc_get_arg_locations (vpstruct_t process, vm_address_t *argv,
169
kern_return_t 



152
					vm_address_t *envp)
170
p_proc_get_arg_locations (vpstruct_t process, vm_address_t *argv,



171
			  vm_address_t *envp)



153
{
172
{



154
  debug ("task id: %d\n", process->task_id);
173
  debug ("task id: %d\n", process->task_id);



155
  return proc_get_arg_locations(process->proc , argv , envp);
174
  return proc_get_arg_locations (process->proc, argv, envp);



156
}
175
}



157
176



158
kern_return_t p_proc_wait (vpstruct_t process, mach_port_t reply_port,
177
kern_return_t 



159
			   mach_msg_type_name_t reply_portPoly, pid_t pid, int options,
178
p_proc_wait (vpstruct_t process, mach_port_t reply_port,



160
			   int *status, int *sigcode, rusage_t *rusage, pid_t *pid_status)
179
	     mach_msg_type_name_t reply_portPoly, pid_t pid, int options,



180
	     int *status, int *sigcode, rusage_t *rusage, pid_t *pid_status)



161
{
181
{



162
  debug ("task id: %d\n", process->task_id);
182
  debug ("task id: %d\n", process->task_id);



163
  return proc_wait(process->proc , pid , options , status , sigcode , 
183
  return proc_wait (process->proc, pid, options, status, sigcode, 



164
		   rusage , pid_status);
184
		    rusage, pid_status);



165
}
185
}



166
186



167
kern_return_t p_proc_dostop (vpstruct_t process, mach_port_t contthread)
187
kern_return_t 



188
p_proc_dostop (vpstruct_t process, mach_port_t contthread)



168
{
189
{



169
  kern_return_t ret;
190
  kern_return_t ret;



170
//  process_t actual_proc;
191
  //  process_t actual_proc;



171
//  ret = proc_task2proc (getproc (), process->task_id, &actual_proc);
192
  //  ret = proc_task2proc (getproc (), process->task_id, &actual_proc);



172
//  if (ret)
193
  //  if (ret)



173
//    error (3, ret, "proc_task2proc");
194
  //    error (3, ret, "proc_task2proc");



174
195



175
  debug ("task id: %d\n", process->task_id);
196
  debug ("task id: %d\n", process->task_id);



176
  ret = proc_dostop(process->proc /*actual_proc*/ , contthread);
197
  ret = proc_dostop(process->proc /*actual_proc*/, contthread);



177
  if (ret)
198
  if (ret)



178
    error (4, ret, "proc_dostop");
199
    error (4, ret, "proc_dostop");



179
  return ret;
200
  return ret;



180
}
201
}



181
202



182
kern_return_t p_proc_handle_exceptions (vpstruct_t process, mach_port_t msgport,
203
kern_return_t 



183
					mach_port_t forwardport, int flavor, thread_state_t new_state,
204
p_proc_handle_exceptions (vpstruct_t process, mach_port_t msgport,



184
					mach_msg_type_number_t new_stateCnt)
205
			  mach_port_t forwardport, int flavor,



206
			  thread_state_t new_state,



207
			  mach_msg_type_number_t new_stateCnt)



185
{
208
{



186
  debug ("task id: %d\n", process->task_id);
209
  debug ("task id: %d\n", process->task_id);



187
  return proc_handle_exceptions(process->proc , msgport , forwardport , 
210
  return proc_handle_exceptions (process->proc, msgport, forwardport, 



188
				MACH_MSG_TYPE_MOVE_SEND , flavor , new_state , new_stateCnt);
211
				 MACH_MSG_TYPE_MOVE_SEND, flavor,



212
				 new_state, new_stateCnt);



189
}
213
}



190
214



191
kern_return_t p_proc_mark_stop (vpstruct_t process, int signo, int sigcode)
215
kern_return_t 



216
p_proc_mark_stop (vpstruct_t process, int signo, int sigcode)



192
{
217
{



193
  debug ("task id: %d\n", process->task_id);
218
  debug ("task id: %d\n", process->task_id);



194
  return proc_mark_stop(process->proc , signo , sigcode);
219
  return proc_mark_stop (process->proc, signo, sigcode);



195
}
220
}



196
221



197
kern_return_t p_proc_mark_cont (vpstruct_t process)
222
kern_return_t 



223
p_proc_mark_cont (vpstruct_t process)



198
{
224
{



199
  debug ("task id: %d\n", process->task_id);
225
  debug ("task id: %d\n", process->task_id);



200
  return proc_mark_cont(process->proc);
226
  return proc_mark_cont (process->proc);



201
}
227
}



202
228



203
kern_return_t p_proc_mark_exit (vpstruct_t process, int status, int sigcode)
229
kern_return_t 



230
p_proc_mark_exit (vpstruct_t process, int status, int sigcode)



204
{
231
{



205
  debug ("task id: %d\n", process->task_id);
232
  debug ("task id: %d\n", process->task_id);



206
  return proc_mark_exit(process->proc , status , sigcode);
233
  return proc_mark_exit (process->proc, status, sigcode);



207
}
234
}



208
235



209
kern_return_t p_proc_mark_traced (vpstruct_t process)
236
kern_return_t 



237
p_proc_mark_traced (vpstruct_t process)



210
{
238
{



211
  debug ("task id: %d\n", process->task_id);
239
  debug ("task id: %d\n", process->task_id);



212
  return proc_mark_traced(process->proc);
240
  return proc_mark_traced (process->proc);



213
}
241
}



214
242



215
kern_return_t p_proc_mark_exec (vpstruct_t process)
243
kern_return_t 



244
p_proc_mark_exec (vpstruct_t process)



216
{
245
{



217
  debug ("task id: %d\n", process->task_id);
246
  debug ("task id: %d\n", process->task_id);



218
  return proc_mark_exec(process->proc);
247
  return proc_mark_exec (process->proc);



219
}
248
}



220
249



221
kern_return_t p_proc_mod_stopchild (vpstruct_t process, int doit)
250
kern_return_t 



251
p_proc_mod_stopchild (vpstruct_t process, int doit)



222
{
252
{



223
  debug ("task id: %d\n", process->task_id);
253
  debug ("task id: %d\n", process->task_id);



224
  return proc_mod_stopchild(process->proc , doit);
254
  return proc_mod_stopchild (process->proc , doit);



225
}
255
}



226
256



227
kern_return_t p_proc_pid2task (vpstruct_t process, pid_t pid, mach_port_t *task)
257
kern_return_t 



258
p_proc_pid2task (vpstruct_t process, pid_t pid, mach_port_t *task)



228
{
259
{



229
  kern_return_t ret;
260
  kern_return_t ret;



230
  ret = proc_pid2task(getproc() , pid , task);
261
  ret = proc_pid2task (getproc (), pid, task);



231
  debug("pid: %d, task: %d\n", pid, *task);
262
  debug ("pid: %d, task: %d\n", pid, *task);



232
  return ret;
263
  return ret;



233
}
264
}



234
265



235
kern_return_t p_proc_task2pid (vpstruct_t process, mach_port_t task, pid_t *pid)
266
kern_return_t



267
p_proc_task2pid (vpstruct_t process, mach_port_t task, pid_t *pid)



236
{
268
{



237
  debug ("task id: %d\n", task);
269
  debug ("task id: %d\n", task);



238
  return proc_task2pid(getproc() , task , pid);
270
  return proc_task2pid (getproc (), task, pid);



239
}
271
}



240
272



241
kern_return_t p_proc_task2proc (vpstruct_t callerp, mach_port_t task,
273
kern_return_t 



242
				mach_port_t *proc)
274
p_proc_task2proc (vpstruct_t callerp, mach_port_t task,



275
		  mach_port_t *proc)



243
{
276
{



244
  kern_return_t err;
277
  kern_return_t err;



245
  process_t actual_proc;
278
  process_t actual_proc;


...
...
249
  *proc = ports_get_right (process);
282
  *proc = ports_get_right (process);



250
283



251
  /* Get the actuall port to the proc server. */
284
  /* Get the actuall port to the proc server. */



252
  err = proc_task2proc (getproc(), task, &actual_proc);
285
  err = proc_task2proc (getproc (), task, &actual_proc);



253
  if (err)
286
  if (err)



254
    error (3, err, "proc_task2proc");
287
    error (3, err, "proc_task2proc");



255
  process->proc = actual_proc;
288
  process->proc = actual_proc;


...
...
259
  return 0;
292
  return 0;



260
}
293
}



261
294



262
kern_return_t p_proc_proc2task (vpstruct_t process, mach_port_t *task)
295
kern_return_t 



296
p_proc_proc2task (vpstruct_t process, mach_port_t *task)



263
{
297
{



264
  debug ("task id: %d\n", process->task_id);
298
  debug ("task id: %d\n", process->task_id);



265
  *task = process->task_id;
299
  *task = process->task_id;



266
  return 0;
300
  return 0;



267
}
301
}



268
302



269
kern_return_t p_proc_pid2proc (vpstruct_t process, pid_t pid, mach_port_t *proc)
303
kern_return_t 



304
p_proc_pid2proc (vpstruct_t process, pid_t pid, mach_port_t *proc)



270
{
305
{



271
  debug ("pid id: %d\n", pid);
306
  debug ("pid id: %d\n", pid);



272
  return proc_pid2proc(getproc() , pid , proc);
307
  return proc_pid2proc (getproc (), pid, proc);



273
}
308
}



274
309



275
kern_return_t p_proc_getprocinfo (vpstruct_t process, pid_t which,
310
kern_return_t 



276
				  int *flags, procinfo_t *procinfo, mach_msg_type_number_t *procinfoCnt,
311
p_proc_getprocinfo (vpstruct_t process, pid_t which, int *flags,



277
				  data_t *threadwaits, mach_msg_type_number_t *threadwaitsCnt)
312
		    procinfo_t *procinfo, mach_msg_type_number_t *procinfoCnt,



313
		    data_t *threadwaits, mach_msg_type_number_t *threadwaitsCnt)



278
{
314
{



279
  debug ("pid id: %d\n", which);
315
  debug ("pid id: %d\n", which);



280
  return proc_getprocinfo(getproc() , which , flags , procinfo,
316
  return proc_getprocinfo (getproc (), which, flags, procinfo,



281
			  procinfoCnt , threadwaits , threadwaitsCnt);
317
			   procinfoCnt, threadwaits, threadwaitsCnt);



282
}
318
}



283
319



284
kern_return_t p_proc_getprocargs (vpstruct_t process, pid_t which,
320
kern_return_t 



285
				  data_t *procargs, mach_msg_type_number_t *procargsCnt)
321
p_proc_getprocargs (vpstruct_t process, pid_t which,



322
		    data_t *procargs, mach_msg_type_number_t *procargsCnt)



286
{
323
{



287
  debug ("pid id: %d\n", which);
324
  debug ("pid id: %d\n", which);



288
  return proc_getprocargs(getproc() , which , procargs , procargsCnt);
325
  return proc_getprocargs (getproc (), which, procargs, procargsCnt);



289
}
326
}



290
327



291
kern_return_t p_proc_getprocenv (vpstruct_t process, pid_t which,
328
kern_return_t 



292
				 data_t *procenv, mach_msg_type_number_t *procenvCnt)
329
p_proc_getprocenv (vpstruct_t process, pid_t which,



330
		   data_t *procenv, mach_msg_type_number_t *procenvCnt)



293
{
331
{



294
  debug ("pid id: %d\n", which);
332
  debug ("pid id: %d\n", which);



295
  return proc_getprocenv(getproc() , which , procenv , procenvCnt);
333
  return proc_getprocenv (getproc (), which, procenv, procenvCnt);



296
}
334
}



297
335



298
kern_return_t p_proc_make_login_coll (vpstruct_t process)
336
kern_return_t 



337
p_proc_make_login_coll (vpstruct_t process)



299
{
338
{



300
  debug ("task id: %d\n", process->task_id);
339
  debug ("task id: %d\n", process->task_id);



301
  return proc_make_login_coll(process->proc);
340
  return proc_make_login_coll (process->proc);



302
}
341
}



303
342



304
kern_return_t p_proc_getloginid (vpstruct_t process, pid_t pid, pid_t *login_id)
343
kern_return_t 



344
p_proc_getloginid (vpstruct_t process, pid_t pid, pid_t *login_id)



305
{
345
{



306
  debug ("pid id: %d\n", pid);
346
  debug ("pid id: %d\n", pid);



307
  return proc_getloginid(getproc() , pid , login_id);
347
  return proc_getloginid (getproc (), pid, login_id);



308
}
348
}



309
349



310
kern_return_t p_proc_getloginpids (vpstruct_t process, pid_t id,
350
kern_return_t 



311
				   pidarray_t *pids, mach_msg_type_number_t *pidsCnt)
351
p_proc_getloginpids (vpstruct_t process, pid_t id,



352
		     pidarray_t *pids, mach_msg_type_number_t *pidsCnt)



312
{
353
{



313
  debug ("pid id: %d\n", id);
354
  debug ("pid id: %d\n", id);



314
  return proc_getloginpids(getproc() , id , pids , pidsCnt);
355
  return proc_getloginpids (getproc (), id, pids, pidsCnt);



315
}
356
}



316
357



317
kern_return_t p_proc_setlogin (vpstruct_t process, string_t logname)
358
kern_return_t 



359
p_proc_setlogin (vpstruct_t process, string_t logname)



318
{
360
{



319
  debug ("task id: %d\n", process->task_id);
361
  debug ("task id: %d\n", process->task_id);



320
  return proc_setlogin(process->proc , logname);
362
  return proc_setlogin (process->proc, logname);



321
}
363
}



322
364



323
kern_return_t p_proc_getlogin (vpstruct_t process, string_t logname)
365
kern_return_t 



366
p_proc_getlogin (vpstruct_t process, string_t logname)



324
{
367
{



325
  debug ("task id: %d\n", process->task_id);
368
  debug ("task id: %d\n", process->task_id);



326
  return proc_getlogin(process->proc, logname);
369
  return proc_getlogin (process->proc, logname);



327
}
370
}



328
371



329
kern_return_t p_proc_setsid (vpstruct_t process)
372
kern_return_t 



373
p_proc_setsid (vpstruct_t process)



330
{
374
{



331
  debug ("task id: %d\n", process->task_id);
375
  debug ("task id: %d\n", process->task_id);



332
  return proc_setsid(process->proc);
376
  return proc_setsid (process->proc);



333
}
377
}



334
378



335
kern_return_t p_proc_getsid (vpstruct_t process, pid_t pid, pid_t *sid)
379
kern_return_t



380
p_proc_getsid (vpstruct_t process, pid_t pid, pid_t *sid)



336
{
381
{



337
  debug ("pid id: %d\n", pid);
382
  debug ("pid id: %d\n", pid);



338
  return proc_getsid(getproc() , pid , sid);
383
  return proc_getsid (getproc (), pid, sid);



339
}
384
}



340
385



341
kern_return_t p_proc_getsessionpgids (vpstruct_t process, pid_t sid,
386
kern_return_t 



342
				      pidarray_t *pgidset, mach_msg_type_number_t *pgidsetCnt)
387
p_proc_getsessionpgids (vpstruct_t process, pid_t sid,



388
			pidarray_t *pgidset, mach_msg_type_number_t *pgidsetCnt)



343
{
389
{



344
  debug ("pid id: %d\n", sid);
390
  debug ("pid id: %d\n", sid);



345
  return proc_getsessionpgids(getproc() , sid , pgidset , pgidsetCnt);
391
  return proc_getsessionpgids (getproc (), sid, pgidset, pgidsetCnt);



346
}
392
}



347
393



348
kern_return_t p_proc_getsessionpids (vpstruct_t process, pid_t sid,
394
kern_return_t 



349
				     pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt)
395
p_proc_getsessionpids (vpstruct_t process, pid_t sid,



396
		       pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt)



350
{
397
{



351
  debug ("pid id: %d\n", sid);
398
  debug ("pid id: %d\n", sid);



352
  return proc_getsessionpids(getproc() , sid , pidset , pidsetCnt);
399
  return proc_getsessionpids (getproc (), sid, pidset, pidsetCnt);



353
}
400
}



354
401



355
kern_return_t p_proc_getsidport (vpstruct_t process, mach_port_t *sessport,
402
kern_return_t 



356
				 mach_msg_type_name_t *sessportPoly)
403
p_proc_getsidport (vpstruct_t process, mach_port_t *sessport,



404
		   mach_msg_type_name_t *sessportPoly)



357
{
405
{



358
  kern_return_t ret;
406
  kern_return_t ret;



359
  debug ("task id: %d\n", process->task_id);
407
  debug ("task id: %d\n", process->task_id);



360
  ret=proc_getsidport(process->proc, sessport);
408
  ret = proc_getsidport (process->proc, sessport);



361
  if(ret == 0)
409
  if (ret == 0)



362
    *sessportPoly = MACH_MSG_TYPE_MOVE_SEND;
410
    *sessportPoly = MACH_MSG_TYPE_MOVE_SEND;



363
  return ret;
411
  return ret;



364
}
412
}



365
413



366
kern_return_t p_proc_setpgrp (vpstruct_t process, pid_t pid, pid_t pgrp)
414
kern_return_t 



415
p_proc_setpgrp (vpstruct_t process, pid_t pid, pid_t pgrp)



367
{
416
{



368
  debug ("pid id: %d\n", pid);
417
  debug ("pid id: %d\n", pid);



369
  return proc_setpgrp(getproc() , pid , pgrp);
418
  return proc_setpgrp (getproc (), pid, pgrp);



370
}
419
}



371
420



372
kern_return_t p_proc_getpgrp (vpstruct_t process, pid_t pid, pid_t *pgrp)
421
kern_return_t 



422
p_proc_getpgrp (vpstruct_t process, pid_t pid, pid_t *pgrp)



373
{
423
{



374
  kern_return_t ret;
424
  kern_return_t ret;



375
  debug ("pid id: %d\n", pid);
425
  debug ("pid id: %d\n", pid);



376
  ret = proc_getpgrp(getproc() , pid , pgrp);
426
  ret = proc_getpgrp(getproc(), pid, pgrp);



377
  if (ret)
427
  if (ret)



378
    error (0, ret, "proc_proxy: proc_getpgrp");
428
    error (0, ret, "proc_proxy: proc_getpgrp");



379
  return ret;
429
  return ret;



380
}
430
}



381
431



382
kern_return_t p_proc_getpgrppids (vpstruct_t process, pid_t pgrp,
432
kern_return_t 



383
				  pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt)
433
p_proc_getpgrppids (vpstruct_t process, pid_t pgrp,



434
		    pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt)



384
{
435
{



385
  debug ("pgrp id: %d\n", pgrp);
436
  debug ("pgrp id: %d\n", pgrp);



386
  return proc_getpgrppids(getproc() , pgrp , pidset , pidsetCnt);
437
  return proc_getpgrppids (getproc (), pgrp, pidset, pidsetCnt);



387
}
438
}



388
439



389
kern_return_t p_proc_get_tty (vpstruct_t calling_process,
440
kern_return_t 



390
			      pid_t target_process, mach_port_t *tty, mach_msg_type_name_t *ttyPoly)
441
p_proc_get_tty (vpstruct_t calling_process, pid_t target_process,



442
		mach_port_t *tty, mach_msg_type_name_t *ttyPoly)



391
{
443
{



392
  kern_return_t ret;
444
  kern_return_t ret;



393
  debug ("");
445
  debug ("");



394
  ret=proc_get_tty(getproc() , target_process , tty);
446
  ret = proc_get_tty (getproc (), target_process, tty);



395
  if(ret == 0)
447
  if (ret == 0)



396
    *ttyPoly=MACH_MSG_TYPE_MOVE_SEND;
448
    *ttyPoly = MACH_MSG_TYPE_MOVE_SEND;



397
  return ret;
449
  return ret;



398
}
450
}