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;
          }));

      nixpkgsFor = forAllSystems ({ system, localSystem, crossSystem }:
        if localSystem == crossSystem then
          import nixpkgs {
            inherit system;
            overlays = [ self.overlay nimble.overlay ];
          }
        else
          import nixpkgs {
            inherit localSystem;
            crossSystem = {
              system = crossSystem;
              useLLVM = true;
            };
            config.allowUnsupportedSystem = true;
            overlays = [ self.overlay nimble.overlay ];
          });

    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;

                  };

                })
              ];
            });

        });

      legacyPackages =
        # The nixpkgs.legacyPackages after overlaying
        # and with some additional Genode packages
        forAllSystems
        ({ system, localSystem, crossSystem }: nixpkgsFor.${system});
      # pass thru Nixpkgs

      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)
          nixpkgsFor.${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 = nixpkgsFor.${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;

    };
}