Add a disabled builder for aarch64 emulated tests

This commit adds a disabled builder which will run all tests for the standard
library for aarch64 in a QEMU instance. Once we get enough capacity to run this
on Travis this can be used to boost our platform coverage of AArch64

configure

@@ -490,6 +490,7 @@ valopt musl-root-armhf "" "arm-unknown-linux-musleabihf install directory"
 valopt musl-root-armv7 "" "armv7-unknown-linux-musleabihf install directory"
 valopt extra-filename "" "Additional data that is hashed and passed to the -C extra-filename flag"
 valopt qemu-armhf-rootfs "" "rootfs in qemu testing, you probably don't want to use this"
+valopt qemu-aarch64-rootfs "" "rootfs in qemu testing, you probably don't want to use this"
 valopt experimental-targets "" "experimental LLVM targets to build"
 
 if [ -e ${CFG_SRC_DIR}.git ]

src/bootstrap/config.rs

@@ -636,6 +636,11 @@ impl Config {
                     let target = self.target_config.entry(target).or_insert(Target::default());
                     target.qemu_rootfs = Some(parse_configure_path(value));
                 }
+                "CFG_QEMU_AARCH64_ROOTFS" if value.len() > 0 => {
+                    let target = INTERNER.intern_str("aarch64-unknown-linux-gnu");
+                    let target = self.target_config.entry(target).or_insert(Target::default());
+                    target.qemu_rootfs = Some(parse_configure_path(value));
+                }
                 _ => {}
             }
         }

src/ci/docker/armhf-gnu/Dockerfile

@@ -63,11 +63,11 @@ RUN curl http://cdimage.ubuntu.com/ubuntu-base/releases/16.04/release/ubuntu-bas
 
 # Copy over our init script, which starts up our test server and also a few
 # other misc tasks.
-COPY armhf-gnu/rcS rootfs/etc/init.d/rcS
+COPY scripts/qemu-bare-bones-rcS rootfs/etc/init.d/rcS
 RUN chmod +x rootfs/etc/init.d/rcS
 
 # Helper to quickly fill the entropy pool in the kernel.
-COPY armhf-gnu/addentropy.c /tmp/
+COPY scripts/qemu-bare-bones-addentropy.c /tmp/addentropy.c
 RUN arm-linux-gnueabihf-gcc addentropy.c -o rootfs/addentropy -static
 
 # TODO: What is this?!

src/ci/docker/disabled/aarch64-gnu/Dockerfile

@@ -0,0 +1,85 @@
+FROM ubuntu:16.04
+
+RUN apt-get update -y && apt-get install -y --no-install-recommends \
+      bc \
+      bzip2 \
+      ca-certificates \
+      cmake \
+      cpio \
+      curl \
+      file \
+      g++ \
+      gcc-aarch64-linux-gnu \
+      git \
+      libc6-dev \
+      libc6-dev-arm64-cross \
+      make \
+      python2.7 \
+      qemu-system-aarch64 \
+      xz-utils
+
+ENV ARCH=arm64 \
+    CROSS_COMPILE=aarch64-linux-gnu-
+
+WORKDIR /build
+
+# Compile the kernel that we're going to run and be emulating with. This is
+# basically just done to be compatible with the QEMU target that we're going
+# to be using when running tests. If any other kernel works or if any
+# other QEMU target works with some other stock kernel, we can use that too!
+#
+# The `config` config file was a previously generated config file for
+# the kernel. This file was generated by running `make defconfig`
+# followed by `make menuconfig` and then enabling the IPv6 protocol page.
+COPY disabled/aarch64-gnu/config /build/.config
+RUN curl https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.42.tar.xz | \
+      tar xJf - && \
+      cd /build/linux-4.4.42 && \
+      cp /build/.config . && \
+      make -j$(nproc) all && \
+      cp arch/arm64/boot/Image /tmp && \
+      cd /build &&  \
+      rm -rf linux-4.4.42
+
+# Compile an instance of busybox as this provides a lightweight system and init
+# binary which we will boot into. Only trick here is configuring busybox to
+# build static binaries.
+RUN curl https://www.busybox.net/downloads/busybox-1.21.1.tar.bz2 | tar xjf - && \
+      cd busybox-1.21.1 && \
+      make defconfig && \
+      sed -i 's/.*CONFIG_STATIC.*/CONFIG_STATIC=y/' .config && \
+      make -j$(nproc) && \
+      make install && \
+      mv _install /tmp/rootfs && \
+      cd /build && \
+      rm -rf busybox-1.12.1
+
+# Download the ubuntu rootfs, which we'll use as a chroot for all our tests.
+WORKDIR /tmp
+RUN mkdir rootfs/ubuntu
+RUN curl http://cdimage.ubuntu.com/ubuntu-base/releases/16.04/release/ubuntu-base-16.04-core-arm64.tar.gz | \
+      tar xzf - -C rootfs/ubuntu && \
+      cd rootfs && mkdir proc sys dev etc etc/init.d
+
+# Copy over our init script, which starts up our test server and also a few
+# other misc tasks.
+COPY scripts/qemu-bare-bones-rcS rootfs/etc/init.d/rcS
+RUN chmod +x rootfs/etc/init.d/rcS
+
+# Helper to quickly fill the entropy pool in the kernel.
+COPY scripts/qemu-bare-bones-addentropy.c /tmp/addentropy.c
+RUN aarch64-linux-gnu-gcc addentropy.c -o rootfs/addentropy -static
+
+COPY scripts/dumb-init.sh /scripts/
+RUN sh /scripts/dumb-init.sh
+
+COPY scripts/sccache.sh /scripts/
+RUN sh /scripts/sccache.sh
+
+ENTRYPOINT ["/usr/bin/dumb-init", "--"]
+
+ENV RUST_CONFIGURE_ARGS \
+      --target=aarch64-unknown-linux-gnu \
+      --qemu-aarch64-rootfs=/tmp/rootfs
+ENV SCRIPT python2.7 ../x.py test --target aarch64-unknown-linux-gnu
+ENV NO_CHANGE_USER=1

src/libstd/sys/unix/process/process_common.rs

@@ -469,6 +469,7 @@ mod tests {
     // although the reason isn't very clear as to why. For now this test is
     // ignored there.
     #[cfg_attr(target_arch = "arm", ignore)]
+    #[cfg_attr(target_arch = "aarch64", ignore)]
     fn test_process_mask() {
         unsafe {
             // Test to make sure that a signal mask does not get inherited.

src/libstd/time/mod.rs

@@ -533,9 +533,17 @@ mod tests {
         assert!(b > a);
         assert_eq!(b - a, Duration::new(1, 0));
 
-        // let's assume that we're all running computers later than 2000
         let thirty_years = Duration::new(1, 0) * 60 * 60 * 24 * 365 * 30;
-        assert!(a > thirty_years);
+
+        // Right now for CI this test is run in an emulator, and apparently the
+        // aarch64 emulator's sense of time is that we're still living in the
+        // 70s.
+        //
+        // Otherwise let's assume that we're all running computers later than
+        // 2000.
+        if !cfg!(target_arch = "aarch64") {
+            assert!(a > thirty_years);
+        }
 
         // let's assume that we're all running computers earlier than 2090.
         // Should give us ~70 years to fix this!

src/test/codegen/stack-probes.rs

@@ -11,6 +11,7 @@
 // ignore-arm
 // ignore-aarch64
 // ignore-powerpc
+// ignore-aarch64
 // ignore-wasm
 // ignore-emscripten
 // ignore-windows

src/tools/remote-test-client/src/main.rs

@@ -66,7 +66,7 @@ fn spawn_emulator(target: &str,
         start_android_emulator(server);
     } else {
         let rootfs = rootfs.as_ref().expect("need rootfs on non-android");
-        start_qemu_emulator(rootfs, server, tmpdir);
+        start_qemu_emulator(target, rootfs, server, tmpdir);
     }
 
     // Wait for the emulator to come online
@@ -120,7 +120,10 @@ fn start_android_emulator(server: &Path) {
                     .unwrap();
 }
 
-fn start_qemu_emulator(rootfs: &Path, server: &Path, tmpdir: &Path) {
+fn start_qemu_emulator(target: &str,
+                       rootfs: &Path,
+                       server: &Path,
+                       tmpdir: &Path) {
     // Generate a new rootfs image now that we've updated the test server
     // executable. This is the equivalent of:
     //
@@ -143,16 +146,36 @@ fn start_qemu_emulator(rootfs: &Path, server: &Path, tmpdir: &Path) {
     assert!(t!(child.wait()).success());
 
     // Start up the emulator, in the background
-    let mut cmd = Command::new("qemu-system-arm");
-    cmd.arg("-M").arg("vexpress-a15")
-       .arg("-m").arg("1024")
-       .arg("-kernel").arg("/tmp/zImage")
-       .arg("-initrd").arg(&rootfs_img)
-       .arg("-dtb").arg("/tmp/vexpress-v2p-ca15-tc1.dtb")
-       .arg("-append").arg("console=ttyAMA0 root=/dev/ram rdinit=/sbin/init init=/sbin/init")
-       .arg("-nographic")
-       .arg("-redir").arg("tcp:12345::12345");
-    t!(cmd.spawn());
+    match target {
+        "arm-unknown-linux-gnueabihf" => {
+            let mut cmd = Command::new("qemu-system-arm");
+            cmd.arg("-M").arg("vexpress-a15")
+               .arg("-m").arg("1024")
+               .arg("-kernel").arg("/tmp/zImage")
+               .arg("-initrd").arg(&rootfs_img)
+               .arg("-dtb").arg("/tmp/vexpress-v2p-ca15-tc1.dtb")
+               .arg("-append")
+               .arg("console=ttyAMA0 root=/dev/ram rdinit=/sbin/init init=/sbin/init")
+               .arg("-nographic")
+               .arg("-redir").arg("tcp:12345::12345");
+            t!(cmd.spawn());
+        }
+        "aarch64-unknown-linux-gnu" => {
+            let mut cmd = Command::new("qemu-system-aarch64");
+            cmd.arg("-machine").arg("virt")
+               .arg("-cpu").arg("cortex-a57")
+               .arg("-m").arg("1024")
+               .arg("-kernel").arg("/tmp/Image")
+               .arg("-initrd").arg(&rootfs_img)
+               .arg("-append")
+               .arg("console=ttyAMA0 root=/dev/ram rdinit=/sbin/init init=/sbin/init")
+               .arg("-nographic")
+               .arg("-netdev").arg("user,id=net0,hostfwd=tcp::12345-:12345")
+               .arg("-device").arg("virtio-net-device,netdev=net0,mac=00:00:00:00:00:00");
+            t!(cmd.spawn());
+        }
+        _ => panic!("cannot start emulator for: {}"< target),
+    }
 
     fn add_files(w: &mut Write, root: &Path, cur: &Path) {
         for entry in t!(cur.read_dir()) {