fix 1 to 4

README.org

@@ -1,18 +1,25 @@
-* Install NixOS with ZFS as root filesystem
-This repo contains a minimal set of configuration for installing
-NixOS, using ZFS as root filesystem.
+* Minimal installer for NixOS using ZFS encrypted root
+This repo contains a minimal set of configuration needed for
+installing NixOS on a computer with ZFS as root filesystem.
 
-ZFS is a modern filesystem with many features such as snapshot,
-self-healing and pooled storage, see [[https://openzfs.org/wiki/Main_Page#Introduction_to_OpenZFS][Introduction]] for details.
+#+begin_src text
+.gitignore
+LICENSE
+configuration.nix   <- configuration shared by all hosts
+flake.lock
+flake.nix
+hosts/nixos/default.nix  <- per-host configuration
+hosts/nixos/sshUnlock.txt
+modules/boot/default.nix
+modules/default.nix
+modules/fileSystems/default.nix
+modules/networking/default.nix
+modules/users/default.nix
+#+end_src text
 
-For using this repo on your computer, see [[https://openzfs.github.io/openzfs-docs/Getting%20Started/NixOS/Root%20on%20ZFS.html][Documentation]].
+* Thanks to
+See [[https://github.com/ne9z/personal-dotfiles][ne9z dotfiles repo]] for an example of how to configure
+servers and desktop computers in the same git repository, based on
+this template repo you are viewing now.
 
-Upon initial installation, only the bootloader, mountpoints and root
-password are configured.
-
-- Refer to =man configuration.nix= for available options;
-- Search for available packages with [[https://search.nixos.org/packages][Package Search]];
-- Search for options with [[https://search.nixos.org/options][Option Search]].
-
-[[https://codeberg.org/m0p/dotfiles][My personal dotfiles repo]] contains an example of desktop configuration
-based on sway, tmux and Emacs.
+[[https://openzfs.github.io/openzfs-docs/Getting%20Started/NixOS/Root%20on%20ZFS.html][Official Tutorial]]

configuration.nix

@@ -1,8 +1,16 @@
-# configuration in this file is shared by all hosts
+{ my-config, zfs-root, inputs, pkgs, lib, ... }: {
+  # load module config to top-level configuration
+  inherit my-config zfs-root;
+
+  # Let 'nixos-version --json' know about the Git revision
+  # of this flake.
+  system.configurationRevision = if (inputs.self ? rev) then
+    inputs.self.rev
+  else
+    throw "refuse to build: git tree is dirty";
+
+  system.stateVersion = "22.11";
 
-{ pkgs, pkgs-unstable, inputs, ... }:
-let inherit (inputs) self;
-in {
   # Enable NetworkManager for wireless networking,
   # You can configure networking with "nmtui" command.
   networking.useDHCP = true;
@@ -15,48 +23,31 @@ in {
     };
   };
 
-  ## enable GNOME desktop.
-  ## You need to configure a normal, non-root user.
-  # services.xserver = {
-  #  enable = true;
-  #  desktopManager.gnome.enable = true;
-  #  displayManager.gdm.enable = true;
-  # };
-
-  ## enable ZFS auto snapshot on datasets
-  ## You need to set the auto snapshot property to "true"
-  ## on datasets for this to work, such as
-  # zfs set com.sun:auto-snapshot=true rpool/nixos/home
-  services.zfs = {
-    autoSnapshot = {
-      enable = false;
-      flags = "-k -p --utc";
-      monthly = 48;
-    };
-  };
-
   programs.neovim = {
     enable = true;
     viAlias = true;
     vimAlias = true;
   };
 
+  imports = [
+    "${inputs.nixpkgs}/nixos/modules/installer/scan/not-detected.nix"
+    # "${inputs.nixpkgs}/nixos/modules/profiles/qemu-guest.nix"
+  ];
+
   services.openssh = {
-    enable = true;
-    settings = { PasswordAuthentication = false; };
+    enable = lib.mkDefault true;
+    settings = { PasswordAuthentication = lib.mkDefault false; };
   };
 
-  boot.zfs.forceImportRoot = false;
+  boot.zfs.forceImportRoot = lib.mkDefault false;
 
-  nix.settings.experimental-features = [ "nix-command" "flakes" ];
-
-  boot.initrd.systemd.enable = true;
+  nix.settings.experimental-features = lib.mkDefault [ "nix-command" "flakes" ];
 
   programs.git.enable = true;
 
   security = {
-    doas.enable = true;
-    sudo.enable = false;
+    doas.enable = lib.mkDefault true;
+    sudo.enable = lib.mkDefault false;
   };
 
   environment.systemPackages = builtins.attrValues {
@@ -64,27 +55,5 @@ in {
       mg # emacs-like editor
       jq # other programs
     ;
-    # By default, the system will only use packages from the
-    # stable channel. i.e.
-    # inherit (pkg) my-favorite-stable-package;
-    # You can selectively install packages
-    # from the unstable channel. Such as
-    # inherit (pkgs-unstable) my-favorite-unstable-package;
-    # You can also add more
-    # channels to pin package version.
   };
-
-  # Safety mechanism: refuse to build unless everything is
-  # tracked by git
-  system.configurationRevision = if (self ? rev) then
-    self.rev
-  else
-    throw "refuse to build: git tree is dirty";
-
-  system.stateVersion = "23.05";
-
-  # let nix commands follow system nixpkgs revision
-  nix.registry.nixpkgs.flake = inputs.nixpkgs;
-  # you can then test any package in a nix shell, such as
-  # $ nix shell nixpkgs#neovim
 }

flake.lock

@@ -1,61 +1,24 @@
 {
   "nodes": {
-    "home-manager": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1695108154,
-        "narHash": "sha256-gSg7UTVtls2yO9lKtP0yb66XBHT1Fx5qZSZbGMpSn2c=",
-        "owner": "nix-community",
-        "repo": "home-manager",
-        "rev": "07682fff75d41f18327a871088d20af2710d4744",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "ref": "release-23.05",
-        "repo": "home-manager",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1696983906,
-        "narHash": "sha256-L7GyeErguS7Pg4h8nK0wGlcUTbfUMDu+HMf1UcyP72k=",
-        "owner": "NixOS",
+        "lastModified": 1685533922,
+        "narHash": "sha256-y4FCQpYafMQ42l1V+NUrMel9RtFtZo59PzdzflKR/lo=",
+        "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "bd1cde45c77891214131cbbea5b1203e485a9d51",
+        "rev": "3a70dd92993182f8e514700ccf5b1ae9fc8a3b8d",
         "type": "github"
       },
       "original": {
-        "id": "nixpkgs",
+        "owner": "nixos",
         "ref": "nixos-23.05",
-        "type": "indirect"
-      }
-    },
-    "nixpkgs-unstable": {
-      "locked": {
-        "lastModified": 1697349934,
-        "narHash": "sha256-mSOXTIvCMA31nD/XEYmeSOebrXl0lFKirM14LK845e4=",
-        "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f320b0d46ee33f521f50d7c6885605714210e5c9",
         "type": "github"
-      },
-      "original": {
-        "id": "nixpkgs",
-        "ref": "master",
-        "type": "indirect"
       }
     },
     "root": {
       "inputs": {
-        "home-manager": "home-manager",
-        "nixpkgs": "nixpkgs",
-        "nixpkgs-unstable": "nixpkgs-unstable"
+        "nixpkgs": "nixpkgs"
       }
     }
   },

flake.nix

@@ -1,61 +1,27 @@
 {
-  description = "Barebones NixOS on ZFS config";
+  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-23.05";
+  ## after reboot, you can track rolling release by using
+  #inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
 
-  inputs = {
-    nixpkgs.url = "nixpkgs/nixos-23.05";
-    nixpkgs-unstable.url = "nixpkgs/master";
-    home-manager = {
-      url = "github:nix-community/home-manager/release-23.05";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-
-  outputs = { self, nixpkgs, nixpkgs-unstable, home-manager }@inputs:
+  outputs = { self, nixpkgs }@inputs:
     let
-      mkHost = hostName: system:
-        nixpkgs.lib.nixosSystem {
-          pkgs = import nixpkgs {
-            inherit system;
-            # settings to nixpkgs goes to here
-            # nixpkgs.pkgs.zathura.useMupdf = true;
-            # nixpkgs.config.allowUnfree = false;
-          };
-
-          specialArgs = {
-            # By default, the system will only use packages from the
-            # stable channel.  You can selectively install packages
-            # from the unstable channel.  You can also add more
-            # channels to pin package version.
-            pkgs-unstable = import nixpkgs-unstable {
-              inherit system;
-              # settings to nixpkgs-unstable goes to here
-            };
-
-            # make all inputs availabe in other nix files
-            inherit inputs;
-          };
-
+      lib = nixpkgs.lib;
+      mkHost = { my-config, zfs-root, pkgs, system, ... }:
+        lib.nixosSystem {
+          inherit system;
           modules = [
-            # Root on ZFS related configuration
             ./modules
-
-            # Configuration shared by all hosts
-            ./configuration.nix
-
-            # Configuration per host
-            ./hosts/${hostName}
-
-            # home-manager
-            home-manager.nixosModules.home-manager
-            {
-              home-manager.useGlobalPkgs = true;
-              home-manager.useUserPackages = true;
-            }
+            (import ./configuration.nix {
+              inherit my-config zfs-root inputs pkgs lib;
+            })
           ];
         };
     in {
       nixosConfigurations = {
-        exampleHost = mkHost "exampleHost" "x86_64-linux";
+        nixos = let
+          system = "x86_64-linux";
+          pkgs = nixpkgs.legacyPackages.${system};
+        in mkHost (import ./hosts/nixos { inherit system pkgs; });
       };
     };
 }

hosts/exampleHost/changeHostName.txt

@@ -1,39 +0,0 @@
-How to set hostname for a host.
-
-You need to change the host name in three different places.
-
-Place 1.
-
-./flake.nix
-
-Change
-
-    exampleHost = mkHost "exampleHost" "x86_64-linux";
-
-to
-
-    myHost = mkHost "myHost" "x86_64-linux";
-
-Place 2.
-
-Move directory
-
-    ./hosts/exampleHost
-
-to
-
-    ./hosts/myHost
-
-Place 3.
-
-./hosts/exampleHost/default.nix
-
-Change
-
-  networking.hostName = "exampleHost";
-
-to
-
-  networking.hostName = "myHost";
-
-End.

hosts/exampleHost/default.nix

@@ -1,24 +0,0 @@
-{ config, pkgs, lib, inputs, modulesPath, ... }: {
-  zfs-root = {
-    boot = {
-      devNodes = "/dev/disk/by-id/";
-      bootDevices = [ "bootDevices_placeholder" ];
-      immutable.enable = false;
-      removableEfi = true;
-      luks.enable = false;
-    };
-  };
-  boot.initrd.availableKernelModules = [ "kernelModules_placeholder" ];
-  boot.kernelParams = [ ];
-  networking.hostId = "abcd1234";
-  # read changeHostName.txt file.
-  networking.hostName = "exampleHost";
-  time.timeZone = "Europe/Berlin";
-
-  # import preconfigured profiles
-  imports = [
-    (modulesPath + "/installer/scan/not-detected.nix")
-    # (modulesPath + "/profiles/hardened.nix")
-    # (modulesPath + "/profiles/qemu-guest.nix")
-  ];
-}

hosts/nixos/changeHostName.txt

@@ -0,0 +1,45 @@
+How to set hostname for a host.
+
+This repo is structured in a way that allows managing multiple hosts
+in a single repo.  As a consequence of this, hostname appears in
+several different places and should be updated together if needed.
+
+The entry point of this repo is ``flake.nix'' file, which takes a
+revision of the nixpkgs as input then gives an attribute set (attrset)
+as output:
+
+  {
+    nixosConfigurations = {
+      exampleHost = { ... };
+      host2 = { ... };
+      host3 = { ... };
+      ...
+    };
+  }
+
+
+The hostname specified here inside nixosConfigurations attrset is used
+when ``nix command'' is invoked, as in
+
+  nixos-install --flake ./#exampleHost
+
+The hostname also appears in the filesystem path of the per-host
+configuration file:
+
+  hosts/exampleHost/default.nix
+  hosts/host2/default.nix
+  ...
+
+Finally, the hostname is specified in the zfs-boot.networking.hostName
+option inside per-host configuration file at
+hosts/exampleHost/default.nix:
+
+  zfs-boot.networking.hostName = "exampleHost";
+
+If the value of this option is identical to the name of
+nixosConfigurations.<hostname> attrset, all subsequent invocations of
+``nix command'' will default to this hostname, i.e. the command:
+
+  nixos-rebuild boot
+
+will automatically append ``#hostName'' when evaluating the flake.

hosts/nixos/default.nix

@@ -0,0 +1,37 @@
+# #
+##
+##  per-host configuration for nixos host
+##
+##
+
+{ system, pkgs, ... }: {
+  inherit pkgs system;
+  zfs-root = {
+    boot = {
+      devNodes = "/dev/disk/by-id/";
+      bootDevices = [ "bootDevices_placeholder" ];
+      immutable = false;
+      availableKernelModules = [ "kernelModules_placeholder" ];
+      removableEfi = true;
+      kernelParams = [ ];
+      sshUnlock = {
+        # read sshUnlock.txt file.
+        enable = false;
+        authorizedKeys = [ ];
+      };
+    };
+    networking = {
+      # read changeHostName.txt file.
+      hostName = "nixos";
+      timeZone = "Europe/Paris";
+      hostId = "abcd1234";
+    };
+  };
+
+  # To add more options to per-host configuration, you can create a
+  # custom configuration module, then add it here.
+  my-config = {
+    # Enable custom gnome desktop on exampleHost
+    template.desktop.gnome.enable = false;
+  };
+}

hosts/nixos/sshUnlock.txt

@@ -0,0 +1,61 @@
+Audience
+
+This text is intended for users who wish to remotely unlock their
+natively encrypted ZFS root filesystem with SSH during the early
+stages of system boot up.
+
+=================================================================
+
+Steps
+
+By default, the initial RAM disk image, (hereafter refered to as
+initrd) only includes essential kernel modules needed for mounting the
+root filesystem.
+
+To enable network connection during this stage of system boot, you
+need to instruct NixOS to include kernel modules needed for the
+network adapter.
+
+Check which module is needed with:
+
+  nix-shell -p pciutils --run "lspci -v | grep -iA8 'network\|ethernet'"
+
+Then, add the the modules to
+
+  zfs-root.boot.availableKernelModules
+
+option inside the per-host configuration file.  This file is located
+at hosts/exampleHost/default.nix.
+
+By default, initrd uses DHCP auto-configuration for networking.  If
+you need to specify a static IP address, see the documentation for
+"ip=" kernel command line option for NFS root:
+
+  https://www.kernel.org/doc/Documentation/filesystems/nfs/nfsroot.txt
+
+Then, add the necessary kernel command line options to
+
+  zfs-root.boot.kernelParams
+
+option inside the per-host configuration file.
+
+Finally, you need to generate a pair of SSH private keys exclusively
+for use with decrypting the root filesystem during boot.  This pair of
+keys should not be used anywhere else.  Reasons for this can be found
+in the documentation NixOS option:
+
+  boot.initrd.network.ssh.hostKeys
+
+> Do NOT use your regular SSH host private keys for this purpose or
+> you'll expose them to regular users! Additionally, even if your initrd
+> supports secrets, if you're using initrd SSH to unlock an encrypted
+> disk then using your regular host keys exposes the private keys on
+> your unencrypted boot partition.
+
+You can generate host key with:
+
+  ssh-keygen -t ed25519 -N "" -f "/var/lib/ssh_unlock_zfs_ed25519_key"
+  ssh-keygen -t rsa -N "" -f "/var/lib/ssh_unlock_zfs_rsa_key"
+
+If you are performing a system installation, change path from
+/var/lib to /mnt/var/lib in both commands.

install.sh

@@ -0,0 +1,251 @@
+#!/bin/env bash
+
+lsblk
+echo ""
+
+read -p "disk: " DISK
+read -p "swapsize GiB: " SWAPSIZEGIB
+read -p "reserve GiB: " RESERVEGIB
+read -sp "password: " POOLPASS
+
+EMAIL="marc@marcpartensky.com"
+NAME="Marc Partensky"
+
+RESERVE=$((RESERVEGIB * 1024))
+SWAPSIZE=$((SWAPSIZEGIB * 1024))
+
+
+MNT=$(mktemp -d)
+
+log() { echo -e "\n\033[1m${@}\033[0m"; }
+
+log Destroying zfs pool rpool and bpool just in case
+swapoff -a
+zpool import -fa
+for i in ${DISK}; do
+   zpool labelclear -f $i
+done
+zpool destroy -f bpool
+zpool destroy -f rpool
+zpool export -a
+
+log Unmounting filesystems just in case
+# ---
+umount -Rl "${MNT}"
+
+log Enabling Nix Flakes functionality
+# ---
+mkdir -p ~/.config/nix
+echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
+
+
+log Installing programs needed for system installation
+# ---
+if ! command -v git; then nix-env -f '<nixpkgs>' -iA git; fi
+if ! command -v jq;  then nix-env -f '<nixpkgs>' -iA jq; fi
+if ! command -v partprobe;  then nix-env -f '<nixpkgs>' -iA parted; fi
+
+
+log Partition the disks
+# ---
+partition_disk () {
+ local disk="${1}"
+ blkdiscard -f "${disk}" || true
+
+ parted --script --align=optimal  "${disk}" -- \
+     mklabel gpt \
+     mkpart swap  1MiB $((SWAPSIZE + 1))MiB \
+     mkpart rpool $((SWAPSIZE + 1))MiB -$((RESERVE + 100))MiB \
+     mkpart bpool -$((RESERVE + 100))MiB -$((RESERVE + 3))MiB \
+     mkpart EFI -$((RESERVE + 3))MiB -$((RESERVE + 2))MiB \
+     mkpart BIOS -$((RESERVE + 2))MiB -$((RESERVE + 1))MiB \
+     set 4 esp on \
+     set 5 bios_grub on \
+     set 5 legacy_boot on
+
+ partprobe "${disk}"
+ udevadm settle
+}
+
+for i in ${DISK}; do
+   partition_disk "${i}"
+done
+
+
+log Creating boot pool
+# ---
+# shellcheck disable=SC2046
+zpool create \
+    -o compatibility=grub2 \
+    -o ashift=12 \
+    -o autotrim=on \
+    -O acltype=posixacl \
+    -O canmount=off \
+    -O compression=lz4 \
+    -O devices=off \
+    -O normalization=formD \
+    -O relatime=on \
+    -O xattr=sa \
+    -O mountpoint=/boot \
+    -R "${MNT}" \
+    bpool \
+    $(for i in ${DISK}; do
+       printf '%s ' "${i}3";
+      done)
+
+
+log Creating root pool
+# ---
+# shellcheck disable=SC2046
+echo $POOLPASS | zpool create \
+    -o ashift=12 \
+    -o autotrim=on \
+    -R "${MNT}" \
+    -O acltype=posixacl \
+    -O canmount=off \
+    -O compression=zstd \
+    -O dnodesize=auto \
+    -O normalization=formD \
+    -O relatime=on \
+    -O xattr=sa \
+    -O mountpoint=/ \
+    -o feature@encryption=enabled \
+    -O encryption=on \
+    -O keyformat=passphrase \
+    rpool \
+   $(for i in ${DISK}; do
+      printf '%s ' "${i}2";
+     done)
+
+
+log Creating encrypted root system container
+# ---
+echo $POOLPASS | zfs create \
+    -o canmount=off \
+    -o mountpoint=none \
+    -o encryption=on \
+    -o keylocation=prompt \
+    -o keyformat=passphrase \
+    rpool/nixos
+
+
+log Creating system datasets, managing mountpoints with mountpoint=legacy
+# ---
+zfs create -o mountpoint=legacy     rpool/nixos/root
+mount -t zfs rpool/nixos/root "${MNT}"/
+zfs create -o mountpoint=legacy rpool/nixos/home
+mkdir "${MNT}"/home
+mount -t zfs rpool/nixos/home "${MNT}"/home
+zfs create -o mountpoint=legacy  rpool/nixos/var
+zfs create -o mountpoint=legacy rpool/nixos/var/lib
+zfs create -o mountpoint=legacy rpool/nixos/var/log
+zfs create -o mountpoint=none bpool/nixos
+zfs create -o mountpoint=legacy bpool/nixos/root
+mkdir "${MNT}"/boot
+mount -t zfs bpool/nixos/root "${MNT}"/boot
+mkdir -p "${MNT}"/var/log
+mkdir -p "${MNT}"/var/lib
+mount -t zfs rpool/nixos/var/lib "${MNT}"/var/lib
+mount -t zfs rpool/nixos/var/log "${MNT}"/var/log
+zfs create -o mountpoint=legacy rpool/nixos/empty
+zfs snapshot rpool/nixos/empty@start
+
+
+log Formatting and mounting ESP
+# ---
+for i in ${DISK}; do
+ mkfs.vfat -n EFI "${i}"4
+ mkdir -p "${MNT}"/boot/efis/"${i##*/}"4
+ mount -t vfat -o iocharset=iso8859-1 "${i}"4 "${MNT}"/boot/efis/"${i##*/}"4
+done
+
+
+log Cloning template flake configuration
+# ---
+mkdir -p "${MNT}"/etc
+git clone --depth 1 --branch custom \
+  https://github.com/marcpartensky/dotfiles-flake.git "${MNT}"/etc/nixos
+
+rm -rf "${MNT}"/etc/nixos/.git
+git -C "${MNT}"/etc/nixos/ init -b master
+git -C "${MNT}"/etc/nixos/ add "${MNT}"/etc/nixos/
+git -C "${MNT}"/etc/nixos config user.email $EMAIL
+git -C "${MNT}"/etc/nixos config user.name $NAME
+git -C "${MNT}"/etc/nixos commit -asm 'initial commit'
+
+
+log Customizing configuration to your hardware
+# ---
+for i in ${DISK}; do
+  sed -i \
+  "s|/dev/disk/by-id/|${i%/*}/|" \
+  "${MNT}"/etc/nixos/hosts/nixos/default.nix
+  break
+done
+
+diskNames=""
+for i in ${DISK}; do
+  diskNames="${diskNames} \"${i##*/}\""
+done
+
+sed -i "s|\"bootDevices_placeholder\"|${diskNames}|g" \
+  "${MNT}"/etc/nixos/hosts/nixos/default.nix
+
+sed -i "s|\"abcd1234\"|\"$(head -c4 /dev/urandom | od -A none -t x4| sed 's| ||g' || true)\"|g" \
+  "${MNT}"/etc/nixos/hosts/nixos/default.nix
+
+sed -i "s|\"x86_64-linux\"|\"$(uname -m || true)-linux\"|g" \
+  "${MNT}"/etc/nixos/flake.nix
+
+cp "$(command -v nixos-generate-config || true)" ./nixos-generate-config
+
+chmod a+rw ./nixos-generate-config
+
+# shellcheck disable=SC2016
+echo 'print STDOUT $initrdAvailableKernelModules' >> ./nixos-generate-config
+
+kernelModules="$(./nixos-generate-config --show-hardware-config --no-filesystems | tail -n1 || true)"
+
+sed -i "s|\"kernelModules_placeholder\"|${kernelModules}|g" \
+  "${MNT}"/etc/nixos/hosts/nixos/default.nix
+
+log Setting root password
+# ---
+rootPwd=$(mkpasswd -m SHA-512)
+sed -i \
+"s|rootHash_placeholder|${rootPwd}|" \
+"${MNT}"/etc/nixos/configuration.nix
+
+
+log Commiting changes to local repo
+# ---
+git -C "${MNT}"/etc/nixos commit -asm 'initial installation'
+
+log Updating flake lock file to track latest system version
+# ---
+nix flake update --commit-lock-file \
+  "git+file://${MNT}/etc/nixos"
+
+log Installing system and apply configuration
+# ---
+nixos-install \
+--root "${MNT}" \
+--no-root-passwd \
+--flake "git+file://${MNT}/etc/nixos#nixos"
+
+
+log Setuping encrypted swap. This is useful if the available memory is small
+# ---
+for i in ${DISK}; do
+   cryptsetup open --type plain --key-file /dev/random "${i}"1 "${i##*/}"1
+   mkswap /dev/mapper/"${i##*/}"1
+   swapon /dev/mapper/"${i##*/}"1
+done
+
+log Unmounting filesystems
+# ---
+umount -Rl "${MNT}"
+zpool export -a
+
+
+log The installation is done, enjoy

modules/boot/default.nix

@@ -11,11 +11,6 @@ in {
       type = types.bool;
       default = true;
     };
-    luks.enable = mkOption {
-      description = "Use luks encryption";
-      type = types.bool;
-      default = false;
-    };
     devNodes = mkOption {
       description = "Specify where to discover ZFS pools";
       type = types.str;
@@ -29,7 +24,15 @@ in {
       description = "Specify boot devices";
       type = types.nonEmptyListOf types.str;
     };
-    immutable.enable = mkOption {
+    availableKernelModules = mkOption {
+      type = types.nonEmptyListOf types.str;
+      default = [ "uas" "nvme" "ahci" ];
+    };
+    kernelParams = mkOption {
+      type = types.listOf types.str;
+      default = [ ];
+    };
+    immutable = mkOption {
       description = "Enable root on ZFS immutable root support";
       type = types.bool;
       default = false;
@@ -41,61 +44,56 @@ in {
     };
     partitionScheme = mkOption {
       default = {
-        biosBoot = "-part5";
-        efiBoot = "-part1";
-        swap = "-part4";
-        bootPool = "-part2";
-        rootPool = "-part3";
+        swap = "1";
+        rootPool = "2";
+        bootPool = "3";
+        efiBoot = "4";
+        biosBoot = "5";
       };
       description = "Describe on disk partitions";
       type = types.attrsOf types.str;
     };
+    sshUnlock = {
+      enable = mkOption {
+        type = types.bool;
+        default = false;
+      };
+      authorizedKeys = mkOption {
+        type = types.listOf types.str;
+        default = [ ];
+      };
+    };
   };
   config = mkIf (cfg.enable) (mkMerge [
     {
       zfs-root.fileSystems.datasets = {
-        # rpool/path/to/dataset = "/path/to/mountpoint"
         "rpool/nixos/home" = mkDefault "/home";
         "rpool/nixos/var/lib" = mkDefault "/var/lib";
         "rpool/nixos/var/log" = mkDefault "/var/log";
         "bpool/nixos/root" = "/boot";
       };
     }
-    (mkIf cfg.luks.enable {
-      boot.initrd.luks.devices = mkMerge (map (diskName: {
-        "luks-rpool-${diskName}${cfg.partitionScheme.rootPool}" = {
-          device = (cfg.devNodes + diskName + cfg.partitionScheme.rootPool);
-          allowDiscards = true;
-          bypassWorkqueues = true;
-        };
-      }) cfg.bootDevices);
-    })
-    (mkIf (!cfg.immutable.enable) {
+    (mkIf (!cfg.immutable) {
       zfs-root.fileSystems.datasets = { "rpool/nixos/root" = "/"; };
     })
-    (mkIf cfg.immutable.enable {
+    (mkIf cfg.immutable {
       zfs-root.fileSystems = {
         datasets = {
-          # rpool/path/to/dataset = "/path/to/mountpoint"
           "rpool/nixos/empty" = "/";
           "rpool/nixos/root" = "/oldroot";
         };
         bindmounts = {
-          # /bindmount/source = /bindmount/target
           "/oldroot/nix" = "/nix";
           "/oldroot/etc/nixos" = "/etc/nixos";
         };
       };
-      boot.initrd.systemd.services.immutable-zfs-root = {
-        description = "Rollback root filesystem to an empty snapshot";
-        unitConfig.DefaultDependencies = false;
-        wantedBy = [ "zfs.target" ];
-        after = [ "zfs-import-rpool.service" ];
-        before = [ "sysroot.mount" ];
-        path = [ pkgs.zfs ];
-        serviceConfig.Type = "oneshot";
-        script = "zfs rollback -r rpool/nixos/empty@start";
-      };
+      boot.initrd.postDeviceCommands = ''
+        if ! grep -q zfs_no_rollback /proc/cmdline; then
+          zpool import -N rpool
+          zfs rollback -r rpool/nixos/empty@start
+          zpool export -a
+        fi
+      '';
     })
     {
       zfs-root.fileSystems = {
@@ -106,6 +104,10 @@ in {
           (map (diskName: diskName + cfg.partitionScheme.swap) cfg.bootDevices);
       };
       boot = {
+        kernelPackages =
+          mkDefault config.boot.zfs.package.latestCompatibleLinuxPackages;
+        initrd.availableKernelModules = cfg.availableKernelModules;
+        kernelParams = cfg.kernelParams;
         supportedFilesystems = [ "zfs" ];
         zfs = {
           devNodes = cfg.devNodes;
@@ -134,5 +136,27 @@ in {
         };
       };
     }
+    (mkIf cfg.sshUnlock.enable {
+      boot.initrd = {
+        network = {
+          enable = true;
+          ssh = {
+            enable = true;
+            hostKeys = [
+              "/var/lib/ssh_unlock_zfs_ed25519_key"
+              "/var/lib/ssh_unlock_zfs_rsa_key"
+            ];
+            authorizedKeys = cfg.sshUnlock.authorizedKeys;
+          };
+          postCommands = ''
+            tee -a /root/.profile >/dev/null <<EOF
+            if zfs load-key rpool/nixos; then
+               pkill zfs
+            fi
+            exit
+            EOF'';
+        };
+      };
+    })
   ]);
 }

modules/default.nix

@@ -1 +1,3 @@
-{ config, lib, pkgs, ... }: { imports = [ ./boot ./fileSystems ]; }
+{ config, lib, pkgs, ... }: {
+  imports = [ ./boot ./fileSystems ./networking ./my-config ];
+}

modules/fileSystems/default.nix

@@ -41,7 +41,7 @@ in {
     };
   }) cfg.bindmounts ++ map (esp: {
     "/boot/efis/${esp}" = {
-      device = "${config.zfs-root.boot.devNodes}${esp}";
+      device = "${config.zfs-root.boot.devNodes}/${esp}";
       fsType = "vfat";
       options = [
         "x-systemd.idle-timeout=1min"
@@ -54,7 +54,7 @@ in {
     };
   }) cfg.efiSystemPartitions);
   config.swapDevices = mkDefault (map (swap: {
-    device = "${config.zfs-root.boot.devNodes}${swap}";
+    device = "${config.zfs-root.boot.devNodes}/${swap}";
     discardPolicy = mkDefault "both";
     randomEncryption = {
       enable = true;

modules/my-config/default.nix

@@ -0,0 +1,41 @@
+{ config, lib, pkgs, ... }:
+let inherit (lib) types mkIf mkDefault mkOption;
+in {
+  options.my-config = {
+    template.desktop.gnome.enable = mkOption {
+      description = "Enable my customized GNOME desktop";
+      type = types.bool;
+      default = false;
+    };
+  };
+
+  # if my-config.template.desktop.gnome.enable is set to true
+  # set the following options
+  config = mkIf config.my-config.template.desktop.gnome.enable {
+    services.xserver = {
+      enable = true;
+      desktopManager.gnome.enable = true;
+      displayManager.gdm.enable = true;
+    };
+
+    # GNOME must be used with a non-root user,
+    # add a non-root user
+    users.users.alice = {
+      # Generate hashed password with "mkpasswd -m sha-512" command,
+      # "!" disables login.
+      # "mkpasswd" without "-m sha-512" will not work
+      initialHashedPassword = "!";
+      description = "Full Name";
+      # Users in "wheel" group are allowed to use "doas" command
+      # to obtain root permissions.
+      extraGroups = [ "wheel" ];
+      packages = builtins.attrValues {
+        inherit (pkgs)
+          mg # emacs-like editor
+          jq # other programs
+        ;
+      };
+      isNormalUser = true;
+    };
+  };
+}

modules/networking/default.nix

@@ -0,0 +1,29 @@
+{ config, lib, ... }:
+let
+  cfg = config.zfs-root.networking;
+  inherit (lib) types mkDefault mkOption;
+in {
+  options.zfs-root.networking = {
+    hostName = mkOption {
+      description = "The name of the machine.  Used by nix flake.";
+      type = types.str;
+      default = "nixos";
+    };
+    timeZone = mkOption {
+      type = types.str;
+      default = "Etc/UTC";
+    };
+    hostId = mkOption {
+      description = "Set host id";
+      type = types.str;
+    };
+  };
+  config = {
+    networking.hostId = cfg.hostId;
+    time.timeZone = cfg.timeZone;
+    networking = {
+      firewall.enable = mkDefault true;
+      hostName = cfg.hostName;
+    };
+  };
+}