write_all assumes that a write returning 0 is a kind of EOF

[RalfJung]

The code is quite self-explaining:

rust/library/std/src/io/mod.rs

Lines 1835 to 1847 in a7e8fe7

	fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
	while !buf.is_empty() {
	match self.write(buf) {
	Ok(0) => {
	return Err(Error::WRITE_ALL_EOF);
	}
	Ok(n) => buf = &buf[n..],
	Err(ref e) if e.is_interrupted() => {}
	Err(e) => return Err(e),
	}
	}
	Ok(())
	}

However, reading the write() docs, I see no justification for this. As far as I can tell, write is allowed to spuriously return 0 as a form of "short write". This random website also says so.

Cc @the8472

[the8472]

well... while !buf.is_empty() {

As far as I can tell, write is allowed to spuriously return 0 as a form of "short write

Short writes are still larger than zero. If it's a socket then it will block if there's no capacity or return an EAGAIN if it's nonblocking. Ditto for pipes. Regular files only return 0 when it's full.

[RalfJung]

The count argument will never be 0, yes. But this issue is about the return value.

This is not the same discussion as what I raised on Zulip earlier.

[RalfJung]

Short writes are still larger than zero. If it's a socket then it will block if there's no capacity or return an EAGAIN if it's nonblocking. Ditto for pipes. Regular files only return 0 when it's full.

The read docs say that when read returns 0, that indicates EOF. The write docs say nothing like that, as far as I can see. So, what is this based on?

[the8472]

This code is ancient, primordial rust even.

https://github.com/rust-lang/rust/blame/79dd393a4f144fa5e6f81c720c782de3175810d7/src/libstd/io/mod.rs#L374

I recall discussion that in some cases zero-length writes are returned when files are full. Maybe it stems from older posix specs?

[the8472]

Ah, this is not actually EOF, it's just poorly named.

rust/library/std/src/io/error.rs

Lines 93 to 94 in b416342

	pub(crate) const WRITE_ALL_EOF: Self =
	const_error!(ErrorKind::WriteZero, "failed to write whole buffer");

The so the actual errorkind we return is WriteZero

This specific behavior of write_all was previously approved by T-libs. We turn this into an error because we don't want to busy-loop when nothing can be written. Either the implementation blocks, retruns an error (which can be EAGAIN telling the caller to poll) or it writes at least one byte.

Note that this is our general Write contract, not specific to file IO.

[RalfJung]

The Write contract says:

A return value of Ok(0) typically means that the underlying object is no longer able to accept bytes and will likely not be able to in the future as well, or that the buffer provided is empty.

"typical" doesn't mean "always".

It's also unclear to me whether the POSIX file descriptor implementation of Write satisfies this condition, since POSIX says nothing about what a return value of 0 "typically" means.

---

The POSIX docs also have an interesting comment:

Where this volume of POSIX.1-2017 requires -1 to be returned and errno set to [EAGAIN], most historical implementations return zero

[the8472]

The POSIX docs also have an interesting comment

Note, the page uses frames. To directly link to a page you first need to show only one frame and then take the url. Also, that's posix2017.
Here's the 2024 write() page: https://pubs.opengroup.org/onlinepubs/9799919799/functions/write.html

Where this volume of POSIX.1-2017 requires -1 to be returned and errno set to [EAGAIN], most historical implementations return zero

That's about blocking behavior on pipes and I think by "historical" they mean stuff from the 80s that we don't support.

---

Overall I don't think zero-length returns can happen under normal circumstances. Of course FUSE and special filesystems might do crazy things in practice, but spec-compliant behavior is:

When attempting to write to a file descriptor (other than a pipe or FIFO) that supports non-blocking writes and cannot accept the data immediately:
If the O_NONBLOCK flag is clear, write() shall block the calling thread until the data can be accepted.
If the O_NONBLOCK flag is set, write() shall not block the thread. If some data can be written without blocking the thread, write() shall write what it can and return the number of bytes written. Otherwise, it shall return -1 and set errno to [EAGAIN].

This means if something currently cannot accept any bytes at all it either has to block or return EAGAIN. Attempting to write data at the end of a fixed-size block devices returns ENOSPC. Interrupted writes return EINTR. None of those cases is zero.

If it can accept some bytes it can do a partial write, which then is N > 0.