Openai/690f5a8f-e6b0-800f-9707-b301528ae1f3

MergerFS disk fill option

Generated: 2025-11-08 22:17:00

Prompt: If I use MergerFS with an NVR, and I want it to fill up one disk at a time, letting the other drives sleep, what disk fill option should I use? Least Free Space? But if the /NVR folder exists on every disk won't every disk spin up?

ChatGPT: Excellent question — this is one of the trickiest things about using MergerFS with an NVR (Network Video Recorder) setup, because surveillance workloads are highly write-intensive and you don’t want every drive spinning 24/7 if you can help it.

Let’s go through this carefully:

You want:

• To record video to a pooled path (e.g. /mnt/storage or /pool/NVR)
• To fill up one drive at a time
• To allow other drives to stay spun down (sleep) when not in use

MergerFS has many “policies” for where new files get created. The key ones relevant to your case are:

So, the creation policy you want is: 👉 eplfs (Existing Path, Least Free Space)

That means:

• When writing new files, MergerFS will choose the drive that already has the least free space, i.e. the fullest drive.
• It will continue filling that drive until it’s full, then move on to the next.
• This minimizes the number of drives that are active at once.

The ep (existing path) part matters a lot.

If your NVR writes to /pool/NVR, and that folder exists on every drive, MergerFS will check all drives to find where /NVR exists — which can wake all drives.

✅ To avoid this: Only create /NVR on the first drive (or on whichever drive you want to start filling first).

For example:

/mnt/disk1/NVR
/mnt/disk2/    (no NVR folder yet)
/mnt/disk3/    (no NVR folder yet)

Then mount MergerFS like:

mergerfs /mnt/disk* /mnt/pool -o defaults,use_ino,category.create=eplfs,moveonenospc=true,cache.files=off,dropcacheonclose=true

Now, MergerFS will:

• Write to /mnt/disk1/NVR only.
• When disk1 fills up, you manually (or via script) create /mnt/disk2/NVR — then it’ll move to that drive.

1. Disable directory caching: cache.files=off, dropcacheonclose=true → Prevents the kernel from keeping directory metadata in memory, which otherwise causes unnecessary drive wakeups.
2. Avoid stat or background monitoring (like Plex scanners, NVR indexers, etc.) that scan the merged folder — they can wake all drives.
3. Consider NVR configuration If your NVR software insists on scanning or checking free space across all drives, that may still cause wakeups. Sometimes mounting MergerFS as a subfolder (e.g. /pool/NVR only, not root of pool) helps.

To fill one disk at a time and let others sleep, use:

category.create=eplfs

And make sure the target subfolder exists only on the currently active disk.

Optional full example:

mergerfs /mnt/disk* /mnt/pool \
  -o defaults,use_ino,category.create=eplfs,moveonenospc=true,cache.files=off,dropcacheonclose=true,minfreespace=5G

If you tell me which NVR software you’re using (e.g., Blue Iris, Shinobi, Frigate, ZoneMinder, etc.), I can suggest a layout that minimizes wakeups specifically for that system. Would you like that?

Prompt: It's for Reolink

ChatGPT: Perfect — Reolink makes this a bit easier, because their NVRs and cameras don’t scan or index storage like Plex or Shinobi do. They just write raw video streams continuously to the target path.

That means you can 100% make MergerFS work in a “fill one drive at a time” setup, as long as you plan the folder layout correctly.

Let’s go step-by-step.

You have multiple disks:

/mnt/disk1
/mnt/disk2
/mnt/disk3

You want to expose them as:

/mnt/pool/NVR

And you want Reolink to record to /mnt/pool/NVR while only one disk is spinning at a time.

Use this:

mergerfs /mnt/disk* /mnt/pool \
  -o defaults,use_ino,category.create=eplfs,moveonenospc=true,cache.files=off,dropcacheonclose=true,minfreespace=5G

• category.create=eplfs → fill the drive with least free space first (i.e., one at a time)
• moveonenospc=true → automatically move to the next drive if one fills up
• cache.files=off,dropcacheonclose=true → allow drives to spin down cleanly
• minfreespace=5G → leaves 5 GB free on each drive before switching

This is the crucial part for drive spindown.

Only create the Reolink folder (/NVR) on one drive at a time.

Example initial layout:

/mnt/disk1/NVR/
/mnt/disk2/       (no NVR folder)
/mnt/disk3/       (no NVR folder)

Then Reolink records to /mnt/pool/NVR → which actually writes into /mnt/disk1/NVR only.

When disk1 fills up:

1. Create /mnt/disk2/NVR
2. MergerFS (with eplfs) will now start filling that one next
3. disk1 can spin down completely

This keeps Reolink happily recording without caring that the data is actually spreading across drives over time.

You can check spindown with:

hdparm -C /dev/sdX

And manage timeouts with:

hdparm -S 120 /dev/sdX   # spin down after 10 minutes of inactivity

Also ensure:

• No cron jobs or daemons (like updatedb, smartd, or Reolink’s free space checker) are touching /mnt/pool frequently.
• Use /mnt/pool/NVR in the Reolink web UI or app, not /mnt/pool itself.

If you want the switch to happen automatically when one drive fills, you can use a tiny script (run hourly by cron) that does something like:

#!/bin/bash
# Check which drive is nearly full and create /NVR on the next one

for d in /mnt/disk*; do
  usage=$(df "$d" | awk 'NR==2 {print $5}' | tr -d '%')
  if [ "$usage" -ge 95 ]; then
    next=$(ls -d /mnt/disk* | grep -A1 "$d" | tail -n1)
    [ -d "$next" ] && [ ! -d "$next/NVR" ] && mkdir "$next/NVR"
  fi
done

That way, you never have to think about it — it just starts using the next disk when one’s full.

Would you like me to show a sample /etc/fstab entry for this setup, so it auto-mounts correctly on boot?

Prompt: When you create a folder to a mergerfs volume, doesn't it automatically generate that same folder on all drives?

ChatGPT: Excellent observation — and this is where MergerFS behavior can be unintuitive if you haven’t dug into how it handles new directories.

The short answer is:

It only creates the folder on one underlying drive, according to the create policy you’ve set.

Let’s break this down clearly:

When you do something like:

mkdir /mnt/pool/NVR

MergerFS decides which drive gets the real /NVR folder based on your category.create policy.

So for example:

• With category.create=eplfs (existing path, least free space): * It looks for drives that already have the parent path (in this case /mnt/diskX/) * Among those, it picks the one with the least free space (i.e. the fullest) * It creates /mnt/diskX/NVR only on that drive

No other disks get the folder until something explicitly creates it there later.

If /NVR exists on multiple drives already (e.g. /mnt/disk1/NVR, /mnt/disk2/NVR, /mnt/disk3/NVR), then:

• MergerFS will see all those paths as “existing”.
• When writing to /mnt/pool/NVR/..., it must check all drives to find where it can place files — and that can spin up all drives.

So you want to avoid that situation for your power-saving goal.

1. Make sure only the first drive has the folder initially:

    mkdir /mnt/disk1/NVR
   

   (Don’t create /NVR on the others yet.)
2. Mount MergerFS with:

    mergerfs /mnt/disk* /mnt/pool -o defaults,use_ino,category.create=eplfs,moveonenospc=true,cache.files=off,dropcacheonclose=true
   

3. Now when Reolink writes to /mnt/pool/NVR, it’ll create and fill files only on /mnt/disk1/NVR.
4. When disk1 fills up:

    mkdir /mnt/disk2/NVR
   

   Then MergerFS starts writing new files there.
5. disk1 can now spin down completely.

Imagine 3 disks:

/mnt/disk1/
/mnt/disk2/
/mnt/disk3/

Mount:

mergerfs /mnt/disk* /mnt/pool -o category.create=eplfs

Then run:

mkdir /mnt/pool/NVR

Check each:

ls /mnt/disk*/NVR

You’ll see:

/mnt/disk1/NVR
ls: cannot access '/mnt/disk2/NVR': No such file or directory
ls: cannot access '/mnt/disk3/NVR': No such file or directory

So only one got created.

Would you like me to show a script that automatically creates /NVR on the next drive once the current one is full (so you never have to do it manually)?

Prompt: yes please show that script

ChatGPT: Perfect 👍 — here’s a simple, reliable script that automatically creates the /NVR folder on the next drive only when the current drive is nearly full. This keeps your MergerFS pool running smoothly and allows older drives to sleep.

🧩 Script: nvr-autocreate.sh

#!/bin/bash
#
# Automatically create /NVR on the next MergerFS drive when the current one fills.
# Designed for setups using category.create=eplfs (fill one drive at a time).
#

# ---------- CONFIGURATION ----------
# Where your drives are mounted:
DRIVES=(/mnt/disk1 /mnt/disk2 /mnt/disk3)

# The path you want to manage inside the pool:
FOLDER_NAME="NVR"

# Minimum % free space before moving to next drive:
THRESHOLD=5    # 5% free space remaining

# ---------- SCRIPT LOGIC ----------
for ((i=0; i<${#DRIVES[@]}; i++)); do
    DRIVE="${DRIVES[$i]}"
    TARGET="$DRIVE/$FOLDER_NAME"

    # Skip if this drive doesn't have the folder
    [[ ! -d "$TARGET" ]] && continue

    # Get free space percentage (integer only)
    FREE=$(df -P "$DRIVE" | awk 'NR==2 {print 100 - $5}')

    # If free space <= threshold, prepare the next drive
    if (( FREE <= THRESHOLD )); then
        NEXT_INDEX=$((i+1))
        NEXT_DRIVE="${DRIVES[$NEXT_INDEX]}"
        NEXT_TARGET="$NEXT_DRIVE/$FOLDER_NAME"

        if [[ -z "$NEXT_DRIVE" ]]; then
            echo "⚠️  No more drives available after $DRIVE."
            exit 0
        fi

        if [[ ! -d "$NEXT_TARGET" ]]; then
            echo "📁 Creating $NEXT_TARGET ..."
            mkdir -p "$NEXT_TARGET"
            echo "✅ Created $NEXT_TARGET. MergerFS will now start using it next."
        fi
    fi
done

🧠 How It Works

• It loops through your drives (e.g. /mnt/disk1, /mnt/disk2, /mnt/disk3)
• Finds the one that currently has /NVR
• Checks free space * If ≤ 5% free (configurable), it creates /NVR on the next drive in the list
• MergerFS will then automatically start filling that new one (because of eplfs)

⚙️ Setup Instructions

1. Save the script:

    sudo nano /usr/local/bin/nvr-autocreate.sh
   

   (Paste the code, then Ctrl+O, Enter, Ctrl+X)
2. Make it executable:

    sudo chmod +x /usr/local/bin/nvr-autocreate.sh
   

3. Test it manually:

    sudo /usr/local/bin/nvr-autocreate.sh
   

4. If it looks good, schedule it to run automatically (e.g., every hour):

    sudo crontab -e
   

   Add this line:

    0 * * * * /usr/local/bin/nvr-autocreate.sh >/dev/null 2>&1 

🧾 Example Output

When disk1 gets full:

📁 Creating /mnt/disk2/NVR ...
✅ Created /mnt/disk2/NVR. MergerFS will now start using it next.

When all drives are full:

⚠️  No more drives available after /mnt/disk3.

✅ Summary

Task	Done by
Fill one disk at a time	category.create=eplfs
Keep others spun down	Only one /NVR exists at a time
Automatically prepare next drive	nvr-autocreate.sh
Scheduling	Cron every hour (or more frequently if desired)

Would you like me to modify the script to also send a system notification or email when a new drive is activated (for example, “Now writing to disk2”)?