Provided by: fsarchiver_0.6.22-1_amd64 bug


       fsarchiver - filesystem archiver


       fsarchiver  is  a  system  tool  that allows you to save the contents of a filesystem to a
       compressed archive file. The file-system can be  restored  on  a  partition  which  has  a
       different  size  and  it  can  be  restored  on  a  different file-system. Unlike tar/dar,
       FSArchiver also creates the filesystem when it extracts the data to partitions. Everything
       is checksummed in the archive in order to protect the data. If the archive is corrupt, you
       just lose the current file, not the whole archive.


   Official project homepage:

   Quick Start Guide:

   Forums where to ask questions:

   Report a bug:


       fsarchiver [ options ] savefs archive filesystem ...

       fsarchiver [ options ] restfs  archive  id=n,dest=filesystem[,mkfs=fstype,mkfsopt=options]

       fsarchiver [ options ] savedir archive directory ...

       fsarchiver [ options ] restdir archive destination

       fsarchiver [ options ] archinfo archive

       fsarchiver [ options ] probe [detailed]


       savefs Save filesystems to archive.

       restfs Restore   filesystems   from   archive.   This  overwrites  the  existing  data  on
              filesystems.  Zero-based index n indicates the part  of  the  archive  to  restore.
              Optionally, a filesystem may be converted to fstype.

              Save directories to archive (similar to a compressed tarball).

              Restore data from archive which is not based on a filesystem to destination.

              Show information about an existing archive file and its contents.

       probe  Show list of filesystems detected on the disks.


       -h, --help
              Show help and information about how to use fsarchiver with examples.

       -V, --version
              Show program version and exit.

       -v, --verbose
              Verbose  mode  (can  be  used several times to increase the level of details).  The
              details will be printed to the console.

       -o, --overwrite
              Overwrite the archive if it already exists instead of failing.

       -d, --debug
              Debug mode (can be used several times to  increase  the  level  of  details).   The
              details will be written in /var/log/fsarchiver.log.

       -A, --allow-rw-mounted
              Allow  to  save  a  filesystem  which  is  mounted in read-write (live backup).  By
              default fsarchiver fails with an error if the partition if  mounted  in  read-write
              mode  which  allows  modifications  to be done on the filesystem during the backup.
              Modifications can drive to inconsistencies in the backup.  Using lvm  snapshots  is
              the  recommended  way  to make backups since it will provide consistency, but it is
              only available for filesystems which are on LVM logical-volumes.

       -a, --allow-no-acl-xattr
              Allow to run savefs when partition is mounted without the  acl/xattr  options.   By
              default  fsarchiver  fails  with an error if the partition is mounted in such a way
              that the ACL and Extended-Attributes are not readable. These attributes  would  not
              be  saved  and  then such attributes could be lost. If you know what you don't need
              ACL and Extended-Attributes to be preserved then it's safe to run  fsarchiver  with
              that option.

       -e pattern, --exclude=pattern
              Exclude  files  and  directories  that match that pattern. The pattern can contains
              shell asterisks such as * and ?, and the pattern may be either  a  simple  file/dir
              name or an absolute file/dir path. You must use quotes around the pattern each time
              you use wildcards, else it would be interpreted by the shell. The wildcards must be
              interpreted by fsarchiver. See examples below for more details about this option.

       -L label, --label=label
              Set  the  label  of the archive: it's just a comment about the contents.  It can be
              used to remember a  particular  thing  about  the  archive  or  the  state  of  the
              filesystem for instance.

       -z level, --compress=level
              Valid  compression  levels are between 1 (very fast) and 9 (very good).  The memory
              requirement increases a lot with the best compression levels, and  it's  multiplied
              by  the  number  of  compression  threads (option -j).  Level 9 is considered as an
              extreme compression level and requires an huge amount of memory to run.   For  more
              details please read this page:

       -s mbsize, --split=mbsize
              Split the archive into several files of mbsize megabytes each.

       -j count, --jobs=count
              Create  more  than  one  compression thread. Useful on multi-core CPUs.  By default
              fsarchiver will only use one compression thread (-j 1) and then  only  one  logical
              processor  will  be used for compression.  You should use that option if you have a
              multi-core CPU or more than one physical CPU on your computer. The typical  way  to
              use  this  option  is to specify the number of logical processors available so that
              all the processing power is used to compress the archive very quickly. You may also
              want  to  use  all  the logical processors but one for that task so that the system
              stays responsive for other applications.

       -c password, --cryptpass=password
              Encrypt/decrypt data in archive. Password length: 6 to 64 chars.   You  can  either
              provide  a  real password or a dash ("-c -") with this option if you do not want to
              provide the password in the command line and you want to be prompted for a password
              in the terminal instead.


   save only one filesystem (/dev/sda1) to an archive:
       fsarchiver savefs /data/myarchive1.fsa /dev/sda1

   save two filesystems (/dev/sda1 and /dev/sdb1) to an archive:
       fsarchiver savefs /data/myarchive2.fsa /dev/sda1 /dev/sdb1

   restore the first filesystem from an archive (first = number 0):
       fsarchiver restfs /data/myarchive2.fsa id=0,dest=/dev/sda1

   restore the second filesystem from an archive (second = number 1):
       fsarchiver restfs /data/myarchive2.fsa id=1,dest=/dev/sdb1

   restore two filesystems from an archive (number 0 and 1):
       fsarchiver restfs /data/arch2.fsa id=0,dest=/dev/sda1 id=1,dest=/dev/sdb1

   restore a filesystem from an archive and convert it to reiserfs:
       fsarchiver restfs /data/myarchive1.fsa id=0,dest=/dev/sda1,mkfs=reiserfs

   restore a filesystem from an archive and specify extra mkfs options:
       fsarchiver restfs /data/myarchive1.fsa id=0,dest=/dev/sda1,mkfs=ext4,mkfsopt="-I 256"

   save the contents of /usr/src/linux to an archive (similar to tar):
       fsarchiver savedir /data/linux-sources.fsa /usr/src/linux

   save a /dev/sda1 to an archive split into volumes of 680MB:
       fsarchiver savefs -s 680 /data/myarchive1.fsa /dev/sda1

   save a filesystem and exclude all files/dirs called 'pagefile.*'
       fsarchiver savefs /data/myarchive.fsa /dev/sda1 --exclude='pagefile.*'

   exclude 'share' in both '/usr/share' and '/usr/local/share':
       fsarchiver savefs /data/myarchive.fsa --exclude=share

   absolute exclude valid for '/usr/share' but not '/usr/local/share'
       fsarchiver savefs /data/myarchive.fsa --exclude=/usr/share

   save a filesystem (/dev/sda1) to an encrypted archive:
       fsarchiver savefs -c mypassword /data/myarchive1.fsa /dev/sda1

   extract an archive made of simple files to /tmp/extract:
       fsarchiver restdir /data/linux-sources.fsa /tmp/extract

   show information about an archive and its file systems:
       fsarchiver archinfo /data/myarchive2.fsa


       fsarchiver is still in development, don't use it for critical data yet.


       fsarchiver  was  written  by  Francois  Dupoux. It is released under the GPL2 (GNU General
       Public License version 2). This manpage was written by Ilya Barygin and Francois Dupoux.

                                         30 December 2009                           FSARCHIVER(8)