btrbk is a backup tool for btrfs subvolumes, taking advantage of btrfs specific capabilities to create atomic snapshots and transfer them incrementally to your backup locations.

The source and target locations are specified in a config file, which allows to easily configure simple scenarios like "laptop with locally attached backup disks", as well as more complex ones, e.g. "server receiving backups from several hosts via ssh, with different retention policy".

Key Features:

  • Atomic snapshots
  • Incremental backups
  • Configurable retention policy
  • Backups to multiple destinations
  • Transfer via ssh
  • Resume of backups (if backup target was not reachable for a while)
  • Encrypted backups to non-btrfs destinations
  • Wildcard subvolumes (useful for docker and lxc containers)
  • Transaction log
  • Comprehensive list and statistics output
  • Resolve and trace btrfs parent-child and received-from relationships
  • Display file changes between two backups

btrbk is designed to run as a cron job for triggering periodic snapshots and backups, as well as from the command line (e.g. for instantly creating additional snapshots).


Btrbk is a single perl script, and does not require any special installation procedures or libraries. Simply download the latest btrbk source tarball and run the "btrbk" executable.

For more information, read the installation documentation.


  • btrfs-progs: Btrfs filesystem utilities >= v3.18.2
  • Perl interpreter: Probably already installed on your system
  • OpenSSH: If you want to transfer backups from/to remote locations
  • Pipe Viewer: If you want rate limiting and progress bars


Please consult the btrbk(1) man-page provided with this package for a full description of the command line options.

Configuration File

Before running btrbk, you will need to create a configuration file. You might want to take a look at btrbk.conf.example provided with this package. For a detailed description, please consult the btrbk.conf(5) man-page.

When playing around with config-files, it is highly recommended to check the output using the dryrun command before executing the backups:

btrbk -c /path/to/myconfig -v dryrun

This will read all btrfs information on the source/target filesystems and show what actions would be performed (without writing anything to the disks).

Example: laptop with usb-disk for backups

In this example, we assume you have a laptop with:

  • a disk having a btrfs root subvolume (subvolid=5) mounted on /mnt/btr_pool, containing a subvolume rootfs for the root filesystem (i.e. mounted on /) and a subvolume home for the user data,
  • a directory or subvolume /mnt/btr_pool/btrbk_snapshots which will hold the btrbk snapshots,
  • a backup disk having a btrfs volume mounted as /mnt/btr_backup, containing a subvolume or directory mylaptop for the incremental backups.

Retention policy:

  • keep all snapshots for 2 days, no matter how frequently you (or your cron-job) run btrbk
  • keep daily snapshots for 14 days (very handy if you are on the road and the backup disk is not attached)
  • keep monthly backups forever
  • keep weekly backups for 10 weeks
  • keep daily backups for 20 days


snapshot_preserve_min       2d
snapshot_preserve          14d

target_preserve_min        no
target_preserve            20d 10w *m

snapshot_dir               btrbk_snapshots

volume /mnt/btr_pool
  subvolume rootfs
    target send-receive    /mnt/btr_backup/mylaptop

  subvolume home
    target send-receive    /mnt/btr_backup/mylaptop


exec /usr/sbin/btrbk -q -c /etc/btrbk/btrbk-mylaptop.conf run
  • This will create snapshots on a daily basis:
    • /mnt/btr_pool/btrbk_snapshots/rootfs.YYYYMMDD
    • /mnt/btr_pool/btrbk_snapshots/home.YYYYMMDD
  • And create incremental backups in:
    • /mnt/btr_backup/mylaptop/rootfs.YYYYMMDD
    • /mnt/btr_backup/mylaptop/home.YYYYMMDD

If you want the snapshots to be created only if the backup disk is attached, simply add the following line to the config:

snapshot_create            ondemand

Example: host-initiated backup on fileserver

Let's say you have a fileserver at "" where you want to create backups of your laptop disk, the config would look like this:

ssh_identity               /etc/btrbk/ssh/id_rsa

volume /mnt/btr_pool
  subvolume rootfs
    target send-receive    /mnt/btr_backup/mylaptop
    target send-receive    ssh://

In addition to the backups on your local usb-disk mounted at /mnt/btr_backup/mylaptop, incremental backups would also be pushed to

Example: fileserver-initiated backups from several hosts

If you're a sysadmin and want to trigger backups directly from your fileserver, the config would be something like:

ssh_identity               /etc/btrbk/ssh/id_rsa

volume ssh://
  subvolume rootfs
    target send-receive    /mnt/btr_backup/alpha

  subvolume home
    target send-receive    /mnt/btr_backup/alpha

volume ssh://
  subvolume rootfs
    target send-receive    /mnt/btr_backup/beta

  subvolume dbdata
    target send-receive    /mnt/btr_backup/beta

This will pull backups from alpha/ and locally create:

  • /mnt/btr_backup/alpha/rootfs.YYYYMMDD
  • /mnt/btr_backup/alpha/home.YYYYMMDD
  • /mnt/btr_backup/beta/rootfs.YYYYMMDD
  • /mnt/btr_backup/beta/dbdata.YYYYMMDD

Example: local time-machine (hourly snapshots)

If all you want is to create snapshots of your home directory on a regular basis:


timestamp_format        long
snapshot_preserve_min   18h
snapshot_preserve       48h 20d 6m

volume /mnt/btr_pool
  snapshot_dir btrbk_snapshots
  subvolume home


exec /usr/sbin/btrbk -q run

Note that you can run btrbk more than once an hour, e.g. by calling sudo btrbk run from the command line. With this setup, all those extra snapshots will be kept for 18 hours.

Example: multiple btrbk instances

Let's say we have a host (at running btrbk with the setup of the time-machine example above, and we need a backup server to only fetch the snapshots.

/etc/btrbk/btrbk.conf (on backup server):

target_preserve_min        no
target_preserve            0d 10w *m

volume ssh://
  subvolume home
    snapshot_dir           btrbk_snapshots
    snapshot_preserve_min  all
    snapshot_create        no

    target send-receive  /mnt/btr_backup/

If the server runs btrbk with this config, 10 weeklies and all monthlies are received from The source filesystem is never altered because of snapshot_preserve_min all.

Example: backup from non-btrfs source

First create a btrfs subvolume on the backup server:

# btrfs subvolume create /mnt/btr_backup/myhost_sync

In your daily cron script, prior to running btrbk, sync your source to myhost_sync, something like:

rsync -a --inplace --delete -e ssh /mnt/btr_backup/myhost_sync/

Then run btrbk, with myhost_sync configured without any targets as follows:

volume /mnt/btr_backup
  subvolume myhost_sync
    snapshot_name           myhost

    snapshot_preserve_min   latest
    snapshot_preserve       14d 20w *m

This will produce daily snapshots /mnt/btr_backup/myhost.20150101, with retention as defined with the snapshot_preserve option.

Note that the provided script: "contrib/cron/btrbk-mail" has support for this!

Example: encrypted backup to non-btrfs target

If your backup server does not support btrfs, you can send your subvolumes to a raw file.

This is an experimental feature: btrbk supports "raw" targets, meaning that similar to the "send-receive" target the btrfs subvolume is being sent using btrfs send (mirroring filesystem level data), but instead of instantly being received (btrfs receive) by the target filesystem, it is being redirected to a file, optionally compressed and piped through GnuPG.


raw_target_compress   xz
raw_target_encrypt    gpg
gpg_keyring           /etc/btrbk/gpg/pubring.gpg

volume /mnt/btr_pool
  subvolume home
    target raw ssh://
      ssh_user  btrbk
      # incremental  no

This will create a GnuPG encrypted, compressed files on the target host. For each backup, two files are created:

  • /backup/home.YYYYMMDD.btrfs.xz.gpg: main data file containing the btrfs send-stream,
  • /backup/ sidecar file containing metadata used by btrbk.

I you are using raw incremental backups, please make sure you understand the implications (see btrbk.conf(5), TARGET TYPES).

Setting up SSH

Since btrbk needs root access, it is very advisable to take all the security precautions you can. In most cases backups are generated periodically without user interaction, so it is not possible to protect your ssh key with a password. The steps below will give you hints on how to secure your ssh server for a backup scenario. Note that the btrbk executable is not needed on the remote side, but you will need the btrfs executable from the btrfs-progs package.

Step 1: Create SSH keypair

On the client side, create a ssh key dedicated to btrbk, without password protection:

ssh-keygen -t rsa -b 2048 -f /etc/btrbk/ssh/id_rsa -C -N ""

The content of the public key (/etc/btrbk/ssh/ is used for authentication in "authorized_keys" on the server side (see sshd(8) for details).

Step 2 (option): root login restricted by ""

Btrbk comes with a shell script "", which restricts ssh access to sane calls to the "btrfs" command needed for snapshot creation and send/receive operations (see ssh_filter_btrbk(1)).

Copy "" to "/backup/scripts/", and configure sshd to run it whenever the key is used for authentication. Example "/root/.ssh/authorized_keys":

# example backup source (also allowing deletion of old snapshots)
command="/backup/scripts/ -l --source --delete" <pubkey>...

# example backup target (also allowing deletion of old snapshots)
command="/backup/scripts/ -l --target --delete" <pubkey>...

# example fetch-only backup source (snapshot_preserve_min=all, snapshot_create=no),
# restricted to subvolumes within /home or /data
command="/backup/scripts/ -l --send -p /home -p /data" <pubkey>...

Step 2 (option): dedicated user login, using different backend

Create a user dedicated to btrbk and add the public key to "/home/btrbk/.ssh/authorized_keys". In "btrbk.conf", choose either:

  • backend btrfs-progs-btrbk to use separated binaries with elevated privileges (suid or fscaps) instead of the "btrfs" command (see btrfs-progs-btrbk).

  • backend btrfs-progs-sudo, configure "/etc/sudoers" and add the --sudo option.

Further considerations

You might also want to restrict ssh access to a static IP address within your network:

from="",command=... <pubkey>...

For even more security, set up a chroot environment in "/etc/ssh/sshd_config" (see sshd_config(5)).

Restoring Backups

btrbk does not provide any mechanism to restore your backups, this has to be done manually. In the examples below, we assume that you have a btrfs volume mounted at /mnt/btr_pool, and the subvolume you want to have restored is at /mnt/btr_pool/data.

Important: don't use btrfs property set to make a subvolume read-write after restoring. This is a low-level command, and leaves "Received UUID" in a false state which causes btrbk to fail on subsequent incremental backups. Instead, use btrfs subvolume snapshot (without -r flag) as described below.

Example: Restore a Snapshot

First, pick a snapshot to be restored:

btrbk list snapshots

From the list, pick the snapshot you want to restore. Let's say it's /mnt/btr_pool/_btrbk_snap/data.20150101.

If the broken subvolume is still present, move it away:

mv /mnt/btr_pool/data /mnt/btr_pool/data.BROKEN

Now restore the snapshot:

btrfs subvolume snapshot /mnt/btr_pool/_btrbk_snap/data.20150101 /mnt/btr_pool/data

That's it; your data subvolume is restored. If everything went fine, it's time to nuke the broken subvolume:

btrfs subvolume delete /mnt/btr_pool/data.BROKEN

Example: Restore a Backup

First, pick a backup to be restored:

btrbk list backups

From the list, pick the backup you want to restore. Let's say it's /mnt/btr_backup/data.20150101.

If the broken subvolume is still present, move it away:

mv /mnt/btr_pool/data /mnt/btr_pool/data.BROKEN

Now restore the backup:

btrfs send /mnt/btr_backup/data.20150101 | btrfs receive /mnt/btr_pool/
btrfs subvolume snapshot /mnt/btr_pool/data.20150101 /mnt/btr_pool/data
btrfs subvolume delete /mnt/btr_pool/data.20150101

Alternatively, if you're restoring data on a remote host, do something like this:

btrfs send /mnt/btr_backup/data.20150101 | ssh btrfs receive /mnt/btr_pool/

Hint: If you still have common snapshot / backup pairs (i.e. both "snapshot_subvol" and "target_subvol" are listed) consider sending the backup incrementally by specifying a parent subvolume:

btrfs send -p /mnt/btr_backup/<parent-subvolume> [...]

This allows btrbk to continue using the parent subvolume for incremental backups later.

If everything went fine, nuke the broken subvolume:

btrfs subvolume delete /mnt/btr_pool/data.BROKEN


Make sure to also read the btrbk FAQ page. Help improve it by asking!


So btrbk saved your day?

I will definitively continue developing btrbk for free, but if you want to support me you can do so:



Source Code Repository

The source code for btrbk is managed using Git.

Official repository:

git clone

Mirror on GitHub:

git clone

How to Contribute

Your contributions are welcome!

If you would like to contribute or have found bugs:

Any feedback is appreciated!


btrbk is free software, available under the GNU General Public License, Version 3.

« prev | next »