Basic Rsync Usage Summaries from Man Page

Be careful with the –delete switch!! I regard this as the most dangerous command since when rm -vr / did not have a default "–interactive" to prevent deletion without checks.  –delete did not seem to behave as described below – test it on expendable data first! You only need z compression over slow links. a archive is recursive and includes all links, attribs, timestamps, perms etc.; you don't need both -ar. In crontabs, don't use -h; you're not watching, -a will do.

Page info summarised for me, for generic copy/update with compression but no deletes, with timestamps retained to:
rsync /Quadra/StevesITStuff/ /Storebird/StevesITStuff –progress -vazh –dry-run

or, easier to edit quickly:

rsync /Quadra/StevesITStuff/ /Storebird/StevesITStuff –progress -vahn
then Go!

rsync /Quadra/StevesITStuff/     /Storebird/StevesITStuff –progress –vah

DOUBLE CHECK THE TRAILING SLASHES – Prevent same directory nesting!! The above line is the same as below:

rsync /Quadra/StevesITStuff/*   /Storebird/StevesITStuff/ –progress –vah

but BEWARE! It is NOT the same as below – which nests the source in the destination:

rsync /Quadra/StevesITStuff    /Storebird/StevesITStuff/ –progress –vah

To exclude multiple files/dirs say, for your update to a backup of key OS dirs you have recursively copied to BURoot already:

sudo rsync –progress / /BURoot/ –exclude={BURoot,cdrom,dev,proc,sys,tmp} -vahn

There is a GUI frontend called grsync if you prefer to not use cmd lines, and install that also.


rsync – a fast, versatile, remote (and local) file-copying tool


Local: rsync [OPTION…] SRC… [DEST]

Access via remote shell:

Pull: rsync [OPTION…] [USER@]HOST:SRC… [DEST]


Access via rsync daemon:

Pull: rsync [OPTION…] [USER@]HOST::SRC… [DEST]

rsync [OPTION…] rsync://[USER@]HOST[:PORT]/SRC… [DEST]

Push: rsync [OPTION…] SRC… [USER@]HOST::DEST

rsync [OPTION…] SRC… rsync://[USER@]HOST[:PORT]/DEST

Usages with just one SRC arg and no DEST arg will list the source files

instead of copying.


Rsync is a fast and extraordinarily versatile file copying tool. It

can copy locally, to/from another host over any remote shell, or

to/from a remote rsync daemon. It offers a large number of options

that control every aspect of its behavior and permit very flexible

specification of the set of files to be copied. It is famous for its

delta-transfer algorithm, which reduces the amount of data sent over

the network by sending only the differences between the source files

and the existing files in the destination. Rsync is widely used for

backups and mirroring and as an improved copy command for everyday use.

Rsync finds files that need to be transferred using a "quick check"

algorithm (by default) that looks for files that have changed in size

or in last-modified time. Any changes in the other preserved

attributes (as requested by options) are made on the destination file

directly when the quick check indicates that the files data does not

need to be updated.


You use rsync in the same way you use rcp. You must specify a source

and a destination, one of which may be remote.

Perhaps the best way to explain the syntax is with some examples:

rsync -t *.c     foo:src/

This would transfer all files matching the pattern *.c from the current

directory to the directory src on the machine foo. If any of the files

already exist on the remote system then the rsync remote-update proto

col is used to update the file by sending only the differences.

rsync -avz foo:src/bar /data/tmp

This would recursively transfer all files from the directory src/bar on

the machine foo into the /data/tmp/bar directory on the local machine.

The files are transferred in "archive" mode, which ensures that sym

bolic links, devices, attributes, permissions, ownerships, etc. are

preserved in the transfer. Additionally, compression will be used to

reduce the size of data portions of the transfer.

rsync -avz foo:src/bar/ /data/tmp

A trailing slash on the source changes this behavior to avoid creating

an additional directory level at the destination. You can think of a

trailing / on a source as meaning "copy the contents of this directory"

as opposed to "copy the directory by name", but in both cases the

attributes of the containing directory are transferred to the contain

ing directory on the destination. In other words, each of the follow

ing commands copies the files in the same way, including their setting

of the attributes of /dest/foo:

rsync -av /src/foo /dest

rsync -av /src/foo/ /dest/foo

If you need to transfer a filename that contains whitespace, you can

either specify the –protect-args (-s) option, or you'll need to escape

the whitespace in a way that the remote shell will understand. For


rsync -av host:'file\ name\ with\ spaces' /dest

I mirror a directory between my "old" and "new" ftp sites with the com


rsync -az -e ssh –delete ~ftp/pub/samba nimbus:"~ftp/pub/tridge"

(*VIA A REMOTE-SHELL CONNECTION – the sshd and keys would have been setup for no pword login here?)


Here is a short summary of the options available in rsync. Please refer

to the detailed description below for a complete description.


This option tells rsync to print information showing the

progress of the transfer. This gives a bored user something to


-n, –dry-run

This makes rsync perform a trial run that doesnt make any

changes (and produces mostly the same output as a real run). It

is most commonly used in combination with the -v, –verbose

and/or -i, –itemize-changes options to see what an rsync com

mand is going to do before one actually runs it.

-u, –update

This forces rsync to skip any files which exist on the destina

tion and have a modified time that is newer than the source

file. (If an existing destination file has a modification time

equal to the source files, it will be updated if the sizes are



This tells rsync to skip updating files that already exist on

the destination (this does not ignore existing directories, or

nothing would get done). See also –existing.


This tells rsync to delete extraneous files from the receiving

side (ones that arent on the sending side), but only for the

directories that are being synchronized. You must have asked

rsync to send the whole directory (e.g. "dir" or "dir/") without

using a wildcard for the directorys contents (e.g. "dir/*")

since the wildcard is expanded by the shell and rsync thus gets

a request to transfer individual files, not the files parent

directory. Files that are excluded from the transfer are also

excluded from being deleted unless you use the –delete-excluded

option or mark the rules as only matching on the sending side

(see the include/exclude modifiers in the FILTER RULES section).

Prior to rsync 2.6.7, this option would have no effect unless

–recursive was enabled. Beginning with 2.6.7, deletions will

also occur when –dirs (-d) is enabled, but only for directories

whose contents are being copied.

This option can be dangerous if used incorrectly! It is a very

good idea to first try a run using the –dry-run option (-n) to

see what files are going to be deleted.

If the sending side detects any I/O errors, then the deletion of

any files at the destination will be automatically disabled.

This is to prevent temporary filesystem failures (such as NFS

errors) on the sending side from causing a massive deletion of

files on the destination. You can override this with the

–ignore-errors option.


Request that the file-deletions on the receiving side be done

before the transfer starts. See –delete (which is implied) for

more details on file-deletion.

Deleting before the transfer is helpful if the filesystem is

tight for space and removing extraneous files would help to make

the transfer possible. However, it does introduce a delay

before the start of the transfer, and this delay might cause the

transfer to timeout (if –timeout was specified). It also

forces rsync to use the old, non-incremental recursion algorithm

that requires rsync to scan all the files in the transfer into

memory at once (see –recursive).

–delete-during, –del

Request that the file-deletions on the receiving side be done

incrementally as the transfer happens. The per-directory delete

scan is done right before each directory is checked for updates,

so it behaves like a more efficient –delete-before, including

doing the deletions prior to any per-directory filter files

being updated.

-z, –compress

With this option, rsync compresses the file data as it is sent

to the destination machine, which reduces the amount of data

being transmitted — something that is useful over a slow con


Note that this option typically achieves better compression

ratios than can be achieved by using a compressing remote shell

or a compressing transport because it takes advantage of the

implicit information in the matching data blocks that are not

explicitly sent over the connection.

-h, –human-readable

Output numbers in a more human-readable format. There are 3

possible levels: (1) output numbers with a separator between

each set of 3 digits (either a comma or a period, depending on

if the decimal point is represented by a period or a comma); (2)

output numbers in units of 1000 (with a character suffix for

larger units — see below); (3) output numbers in units of 1024.

The default is human-readable level 1.


This option allows you to specify the maximum transfer rate for

the data sent over the socket, specified in units per second.

The RATE value can be suffixed with a string to indicate a size

multiplier, and may be a fractional value (e.g.

"–bwlimit=1.5m"). If no suffix is specified, the value will be

assumed to be in units of 1024 bytes (as if "K" or "KiB" had

been appended).

A WEB site is available at

The site includes

an FAQ-O-Matic which may cover questions unanswered by this manual



rsync was originally written by Andrew Tridgell and Paul Mackerras.

Many people have later contributed to it. It is currently maintained

by Wayne Davison.

-v, –verbose increase verbosity

–info=FLAGS fine-grained informational verbosity

–debug=FLAGS fine-grained debug verbosity

–msgs2stderr special output handling for debugging

-q, –quiet suppress non-error messages

–no-motd suppress daemon-mode MOTD (see caveat)

-c, –checksum skip based on checksum, not mod-time & size

-a, –archive archive mode; equals -rlptgoD (no -H,-A,-X)

–no-OPTION turn off an implied OPTION (e.g. –no-D)

-r, –recursive recurse into directories

-R, –relative use relative path names

–no-implied-dirs don't send implied dirs with –relative

-b, –backup make backups (see –suffix & –backup-dir)

–backup-dir=DIR make backups into hierarchy based in DIR

–suffix=SUFFIX backup suffix (default ~ w/o –backup-dir)

-u, –update skip files that are newer on the receiver

–inplace update destination files in-place

–append append data onto shorter files

–append-verify –append w/old data in file checksum

-d, –dirs transfer directories without recursing

-l, –links copy symlinks as symlinks

-L, –copy-links transform symlink into referent file/dir

–copy-unsafe-links only "unsafe" symlinks are transformed

–safe-links ignore symlinks that point outside the tree

–munge-links munge symlinks to make them safer

-k, –copy-dirlinks transform symlink to dir into referent dir

-K, –keep-dirlinks treat symlinked dir on receiver as dir

-H, –hard-links preserve hard links

-p, –perms preserve permissions

-E, –executability preserve executability

–chmod=CHMOD affect file and/or directory permissions

-A, –acls preserve ACLs (implies -p)

-X, –xattrs preserve extended attributes

-o, –owner preserve owner (super-user only)

-g, –group preserve group

–devices preserve device files (super-user only)

–specials preserve special files

-D same as –devices –specials

-t, –times preserve modification times

-O, –omit-dir-times omit directories from –times

-J, –omit-link-times omit symlinks from –times

–super receiver attempts super-user activities

–fake-super store/recover privileged attrs using xattrs

-S, –sparse handle sparse files efficiently

–preallocate allocate dest files before writing

-n, –dry-run perform a trial run with no changes made

-W, –whole-file copy files whole (w/o delta-xfer algorithm)

-x, –one-file-system don't cross filesystem boundaries

-B, –block-size=SIZE force a fixed checksum block-size

-e, –rsh=COMMAND specify the remote shell to use

–rsync-path=PROGRAM specify the rsync to run on remote machine

–existing skip creating new files on receiver

–ignore-existing skip updating files that exist on receiver

–remove-source-files sender removes synchronized files (non-dir)

–del an alias for –delete-during

–delete delete extraneous files from dest dirs

–delete-before receiver deletes before xfer, not during

–delete-during receiver deletes during the transfer

–delete-delay find deletions during, delete after

–delete-after receiver deletes after transfer, not during

–delete-excluded also delete excluded files from dest dirs

–ignore-missing-args ignore missing source args without error

–delete-missing-args delete missing source args from destination

–ignore-errors delete even if there are I/O errors

–force force deletion of dirs even if not empty

–max-delete=NUM don't delete more than NUM files

–max-size=SIZE don't transfer any file larger than SIZE

–min-size=SIZE don't transfer any file smaller than SIZE

–partial keep partially transferred files

–partial-dir=DIR put a partially transferred file into DIR

–delay-updates put all updated files into place at end

-m, –prune-empty-dirs prune empty directory chains from file-list

–numeric-ids don't map uid/gid values by user/group name

–usermap=STRING custom username mapping

–groupmap=STRING custom groupname mapping

–chown=USER:GROUP simple username/groupname mapping

–timeout=SECONDS set I/O timeout in seconds

–contimeout=SECONDS set daemon connection timeout in seconds

-I, –ignore-times don't skip files that match size and time

–size-only skip files that match in size

–modify-window=NUM compare mod-times with reduced accuracy

-T, –temp-dir=DIR create temporary files in directory DIR

-y, –fuzzy find similar file for basis if no dest file

–compare-dest=DIR also compare received files relative to DIR

–copy-dest=DIR … and include copies of unchanged files

–link-dest=DIR hardlink to files in DIR when unchanged

-z, –compress compress file data during the transfer

–compress-level=NUM explicitly set compression level

–skip-compress=LIST skip compressing files with suffix in LIST

-C, –cvs-exclude auto-ignore files in the same way CVS does

-f, –filter=RULE add a file-filtering RULE

-F same as –filter='dir-merge /.rsync-filter'

repeated: –filter='- .rsync-filter'

–exclude=PATTERN exclude files matching PATTERN

–exclude-from=FILE read exclude patterns from FILE

–include=PATTERN don't exclude files matching PATTERN

–include-from=FILE read include patterns from FILE

–files-from=FILE read list of source-file names from FILE

-0, –from0 all *from/filter files are delimited by 0s

-s, –protect-args no space-splitting; wildcard chars only

–address=ADDRESS bind address for outgoing socket to daemon

–port=PORT specify double-colon alternate port number

–sockopts=OPTIONS specify custom TCP options

–blocking-io use blocking I/O for the remote shell

–outbuf=N|L|B set out buffering to None, Line, or Block

–stats give some file-transfer stats

-8, –8-bit-output leave high-bit chars unescaped in output

-h, –human-readable output numbers in a human-readable format

–progress show progress during transfer

-P same as –partial –progress

-i, –itemize-changes output a change-summary for all updates

-M, –remote-option=OPTION send OPTION to the remote side only

–out-format=FORMAT output updates using the specified FORMAT

–log-file=FILE log what we're doing to the specified FILE

–log-file-format=FMT log updates using the specified FMT

–password-file=FILE read daemon-access password from FILE

–list-only list the files instead of copying them

–bwlimit=RATE limit socket I/O bandwidth

–write-batch=FILE write a batched update to FILE

–only-write-batch=FILE like –write-batch but w/o updating dest

–read-batch=FILE read a batched update from FILE

–protocol=NUM force an older protocol version to be used

–iconv=CONVERT_SPEC request charset conversion of filenames

–checksum-seed=NUM set block/file checksum seed (advanced)

-4, –ipv4 prefer IPv4

-6, –ipv6 prefer IPv6

–version print version number

(-h) –help show this help (see below for -h comment)