wasmer_wasix/syscalls/wasix/
proc_exec3.rs1use wasmer::FromToNativeWasmType;
2
3use super::*;
4use crate::{
5 VIRTUAL_ROOT_FD, WasiFs,
6 os::task::{OwnedTaskStatus, TaskStatus},
7 syscalls::*,
8};
9
10#[instrument(level = "trace", skip_all, fields(name = field::Empty, %args_len), ret)]
23pub fn proc_exec3<M: MemorySize>(
24 mut ctx: FunctionEnvMut<'_, WasiEnv>,
25 name: WasmPtr<u8, M>,
26 name_len: M::Offset,
27 args: WasmPtr<u8, M>,
28 args_len: M::Offset,
29 envs: WasmPtr<u8, M>,
30 envs_len: M::Offset,
31 search_path: Bool,
32 path: WasmPtr<u8, M>,
33 path_len: M::Offset,
34) -> Result<Errno, WasiError> {
35 WasiEnv::do_pending_operations(&mut ctx)?;
36
37 if let Some(exit_code) = unsafe { handle_rewind::<M, i32>(&mut ctx) } {
39 let exit_code = ExitCode::from_native(exit_code);
42 ctx.data().process.terminate(exit_code);
43 return Err(WasiError::Exit(exit_code));
44 }
45
46 let memory = unsafe { ctx.data().memory_view(&ctx) };
47 let mut name = name.read_utf8_string(&memory, name_len).map_err(|err| {
48 warn!("failed to execve as the name could not be read - {}", err);
49 WasiError::Exit(Errno::Inval.into())
50 })?;
51 Span::current().record("name", name.as_str());
52 let args = args.read_utf8_string(&memory, args_len).map_err(|err| {
53 warn!("failed to execve as the args could not be read - {}", err);
54 WasiError::Exit(Errno::Inval.into())
55 })?;
56 let args: Vec<_> = args
57 .split(&['\n', '\r'])
58 .map(|a| a.to_string())
59 .filter(|a| !a.is_empty())
60 .collect();
61
62 let envs = if !envs.is_null() {
63 let envs = envs.read_utf8_string(&memory, envs_len).map_err(|err| {
64 warn!("failed to execve as the envs could not be read - {}", err);
65 WasiError::Exit(Errno::Inval.into())
66 })?;
67
68 let envs = envs
69 .split(&['\n', '\r'])
70 .map(|a| a.to_string())
71 .filter(|a| !a.is_empty());
72
73 let mut vec = vec![];
74 for env in envs {
75 let (key, value) = wasi_try_ok!(env.split_once('=').ok_or(Errno::Inval));
76
77 vec.push((key.to_string(), value.to_string()));
78 }
79
80 Some(vec)
81 } else {
82 None
83 };
84
85 if search_path == Bool::True && !name.contains('/') {
87 let path_str;
88
89 let path = if path.is_null() {
90 vec!["/usr/local/bin", "/bin", "/usr/bin"]
91 } else {
92 path_str = path.read_utf8_string(&memory, path_len).map_err(|err| {
93 warn!("failed to execve as the path could not be read - {}", err);
94 WasiError::Exit(Errno::Inval.into())
95 })?;
96 path_str.split(':').collect()
97 };
98 let (_, state, inodes) =
99 unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
100 match find_executable_in_path(&state.fs, inodes, path.iter().map(AsRef::as_ref), &name) {
101 FindExecutableResult::Found(p) => name = p,
102 FindExecutableResult::AccessError => return Ok(Errno::Access),
103 FindExecutableResult::NotFound => return Ok(Errno::Noexec),
104 }
105 } else if name.starts_with("./") {
106 name = ctx.data().state.fs.relative_path_to_absolute(name);
107 }
108
109 trace!(name);
110
111 let preopen = ctx.data().state.preopen.clone();
113
114 let (_, cur_dir) = {
116 let (memory, state, inodes) =
117 unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
118 match state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD) {
119 Ok(a) => a,
120 Err(err) => {
121 warn!("failed to create subprocess for fork - {}", err);
122 return Err(WasiError::Exit(err.into()));
123 }
124 }
125 };
126
127 let new_store = ctx.data().runtime.new_store();
128
129 if let Some(mut vfork) = ctx.data_mut().vfork.take() {
132 let mut child_env = Box::new(ctx.data().clone());
134
135 let child_pid = ctx.data().process.pid();
137
138 tracing::debug!(
139 %child_pid,
140 vfork_pid = %vfork.env.process.pid(),
141 "proc_exec in presence of vfork"
142 );
143
144 let mut vfork_env = vfork.env.clone();
146 vfork_env.swap_inner(ctx.data_mut());
147 std::mem::swap(vfork_env.as_mut(), ctx.data_mut());
148 let mut wasi_env = *vfork_env;
149 wasi_env.owned_handles.push(vfork.handle.clone());
150 _prepare_wasi(&mut wasi_env, Some(args), envs, None);
151
152 let stack_lower = wasi_env.layout.stack_lower;
154 let stack_upper = wasi_env.layout.stack_upper;
155
156 let mut err_exit_code: ExitCode = Errno::Success.into();
158
159 let spawn_result = {
160 let bin_factory = Box::new(ctx.data().bin_factory.clone());
161 let tasks = wasi_env.tasks().clone();
162
163 let mut config = Some(wasi_env);
164
165 match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut config) {
166 Ok(a) => Ok(()),
167 Err(err) => {
168 if !err.is_not_found() {
169 error!("builtin failed - {}", err);
170 }
171
172 let env = config.take().unwrap();
173
174 let name_inner = name.clone();
175 __asyncify_light(ctx.data(), None, async {
176 let ret = bin_factory.spawn(name_inner, env).await;
177 match ret {
178 Ok(ret) => {
179 trace!(%child_pid, "spawned sub-process");
180 Ok(())
181 }
182 Err(err) => {
183 err_exit_code = conv_spawn_err_to_exit_code(&err);
184
185 debug!(%child_pid, "process failed with (err={})", err_exit_code);
186
187 Err(Errno::Noexec)
188 }
189 }
190 })
191 .unwrap()
192 }
193 }
194 };
195
196 match spawn_result {
197 Err(e) => {
198 child_env.swap_inner(ctx.data_mut());
200 std::mem::swap(child_env.as_mut(), ctx.data_mut());
201
202 ctx.data_mut().vfork = Some(vfork);
203 return Ok(e);
204 }
205 Ok(()) => {
206 let rewind_stack = vfork.rewind_stack.freeze();
209 let store_data = vfork.store_data;
210 unwind::<M, _>(ctx, move |mut ctx, _, _| {
211 match rewind::<M, _>(
213 ctx,
214 None,
215 rewind_stack,
216 store_data,
217 ForkResult {
218 pid: child_pid.raw() as Pid,
219 ret: Errno::Success,
220 },
221 ) {
222 Errno::Success => OnCalledAction::InvokeAgain,
223 err => {
224 warn!("fork failed - could not rewind the stack - errno={}", err);
225 OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
226 }
227 }
228 })?;
229 Ok(Errno::Success)
230 }
231 }
232 }
233 else {
237 let mut wasi_env = ctx.data().clone();
239 _prepare_wasi(&mut wasi_env, Some(args), envs, None);
240
241 let bin_factory = ctx.data().bin_factory.clone();
243 let tasks = wasi_env.tasks().clone();
244
245 let bin_factory = Box::new(ctx.data().bin_factory.clone());
247
248 let mut builder = Some(wasi_env);
249
250 let process = match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut builder) {
251 Ok(a) => Ok(a),
252 Err(err) => {
253 if !err.is_not_found() {
254 error!("builtin failed - {}", err);
255 }
256
257 let env = builder.take().unwrap();
258
259 InlineWaker::block_on(bin_factory.spawn(name, env))
261 }
262 };
263
264 match process {
265 Ok(mut process) => {
266 let env = ctx.data();
268
269 let thread = env.thread.clone();
270
271 let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
273 process
274 .wait_finished()
275 .await
276 .unwrap_or_else(|_| Errno::Child.into())
277 .to_native()
278 })?;
279 match res {
280 AsyncifyAction::Finish(mut ctx, result) => {
281 let exit_code = ExitCode::from_native(result);
283 ctx.data().process.terminate(exit_code);
284 WasiEnv::process_signals_and_exit(&mut ctx)?;
285 Err(WasiError::Exit(Errno::Unknown.into()))
286 }
287 AsyncifyAction::Unwind => Ok(Errno::Success),
288 }
289 }
290 Err(err) => {
291 warn!(
292 "failed to execve as the process could not be spawned (fork)[0] - {}",
293 err
294 );
295 Ok(Errno::Noexec)
296 }
297 }
298 }
299}
300
301pub(crate) enum FindExecutableResult {
302 Found(String),
303 AccessError,
304 NotFound,
305}
306
307pub(crate) fn find_executable_in_path<'a>(
308 fs: &WasiFs,
309 inodes: &WasiInodes,
310 path: impl IntoIterator<Item = &'a str>,
311 file_name: &str,
312) -> FindExecutableResult {
313 let mut encountered_eaccess = false;
314 for p in path {
315 let full_path = format!("{}/{}", p.trim_end_matches('/'), file_name);
316 match fs.get_inode_at_path(inodes, VIRTUAL_ROOT_FD, &full_path, true) {
317 Ok(_) => return FindExecutableResult::Found(full_path),
318 Err(Errno::Access) => encountered_eaccess = true,
319 Err(_) => (),
320 }
321 }
322
323 if encountered_eaccess {
324 FindExecutableResult::AccessError
325 } else {
326 FindExecutableResult::NotFound
327 }
328}