feat: Improve boolean helpers (#1268)

*

.devcontainer.json

@@ -1,6 +0,0 @@
-{
-  "name": "dsm",
-  "service": "dsm",
-  "forwardPorts": [5000],
-  "dockerComposeFile": "compose.yml"
-}

.devcontainer/codespaces.yml

@@ -0,0 +1,19 @@
+services:
+  dsm:
+    container_name: dsm
+    image: ghcr.io/vdsm/virtual-dsm
+    environment:
+      RAM_SIZE: "half"
+      DISK_SIZE: "max"
+      CPU_CORES: "max"
+    devices:
+      - /dev/kvm
+      - /dev/net/tun
+    cap_add:
+      - NET_ADMIN
+    ports:
+      - 5000:5000
+    volumes:
+      - ./dsm:/storage
+    restart: on-failure
+    stop_grace_period: 2m

.devcontainer/devcontainer.json

@@ -0,0 +1,15 @@
+{
+  "name": "Virtual DSM",
+  "service": "dsm",
+  "forwardPorts": [5000],
+  "portsAttributes": {
+    "5000": {
+      "label": "Web",
+      "onAutoForward": "notify"
+    }
+  },
+  "otherPortsAttributes": {
+    "onAutoForward": "ignore"
+  }, 
+  "dockerComposeFile": "codespaces.yml"
+}

.dockerignore

@@ -1,4 +1,5 @@
 .dockerignore
+.devcontainer
 .git
 .github
 .gitignore

.github/ISSUE_TEMPLATE/1-issue.yml

@@ -21,6 +21,7 @@ body:
     attributes:
       label: Docker compose
       description: The compose file (or otherwise the `docker run` command used).
+      render: yaml
     validations:
       required: true
   - type: textarea
@@ -28,6 +29,7 @@ body:
     attributes:
       label: Docker log
       description: The logfile of the container (as shown by `docker logs dsm`).
+      render: shell
     validations:
       required: true
   - type: textarea

.github/ISSUE_TEMPLATE/3-bug.yml

@@ -23,6 +23,7 @@ body:
     attributes:
       label: Docker compose
       description: The compose file (or otherwise the `docker run` command used).
+      render: yaml
     validations:
       required: true
   - type: textarea
@@ -30,6 +31,7 @@ body:
     attributes:
       label: Docker log
       description: The logfile of the container (as shown by `docker logs dsm`).
+      render: shell
     validations:
       required: true
   - type: textarea

.github/workflows/build.yml

@@ -2,20 +2,6 @@ name: Build
 
 on:
   workflow_dispatch:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**/*.md'
-      - '**/*.yml'
-      - '**/*.js'
-      - '**/*.css'
-      - '**/*.html'
-      - 'web/**'
-      - '.gitignore'
-      - '.dockerignore'
-      - '.github/**'
-      - '.github/workflows/**'
 
 concurrency:
   group: build
@@ -36,13 +22,13 @@ jobs:
     steps:
       -
         name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0
       -
         name: Docker metadata
         id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
         with:
           context: git
           images: |
@@ -57,23 +43,23 @@ jobs:
           DOCKER_METADATA_ANNOTATIONS_LEVELS: manifest,index
       - 
         name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
       -
         name: Login into Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
       -
         name: Login to GitHub Container Registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       -
         name: Build Docker image
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           context: .
           push: true

.github/workflows/check.yml

@@ -7,9 +7,10 @@ jobs:
     name: shellcheck
     runs-on: ubuntu-latest
     steps:
-      - 
+    - 
-        name: Checkout
+      name: Checkout
-        uses: actions/checkout@v4
+      uses: actions/checkout@v7
+    - parallel:
       -
         name: Run ShellCheck
         uses: ludeeus/action-shellcheck@master
@@ -17,8 +18,13 @@ jobs:
           SHELLCHECK_OPTS: -x --source-path=src -e SC2001 -e SC2034 -e SC2064 -e SC2317 -e SC2153 -e SC2028
       - 
         name: Lint Dockerfile
-        uses: hadolint/hadolint-action@v3.1.0
+        uses: hadolint/hadolint-action@v3.3.0
         with:
           dockerfile: Dockerfile
           ignore: DL3008,DL3003,DL3006,DL3013
           failure-threshold: warning
+      -
+        name: Validate JSON and YML files
+        uses: GrantBirki/json-yaml-validate@v5.0.0
+        with:
+          yaml_exclude_regex: ".*\\kubernetes\\.yml$"

.github/workflows/hub.yml

@@ -12,13 +12,15 @@ jobs:
   dockerHubDescription:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+      -
-    - 
+        name: Checkout repo
-      name: Docker Hub Description
+        uses: actions/checkout@v7
-      uses: peter-evans/dockerhub-description@v4
+      - 
-      with:
+        name: Docker Hub Description
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        uses: peter-evans/dockerhub-description@v5
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
+        with:
-        repository: ${{ secrets.DOCKERHUB_REPO }}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
-        short-description: ${{ github.event.repository.description }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
-        readme-filepath: ./readme.md
+          repository: ${{ secrets.DOCKERHUB_REPO }}
+          short-description: ${{ github.event.repository.description }}
+          readme-filepath: ./readme.md

.github/workflows/review.yml

@@ -0,0 +1,71 @@
+on:
+  pull_request:
+
+name: "Review"
+
+permissions:
+  contents: read
+  pull-requests: write
+  checks: write
+
+jobs:
+  review:
+    name: review
+    runs-on: ubuntu-latest
+    steps:
+    -
+      name: Checkout
+      uses: actions/checkout@v7
+    - parallel:
+      -
+        name: Spelling
+        uses: reviewdog/action-misspell@v1
+        with:
+          locale: "US"
+          level: warning
+          pattern: |
+            *.md
+            *.sh
+          reporter: github-pr-review
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Hadolint
+        uses: reviewdog/action-hadolint@v1
+        with:
+          level: warning
+          fail_level: error
+          reporter: github-pr-review
+          hadolint_ignore: DL3008 DL3003 DL3006 DL3013
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: YamlLint
+        uses: reviewdog/action-yamllint@v1
+        with:
+          level: warning
+          reporter: github-pr-review
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: ActionLint
+        uses: reviewdog/action-actionlint@v1
+        with:
+          level: warning
+          reporter: github-pr-review
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Shellformat
+        uses: reviewdog/action-shfmt@v1
+        if: false
+        with:
+          level: warning
+          fail_on_error: "true"
+          shfmt_flags: "-i 2 -ci -bn"
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Shellcheck
+        uses: reviewdog/action-shellcheck@v1
+        with:
+          level: warning
+          fail_level: error
+          reporter: github-pr-review
+          shellcheck_flags: -x -e SC1091 -e SC2001 -e SC2034 -e SC2064 -e SC2317 -e SC2153 -e SC2028
+          github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -1,11 +1,6 @@
 on:
   workflow_dispatch:
   pull_request:
-    paths:
-      - '**/*.sh'
-      - 'Dockerfile'
-      - '.github/workflows/test.yml'
-      - '.github/workflows/check.yml'
 
 name: "Test"
 permissions: {}

Dockerfile

@@ -1,70 +1,88 @@
+# syntax=docker/dockerfile:1
+
 FROM qemux/qemu-host:2.05 AS builder
-
-#  FROM golang as builder
-#  WORKDIR /
-#  RUN git clone https://github.com/qemus/qemu-host.git
-#  WORKDIR /qemu-host/src
-#  RUN go mod download
-#  RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o /qemu-host.bin .
-
 FROM debian:trixie-slim
 
+ARG TARGETARCH
 ARG TARGETPLATFORM
 ARG VERSION_ARG="0.0"
+ARG VERSION_PASST="2026_06_11"
+
 ARG DEBCONF_NOWARNINGS="yes"
 ARG DEBIAN_FRONTEND="noninteractive"
 ARG DEBCONF_NONINTERACTIVE_SEEN="true"
 
-RUN set -eu && \
+RUN <<EOF
-    apt-get update && \
+  set -eu
-    apt-get --no-install-recommends -y install \
+
-        jq \
+  apt-get update
-        tini \
+  apt-get --no-install-recommends -y install \
-        curl \
+    jq \
-        wget \
+    tini \
-        fdisk \
+    curl \
-        unzip \
+    wget \
-        nginx \
+    fdisk \
-        procps \
+    unzip \
-        python3 \
+    nginx \
-        python3-pip \
+    procps \
-        python3-msgpack \
+    ipcalc \
-        python3-pysodium \
+    ethtool \
-        xz-utils \
+    python3 \
-        iptables \
+    python3-pip \
-        iproute2 \
+    python3-msgpack \
-        apt-utils \
+    python3-pysodium \
-        dnsmasq \
+    xz-utils \
-        fakeroot \
+    iptables \
-        net-tools \
+    iproute2 \
-        e2fsprogs \
+    dnsmasq \
-        qemu-utils \
+    fakeroot \
-        iputils-ping \
+    apt-utils \
-        ca-certificates \
+    net-tools \
-        netcat-openbsd \
+    e2fsprogs \
-        qemu-system-x86 && \
+    qemu-utils \
-    apt-get clean && \
+    websocketd \
-    pip3 install --no-cache-dir --break-system-packages dissect.cstruct && \
+    iputils-ping \
-    mkdir -p /etc/qemu && \
+    inotify-tools \
-    echo "allow br0" > /etc/qemu/bridge.conf && \
+    ca-certificates \
-    unlink /etc/nginx/sites-enabled/default && \
+    netcat-openbsd \
-    sed -i 's/^worker_processes.*/worker_processes 1;/' /etc/nginx/nginx.conf && \
+    qemu-system-x86
-    echo "$VERSION_ARG" > /run/version && \
+
-    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+  # Install Passt package
+  wget "https://github.com/qemus/passt/releases/download/v${VERSION_PASST}/passt_${VERSION_PASST}_${TARGETARCH}.deb" -O /tmp/passt.deb -q --timeout=10
+  dpkg -i /tmp/passt.deb
+
+  apt-get clean
+
+  # Install Python dependencies
+  pip3 install --no-cache-dir --break-system-packages --root-user-action=ignore dissect.cstruct
+
+  # Configure QEMU
+  mkdir -p /etc/qemu
+  echo "allow br0" > /etc/qemu/bridge.conf
+
+  # Configure nginx
+  unlink /etc/nginx/sites-enabled/default
+  sed -i 's/^worker_processes.*/worker_processes 1;/' /etc/nginx/nginx.conf
+
+  # Set version file
+  echo "$VERSION_ARG" > /etc/version
+
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+EOF
 
 COPY --chmod=755 ./src /run/
 COPY --chmod=755 ./web /var/www/
 COPY --chmod=755 --from=builder /qemu-host.bin /run/host.bin
-COPY --chmod=744 ./web/conf/nginx.conf /etc/nginx/sites-enabled/web.conf
+COPY --chmod=744 ./web/conf/nginx.conf /etc/nginx/default.conf
 ADD --chmod=775 https://raw.githubusercontent.com/sud0woodo/patology/refs/heads/main/patology.py /run/extract.py
 
 VOLUME /storage
 EXPOSE 22 139 445 5000
 
-ENV RAM_SIZE="1G"
+ENV RAM_SIZE="2G"
-ENV DISK_SIZE="16G"
+ENV CPU_CORES="2"
-ENV CPU_CORES="1"
+ENV DISK_SIZE="256G"
 
-HEALTHCHECK --interval=60s --start-period=45s --retries=2 CMD /run/check.sh
+HEALTHCHECK --interval=60s --start-period=45s --retries=2 CMD ["/run/check.sh"]
 
 ENTRYPOINT ["/usr/bin/tini", "-s", "/run/entry.sh"]

compose.yml

@@ -3,7 +3,7 @@ services:
     container_name: dsm
     image: vdsm/virtual-dsm
     environment:
-      DISK_SIZE: "16G"
+      DISK_SIZE: "256G"
     devices:
       - /dev/kvm
       - /dev/net/tun

docs/environment.md

@@ -0,0 +1,93 @@
+# Environment Variables
+
+This page lists all the environment variables that can be used to configure the container.
+
+An empty default means the variable is unset and its value is determined automatically when applicable.
+
+## 💽 Virtual DSM
+
+| Variable | Default | Description |
+|---|---|---|
+| `URL` |  | URL or local path to the DSM `.pat` installation file. Downloads the default Virtual DSM image automatically when unset. |
+| `HOST_MAC` |  | MAC address reported to DSM. |
+| `HOST_MODEL` |  | Synology host model reported to DSM. |
+| `HOST_SERIAL` |  | Synology host serial number reported to DSM. |
+| `GUEST_SERIAL` |  | Synology guest serial number reported to DSM. |
+
+## 🧠 CPU and Memory
+
+| Variable | Default | Description |
+|---|---|---|
+| `CPU_CORES` | `2` | Number of virtual CPU cores, such as `4`, `half`, or `max`. |
+| `CPU_MODEL` | `host` | QEMU CPU model. |
+| `CPU_FLAGS` |  | Additional QEMU CPU flags. |
+| `HOST_CPU` |  | CPU name reported to DSM. Selected automatically when unset. |
+| `KVM` | `Y` | Enables KVM hardware acceleration. |
+| `RAM_SIZE` | `2G` | Amount of RAM assigned to DSM, such as `2G`, `4G`, `half`, or `max`. |
+| `RAM_CHECK` | `Y` | Checks whether enough host memory is available before starting DSM. |
+
+## 💾 Storage
+
+| Variable | Default | Description |
+|---|---|---|
+| `DISK_SIZE` | `256G` | Size of the main data disk. |
+| `DISK_FMT` | `raw` | Disk image format: `raw` or `qcow2`. |
+| `DISK_TYPE` | `scsi` | Disk device type, such as `sata`, `scsi`, `nvme`, or `blk`. |
+| `DISK_CACHE` | `none` | Disk cache mode, such as `none` or `writeback`. |
+| `DISK_IO` | `native` | Disk I/O mode, such as `native`, `threads`, or `io_uring`. |
+| `DISK_DISCARD` | `unmap` | Discard/TRIM mode for the primary disk. |
+| `DISK_ROTATION` | `1` | Rotation rate reported to the guest. Use `1` to identify the disk as an SSD. |
+| `DISK_FLAGS` |  | Additional options used when creating `qcow2` disks. |
+| `ALLOCATE` | `N` | Preallocates space for the data disks. |
+| `STORAGE` | `/storage` | Storage directory used for disks, settings, and downloads. |
+
+## 🌐 Networking
+
+| Variable | Default | Description |
+|---|---|---|
+| `NETWORK` |  | Network mode, such as `nat`, `passt`, `slirp`, or `N` to disable networking. |
+| `DHCP` | `N` | Enables macvtap networking so  DSM receives an address from the external LAN through DHCP. |
+| `HOST` | `VirtualDSM` | Hostname assigned to DSM. |
+| `IP` |  | Overrides the automatically selected guest IPv4 address. |
+| `MAC` |  | Guest network adapter MAC address. |
+| `ADAPTER` | `virtio-net-pci` | QEMU network adapter model. |
+| `DEV` | `eth0` | Container network interface used as the uplink. |
+| `MTU` |  | MTU assigned to the guest network interface. |
+| `MASK` | `255.255.255.0` | IPv4 netmask. |
+| `TAP` | `dsm` | TAP or macvtap interface name. |
+| `BRIDGE` | `docker` | Bridge name used for NAT networking. |
+| `HOST_PORTS` |  | Ports excluded from guest forwarding. |
+| `USER_PORTS` |  | Additional ports to forward to DSM when using user-mode networking. |
+| `DNSMASQ_OPTS` |  | Additional options passed to dnsmasq. |
+| `DNSMASQ_DEBUG` | `N` | Enables dnsmasq debug output. |
+| `DNSMASQ_DISABLE` | `N` | Disables the internal dnsmasq resolver. |
+| `PASST_OPTS` |  | Additional options passed to passt. |
+| `PASST_DEBUG` | `N` | Enables passt debug output. |
+
+## 🖥️ Display
+
+| Variable | Default | Description |
+|---|---|---|
+| `DISPLAY` | `none` | Display backend, such as `vnc`, `disabled`, or `none`. |
+| `VGA` | `none` | QEMU video adapter model. |
+| `GPU` | `N` | Enables Intel iGPU acceleration. |
+| `RENDERNODE` | `/dev/dri/renderD128` | Render node used for GPU acceleration. |
+
+## 🔌 Shutdown
+
+| Variable | Default | Description |
+|---|---|---|
+| `SHUTDOWN` | `Y` | Enables graceful shutdown. |
+| `TIMEOUT` | `115` | Maximum time, in seconds, to wait before forcing DSM to stop. |
+| `API_TIMEOUT` | `90` | Maximum time, in seconds, to wait for the shutdown API call. |
+
+## 🐞 Debugging
+
+| Variable | Default | Description |
+|---|---|---|
+| `DEBUG` | `N` | Enables verbose debug output. |
+| `TRACE` | `N` | Enables shell command tracing. |
+| `COM_PORT` | `2210` | Internal communication port used by the DSM host helper. |
+| `CHR_PORT` | `12345` | Internal character device port used by the DSM host helper. |
+| `HOST_DEBUG` | `N` | Enables debug output for the DSM host helper. |
+| `ARGUMENTS` |  | Additional raw arguments appended to the QEMU command line. |

kubernetes.yml

@@ -8,7 +8,7 @@ spec:
   - ReadWriteOnce
   resources:
     requests:
-      storage: 16Gi
+      storage: 256Gi
 ---
 apiVersion: apps/v1
 kind: Deployment
@@ -31,7 +31,7 @@ spec:
         image: vdsm/virtual-dsm
         env:
         - name: DISK_SIZE
-          value: "16G"
+          value: "256G"
         ports:
           - containerPort: 5000
             name: http

readme.md

@@ -16,13 +16,17 @@ Virtual DSM in a Docker container.
 
 ## Features ✨
 
- - Multiple disks
+- Runs Virtual DSM inside a Docker container
- - KVM acceleration
+- Automatic download of the installation files
- - Upgrades supported
+- Web-based access to the DSM desktop
- 
+- Near-native performance with KVM acceleration
+- Customizable CPU, memory, and storage allocation
+- Supports multiple disks and physical disk passthrough
+- Supports NAT, user-mode, macvlan, and macvtap networking
+
 ## Usage  🐳
 
-##### Via Docker Compose:
+##### Docker Compose:
 
 ```yaml
 services:
@@ -30,7 +34,7 @@ services:
     container_name: dsm
     image: vdsm/virtual-dsm
     environment:
-      DISK_SIZE: "16G"
+      DISK_SIZE: "256G"
     devices:
       - /dev/kvm
       - /dev/net/tun
@@ -44,21 +48,31 @@ services:
     stop_grace_period: 2m
 ```
 
-##### Via Docker CLI:
+##### Docker CLI:
 
 ```bash
-docker run -it --rm --name dsm -p 5000:5000 --device=/dev/kvm --device=/dev/net/tun --cap-add NET_ADMIN -v ${PWD:-.}/dsm:/storage --stop-timeout 120 vdsm/virtual-dsm
+docker run -it --rm --name dsm -e "DISK_SIZE=256G" -p 5000:5000 --device=/dev/kvm --device=/dev/net/tun --cap-add NET_ADMIN -v "${PWD:-.}/dsm:/storage" --stop-timeout 120 docker.io/vdsm/virtual-dsm
 ```
 
-##### Via Kubernetes:
+##### Kubernetes:
 
 ```shell
 kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/master/kubernetes.yml
 ```
 
-##### Via Github Codespaces:
+##### GitHub Codespaces:
 
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?repo=619260050&machine=basicLinux32gb)
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/vdsm/virtual-dsm)
+
+## Requirements ⚙️
+
+- Docker or Podman on a Linux host with KVM support.
+- Docker Desktop or Podman (Desktop) on Windows 11 with nested virtualization enabled.
+- At least 2 GB of available RAM.
+- At least 32 GB of free disk space.
+
+> [!NOTE]
+> Docker Desktop on Linux, macOS, and Windows 10 does not currently provide KVM access to containers and is therefore not supported.
 
 ## FAQ 💬
 
@@ -70,7 +84,7 @@ kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/m
 
   - Wait until DSM finishes its installation
  
-  - Choose an username and password, and you will be taken to the desktop.
+  - Choose a username and password, and you will be taken to the desktop.
   
   Enjoy your brand new NAS, and don't forget to star this repo!
 
@@ -87,26 +101,15 @@ kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/m
  
 ### How do I change the size of the disk?
 
-  To expand the default size of 16 GB, locate the `DISK_SIZE` setting in your compose file and modify it to your preferred capacity:
+  To expand the default size of 256 GB, locate the `DISK_SIZE` setting in your compose file and modify it to your preferred capacity:
 
   ```yaml
   environment:
-    DISK_SIZE: "128G"
+    DISK_SIZE: "512G"
   ```
   
 > [!TIP]
-> This can also be used to resize the existing disk to a larger capacity without any data loss.
+> This can also be used to resize an existing disk to a larger capacity without any data loss.
-
-### How do I create a growable disk?
-
-  By default, the entire capacity of the disk will be reserved in advance.
-
-  To create a growable disk that only allocates space that is actually used, add the following environment variable:
-
-  ```yaml
-  environment:
-    DISK_FMT: "qcow2"
-  ```
 
 ### How do I add multiple disks?
 
@@ -114,29 +117,28 @@ kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/m
   
   ```yaml
   environment:
-    DISK2_SIZE: "32G"
+    DISK2_SIZE: "500G"
-    DISK3_SIZE: "64G"
+    DISK3_SIZE: "750G"
   volumes:
     - ./example2:/storage2
     - ./example3:/storage3
   ```
 
-### How do I pass-through a disk?
+### How do I pass through a disk?
 
-   It is possible to pass-through a disk device directly, which can be useful when your host is a virtual machine, as it removes an extra layer and allows for easier image management on the host.
+   You can pass through disk devices or partitions directly by adding them to your compose file in this way:
-   
-   For use with physical disks this method provides little advantage over using an image and is not recommended. You can add the device to your compose file like this:
 
   ```yaml
   devices:
-    - /dev/sdc:/disk1
+    - /dev/sdb:/disk1
+    - /dev/sdc1:/disk2
   ```
 
-  Replace `/dev/sdc` with the name of the disk. It needs to be totally empty (without any partition table) otherwise DSM does not always format it into a volume.
+  Make sure it is totally empty (without any filesystem), otherwise DSM may not format it as a volume.
 
 ### How do I change the amount of CPU or RAM?
 
-  By default, the container will be allowed to use a maximum of 1 CPU core and 1 GB of RAM.
+  By default, Virtual DSM will be allowed to use 2 CPU cores and 2 GB of RAM.
 
   If you want to adjust this, you can specify the desired amount using the following environment variables:
 
@@ -146,34 +148,6 @@ kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/m
     CPU_CORES: "4"
   ```
 
-### How do I verify if my system supports KVM?
-
-  First check if your software is compatible using this chart:
-
-  | **Product**  | **Linux** | **Win11** | **Win10** | **macOS** |
-  |---|---|---|---|---|
-  | Docker CLI        | ✅   | ✅       | ❌        | ❌ |
-  | Docker Desktop    | ❌   | ✅       | ❌        | ❌ | 
-  | Podman CLI        | ✅   | ✅       | ❌        | ❌ | 
-  | Podman Desktop    | ✅   | ✅       | ❌        | ❌ | 
-
-  After that you can run the following commands in Linux to check your system:
-
-  ```bash
-  sudo apt install cpu-checker
-  sudo kvm-ok
-  ```
-
-  If you receive an error from `kvm-ok` indicating that KVM cannot be used, please check whether:
-
-  - the virtualization extensions (`Intel VT-x` or `AMD SVM`) are enabled in your BIOS.
-
-  - you enabled "nested virtualization" if you are running the container inside a virtual machine.
-
-  - you are not using a cloud provider, as most of them do not allow nested virtualization for their VPS's.
-
-  If you did not receive any error from `kvm-ok` but the container still complains about a missing KVM device, it could help to add `privileged: true` to your compose file (or `sudo` to your `docker` command) to rule out any permission issue.
-
 ### How do I assign an individual IP address to the container?
 
   By default, the container uses bridge networking, which shares the IP address with the host. 
@@ -226,9 +200,9 @@ kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/m
     - 'c *:* rwm'
   ```
 
-### How do I pass-through the GPU?
+### How do I pass through the GPU?
 
-  To pass-through your Intel GPU, add the following lines to your compose file:
+  To pass through your Intel GPU, add the following lines to your compose file:
 
   ```yaml
   environment:
@@ -260,26 +234,53 @@ kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/m
 
   Replace the example path `./DSM_VirtualDSM_42218.pat` with the filename of your desired `.pat` file. The value of `URL` will be ignored in this case.
 
+### Are these all available options?
+
+  No. For a complete overview of all supported settings, see the [environment variables](docs/environment.md) page.
+
+### How do I verify that KVM is available?
+
+  First, make sure your platform and container runtime meet the [requirements](#requirements-️) listed above.
+
+  On a Linux host, install `cpu-checker` and run:
+
+  ```bash
+  sudo apt install cpu-checker
+  sudo kvm-ok
+  ```
+
+  A working configuration should report:
+
+  ```text
+  KVM acceleration can be used
+  ```
+
+  You can also verify that the KVM device exists:
+
+  ```bash
+  ls -l /dev/kvm
+  ```
+
+  If KVM is unavailable, check whether:
+
+  - Hardware virtualization (`Intel VT-x` or `AMD-V`) is enabled in your BIOS or UEFI.
+  - Nested virtualization is enabled when the host itself is a virtual machine.
+  - Your VPS or cloud provider supports nested virtualization.
+
+  If `kvm-ok` succeeds but the container still reports that KVM is unavailable, you can temporarily add `privileged: true` to your Compose file to rule out a permission or device-access issue.
+
 ### What are the differences compared to the standard DSM?
 
   There are only two minor differences: the Virtual Machine Manager package is not available, and Surveillance Station will not include any free licenses.
 
-### How do I run Windows in a container?
-
-  You can use [dockur/windows](https://github.com/dockur/windows) for that. It shares many of the same features, and even has completely automatic installation.
-
-### How do I run a Linux desktop in a container?
-
-  You can use [qemus/qemu](https://github.com/qemus/qemu) in that case.
-
 ### Is this project legal?
 
-  Yes, this project contains only open-source code and does not distribute any copyrighted material. Neither does it try to circumvent any copyright protection measures. So under all applicable laws, this project will be considered legal. 
+  Yes, this project contains only open-source code and does not distribute any material owned by Synology. Neither does it try to circumvent any copyright protection measures.
   
   However, by installing Synology's Virtual DSM, you must accept their end-user license agreement, which does not permit installation on non-Synology hardware. So only run this container on an official Synology NAS, as any other use will be a violation of their terms and conditions.
 
 ## Stars 🌟
-[![Stars](https://starchart.cc/vdsm/virtual-dsm.svg?variant=adaptive)](https://starchart.cc/vdsm/virtual-dsm)
+[![Stargazers](https://raw.githubusercontent.com/star-stats/stars/refs/heads/data/charts/vdsm-virtual-dsm.svg)](https://github.com/vdsm/virtual-dsm/stargazers)
 
 ## Disclaimer ⚖️
 

src/check.sh

@@ -1,28 +1,33 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
+cd /run
+. utils.sh      # Load functions
+
+: "${DHCP:="N"}"
 : "${NETWORK:="Y"}"
 
-[ -f "/run/shm/qemu.end" ] && echo "QEMU is shutting down.." && exit 1
+[ -f "/run/shm/qemu.end" ] && echo "QEMU is shutting down..." && exit 1
-[ ! -s "/run/shm/qemu.pid" ] && echo "QEMU is not running yet.." && exit 0
+[ ! -s "/run/shm/qemu.pid" ] && echo "QEMU is not running yet..." && exit 0
-[[ "$NETWORK" == [Nn]* ]] && echo "Networking is disabled.." && exit 0
+disabled "$NETWORK" && echo "Networking is disabled." && exit 0
 
 file="/run/shm/dsm.url"
 address="/run/shm/qemu.ip"
+gateway="/run/shm/qemu.gw"
 
-[ ! -s  "$file" ] && echo "DSM has not enabled networking yet.." && exit 1
+[ ! -s  "$file" ] && echo "DSM has not enabled networking yet..." && exit 1
 
 location=$(<"$file")
 
 if ! curl -m 20 -ILfSs "http://$location/" > /dev/null; then
 
-  if [[ "$location" == "20.20"* ]]; then
+  if enabled "$DHCP"; then
-    ip="20.20.20.1"
+    ip=$(<"$address")
+    echo "Failed to reach DSM at http://$location"
+  else
+    ip=$(<"$gateway")
     port="${location##*:}"
     echo "Failed to reach DSM at port $port"
-  else
-    echo "Failed to reach DSM at http://$location"
-    ip=$(<"$address")
   fi
 
   echo "You might need to whitelist IP $ip in the DSM firewall." && exit 1

src/config.sh

@@ -3,6 +3,7 @@ set -Eeuo pipefail
 
 DEF_OPTS="-nodefaults -boot strict=on"
 RAM_OPTS=$(echo "-m ${RAM_SIZE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+MON_OPTS="-name $PROCESS,process=$PROCESS,debug-threads=on -pidfile $QEMU_PID"
 CPU_OPTS="-cpu $CPU_FLAGS -smp $CPU_CORES,sockets=1,dies=1,cores=$CPU_CORES,threads=1"
 MAC_OPTS="-machine type=q35,smm=off,usb=off,vmport=off,dump-guest-core=off,hpet=off${KVM_OPTS}"
 DEV_OPTS="-device virtio-balloon-pci,id=balloon0,bus=pcie.0,addr=0x4"
@@ -12,32 +13,4 @@ DEV_OPTS+=" -device virtio-rng-pci,rng=objrng0,id=rng0,bus=pcie.0,addr=0x1c"
 ARGS="$DEF_OPTS $CPU_OPTS $RAM_OPTS $MAC_OPTS $DISPLAY_OPTS $MON_OPTS $SERIAL_OPTS $NET_OPTS $DISK_OPTS $DEV_OPTS $ARGUMENTS"
 ARGS=$(echo "$ARGS" | sed 's/\t/ /g' | tr -s ' ')
 
-# Check available memory as the very last step
-
-if [[ "$RAM_CHECK" != [Nn]* ]]; then
-
-  RAM_AVAIL=$(free -b | grep -m 1 Mem: | awk '{print $7}')
-  AVAIL_MEM=$(formatBytes "$RAM_AVAIL")
-
-  if (( (RAM_WANTED + RAM_SPARE) > RAM_AVAIL )); then
-    msg="Your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is too high for the $AVAIL_MEM of memory available, please set a lower value."
-    [[ "${FS,,}" != "zfs" ]] && error "$msg" && exit 17
-    info "$msg"
-  else
-    if (( (RAM_WANTED + (RAM_SPARE * 3)) > RAM_AVAIL )); then
-      msg="your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is very close to the $AVAIL_MEM of memory available, please consider a lower value."
-      if [[ "${FS,,}" != "zfs" ]]; then
-        warn "$msg"
-      else
-        info "$msg"
-      fi
-    fi
-  fi
-
-fi
-
-if [[ "$DEBUG" == [Yy1]* ]]; then
-  printf "Arguments:\n\n%s\n\n" "${ARGS// -/$'\n-'}"
-fi
-
 return 0

src/disk.sh

@@ -8,50 +8,56 @@ set -Eeuo pipefail
 : "${DISK_TYPE:=""}"              # Device type to be used, "sata", "nvme", "blk" or "scsi"
 : "${DISK_FLAGS:=""}"             # Specifies the options for use with the qcow2 disk format
 : "${DISK_CACHE:="none"}"         # Caching mode, can be set to 'writeback' for better performance
-: "${DISK_DISCARD:="on"}"         # Controls whether unmap (TRIM) commands are passed to the host.
+: "${DISK_DISCARD:="unmap"}"      # Controls whether unmap (TRIM) commands are passed to the host.
 : "${DISK_ROTATION:="1"}"         # Rotation rate, set to 1 for SSD storage and increase for HDD
 
+# Sanitize all variables
+DISK_IO=$(strip "$DISK_IO")
+DISK_FMT=$(strip "$DISK_FMT")
+DISK_TYPE=$(strip "$DISK_TYPE")
+DISK_FLAGS=$(strip "$DISK_FLAGS")
+DISK_CACHE=$(strip "$DISK_CACHE")
+DISK_DISCARD=$(strip "$DISK_DISCARD")
+DISK_ROTATION=$(strip "$DISK_ROTATION")
+
 BOOT="$STORAGE/$BASE.boot.img"
 SYSTEM="$STORAGE/$BASE.system.img"
 
 [ ! -s "$BOOT" ] && error "Virtual DSM boot-image does not exist ($BOOT)" && exit 81
 [ ! -s "$SYSTEM" ] && error "Virtual DSM system-image does not exist ($SYSTEM)" && exit 82
 
+if ! setOwner "$BOOT"; then
+  warn "failed to set the owner for \"$BOOT\" !"
+fi
+
+if ! setOwner "$SYSTEM"; then
+  warn "failed to set the owner for \"$SYSTEM\" !"
+fi
+
 fmt2ext() {
-  local DISK_FMT=$1
+  local DISK_FMT="$1"
 
   case "${DISK_FMT,,}" in
-    qcow2)
+    qcow2) echo "qcow2" ;;
-      echo "qcow2"
+    raw) echo "img" ;;
-      ;;
+    *) error "Unrecognized disk format: $DISK_FMT" && exit 78 ;;
-    raw)
-      echo "img"
-      ;;
-    *)
-      error "Unrecognized disk format: $DISK_FMT" && exit 78
-      ;;
   esac
 }
 
 ext2fmt() {
-  local DISK_EXT=$1
+  local DISK_EXT="$1"
 
   case "${DISK_EXT,,}" in
-    qcow2)
+    qcow2) echo "qcow2" ;;
-      echo "qcow2"
+    img) echo "raw" ;;
-      ;;
+    *) error "Unrecognized file extension: .$DISK_EXT" && exit 78 ;;
-    img)
-      echo "raw"
-      ;;
-    *)
-      error "Unrecognized file extension: .$DISK_EXT" && exit 78
-      ;;
   esac
 }
 
 getSize() {
-  local DISK_FILE=$1
+
-  local DISK_EXT DISK_FMT
+  local DISK_FILE="$1"
+  local DISK_EXT DISK_FMT size
 
   DISK_EXT=$(echo "${DISK_FILE//*./}" | sed 's/^.*\.//')
   DISK_FMT=$(ext2fmt "$DISK_EXT")
@@ -60,17 +66,25 @@ getSize() {
     raw)
       stat -c%s "$DISK_FILE"
       ;;
+
     qcow2)
-      qemu-img info "$DISK_FILE" -f "$DISK_FMT" | grep '^virtual size: ' | sed 's/.*(\(.*\) bytes)/\1/'
+      size=$(qemu-img info --output=json -f "$DISK_FMT" "$DISK_FILE" | jq -r '."virtual-size" // empty')
+      if [[ ! "$size" =~ ^[0-9]+$ ]]; then
+        error "Failed to determine virtual size of $DISK_FILE"
+        exit 78
+      fi
+      echo "$size"
       ;;
+
     *)
-      error "Unrecognized disk format: $DISK_FMT" && exit 78
+      error "Unrecognized disk format: $DISK_FMT"
+      exit 78
       ;;
   esac
 }
 
 isCow() {
-  local FS=$1
+  local FS="$1"
 
   if [[ "${FS,,}" == "btrfs" ]]; then
     return 0
@@ -80,39 +94,137 @@ isCow() {
 }
 
 supportsDirect() {
-  local FS=$1
+  local FS="$1"
 
-  if [[ "${FS,,}" == "ecryptfs" ]] || [[ "${FS,,}" == "tmpfs" ]]; then
+  if [[ "${FS,,}" == "ecryptfs" || "${FS,,}" == "tmpfs" ]]; then
     return 1
   fi
 
   return 0
 }
 
+allocateRaw() {
+
+  local DISK_FILE="$1"
+  local DATA_SIZE="$2"
+
+  if disabled "$ALLOCATE"; then
+    truncate -s "$DATA_SIZE" "$DISK_FILE"
+    return $?
+  fi
+
+  fallocate -l "$DATA_SIZE" "$DISK_FILE" &>/dev/null && return 0
+  fallocate -l -x "$DATA_SIZE" "$DISK_FILE" && return 0
+  truncate -s "$DATA_SIZE" "$DISK_FILE" || return 1
+
+  return 0
+}
+
+getDiskOptions() {
+
+  local FS="$1"
+  local DISK_FMT="$2"
+  local DISK_PARAM="$DISK_ALLOC"
+
+  isCow "$FS" && DISK_PARAM+=",nocow=on"
+
+  if [[ "${DISK_FMT,,}" != "raw" ]]; then
+    [ -n "$DISK_FLAGS" ] && DISK_PARAM+=",$DISK_FLAGS"
+  fi
+
+  echo "$DISK_PARAM"
+  return 0
+}
+
+normalizeSize() {
+
+  local DISK_SPACE="$1"
+  local DISK_DESC="$2"
+  local DIR="$3"
+  local SPACE FREE GB DATA_SIZE
+
+  if [[ "${DISK_SPACE,,}" == "max" || "${DISK_SPACE,,}" == "half" ]]; then
+
+    local SPARE=1073741824
+    FREE=$(df --output=avail -B 1 "$DIR" | tail -n 1)
+
+    if [[ "${DISK_SPACE,,}" == "max" ]]; then
+      FREE=$(( FREE - SPARE ))
+    else
+      FREE=$(( FREE / 2 ))
+    fi
+
+    (( FREE < SPARE )) && FREE="$SPARE"
+    GB=$(( FREE / 1073741825 ))
+    DISK_SPACE="${GB}G"
+
+  fi
+
+  SPACE="${DISK_SPACE// /}"
+  [ -z "$SPACE" ] && SPACE="256G"
+  [ -z "${SPACE//[0-9. ]}" ] && SPACE="${SPACE}G"
+  SPACE=$(echo "${SPACE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+
+  if ! numfmt --from=iec "$SPACE" &>/dev/null; then
+    error "Invalid value for ${DISK_DESC^^}_SIZE: $DISK_SPACE" && exit 73
+  fi
+
+  DATA_SIZE=$(numfmt --from=iec "$SPACE")
+
+  if (( DATA_SIZE < 6442450944 )); then
+    error "Please increase the ${DISK_DESC^^}_SIZE variable to at least 6 GB." && exit 73
+  fi
+
+  echo "$SPACE"
+  return 0
+}
+
+
+baseDir() {
+
+  local path="${1%/}"
+
+  [[ -z "$path" || "$path" == "/" ]] && {
+    echo "/"
+    return 0
+  }
+
+  path="${path#/}"
+  path="${path%%/*}"
+
+  echo "/$path"
+  return 0
+}
 createDisk() {
 
-  local DISK_FILE=$1
+  local DISK_FILE="$1"
-  local DISK_SPACE=$2
+  local DISK_SPACE="$2"
-  local DISK_DESC=$3
+  local DISK_DESC="$3"
-  local DISK_FMT=$4
+  local DISK_FMT="$4"
-  local FS=$5
+  local FS="$5"
-  local DATA_SIZE DIR SPACE GB FA
+  local DATA_SIZE DIR BASE_DIR SPACE GB FA
-
-  DATA_SIZE=$(numfmt --from=iec "$DISK_SPACE")
 
   rm -f "$DISK_FILE"
 
-  if [[ "$ALLOCATE" != [Nn]* ]]; then
+  DATA_SIZE=$(numfmt --from=iec "$DISK_SPACE")
+
+  if ! disabled "$ALLOCATE"; then
 
     # Check free diskspace
     DIR=$(dirname "$DISK_FILE")
-    SPACE=$(df --output=avail -B 1 "$DIR" | tail -n 1)
+    BASE_DIR=$(baseDir "$DIR")
+
+    if ! SPACE=$(df --output=avail -B 1 "$DIR" | tail -n 1); then
+      error "Failed to check free space in $BASE_DIR."
+      exit 76
+    fi
 
     if (( DATA_SIZE > SPACE )); then
       GB=$(formatBytes "$SPACE")
-      error "Not enough free space to create a $DISK_DESC of ${DISK_SPACE/G/ GB} in $DIR, it has only $GB available..."
+      error "Not enough free space to create a $DISK_DESC of ${DISK_SPACE/G/ GB} in $BASE_DIR, it has only $GB available..."
       error "Please specify a smaller ${DISK_DESC^^}_SIZE or disable preallocation by setting ALLOCATE=N." && exit 76
     fi
+
   fi
 
   html "Creating a $DISK_DESC image..."
@@ -130,33 +242,15 @@ createDisk() {
         { chattr +C "$DISK_FILE"; } || :
       fi
 
-      if [[ "$ALLOCATE" == [Nn]* ]]; then
+      if ! allocateRaw "$DISK_FILE" "$DATA_SIZE"; then
-
+        rm -f "$DISK_FILE"
-        # Create an empty file
+        error "$FAIL" && exit 77
-        if ! truncate -s "$DATA_SIZE" "$DISK_FILE"; then
-          rm -f "$DISK_FILE"
-          error "$FAIL" && exit 77
-        fi
-
-      else
-
-        # Create an empty file
-        if ! fallocate -l "$DATA_SIZE" "$DISK_FILE" &>/dev/null; then
-          if ! fallocate -l -x "$DATA_SIZE" "$DISK_FILE"; then
-            if ! truncate -s "$DATA_SIZE" "$DISK_FILE"; then
-              rm -f "$DISK_FILE"
-              error "$FAIL" && exit 77
-            fi
-          fi
-        fi
-
       fi
       ;;
     qcow2)
 
-      local DISK_PARAM="$DISK_ALLOC"
+      local DISK_PARAM
-      isCow "$FS" && DISK_PARAM+=",nocow=on"
+      DISK_PARAM=$(getDiskOptions "$FS" "$DISK_FMT")
-      [ -n "$DISK_FLAGS" ] && DISK_PARAM+=",$DISK_FLAGS"
 
       if ! qemu-img create -f "$DISK_FMT" -o "$DISK_PARAM" -- "$DISK_FILE" "$DATA_SIZE" ; then
         rm -f "$DISK_FILE"
@@ -177,29 +271,35 @@ createDisk() {
 
 resizeDisk() {
 
-  local DISK_FILE=$1
+  local DISK_FILE="$1"
-  local DISK_SPACE=$2
+  local DISK_SPACE="$2"
-  local DISK_DESC=$3
+  local DISK_DESC="$3"
-  local DISK_FMT=$4
+  local DISK_FMT="$4"
-  local FS=$5
+  local FS="$5"
-  local CUR_SIZE DATA_SIZE DIR SPACE GB
+  local CUR_SIZE DATA_SIZE DIR BASE_DIR SPACE GB
 
-  CUR_SIZE=$(getSize "$DISK_FILE")
+  CUR_SIZE=$(getSize "$DISK_FILE") || exit 71
   DATA_SIZE=$(numfmt --from=iec "$DISK_SPACE")
-  local REQ=$((DATA_SIZE-CUR_SIZE))
+  local REQ=$(( DATA_SIZE - CUR_SIZE ))
   (( REQ < 1 )) && error "Shrinking disks is not supported yet, please increase ${DISK_DESC^^}_SIZE." && exit 71
 
-  if [[ "$ALLOCATE" != [Nn]* ]]; then
+  if ! disabled "$ALLOCATE"; then
 
     # Check free diskspace
     DIR=$(dirname "$DISK_FILE")
-    SPACE=$(df --output=avail -B 1 "$DIR" | tail -n 1)
+    BASE_DIR=$(baseDir "$DIR")
+
+    if ! SPACE=$(df --output=avail -B 1 "$DIR" | tail -n 1); then
+      error "Failed to check free space in $BASE_DIR."
+      exit 76
+    fi
 
     if (( REQ > SPACE )); then
       GB=$(formatBytes "$SPACE")
-      error "Not enough free space to resize $DISK_DESC to ${DISK_SPACE/G/ GB} in $DIR, it has only $GB available.."
+      error "Not enough free space to resize $DISK_DESC to ${DISK_SPACE/G/ GB} in $BASE_DIR, it has only $GB available.."
       error "Please specify a smaller ${DISK_DESC^^}_SIZE or disable preallocation by setting ALLOCATE=N." && exit 74
     fi
+
   fi
 
   GB=$(formatBytes "$CUR_SIZE")
@@ -211,24 +311,8 @@ resizeDisk() {
   case "${DISK_FMT,,}" in
     raw)
 
-      if [[ "$ALLOCATE" == [Nn]* ]]; then
+      if ! allocateRaw "$DISK_FILE" "$DATA_SIZE"; then
-
+        error "$FAIL" && exit 75
-        # Resize file by changing its length
-        if ! truncate -s "$DATA_SIZE" "$DISK_FILE"; then
-          error "$FAIL" && exit 75
-        fi
-
-      else
-
-        # Resize file by allocating more space
-        if ! fallocate -l "$DATA_SIZE" "$DISK_FILE" &>/dev/null; then
-          if ! fallocate -l -x "$DATA_SIZE" "$DISK_FILE"; then
-            if ! truncate -s "$DATA_SIZE" "$DISK_FILE"; then
-              error "$FAIL" && exit 75
-            fi
-          fi
-        fi
-
       fi
       ;;
     qcow2)
@@ -245,34 +329,42 @@ resizeDisk() {
 
 convertDisk() {
 
-  local SOURCE_FILE=$1
+  local SOURCE_FILE="$1"
-  local SOURCE_FMT=$2
+  local SOURCE_FMT="$2"
-  local DST_FILE=$3
+  local DST_FILE="$3"
-  local DST_FMT=$4
+  local DST_FMT="$4"
-  local DISK_BASE=$5
+  local DISK_BASE="$5"
-  local DISK_DESC=$6
+  local DISK_DESC="$6"
-  local FS=$7
+  local FS="$7"
 
   [ -f "$DST_FILE" ] && error "Conversion failed, destination file $DST_FILE already exists?" && exit 79
-  [ ! -f "$SOURCE_FILE" ] && error "Conversion failed, source file $SOURCE_FILE does not exists?" && exit 79
+  [ ! -f "$SOURCE_FILE" ] && error "Conversion failed, source file $SOURCE_FILE does not exist?" && exit 79
 
   local TMP_FILE="$DISK_BASE.tmp"
   rm -f "$TMP_FILE"
 
-  if [[ "$ALLOCATE" != [Nn]* ]]; then
+  local DIR BASE_DIR FA
+  DIR=$(dirname "$TMP_FILE")
+  BASE_DIR=$(baseDir "$DIR")
 
-    local DIR CUR_SIZE SPACE GB
+  if ! disabled "$ALLOCATE"; then
+
+    local CUR_SIZE SPACE GB
 
     # Check free diskspace
-    DIR=$(dirname "$TMP_FILE")
+    CUR_SIZE=$(getSize "$SOURCE_FILE") || exit 79
-    CUR_SIZE=$(getSize "$SOURCE_FILE")
+
-    SPACE=$(df --output=avail -B 1 "$DIR" | tail -n 1)
+    if ! SPACE=$(df --output=avail -B 1 "$DIR" | tail -n 1); then
+      error "Failed to check free space in $BASE_DIR."
+      exit 76
+    fi
 
     if (( CUR_SIZE > SPACE )); then
       GB=$(formatBytes "$SPACE")
-      error "Not enough free space to convert $DISK_DESC to $DST_FMT in $DIR, it has only $GB available..."
+      error "Not enough free space to convert $DISK_DESC to $DST_FMT in $BASE_DIR, it has only $GB available..."
       error "Please free up some disk space or disable preallocation by setting ALLOCATE=N." && exit 76
     fi
+
   fi
 
   local msg="Converting $DISK_DESC to $DST_FMT"
@@ -280,26 +372,30 @@ convertDisk() {
   info "$msg, please wait until completed..."
 
   local CONV_FLAGS="-p"
-  local DISK_PARAM="$DISK_ALLOC"
+  local DISK_PARAM
-  isCow "$FS" && DISK_PARAM+=",nocow=on"
+  DISK_PARAM=$(getDiskOptions "$FS" "$DST_FMT")
 
   if [[ "$DST_FMT" != "raw" ]]; then
-    if [[ "$ALLOCATE" == [Nn]* ]]; then
+    if disabled "$ALLOCATE"; then
       CONV_FLAGS+=" -c"
     fi
-    [ -n "$DISK_FLAGS" ] && DISK_PARAM+=",$DISK_FLAGS"
   fi
 
   # shellcheck disable=SC2086
   if ! qemu-img convert -f "$SOURCE_FMT" $CONV_FLAGS -o "$DISK_PARAM" -O "$DST_FMT" -- "$SOURCE_FILE" "$TMP_FILE"; then
     rm -f "$TMP_FILE"
-    error "Failed to convert $DISK_STYLE $DISK_DESC image to $DST_FMT format in $DIR, is there enough space available?" && exit 79
+    error "Failed to convert $DISK_STYLE $DISK_DESC image to $DST_FMT format in $BASE_DIR, is there enough space available?" && exit 79
   fi
 
   if [[ "$DST_FMT" == "raw" ]]; then
-    if [[ "$ALLOCATE" != [Nn]* ]]; then
+    if ! disabled "$ALLOCATE"; then
+
       # Work around qemu-img bug
-      CUR_SIZE=$(stat -c%s "$TMP_FILE")
+      if ! CUR_SIZE=$(stat -c%s "$TMP_FILE"); then
+        error "Failed to determine converted image size: $TMP_FILE"
+        exit 79
+      fi
+
       if ! fallocate -l "$CUR_SIZE" "$TMP_FILE" &>/dev/null; then
         if ! fallocate -l -x "$CUR_SIZE" "$TMP_FILE"; then
           error "Failed to allocate $CUR_SIZE bytes for $DISK_DESC image $TMP_FILE"
@@ -308,8 +404,15 @@ convertDisk() {
     fi
   fi
 
-  rm -f "$SOURCE_FILE"
+  if ! mv "$TMP_FILE" "$DST_FILE"; then
-  mv "$TMP_FILE" "$DST_FILE"
+    error "Failed to move converted $DISK_DESC image to $DST_FILE."
+    exit 79
+  fi
+
+  if ! rm -f "$SOURCE_FILE"; then
+    error "Failed to remove old $DISK_DESC image $SOURCE_FILE."
+    exit 79
+  fi
 
   if isCow "$FS"; then
     FA=$(lsattr "$DST_FILE")
@@ -320,38 +423,39 @@ convertDisk() {
 
   msg="Conversion of $DISK_DESC"
   html "$msg completed..."
-  info "$msg to $DST_FMT completed succesfully!"
+  info "$msg to $DST_FMT completed successfully!"
 
   return 0
 }
 
 checkFS () {
 
-  local FS=$1
+  local FS="$1"
-  local DISK_FILE=$2
+  local DISK_FILE="$2"
-  local DISK_DESC=$3
+  local DISK_DESC="$3"
-  local DIR FA
+  local DIR BASE_DIR FA
 
   DIR=$(dirname "$DISK_FILE")
+  BASE_DIR=$(baseDir "$DIR")
   [ ! -d "$DIR" ] && return 0
 
-  if [[ "${FS,,}" == "overlay"* ]]; then
+  if [[ "${FS,,}" == "overlay"* && "${ENGINE,,}" == "docker" ]]; then
-    info "Warning: the filesystem of $DIR is OverlayFS, this usually means it was binded to an invalid path!"
+    warn "the filesystem of $BASE_DIR is OverlayFS, this usually means it was binded to an invalid path!"
   fi
 
   if [[ "${FS,,}" == "fuse"* ]]; then
-    info "Warning: the filesystem of $DIR is FUSE, this extra layer will negatively affect performance!"
+    warn "the filesystem of $BASE_DIR is FUSE, this extra layer will negatively affect performance!"
   fi
 
   if ! supportsDirect "$FS"; then
-    info "Warning: the filesystem of $DIR is $FS, which does not support O_DIRECT mode, adjusting settings..."
+    warn "the filesystem of $BASE_DIR is $FS, which does not support O_DIRECT mode, adjusting settings..."
   fi
 
   if isCow "$FS"; then
     if [ -f "$DISK_FILE" ]; then
       FA=$(lsattr "$DISK_FILE")
       if [[ "$FA" != *"C"* ]]; then
-        info "Warning: COW (copy on write) is not disabled for $DISK_DESC image file $DISK_FILE, this is recommended on ${FS^^} filesystems!"
+        warn "COW (copy on write) is not disabled for $DISK_DESC image file $DISK_FILE, this is recommended on ${FS^^} filesystems!"
       fi
     fi
   fi
@@ -361,13 +465,15 @@ checkFS () {
 
 createDevice () {
 
-  local DISK_FILE=$1
+  local DISK_FILE="$1"
-  local DISK_TYPE=$2
+  local DISK_TYPE="$2"
-  local DISK_INDEX=$3
+  local DISK_INDEX="$3"
-  local DISK_ADDRESS=$4
+  local DISK_ADDRESS="$4"
-  local DISK_FMT=$5
+  local DISK_FMT="$5"
-  local DISK_IO=$6
+  local DISK_IO="$6"
-  local DISK_CACHE=$7
+  local DISK_CACHE="$7"
+  local DISK_SERIAL="$8"
+  local DISK_SECTORS="$9"
   local DISK_ID="data$DISK_INDEX"
 
   local index=""
@@ -381,29 +487,29 @@ createDevice () {
       ;;
     "usb" )
       result+=",if=none \
-      -device usb-storage,drive=${DISK_ID}${index}"
+      -device usb-storage,drive=${DISK_ID}${index}${DISK_SERIAL}${DISK_SECTORS}"
       echo "$result"
       ;;
     "nvme" )
       result+=",if=none \
-      -device nvme,drive=${DISK_ID}${index},serial=deadbeaf${DISK_INDEX}"
+      -device nvme,drive=${DISK_ID}${index},serial=deadbeaf${DISK_INDEX}${DISK_SERIAL}${DISK_SECTORS}"
       echo "$result"
       ;;
     "ide" | "sata" )
       result+=",if=none \
       -device ich9-ahci,id=ahci${DISK_INDEX},addr=$DISK_ADDRESS \
-      -device ide-hd,drive=${DISK_ID},bus=ahci$DISK_INDEX.0,rotation_rate=$DISK_ROTATION${index}"
+      -device ide-hd,drive=${DISK_ID},bus=ahci$DISK_INDEX.0,rotation_rate=$DISK_ROTATION${index}${DISK_SERIAL}${DISK_SECTORS}"
       echo "$result"
       ;;
     "blk" | "virtio-blk" )
       result+=",if=none \
-      -device virtio-blk-pci,drive=${DISK_ID},bus=pcie.0,addr=$DISK_ADDRESS,iothread=io2${index}"
+      -device virtio-blk-pci,drive=${DISK_ID},bus=pcie.0,addr=$DISK_ADDRESS,iothread=io2${index}${DISK_SERIAL}${DISK_SECTORS}"
       echo "$result"
       ;;
     "scsi" | "virtio-scsi" )
       result+=",if=none \
       -device virtio-scsi-pci,id=${DISK_ID}b,bus=pcie.0,addr=$DISK_ADDRESS,iothread=io2 \
-      -device scsi-hd,drive=${DISK_ID},bus=${DISK_ID}b.0,channel=0,scsi-id=0,lun=0,rotation_rate=$DISK_ROTATION${index}"
+      -device scsi-hd,drive=${DISK_ID},bus=${DISK_ID}b.0,channel=0,scsi-id=0,lun=0,rotation_rate=$DISK_ROTATION${index}${DISK_SERIAL}${DISK_SECTORS}"
       echo "$result"
       ;;
   esac
@@ -411,18 +517,32 @@ createDevice () {
   return 0
 }
 
+finishDisks () {
+
+  case "${DISK_TYPE,,}" in
+    "blk" | "scsi" | "virtio-blk" | "virtio-scsi" )
+      [[ "$DISK_OPTS" != *" -object iothread,id=io2"* ]] && DISK_OPTS+=" -object iothread,id=io2" ;;
+  esac
+
+  if ! enabled "$DISK_DISABLE"; then
+    html "Initialized disks successfully..."
+  fi
+
+  return 0
+}
+
 addDisk () {
 
-  local DISK_BASE=$1
+  local DISK_BASE="$1"
-  local DISK_TYPE=$2
+  local DISK_TYPE="$2"
-  local DISK_DESC=$3
+  local DISK_DESC="$3"
-  local DISK_SPACE=$4
+  local DISK_SPACE="$4"
-  local DISK_INDEX=$5
+  local DISK_INDEX="$5"
-  local DISK_ADDRESS=$6
+  local DISK_ADDRESS="$6"
-  local DISK_FMT=$7
+  local DISK_FMT="$7"
-  local DISK_IO=$8
+  local DISK_IO="$8"
-  local DISK_CACHE=$9
+  local DISK_CACHE="$9"
-  local DISK_EXT DIR SPACE DATA_SIZE FS PREV_FMT PREV_EXT CUR_SIZE
+  local DISK_EXT DIR SPACE DATA_SIZE FS PREV_FMT PREV_EXT CUR_SIZE LEFT FREE USED
 
   DISK_EXT=$(fmt2ext "$DISK_FMT")
   local DISK_FILE="$DISK_BASE.$DISK_EXT"
@@ -430,21 +550,9 @@ addDisk () {
   DIR=$(dirname "$DISK_FILE")
   [ ! -d "$DIR" ] && return 0
 
-  SPACE="${DISK_SPACE// /}"
+  SPACE=$(normalizeSize "$DISK_SPACE" "$DISK_DESC" "$DIR")
-  [ -z "$SPACE" ] && SPACE="16G"
-  [ -z "${SPACE//[0-9. ]}" ] && SPACE="${SPACE}G"
-  SPACE=$(echo "${SPACE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
-
-  if ! numfmt --from=iec "$SPACE" &>/dev/null; then
-    error "Invalid value for ${DISK_DESC^^}_SIZE: $DISK_SPACE" && exit 73
-  fi
-
   DATA_SIZE=$(numfmt --from=iec "$SPACE")
 
-  if (( DATA_SIZE < 6442450944 )); then
-    error "Please increase ${DISK_DESC^^}_SIZE to at least 6 GB." && exit 73
-  fi
-
   FS=$(stat -f -c %T "$DIR")
   checkFS "$FS" "$DISK_FILE" "$DISK_DESC" || exit $?
 
@@ -453,7 +561,7 @@ addDisk () {
     DISK_CACHE="writeback"
   fi
 
-  if ! [ -s "$DISK_FILE" ] ; then
+  if [ ! -s "$DISK_FILE" ] ; then
 
     if [[ "${DISK_FMT,,}" != "raw" ]]; then
       PREV_FMT="raw"
@@ -466,14 +574,26 @@ addDisk () {
     if [ -s "$DISK_BASE.$PREV_EXT" ] ; then
       convertDisk "$DISK_BASE.$PREV_EXT" "$PREV_FMT" "$DISK_FILE" "$DISK_FMT" "$DISK_BASE" "$DISK_DESC" "$FS" || exit $?
     fi
+
   fi
 
   if [ -s "$DISK_FILE" ]; then
 
-    CUR_SIZE=$(getSize "$DISK_FILE")
+    CUR_SIZE=$(getSize "$DISK_FILE") || exit 71
 
     if (( DATA_SIZE > CUR_SIZE )); then
+
       resizeDisk "$DISK_FILE" "$SPACE" "$DISK_DESC" "$DISK_FMT" "$FS" || exit $?
+
+    else
+
+      if (( DATA_SIZE < CUR_SIZE )); then
+
+        if [[ "${DISK_SPACE,,}" != "max" && "${DISK_SPACE,,}" != "half" ]]; then
+          info "You decreased the ${DISK_DESC^^}_SIZE variable to ${DISK_SPACE/G/ GB} but shrinking disks is not supported, will be ignored..."
+        fi
+
+      fi
     fi
 
   else
@@ -482,46 +602,142 @@ addDisk () {
 
   fi
 
-  DISK_OPTS+=$(createDevice "$DISK_FILE" "$DISK_TYPE" "$DISK_INDEX" "$DISK_ADDRESS" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE")
+  if [ -f "$DISK_FILE" ] && disabled "$ALLOCATE"; then
+
+    CUR_SIZE=$(getSize "$DISK_FILE") || exit 73
+    USED=$(du -sB 1 "$DISK_FILE" | cut -f1)
+    FREE=$(df --output=avail -B 1 "$DIR" | tail -n 1)
+    LEFT=$(( CUR_SIZE - USED - FREE ))
+    (( LEFT < 0 )) && LEFT=0
+
+    if (( LEFT > 0 )); then
+
+      local GB BASE_DIR
+      GB=$(formatBytes "$FREE")
+      BASE_DIR=$(baseDir "$DIR")
+      LEFT=$(formatBytes "$LEFT")
+      CUR_SIZE=$(formatBytes "$CUR_SIZE")
+      msg="The virtual size of the ${DISK_DESC,,} is $CUR_SIZE"
+
+      if [ -n "$USED" ] && [[ "$USED" != "0" ]]; then
+        USED=$(formatBytes "$USED")
+        msg+=" (of which $USED is used)"
+      fi
+
+      info "$msg, but there is only $GB of free space remaining in $BASE_DIR now."
+      info "Please consider making at least $LEFT more space available in $BASE_DIR for future expansions."
+
+    fi
+
+  fi
+
+  if [ -f "$DISK_FILE" ]; then
+    if ! setOwner "$DISK_FILE"; then
+      warn "failed to set the owner for \"$DISK_FILE\" !"
+    fi
+  fi
+
+  DISK_OPTS+=$(createDevice "$DISK_FILE" "$DISK_TYPE" "$DISK_INDEX" "$DISK_ADDRESS" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE" "" "")
 
   return 0
 }
 
 addDevice () {
 
-  local DISK_DEV=$1
+  local DISK_DEV="$1"
-  local DISK_TYPE=$2
+  local DISK_TYPE="$2"
-  local DISK_INDEX=$3
+  local DISK_INDEX="$3"
-  local DISK_ADDRESS=$4
+  local DISK_ADDRESS="$4"
 
   [ -z "$DISK_DEV" ] && return 0
   [ ! -b "$DISK_DEV" ] && error "Device $DISK_DEV cannot be found! Please add it to the 'devices' section of your compose file." && exit 55
 
-  DISK_OPTS+=$(createDevice "$DISK_DEV" "$DISK_TYPE" "$DISK_INDEX" "$DISK_ADDRESS" "raw" "$DISK_IO" "$DISK_CACHE")
+  local sectors=""
+  local dev_type=""
+  dev_type=$(lsblk -no TYPE "$DISK_DEV" 2>/dev/null | head -n1)
+
+  # Only detect and apply sector sizes for partitions, not whole disks
+  # Whole disk passthrough with explicit sector sizes causes DSM not to recognize the disk
+  if [[ "$dev_type" == "part" ]]; then
+    local result=""
+    local logical=""
+    local physical=""
+
+    result=$(fdisk -l "$DISK_DEV" 2>/dev/null | grep -m 1 -o "(logical/physical): .*" | cut -c 21- || true)
+
+    if [ -n "$result" ]; then
+      logical="${result%% *}"
+      physical=$(echo "$result" | grep -m 1 -o "/ .*" | cut -c 3- || true)
+      physical="${physical%% *}"
+    fi
+
+    if [ -z "$logical" ] || [ -z "$physical" ]; then
+      warn "Failed to determine the sector size for $DISK_DEV"
+    elif [[ "$physical" != "512" ]]; then
+      sectors=",logical_block_size=$logical,physical_block_size=$physical"
+    fi
+  fi
+
+  DISK_OPTS+=$(createDevice "$DISK_DEV" "$DISK_TYPE" "$DISK_INDEX" "$DISK_ADDRESS" "raw" "$DISK_IO" "$DISK_CACHE" "" "$sectors")
 
   return 0
 }
 
-html "Initializing disks..."
-
 [ -z "${DISK_OPTS:-}" ] && DISK_OPTS=""
 [ -z "${DISK_TYPE:-}" ] && DISK_TYPE="scsi"
 [ -z "${DISK_NAME:-}" ] && DISK_NAME="data"
+[ -z "${DISK_DISABLE:-}" ] && DISK_DISABLE=""
+
+if ! enabled "$DISK_DISABLE"; then
+  msg="Initializing disks..."
+  html "$msg"
+  enabled "$DEBUG" && echo "$msg"
+fi
+
+if [[ "${DISK_IO,,}" == "native" && "${DISK_CACHE,,}" != "none" && "${DISK_CACHE,,}" != "directsync" ]]; then
+  warn "DISK_IO=native requires direct I/O caching, using DISK_IO=threads with DISK_CACHE=$DISK_CACHE."
+  DISK_IO="threads"
+fi
+
+case "${DISK_DISCARD,,}" in
+  "y" | "yes" | "true" | "1" | "on" | "unmap" )
+    DISK_DISCARD="unmap" ;;
+
+  "n" | "no" | "false" | "0" | "off" | "ignore" )
+    DISK_DISCARD="ignore" ;;
+
+  * )
+    warn "Invalid DISK_DISCARD value '$DISK_DISCARD', using 'unmap'."
+    DISK_DISCARD="unmap" ;;
+esac
+
+if [[ ! "$DISK_ROTATION" =~ ^[0-9]+$ ]]; then
+  warn "Invalid DISK_ROTATION value '$DISK_ROTATION', using 1."
+  DISK_ROTATION="1"
+fi
+
+DISK_FMT="${DISK_FMT,,}"
+
+case "$DISK_FMT" in
+  "raw" | "qcow2" ) ;;
+  * ) error "Invalid DISK_FMT specified, value \"$DISK_FMT\" is not recognized!" && exit 78 ;;
+esac
 
 case "${DISK_TYPE,,}" in
-  "ide" | "sata" | "nvme" | "usb" | "scsi" | "blk" | "auto" | "none" ) ;;
+  "ide" | "sata" | "nvme" | "usb" | "scsi" | "blk" | "virtio-blk" | "virtio-scsi" | "auto" | "none" ) ;;
   * ) error "Invalid DISK_TYPE specified, value \"$DISK_TYPE\" is not recognized!" && exit 80 ;;
 esac
 
-if [ -z "$ALLOCATE" ]; then
+if [[ "$DISK_FLAGS" =~ [[:space:]] ]]; then
-  if [[ "${DISK_FMT,,}" == "raw" ]]; then
+  error "Invalid DISK_FLAGS value '$DISK_FLAGS', spaces are not allowed."
-    ALLOCATE="Y"
+  exit 78
-  else
-    ALLOCATE="N"
-  fi
 fi
 
-if [[ "$ALLOCATE" == [Nn]* ]]; then
+if [ -z "$ALLOCATE" ]; then
+  ALLOCATE="N"
+fi
+
+if disabled "$ALLOCATE"; then
   DISK_STYLE="growable"
   DISK_ALLOC="preallocation=off"
 else
@@ -529,41 +745,17 @@ else
   DISK_ALLOC="preallocation=falloc"
 fi
 
-DISK_OPTS+=$(createDevice "$BOOT" "$DISK_TYPE" "1" "0xa" "raw" "$DISK_IO" "$DISK_CACHE")
+DISK_OPTS+=$(createDevice "$BOOT" "$DISK_TYPE" "1" "0xa" "raw" "$DISK_IO" "$DISK_CACHE" "" "")
-DISK_OPTS+=$(createDevice "$SYSTEM" "$DISK_TYPE" "2" "0xb" "raw" "$DISK_IO" "$DISK_CACHE")
+DISK_OPTS+=$(createDevice "$SYSTEM" "$DISK_TYPE" "2" "0xb" "raw" "$DISK_IO" "$DISK_CACHE" "" "")
+
+if enabled "$DISK_DISABLE"; then
+  finishDisks
+  return 0
+fi
 
 DISK1_FILE="$STORAGE/${DISK_NAME}"
-if [[ ! -f "$DISK1_FILE.img" ]] && [[ -f "$STORAGE/data${DISK_SIZE}.img" ]]; then
-  # Fallback for legacy installs
-  mv "$STORAGE/data${DISK_SIZE}.img" "$DISK1_FILE.img"
-fi
-
 DISK2_FILE="/storage2/${DISK_NAME}2"
-if [ ! -f "$DISK2_FILE.img" ]; then
-  # Fallback for legacy installs
-  FALLBACK="/storage2/data.img"
-  if [[ -f "$DISK1_FILE.img" ]] && [[ -f "$FALLBACK" ]]; then
-    SIZE1=$(stat -c%s "$FALLBACK")
-    SIZE2=$(stat -c%s "$DISK1_FILE.img")
-    if [[ SIZE1 -ne SIZE2 ]]; then
-      mv "$FALLBACK" "$DISK2_FILE.img"
-    fi
-  fi
-fi
-
 DISK3_FILE="/storage3/${DISK_NAME}3"
-if [ ! -f "$DISK3_FILE.img" ]; then
-  # Fallback for legacy installs
-  FALLBACK="/storage3/data.img"
-  if [[ -f "$DISK1_FILE.img" ]] && [[ -f "$FALLBACK" ]]; then
-    SIZE1=$(stat -c%s "$FALLBACK")
-    SIZE2=$(stat -c%s "$DISK1_FILE.img")
-    if [[ SIZE1 -ne SIZE2 ]]; then
-      mv "$FALLBACK" "$DISK3_FILE.img"
-    fi
-  fi
-fi
-
 DISK4_FILE="/storage4/${DISK_NAME}4"
 
 : "${DISK2_SIZE:=""}"
@@ -586,31 +778,23 @@ DISK4_FILE="/storage4/${DISK_NAME}4"
 [ -z "$DEVICE3" ] && [ -b "/dev/disk3" ] && DEVICE3="/dev/disk3"
 [ -z "$DEVICE4" ] && [ -b "/dev/disk4" ] && DEVICE4="/dev/disk4"
 
-if [ -n "$DEVICE" ]; then
+DISK_FILES=( "$DISK1_FILE" "$DISK2_FILE" "$DISK3_FILE" "$DISK4_FILE" )
-  addDevice "$DEVICE" "$DISK_TYPE" "3" "0xc" || exit $?
+DISK_DESCS=( "disk" "disk2" "disk3" "disk4" )
-else
+DISK_SIZES=( "$DISK_SIZE" "$DISK2_SIZE" "$DISK3_SIZE" "$DISK4_SIZE" )
-  addDisk "$DISK1_FILE" "$DISK_TYPE" "disk" "$DISK_SIZE" "3" "0xc" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE" || exit $?
+DISK_DEVICES=( "$DEVICE" "$DEVICE2" "$DEVICE3" "$DEVICE4" )
-fi
+DISK_INDEXES=( "3" "4" "5" "6" )
+DISK_ADDRESSES=( "0xc" "0xd" "0xe" "0xf" )
 
-if [ -n "$DEVICE2" ]; then
+for i in "${!DISK_FILES[@]}"; do
-  addDevice "$DEVICE2" "$DISK_TYPE" "4" "0xd" || exit $?
-else
-  addDisk "$DISK2_FILE" "$DISK_TYPE" "disk2" "$DISK2_SIZE" "4" "0xd" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE" || exit $?
-fi
 
-if [ -n "$DEVICE3" ]; then
+  if [ -n "${DISK_DEVICES[i]}" ]; then
-  addDevice "$DEVICE3" "$DISK_TYPE" "5" "0xe" || exit $?
+    addDevice "${DISK_DEVICES[i]}" "$DISK_TYPE" "${DISK_INDEXES[i]}" "${DISK_ADDRESSES[i]}" || exit $?
-else
+  else
-  addDisk "$DISK3_FILE" "$DISK_TYPE" "disk3" "$DISK3_SIZE" "5" "0xe" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE" || exit $?
+    addDisk "${DISK_FILES[i]}" "$DISK_TYPE" "${DISK_DESCS[i]}" "${DISK_SIZES[i]}" "${DISK_INDEXES[i]}" "${DISK_ADDRESSES[i]}" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE" || exit $?
-fi
+  fi
 
-if [ -n "$DEVICE4" ]; then
+done
-  addDevice "$DEVICE4" "$DISK_TYPE" "6" "0xf" || exit $?
-else
-  addDisk "$DISK4_FILE" "$DISK_TYPE" "disk4" "$DISK4_SIZE" "6" "0xf" "$DISK_FMT" "$DISK_IO" "$DISK_CACHE" || exit $?
-fi
 
-DISK_OPTS+=" -object iothread,id=io2"
+finishDisks
 
-html "Initialized disks successfully..."
 return 0

src/display.sh

@@ -8,7 +8,14 @@ set -Eeuo pipefail
 : "${DISPLAY:="none"}"  # Display type
 : "${RENDERNODE:="/dev/dri/renderD128"}"  # Render node
 
-if [[ "$GPU" != [Yy1]* ]] || [[ "$ARCH" != "amd64" ]]; then
+# Sanitize variables
+VGA=$(strip "$VGA")
+DISPLAY=$(strip "$DISPLAY")
+RENDERNODE=$(strip "$RENDERNODE")
+
+CPU_VENDOR=$(lscpu | awk '/Vendor ID/{print $3}')
+
+if ! enabled "$GPU" || [[ "$CPU_VENDOR" != "GenuineIntel" || "$ARCH" != "amd64" ]]; then
 
   [[ "${DISPLAY,,}" == "none" ]] && VGA="none"
   DISPLAY_OPTS="-display $DISPLAY -vga $VGA"
@@ -16,6 +23,10 @@ if [[ "$GPU" != [Yy1]* ]] || [[ "$ARCH" != "amd64" ]]; then
 
 fi
 
+msg="Configuring display drivers..."
+html "$msg"
+enabled "$DEBUG" && echo "$msg"
+
 DISPLAY_OPTS="-display egl-headless,rendernode=$RENDERNODE"
 DISPLAY_OPTS+=" -vga $VGA"
 

src/entry.sh

@@ -1,13 +1,16 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
+: "${PLATFORM:="x64"}"
 : "${APP:="Virtual DSM"}"
 : "${SUPPORT:="https://github.com/vdsm/virtual-dsm"}"
 
 cd /run
 
+. start.sh      # Startup hook
 . utils.sh      # Load functions
 . reset.sh      # Initialize system
+. server.sh     # Start webserver
 . install.sh    # Run installation
 . disk.sh       # Initialize disks
 . display.sh    # Initialize graphics
@@ -15,23 +18,29 @@ cd /run
 . proc.sh       # Initialize processor
 . serial.sh     # Initialize serialport
 . power.sh      # Configure shutdown
+. memory.sh     # Check available memory
 . config.sh     # Configure arguments
+. finish.sh     # Finish initialization
 
 trap - ERR
 
-version=$(qemu-system-x86_64 --version | head -n 1 | cut -d '(' -f 1 | awk '{ print $NF }')
+cmd=(qemu-system-x86_64)
-info "Booting $APP using QEMU v$version..."
+version=$("${cmd[@]}" --version | awk 'NR==1 { print $4 }')
+info "Booting $APP using QEMU v$version..." && echo
 
-if [[ "$CONSOLE" == [Yy]* ]]; then
+if ! enabled "$SHUTDOWN"; then
-  exec qemu-system-x86_64 ${ARGS:+ $ARGS}
+  exec "${cmd[@]}" ${ARGS:+ $ARGS}
 fi
 
-{ qemu-system-x86_64 ${ARGS:+ $ARGS} >"$QEMU_OUT" 2>"$QEMU_LOG"; rc=$?; } || :
+if [ ! -t 1 ] || [ ! -c /dev/tty ]; then
-(( rc != 0 )) && error "$(<"$QEMU_LOG")" && exit 15
+  "${cmd[@]}" ${ARGS:+ $ARGS} &
+else
+  "${cmd[@]}" ${ARGS:+ $ARGS} </dev/tty >/dev/tty &
+fi
 
-terminal
+rc=0
-tail -fn +0 "$QEMU_LOG" 2>/dev/null &
+wait $! || rc=$?
-cat "$QEMU_TERM" 2>/dev/null & wait $! || :
+[ -f "$QEMU_END" ] && exit "$rc"
 
 sleep 1 & wait $!
-[ ! -f "$QEMU_END" ] && finish 0
+finish "$rc"

src/finish.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+if enabled "$DEBUG"; then
+  printf "QEMU arguments:\n\n%s\n\n" "${ARGS// -/$'\n-'}"
+fi
+
+return 0

src/install.sh

@@ -13,32 +13,36 @@ else
 fi
 
 FN="boot.pat"
-if [ -d "/$FN" ]; then
+DIR=$(find / -maxdepth 1 -type d -iname "$FN" -print -quit)
-  error "The file /$FN does not exist, please check that you mapped it to a valid path!" && exit 65
+[ ! -d "$DIR" ] && DIR=$(find "$STORAGE" -maxdepth 1 -type d -iname "$FN" -print -quit)
-fi
 
-FILE=$(find / -maxdepth 1 -type f -iname "$FN" | head -n 1)
+if [ -d "$DIR" ]; then
-[ ! -s "$FILE" ] && FILE=$(find "$STORAGE" -maxdepth 1 -type f -iname "$FN" | head -n 1)
+  BASE="DSM_VirtualDSM" && URL="file://$DIR"
-[ -s "$FILE" ] && BASE="DSM_VirtualDSM" && URL="file://$FILE" 
+  if [[ ! -s "$STORAGE/$BASE.boot.img" || ! -s "$STORAGE/$BASE.system.img" ]]; then
-
+    error "The bind $DIR maps to a file that does not exist!" && exit 65
-if [ -n "$URL" ]; then
-  if [ ! -s "$FILE" ]; then
-    BASE=$(basename "$URL" .pat)
-    if [ ! -s "$STORAGE/$BASE.system.img" ]; then
-      BASE=$(basename "${URL%%\?*}" .pat)
-      : "${BASE//+/ }"; printf -v BASE '%b' "${_//%/\\x}"
-      BASE=$(echo "$BASE" | sed -e 's/[^A-Za-z0-9._-]/_/g')
-    fi
-  fi
-  if [[ "${URL,,}" != "http"* ]] && [[ "${URL,,}" != "file:"* ]] ; then
-    URL="file:///$BASE.pat"
-    if [ ! -s "/$BASE.pat" ]; then
-      error "File '$BASE.pat' does not exist!" && exit 65
-    fi
   fi
 fi
 
-if [[ -s "$STORAGE/$BASE.boot.img" ]] && [[ -s "$STORAGE/$BASE.system.img" ]]; then
+FILE=$(find / -maxdepth 1 -type f -iname "$FN" -print -quit)
+[ ! -s "$FILE" ] && FILE=$(find "$STORAGE" -maxdepth 1 -type f -iname "$FN" -print -quit)
+[ -s "$FILE" ] && BASE="DSM_VirtualDSM" && URL="file://$FILE"
+
+URL=$(strip "$URL")
+
+if [ -n "$URL" ] && [ ! -s "$FILE" ] && [ ! -d "$DIR" ]; then
+  BASE=$(basename "$URL" .pat)
+  if [ ! -s "$STORAGE/$BASE.system.img" ]; then
+    BASE=$(basename "${URL%%\?*}" .pat)
+    printf -v BASE '%b' "${BASE//%/\\x}"
+    BASE="${BASE//[!A-Za-z0-9._-]/_}"
+  fi
+  if [[ "${URL,,}" != "http"* && "${URL,,}" != "file:"* ]]; then
+    [ ! -s "$STORAGE/$BASE.pat" ] && error "Invalid URL:  $URL" && exit 65
+    URL="file://$STORAGE/$BASE.pat"
+  fi
+fi
+
+if [[ -s "$STORAGE/$BASE.boot.img" && -s "$STORAGE/$BASE.system.img" ]]; then
   return 0  # Previous installation found
 fi
 
@@ -63,8 +67,8 @@ fi
 
 if [ ! -s "$FILE" ]; then
   BASE=$(basename "${URL%%\?*}" .pat)
-  : "${BASE//+/ }"; printf -v BASE '%b' "${_//%/\\x}"
+  printf -v BASE '%b' "${BASE//%/\\x}"
-  BASE=$(echo "$BASE" | sed -e 's/[^A-Za-z0-9._-]/_/g')
+  BASE="${BASE//[!A-Za-z0-9._-]/_}"
 fi
 
 if [[ "$URL" != "file://$STORAGE/$BASE.pat" ]]; then
@@ -78,16 +82,16 @@ rm -f "$STORAGE/$BASE.system.img"
 # Check filesystem
 FS=$(stat -f -c %T "$STORAGE")
 
-if [[ "${FS,,}" == "overlay"* ]]; then
+if [[ "${FS,,}" == "overlay"* && "${ENGINE,,}" == "docker" ]]; then
-  info "Warning: the filesystem of $STORAGE is OverlayFS, this usually means it was binded to an invalid path!"
+  warn "the filesystem of $STORAGE is OverlayFS, this usually means it was binded to an invalid path!"
 fi
 
 if [[ "${FS,,}" == "fuse"* ]]; then
-  info "Warning: the filesystem of $STORAGE is FUSE, this extra layer will negatively affect performance!"
+  warn "the filesystem of $STORAGE is FUSE, this extra layer will negatively affect performance!"
 fi
 
-if [[ "${FS,,}" == "ecryptfs" ]] || [[ "${FS,,}" == "tmpfs" ]]; then
+if [[ "${FS,,}" == "ecryptfs" || "${FS,,}" == "tmpfs" ]]; then
-  info "Warning: the filesystem of $STORAGE is $FS, which does not support O_DIRECT mode, adjusting settings..."
+  warn "the filesystem of $STORAGE is $FS, which does not support O_DIRECT mode, adjusting settings..."
 fi
 
 if [[ "${FS,,}" == "fat"* || "${FS,,}" == "vfat"* || "${FS,,}" == "msdos"* ]]; then
@@ -96,6 +100,10 @@ fi
 
 if [[ "${FS,,}" != "exfat"* && "${FS,,}" != "ntfs"* && "${FS,,}" != "unknown"* ]]; then
   TMP="$STORAGE/tmp"
+  rm -rf "$TMP"
+  if ! makeDir "$TMP"; then
+    error "Failed to create directory \"$TMP\" !" && exit 93
+  fi
 else
   TMP="/tmp/dsm"
   TMP_SPACE=2147483648
@@ -104,10 +112,9 @@ else
   if (( TMP_SPACE > SPACE )); then
     error "Not enough free space inside the container, have $SPACE_MB available but need at least 2 GB." && exit 93
   fi
+  rm -rf "$TMP" && mkdir -p "$TMP"
 fi
 
-rm -rf "$TMP" && mkdir -p "$TMP"
-
 # Check free diskspace
 ROOT_SPACE=536870912
 SPACE=$(df --output=avail -B 1 / | tail -n 1)
@@ -152,20 +159,44 @@ if [[ "$URL" == "file://"* ]]; then
 else
 
   SIZE=0
+  REASON=""
+  LOG=$(mktemp)
+
   [[ "${URL,,}" == *"_72806.pat" ]] && SIZE=361010261
   [[ "${URL,,}" == *"_69057.pat" ]] && SIZE=363837333
   [[ "${URL,,}" == *"_42218.pat" ]] && SIZE=379637760
 
   /run/progress.sh "$PAT" "$SIZE" "$MSG ([P])..." &
 
-  { wget "$URL" -O "$PAT" -q --no-check-certificate --timeout=10 --no-http-keep-alive --show-progress "$PROGRESS"; rc=$?; } || :
+  {
+    LC_ALL=C wget "$URL" -O "$PAT" --no-verbose --no-check-certificate \
+      --timeout=30 --no-http-keep-alive --show-progress "$PROGRESS" \
+      --output-file="$LOG"
+    rc=$?
+  } || :
 
   fKill "progress.sh"
 
-  (( rc == 3 )) && error "$ERR , cannot write file (disk full?)" && exit 69
+  if (( rc != 0 )); then
-  (( rc == 4 )) && error "$ERR , network failure!" && exit 69
+    REASON=$(sed -n \
-  (( rc == 8 )) && error "$ERR , server issued an error response!" && exit 69
+      -e 's/^wget: //p' \
-  (( rc != 0 )) && error "$ERR , reason: $rc" && exit 69
+      -e 's/^[0-9-]\{10\} [0-9:]\{8\} ERROR //p' \
+      "$LOG" | tail -n 1)
+  fi
+
+  rm -f "$LOG"
+
+  if (( rc == 3 )); then
+    error "$ERR because the file could not be written (disk full?)."
+    exit 69
+  elif (( rc != 0 )); then
+    if [ -n "$REASON" ]; then
+      error "$ERR: ${REASON%.}."
+    else
+      error "$ERR with exit status $rc."
+    fi
+    exit 69
+  fi
 
 fi
 
@@ -198,11 +229,12 @@ fi
 MSG="Preparing system partition..."
 info "Install: $MSG" && html "$MSG"
 
-BOOT=$(find "$TMP" -name "*.bin.zip")
+BOOT=$(find "$TMP" -name "*.bin.zip" -print -quit)
-[ ! -s "$BOOT" ] && error "The PAT file contains no boot image." && exit 67
+[ -z "$BOOT" ] && error "The PAT file contains no boot image." && exit 67
+[ ! -s "$BOOT" ] && error "The PAT boot image archive is empty." && exit 67
 
-BOOT=$(echo "$BOOT" | head -c -5)
+unzip -q -o "$BOOT" -d "$TMP"
-unzip -q -o "$BOOT".zip -d "$TMP"
+BOOT="${BOOT%.zip}"
 
 SYSTEM="$STORAGE/$BASE.system.img"
 rm -f "$SYSTEM"
@@ -220,6 +252,8 @@ if ! touch "$SYSTEM"; then
   error "Could not create file $SYSTEM for the system disk." && exit 98
 fi
 
+! setOwner "$SYSTEM" && warn "failed to set the owner for \"$SYSTEM\" !"
+
 if [[ "${FS,,}" == "btrfs" ]]; then
   { chattr +C "$SYSTEM"; } || :
   FA=$(lsattr "$SYSTEM")
@@ -239,20 +273,25 @@ fi
 
 PART="$TMP/partition.fdisk"
 
-{       echo "label: dos"
+{
-        echo "label-id: 0x6f9ee2e9"
+  echo "label: dos"
-        echo "device: $SYSTEM"
+  echo "label-id: 0x6f9ee2e9"
-        echo "unit: sectors"
+  echo "device: $SYSTEM"
-        echo "sector-size: 512"
+  echo "unit: sectors"
-        echo ""
+  echo "sector-size: 512"
-        echo "${SYSTEM}1 : start=        2048, size=    16777216, type=83"
+  echo ""
-        echo "${SYSTEM}2 : start=    16779264, size=     4194304, type=82"
+  echo "${SYSTEM}1 : start=        2048, size=    16777216, type=83"
+  echo "${SYSTEM}2 : start=    16779264, size=     4194304, type=82"
 } > "$PART"
 
 sfdisk -q "$SYSTEM" < "$PART"
 
 MOUNT="$TMP/system"
-rm -rf "$MOUNT" && mkdir -p "$MOUNT"
+rm -rf "$MOUNT"
+
+if ! makeDir "$MOUNT"; then
+  error "Failed to create directory \"$MOUNT\" !" && exit 93
+fi
 
 MSG="Extracting system partition..."
 info "Install: $MSG" && html "$MSG"
@@ -268,12 +307,10 @@ mv "$HDA.tgz" "$HDA.txz"
 [ -d "$PKG" ] && mv "$PKG/" "$MOUNT/.SynoUpgradePackages/"
 rm -f "$MOUNT/.SynoUpgradePackages/ActiveInsight-"*
 
-[ -s "$HDP.txz" ] && tar xpfJ "$HDP.txz" --absolute-names -C "$MOUNT/"
+INDEX_DB="$MOUNT/usr/syno/synoman/indexdb"
 
 if [ -s "$IDB.txz" ]; then
-  INDEX_DB="$MOUNT/usr/syno/synoman/indexdb/"
   mkdir -p "$INDEX_DB"
-  tar xpfJ "$IDB.txz" --absolute-names -C "$INDEX_DB"
 fi
 
 LABEL="1.44.1-42218"
@@ -282,12 +319,15 @@ NUMBLOCKS="2097152" # (16777216 * 512) / 4096
 MSG="Installing system partition..."
 
 fakeroot -- bash -c "set -Eeu;\
+  [ -s $HDP.txz ] && tar xpfJ $HDP.txz --absolute-names -C $MOUNT/;\
+  [ -s $IDB.txz ] && tar xpfJ $IDB.txz --absolute-names -C $INDEX_DB/;\
   tar xpfJ $HDA.txz --absolute-names --skip-old-files -C $MOUNT/;\
   printf '%b%s%b' '\E[1;34m❯ \E[1;36m' 'Install: $MSG' '\E[0m\n';\
   mke2fs -q -t ext4 -b 4096 -d $MOUNT/ -L $LABEL -F -E offset=$OFFSET $SYSTEM $NUMBLOCKS"
 
 rm -rf "$MOUNT"
 echo "$BASE" > "$STORAGE/dsm.ver"
+! setOwner "$STORAGE/dsm.ver" && warn "failed to set the owner for \"$STORAGE/dsm.ver\" !"
 
 if [[ "$URL" == "file://$STORAGE/$BASE.pat" ]]; then
   rm -f "$PAT"
@@ -295,10 +335,13 @@ else
   mv -f "$PAT" "$STORAGE/$BASE.pat"
 fi
 
+if [ -f "$STORAGE/$BASE.pat" ]; then
+  ! setOwner "$STORAGE/$BASE.pat" && warn "failed to set the owner for \"$STORAGE/$BASE.pat\" !"
+fi
+
 mv -f "$BOOT" "$STORAGE/$BASE.boot.img"
+! setOwner "$STORAGE/$BASE.boot.img" && warn "failed to set the owner for \"$STORAGE/$BASE.boot.img\" !"
+
 rm -rf "$TMP"
 
-html "Booting DSM instance..."
-sleep 1.2
-
 return 0

src/memory.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+msg="Checking memory..."
+enabled "$DEBUG" && echo "$msg"
+
+app() {
+  echo "Virtual DSM"
+  return 0
+}
+
+checkConfiguredMemory() {
+  local wanted msg
+
+  if disabled "$RAM_CHECK" || [[ "${RAM_SIZE,,}" == "max" || "${RAM_SIZE,,}" == "half" ]]; then
+    return 0
+  fi
+
+  wanted=$(numfmt --from=iec "$RAM_SIZE")
+
+  if (( (wanted + RAM_SPARE) > RAM_AVAIL )); then
+    msg="Your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is too high for the $AVAIL_MEM of free memory available,"
+    if [[ "${FS,,}" == "zfs" ]]; then
+      info "$msg but since ZFS is active this will be ignored."
+    else
+      RAM_SIZE="max"
+      warn "$msg it will automatically be adjusted to a lower amount."
+    fi
+  else
+    if (( (wanted + (RAM_SPARE * 3)) > RAM_AVAIL )); then
+      msg="your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is very close to the $AVAIL_MEM of free memory available,"
+      if [[ "${FS,,}" == "zfs" ]]; then
+        info "$msg but since ZFS is active this will be ignored."
+      else
+        warn "$msg please consider a lower amount."
+      fi
+    fi
+  fi
+
+  return 0
+}
+
+configureHalfMemory() {
+  local wanted
+
+  if [[ "${RAM_SIZE,,}" != "half" ]]; then
+    return 0
+  fi
+
+  if (( (RAM_AVAIL / 2) > RAM_SPARE )); then
+    wanted=$(( (RAM_AVAIL / 2) / 1048577 ))
+    RAM_SIZE="${wanted}M"
+    info "Allocated $wanted MB of RAM for $(app)."
+  else
+    RAM_SIZE="max"
+  fi
+
+  return 0
+}
+
+configureMaxMemory() {
+  local wanted
+
+  if [[ "${RAM_SIZE,,}" != "max" ]]; then
+    return 0
+  fi
+
+  if (( RAM_AVAIL < (RAM_SPARE * 2) )); then
+
+    wanted=$(( RAM_AVAIL / 2 ))
+
+  else
+
+    wanted=$(( RAM_AVAIL - (RAM_SPARE * 3) ))
+
+    if (( wanted < (RAM_SPARE * 6) )); then
+      wanted=$(( RAM_AVAIL - RAM_SPARE ))
+    fi
+
+  fi
+
+  wanted=$(( wanted / 1048577 ))
+  RAM_SIZE="${wanted}M"
+
+  info "Allocated $wanted MB of RAM for $(app)."
+
+  return 0
+}
+
+checkMinimumMemory() {
+  local wanted
+
+  wanted=$(numfmt --from=iec "$RAM_SIZE")
+
+  if [ "$wanted" -lt "$RAM_MINIMUM" ]; then
+    wanted=$(( wanted / 1048577 ))
+    error "Not enough memory available, there is only $wanted MB left!"
+    exit 16
+  fi
+
+  return 0
+}
+
+getMemoryInfo
+AVAIL_MEM=$(formatBytes "$RAM_AVAIL")
+
+checkConfiguredMemory
+configureHalfMemory
+configureMaxMemory
+checkMinimumMemory
+
+return 0

src/power.sh

@@ -1,135 +1,131 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
+: "${SHUTDOWN:="Y"}"        # Graceful ACPI shutdown
+: "${TIMEOUT:="115"}"       # QEMU termination timeout
+: "${API_TIMEOUT:="90"}"    # External API call timeout
+
 # Configure QEMU for graceful shutdown
 
 API_CMD=6
-API_TIMEOUT=50
+API_HOST="127.0.0.1:$COM_PORT"
-API_HOST="127.0.0.1:2210"
+
+# Configure QEMU for graceful shutdown
 
-QEMU_TERM=""
-QEMU_PORT=7100
-QEMU_TIMEOUT=50
-QEMU_DIR="/run/shm"
-QEMU_PID="$QEMU_DIR/qemu.pid"
-QEMU_LOG="$QEMU_DIR/qemu.log"
-QEMU_OUT="$QEMU_DIR/qemu.out"
 QEMU_END="$QEMU_DIR/qemu.end"
 
-if [[ "$KVM" == [Nn]* ]]; then
-  API_TIMEOUT=$(( API_TIMEOUT*2 ))
-  QEMU_TIMEOUT=$(( QEMU_TIMEOUT*2 ))
-fi
-
-touch "$QEMU_LOG"
-
 _trap() {
-  func="$1" ; shift
+
-  for sig ; do
+  local func="$1"; shift
+  local sig
+  TRAP_PID=$BASHPID
+
+  for sig; do
     trap "$func $sig" "$sig"
   done
+
+  return 0
+}
+
+signalCode() {
+
+  local sig="$1"
+
+  case "$sig" in
+    SIGHUP)  echo 129 ;;
+    SIGINT)  echo 130 ;;
+    SIGQUIT) echo 131 ;;
+    SIGABRT) echo 134 ;;
+    SIGTERM) echo 143 ;;
+    *)       echo 0 ;;
+  esac
+
+  return 0
+}
+
+displayReason() {
+
+  local reason="$1"
+
+  case "$reason" in
+    129 ) echo "SIGHUP" ;;
+    130 ) echo "SIGINT" ;;
+    131 ) echo "SIGQUIT" ;;
+    134 ) echo "SIGABRT" ;;
+    143 ) echo "SIGTERM" ;;
+    * )   echo "$reason" ;;
+  esac
+
+  return 0
+}
+
+readQemuPid() {
+
+  local -n _pid="$1"
+
+  if [ ! -s "$QEMU_PID" ] || ! read -r _pid <"$QEMU_PID"; then
+    return 1
+  fi
+
+  return 0
+}
+
+forceKillQemu() {
+
+  local reason="$1"
+  local pid=""
+  local display
+
+  ! readQemuPid pid && return 0
+  ! isAlive "$pid" && return 0
+
+  display=$(displayReason "$reason")
+  error "Forcefully terminating $(app), reason: $display..."
+  { disown "$pid" || :; kill -9 -- "$pid" || :; } 2>/dev/null
+
+  return 0
+}
+
+cleanupHelpers() {
+
+  local pids=( "${HOST_PID:-}" "${WSD_PID:-}" \
+               "${WEB_PID:-}" "${PASST_PID:-}" "${DNSMASQ_PID:-}" )
+
+  mKill "${pids[@]}"
+  fKill "print.sh"
+
+  closeNetwork
+  return 0
 }
 
 finish() {
 
-  local pid
   local reason=$1
-
   touch "$QEMU_END"
 
-  if [ -s "$QEMU_PID" ]; then
+  forceKillQemu "$reason"
+  cleanupHelpers
 
-    pid=$(<"$QEMU_PID")
+  if ! waitPidFile "$QEMU_PID" 10; then
-    echo && error "Forcefully terminating QEMU process, reason: $reason..."
+    warn "Timed out while waiting for $(app) to exit!"
-    { kill -15 "$pid" || true; } 2>/dev/null
-
-    while isAlive "$pid"; do
-      sleep 1
-      # Workaround for zombie pid
-      [ ! -s "$QEMU_PID" ] && break
-    done
   fi
 
-  fKill "print.sh"
+  (( reason != 1 )) && echo && echo "❯ Shutdown completed!"
-  fKill "host.bin"
-
-  closeNetwork
-
-  sleep 1
-  echo && echo "❯ Shutdown completed!"
 
   exit "$reason"
 }
 
-terminal() {
+sendGuestShutdown() {
 
-  local dev=""
+  local pid="$1"
-
+  local response
-  if [ -s "$QEMU_OUT" ]; then
+  local url
-
-    local msg
-    msg=$(<"$QEMU_OUT")
-
-    if [ -n "$msg" ]; then
-
-      if [[ "${msg,,}" != "char"* ||  "$msg" != *"serial0)" ]]; then
-        echo "$msg"
-      fi
-
-      dev="${msg#*/dev/p}"
-      dev="/dev/p${dev%% *}"
-
-    fi
-  fi
-
-  if [ ! -c "$dev" ]; then
-    dev=$(echo 'info chardev' | nc -q 1 -w 1 localhost "$QEMU_PORT" | tr -d '\000')
-    dev="${dev#*serial0}"
-    dev="${dev#*pty:}"
-    dev="${dev%%$'\n'*}"
-    dev="${dev%%$'\r'*}"
-  fi
-
-  if [ ! -c "$dev" ]; then
-    error "Device '$dev' not found!"
-    finish 34 && return 34
-  fi
-
-  QEMU_TERM="$dev"
-  return 0
-}
-
-_graceful_shutdown() {
-
-  local code=$?
-  local pid url response
-
-  set +e
-
-  if [ -f "$QEMU_END" ]; then
-    echo && info "Received $1 signal while already shutting down..."
-    return
-  fi
-
-  touch "$QEMU_END"
-  echo && info "Received $1 signal, sending shutdown command..."
-
-  if [ ! -s "$QEMU_PID" ]; then
-    echo && error "QEMU PID file does not exist?"
-    finish "$code" && return "$code"
-  fi
-
-  pid=$(<"$QEMU_PID")
-
-  if ! isAlive "$pid"; then
-    echo && error "QEMU process does not exist?"
-    finish "$code" && return "$code"
-  fi
 
   # Don't send the powerdown signal because vDSM ignores ACPI signals
-  # echo 'system_powerdown' | nc -q 1 -w 1 localhost "${QEMU_PORT}" > /dev/null
+  # nc -q 1 -w 1 -U "$QEMU_DIR/monitor.sock" &> /dev/null <<<'system_powerdown' || :
 
   # Send shutdown command to guest agent via serial port
+  API_TIMEOUT=$(strip "$API_TIMEOUT")
   url="http://$API_HOST/read?command=$API_CMD&timeout=$API_TIMEOUT"
   response=$(curl -sk -m "$(( API_TIMEOUT+2 ))" -S "$url" 2>&1)
 
@@ -141,45 +137,121 @@ _graceful_shutdown() {
 
     response="${response#*message\"\: \"}"
     [ -z "$response" ] && response="second signal"
+
     echo && error "Forcefully terminating because of: ${response%%\"*}"
-    { kill -15 "$pid" || true; } 2>/dev/null
+    kill -15 -- "$pid" 2>/dev/null || :
 
   fi
 
+  return 0
+}
+
+normalizeTimeout() {
+
+  local term_grace=3      # seconds before loop ends to send SIGTERM
+  local cleanup_grace=3   # seconds reserved after the loop for cleanup
+  local elapsed
+  local timeout_left
+  local min
+
+  TIMEOUT=$(strip "$TIMEOUT")
+  if [[ ! "$TIMEOUT" =~ ^[0-9]+$ ]]; then
+    TIMEOUT=115
+  fi
+
+  if (( TIMEOUT >= 30 )); then
+    term_grace=5
+    cleanup_grace=5
+  elif (( TIMEOUT >= 15 )); then
+    term_grace=4
+    cleanup_grace=4
+  fi
+
+  elapsed=$((SECONDS - start))
+  timeout_left=$((TIMEOUT - elapsed))
+
+  min=$((term_grace + cleanup_grace + 1))
+  (( timeout_left < min )) && timeout_left=$min
+
+  wait_until=$((timeout_left - cleanup_grace))
+  sigterm_at=$((wait_until - term_grace))
+
+  return 0
+}
+
+waitForShutdown() {
+
   local cnt=0
+  local pid="$1"
+  local name="$APP"
+  local slp
 
-  while [ "$cnt" -lt "$QEMU_TIMEOUT" ]; do
+  while (( cnt <= wait_until )); do
 
+    sleep 1 &
+    slp=$!
+
+    # Stop waiting if the process has exited
     ! isAlive "$pid" && break
 
-    sleep 1
+    # Workaround for stale/zombie QEMU pid file
-    cnt=$((cnt+1))
-
-    [[ "$DEBUG" == [Yy1]* ]] && info "Shutting down, waiting... ($cnt/$QEMU_TIMEOUT)"
-
-    # Workaround for zombie pid
     [ ! -s "$QEMU_PID" ] && break
 
+    if (( cnt == sigterm_at )); then
+      info "${name^} is still running, sending SIGTERM... ($cnt/$wait_until)"
+      kill -15 -- "$pid" 2>/dev/null || :
+    elif (( cnt > 0 )) && enabled "${DEBUG:-}"; then
+      info "Waiting for $name to shut down... ($cnt/$wait_until)"
+    fi
+
+    wait "$slp"
+    (( cnt++ ))
+
   done
 
-  if [ "$cnt" -ge "$QEMU_TIMEOUT" ]; then
+  return 0
-    echo && error "Shutdown timeout reached, aborting..."
-  fi
-
-  finish "$code" && return "$code"
 }
 
-MON_OPTS="\
+graceful_shutdown() {
-        -pidfile $QEMU_PID \
-        -name $PROCESS,process=$PROCESS,debug-threads=on \
-        -monitor telnet:localhost:$QEMU_PORT,server,nowait,nodelay"
 
-if [[ "$CONSOLE" != [Yy]* ]]; then
+  local sig="$1"
+  local pid=""
+  local code=0
 
-  MON_OPTS+=" -daemonize -D $QEMU_LOG"
+  [[ $BASHPID != "$TRAP_PID" ]] && return
 
-  _trap _graceful_shutdown SIGTERM SIGHUP SIGINT SIGABRT SIGQUIT
+  code=$(signalCode "$sig")
 
-fi
+  if [ -f "$QEMU_END" ]; then
+    echo && info "Received $1 signal while already shutting down..."
+    return
+  fi
+
+  set +e
+  start=$SECONDS
+  touch "$QEMU_END"
+  echo && info "Received $1 signal, sending shutdown command..."
+
+  if ! readQemuPid pid; then
+    warn "QEMU PID file ($QEMU_PID) does not exist?"
+    finish "$code"
+  fi
+
+  if ! isAlive "$pid"; then
+    warn "QEMU process with PID $pid does not exist?"
+    finish "$code"
+  fi
+
+  sendGuestShutdown "$pid"
+  normalizeTimeout
+  waitForShutdown "$pid"
+
+  finish "$code"
+}
+
+! enabled "$SHUTDOWN" && return 0
+[ -n "${QEMU_TIMEOUT:-}" ] && TIMEOUT="$QEMU_TIMEOUT"
+
+_trap graceful_shutdown SIGTERM SIGHUP SIGABRT SIGQUIT
 
 return 0

src/print.sh

@@ -1,16 +1,21 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC2329
 set -Eeuo pipefail
 
 : "${DHCP:="N"}"
 : "${NETWORK:="Y"}"
 
-[[ "$NETWORK" == [Nn]* ]] && exit 0
+cd /run
+. utils.sh      # Load functions
 
 info () { printf "%b%s%b" "\E[1;34m❯ \E[1;36m" "$1" "\E[0m\n" >&2; }
 error () { printf "%b%s%b" "\E[1;31m❯ " "ERROR: $1" "\E[0m\n" >&2; }
 
+disabled "$NETWORK" && exit 0
+
 file="/run/shm/dsm.url"
-info="/run/shm/msg.html"
+msgs="/run/shm/msg.html"
+driver="/run/shm/qemu.nic"
 page="/run/shm/index.html"
 address="/run/shm/qemu.ip"
 shutdown="/run/shm/qemu.end"
@@ -21,88 +26,180 @@ resp_err="Guest returned an invalid response:"
 curl_err="Failed to connect to guest: curl error"
 jq_err="Failed to parse response from guest: jq error"
 
-while [ ! -s  "$file" ]
+exitIfShuttingDown() {
-do
-
-  # Check if not shutting down
-  [ -f "$shutdown" ] && exit 1
-
-  sleep 3
 
   [ -f "$shutdown" ] && exit 1
-  [ -s "$file" ] && break
 
-  # Retrieve network info from guest VM
+  return 0
+}
+
+queryGuest() {
+
+  local rc
+
   { json=$(curl -m 20 -sk "$url"); rc=$?; } || :
 
-  [ -f "$shutdown" ] && exit 1
+  exitIfShuttingDown
-  (( rc != 0 )) && error "$curl_err $rc" && continue
 
-  { result=$(echo "$json" | jq -r '.status'); rc=$?; } || :
+  if (( rc != 0 )); then
-  (( rc != 0 )) && error "$jq_err $rc ( $json )" && continue
+    error "$curl_err $rc"
-  [[ "$result" == "null" ]] && error "$resp_err $json" && continue
+    return 1
-
-  if [[ "$result" != "success" ]] ; then
-    { msg=$(echo "$json" | jq -r '.message'); rc=$?; } || :
-    error "Guest replied $result: $msg" && continue
   fi
 
-  { port=$(echo "$json" | jq -r '.data.data.dsm_setting.data.http_port'); rc=$?; } || :
+  return 0
-  (( rc != 0 )) && error "$jq_err $rc ( $json )" && continue
+}
-  [[ "$port" == "null" ]] && error "$resp_err $json" && continue
-  [ -z "$port" ] && continue
 
-  { ip=$(echo "$json" | jq -r '.data.data.ip.data[] | select((.name=="eth0") and has("ip")).ip'); rc=$?; } || :
+readJsonField() {
-  (( rc != 0 )) && error "$jq_err $rc ( $json )" && continue
-  [[ "$ip" == "null" ]] && error "$resp_err $json" && continue
 
-  if [ -z "$ip" ]; then
+  local query="$1"
-    [[ "$DHCP" == [Yy1]* ]] && continue
+  local result
-    ip="20.20.20.21"
+  local rc
+
+  { result=$(jq -r "$query" <<< "$json"); rc=$?; } || :
+
+  if (( rc != 0 )); then
+    error "$jq_err $rc ( $json )"
+    return 1
   fi
 
-  echo "$ip:$port" > $file
+  if [[ "$result" == "null" ]]; then
+    error "$resp_err $json"
+    return 1
+  fi
 
-done
+  printf '%s\n' "$result"
+  return 0
+}
 
-[ -f "$shutdown" ] && exit 1
+readGuestStatus() {
 
-location=$(<"$file")
+  local result msg rc
 
-if [[ "$location" != "20.20"* ]]; then
+  result=$(readJsonField '.status') || return 1
+
+  if [[ "$result" != "success" ]]; then
+    { msg=$(jq -r '.message // empty' <<< "$json"); rc=$?; } || :
+
+    if (( rc != 0 )); then
+      error "$jq_err $rc ( $json )"
+      return 1
+    fi
+
+    error "Guest replied $result: $msg"
+    return 1
+  fi
+
+  return 0
+}
+
+readGuestPort() {
+
+  port=$(readJsonField '.data.data.dsm_setting.data.http_port') || return 1
+  [ -z "$port" ] && return 1
+
+  return 0
+}
+
+readGuestIp() {
+
+  ip=$(readJsonField '.data.data.ip.data[] | select(.name=="eth0" and has("ip")) | .ip | select(test("^[0-9]+\\."))') || return 1
+  [ -z "$ip" ] && return 1
+
+  return 0
+}
+
+writeDsmLocation() {
+
+  echo "$ip:$port" > "$file"
+
+  return 0
+}
+
+pollGuestLocation() {
+
+  while [ ! -s "$file" ]; do
+
+    # Check if not shutting down
+    exitIfShuttingDown
+
+    sleep 3
+
+    exitIfShuttingDown
+    [ -s "$file" ] && break
+
+    # Retrieve network info from guest VM
+    queryGuest || continue
+    readGuestStatus || continue
+    readGuestPort || continue
+    readGuestIp || continue
+    writeDsmLocation
+
+  done
+
+  return 0
+}
+
+writeDhcpPage() {
+
+  local title body script html
 
   msg="http://$location"
   title="<title>Virtual DSM</title>"
   body="The location of DSM is <a href='http://$location'>http://$location</a>"
   script="<script>setTimeout(function(){ window.location.assign('http://$location'); }, 3000);</script>"
 
-  HTML=$(<"$template")
+  html=$(<"$template")
-  HTML="${HTML/\[1\]/$title}"
+  html="${html/\[1\]/$title}"
-  HTML="${HTML/\[2\]/$script}"
+  html="${html/\[2\]/$script}"
-  HTML="${HTML/\[3\]/$body}"
+  html="${html/\[3\]/$body}"
-  HTML="${HTML/\[4\]/}"
+  html="${html/\[4\]/}"
-  HTML="${HTML/\[5\]/}"
+  html="${html/\[5\]/}"
 
-  echo "$HTML" > "$page"
+  echo "$html" > "$page"
-  echo "$body" > "$info"
+  echo "$body" > "$msgs"
 
-else
+  return 0
+}
 
+buildStaticMessage() {
+
+  local nic ip port
+
+  nic=$(<"$driver")
   ip=$(<"$address")
   port="${location##*:}"
 
-  if [[ "$ip" == "172."* ]]; then
+  if [[ "${nic,,}" != "macvlan" ]]; then
     msg="port $port"
   else
     msg="http://$ip:$port"
   fi
 
+  return 0
+}
+
+printLoginMessage() {
+
+  echo "" >&2
+  info "-----------------------------------------------------------"
+  info " You can now login to DSM at $msg"
+  info "-----------------------------------------------------------"
+  echo "" >&2
+
+  return 0
+}
+
+pollGuestLocation
+exitIfShuttingDown
+
+location=$(<"$file")
+
+if enabled "$DHCP"; then
+  writeDhcpPage
+else
+  buildStaticMessage
 fi
 
-echo "" >&2
+printLoginMessage
-info "-----------------------------------------------------------"
-info " You can now login to DSM at $msg"
-info "-----------------------------------------------------------"
-echo "" >&2
 
 exit 0

src/proc.sh

@@ -3,21 +3,35 @@ set -Eeuo pipefail
 
 # Docker environment variables
 
-: "${KVM:="Y"}"
 : "${HOST_CPU:=""}"
 : "${CPU_FLAGS:=""}"
 : "${CPU_MODEL:=""}"
-: "${DEF_MODEL:="qemu64"}"
 
-CLOCKSOURCE="tsc"
+HOST_CPU=$(strip "$HOST_CPU")
-[[ "${ARCH,,}" == "arm64" ]] && CLOCKSOURCE="arch_sys_counter"
+CPU_FLAGS=$(strip "$CPU_FLAGS")
-CLOCK="/sys/devices/system/clocksource/clocksource0/current_clocksource"
+CPU_MODEL=$(strip "$CPU_MODEL")
+
+selectClocksource() {
+
+  CLOCKSOURCE="tsc"
+  [[ "${ARCH,,}" == "arm64" ]] && CLOCKSOURCE="arch_sys_counter"
+  CLOCK="/sys/devices/system/clocksource/clocksource0/current_clocksource"
+
+  return 0
+}
+
+checkClocksource() {
+
+  local result
+
+  if [ ! -f "$CLOCK" ]; then
+    warn "file \"$CLOCK\" cannot be found?"
+    return 0
+  fi
 
-if [ ! -f "$CLOCK" ]; then
-  warn "file \"$CLOCK\" cannot not found?"
-else
   result=$(<"$CLOCK")
   result="${result//[![:print:]]/}"
+
   case "${result,,}" in
     "${CLOCKSOURCE,,}" ) ;;
     "kvm-clock" ) info "Nested KVM virtualization detected.." ;;
@@ -25,63 +39,64 @@ else
     "hpet" ) warn "unsupported clock source detected: '$result'. Please set host clock source to '$CLOCKSOURCE'." ;;
     *) warn "unexpected clock source detected: '$result'. Please set host clock source to '$CLOCKSOURCE'." ;;
   esac
-fi
 
-if [[ "${ARCH,,}" != "amd64" ]]; then
+  return 0
-  KVM="N"
+}
-  warn "your CPU architecture is ${ARCH^^} and cannot provide KVM acceleration for x64 instructions, this will cause a major loss of performance."
-fi
 
-if [[ "$KVM" != [Nn]* ]]; then
+checkSse42() {
 
-  KVM_ERR=""
+  if ! grep -qw "sse4_2" <<< "$flags"; then
-
+    error "Your CPU does not have the SSE4 instruction set that Virtual DSM requires!"
-  if [ ! -e /dev/kvm ]; then
+    ! enabled "$DEBUG" && exit 88
-    KVM_ERR="(device file missing)"
-  else
-    if ! sh -c 'echo -n > /dev/kvm' &> /dev/null; then
-      KVM_ERR="(no write access)"
-    else
-      flags=$(sed -ne '/^flags/s/^.*: //p' /proc/cpuinfo)
-      if ! grep -qw "vmx\|svm" <<< "$flags"; then
-        KVM_ERR="(vmx/svm disabled)"
-      fi
-    fi
   fi
 
-  if [ -n "$KVM_ERR" ]; then
+  return 0
-    KVM="N"
+}
-    if [[ "$OSTYPE" =~ ^darwin ]]; then
-      warn "you are using macOS which has no KVM support, this will cause a major loss of performance."
-    else
-      error "KVM acceleration not available $KVM_ERR, this will cause a major loss of performance."
-      error "See the FAQ on how to diagnose the cause, or continue without KVM by setting KVM=N (not recommended)."
-      [[ "$DEBUG" != [Yy1]* ]] && exit 88
-    fi
-  fi
 
-fi
+trimSpaces() {
 
-if [[ "$KVM" != [Nn]* ]]; then
+  local value="$1"
+
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  echo "$value"
+  return 0
+}
+
+removeCpuArgument() {
+
+  local args=" ${ARGUMENTS:-} "
+
+  while [[ "$args" =~ [[:space:]]-cpu([[:space:]][^[:space:]]+|=[^[:space:]]+)? ]]; do
+    local cpu="${BASH_REMATCH[0]}"
+    args="${args/$cpu/ }"
+    warn "Ignoring '${cpu#" "}' from ARGUMENTS, use CPU_MODEL and CPU_FLAGS instead."
+  done
+
+  ARGUMENTS=$(trimSpaces "$args")
+
+  return 0
+}
+
+configureKvmCpuModel() {
 
   CPU_FEATURES="kvm=on,l3-cache=on,+hypervisor"
   KVM_OPTS=",accel=kvm -enable-kvm -global kvm-pit.lost_tick_policy=discard"
 
-  if ! grep -qw "sse4_2" <<< "$flags"; then
-    info "Your CPU does not have the SSE4 instruction set that Virtual DSM requires, it will be emulated..."
-    [ -z "$CPU_MODEL" ] && CPU_MODEL="$DEF_MODEL"
-    CPU_FEATURES+=",+ssse3,+sse4.1,+sse4.2"
-  fi
-
   if [ -z "$CPU_MODEL" ]; then
     CPU_MODEL="host"
     CPU_FEATURES+=",migratable=no"
   fi
 
+  return 0
+}
+
+appendKvmInvtscFeature() {
+
   if grep -qw "svm" <<< "$flags"; then
 
     # AMD processor
-
     if grep -qw "tsc_scale" <<< "$flags"; then
       CPU_FEATURES+=",+invtsc"
     fi
@@ -89,7 +104,7 @@ if [[ "$KVM" != [Nn]* ]]; then
   else
 
     # Intel processor
-
+    local vmx
     vmx=$(sed -ne '/^vmx flags/s/^.*: //p' /proc/cpuinfo)
 
     if grep -qw "tsc_scaling" <<< "$vmx"; then
@@ -98,7 +113,35 @@ if [[ "$KVM" != [Nn]* ]]; then
 
   fi
 
-else
+  return 0
+}
+
+configureKvm() {
+
+  configureKvmCpuModel
+  checkSse42
+  appendKvmInvtscFeature
+
+  return 0
+}
+
+configureTcgCpuModel() {
+
+  if [ -n "$CPU_MODEL" ]; then
+    return 0
+  fi
+
+  if [[ "$ARCH" == "amd64" ]]; then
+    CPU_MODEL="max"
+    CPU_FEATURES+=",migratable=no"
+  else
+    CPU_MODEL="qemu64"
+  fi
+
+  return 0
+}
+
+configureTcg() {
 
   KVM_OPTS=""
   CPU_FEATURES="l3-cache=on,+hypervisor"
@@ -107,46 +150,52 @@ else
     KVM_OPTS=" -accel tcg,thread=multi"
   fi
 
-  if [ -z "$CPU_MODEL" ]; then
+  configureTcgCpuModel
-    if [[ "$ARCH" == "amd64" ]]; then
+  CPU_FEATURES+=",+ssse3,+sse4.1,+sse4.2"
-      CPU_MODEL="max"
+
-      CPU_FEATURES+=",migratable=no"
+  return 0
+}
+
+composeCpuFlags() {
+
+  CPU_FLAGS="${CPU_MODEL}${CPU_FEATURES:+,$CPU_FEATURES}${CPU_FLAGS:+,$CPU_FLAGS}"
+
+  return 0
+}
+
+configureHostCpuName() {
+
+  if [ -z "$HOST_CPU" ]; then
+    [[ "${CPU,,}" != "unknown" ]] && HOST_CPU="$CPU"
+  fi
+
+  if [ -n "$HOST_CPU" ]; then
+    HOST_CPU="${HOST_CPU%%,*},,"
+  else
+    HOST_CPU="QEMU, Virtual CPU,"
+    if [ "$ARCH" == "amd64" ]; then
+      HOST_CPU+=" X86_64"
     else
-      CPU_MODEL="$DEF_MODEL"
+      HOST_CPU+=" $ARCH"
     fi
   fi
 
-  CPU_FEATURES+=",+ssse3,+sse4.1,+sse4.2"
+  return 0
+}
 
-fi
+selectClocksource
+checkClocksource
 
-if [ -z "$CPU_FLAGS" ]; then
+flags=$(sed -ne '/^flags/s/^.*: //p' /proc/cpuinfo)
-  if [ -z "$CPU_FEATURES" ]; then
+
-    CPU_FLAGS="$CPU_MODEL"
+if ! disabled "$KVM"; then
-  else
+  configureKvm
-    CPU_FLAGS="$CPU_MODEL,$CPU_FEATURES"
-  fi
 else
-  if [ -z "$CPU_FEATURES" ]; then
+  configureTcg
-    CPU_FLAGS="$CPU_MODEL,$CPU_FLAGS"
-  else
-    CPU_FLAGS="$CPU_MODEL,$CPU_FEATURES,$CPU_FLAGS"
-  fi
 fi
 
-if [ -z "$HOST_CPU" ]; then
+removeCpuArgument
-  [[ "${CPU,,}" != "unknown" ]] && HOST_CPU="$CPU"
+composeCpuFlags
-fi
+configureHostCpuName
-
-if [ -n "$HOST_CPU" ]; then
-  HOST_CPU="${HOST_CPU%%,*},,"
-else
-  HOST_CPU="QEMU, Virtual CPU,"
-  if [ "$ARCH" == "amd64" ]; then
-    HOST_CPU+=" X86_64"
-  else
-    HOST_CPU+=" $ARCH"
-  fi
-fi
 
 return 0

src/progress.sh

@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
+info="/run/shm/msg.html"
+
 escape () {
     local s
     s=${1//&/\&}
@@ -11,28 +13,33 @@ escape () {
     return 0
 }
 
-file="$1"
+path="$1"
 total="$2"
 body=$(escape "$3")
-info="/run/shm/msg.html"
 
 if [[ "$body" == *"..." ]]; then
-  body="<p class=\"loading\">${body/.../}</p>"
+  body="<p class=\"loading\">${body::-3}</p>"
 fi
 
 while true
 do
-  if [ -s "$file" ]; then
+
-    bytes=$(du -sb "$file" | cut -f1)
+  if [ ! -s "$path" ] && [ ! -d "$path" ]; then
-    if (( bytes > 1000 )); then
+    bytes="0"
-      if [ -z "$total" ] || [[ "$total" == "0" ]]; then
+  else
-        size=$(numfmt --to=iec --suffix=B "$bytes" | sed -r 's/([A-Z])/ \1/')
+    bytes=$(du -sb "$path" 2>/dev/null | cut -f1) || bytes="0"
-      else
-        size="$(echo "$bytes" "$total" | awk '{printf "%.1f", $1 * 100 / $2}')"
-        size="$size%"
-      fi
-      echo "${body//(\[P\])/($size)}"> "$info"
-    fi
   fi
+  
+  if (( bytes > 4096 )); then
+    if [ -z "$total" ] || [[ "$total" == "0" ]] || [ "$bytes" -gt "$total" ]; then
+      size=$(numfmt --to=iec --suffix=B "$bytes" | sed -r 's/([A-Z])/ \1/') || size="${bytes} bytes"
+    else
+      size="$(echo "$bytes" "$total" | awk '{printf "%.1f", $1 * 100 / $2}')"
+      size="$size%"
+    fi
+    [[ "$size" != "0.0%" ]] && echo "${body//(\[P\])/($size)}"> "$info"
+  fi
+
   sleep 1 & wait $!
+
 done

src/reset.sh

@@ -2,97 +2,339 @@
 set -Eeuo pipefail
 
 trap 'error "Status $? while: $BASH_COMMAND (line $LINENO/$BASH_LINENO)"' ERR
+enabled "${TRACE:-}" && set -o functrace && trap 'echo "# $BASH_COMMAND" >&2' DEBUG
 
-[ ! -f "/run/entry.sh" ] && error "Script must run inside Docker container!" && exit 11
+[ ! -f "/run/entry.sh" ] && error "Script must be run inside the container!" && exit 11
 [ "$(id -u)" -ne "0" ] && error "Script must be executed with root privileges." && exit 12
 
-echo "❯ Starting $APP for Docker v$(</run/version)..."
-echo "❯ For support visit $SUPPORT"
-
 # Docker environment variables
 
-: "${TZ:=""}"              # System local timezone
+: "${TZ:=""}"              # System timezone
+: "${KVM:="Y"}"            # KVM acceleration
 : "${DEBUG:="N"}"          # Disable debugging mode
 : "${COUNTRY:=""}"         # Country code for mirror
-: "${CONSOLE:="N"}"        # Disable console mode
 : "${ALLOCATE:=""}"        # Preallocate diskspace
 : "${ARGUMENTS:=""}"       # Extra QEMU parameters
-: "${CPU_CORES:="1"}"      # Amount of CPU cores
+: "${CPU_CORES:="2"}"      # Amount of CPU cores
-: "${RAM_SIZE:="1G"}"      # Maximum RAM amount
+: "${RAM_SIZE:="2G"}"      # Maximum RAM amount
 : "${RAM_CHECK:="Y"}"      # Check available RAM
 : "${DISK_SIZE:="16G"}"    # Initial data disk size
 : "${STORAGE:="/storage"}" # Storage folder location
 
-# Helper variables
+detectEngine() {
 
+  if [ -f "/run/.containerenv" ]; then
+    ENGINE="${container:-}"
+
+    if [[ "${ENGINE,,}" == *"podman"* ]]; then
+      ENGINE="Podman"
+    else
+      [ -z "$ENGINE" ] && ENGINE="Kubernetes"
+    fi
+  elif [ -f "/.dockerenv" ]; then
+    ENGINE="Docker"
+  fi
+
+  return 0
+}
+
+detectRootless() {
+
+  local uid_map=""
+
+  uid_map=$(awk '{$1=$1; print}' /proc/self/uid_map 2>/dev/null || true)
+
+  if [[ "$uid_map" == "0 0 4294967295" ]]; then
+    ROOTLESS="N"
+  else
+    ROOTLESS="Y"
+  fi
+
+  return 0
+}
+
+checkPrivileged() {
+
+  local cap_bnd
+  local last_cap
+  local max_cap
+
+  # Get the capability bounding set
+  cap_bnd=$(grep '^CapBnd:' /proc/$$/status | awk '{print $2}')
+  cap_bnd=$(printf "%d" "0x${cap_bnd}")
+
+  # Get the last capability number
+  last_cap=$(cat /proc/sys/kernel/cap_last_cap)
+
+  # Calculate the maximum capability value
+  max_cap=$(((1 << (last_cap + 1)) - 1))
+
+  if [ "$cap_bnd" -eq "$max_cap" ]; then
+    PRIVILEGED="Y"
+  fi
+
+  return 0
+}
+
+normalizeCpuCores() {
+
+  CPU_CORES=$(strip "$CPU_CORES")
+  [ -z "$CPU_CORES" ] && CPU_CORES=2
+  [[ "${CPU_CORES,,}" == "max" ]] && CPU_CORES="$CORES"
+  [[ "${CPU_CORES,,}" == "half" ]] && CPU_CORES=$(( CORES / 2 ))
+  [ -z "${CPU_CORES##*[!0-9]*}" ] && error "Invalid amount of CPU_CORES: $CPU_CORES" && exit 15
+
+  [ "$CPU_CORES" -lt "1" ] && CPU_CORES=1
+  if [ "$CPU_CORES" -gt "$CORES" ]; then
+    warn "The amount for CPU_CORES (${CPU_CORES}) exceeds the amount of logical cores available (${CORES}) and will be limited."
+    CPU_CORES="$CORES"
+  fi
+
+  return 0
+}
+
+checkStorage() {
+
+  # Check system
+
+  QEMU_DIR="/run/shm"
+
+  if [ ! -d "/dev/shm" ]; then
+    error "Directory /dev/shm not found!" && exit 14
+  else
+    [ ! -d "$QEMU_DIR" ] && ln -s /dev/shm "$QEMU_DIR"
+  fi
+
+  QEMU_PID="$QEMU_DIR/qemu.pid"
+
+  # Check folder
+
+  if [[ "${STORAGE,,}" != "/storage" ]]; then
+    mkdir -p "$STORAGE"
+  fi
+
+  if [ ! -d "$STORAGE" ]; then
+    error "Storage folder ($STORAGE) not found!" && exit 13
+  fi
+
+  if [ ! -w "$STORAGE" ]; then
+    msg="Storage folder ($STORAGE) is not writeable!"
+    msg+=" If SELinux is active, you need to add the \":Z\" flag to the bind mount."
+    error "$msg" && exit 13
+  fi
+
+  return 0
+}
+
+checkFilesystem() {
+
+  # Check filesystem
+  FS=$(stat -f -c %T "$STORAGE")
+
+  if [[ "${FS,,}" == "ecryptfs" || "${FS,,}" == "tmpfs" ]]; then
+    DISK_IO="threads"
+    DISK_CACHE="writeback"
+  fi
+
+  return 0
+}
+
+finiteMemoryLimit() {
+
+  local limit="$1"
+  local sentinel="4611686018427387904"
+  local i=0
+  local left=""
+  local right=""
+
+  [[ "$limit" =~ ^[0-9]+$ ]] || return 1
+
+  (( ${#limit} < ${#sentinel} )) && return 0
+  (( ${#limit} > ${#sentinel} )) && return 1
+
+  for (( i=0; i<${#sentinel}; i++ )); do
+    left="${limit:i:1}"
+    right="${sentinel:i:1}"
+
+    (( left < right )) && return 0
+    (( left > right )) && return 1
+  done
+
+  return 1
+}
+
+getMemoryInfo() {
+
+  local host_total=""
+  local host_avail=""
+  local limit=""
+  local current=""
+  local available=""
+
+  host_total=$(free -b | awk '/^Mem:/ {print $2; exit}')
+  host_avail=$(free -b | awk '/^Mem:/ {print $7; exit}')
+
+  RAM_TOTAL="$host_total"
+  RAM_AVAIL="$host_avail"
+
+  if [ -r /sys/fs/cgroup/memory.max ] && [ -r /sys/fs/cgroup/memory.current ]; then
+    limit=$(< /sys/fs/cgroup/memory.max)
+    current=$(< /sys/fs/cgroup/memory.current)
+  elif [ -r /sys/fs/cgroup/memory/memory.limit_in_bytes ] && [ -r /sys/fs/cgroup/memory/memory.usage_in_bytes ]; then
+    limit=$(< /sys/fs/cgroup/memory/memory.limit_in_bytes)
+    current=$(< /sys/fs/cgroup/memory/memory.usage_in_bytes)
+  fi
+
+  if finiteMemoryLimit "$limit" && [[ "$current" =~ ^[0-9]+$ ]]; then
+    (( limit < RAM_TOTAL )) && RAM_TOTAL="$limit"
+
+    available=$(( limit - current ))
+    (( available < 0 )) && available=0
+    (( available < RAM_AVAIL )) && RAM_AVAIL="$available"
+  fi
+
+  return 0
+}
+
+normalizeRamSize() {
+
+  # Read host and container memory limits.
+  getMemoryInfo
+
+  RAM_SPARE=500000000
+  RAM_MINIMUM=136314880
+
+  RAM_SIZE=$(strip "$RAM_SIZE")
+  RAM_SIZE="${RAM_SIZE// /}"
+  [ -z "$RAM_SIZE" ] && RAM_SIZE="2G"
+
+  if [[ "${RAM_SIZE,,}" != "max" && "${RAM_SIZE,,}" != "half" ]]; then
+
+    if [ -z "${RAM_SIZE//[0-9. ]}" ]; then
+      [ "${RAM_SIZE%%.*}" -lt "130" ] && RAM_SIZE="${RAM_SIZE}G" || RAM_SIZE="${RAM_SIZE}M"
+    fi
+
+    RAM_SIZE=$(echo "${RAM_SIZE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+    ! numfmt --from=iec "$RAM_SIZE" &>/dev/null && error "Invalid RAM_SIZE: $RAM_SIZE" && exit 16
+    wanted=$(numfmt --from=iec "$RAM_SIZE")
+    [ "$wanted" -lt "$RAM_MINIMUM" ] && error "RAM_SIZE is too low: $RAM_SIZE" && exit 16
+
+  fi
+
+  return 0
+}
+
+checkKvm() {
+
+  # Check KVM support
+
+  if [[ "${PLATFORM,,}" == "x64" ]]; then
+    TARGET="amd64"
+  else
+    TARGET="arm64"
+  fi
+
+  if disabled "$KVM"; then
+    warn "KVM acceleration is disabled, this will cause the machine to run about 10 times slower!"
+  else
+    if [[ "${ARCH,,}" != "$TARGET" ]]; then
+      KVM="N"
+      warn "your CPU architecture is ${ARCH^^} and cannot provide KVM acceleration for ${PLATFORM^^} instructions, so the machine will run about 10 times slower."
+    fi
+  fi
+
+  if ! disabled "$KVM"; then
+
+    KVM_ERR=""
+
+    if [ ! -e /dev/kvm ]; then
+      KVM_ERR="(/dev/kvm is missing)"
+    else
+      if ! sh -c 'echo -n > /dev/kvm' &> /dev/null; then
+        KVM_ERR="(/dev/kvm is unwriteable)"
+      else
+        if [[ "${PLATFORM,,}" == "x64" ]]; then
+          flags=$(sed -ne '/^flags/s/^.*: //p' /proc/cpuinfo)
+          if ! grep -qw "vmx\|svm" <<< "$flags"; then
+            KVM_ERR="(not enabled in BIOS)"
+          fi
+          if ! grep -qw "sse4_2" <<< "$flags"; then
+            error "Your CPU does not have the SSE4 instruction set that Virtual DSM requires!"
+            ! enabled "$DEBUG" && exit 88
+          fi
+        fi
+      fi
+    fi
+
+    if [ -n "$KVM_ERR" ]; then
+      KVM="N"
+      if [[ "$OSTYPE" =~ ^darwin ]]; then
+        warn "you are using macOS which has no KVM support, so the machine will run about 10 times slower."
+      else
+        kernel=$(uname -a)
+        case "${kernel,,}" in
+          *"microsoft"* )
+            error "Please bind '/dev/kvm' as a volume in the optional container settings when using Docker Desktop." ;;
+          *"synology"* )
+            error "Please make sure that Synology VMM (Virtual Machine Manager) is installed and that '/dev/kvm' is binded to this container." ;;
+          *)
+            error "KVM acceleration is not available $KVM_ERR, this will cause the machine to run about 10 times slower."
+            error "See the FAQ for possible causes, or disable acceleration by adding the \"KVM=N\" variable (not recommended)." ;;
+        esac
+        ! enabled "$DEBUG" && exit 88
+      fi
+    fi
+
+  fi
+
+  return 0
+}
+
+# Sanitize variables
+TZ=$(strip "$TZ")
+STORAGE=$(strip "$STORAGE")
+COUNTRY=$(strip "$COUNTRY")
+DISK_SIZE=$(strip "$DISK_SIZE")
+
+# Helper variables
+ROOTLESS="N"
+PRIVILEGED="N"
+ENGINE="Docker"
 PROCESS="${APP,,}"
 PROCESS="${PROCESS// /-}"
 
+detectEngine
+detectRootless
+
+echo "❯ Starting $APP for $ENGINE v$(</etc/version)..."
+echo "❯ For support visit $SUPPORT"
+
+checkPrivileged
+
 INFO="/run/shm/msg.html"
 PAGE="/run/shm/index.html"
 TEMPLATE="/var/www/index.html"
-FOOTER1="$APP for Docker v$(</run/version)"
+FOOTER1="$APP for $ENGINE v$(</etc/version)"
 FOOTER2="<a href='$SUPPORT'>$SUPPORT</a>"
 
+SOCKETS=1
 CPU=$(cpu)
 SYS=$(uname -r)
-HOST=$(hostname -s)
 KERNEL=$(echo "$SYS" | cut -b 1)
 MINOR=$(echo "$SYS" | cut -d '.' -f2)
 ARCH=$(dpkg --print-architecture)
 CORES=$(grep -c '^processor' /proc/cpuinfo)
 
-if ! grep -qi "socket(s)" <<< "$(lscpu)"; then
+if grep -qi "socket(s)" <<< "$(lscpu)"; then
-  SOCKETS=1
+  SOCKETS=$(lscpu | grep -m 1 -i 'socket(s)' | awk '{print $2}')
-else
+  [ -z "${SOCKETS##*[!0-9]*}" ] && SOCKETS=1
-  SOCKETS=$(lscpu | grep -m 1 -i 'socket(s)' | awk '{print $(2)}')
+  [ "$SOCKETS" -lt "1" ] && SOCKETS=1
 fi
 
-[ -n "${CPU_CORES//[0-9 ]}" ] && error "Invalid amount of CPU_CORES: $CPU_CORES" && exit 15
+normalizeCpuCores
-
+checkStorage
-# Check system
+checkFilesystem
-
+normalizeRamSize
-if [ ! -d "/dev/shm" ]; then
-  error "Directory /dev/shm not found!" && exit 14
-else
-  [ ! -d "/run/shm" ] && ln -s /dev/shm /run/shm
-fi
-
-# Check folder
-
-if [[ "${COMMIT:-}" == [Yy1]* ]]; then
-  STORAGE="/local"
-  mkdir -p "$STORAGE"
-fi
-
-if [ ! -d "$STORAGE" ]; then
-  error "Storage folder ($STORAGE) not found!" && exit 13
-fi
-
-# Check filesystem
-FS=$(stat -f -c %T "$STORAGE")
-
-if [[ "${FS,,}" == "ecryptfs" ]] || [[ "${FS,,}" == "tmpfs" ]]; then
-  DISK_IO="threads"
-  DISK_CACHE="writeback"
-fi
-
-# Read memory
-RAM_SPARE=500000000
-RAM_AVAIL=$(free -b | grep -m 1 Mem: | awk '{print $7}')
-RAM_TOTAL=$(free -b | grep -m 1 Mem: | awk '{print $2}')
-
-RAM_SIZE="${RAM_SIZE// /}"
-[ -z "$RAM_SIZE" ] && error "RAM_SIZE not specified!" && exit 16
-
-if [ -z "${RAM_SIZE//[0-9. ]}" ]; then
-  [ "${RAM_SIZE%%.*}" -lt "130" ] && RAM_SIZE="${RAM_SIZE}G" || RAM_SIZE="${RAM_SIZE}M"
-fi
-
-RAM_SIZE=$(echo "${RAM_SIZE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
-! numfmt --from=iec "$RAM_SIZE" &>/dev/null && error "Invalid RAM_SIZE: $RAM_SIZE" && exit 16
-RAM_WANTED=$(numfmt --from=iec "$RAM_SIZE")
-[ "$RAM_WANTED" -lt "136314880 " ] && error "RAM_SIZE is too low: $RAM_SIZE" && exit 16
 
 # Print system info
 SYS="${SYS/-generic/}"
@@ -104,100 +346,17 @@ SPACE_GB=$(formatBytes "$SPACE" "down")
 AVAIL_MEM=$(formatBytes "$RAM_AVAIL" "down")
 TOTAL_MEM=$(formatBytes "$RAM_TOTAL" "up")
 
-echo "❯ CPU: ${CPU} | RAM: ${AVAIL_MEM/ GB/}/$TOTAL_MEM | DISK: $SPACE_GB (${FS}) | KERNEL: ${SYS}..."
+echo "❯ CPU: ${CPU} | RAM: ${AVAIL_MEM/ GB/}/$TOTAL_MEM | DISK: $SPACE_GB (${FS}) | KERNEL: ${SYS}"
 echo
 
-# Check available memory
+checkKvm
-
-if [[ "$RAM_CHECK" != [Nn]* ]] && (( (RAM_WANTED + RAM_SPARE) > RAM_AVAIL )); then
-  AVAIL_MEM=$(formatBytes "$RAM_AVAIL")
-  msg="Your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is too high for the $AVAIL_MEM of memory available, please set a lower value."
-  [[ "${FS,,}" != "zfs" ]] && error "$msg" && exit 17
-  info "$msg"
-fi
 
 # Cleanup files
-rm -f /run/shm/qemu.*
+rm -f "$QEMU_DIR"/dsm.url
-rm -f /run/shm/dsm.url
+rm -f "$QEMU_DIR"/qemu.* "$QEMU_DIR"/*.pid "$QEMU_DIR"/*.sock
 
 # Cleanup dirs
 rm -rf /tmp/dsm
 rm -rf "$STORAGE/tmp"
 
-getCountry() {
-  local url=$1
-  local query=$2
-  local rc json result
-
-  { json=$(curl -m 5 -H "Accept: application/json" -sfk "$url"); rc=$?; } || :
-  (( rc != 0 )) && return 0
-
-  { result=$(echo "$json" | jq -r "$query" 2> /dev/null); rc=$?; } || :
-  (( rc != 0 )) && return 0
-
-  [[ ${#result} -ne 2 ]] && return 0
-  [[ "${result^^}" == "XX" ]] && return 0
-
-  COUNTRY="${result^^}"
-
-  return 0
-}
-
-setCountry() {
-
-  [[ "${TZ,,}" == "asia/harbin" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/beijing" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/urumqi" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/kashgar" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/shanghai" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/chongqing" ]] && COUNTRY="CN"
-
-  [ -z "$COUNTRY" ] && getCountry "https://api.ipapi.is" ".location.country_code"
-  [ -z "$COUNTRY" ] && getCountry "https://ifconfig.co/json" ".country_iso"
-  [ -z "$COUNTRY" ] && getCountry "https://api.ip2location.io" ".country_code"
-  [ -z "$COUNTRY" ] && getCountry "https://ipinfo.io/json" ".country"
-  [ -z "$COUNTRY" ] && getCountry "https://api.myip.com" ".cc"
-
-  return 0
-}
-
-addPackage() {
-  local pkg=$1
-  local desc=$2
-
-  if apt-mark showinstall | grep -qx "$pkg"; then
-    return 0
-  fi
-
-  MSG="Installing $desc..."
-  info "$MSG" && html "$MSG"
-
-  [ -z "$COUNTRY" ] && setCountry
-
-  if [[ "${COUNTRY^^}" == "CN" ]]; then
-    sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources
-  fi
-
-  DEBIAN_FRONTEND=noninteractive apt-get -qq update
-  DEBIAN_FRONTEND=noninteractive apt-get -qq --no-install-recommends -y install "$pkg" > /dev/null
-
-  return 0
-}
-
-# shellcheck disable=SC2143
-if [ -f /proc/net/if_inet6 ] && [ -n "$(ifconfig -a | grep inet6)" ]; then
-
-  sed -i "s/listen 5000 default_server;/listen [::]:5000 default_server ipv6only=off;/g" /etc/nginx/sites-enabled/web.conf
-
-else
-
-  sed -i "s/listen [::]:5000 default_server ipv6only=off;/listen 5000 default_server;/g" /etc/nginx/sites-enabled/web.conf
-
-fi
-
-# Start webserver
-cp -r /var/www/* /run/shm
-html "Starting $APP for Docker..."
-nginx -e stderr
-
 return 0

src/serial.sh

@@ -5,11 +5,22 @@ set -Eeuo pipefail
 
 : "${HOST_MAC:=""}"
 : "${HOST_DEBUG:=""}"
-: "${HOST_SERIAL:=""}"
 : "${HOST_MODEL:=""}"
+: "${HOST_SERIAL:=""}"
 : "${GUEST_SERIAL:=""}"
 
-if [ -n "$HOST_MAC" ]; then
+# Sanitize variables
+HOST_MAC=$(strip "$HOST_MAC")
+HOST_MODEL=$(strip "$HOST_MODEL")
+HOST_SERIAL=$(strip "$HOST_SERIAL")
+GUEST_SERIAL=$(strip "$GUEST_SERIAL")
+
+validateHostMac() {
+  local m
+
+  if [ -z "$HOST_MAC" ]; then
+    return 0
+  fi
 
   HOST_MAC="${HOST_MAC//-/:}"
 
@@ -22,54 +33,77 @@ if [ -n "$HOST_MAC" ]; then
     error "Invalid HOST_MAC address: '$HOST_MAC', should be 12 or 17 digits long!" && exit 28
   fi
 
-fi
+  return 0
+}
 
-HOST_ARGS=()
+buildHostArguments() {
-HOST_ARGS+=("-cpu=$CPU_CORES")
-HOST_ARGS+=("-cpu_arch=$HOST_CPU")
 
-[ -n "$HOST_MAC" ] && HOST_ARGS+=("-mac=$HOST_MAC")
+  HOST_ARGS=()
-[ -n "$HOST_MODEL" ] && HOST_ARGS+=("-model=$HOST_MODEL")
+  HOST_ARGS+=("-cpu=$CPU_CORES")
-[ -n "$HOST_SERIAL" ] && HOST_ARGS+=("-hostsn=$HOST_SERIAL")
+  HOST_ARGS+=("-cpu_arch=$HOST_CPU")
-[ -n "$GUEST_SERIAL" ] && HOST_ARGS+=("-guestsn=$GUEST_SERIAL")
 
-if [[ "$HOST_DEBUG" == [Yy1]* ]]; then
+  [ -n "$HOST_MAC" ] && HOST_ARGS+=("-mac=$HOST_MAC")
-  set -x
+  [ -n "$HOST_MODEL" ] && HOST_ARGS+=("-model=$HOST_MODEL")
-  ./host.bin "${HOST_ARGS[@]}" &
+  [ -n "$HOST_SERIAL" ] && HOST_ARGS+=("-hostsn=$HOST_SERIAL")
-  { set +x; } 2>/dev/null
+  [ -n "$GUEST_SERIAL" ] && HOST_ARGS+=("-guestsn=$GUEST_SERIAL")
-  echo
-else
-  ./host.bin "${HOST_ARGS[@]}" >/dev/null &
-fi
 
-cnt=0
+  return 0
-sleep 0.2
+}
 
-while ! nc -z -w2 127.0.0.1 2210 > /dev/null 2>&1; do
+startHostBinary() {
-  sleep 0.1
-  cnt=$((cnt + 1))
-  (( cnt > 50 )) && error "Failed to connect to qemu-host.." && exit 58
-done
 
-cnt=0
+  if enabled "$HOST_DEBUG"; then
+    set -x
+    ./host.bin "${HOST_ARGS[@]}" &
+    { set +x; } 2>/dev/null
+    echo "$!" > "$HOST_PID"
+    echo
+  else
+    ./host.bin "${HOST_ARGS[@]}" >/dev/null &
+    echo "$!" > "$HOST_PID"
+  fi
 
-while ! nc -z -w2 127.0.0.1 12345 > /dev/null 2>&1; do
+  return 0
-  sleep 0.1
+}
-  cnt=$((cnt + 1))
-  (( cnt > 50 )) && error "Failed to connect to qemu-host.." && exit 59
-done
 
-# Configure serial ports
+waitForPort() {
 
-if [[ "$CONSOLE" != [Yy]* ]]; then
+  local port="$1"
-  SERIAL_OPTS="-serial pty"
+  local exit_code="$2"
-else
+  local cnt=0
-  SERIAL_OPTS="-serial mon:stdio"
-fi
 
-SERIAL_OPTS+=" \
+  while ! nc -z -w2 127.0.0.1 "$port" > /dev/null 2>&1; do
+    sleep 0.1
+    cnt=$((cnt + 1))
+    (( cnt > 50 )) && error "Failed to connect to qemu-host.." && exit "$exit_code"
+  done
+
+  return 0
+}
+
+configureSerialPorts() {
+
+  # Configure serial ports
+  SERIAL_OPTS="-serial mon:stdio \
         -device virtio-serial-pci,id=virtio-serial0,bus=pcie.0,addr=0x3 \
-        -chardev socket,id=charchannel0,host=127.0.0.1,port=12345,reconnect=10 \
+        -chardev socket,id=charchannel0,host=127.0.0.1,port=$CHR_PORT,reconnect=10 \
         -device virtserialport,bus=virtio-serial0.0,nr=1,chardev=charchannel0,id=channel0,name=vchannel"
 
+  return 0
+}
+
+validateHostMac
+
+HOST_PID="$QEMU_DIR/host.pid"
+
+buildHostArguments
+startHostBinary
+
+sleep 0.2
+
+waitForPort "$COM_PORT" 58
+waitForPort "$CHR_PORT" 59
+
+configureSerialPorts
+
 return 0

src/server.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+: "${COM_PORT:="2210"}"    # Comm port
+: "${WEB_PORT:="5000"}"    # Webserver port
+: "${CHR_PORT:="12345"}"   # Character port
+: "${WSD_PORT:="8004"}"    # Websockets port
+
+# Sanitize port variables
+COM_PORT=$(strip "$COM_PORT")
+WEB_PORT=$(strip "$WEB_PORT")
+CHR_PORT=$(strip "$CHR_PORT")
+WSD_PORT=$(strip "$WSD_PORT")
+
+WEB_PID="/run/nginx.pid"
+WSD_PID="$QEMU_DIR/websocketd.pid"
+
+prepareWebFiles() {
+
+  cp -r /var/www/* "$QEMU_DIR" || return 1
+  rm -f "$WSD_PID" "$WEB_PID" || return 1
+
+  return 0
+}
+
+configureWebPorts() {
+
+  sed -i "s/listen 5000 default_server;/listen $WEB_PORT default_server;/g" /etc/nginx/sites-enabled/web.conf
+  sed -i "s/proxy_pass http:\/\/127.0.0.1:8004\/;/proxy_pass http:\/\/127.0.0.1:$WSD_PORT\/;/g" /etc/nginx/sites-enabled/web.conf
+
+  return 0
+}
+
+configureIpv6Listen() {
+
+  # shellcheck disable=SC2143
+  if [ -f /proc/net/if_inet6 ] && [[ "$(cat /proc/sys/net/ipv6/conf/all/disable_ipv6 2>/dev/null)" != "1" ]]; then
+    sed -i "s/listen $WEB_PORT default_server;/listen [::]:$WEB_PORT default_server ipv6only=off;/g" /etc/nginx/sites-enabled/web.conf
+  fi
+
+  return 0
+}
+
+configureWebServer() {
+
+  mkdir -p /etc/nginx/sites-enabled
+  cp /etc/nginx/default.conf /etc/nginx/sites-enabled/web.conf
+
+  configureWebPorts || return 1
+  configureIpv6Listen || return 1
+
+  return 0
+}
+
+startWebServer() {
+
+  # Start webserver
+  nginx -e stderr || return 1
+
+  return 0
+}
+
+startWebsocketServer() {
+
+  local log="/var/log/websocketd.log"
+  rm -f "$log"
+
+  # Start websocket server
+  websocketd --address 127.0.0.1 --port="$WSD_PORT" /run/socket.sh > "$log" 2>&1 &
+  local pid=$!
+
+  if ! echo "$pid" > "$WSD_PID"; then
+    kill "$pid" 2>/dev/null || :
+    return 1
+  fi
+
+  sleep 0.1
+
+  if ! isAlive "$pid"; then
+    rm -f "$WSD_PID"
+    [ -s "$log" ] && cat "$log" >&2
+    error "Failed to start websocket server!"
+    return 1
+  fi
+
+  return 0
+}
+
+prepareWebFiles || return 1
+
+html "Starting $APP for $ENGINE..."
+
+disabled "${WEB:-}" && return 0
+
+configureWebServer || return 1
+
+startWebServer || return 1
+startWebsocketServer || return 1
+
+return 0

src/socket.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+lastmsg=""
+path="/run/shm/msg.html"
+
+refresh() {
+
+  [ ! -f "$path" ] && return 0
+  [ ! -s "$path" ] && return 0
+
+  msg=$(< "$path") || return 0
+  msg="${msg%$'\n'}"
+
+  [ -z "$msg" ] && return 0
+  [[ "$msg" == "$lastmsg" ]] && return 0
+
+  lastmsg="$msg"
+  echo "s: $msg"
+  return 0
+}
+
+refresh
+
+inotifywait -m "$path" |
+  while read -r fp event fn; do
+    case "${event,,}" in
+      "modify"* ) refresh ;;
+      "delete_self" ) echo "c: vnc" ;;
+    esac    
+  done

src/start.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# You can override this hook to execute a script before startup!
+
+return 0

src/utils.sh

@@ -7,11 +7,60 @@ info () { printf "%b%s%b" "\E[1;34m❯ \E[1;36m" "${1:-}" "\E[0m\n"; }
 error () { printf "%b%s%b" "\E[1;31m❯ " "ERROR: ${1:-}" "\E[0m\n" >&2; }
 warn () { printf "%b%s%b" "\E[1;31m❯ " "Warning: ${1:-}" "\E[0m\n" >&2; }
 
+strip() {
+
+  local value="${1:-}"
+
+  # Remove surrounding whitespace
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  # Remove leading/trailing single/double quotes
+  value="${value%\"}"
+  value="${value#\"}"
+  value="${value%\'}"
+  value="${value#\'}"
+
+  # Remove surrounding whitespace again
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  printf '%s' "$value"
+}
+
+enabled() {
+
+  local value
+  value=$(strip "${1:-}")
+
+  case "${value,,}" in
+    y|yes|true|1|on|enable|enabled) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+disabled() {
+
+  local value
+  value=$(strip "${1:-}")
+
+  case "${value,,}" in
+    n|no|none|false|0|off|disable|disabled) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
 formatBytes() {
+
   local result
-  result=$(numfmt --to=iec --suffix=B "$1" | sed -r 's/([A-Z])/ \1/' | sed 's/ B/ bytes/g;')
+
+  if ! result=$(numfmt --to=iec --suffix=B "$1" | sed -r 's/([A-Z])/ \1/' | sed 's/ B/ bytes/g;'); then
+    return 1
+  fi
+
   local unit="${result//[0-9. ]}"
   result="${result//[a-zA-Z ]/}"
+
   if [[ "${2:-}" == "up" ]]; then
     if [[ "$result" == *"."* ]]; then
       result="${result%%.*}"
@@ -22,12 +71,15 @@ formatBytes() {
       result="${result%%.*}"
     fi
   fi
+
   echo "$result $unit"
   return 0
 }
 
 isAlive() {
+
   local pid="$1"
+  [ -z "$pid" ] && return 1
 
   if kill -0 "$pid" 2>/dev/null; then
     return 0
@@ -36,48 +88,265 @@ isAlive() {
   return 1
 }
 
-pKill() {
+waitPid() {
+
+  local i=0
   local pid="$1"
+  local timeout="${2:-10}"
 
-  { kill -15 "$pid" || true; } 2>/dev/null
+  while [ -n "$pid" ] && isAlive "$pid"; do
-
-  while isAlive "$pid"; do
     sleep 0.2
+    i=$((i + 1))
+    (( i >= timeout * 5 )) && return 1
   done
 
   return 0
 }
 
+waitPidFile() {
+
+  local i=0
+  local pid=""
+  local file="$1"
+  local timeout="${2:-10}"
+
+  [ ! -s "$file" ] && return 0
+  ! read -r pid <"$file" && return 0
+  [ -z "$pid" ] && return 0
+
+  while [ -s "$file" ] && isAlive "$pid"; do
+    sleep 0.2
+    i=$((i + 1))
+    (( i >= timeout * 5 )) && return 1
+  done
+
+  rm -f -- "$file"
+  return 0
+}
+
+pKill() {
+
+  local pid="$1"
+  local timeout="${2:-10}"
+
+  { kill -15 -- "$pid" || :; } 2>/dev/null
+
+  if ! waitPid "$pid" "$timeout"; then
+    warn "Timed out while waiting for PID $pid"
+  fi
+
+  return 0
+}
+
 fWait() {
+
+  local i=0
   local name="$1"
+  local timeout="${2:-10}"
+
+  [ -z "$name" ] && return 0
 
   while pgrep -f -l "$name" >/dev/null; do
     sleep 0.2
+    i=$((i + 1))
+    if (( i >= timeout * 5 )); then
+      warn "Timed out while waiting for process: $name"
+      break
+    fi
   done
 
   return 0
 }
 
 fKill() {
-  local name="$1"
 
-  { pkill -f "$name" || true; } 2>/dev/null
+  local name="$1"
-  fWait "$name"
+  local timeout="${2:-10}"
+
+  [ -z "$name" ] && return 0
+
+  { pkill -f "$name" || :; } 2>/dev/null
+  fWait "$name" "$timeout"
 
   return 0
 }
 
+sKill() {
+
+  local pid=""
+  local file="$1"
+
+  [ ! -s "$file" ] && return 0
+  ! read -r pid <"$file" && return 0
+  [ -z "$pid" ] && return 0
+
+  if isAlive "$pid"; then
+    { kill -15 -- "$pid" || :; } 2>/dev/null
+  fi
+
+  return 0
+}
+
+mKill() {
+
+  local timeout=10
+  local files=("$@")
+
+  for file in "${files[@]}"; do
+    sKill "$file"
+  done
+
+  for file in "${files[@]}"; do
+    if ! waitPidFile "$file" "$timeout"; then
+      warn "Timed out while waiting for PID file: $file"
+    fi
+  done
+
+  return 0
+}
+
+setOwner() {
+
+  local file="$1"
+  local dir uid gid
+
+  [ ! -f "$file" ] && return 1
+
+  dir=$(dirname -- "$file")
+  uid=$(stat -c '%u' "$dir") || return 1
+  gid=$(stat -c '%g' "$dir") || return 1
+
+  ! chown "$uid:$gid" "$file" && return 1
+
+  return 0
+}
+
+makeDir() {
+
+  local path="$1"
+  local dir uid gid
+
+  [ -d "$path" ] && return 0
+  ! mkdir -p "$path" && return 1
+
+  dir=$(dirname -- "$path")
+
+  if ! uid=$(stat -c '%u' "$dir") || ! gid=$(stat -c '%g' "$dir"); then
+    warn "failed to determine the owner for \"$path\"."
+    return 0
+  fi
+
+  if ! chown "$uid:$gid" "$path"; then
+    warn "failed to set the owner for \"$path\"."
+    return 0
+  fi
+
+  return 0
+}
+
+stateFile() {
+
+  local name="$1"
+  local prefix="${2:-$PROCESS}"
+
+  [[ "$name" == */* ]] && printf '%s\n' "$name" && return 0
+
+  printf '%s/%s.%s\n' "$STORAGE" "$prefix" "$name"
+  return 0
+}
+
+writeFile() {
+
+  local txt="$1"
+  local path="$2"
+
+  if ! printf '%s\n' "$txt" > "$path"; then
+    error "Failed to write file \"$path\" !"
+    return 1
+  fi
+
+  if ! setOwner "$path"; then
+    warn "failed to set the owner for \"$path\"."
+  fi
+
+  return 0
+}
+
+readFile() {
+
+  local path="$1"
+  local value
+
+  [ -s "$path" ] || return 0
+
+  value=$(<"$path") || return 1
+  value="${value//[![:print:]]/}"
+
+  printf '%s\n' "$value"
+  return 0
+}
+
+writeState() {
+
+  local name="$1"
+  local value="$2"
+  local prefix="${3:-$PROCESS}"
+  local path
+
+  [ -z "$value" ] && return 0
+
+  path=$(stateFile "$name" "$prefix") || return 1
+  writeFile "$value" "$path"
+
+  return $?
+}
+
+readState() {
+
+  local name="$1"
+  local prefix="${2:-$PROCESS}"
+  local path
+
+  path=$(stateFile "$name" "$prefix") || return 1
+  readFile "$path"
+
+  return $?
+}
+
+restoreState() {
+
+  local var="$1"
+  local name="$2"
+  local force="${3:-N}"
+  local prefix="${4:-$PROCESS}"
+  local value
+
+  if ! enabled "$force"; then
+    [ -z "${!var:-}" ] || return 0
+  fi
+
+  value=$(readState "$name" "$prefix") || return 1
+  [ -n "$value" ] || return 0
+
+  printf -v "$var" '%s' "$value" || return 1
+  return 0
+}
+
 escape () {
+
   local s
   s=${1//&/\&amp;}
   s=${s//</\&lt;}
   s=${s//>/\&gt;}
   s=${s//'"'/\&quot;}
+
   printf -- %s "$s"
+
   return 0
 }
 
 html() {
+
   local title
   local body
   local script
@@ -102,52 +371,44 @@ html() {
   HTML="${HTML/\[4\]/$footer}"
   HTML="${HTML/\[5\]/$FOOTER2}"
 
-  echo "$HTML" > "$PAGE"
+  echo "$HTML" > "$PAGE" || return 1
-  echo "$body" > "$INFO"
+  echo "$body" > "$INFO" || return 1
 
   return 0
 }
 
 cpu() {
+
   local ret
   local cpu=""
 
   ret=$(lscpu)
-  
+
   if grep -qi "model name" <<< "$ret"; then
     cpu=$(echo "$ret" | grep -m 1 -i 'model name' | cut -f 2 -d ":" | awk '{$1=$1}1' | sed 's# @.*##g' | sed s/"(R)"//g | sed 's/[^[:alnum:] ]\+/ /g' | sed 's/  */ /g')
   fi
-  
+
   if [ -z "${cpu// /}" ] && grep -qi "model:" <<< "$ret"; then
     cpu=$(echo "$ret" | grep -m 1 -i 'model:' | cut -f 2 -d ":" | awk '{$1=$1}1' | sed 's# @.*##g' | sed s/"(R)"//g | sed 's/[^[:alnum:] ]\+/ /g' | sed 's/  */ /g')
   fi
-  
+
   cpu="${cpu// CPU/}"
-  cpu="${cpu// 4 Core/}"
+  cpu="${cpu// [0-9][0-9][0-9] Core}"
-  cpu="${cpu// 6 Core/}"
+  cpu="${cpu// [0-9][0-9] Core}"
-  cpu="${cpu// 8 Core/}"
+  cpu="${cpu// [0-9] Core}"
-  cpu="${cpu// 10 Core/}"
+  cpu="${cpu//[0-9][0-9]th Gen }"
-  cpu="${cpu// 12 Core/}"
+  cpu="${cpu//[0-9]th Gen }"
-  cpu="${cpu// 16 Core/}"
-  cpu="${cpu// 32 Core/}"
-  cpu="${cpu// 64 Core/}"
-  cpu="${cpu//7th Gen /}"
-  cpu="${cpu//8th Gen /}"
-  cpu="${cpu//9th Gen /}"
-  cpu="${cpu//10th Gen /}"
-  cpu="${cpu//11th Gen /}"
-  cpu="${cpu//12th Gen /}"
-  cpu="${cpu//13th Gen /}"
-  cpu="${cpu//14th Gen /}"
-  cpu="${cpu//15th Gen /}"
   cpu="${cpu// Processor/}"
   cpu="${cpu// Quad core/}"
   cpu="${cpu// Dual core/}"
   cpu="${cpu// Octa core/}"
+  cpu="${cpu// Hexa core/}"
   cpu="${cpu// Core TM/ Core}"
   cpu="${cpu// with Radeon Graphics/}"
   cpu="${cpu// with Radeon Vega Graphics/}"
-  
+  cpu="${cpu// with Radeon Vega Mobile Gfx/}"
+  cpu="${cpu// w Radeon [0-9][0-9][0-9]M Graphics/}"
+
   [ -z "${cpu// /}" ] && cpu="Unknown"
 
   echo "$cpu"
@@ -156,6 +417,8 @@ cpu() {
 
 hasDisk() {
 
+  enabled "${DISK_DISABLE:-}" && return 1
+
   [ -b "/disk" ] && return 0
   [ -b "/disk1" ] && return 0
   [ -b "/dev/disk1" ] && return 0
@@ -168,4 +431,67 @@ hasDisk() {
   return 1
 }
 
+getCountry() {
+
+  local url=$1
+  local query=$2
+  local rc json result
+
+  { json=$(curl -m 5 -H "Accept: application/json" -sfk "$url"); rc=$?; } || :
+  (( rc != 0 )) && return 0
+
+  { result=$(echo "$json" | jq -r "$query" 2> /dev/null); rc=$?; } || :
+  (( rc != 0 )) && return 0
+
+  [[ ${#result} -ne 2 ]] && return 0
+  [[ "${result^^}" == "XX" ]] && return 0
+
+  COUNTRY="${result^^}"
+
+  return 0
+}
+
+setCountry() {
+
+  [[ "${TZ,,}" == "asia/harbin" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/beijing" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/urumqi" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/kashgar" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/shanghai" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/chongqing" ]] && COUNTRY="CN"
+
+  [ -z "$COUNTRY" ] && getCountry "https://api.ipapi.is" ".location.country_code"
+  [ -z "$COUNTRY" ] && getCountry "https://ifconfig.co/json" ".country_iso"
+  [ -z "$COUNTRY" ] && getCountry "https://api.ip2location.io" ".country_code"
+  [ -z "$COUNTRY" ] && getCountry "https://ipinfo.io/json" ".country"
+  [ -z "$COUNTRY" ] && getCountry "https://api.ipquery.io/?format=json" ".location.country_code" 
+  [ -z "$COUNTRY" ] && getCountry "https://api.myip.com" ".cc"
+
+  return 0
+}
+
+addPackage() {
+
+  local pkg=$1
+  local desc=$2
+
+  if apt-mark showinstall | grep -qx "$pkg"; then
+    return 0
+  fi
+
+  MSG="Installing $desc..."
+  info "$MSG" && html "$MSG"
+
+  [ -z "$COUNTRY" ] && setCountry
+
+  if [[ "${COUNTRY^^}" == "CN" ]]; then
+    sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources
+  fi
+
+  DEBIAN_FRONTEND=noninteractive apt-get -qq update || return 1
+  DEBIAN_FRONTEND=noninteractive apt-get -qq --no-install-recommends -y install "$pkg" > /dev/null || return 1
+
+  return 0
+}
+
 return 0

web/conf/nginx.conf

@@ -27,4 +27,18 @@ server {
       index index.html;
 
     }
+
+    location /status {
+
+      proxy_http_version 1.1;
+
+      proxy_set_header Connection 'upgrade';
+      proxy_set_header Upgrade $http_upgrade;
+
+      proxy_buffering off;
+      proxy_read_timeout 3600s;
+      proxy_send_timeout 3600s;
+
+      proxy_pass http://127.0.0.1:8004/;
+    }    
 }

web/js/script.js

@@ -1,4 +1,5 @@
 var request;
+var booting = false;
 var interval = 1000;
 
 function getInfo() {
@@ -6,11 +7,14 @@ function getInfo() {
     var url = "msg.html";
 
     try {
+        if (request) {
+            request.abort();
+        }
 
         if (window.XMLHttpRequest) {
             request = new XMLHttpRequest();
         } else {
-            throw "XMLHttpRequest not available!";
+            throw new Error("XMLHttpRequest not available!");
         }
 
         request.onreadystatechange = processInfo;
@@ -18,22 +22,49 @@ function getInfo() {
         request.send();
 
     } catch (e) {
-        var err = "Error: " + e.message;
+        setError("Error: " + e.message);
-        console.log(err);
-        setError(err);
     }
 }
 
+function getURL() {
+
+    var protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    var path = window.location.pathname.replace(/[^/]*$/, '').replace(/\/$/, '');
+
+    return protocol + "//" + window.location.host + path;
+}
+
+function processMsg(msg) {
+
+    if (msg.toLowerCase().indexOf("href=") !== -1) {
+        var div = document.createElement("div");
+        div.innerHTML = msg;
+        var url = div.querySelector("a").href;
+        setTimeout(() => {
+            window.location.assign(url);
+        }, 3000);
+    }
+
+    setInfo(msg);
+    return true;
+}
+
 function processInfo() {
     try {
+
         if (request.readyState != 4) {
             return true;
         }
 
         var msg = request.responseText;
         if (msg == null || msg.length == 0) {
-            setInfo("Booting DSM instance", true);
+
-            schedule();
+            if (booting) {
+                schedule();
+                return true;
+            }
+
+            window.location.reload();
             return false;
         }
 
@@ -43,20 +74,11 @@ function processInfo() {
             if (msg.toLowerCase().indexOf("<html>") !== -1) {
                 notFound = true;
             } else {
-                if (msg.toLowerCase().indexOf("href=") !== -1) {
+                processMsg(msg);
-                    var div = document.createElement("div");
+                if (msg.toLowerCase().indexOf("href=") == -1) {
-                    div.innerHTML = msg;
-                    var url = div.querySelector("a").href;
-                    setTimeout(() => {
-                        window.location.assign(url);
-                    }, 3000);
-                    setInfo(msg);
-                    return true;
-                } else {
-                    setInfo(msg);
                     schedule();
-                    return true;
                 }
+                return true;
             }
         }
 
@@ -67,44 +89,60 @@ function processInfo() {
         }
 
         setError("Error: Received statuscode " + request.status);
-        schedule();
         return false;
 
     } catch (e) {
-        var err = "Error: " + e.message;
+        setError("Error: " + e.message);
-        console.log(err);
-        setError(err);
         return false;
     }
 }
 
-function setInfo(msg, loading, error) {
+function extractContent(s) {
+    var span = document.createElement('span');
+    span.innerHTML = s;
+    return span.textContent || span.innerText;
+};
 
+function setInfo(msg, loading, error) {
     try {
+
         if (msg == null || msg.length == 0) {
             return false;
         }
 
-        var el = document.getElementById("spinner");
+        if (msg.includes("Booting ")) {
+            booting = true;
+        }
+
+        var el = document.getElementById("info");
+
+        if (el.innerText == msg || el.innerHTML == msg) {
+            return true;
+        }
+
+        var spin = document.getElementById("spinner");
 
         error = !!error;
         if (!error) {
-            el.style.visibility = 'visible';
+            spin.style.visibility = 'visible';
         } else {
-            el.style.visibility = 'hidden';
+            spin.style.visibility = 'hidden';
         }
 
+        var p = "<p class=\"loading\">";
         loading = !!loading;
         if (loading) {
-            msg = "<p class=\"loading\">" + msg + "</p>";
+            msg = p + msg + "</p>";
         }
 
-        el = document.getElementById("info");
+        if (msg.includes(p)) {
-
+            if (el.innerHTML.includes(p)) {
-        if (el.innerHTML != msg) {
+                el.getElementsByClassName('loading')[0].textContent = extractContent(msg);
-            el.innerHTML = msg;
+                return true;
+            }
         }
 
+        el.innerHTML = msg;
         return true;
 
     } catch (e) {
@@ -114,6 +152,7 @@ function setInfo(msg, loading, error) {
 }
 
 function setError(text) {
+    console.warn(text);
     return setInfo(text, false, true);
 }
 
@@ -123,8 +162,47 @@ function schedule() {
 
 function reload() {
     setTimeout(() => {
-        document.location.reload();
+        window.location.reload();
     }, 3000);
 }
 
+function connect() {
+
+    var wsUrl = getURL() + "/status";
+    var ws = new WebSocket(wsUrl);
+
+    ws.onmessage = function(e) {
+
+        var pos = e.data.indexOf(":");
+        var cmd = e.data.substring(0, pos);
+        var msg = e.data.substring(pos + 2);
+
+        switch (cmd) {
+            case "s":
+                processMsg(msg);
+                break;
+            case "e":
+                setError(msg);
+                break;
+            default:
+                console.warn("Unknown event: " + cmd);
+                break;
+        }
+    };
+
+    ws.onclose = function(e) {
+        setTimeout(function() {
+            connect();
+        }, interval);
+    };
+
+    ws.onerror = function(e) {
+        ws.close();
+        if (!booting) {
+            window.location.reload();
+        }
+    };
+}
+
 schedule();
+connect();