nathan/nixpkgs
1
0
Fork 0
mirror of https://github.com/NixOS/nixpkgs.git synced 2026-06-05 21:03:40 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
0c19eb3e5559a9e27a3402dda4357d0cd2b58dae
nixpkgs/pkgs/top-level/release-cross.nix
Emily 0c19eb3e55 lib/systems: unify ARMv5 platforms with stock kernel configuration 
The `sheevaplug` kernel configuration was added a very long time
ago and has not been adjusted for years. `pogoplug4` was identical
to `sheevaplug` except for an even more stripped‐down kernel
configuration, no device tree support, and a different load address
for the uImage.

These days, the stock kernel configuration builds and there has been
an upstream device tree for the Pogoplug Series 4 for years; unify
`sheevaplug` and `pogoplug4` into an `armv5tel-multiplatform` that
uses the standard configuration.

ARMv5 was also the only platform that defaulted to uImage, the [legacy
U‐Boot image format] that is deprecated upstream. Our bootloader
machinery in NixOS does not handle these images in any special way
and even the original ARMv6 Raspberry Pi platform defaults to the
standard zImage. We switch `armv5tel-multiplatform` to zImage to match.

[legacy U‐Boot image format]: https://docs.u-boot.org/en/latest/usage/cmd/bootm.html#legacy-boot

It is of course natural to worry about backwards compatibility
here: this switches to a different kernel image format and drops
support for root on NFS along with random oddities like KGDB and
LatencyTOP. Renaming the platform is intended to help mitigate
this risk.

The reality, however, is that it is currently very
difficult to build a configuration for ARMv5. I found
<https://github.com/thefloweringash/sheevaplug-nix> online as
an example configuration from many years ago; it already set
`autoModules`, and builds U‐Boot using `CONFIG_DISTRO_DEFAULTS`,
which should work out of the box without requiring the legacy U‐Boot
image format.

Even then, however, I confirmed with the author that it hasn’t
been used in years, and I could barely get it to build with
a modern Nixpkgs: OpenSSH is broken, Nix is broken, multiple
default `environment.systemPackages` in the SD image profile
are broken, `boot.initrd.includeDefaultModules` is broken, and
`hardware.enableAllHardware` is broken.

I conclude that if anyone is actively building systems on ARMv5, they
have a forked Nixpkgs or a very custom setup. Given our general move
to standard boot chains and no platform‐specific hacks, and the
decaying state of our unofficial support for 32‐bit ARM, I think
it is not worth maintaining support for the legacy image format for
this one ancient platform.

If anyone is running a heavily stripped‐down NixOS configuration on
mission‐critical SheevaPlugs using a custom Nix‐free deployment
setup relying on the legacy U‐Boot image format and somehow none
of these kernel changes manage to loudly break their build, hopefully
they’ll at least notice the release notes entry! Otherwise there’s
always JTAG…
2026-06-01 11:12:17 +10:00

343 lines
12 KiB
Nix
Raw Blame History

/*
This file defines some basic smoke tests for cross compilation.
Individual jobs can be tested by running:
$ nix-build pkgs/top-level/release-cross.nix -A <jobname>.<package> --arg supportedSystems '[builtins.currentSystem]'
e.g.
$ nix-build pkgs/top-level/release-cross.nix -A crossMingw32.nix --arg supportedSystems '[builtins.currentSystem]'
To build all of the bootstrapFiles bundles on every enabled platform, use:
$ nix-build --expr 'with import ./pkgs/top-level/release-cross.nix {supportedSystems = [builtins.currentSystem];}; builtins.mapAttrs (k: v: v.build) bootstrapTools'
*/
{
# The platforms *from* which we cross compile.
supportedSystems ? [
"x86_64-linux"
"aarch64-linux"
"aarch64-darwin"
],
# Strip most of attributes when evaluating to spare memory usage
scrubJobs ? true,
# Attributes passed to nixpkgs. Don't build packages marked as unfree.
nixpkgsArgs ? {
config = {
allowAliases = false;
allowUnfree = false;
inHydra = true;
};
__allowFileset = false;
},
}:
let
release-lib = import ./release-lib.nix {
inherit supportedSystems scrubJobs nixpkgsArgs;
};
inherit (release-lib)
all
assertTrue
darwin
forMatchingSystems
hydraJob'
linux
mapTestOnCross
pkgsForCross
;
inherit (release-lib.lib)
mapAttrs
addMetaAttrs
elem
getAttrFromPath
isDerivation
maintainers
mapAttrsRecursive
mapAttrsRecursiveCond
recursiveUpdate
systems
;
inherit (release-lib.lib.attrsets)
removeAttrs
;
nativePlatforms = all;
embedded = {
buildPackages.binutils = nativePlatforms;
buildPackages.gcc = nativePlatforms;
libc = nativePlatforms;
};
common = {
buildPackages.binutils = nativePlatforms;
gmp = nativePlatforms;
libc = nativePlatforms;
nix = nativePlatforms;
nixVersions.git = nativePlatforms;
mesa = nativePlatforms;
rustc = nativePlatforms;
cargo = nativePlatforms;
fd = nativePlatforms;
};
gnuCommon = recursiveUpdate common {
buildPackages.gcc = nativePlatforms;
coreutils = nativePlatforms;
haskell.packages.ghcHEAD.hello = nativePlatforms;
haskellPackages.hello = nativePlatforms;
};
linuxCommon = recursiveUpdate gnuCommon {
buildPackages.gdb = nativePlatforms;
bison = nativePlatforms;
busybox = nativePlatforms;
dropbear = nativePlatforms;
ed = nativePlatforms;
ncurses = nativePlatforms;
patch = nativePlatforms;
};
windowsCommon = recursiveUpdate gnuCommon {
boehmgc = nativePlatforms;
libffi = nativePlatforms;
libtool = nativePlatforms;
libunistring = nativePlatforms;
windows.pthreads = nativePlatforms;
};
cygwinCommon = {
hello = nativePlatforms;
nixVersions.git = nativePlatforms;
};
wasiCommon = {
gmp = nativePlatforms;
boehmgc = nativePlatforms;
hello = nativePlatforms;
zlib = nativePlatforms;
};
darwinCommon = {
buildPackages.binutils = darwin;
};
rpiCommon = linuxCommon // {
vim = nativePlatforms;
unzip = nativePlatforms;
ddrescue = nativePlatforms;
lynx = nativePlatforms;
patchelf = nativePlatforms;
buildPackages.binutils = nativePlatforms;
mpg123 = nativePlatforms;
};
# Enabled-but-unsupported platforms for which nix is known to build.
# We provide Hydra-built `nixStatic` for these platforms. This
# allows users to bootstrap their own system without either (a)
# trusting binaries from a non-Hydra source or (b) having to fight
# with their host distribution's versions of nix's numerous
# build dependencies.
nixCrossStatic = {
nixStatic = linux; # no need for buildPlatform=*-darwin
};
in
{
# These derivations from a cross package set's `buildPackages` should be
# identical to their vanilla equivalents --- none of these package should
# observe the target platform which is the only difference between those
# package sets.
ensureUnaffected =
let
# Absurd values are fine here, as we are not building anything. In fact,
# there probably a good idea to try to be "more parametric" --- i.e. avoid
# any special casing.
crossSystem = {
config = "mips64el-apple-windows-gnu";
libc = "glibc";
};
# Converting to a string (drv path) before checking equality is probably a
# good idea lest there be some irrelevant pass-through debug attrs that
# cause false negatives.
testEqualOne =
path: system:
let
f =
path: crossSystem: system:
toString (getAttrFromPath path (pkgsForCross crossSystem system));
in
assertTrue (f path null system == f ([ "buildPackages" ] ++ path) crossSystem system);
testEqual = path: systems: forMatchingSystems systems (testEqualOne path);
mapTestEqual = mapAttrsRecursive testEqual;
in
mapTestEqual {
boehmgc = nativePlatforms;
libffi = nativePlatforms;
libiconv = nativePlatforms;
libtool = nativePlatforms;
zlib = nativePlatforms;
readline = nativePlatforms;
libxml2 = nativePlatforms;
guile = nativePlatforms;
};
crossIphone64 = mapTestOnCross systems.examples.iphone64 darwinCommon;
crossIphone32 = mapTestOnCross systems.examples.iphone32 darwinCommon;
# Test some cross builds to ARMv5
armv5tel = mapTestOnCross systems.examples.armv5tel-multiplatform (
linuxCommon
// {
ubootSheevaplug = nativePlatforms;
}
);
# Test some cross builds on various mingw-w64 platforms
crossMingw32 = mapTestOnCross systems.examples.mingw-msvcrt-i686 windowsCommon;
cross-mingw-msvcrt-x86_64 = mapTestOnCross systems.examples.mingw-msvcrt-x86_64 windowsCommon;
cross-mingw-ucrt-x86_64 = mapTestOnCross systems.examples.mingw-ucrt-x86_64 windowsCommon;
cross-mingw-ucrt-x86_64-llvm = mapTestOnCross systems.examples.mingw-ucrt-x86_64-llvm windowsCommon;
cross-mingw-ucrt-aarch64 = mapTestOnCross systems.examples.mingw-ucrt-aarch64 windowsCommon;
x86_64-cygwin = mapTestOnCross systems.examples.x86_64-cygwin cygwinCommon;
# Linux on mipsel
fuloongminipc = mapTestOnCross systems.examples.fuloongminipc linuxCommon;
ben-nanonote = mapTestOnCross systems.examples.ben-nanonote linuxCommon;
# Javascript
ghcjs = mapTestOnCross systems.examples.ghcjs {
haskell.packages.native-bignum.ghcHEAD.hello = nativePlatforms;
haskellPackages.hello = nativePlatforms;
};
# Linux on Raspberrypi
rpi = mapTestOnCross systems.examples.raspberryPi rpiCommon;
rpi-musl = mapTestOnCross systems.examples.muslpi rpiCommon;
# Linux on the Remarkable
remarkable1 = mapTestOnCross systems.examples.remarkable1 linuxCommon;
remarkable2 = mapTestOnCross systems.examples.remarkable2 linuxCommon;
# Linux on armv7l-hf
armv7l-hf = mapTestOnCross systems.examples.armv7l-hf-multiplatform linuxCommon;
# Linux on aarch64
aarch64 = mapTestOnCross systems.examples.aarch64-multiplatform linuxCommon;
aarch64-musl = mapTestOnCross systems.examples.aarch64-multiplatform-musl linuxCommon;
# Linux on RISCV
riscv64 = mapTestOnCross systems.examples.riscv64 linuxCommon;
riscv32 = mapTestOnCross systems.examples.riscv32 linuxCommon;
# Linux on LoongArch
loongarch64-linux = mapTestOnCross systems.examples.loongarch64-linux linuxCommon;
m68k = mapTestOnCross systems.examples.m68k linuxCommon;
arc = mapTestOnCross systems.examples.arc linuxCommon;
s390x = mapTestOnCross systems.examples.s390x linuxCommon;
# (Cross-compiled) Linux on x86
x86_64-musl = mapTestOnCross systems.examples.musl64 linuxCommon;
x86_64-gnu = mapTestOnCross systems.examples.gnu64 linuxCommon;
i686-musl = mapTestOnCross systems.examples.musl32 linuxCommon;
i686-gnu = mapTestOnCross systems.examples.gnu32 linuxCommon;
# Linux on POWER
ppc64-elfv1 = mapTestOnCross systems.examples.ppc64-elfv1 linuxCommon;
ppc64-elfv2 = mapTestOnCross systems.examples.ppc64-elfv2 linuxCommon;
ppc64-musl = mapTestOnCross systems.examples.ppc64-musl linuxCommon;
ppc64le = mapTestOnCross systems.examples.powernv linuxCommon;
ppc64le-musl = mapTestOnCross systems.examples.musl-power linuxCommon;
android64 = mapTestOnCross systems.examples.aarch64-android-prebuilt linuxCommon;
android32 = mapTestOnCross systems.examples.armv7a-android-prebuilt linuxCommon;
wasi32 = mapTestOnCross systems.examples.wasi32 wasiCommon;
msp430 = mapTestOnCross systems.examples.msp430 embedded;
mmix = mapTestOnCross systems.examples.mmix embedded;
vc4 = mapTestOnCross systems.examples.vc4 embedded;
or1k = mapTestOnCross systems.examples.or1k embedded;
avr = mapTestOnCross systems.examples.avr embedded;
arm-embedded = mapTestOnCross systems.examples.arm-embedded embedded;
arm-embedded-nano = mapTestOnCross systems.examples.arm-embedded-nano embedded;
armhf-embedded = mapTestOnCross systems.examples.armhf-embedded embedded;
aarch64-embedded = mapTestOnCross systems.examples.aarch64-embedded embedded;
aarch64be-embedded = mapTestOnCross systems.examples.aarch64be-embedded embedded;
powerpc-embedded = mapTestOnCross systems.examples.ppc-embedded embedded;
powerpcle-embedded = mapTestOnCross systems.examples.ppcle-embedded embedded;
i686-embedded = mapTestOnCross systems.examples.i686-embedded embedded;
x86_64-embedded = mapTestOnCross systems.examples.x86_64-embedded embedded;
riscv64-embedded = mapTestOnCross systems.examples.riscv64-embedded embedded;
riscv32-embedded = mapTestOnCross systems.examples.riscv32-embedded embedded;
rx-embedded = mapTestOnCross systems.examples.rx-embedded embedded;
x86_64-freebsd = mapTestOnCross systems.examples.x86_64-freebsd common;
x86_64-netbsd = mapTestOnCross systems.examples.x86_64-netbsd common;
x86_64-openbsd = mapTestOnCross systems.examples.x86_64-openbsd common;
# Cross-built bootstrap tools for every supported platform
bootstrapTools =
let
linuxTools = import ../stdenv/linux/make-bootstrap-tools-cross.nix { system = "x86_64-linux"; };
freebsdTools = import ../stdenv/freebsd/make-bootstrap-tools-cross.nix { system = "x86_64-linux"; };
cygwinTools = import ../stdenv/cygwin/make-bootstrap-tools-cross.nix { system = "x86_64-linux"; };
linuxMeta = {
maintainers = [ ];
};
freebsdMeta = {
maintainers = [ maintainers.rhelmot ];
};
cygwinMeta = {
maintainers = [ maintainers.corngood ];
};
mkBootstrapToolsJob =
meta: drv:
assert elem drv.system supportedSystems;
hydraJob' (addMetaAttrs meta drv);
linux =
mapAttrsRecursiveCond (as: !isDerivation as) (name: mkBootstrapToolsJob linuxMeta)
# The `bootstrapTools.${platform}.bootstrapTools` derivation
# *unpacks* the bootstrap-files using their own `busybox` binary,
# so it will fail unless buildPlatform.canExecute hostPlatform.
# Unfortunately `bootstrapTools` also clobbers its own `system`
# attribute, so there is no way to detect this -- we must add it
# as a special case. We filter the "test" attribute (only from
# *cross*-built bootstrapTools) for the same reason.
(
mapAttrs (
_: v:
removeAttrs v [
"bootstrapTools"
"test"
]
) linuxTools
);
freebsd = mapAttrsRecursiveCond (as: !isDerivation as) (
name: mkBootstrapToolsJob freebsdMeta
) freebsdTools;
cygwin = mapAttrsRecursiveCond (as: !isDerivation as) (
name: mkBootstrapToolsJob cygwinMeta
) cygwinTools;
in
linux // freebsd // cygwin;
# Cross-built nixStatic for platforms for enabled-but-unsupported platforms
mips64el-nixCrossStatic = mapTestOnCross systems.examples.mips64el-linux-gnuabi64 nixCrossStatic;
powerpc64le-nixCrossStatic = mapTestOnCross systems.examples.powernv nixCrossStatic;
}
Reference in New Issue View Git Blame Copy Permalink