]>
Commit | Line | Data |
---|---|---|
476ff2be SL |
1 | // Copyright 2016 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | #![allow(non_camel_case_types)] | |
12 | ||
13 | use convert::TryInto; | |
14 | use io; | |
15 | use os::raw::c_char; | |
16 | use u64; | |
17 | ||
18 | use libc::{c_int, c_void}; | |
19 | ||
20 | pub type mx_handle_t = i32; | |
21 | pub type mx_vaddr_t = usize; | |
22 | pub type mx_rights_t = u32; | |
23 | pub type mx_status_t = i32; | |
24 | ||
25 | pub type mx_size_t = usize; | |
476ff2be SL |
26 | |
27 | pub const MX_HANDLE_INVALID: mx_handle_t = 0; | |
28 | ||
29 | pub type mx_time_t = u64; | |
30 | pub const MX_TIME_INFINITE : mx_time_t = u64::MAX; | |
31 | ||
32 | pub type mx_signals_t = u32; | |
33 | ||
34 | pub const MX_OBJECT_SIGNAL_3 : mx_signals_t = 1 << 3; | |
35 | ||
36 | pub const MX_TASK_TERMINATED : mx_signals_t = MX_OBJECT_SIGNAL_3; | |
37 | ||
38 | pub const MX_RIGHT_SAME_RIGHTS : mx_rights_t = 1 << 31; | |
39 | ||
40 | pub type mx_object_info_topic_t = u32; | |
41 | ||
42 | pub const MX_INFO_PROCESS : mx_object_info_topic_t = 3; | |
43 | ||
476ff2be SL |
44 | pub fn mx_cvt<T>(t: T) -> io::Result<T> where T: TryInto<mx_status_t>+Copy { |
45 | if let Ok(status) = TryInto::try_into(t) { | |
46 | if status < 0 { | |
47 | Err(io::Error::from_raw_os_error(status)) | |
48 | } else { | |
49 | Ok(t) | |
50 | } | |
51 | } else { | |
52 | Err(io::Error::last_os_error()) | |
53 | } | |
54 | } | |
55 | ||
56 | // Safe wrapper around mx_handle_t | |
57 | pub struct Handle { | |
58 | raw: mx_handle_t, | |
59 | } | |
60 | ||
61 | impl Handle { | |
62 | pub fn new(raw: mx_handle_t) -> Handle { | |
63 | Handle { | |
3b2f2976 | 64 | raw, |
476ff2be SL |
65 | } |
66 | } | |
67 | ||
68 | pub fn raw(&self) -> mx_handle_t { | |
69 | self.raw | |
70 | } | |
71 | } | |
72 | ||
73 | impl Drop for Handle { | |
74 | fn drop(&mut self) { | |
75 | unsafe { mx_cvt(mx_handle_close(self.raw)).expect("Failed to close mx_handle_t"); } | |
76 | } | |
77 | } | |
78 | ||
79 | // Common MX_INFO header | |
80 | #[derive(Default)] | |
81 | #[repr(C)] | |
82 | pub struct mx_info_header_t { | |
83 | pub topic: u32, // identifies the info struct | |
84 | pub avail_topic_size: u16, // “native” size of the struct | |
85 | pub topic_size: u16, // size of the returned struct (<=topic_size) | |
86 | pub avail_count: u32, // number of records the kernel has | |
87 | pub count: u32, // number of records returned (limited by buffer size) | |
88 | } | |
89 | ||
90 | #[derive(Default)] | |
91 | #[repr(C)] | |
92 | pub struct mx_record_process_t { | |
93 | pub return_code: c_int, | |
94 | } | |
95 | ||
96 | // Returned for topic MX_INFO_PROCESS | |
97 | #[derive(Default)] | |
98 | #[repr(C)] | |
99 | pub struct mx_info_process_t { | |
100 | pub hdr: mx_info_header_t, | |
101 | pub rec: mx_record_process_t, | |
102 | } | |
103 | ||
104 | extern { | |
7cac9316 | 105 | pub fn mx_job_default() -> mx_handle_t; |
32a655c1 | 106 | |
476ff2be SL |
107 | pub fn mx_task_kill(handle: mx_handle_t) -> mx_status_t; |
108 | ||
109 | pub fn mx_handle_close(handle: mx_handle_t) -> mx_status_t; | |
110 | ||
111 | pub fn mx_handle_duplicate(handle: mx_handle_t, rights: mx_rights_t, | |
112 | out: *const mx_handle_t) -> mx_handle_t; | |
113 | ||
8bb4bdeb | 114 | pub fn mx_object_wait_one(handle: mx_handle_t, signals: mx_signals_t, timeout: mx_time_t, |
476ff2be SL |
115 | pending: *mut mx_signals_t) -> mx_status_t; |
116 | ||
117 | pub fn mx_object_get_info(handle: mx_handle_t, topic: u32, buffer: *mut c_void, | |
118 | buffer_size: mx_size_t, actual_size: *mut mx_size_t, | |
119 | avail: *mut mx_size_t) -> mx_status_t; | |
120 | } | |
121 | ||
476ff2be | 122 | // From `enum special_handles` in system/ulib/launchpad/launchpad.c |
32a655c1 | 123 | // HND_LOADER_SVC = 0 |
476ff2be | 124 | // HND_EXEC_VMO = 1 |
32a655c1 | 125 | pub const HND_SPECIAL_COUNT: usize = 2; |
476ff2be SL |
126 | |
127 | #[repr(C)] | |
128 | pub struct launchpad_t { | |
129 | argc: u32, | |
130 | envc: u32, | |
131 | args: *const c_char, | |
132 | args_len: usize, | |
133 | env: *const c_char, | |
134 | env_len: usize, | |
135 | ||
136 | handles: *mut mx_handle_t, | |
137 | handles_info: *mut u32, | |
138 | handle_count: usize, | |
139 | handle_alloc: usize, | |
140 | ||
141 | entry: mx_vaddr_t, | |
142 | base: mx_vaddr_t, | |
143 | vdso_base: mx_vaddr_t, | |
144 | ||
145 | stack_size: usize, | |
146 | ||
147 | special_handles: [mx_handle_t; HND_SPECIAL_COUNT], | |
148 | loader_message: bool, | |
149 | } | |
150 | ||
151 | extern { | |
152 | pub fn launchpad_create(job: mx_handle_t, name: *const c_char, | |
153 | lp: *mut *mut launchpad_t) -> mx_status_t; | |
154 | ||
8bb4bdeb XL |
155 | pub fn launchpad_go(lp: *mut launchpad_t, |
156 | proc_handle: *mut mx_handle_t, | |
157 | err_msg: *mut *const c_char) -> mx_status_t; | |
476ff2be SL |
158 | |
159 | pub fn launchpad_destroy(lp: *mut launchpad_t); | |
160 | ||
8bb4bdeb | 161 | pub fn launchpad_set_args(lp: *mut launchpad_t, argc: c_int, |
476ff2be SL |
162 | argv: *const *const c_char) -> mx_status_t; |
163 | ||
8bb4bdeb | 164 | pub fn launchpad_set_environ(lp: *mut launchpad_t, envp: *const *const c_char) -> mx_status_t; |
476ff2be | 165 | |
8bb4bdeb | 166 | pub fn launchpad_clone(lp: *mut launchpad_t, what: u32) -> mx_status_t; |
476ff2be SL |
167 | |
168 | pub fn launchpad_clone_fd(lp: *mut launchpad_t, fd: c_int, target_fd: c_int) -> mx_status_t; | |
169 | ||
170 | pub fn launchpad_transfer_fd(lp: *mut launchpad_t, fd: c_int, target_fd: c_int) -> mx_status_t; | |
171 | ||
172 | pub fn launchpad_elf_load(lp: *mut launchpad_t, vmo: mx_handle_t) -> mx_status_t; | |
173 | ||
174 | pub fn launchpad_add_vdso_vmo(lp: *mut launchpad_t) -> mx_status_t; | |
175 | ||
176 | pub fn launchpad_load_vdso(lp: *mut launchpad_t, vmo: mx_handle_t) -> mx_status_t; | |
177 | ||
178 | pub fn launchpad_vmo_from_file(filename: *const c_char) -> mx_handle_t; | |
179 | } | |
32a655c1 | 180 | |
8bb4bdeb XL |
181 | // Launchpad clone constants |
182 | ||
183 | pub const LP_CLONE_MXIO_ROOT: u32 = 0x0001; | |
184 | pub const LP_CLONE_MXIO_CWD: u32 = 0x0002; | |
185 | // LP_CLONE_MXIO_STDIO = 0x0004 | |
186 | // LP_CLONE_MXIO_ALL = 0x00FF | |
187 | // LP_CLONE_ENVIRON = 0x0100 | |
188 | // LP_CLONE_DEFAULT_JOB = 0x0200 | |
189 | // LP_CLONE_ALL = 0xFFFF | |
190 | ||
32a655c1 SL |
191 | // Errors |
192 | ||
193 | #[allow(unused)] pub const ERR_INTERNAL: mx_status_t = -1; | |
194 | ||
195 | // ERR_NOT_SUPPORTED: The operation is not implemented, supported, | |
196 | // or enabled. | |
197 | #[allow(unused)] pub const ERR_NOT_SUPPORTED: mx_status_t = -2; | |
198 | ||
199 | // ERR_NO_RESOURCES: The system was not able to allocate some resource | |
200 | // needed for the operation. | |
cc61c64b | 201 | #[allow(unused)] pub const ERR_NO_RESOURCES: mx_status_t = -3; |
32a655c1 SL |
202 | |
203 | // ERR_NO_MEMORY: The system was not able to allocate memory needed | |
204 | // for the operation. | |
205 | #[allow(unused)] pub const ERR_NO_MEMORY: mx_status_t = -4; | |
206 | ||
207 | // ERR_CALL_FAILED: The second phase of mx_channel_call(; did not complete | |
208 | // successfully. | |
cc61c64b XL |
209 | #[allow(unused)] pub const ERR_CALL_FAILED: mx_status_t = -5; |
210 | ||
211 | // ERR_INTERRUPTED_RETRY: The system call was interrupted, but should be | |
212 | // retried. This should not be seen outside of the VDSO. | |
213 | #[allow(unused)] pub const ERR_INTERRUPTED_RETRY: mx_status_t = -6; | |
32a655c1 SL |
214 | |
215 | // ======= Parameter errors ======= | |
216 | // ERR_INVALID_ARGS: an argument is invalid, ex. null pointer | |
217 | #[allow(unused)] pub const ERR_INVALID_ARGS: mx_status_t = -10; | |
218 | ||
cc61c64b XL |
219 | // ERR_BAD_HANDLE: A specified handle value does not refer to a handle. |
220 | #[allow(unused)] pub const ERR_BAD_HANDLE: mx_status_t = -11; | |
221 | ||
32a655c1 SL |
222 | // ERR_WRONG_TYPE: The subject of the operation is the wrong type to |
223 | // perform the operation. | |
224 | // Example: Attempting a message_read on a thread handle. | |
cc61c64b | 225 | #[allow(unused)] pub const ERR_WRONG_TYPE: mx_status_t = -12; |
32a655c1 SL |
226 | |
227 | // ERR_BAD_SYSCALL: The specified syscall number is invalid. | |
cc61c64b | 228 | #[allow(unused)] pub const ERR_BAD_SYSCALL: mx_status_t = -13; |
32a655c1 SL |
229 | |
230 | // ERR_OUT_OF_RANGE: An argument is outside the valid range for this | |
231 | // operation. | |
cc61c64b | 232 | #[allow(unused)] pub const ERR_OUT_OF_RANGE: mx_status_t = -14; |
32a655c1 SL |
233 | |
234 | // ERR_BUFFER_TOO_SMALL: A caller provided buffer is too small for | |
235 | // this operation. | |
cc61c64b | 236 | #[allow(unused)] pub const ERR_BUFFER_TOO_SMALL: mx_status_t = -15; |
32a655c1 SL |
237 | |
238 | // ======= Precondition or state errors ======= | |
239 | // ERR_BAD_STATE: operation failed because the current state of the | |
240 | // object does not allow it, or a precondition of the operation is | |
241 | // not satisfied | |
242 | #[allow(unused)] pub const ERR_BAD_STATE: mx_status_t = -20; | |
243 | ||
cc61c64b XL |
244 | // ERR_TIMED_OUT: The time limit for the operation elapsed before |
245 | // the operation completed. | |
246 | #[allow(unused)] pub const ERR_TIMED_OUT: mx_status_t = -21; | |
247 | ||
248 | // ERR_SHOULD_WAIT: The operation cannot be performed currently but | |
249 | // potentially could succeed if the caller waits for a prerequisite | |
250 | // to be satisfied, for example waiting for a handle to be readable | |
251 | // or writable. | |
252 | // Example: Attempting to read from a message pipe that has no | |
253 | // messages waiting but has an open remote will return ERR_SHOULD_WAIT. | |
254 | // Attempting to read from a message pipe that has no messages waiting | |
255 | // and has a closed remote end will return ERR_REMOTE_CLOSED. | |
256 | #[allow(unused)] pub const ERR_SHOULD_WAIT: mx_status_t = -22; | |
257 | ||
258 | // ERR_CANCELED: The in-progress operation (e.g. a wait) has been | |
259 | // // canceled. | |
260 | #[allow(unused)] pub const ERR_CANCELED: mx_status_t = -23; | |
261 | ||
262 | // ERR_PEER_CLOSED: The operation failed because the remote end | |
263 | // of the subject of the operation was closed. | |
264 | #[allow(unused)] pub const ERR_PEER_CLOSED: mx_status_t = -24; | |
265 | ||
32a655c1 | 266 | // ERR_NOT_FOUND: The requested entity is not found. |
cc61c64b | 267 | #[allow(unused)] pub const ERR_NOT_FOUND: mx_status_t = -25; |
32a655c1 SL |
268 | |
269 | // ERR_ALREADY_EXISTS: An object with the specified identifier | |
270 | // already exists. | |
271 | // Example: Attempting to create a file when a file already exists | |
272 | // with that name. | |
cc61c64b | 273 | #[allow(unused)] pub const ERR_ALREADY_EXISTS: mx_status_t = -26; |
32a655c1 SL |
274 | |
275 | // ERR_ALREADY_BOUND: The operation failed because the named entity | |
276 | // is already owned or controlled by another entity. The operation | |
277 | // could succeed later if the current owner releases the entity. | |
cc61c64b | 278 | #[allow(unused)] pub const ERR_ALREADY_BOUND: mx_status_t = -27; |
32a655c1 SL |
279 | |
280 | // ERR_UNAVAILABLE: The subject of the operation is currently unable | |
281 | // to perform the operation. | |
282 | // Note: This is used when there's no direct way for the caller to | |
283 | // observe when the subject will be able to perform the operation | |
284 | // and should thus retry. | |
cc61c64b | 285 | #[allow(unused)] pub const ERR_UNAVAILABLE: mx_status_t = -28; |
32a655c1 SL |
286 | |
287 | // ======= Permission check errors ======= | |
288 | // ERR_ACCESS_DENIED: The caller did not have permission to perform | |
289 | // the specified operation. | |
290 | #[allow(unused)] pub const ERR_ACCESS_DENIED: mx_status_t = -30; | |
291 | ||
292 | // ======= Input-output errors ======= | |
293 | // ERR_IO: Otherwise unspecified error occurred during I/O. | |
294 | #[allow(unused)] pub const ERR_IO: mx_status_t = -40; | |
295 | ||
296 | // ERR_REFUSED: The entity the I/O operation is being performed on | |
297 | // rejected the operation. | |
298 | // Example: an I2C device NAK'ing a transaction or a disk controller | |
299 | // rejecting an invalid command. | |
300 | #[allow(unused)] pub const ERR_IO_REFUSED: mx_status_t = -41; | |
301 | ||
302 | // ERR_IO_DATA_INTEGRITY: The data in the operation failed an integrity | |
303 | // check and is possibly corrupted. | |
304 | // Example: CRC or Parity error. | |
305 | #[allow(unused)] pub const ERR_IO_DATA_INTEGRITY: mx_status_t = -42; | |
306 | ||
307 | // ERR_IO_DATA_LOSS: The data in the operation is currently unavailable | |
308 | // and may be permanently lost. | |
309 | // Example: A disk block is irrecoverably damaged. | |
310 | #[allow(unused)] pub const ERR_IO_DATA_LOSS: mx_status_t = -43; | |
311 | ||
312 | // Filesystem specific errors | |
313 | #[allow(unused)] pub const ERR_BAD_PATH: mx_status_t = -50; | |
314 | #[allow(unused)] pub const ERR_NOT_DIR: mx_status_t = -51; | |
315 | #[allow(unused)] pub const ERR_NOT_FILE: mx_status_t = -52; | |
cc61c64b XL |
316 | // ERR_FILE_BIG: A file exceeds a filesystem-specific size limit. |
317 | #[allow(unused)] pub const ERR_FILE_BIG: mx_status_t = -53; | |
318 | // ERR_NO_SPACE: Filesystem or device space is exhausted. | |
319 | #[allow(unused)] pub const ERR_NO_SPACE: mx_status_t = -54; |