@@ -13,7 +13,7 @@ use libc;
13
13
use mem;
14
14
use ptr;
15
15
16
- use sys:: process:: magenta :: { Handle , mx_handle_t } ;
16
+ use sys:: process:: zircon :: { Handle , zx_handle_t } ;
17
17
use sys:: process:: process_common:: * ;
18
18
19
19
////////////////////////////////////////////////////////////////////////////////
@@ -51,10 +51,10 @@ impl Command {
51
51
}
52
52
53
53
unsafe fn do_exec ( & mut self , stdio : ChildPipes )
54
- -> io:: Result < mx_handle_t > {
55
- use sys:: process:: magenta :: * ;
54
+ -> io:: Result < zx_handle_t > {
55
+ use sys:: process:: zircon :: * ;
56
56
57
- let job_handle = mx_job_default ( ) ;
57
+ let job_handle = zx_job_default ( ) ;
58
58
let envp = match * self . get_envp ( ) {
59
59
Some ( ref envp) => envp. as_ptr ( ) ,
60
60
None => ptr:: null ( ) ,
@@ -67,39 +67,39 @@ impl Command {
67
67
}
68
68
69
69
// Duplicate the job handle
70
- let mut job_copy: mx_handle_t = MX_HANDLE_INVALID ;
71
- mx_cvt ( mx_handle_duplicate ( job_handle, MX_RIGHT_SAME_RIGHTS , & mut job_copy) ) ?;
70
+ let mut job_copy: zx_handle_t = zx_HANDLE_INVALID ;
71
+ zx_cvt ( zx_handle_duplicate ( job_handle, zx_RIGHT_SAME_RIGHTS , & mut job_copy) ) ?;
72
72
// Create a launchpad
73
73
let mut launchpad: * mut launchpad_t = ptr:: null_mut ( ) ;
74
- mx_cvt ( launchpad_create ( job_copy, self . get_argv ( ) [ 0 ] , & mut launchpad) ) ?;
74
+ zx_cvt ( launchpad_create ( job_copy, self . get_argv ( ) [ 0 ] , & mut launchpad) ) ?;
75
75
let launchpad_destructor = LaunchpadDestructor ( launchpad) ;
76
76
77
77
// Set the process argv
78
- mx_cvt ( launchpad_set_args ( launchpad, self . get_argv ( ) . len ( ) as i32 - 1 ,
78
+ zx_cvt ( launchpad_set_args ( launchpad, self . get_argv ( ) . len ( ) as i32 - 1 ,
79
79
self . get_argv ( ) . as_ptr ( ) ) ) ?;
80
80
// Setup the environment vars
81
- mx_cvt ( launchpad_set_environ ( launchpad, envp) ) ?;
82
- mx_cvt ( launchpad_add_vdso_vmo ( launchpad) ) ?;
81
+ zx_cvt ( launchpad_set_environ ( launchpad, envp) ) ?;
82
+ zx_cvt ( launchpad_add_vdso_vmo ( launchpad) ) ?;
83
83
// Load the executable
84
- mx_cvt ( launchpad_elf_load ( launchpad, launchpad_vmo_from_file ( self . get_argv ( ) [ 0 ] ) ) ) ?;
85
- mx_cvt ( launchpad_load_vdso ( launchpad, MX_HANDLE_INVALID ) ) ?;
86
- mx_cvt ( launchpad_clone ( launchpad, LP_CLONE_MXIO_ROOT | LP_CLONE_MXIO_CWD ) ) ?;
84
+ zx_cvt ( launchpad_elf_load ( launchpad, launchpad_vmo_from_file ( self . get_argv ( ) [ 0 ] ) ) ) ?;
85
+ zx_cvt ( launchpad_load_vdso ( launchpad, zx_HANDLE_INVALID ) ) ?;
86
+ zx_cvt ( launchpad_clone ( launchpad, LP_CLONE_FDIO_ROOT | LP_CLONE_FDIO_CWD ) ) ?;
87
87
88
88
// Clone stdin, stdout, and stderr
89
89
if let Some ( fd) = stdio. stdin . fd ( ) {
90
- mx_cvt ( launchpad_transfer_fd ( launchpad, fd, 0 ) ) ?;
90
+ zx_cvt ( launchpad_transfer_fd ( launchpad, fd, 0 ) ) ?;
91
91
} else {
92
- mx_cvt ( launchpad_clone_fd ( launchpad, 0 , 0 ) ) ?;
92
+ zx_cvt ( launchpad_clone_fd ( launchpad, 0 , 0 ) ) ?;
93
93
}
94
94
if let Some ( fd) = stdio. stdout . fd ( ) {
95
- mx_cvt ( launchpad_transfer_fd ( launchpad, fd, 1 ) ) ?;
95
+ zx_cvt ( launchpad_transfer_fd ( launchpad, fd, 1 ) ) ?;
96
96
} else {
97
- mx_cvt ( launchpad_clone_fd ( launchpad, 1 , 1 ) ) ?;
97
+ zx_cvt ( launchpad_clone_fd ( launchpad, 1 , 1 ) ) ?;
98
98
}
99
99
if let Some ( fd) = stdio. stderr . fd ( ) {
100
- mx_cvt ( launchpad_transfer_fd ( launchpad, fd, 2 ) ) ?;
100
+ zx_cvt ( launchpad_transfer_fd ( launchpad, fd, 2 ) ) ?;
101
101
} else {
102
- mx_cvt ( launchpad_clone_fd ( launchpad, 2 , 2 ) ) ?;
102
+ zx_cvt ( launchpad_clone_fd ( launchpad, 2 , 2 ) ) ?;
103
103
}
104
104
105
105
// We don't want FileDesc::drop to be called on any stdio. It would close their fds. The
@@ -113,9 +113,9 @@ impl Command {
113
113
// `launchpad_go` destroys the launchpad, so we must not
114
114
mem:: forget ( launchpad_destructor) ;
115
115
116
- let mut process_handle: mx_handle_t = 0 ;
116
+ let mut process_handle: zx_handle_t = 0 ;
117
117
let mut err_msg: * const libc:: c_char = ptr:: null ( ) ;
118
- mx_cvt ( launchpad_go ( launchpad, & mut process_handle, & mut err_msg) ) ?;
118
+ zx_cvt ( launchpad_go ( launchpad, & mut process_handle, & mut err_msg) ) ?;
119
119
// FIXME: See if we want to do something with that err_msg
120
120
121
121
Ok ( process_handle)
@@ -136,27 +136,27 @@ impl Process {
136
136
}
137
137
138
138
pub fn kill ( & mut self ) -> io:: Result < ( ) > {
139
- use sys:: process:: magenta :: * ;
139
+ use sys:: process:: zircon :: * ;
140
140
141
- unsafe { mx_cvt ( mx_task_kill ( self . handle . raw ( ) ) ) ?; }
141
+ unsafe { zx_cvt ( zx_task_kill ( self . handle . raw ( ) ) ) ?; }
142
142
143
143
Ok ( ( ) )
144
144
}
145
145
146
146
pub fn wait ( & mut self ) -> io:: Result < ExitStatus > {
147
147
use default:: Default ;
148
- use sys:: process:: magenta :: * ;
148
+ use sys:: process:: zircon :: * ;
149
149
150
- let mut proc_info: mx_info_process_t = Default :: default ( ) ;
151
- let mut actual: mx_size_t = 0 ;
152
- let mut avail: mx_size_t = 0 ;
150
+ let mut proc_info: zx_info_process_t = Default :: default ( ) ;
151
+ let mut actual: zx_size_t = 0 ;
152
+ let mut avail: zx_size_t = 0 ;
153
153
154
154
unsafe {
155
- mx_cvt ( mx_object_wait_one ( self . handle . raw ( ) , MX_TASK_TERMINATED ,
156
- MX_TIME_INFINITE , ptr:: null_mut ( ) ) ) ?;
157
- mx_cvt ( mx_object_get_info ( self . handle . raw ( ) , MX_INFO_PROCESS ,
155
+ zx_cvt ( zx_object_wait_one ( self . handle . raw ( ) , zx_TASK_TERMINATED ,
156
+ zx_TIME_INFINITE , ptr:: null_mut ( ) ) ) ?;
157
+ zx_cvt ( zx_object_get_info ( self . handle . raw ( ) , zx_INFO_PROCESS ,
158
158
& mut proc_info as * mut _ as * mut libc:: c_void ,
159
- mem:: size_of :: < mx_info_process_t > ( ) , & mut actual,
159
+ mem:: size_of :: < zx_info_process_t > ( ) , & mut actual,
160
160
& mut avail) ) ?;
161
161
}
162
162
if actual != 1 {
@@ -168,14 +168,14 @@ impl Process {
168
168
169
169
pub fn try_wait ( & mut self ) -> io:: Result < Option < ExitStatus > > {
170
170
use default:: Default ;
171
- use sys:: process:: magenta :: * ;
171
+ use sys:: process:: zircon :: * ;
172
172
173
- let mut proc_info: mx_info_process_t = Default :: default ( ) ;
174
- let mut actual: mx_size_t = 0 ;
175
- let mut avail: mx_size_t = 0 ;
173
+ let mut proc_info: zx_info_process_t = Default :: default ( ) ;
174
+ let mut actual: zx_size_t = 0 ;
175
+ let mut avail: zx_size_t = 0 ;
176
176
177
177
unsafe {
178
- let status = mx_object_wait_one ( self . handle . raw ( ) , MX_TASK_TERMINATED ,
178
+ let status = zx_object_wait_one ( self . handle . raw ( ) , zx_TASK_TERMINATED ,
179
179
0 , ptr:: null_mut ( ) ) ;
180
180
match status {
181
181
0 => { } , // Success
@@ -184,9 +184,9 @@ impl Process {
184
184
} ,
185
185
_ => { panic ! ( "Failed to wait on process handle: {}" , status) ; } ,
186
186
}
187
- mx_cvt ( mx_object_get_info ( self . handle . raw ( ) , MX_INFO_PROCESS ,
187
+ zx_cvt ( zx_object_get_info ( self . handle . raw ( ) , zx_INFO_PROCESS ,
188
188
& mut proc_info as * mut _ as * mut libc:: c_void ,
189
- mem:: size_of :: < mx_info_process_t > ( ) , & mut actual,
189
+ mem:: size_of :: < zx_info_process_t > ( ) , & mut actual,
190
190
& mut avail) ) ?;
191
191
}
192
192
if actual != 1 {
0 commit comments