OpenE2K
/
libc-rs
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use docker for all CI tests and images 

Previously we were somewhat half-Docker, half-Travis, half apt-get, etc. This
commit alters the CI infrastructure to use Docker images for each target. This
should make it much easier to update the images and tweak various bits and
pieces of installed software. Additionally, it's also much clearer now what's
needed for each suite of tests!

Some images were updated a bit (e.g. musl is now 1.1.14), but other images
encountered failures when updating so they're not getting updated just yet.
This commit is contained in:
Alex Crichton 2016-06-10 05:03:23 -07:00
parent 70dce055eb
commit 3eb4a48b1b
20 changed files with 267 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
.travis.yml
View File

@ -1,65 +1,106 @@
language: rust
sudo: required
dist: trusty
rust:
- 1.0.0
- stable
- beta
- nightly
services:
- docker
install:
- curl https://static.rust-lang.org/rustup.sh |
sh -s -- --add-target=$TARGET --disable-sudo -y --prefix=`rustc --print sysroot`
script:
- if [[ $TRAVIS_RUST_VERSION = nightly* ]]; then
sh ci/run-travis.sh;
elif [[ $TRAVIS_RUST_VERSION = "1.0.0" ]]; then
cargo build;
- cargo build
- cargo build --no-default-features
- cargo generate-lockfile --manifest-path libc-test/Cargo.toml
- if [[ $TRAVIS_OS_NAME = "linux" ]]; then
sh ci/run-docker.sh $TARGET;
else
cargo build &&
cargo build --no-default-features &&
rustc ci/style.rs && ./style src;
export CARGO_TARGET_DIR=`pwd`/target;
sh ci/run.sh $TARGET;
fi
- rustc ci/style.rs && ./style src
osx_image: xcode7.3
os:
- linux
- osx
env:
matrix:
- ARCH=x86_64
- ARCH=i686
global:
secure: eIDEoQdTyglcsTD13zSGotAX2HDhRSXIaaTnVZTThqLSrySOc3/6KY3qmOc2Msf7XaBqfFy9QA+alk7OwfePp253eiy1Kced67ffjjFOytEcRT7FlQiYpcYQD6WNHZEj62/bJBO4LTM9sGtWNCTJVEDKW0WM8mUK7qNuC+honPM=
matrix:
include:
# 1.0.0 compat
- os: linux
env: TARGET=arm-linux-androideabi DOCKER=alexcrichton/rust-slave-android:2015-11-22
rust: nightly
env: TARGET=x86_64-unknown-linux-gnu
rust: 1.0.0
script: cargo build
install:
# build documentation
- os: linux
env: TARGET=x86_64-unknown-linux-gnu
rust: stable
script: sh ci/dox.sh
# stable compat
- os: linux
env: TARGET=x86_64-unknown-linux-gnu
rust: stable
- os: linux
env: TARGET=i686-unknown-linux-gnu
rust: stable
- os: osx
env: TARGET=x86_64-apple-darwin
rust: stable
- os: osx
env: TARGET=i686-apple-darwin
rust: stable
- os: linux
env: TARGET=arm-linux-androideabi
rust: stable
- os: linux
env: TARGET=x86_64-unknown-linux-musl
rust: nightly
rust: stable
- os: linux
env: TARGET=arm-unknown-linux-gnueabihf
rust: nightly
- os: linux
env: TARGET=mips-unknown-linux-gnu DOCKER=alexcrichton/rust-libc-mips:2016-01-10
rust: nightly
rust: stable
- os: linux
env: TARGET=aarch64-unknown-linux-gnu
rust: nightly
rust: stable
- os: osx
env: TARGET=i386-apple-ios
rust: nightly
rust: stable
- os: osx
env: TARGET=x86_64-apple-ios
rust: stable
- os: linux
env: TARGET=x86_64-rumprun-netbsd
rust: stable
# beta
- os: linux
env: TARGET=x86_64-unknown-linux-gnu
rust: beta
- os: osx
env: TARGET=x86_64-apple-darwin
rust: beta
# nightly
- os: linux
env: TARGET=x86_64-unknown-linux-gnu
rust: nightly
- os: osx
env: TARGET=x86_64-apple-darwin
rust: nightly
- os: linux
env: TARGET=x86_64-rumprun-netbsd DOCKER=alexcrichton/rust-libc-rumprun:2015-11-27
env: TARGET=mips-unknown-linux-gnu
# not sure why this has to be nightly...
rust: nightly
# QEMU based targets that compile in an emulator
- os: linux
env: TARGET=x86_64-unknown-freebsd QEMU=freebsd.qcow2
rust: nightly
env: TARGET=x86_64-unknown-freebsd
rust: stable
- os: linux
env: TARGET=x86_64-unknown-openbsd QEMU=openbsd.qcow2
rust: nightly
rust: stable
script: sh ci/run-docker.sh $TARGET
install:
notifications:
email:
on_success: never

13
ci/cargo-config
View File

@ -1,13 +0,0 @@
# Configuration of which linkers to call on Travis for various architectures
[target.arm-linux-androideabi]
linker = "arm-linux-androideabi-gcc"
[target.arm-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc-4.7"
[target.mips-unknown-linux-gnu]
linker = "mips-linux-gnu-gcc-5"
[target.aarch64-unknown-linux-gnu]
linker = "aarch64-linux-gnu-gcc"

7
ci/docker/aarch64-unknown-linux-gnu/Dockerfile Normal file
View File

@ -0,0 +1,7 @@
FROM ubuntu:14.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc libc6-dev ca-certificates \
gcc-aarch64-linux-gnu libc6-dev-arm64-cross qemu-user
ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc \
PATH=$PATH:/rust/bin

4
ci/docker/arm-linux-androideabi/Dockerfile Normal file
View File

@ -0,0 +1,4 @@
FROM alexcrichton/rust-slave-android:2015-11-22
ENV CARGO_TARGET_ARM_LINUX_ANDROIDEABI_LINKER=arm-linux-androideabi-gcc \
PATH=$PATH:/rust/bin
ENTRYPOINT ["sh"]

7
ci/docker/arm-unknown-linux-gnueabihf/Dockerfile Normal file
View File

@ -0,0 +1,7 @@
FROM ubuntu:16.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc libc6-dev ca-certificates \
gcc-arm-linux-gnueabihf libc6-dev-armhf-cross qemu-user
ENV CARGO_TARGET_ARM_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \
PATH=$PATH:/rust/bin

5
ci/docker/i686-unknown-linux-gnu/Dockerfile Normal file
View File

@ -0,0 +1,5 @@
FROM ubuntu:16.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc-multilib libc6-dev ca-certificates
ENV PATH=$PATH:/rust/bin

13
ci/docker/mips-unknown-linux-gnu/Dockerfile Normal file
View File

@ -0,0 +1,13 @@
FROM ubuntu:15.10
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
software-properties-common gcc libc6-dev qemu-user
RUN add-apt-repository ppa:angelsl/mips-cross
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc-5-mips-linux-gnu libc6-dev-mips-cross
ENV CARGO_TARGET_MIPS_UNKNOWN_LINUX_GNU_LINKER=mips-linux-gnu-gcc-5 \
CC_mips_unknown_linux_gnu=mips-linux-gnu-gcc-5 \
PATH=$PATH:/rust/bin

6
ci/docker/x86_64-rumprun-netbsd/Dockerfile Normal file
View File

@ -0,0 +1,6 @@
FROM mato/rumprun-toolchain-hw-x86_64
USER root
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
qemu
ENV PATH=$PATH:/rust/bin

13
ci/docker/x86_64-unknown-freebsd/Dockerfile Normal file
View File

@ -0,0 +1,13 @@
FROM alexcrichton/rust-slave-linux-cross:2016-04-15
USER root
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
qemu qemu-kvm kmod cpu-checker
ENTRYPOINT ["sh"]
ENV PATH=$PATH:/rust/bin \
QEMU=freebsd.qcow2 \
CAN_CROSS=1 \
CARGO_TARGET_X86_64_UNKNOWN_FREEBSD_LINKER=x86_64-unknown-freebsd10-gcc

5
ci/docker/x86_64-unknown-linux-gnu/Dockerfile Normal file
View File

@ -0,0 +1,5 @@
FROM ubuntu:16.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc libc6-dev ca-certificates
ENV PATH=$PATH:/rust/bin

13
ci/docker/x86_64-unknown-linux-musl/Dockerfile Normal file
View File

@ -0,0 +1,13 @@
FROM ubuntu:16.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc make libc6-dev git curl ca-certificates
RUN curl https://www.musl-libc.org/releases/musl-1.1.14.tar.gz | \
tar xzf - && \
cd musl-1.1.14 && \
./configure --prefix=/musl-x86_64 && \
make install -j4 && \
cd .. && \
rm -rf musl-1.1.14
ENV PATH=$PATH:/musl-x86_64/bin:/rust/bin

7
ci/docker/x86_64-unknown-openbsd/Dockerfile Normal file
View File

@ -0,0 +1,7 @@
FROM ubuntu:16.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends \
gcc libc6-dev qemu qemu-kvm curl ca-certificates kmod cpu-checker
ENV PATH=$PATH:/rust/bin \
QEMU=openbsd.qcow2

12
ci/mips/Dockerfile
View File

@ -1,12 +0,0 @@
FROM ubuntu:15.10
RUN apt-get update
RUN apt-get install -y --force-yes --no-install-recommends \
software-properties-common
RUN add-apt-repository ppa:angelsl/mips-cross
RUN apt-get update
RUN apt-get install -y --force-yes --no-install-recommends \
gcc-5-mips-linux-gnu libc6-dev-mips-cross \
gcc-5-mipsel-linux-gnu libc6-dev-mipsel-cross
RUN apt-get install -y --force-yes --no-install-recommends \
build-essential qemu-user

12
ci/rumprun/Dockerfile
View File

@ -1,12 +0,0 @@
FROM ubuntu:15.04
RUN apt-get update
RUN apt-get install -y binutils git g++ make qemu
WORKDIR /build
RUN git clone --recursive http://repo.rumpkernel.org/rumprun
WORKDIR /build/rumprun
RUN CC=cc ./build-rr.sh hw
ENV PATH=$PATH:/build/rumprun/rumprun/bin
WORKDIR /root

48
ci/run-all.sh
View File

@ -1,48 +0,0 @@
# This is **not** meant to be run on CI, but rather locally instead. If you're
# on a Linux machine you'll be able to run most of these, but otherwise this'll
# just attempt to run as many platforms as possible!
run() {
_target=$1
_cc=$2
if [ "$_cc" != "" ]; then
which $_cc > /dev/null
if [ $? -ne 0 ]; then
echo "$_cc not installed, skipping $_target"
return
fi
export CC=$_cc
fi
if [ ! -d .cargo ]; then
mkdir .cargo
cp ci/cargo-config .cargo/config
fi
sh ci/run.sh $_target
if [ "$?" != "0" ]; then
exit 1
fi
}
OS=`uname`
if [ "$OS" = "Linux" ]; then
# For more info on where to get all these cross compilers see
# ci/run-travis.sh and what packages are needed on ubuntu
run x86_64-unknown-linux-gnu clang
run i686-unknown-linux-gnu clang
run x86_64-unknown-linux-musl musl-gcc
run mips-unknown-linux-gnu mips-linux-gnu-gcc
run aarch64-unknown-linux-gnu aarch64-linux-gnueabihf-gcc
run arm-unknown-linux-gnueabihf arm-linux-gnueabihf-gcc-4.7
# Prep for this by running `vagrant up freebsd` in the `ci` directory
(cd ci && vagrant ssh freebsd -c \
"cd /vagrant && sh ci/run.sh x86_64-unknown-freebsd")
# Make sure you've run `docker pull alexcrichton/rust-libc-test` to get
# this image ahead of time.
docker run -itv `pwd`:/clone alexcrichton/rust-libc-test \
sh ci/run.sh arm-linux-androideabi
elif [ "$OS" = "Darwin" ]; then
cargo run --target x86_64-unknown-linux-gnu
cargo run --target i686-unknown-linux-gnu
fi

25
ci/run-docker.sh Normal file
View File

@ -0,0 +1,25 @@
# Small script to run tests for a target (or all targets) inside all the
# respective docker images.
set -ex
run() {
echo $1
docker build -t libc ci/docker/$1
docker run \
-v `rustc --print sysroot`:/rust:ro \
-v `pwd`:/checkout:ro \
-e CARGO_TARGET_DIR=/tmp/target \
-w /checkout \
--privileged \
-it libc \
ci/run.sh $1
}
if [ -z "$1" ]; then
for d in `ls ci/docker/`; do
run $d
done
else
run $1
fi

5
ci/run-qemu.sh
View File

@ -15,12 +15,9 @@ cp -r $ROOT/libc /tmp/libc
cd /tmp/libc
TARGET=$(cat $ROOT/TARGET)
export CARGO_TARGET_DIR=/tmp
case $TARGET in
*-freebsd)
sudo pkg install -y rust cargo
;;
*-openbsd)
pkg_add rust curl gcc-4.8.4p4
curl https://static.rust-lang.org/cargo-dist/2015-04-02/cargo-nightly-x86_64-unknown-openbsd.tar.gz | \

188
ci/run-travis.sh
View File

@ -1,188 +0,0 @@
# Entry point for all travis builds, this will set up the Travis environment by
# downloading any dependencies. It will then execute the `run.sh` script to
# build and execute all tests.
#
# For a full description of how all tests are run, see `ci/README.md`
set -ex
if [ "$TRAVIS_OS_NAME" = "linux" ]; then
OS=unknown-linux-gnu
else
OS=apple-darwin
fi
export HOST=$ARCH-$OS
if [ "$TARGET" = "" ]; then
TARGET=$HOST
fi
MAIN_TARGETS=https://static.rust-lang.org/dist
DATE=$(echo $TRAVIS_RUST_VERSION | sed s/nightly-//)
if [ "$DATE" != "nightly" ]; then
MAIN_TARGETS=$MAIN_TARGETS/$DATE
TRAVIS_RUST_VERSION=nightly
fi
install() {
if [ "$TRAVIS" = "true" ]; then
sudo apt-get update
sudo apt-get install -y $@
fi
}
# If we're going to run tests inside of a qemu image, then we don't need any of
# the scripts below. Instead, download the image, prepare a filesystem which has
# the current state of this repository, and then run the image.
#
# It's assume that all images, when run with two disks, will run the `run.sh`
# script from the second which we place inside.
if [ "$QEMU" != "" ]; then
# Acquire QEMU and the base OS image
install qemu-kvm
tmpdir=/tmp/qemu-img-creation
mkdir -p $tmpdir
if [ ! -f $tmpdir/$QEMU ]; then
curl https://people.mozilla.org/~acrichton/libc-test/qemu/$QEMU.gz | \
gunzip -d > $tmpdir/$QEMU
fi
# Generate all.{c,rs} on the host which will be compiled inside QEMU. Do this
# here because compiling syntex_syntax in QEMU would time out basically
# everywhere.
rm -rf $tmpdir/generated
mkdir -p $tmpdir/generated
CARGO_TARGET_DIR=$tmpdir/generated-build \
cargo build --manifest-path libc-test/generate-files/Cargo.toml
(cd libc-test && TARGET=$TARGET OUT_DIR=$tmpdir/generated SKIP_COMPILE=1 \
$tmpdir/generated-build/debug/generate-files)
# Create a mount a fresh new filesystem image that we'll later pass to QEMU,
# this contains the checkout of libc and will be able to run all tests
rm -f $tmpdir/libc-test.img
dd if=/dev/null of=$tmpdir/libc-test.img bs=1M seek=5
mkfs.ext2 -F $tmpdir/libc-test.img
rm -rf $tmpdir/mount
mkdir $tmpdir/mount
sudo mount -t ext2 -o loop $tmpdir/libc-test.img $tmpdir/mount
# Copy this folder into the mounted image, the `run.sh` entry point, and
# overwrite the standard libc-test Cargo.toml with the overlay one which will
# assume the all.{c,rs} test files have already been generated
sudo mkdir $tmpdir/mount/libc
sudo cp -r * $tmpdir/mount/libc/
sudo cp ci/run-qemu.sh $tmpdir/mount/run.sh
echo $TARGET | sudo tee -a $tmpdir/mount/TARGET
sudo cp $tmpdir/generated/* $tmpdir/mount/libc/libc-test
sudo cp libc-test/run-generated-Cargo.toml $tmpdir/mount/libc/libc-test/Cargo.toml
sudo umount $tmpdir/mount
# If we can use kvm, prefer that, otherwise just fall back to user-space
# emulation.
if kvm-ok; then
program="sudo kvm"
else
program=qemu-system-x86_64
fi
# Pass -snapshot to prevent tampering with the disk images, this helps when
# running this script in development. The two drives are then passed next,
# first is the OS and second is the one we just made. Next the network is
# configured to work (I'm not entirely sure how), and then finally we turn off
# graphics and redirect the serial console output to out.log.
$program \
-m 1024 \
-snapshot \
-drive if=virtio,file=$tmpdir/$QEMU \
-drive if=virtio,file=$tmpdir/libc-test.img \
-net nic,model=virtio \
-net user \
-nographic \
-vga none 2>&1 | tee out.log
exec grep "^PASSED .* tests" out.log
fi
mkdir -p .cargo
cp ci/cargo-config .cargo/config
# Next up we need to install the standard library for the version of Rust that
# we're testing.
if [ "$TRAVIS" = "true" ]; then
curl https://static.rust-lang.org/rustup.sh | \
sh -s -- --add-target=$TARGET --disable-sudo -y \
--prefix=`rustc --print sysroot`
fi
# If we're testing with a docker image, then run tests entirely within that
# image. Note that this is using the same rustc installation that travis has
# (sharing it via `-v`) and otherwise the tests run entirely within the
# container.
#
# For the docker build we mount the entire current directory at /checkout, set
# up some environment variables to let it run, and then run the standard run.sh
# script.
if [ "$DOCKER" != "" ]; then
args=""
case "$TARGET" in
mips-unknown-linux-gnu)
args="$args -e CC=mips-linux-gnu-gcc-5"
;;
*)
;;
esac
exec docker run \
--entrypoint bash \
-v `rustc --print sysroot`:/usr/local:ro \
-v `pwd`:/checkout \
-e LD_LIBRARY_PATH=/usr/local/lib \
-e CARGO_TARGET_DIR=/tmp \
$args \
-w /checkout \
-it $DOCKER \
ci/run.sh $TARGET
fi
# If we're not running docker or qemu, then we may still need some packages
# and/or tools with various configurations here and there.
case "$TARGET" in
x86_64-unknown-linux-musl)
install musl-tools
export CC=musl-gcc
;;
arm-unknown-linux-gnueabihf)
install gcc-4.7-arm-linux-gnueabihf qemu-user
export CC=arm-linux-gnueabihf-gcc-4.7
;;
aarch64-unknown-linux-gnu)
install gcc-aarch64-linux-gnu qemu-user
export CC=aarch64-linux-gnu-gcc
;;
*-apple-ios)
;;
*)
# clang has better error messages and implements alignof more broadly
export CC=clang
if [ "$TARGET" = "i686-unknown-linux-gnu" ]; then
install gcc-multilib
fi
;;
esac
# Finally, if we've gotten this far, actually run the tests.
sh ci/run.sh $TARGET
if [ "$TARGET" = "x86_64-unknown-linux-gnu" ] && \
[ "$TRAVIS_RUST_VERSION" = "nightly" ] && \
[ "$TRAVIS_OS_NAME" = "linux" ]; then
sh ci/dox.sh
fi

96
ci/run.sh Normal file → Executable file
View File

@ -6,6 +6,89 @@
set -ex
TARGET=$1
# If we're going to run tests inside of a qemu image, then we don't need any of
# the scripts below. Instead, download the image, prepare a filesystem which has
# the current state of this repository, and then run the image.
#
# It's assume that all images, when run with two disks, will run the `run.sh`
# script from the second which we place inside.
if [ "$QEMU" != "" ]; then
tmpdir=/tmp/qemu-img-creation
mkdir -p $tmpdir
if [ ! -f $tmpdir/$QEMU ]; then
curl https://people.mozilla.org/~acrichton/libc-test/qemu/$QEMU.gz | \
gunzip -d > $tmpdir/$QEMU
fi
# Create a mount a fresh new filesystem image that we'll later pass to QEMU.
# This will have a `run.sh` script will which use the artifacts inside to run
# on the host.
rm -f $tmpdir/libc-test.img
dd if=/dev/null of=$tmpdir/libc-test.img bs=1M seek=50
mkfs.ext2 -F $tmpdir/libc-test.img
rm -rf $tmpdir/mount
mkdir $tmpdir/mount
mount -t ext2 -o loop $tmpdir/libc-test.img $tmpdir/mount
# If we have a cross compiler, then we just do the standard rigamarole of
# cross-compiling an executable and then the script to run just executes the
# binary.
#
# If we don't have a cross-compiler, however, then we need to do some crazy
# acrobatics to get this to work. Generate all.{c,rs} on the host which will
# be compiled inside QEMU. Do this here because compiling syntex_syntax in
# QEMU would time out basically everywhere.
if [ "$CAN_CROSS" = "1" ]; then
cargo build --manifest-path libc-test/Cargo.toml --target $TARGET
cp $CARGO_TARGET_DIR/$TARGET/debug/libc-test $tmpdir/mount/
echo 'exec $1/libc-test' > $tmpdir/mount/run.sh
else
rm -rf $tmpdir/generated
mkdir -p $tmpdir/generated
cargo build --manifest-path libc-test/generate-files/Cargo.toml
(cd libc-test && TARGET=$TARGET OUT_DIR=$tmpdir/generated SKIP_COMPILE=1 \
$CARGO_TARGET_DIR/debug/generate-files)
# Copy this folder into the mounted image, the `run.sh` entry point, and
# overwrite the standard libc-test Cargo.toml with the overlay one which will
# assume the all.{c,rs} test files have already been generated
mkdir $tmpdir/mount/libc
cp -r Cargo.* libc-test src ci $tmpdir/mount/libc/
ln -s libc-test/target $tmpdir/mount/libc/target
cp ci/run-qemu.sh $tmpdir/mount/run.sh
echo $TARGET | tee -a $tmpdir/mount/TARGET
cp $tmpdir/generated/* $tmpdir/mount/libc/libc-test
cp libc-test/run-generated-Cargo.toml $tmpdir/mount/libc/libc-test/Cargo.toml
fi
umount $tmpdir/mount
# If we can use kvm, prefer that, otherwise just fall back to user-space
# emulation.
if kvm-ok; then
program=kvm
else
program=qemu-system-x86_64
fi
# Pass -snapshot to prevent tampering with the disk images, this helps when
# running this script in development. The two drives are then passed next,
# first is the OS and second is the one we just made. Next the network is
# configured to work (I'm not entirely sure how), and then finally we turn off
# graphics and redirect the serial console output to out.log.
$program \
-m 1024 \
-snapshot \
-drive if=virtio,file=$tmpdir/$QEMU \
-drive if=virtio,file=$tmpdir/libc-test.img \
-net nic,model=virtio \
-net user \
-nographic \
-vga none 2>&1 | tee $CARGO_TARGET_DIR/out.log
exec grep "^PASSED .* tests" $CARGO_TARGET_DIR/out.log
fi
case "$TARGET" in
*-apple-ios)
cargo rustc --manifest-path libc-test/Cargo.toml --target $TARGET -- \
@ -21,26 +104,25 @@ case "$TARGET" in
arm-linux-androideabi)
emulator @arm-21 -no-window &
adb wait-for-device
adb push /tmp/$TARGET/debug/libc-test /data/libc-test
adb push $CARGO_TARGET_DIR/$TARGET/debug/libc-test /data/libc-test
adb shell /data/libc-test 2>&1 | tee /tmp/out
grep "^PASSED .* tests" /tmp/out
;;
arm-unknown-linux-gnueabihf)
qemu-arm -L /usr/arm-linux-gnueabihf libc-test/target/$TARGET/debug/libc-test
qemu-arm -L /usr/arm-linux-gnueabihf $CARGO_TARGET_DIR/$TARGET/debug/libc-test
;;
mips-unknown-linux-gnu)
qemu-mips -L /usr/mips-linux-gnu /tmp/$TARGET/debug/libc-test
qemu-mips -L /usr/mips-linux-gnu $CARGO_TARGET_DIR/$TARGET/debug/libc-test
;;
aarch64-unknown-linux-gnu)
qemu-aarch64 -L /usr/aarch64-linux-gnu/ \
libc-test/target/$TARGET/debug/libc-test
qemu-aarch64 -L /usr/aarch64-linux-gnu/ $CARGO_TARGET_DIR/$TARGET/debug/libc-test
;;
*-rumprun-netbsd)
rumprun-bake hw_virtio /tmp/libc-test.img /tmp/$TARGET/debug/libc-test
rumprun-bake hw_virtio /tmp/libc-test.img $CARGO_TARGET_DIR/$TARGET/debug/libc-test
qemu-system-x86_64 -nographic -vga none -m 64 \
-kernel /tmp/libc-test.img 2>&1 | tee /tmp/out &
sleep 5
@ -48,6 +130,6 @@ case "$TARGET" in
;;
*)
libc-test/target/$TARGET/debug/libc-test
$CARGO_TARGET_DIR/$TARGET/debug/libc-test
;;
esac

4
src/unix/notbsd/linux/mod.rs
View File

@ -479,10 +479,6 @@ f! {
}
}
extern {
static mut program_invocation_short_name: *mut ::c_char;
}
extern {
pub fn shm_open(name: *const c_char, oflag: ::c_int,
mode: mode_t) -> ::c_int;