sigil/flake.nix

{
  description = "Genode packages";

  inputs.nixpkgs.url = "github:ehmry/nixpkgs/genodepkgs";

  outputs = { self, nixpkgs, nimble }:
    let
      systems = {
        localSystem = [ "x86_64-linux" ];
        crossSystem = [ "aarch64-genode" "x86_64-genode" ];
      };
      systemSpace = nixpkgs.lib.cartesianProductOfSets systems;

      forAllLocalSystems = f:
        nixpkgs.lib.genAttrs systems.localSystem (system: f system);

      forAllCrossSystems = f:
        with builtins;
        let
          f' = { localSystem, crossSystem }:
            let system = localSystem + "-" + crossSystem;
            in {
              name = system;
              value = f { inherit system localSystem crossSystem; };
            };
          list = map f' systemSpace;
          attrSet = listToAttrs list;
        in attrSet;

      forAllSystems = f:
        (forAllCrossSystems f) // (forAllLocalSystems (system:
          f {
            inherit system;
            localSystem = system;
            crossSystem = system;
          }));

    in rec {

      overlay =
        # Overlay of fixes applied to Nixpkgs
        import ./overlay { flake = self; };

      lib =
        # Local utilities merged with the Nixpkgs lib
        nixpkgs.lib.extend (final: prev: {
          inherit forAllSystems forAllLocalSystems forAllCrossSystems;

          /* For a the name of a derivation output and a derivation,
             generate a set of { cap, closure, and path } for a singular
             file found within the subdirectory of the output with the
             same name as that output. In the case that the derivation
             does not have this named output, the subdirectory will be
             taken from the default output. This subdirectory must
             contain a single file, and the output must contain an
             ERIS manifest file.
          */
          getEris = output: pkg:
            with builtins;
            let
              pkg' = prev.getOutput output pkg;
              erisInfo =
                fromJSON (readFile "${pkg'}/nix-support/eris-manifest.json");
              caps = filter
                ({ path, ... }: prev.strings.hasPrefix "${pkg'}/${output}" path)
                (prev.attrsets.mapAttrsToList (path:
                  { cap, closure }: {
                    path = "${pkg'}${
                        substring (stringLength pkg') (stringLength path) path
                      }"; # hack to build a string with context
                    inherit cap closure;
                  }) erisInfo);
            in assert length caps == 1; head caps;

          nixosSystem = { modules, ... }@args:
            import "${nixpkgs}/nixos/lib/eval-config.nix" (args // {
              lib = final;

              baseModules =
                # TODO: do not blacklist modules for the Linux guests
                with builtins;
                let
                  isNotModule = suffix:
                    let x = "${nixpkgs}/nixos/modules/${suffix}";
                    in y: x != y;

                  filters = map isNotModule
                    (import ./nixos-modules/base-modules-blacklist.nix);

                  isCompatible = p:
                    let p' = toString p;
                    in all (f: f p') filters;

                in filter isCompatible
                (import "${nixpkgs}/nixos/modules/module-list.nix");

              modules = modules ++ [
                ({ config, lib, ... }: {
                  options = with lib; {

                    system.boot.loader.id = mkOption {
                      internal = true;
                      default = "";
                    };

                    system.boot.loader.kernelFile = mkOption {
                      internal = true;
                      default = pkgs.stdenv.hostPlatform.platform.kernelTarget;
                      type = types.str;
                    };

                    system.boot.loader.initrdFile = mkOption {
                      internal = true;
                      default = "initrd";
                      type = types.str;
                    };

                    systemd.defaultUnit = mkOption {
                      default = "multi-user.target";
                      type = types.str;
                    };

                  };
                  config = {

                    boot.loader.grub.enable = lib.mkDefault false;

                    fileSystems."/" = { };

                    networking.enableIPv6 = lib.mkForce false;
                    systemd.network.enable = lib.mkForce false;

                    system.nixos.versionSuffix = ".${
                        final.substring 0 8
                        (self.lastModifiedDate or self.lastModified or "19700101")
                      }.${self.shortRev or "dirty"}";

                    system.nixos.revision = final.mkIf (self ? rev) self.rev;

                    system.build.toplevel = config.system.build.initXml;

                  };

                })
              ];
            });

        });

      /* The nixpkgs.legacyPackages after overlaying
         and with some additional Genode packages.
      */
      legacyPackages = let f = import nixpkgs;
      in forAllSystems ({ system, localSystem, crossSystem }:
        if localSystem == crossSystem then
          f {
            inherit system;
            overlays = [ self.overlay nimble.overlay ];
          }
        else
          f {
            inherit localSystem;
            crossSystem = {
              system = crossSystem;
              useLLVM = true;
            };
            config.allowUnsupportedSystem = true;
            overlays = [ self.overlay nimble.overlay ];
          });

      packages =
        # Genode native packages, not packages in the traditional
        # sense in that these cannot be installed within a profile
        forAllCrossSystems ({ system, localSystem, crossSystem }:
          nixpkgs.lib.filterAttrs (n: v: v != null)
          self.legacyPackages.${system}.genodePackages);

      devShell =
        # Development shell for working with the
        # upstream Genode source repositories
        forAllLocalSystems (system:
          let
            pkgs = nixpkgs.legacyPackages.${system};
            fhs = pkgs.buildFHSUserEnv {
              name = "genode-env";
              targetPkgs = pkgs:
                (with pkgs; [
                  binutils
                  bison
                  expect
                  flex
                  git
                  glibc.dev
                  gnumake
                  libxml2
                  qemu
                  rpcsvc-proto
                  subversion
                  tcl
                  wget
                  which
                  xorriso
                ]);
              runScript = "bash";
              extraBuildCommands = let
                toolchain = pkgs.fetchzip {
                  url =
                    "file://${packages.x86_64-linux-x86_64-genode.genodeSources.toolchain.src}";
                  hash = "sha256-26rPvLUPEJm40zLSqTquwuFTJ1idTB0T4VXgaHRN+4o=";
                };
              in "ln -s ${toolchain}/local usr/local";
            };
          in pkgs.stdenv.mkDerivation {
            name = "genode-fhs-shell";
            nativeBuildInputs = [ fhs ];
            shellHook = "exec genode-env";
          });

      nixosModules =
        # Modules for composing Genode and NixOS
        import ./nixos-modules { flake = self; };

      checks =
        # Checks for continous testing
        let tests = import ./tests;
        in with (forAllCrossSystems ({ system, localSystem, crossSystem }:
          tests {
            flake = self;
            inherit system localSystem crossSystem;
            pkgs = self.legacyPackages.${system};
          } // {
            ports = self.legacyPackages.${localSystem}.symlinkJoin {
              name = "ports";
              paths = (builtins.attrValues
                self.packages.${system}.genodeSources.ports);
            };
          })); {
            x86_64-linux = x86_64-linux-aarch64-genode
              // x86_64-linux-x86_64-genode;
          };

      hydraJobs = self.checks;

    };
}