Function create

crates/wasi/src/cli/worker_thread_stdin.rs:97–144

()

}

fn create() -> GlobalStdin {
    std::thread::spawn(|| {
        let state = GlobalStdin::get();
        loop {
            // Wait for a read to be requested, but don't hold the lock across
            // the blocking read.
            let mut lock = state.state.lock().unwrap();
            lock = state
                .read_requested
                .wait_while(lock, |state| !matches!(state, StdinState::ReadRequested(_)))
                .unwrap();

            // Extract the size hint from the request and cap it to `MAX_READ_SIZE_ALLOC`
            // to avoid guest-controlled unbounded allocation.
            // The `.max(1)` ensures a zero-length read is never misinterpreted as EOF.
            let size_hint = match *lock {
                StdinState::ReadRequested(size) => size.min(MAX_READ_SIZE_ALLOC).max(1),
                _ => unreachable!(),
            };
            drop(lock);

            let mut bytes = BytesMut::zeroed(size_hint);
            let (new_state, done) = match std::io::stdin().read(&mut bytes) {
                Ok(0) => (StdinState::Closed, true),
                Ok(nbytes) => {
                    bytes.truncate(nbytes);
                    (StdinState::Data(bytes), false)
                }
                Err(e) => (StdinState::Error(e), true),
            };

            // After the blocking read completes the state should not have been
            // tampered with.
            debug_assert!(matches!(
                *state.state.lock().unwrap(),
                StdinState::ReadRequested(_)
            ));
            let mut lock = state.state.lock().unwrap();
            *lock = new_state;
            state.read_completed.notify_waiters();
            if done {
                break;
            }
        }
    });

    GlobalStdin::default()
}

struct WasiStdin;