Remove rtio

[aturon]

This PR includes a sequence of commits that gradually dismantles the librustrt rtio system -- the main trait previously used to abstract over green and native io. It also largely dismantles libnative, moving much of its code into libstd and refactoring as it does so.

TL;DR:

• Before this PR: rustc hello.rs && wc -c hello produces 715,996
• After this PR: rustc hello.rs && wc -c hello produces 368,100

That is, this PR reduces the footprint of hello world by ~50%.

This is a major step toward #17325 (i.e. toward implementing the runtime removal RFC.) What remains is to pull out the scheduling, synchronization and task infrastructure, and to remove libgreen. These will be done soon in a follow-up PR.

Part of the work here is eliminating the rtio abstraction, which in many cases means bringing the implementation of io closer to the actual API presented in std::io.

Another aspect of this PR is the creation of two new, private modules within std that implement io:

• The sys module, which represents a platform-specific implementation of a number of low-level abstractions that are used directly within std::io and std::os. These "abstractions" are left largely the same as they were in libnative (except for the removal of Arc in file descriptors), but they are expected to evolve greatly over time. Organizationally, there are sys/unix/ and sys/windows/ directories which both implement the entire sys module hierarchy; this means that nearly all of the platform-specific code is isolated and you can get a handle on each platform in isolation.
• The sys_common module, which is rooted at sys/common, and provides a few pieces of private, low-level, but cross-platform functionality.

In the long term, the sys modules will provide hooks for exposing high-level platform-specific APIs as part of libstd. The first such API will be access to file descriptors from std::io abstractions, but a bit of design work remains before that step can be taken.

The sys_common module includes some traits (like AsFileDesc) which allow communication of private details between modules in disparate locations in the hierarchy; this helps overcome the relatively simple hierarchical privacy system in Rust.

To emphasize: the organization in sys is very preliminary and the main goal was to migrate away from rtio as quickly and simply as possible. The design will certainly evolve over time, and all of the details are currently private.

Along the way, this PR also entirely removes signal handling, since it was only supported on librustuv which was removed a while ago.

Because of the removal of APIs from libnative and librustrt, and the removal of signal handling, this is a:

[breaking-change]

Some of these APIs will return in public from from std over time.

r? @alexcrichton

[rust-highfive]

Warning

• These commits modify unsafe code. Please review it carefully!

[alexcrichton]

This may also want to note as being a [breaking-change] in the sense that native::io was gobbled up into the standard library and is no longer being exposed at this time. I expect that will be a more painful change than losing signal handling, sadly (I know I've got a lib or two that uses it!).

In general I definitely feel like this is the right direction to go in, and I'd definitely be willing to help out in making some of these details public over time.

[aturon]

@alexcrichton Ah yes, I've been so used to thinking of things like libnative as "use at your own risk" that I didn't think to warn about that. I'll adjust the commit messages.

[alexcrichton]

Ah and I meant to say: other than that, r=me, amazing work!

[brson]

🎈

[aturon]

Status update: going to make sure things are passing try before passing this along to @bors.

[mcpherrinm]

P=1000000000

[nikomatsakis]

🎯

[alexcrichton]

Turns out the test timed out because the acceptor never actually accepted (it never returned from this function). I think that this was an erroneous copy/paste from

rust/src/libnative/io/util.rs

Lines 174 to 180 in 223ca76

	for &fd in fds.iter() {
	c::fd_set(&mut set, fd);
	max = cmp::max(max, fd + 1);
	}
	if cfg!(windows) {
	max = fds.len() as net::sock_t;
	}

which just needs an if cfg!(windows) around this max = fds.len() as sock_t

[alexcrichton]

Could you also turn tcp-stress parameters back up to what they were?

[aturon]

@alexcrichton Is this latest failure known to be spurious? run-pass/sepcomp-lib-lto.rs on android. seems unrelated to the changes here.