wasi:io: enforce the check-write permit in the remaining output streams

[xia-chao]

A stream has to trap when you write more than check-write allowed. Three don't:

SinkOutputStream — a guest's stdout with -Sinherit-stdout=n:

wasmtime/crates/wasi/src/p2/pipe.rs

Lines 277 to 290 in 4b3cef0

	impl OutputStream for SinkOutputStream {
	fn write(&mut self, _buf: Bytes) -> Result<(), StreamError> {
	Ok(())
	}
	fn flush(&mut self) -> Result<(), StreamError> {
	// This stream is always flushed
	Ok(())
	}
	fn check_write(&mut self) -> Result<usize, StreamError> {
	// This stream is always ready for writing.
	Ok(crate::MAX_READ_SIZE_ALLOC)
	}
	}

OutputFile:

wasmtime/crates/wasi/src/cli/file.rs

Lines 49 to 65 in 4b3cef0

	impl OutputStream for OutputFile {
	fn write(&mut self, bytes: Bytes) -> StreamResult<()> {
	(&*self.file)
	.write_all(&bytes)
	.map_err(|e| StreamError::LastOperationFailed(wasmtime::format_err!(e)))
	}
	fn flush(&mut self) -> StreamResult<()> {
	use std::io::Write;
	self.file
	.flush()
	.map_err(|e| StreamError::LastOperationFailed(wasmtime::format_err!(e)))
	}
	fn check_write(&mut self) -> StreamResult<usize> {
	Ok(crate::MAX_READ_SIZE_ALLOC)
	}

CustomOutputStream:

wasmtime/crates/c-api/src/wasi.rs

Lines 212 to 233 in 4b3cef0

	impl wasmtime_wasi::p2::OutputStream for CustomOutputStream {
	fn write(&mut self, bytes: Bytes) -> Result<(), StreamError> {
	let wrote = self
	.inner
	.raw_write(&bytes)
	.map_err(|e| StreamError::LastOperationFailed(e.into()))?;
	if wrote != bytes.len() {
	return Err(StreamError::LastOperationFailed(wasmtime::format_err!(
	"Partial writes in wasip2 implementation are not allowed"
	)));
	}
	Ok(())
	}
	fn flush(&mut self) -> Result<(), StreamError> {
	Ok(())
	}
	fn check_write(&mut self) -> Result<usize, StreamError> {
	Ok(64 * 1024)
	}
	}

They hand back a number and then take anything. All three always give the same number, so one check is enough.

Spec:

wasmtime/crates/wasi-io/wit/deps/io.wit

Lines 184 to 204 in 4b3cef0

	/// Check readiness for writing. This function never blocks.
	///
	/// Returns the number of bytes permitted for the next call to `write`,
	/// or an error. Calling `write` with more bytes than this function has
	/// permitted will trap.
	///
	/// When this function returns 0 bytes, the `subscribe` pollable will
	/// become ready when this function will report at least 1 byte, or an
	/// error.
	@since(version = 0.2.0)
	check-write: func() -> result<u64, stream-error>;
	/// Perform a write. This function never blocks.
	///
	/// When the destination of a `write` is binary data, the bytes from
	/// `contents` are written verbatim. When the destination of a `write` is
	/// known to the implementation to be text, the bytes of `contents` are
	/// transcoded from UTF-8 into the encoding of the destination and then
	/// written.
	///
	/// Precondition: check-write gave permit of Ok(n) and contents has a
	/// length of less than or equal to n. Otherwise, this function will trap.