From f4e74c2c550aba12b9a69c649c9c4f1aad3e98dc Mon Sep 17 00:00:00 2001 From: Mikael Voss Date: Sun, 21 Jul 2024 16:55:31 +0200 Subject: [PATCH] Initial import --- .gitignore | 7 ++++ flake.lock | 27 ++++++++++++ flake.nix | 70 +++++++++++++++++++++++++++++++ module.nix | 34 +++++++++++++++ nixos.nix | 18 ++++++++ overlay.nix | 113 ++++++++++++++++++++++++++++++++++++++++++++++++++ platforms.nix | 23 ++++++++++ stdenv.nix | 56 +++++++++++++++++++++++++ 8 files changed, 348 insertions(+) create mode 100644 .gitignore create mode 100644 flake.lock create mode 100644 flake.nix create mode 100644 module.nix create mode 100644 nixos.nix create mode 100644 overlay.nix create mode 100644 platforms.nix create mode 100644 stdenv.nix diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a3d6222 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +# Hidden files +.* +!.git* + +# Nix +/result +/result-* diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..e46f50e --- /dev/null +++ b/flake.lock @@ -0,0 +1,27 @@ +{ + "nodes": { + "nixpkgs": { + "locked": { + "lastModified": 1722062969, + "narHash": "sha256-QOS0ykELUmPbrrUGmegAUlpmUFznDQeR4q7rFhl8eQg=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "b73c2221a46c13557b1b3be9c2070cc42cf01eb3", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "nixpkgs": "nixpkgs" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..2e7e437 --- /dev/null +++ b/flake.nix @@ -0,0 +1,70 @@ +{ + inputs = { + nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable"; + }; + + nixConfig = { + extra-substituters = [ "https://cache.kyouma.net" ]; + extra-trusted-public-keys = [ "cache.kyouma.net:Frjwu4q1rnwE/MnSTmX9yx86GNA/z3p/oElGvucLiZg=" ]; + }; + + outputs = { self, nixpkgs, ... }@inputs: + let + inherit (builtins) mapAttrs; + inherit (nixpkgs) lib; + + platforms = mapAttrs + (name: platform: lib.systems.elaborate platform) + (import ./platforms.nix); + in { + lib = { + inherit platforms; + replaceConfig = { + replaceStdenv = + { pkgs }: pkgs.idiosyn pkgs.stdenv; + replaceCrossStdenv = + { buildPackages, baseStdenv }: buildPackages.idiosyn baseStdenv; + }; + }; + overlays.default = import ./overlay.nix inputs; + + nixosModules.default = { ... }: { + nixpkgs = { + overlays = [ self.overlays.default ]; + config = self.lib.replaceConfig // { + allowUnsupportedSystem = true; + }; + }; + + imports = [ ./module.nix ]; + }; + + legacyPackages = mapAttrs (system: platform: + import nixpkgs { + localSystem = system; + crossSystem = platform; + overlays = [ self.overlays.default ]; + config = self.lib.replaceConfig // { + allowUnsupportedSystem = true; + }; + }) platforms; + + nixosConfigurations = mapAttrs (system: platform: lib.nixosSystem { + modules = [ + self.nixosModules.default + ./nixos.nix { + nixpkgs.buildPlatform = system; + nixpkgs.hostPlatform = platform; + } + ]; + }) platforms; + + hydraJobs = { + stdenv = mapAttrs (system: pkgs: pkgs.stdenv) self.legacyPackages; + nixos = mapAttrs (system: host: host.config.system.build.toplevel) self.nixosConfigurations; + pkgs = mapAttrs (system: pkgs: { + inherit (pkgs) rustc; + }) self.legacyPackages; + }; + }; +} diff --git a/module.nix b/module.nix new file mode 100644 index 0000000..28495a7 --- /dev/null +++ b/module.nix @@ -0,0 +1,34 @@ +{ config, lib, pkgs, modulesPath, ... }: +let + inherit (pkgs.stdenv) hostPlatform; + locale-archive-stub = + pkgs.stdenvNoCC.mkDerivation { + pname = "locale-archive-stub"; + version = "0"; + + buildCommand = '' + mkdir -p "$out/lib/locale" + touch "$out/lib/locale/locale-archive" + ''; + }; +in { + disabledModules = [ + (modulesPath + "/config/ldso.nix") + (modulesPath + "/config/stub-ld.nix") + (modulesPath + "/programs/nix-ld.nix") + ]; + + config = lib.mkMerge [ + (lib.mkIf hostPlatform.isMusl { + i18n.glibcLocales = lib.mkDefault locale-archive-stub; + i18n.supportedLocales = lib.mkDefault [ ]; + + programs.command-not-found.enable = lib.mkDefault false; + programs.less.lessopen = lib.mkDefault null; + + security.pam.services.login.updateWtmp = lib.mkForce false; + services.nscd.enable = lib.mkForce false; + system.nssModules = lib.mkForce [ ]; + }) + ]; +} diff --git a/nixos.nix b/nixos.nix new file mode 100644 index 0000000..1cfb7e6 --- /dev/null +++ b/nixos.nix @@ -0,0 +1,18 @@ +{ pkgs, ... }: { + boot.loader.systemd-boot.enable = true; + boot.loader.efi.canTouchEfiVariables = true; + + fileSystems."/".label = "nixos"; + + security.sudo.wheelNeedsPassword = false; + services.getty.autologinUser = "nixos"; + + users.users.nixos = { + isNormalUser = true; + extraGroups = [ "wheel" ]; + }; + + system.stateVersion = "24.11"; + + virtualisation.vmVariant.virtualisation.diskImage = null; +} diff --git a/overlay.nix b/overlay.nix new file mode 100644 index 0000000..d835c96 --- /dev/null +++ b/overlay.nix @@ -0,0 +1,113 @@ +{ nixpkgs, ... }: final: prev: +let + inherit (builtins) trace traceVerbose; + inherit (prev) lib fetchpatch; + inherit (final) hostPlatform addAttrsToDerivation; + inherit (lib.attrsets) optionalAttrs; + + inherit (lib.lists) + intersectLists + mutuallyExclusive + subtractLists + toList; + + pkgs = import nixpkgs { + inherit (final) overlays; + localSystem = final.buildPlatform; + crossSystem = final.hostPlatform; + config = removeAttrs final.config [ + "replaceStdenv" + "replaceCrossStdenv" + ]; + }; + + idiosyn = import ./stdenv.nix pkgs; + + pname = base: + if base ? pname + then "package ${base.pname}" + else "unknown package"; + + attrs = pkg: fun: pkg.overrideAttrs (base: + if base ? idiosynAttrGuard + then traceVerbose "Attribute override applied repeatedly on ${pname base}," { } + else { idiosynAttrGuard = null; } // (fun base)); + + patch = pkg: patches: attrs pkg (base: + if mutuallyExclusive (base.patches or [ ]) patches + then { patches = base.patches or [ ] ++ patches; } + else trace "Patches applied previously for ${pname base}: ${intersectLists base.patches patches}" { + patches = base.patches ++ subtractLists base.patches patches; + }); + + nocheck = pkg: attrs (base: { doCheck = false; }); + + alpine-patches = "https://git.alpinelinux.org/aports/plain"; + gentoo-patches = "https://gitweb.gentoo.org/repo/gentoo.git/plain"; +in optionalAttrs (!prev ? idiosyn) { + inherit idiosyn; + + buildPackages = prev.buildPackages // { + stdenv = final.stdenv; + }; + + busybox = prev.busybox.override { + stdenv = final.gccStdenv; + }; + + efivar = attrs prev.efivar (base: { + buildFlags = base.buildFlags or [ ] + ++ [ "CC=$(CC)" ]; + }); + + icu = attrs prev.icu (base: { + configureFlags = base.configureFlags or [ ] + ++ [ "ac_cv_c_bigendian=${if hostPlatform.isBigEndian then "yes" else "no"}" ]; + }); + + keyutils = attrs prev.keyutils (base: { + LDFLAGS = base.LDFLAGS or [ ] + ++ [ "-Wl,--undefined-version" ]; + }); + + kexec-tools = prev.kexec-tools.override { + stdenv = final.gccStdenv; + }; + + libgcrypt = attrs prev.libgcrypt (base: { + configureFlags = base.configureFlags or [ ] + ++ [ "--disable-jent-support" ]; + }); + + mbrola = prev.mbrola.override { + stdenv = addAttrsToDerivation (base: { + env = base.env or { } // { + NIX_CFLAGS_COMPILE = toString (toList base.env.NIX_CFLAGS_COMPILE or [ ] + ++ [ "-Wno-error=implicit-function-declaration" ]); + }; + }) final.stdenv; + }; + + musl = attrs prev.musl (base: { + LDFLAGS = base.LDFLAGS or [ ] + ++ [ "-Wl,-u,__dls2" ]; + }); + + python3 = prev.python3.override { + packageOverrides = py-final: py-prev: { + psutil = + if hostPlatform.isRiscV + then nocheck py-prev.psutil + else py-prev.psutil; + }; + }; + + python3Packages = final.python3.pkgs; + + time = patch prev.time [ + (fetchpatch { + url = "${gentoo-patches}/sys-process/time/files/time-1.9-implicit-func-decl-clang.patch"; + hash = "sha256-Asz8mWxVh4y3In5NU1dDV7nrJO+XlIhmKIvVFuPH8QE="; + }) + ]; +} diff --git a/platforms.nix b/platforms.nix new file mode 100644 index 0000000..4617846 --- /dev/null +++ b/platforms.nix @@ -0,0 +1,23 @@ +{ + "x86_64-linux" = { + system = "x86_64-linux"; + config = "x86_64-unknown-linux-musl"; + gcc.arch = "x86-64-v3"; + useLLVM = true; + linker = "lld"; + }; + "aarch64-linux" = { + system = "aarch64-linux"; + config = "aarch64-unknown-linux-musl"; + gcc.arch = "armv8.2-a"; + useLLVM = true; + linker = "lld"; + }; + "riscv64-linux" = { + system = "aarch64-linux"; + config = "riscv64-unknown-linux-musl"; + gcc.arch = "rv64imafdc_zicsr_zba_zbb"; + useLLVM = true; + linker = "lld"; + }; +} diff --git a/stdenv.nix b/stdenv.nix new file mode 100644 index 0000000..d085f99 --- /dev/null +++ b/stdenv.nix @@ -0,0 +1,56 @@ +pkgs: stdenv: +let + inherit (pkgs) addAttrsToDerivation mimalloc overrideCC; + inherit (pkgs.lib) getLib optionalAttrs optionals toList; + inherit (pkgs.llvmPackages_latest) clangUseLLVM bintools; + inherit (stdenv) hostPlatform targetPlatform; + + cflags = [ + "-pipe" # Prefer pipes over temporary files between stages + "-O2" # Safe compiler optimisations + "-flto" + ]; + + ldflags = [ + "-O2" # Enable tail merging of strings + "--hash-style=gnu" # Produce only DT_GNU_HASH + "--icf=safe" # Fold identical code where safe + "--lto-O2" + + "-L${getLib mimalloc}/lib" "-lmimalloc" + ]; + + rustflags = [ + "-C opt-level=2" + "-C linker-flavor=lld" + "-C lto" + "-C linker-plugin-lto" + ] ++ optionals (targetPlatform.isx86_64 && targetPlatform ? gcc.arch) [ + "-C target-cpu=${targetPlatform.gcc.arch}" + ] ++ map (flag: "-C link-arg=${flag}") ldflags; + + pname = base: + if base ? pname + then "package ${base.pname}" + else "unknown package"; + +in addAttrsToDerivation (base: + if base ? idiosynStdenvGuard + then builtins.traceVerbose "stdenv override applied repeatedly for ${pname base}," { } + else { + idiosynStdenvGuard = null; + + env = (base.env or { }) // optionalAttrs (!base ? NIX_CFLAGS_COMPILE) { + NIX_CFLAGS_COMPILE = + toString (toList base.env.NIX_CFLAGS_COMPILE or [ ] ++ cflags); + } // optionalAttrs (base ? env.NIX_LDFLAGS) { + NIX_LDFLAGS = + toString (toList base.env.NIX_LDFLAGS or [ ] ++ ldflags); + }; + + NIX_RUSTFLAGS = toList base.NIX_RUSTFLAGS or [ ] ++ rustflags; + } // optionalAttrs (base ? env.NIX_CFLAGS) { + NIX_CFLAGS_COMPILE = toList base.NIX_CFLAGS_COMPILE or [ ] ++ cflags; + } // optionalAttrs (!base ? env.NIX_LDFLAGS) { + NIX_LDFLAGS = toList base.NIX_LDFLAGS or [ ] ++ ldflags; + }) (overrideCC stdenv (clangUseLLVM.override { inherit bintools; }))