The ZFS file system provides functionality to create a snapshot of
the file system contents, transfer the snapshot to another machine,
and extract the snapshot to recreate the file system. You can create
a snapshot at any time, and you can create as many snapshots as you
like. By continually creating, transferring, and restoring
snapshots, you can provide synchronization between one or more
machines in a fashion similar to DRBD.

The following example shows a simple Solaris system running with a
single ZFS pool, mounted at /scratchpool:

The snapshots themselves are stored within the file system metadata,
and the space required to keep them varies as time goes on because
of the way the snapshots are created. The initial creation of a
snapshot is very quick, because instead of taking an entire copy of
the data and metadata required to hold the entire snapshot, ZFS
records only the point in time and metadata of when the snapshot was
created.

As more changes to the original file system are made, the size of
the snapshot increases because more space is required to keep the
record of the old blocks. If you create lots of snapshots, say one
per day, and then delete the snapshots from earlier in the week, the
size of the newer snapshots might also increase, as the changes that
make up the newer state have to be included in the more recent
snapshots, rather than being spread over the seven snapshots that
make up the week.

You cannot directly back up the snapshots because they exist within
the file system metadata rather than as regular files. To get the
snapshot into a format that you can copy to another file system,
tape, and so on, you use the zfs send command to
create a stream version of the snapshot.

For example, to write the snapshot out to a file:

root-shell> zfs send scratchpool@snap1 >/backup/scratchpool-snap1

Or tape:

root-shell> zfs send scratchpool@snap1 >/dev/rmt/0

You can also write out the incremental changes between two snapshots
using zfs send: