This is tar.info, produced by makeinfo version 4.6 from tar.texi.

START-INFO-DIR-ENTRY
* tar: (tar).			Making tape (or disk) archives.
END-INFO-DIR-ENTRY

   This file documents GNU `tar', a utility used to store, backup, and
transport files.

   Copyright (C) 1992, 1994, 1995, 1996, 1997, 1999 Free Software
Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.

   This file documents GNU `tar', which is a utility used to store,
backup, and transport files.  `tar' is a tape (or disk) archiver.  This
manual documents the release 1.13.


File: tar.info,  Node: Blocking Factor,  Prev: Format Variations,  Up: Blocking

The Blocking Factor of an Archive
---------------------------------

     _(This message will disappear, once this node revised.)_

The data in an archive is grouped into blocks, which are 512 bytes.
Blocks are read and written in whole number multiples called "records".
The number of blocks in a record (ie. the size of a record in units of
512 bytes) is called the "blocking factor".  The
`--blocking-factor=512-SIZE' (`-b 512-SIZE') option specifies the
blocking factor of an archive.  The default blocking factor is
typically 20 (ie.  10240 bytes), but can be specified at installation.
To find out the blocking factor of an existing archive, use `tar --list
--file=ARCHIVE-NAME'.  This may not work on some devices.

   Records are separated by gaps, which waste space on the archive
media.  If you are archiving on magnetic tape, using a larger blocking
factor (and therefore larger records) provides faster throughput and
allows you to fit more data on a tape (because there are fewer gaps).
If you are archiving on cartridge, a very large blocking factor (say
126 or more) greatly increases performance. A smaller blocking factor,
on the other hand, may be usefull when archiving small files, to avoid
archiving lots of nulls as `tar' fills out the archive to the end of
the record.  In general, the ideal record size depends on the size of
the inter-record gaps on the tape you are using, and the average size
of the files you are archiving.  *Note create::, for information on
writing archives.

   Archives with blocking factors larger than 20 cannot be read by very
old versions of `tar', or by some newer versions of `tar' running on
old machines with small address spaces.  With GNU `tar', the blocking
factor of an archive is limited only by the maximum record size of the
device containing the archive, or by the amount of available virtual
memory.

   Also, on some systems, not using adequate blocking factors, as
sometimes imposed by the device drivers, may yield unexpected
diagnostics.  For example, this has been reported:

     Cannot write to /dev/dlt: Invalid argument

In such cases, it sometimes happen that the `tar' bundled by the system
is aware of block size idiosyncrasies, while GNU `tar' requires an
explicit specification for the block size, which it cannot guess.  This
yields some people to consider GNU `tar' is misbehaving, because by
comparison, `the bundle `tar' works OK'.  Adding `-b 256', for example,
might resolve the problem.

   If you use a non-default blocking factor when you create an archive,
you must specify the same blocking factor when you modify that archive.
Some archive devices will also require you to specify the blocking
factor when reading that archive, however this is not typically the
case.  Usually, you can use `--list' (`-t') without specifying a
blocking factor--`tar' reports a non-default record size and then lists
the archive members as it would normally.  To extract files from an
archive with a non-standard blocking factor (particularly if you're not
sure what the blocking factor is), you can usually use the
`--read-full-records' (`-B') option while specifying a blocking factor
larger then the blocking factor of the archive (ie. `tar --extract
--read-full-records --blocking-factor=300'.  *Note list::, for more
information on the `--list' (`-t') operation.  *Note Reading::, for a
more detailed explanation of that option.

`--blocking-factor=NUMBER'
`-b NUMBER'
     Specifies the blocking factor of an archive.  Can be used with any
     operation, but is usually not necessary with `--list' (`-t').

   Device blocking

`-b BLOCKS'
`--blocking-factor=BLOCKS'
     Set record size to BLOCKS * 512 bytes.

     This option is used to specify a "blocking factor" for the archive.
     When reading or writing the archive, `tar', will do reads and
     writes of the archive in records of BLOCK*512 bytes.  This is true
     even when the archive is compressed.  Some devices requires that
     all write operations be a multiple of a certain size, and so, `tar'
     pads the archive out to the next record boundary.

     The default blocking factor is set when `tar' is compiled, and is
     typically 20.  Blocking factors larger than 20 cannot be read by
     very old versions of `tar', or by some newer versions of `tar'
     running on old machines with small address spaces.

     With a magnetic tape, larger records give faster throughput and fit
     more data on a tape (because there are fewer inter-record gaps).
     If the archive is in a disk file or a pipe, you may want to specify
     a smaller blocking factor, since a large one will result in a large
     number of null bytes at the end of the archive.

     When writing cartridge or other streaming tapes, a much larger
     blocking factor (say 126 or more) will greatly increase
     performance.  However, you must specify the same blocking factor
     when reading or updating the archive.

     Apparently, Exabyte drives have a physical block size of 8K bytes.
     If we choose our blocksize as a multiple of 8k bytes, then the
     problem seems to dissapper.  Id est, we are using block size of
     112 right now, and we haven't had the problem since we switched...

     With GNU `tar' the blocking factor is limited only by the maximum
     record size of the device containing the archive, or by the amount
     of available virtual memory.

     However, deblocking or reblocking is virtually avoided in a special
     case which often occurs in practice, but which requires all the
     following conditions to be simultaneously true:
        * the archive is subject to a compression option,

        * the archive is not handled through standard input or output,
          nor redirected nor piped,

        * the archive is directly handled to a local disk, instead of
          any special device,

        * `--blocking-factor=512-SIZE' (`-b 512-SIZE') is not
          explicitely specified on the `tar' invocation.

     In previous versions of GNU `tar', the `--compress-block' option
     (or even older: `--block-compress') was necessary to reblock
     compressed archives.  It is now a dummy option just asking not to
     be used, and otherwise ignored.  If the output goes directly to a
     local disk, and not through stdout, then the last write is not
     extended to a full record size.  Otherwise, reblocking occurs.
     Here are a few other remarks on this topic:

        * `gzip' will complain about trailing garbage if asked to
          uncompress a compressed archive on tape, there is an option
          to turn the message off, but it breaks the regularity of
          simply having to use `PROG -d' for decompression.  It would
          be nice if gzip was silently ignoring any number of trailing
          zeros.  I'll ask Jean-loup Gailly, by sending a copy of this
          message to him.

        * `compress' does not show this problem, but as Jean-loup
          pointed out to Michael, `compress -d' silently adds garbage
          after the result of decompression, which tar ignores because
          it already recognized its end-of-file indicator.  So this bug
          may be safely ignored.

        * `gzip -d -q' will be silent about the trailing zeros indeed,
          but will still return an exit status of 2 which tar reports
          in turn.  `tar' might ignore the exit status returned, but I
          hate doing that, as it weakens the protection `tar' offers
          users against other possible problems at decompression time.
          If `gzip' was silently skipping trailing zeros _and_ also
          avoiding setting the exit status in this innocuous case, that
          would solve this situation.

        * `tar' should become more solid at not stopping to read a pipe
          at the first null block encountered.  This inelegantly breaks
          the pipe.  `tar' should rather drain the pipe out before
          exiting itself.

`-i'
`--ignore-zeros'
     Ignore blocks of zeros in archive (means EOF).

     The `--ignore-zeros' (`-i') option causes `tar' to ignore blocks
     of zeros in the archive.  Normally a block of zeros indicates the
     end of the archive, but when reading a damaged archive, or one
     which was created by `cat'-ing several archives together, this
     option allows `tar' to read the entire archive.  This option is
     not on by default because many versions of `tar' write garbage
     after the zeroed blocks.

     Note that this option causes `tar' to read to the end of the
     archive file, which may sometimes avoid problems when multiple
     files are stored on a single physical tape.

`-B'
`--read-full-records'
     Reblock as we read (for reading 4.2BSD pipes).

     If `--read-full-records' (`-B') is used, `tar' will not panic if an
     attempt to read a record from the archive does not return a full
     record.  Instead, `tar' will keep reading until it has obtained a
     full record.

     This option is turned on by default when `tar' is reading an
     archive from standard input, or from a remote machine.  This is
     because on BSD Unix systems, a read of a pipe will return however
     much happens to be in the pipe, even if it is less than `tar'
     requested.  If this option was not used, `tar' would fail as soon
     as it read an incomplete record from the pipe.

     This option is also useful with the commands for updating an
     archive.


   Tape blocking

   When handling various tapes or cartridges, you have to take care of
selecting a proper blocking, that is, the number of disk blocks you put
together as a single tape block on the tape, without intervening tape
gaps.  A "tape gap" is a small landing area on the tape with no
information on it, used for decelerating the tape to a full stop, and
for later regaining the reading or writing speed.  When the tape driver
starts reading a record, the record has to be read whole without
stopping, as a tape gap is needed to stop the tape motion without
loosing information.

   Using higher blocking (putting more disk blocks per tape block) will
use the tape more efficiently as there will be less tape gaps.  But
reading such tapes may be more difficult for the system, as more memory
will be required to receive at once the whole record.  Further, if
there is a reading error on a huge record, this is less likely that the
system will succeed in recovering the information.  So, blocking should
not be too low, nor it should be too high.  `tar' uses by default a
blocking of 20 for historical reasons, and it does not really matter
when reading or writing to disk.  Current tape technology would easily
accomodate higher blockings.  Sun recommends a blocking of 126 for
Exabytes and 96 for DATs.  We were told that for some DLT drives, the
blocking should be a multiple of 4Kb, preferably 64Kb (`-b 128') or 256
for decent performance.  Other manufacturers may use different
recommendations for the same tapes.  This might also depends of the
buffering techniques used inside modern tape controllers.  Some imposes
a minimum blocking, or a maximum blocking.  Others request blocking to
be some exponent of two.

   So, there is no fixed rule for blocking.  But blocking at read time
should ideally be the same as blocking used at write time.  At one place
I know, with a wide variety of equipment, they found it best to use a
blocking of 32 to guarantee that their tapes are fully interchangeable.

   I was also told that, for recycled tapes, prior erasure (by the same
drive unit that will be used to create the archives) sometimes lowers
the error rates observed at rewriting time.

   I might also use `--number-blocks' instead of `--block-number', so
`--block' will then expand to `--blocking-factor' unambiguously.


File: tar.info,  Node: Many,  Next: Using Multiple Tapes,  Prev: Blocking,  Up: Media

Many Archives on One Tape
=========================

Most tape devices have two entries in the `/dev' directory, or entries
that come in pairs, which differ only in the minor number for this
device.  Let's take for example `/dev/tape', which often points to the
only or usual tape device of a given system.  There might be a
corresponding `/dev/nrtape' or `/dev/ntape'.  The simpler name is the
_rewinding_ version of the device, while the name having `nr' in it is
the _no rewinding_ version of the same device.

   A rewinding tape device will bring back the tape to its beginning
point automatically when this device is opened or closed.  Since `tar'
opens the archive file before using it and closes it afterwards, this
means that a simple:

     $ tar cf /dev/tape DIRECTORY

will reposition the tape to its beginning both prior and after saving
DIRECTORY contents to it, thus erasing prior tape contents and making
it so that any subsequent write operation will destroy what has just
been saved.

   So, a rewinding device is normally meant to hold one and only one
file.  If you want to put more than one `tar' archive on a given tape,
you will need to avoid using the rewinding version of the tape device.
You will also have to pay special attention to tape positioning.
Errors in positionning may overwrite the valuable data already on your
tape.  Many people, burnt by past experiences, will only use rewinding
devices and limit themselves to one file per tape, precisely to avoid
the risk of such errors.  Be fully aware that writing at the wrong
position on a tape loses all information past this point and most
probably until the end of the tape, and this destroyed information
_cannot_ be recovered.

   To save DIRECTORY-1 as a first archive at the beginning of a tape,
and leave that tape ready for a second archive, you should use:

     $ mt -f /dev/nrtape rewind
     $ tar cf /dev/nrtape DIRECTORY-1

   "Tape marks" are special magnetic patterns written on the tape
media, which are later recognizable by the reading hardware.  These
marks are used after each file, when there are many on a single tape.
An empty file (that is to say, two tape marks in a row) signal the
logical end of the tape, after which no file exist.  Usually,
non-rewinding tape device drivers will react to the close request issued
by `tar' by first writing two tape marks after your archive, and by
backspacing over one of these.  So, if you remove the tape at that time
from the tape drive, it is properly terminated.  But if you write
another file at the current position, the second tape mark will be
erased by the new information, leaving only one tape mark between files.

   So, you may now save DIRECTORY-2 as a second archive after the first
on the same tape by issuing the command:

     $ tar cf /dev/nrtape DIRECTORY-2

and so on for all the archives you want to put on the same tape.

   Another usual case is that you do not write all the archives the same
day, and you need to remove and store the tape between two archive
sessions.  In general, you must remember how many files are already
saved on your tape.  Suppose your tape already has 16 files on it, and
that you are ready to write the 17th.  You have to take care of skipping
the first 16 tape marks before saving DIRECTORY-17, say, by using these
commands:

     $ mt -f /dev/nrtape rewind
     $ mt -f /dev/nrtape fsf 16
     $ tar cf /dev/nrtape DIRECTORY-17

   In all the previous examples, we put aside blocking considerations,
but you should do the proper things for that as well.  *Note Blocking::.

* Menu:

* Tape Positioning::            Tape Positions and Tape Marks
* mt::                          The `mt' Utility


File: tar.info,  Node: Tape Positioning,  Next: mt,  Prev: Many,  Up: Many

Tape Positions and Tape Marks
-----------------------------

     _(This message will disappear, once this node revised.)_

Just as archives can store more than one file from the file system,
tapes can store more than one archive file.  To keep track of where
archive files (or any other type of file stored on tape) begin and end,
tape archive devices write magnetic "tape marks" on the archive media.
Tape drives write one tape mark between files, two at the end of all
the file entries.

   If you think of data as a series of records "rrrr"'s, and tape marks
as "*"'s, a tape might look like the following:

     rrrr*rrrrrr*rrrrr*rr*rrrrr**-------------------------

   Tape devices read and write tapes using a read/write "tape head"--a
physical part of the device which can only access one point on the tape
at a time.  When you use `tar' to read or write archive data from a
tape device, the device will begin reading or writing from wherever on
the tape the tape head happens to be, regardless of which archive or
what part of the archive the tape head is on.  Before writing an
archive, you should make sure that no data on the tape will be
overwritten (unless it is no longer needed).  Before reading an
archive, you should make sure the tape head is at the beginning of the
archive you want to read.  (The `restore' script will find the archive
automatically.  .  ).  *Note mt::, for an explanation of the tape
moving utility.

   If you want to add new archive file entries to a tape, you should
advance the tape to the end of the existing file entries, backspace
over the last tape mark, and write the new archive file.  If you were
to add two archives to the example above, the tape might look like the
following:

     rrrr*rrrrrr*rrrrr*rr*rrrrr*rrr*rrrr**----------------


File: tar.info,  Node: mt,  Prev: Tape Positioning,  Up: Many

The `mt' Utility
----------------

     _(This message will disappear, once this node revised.)_

*Note Blocking Factor::.

   You can use the `mt' utility to advance or rewind a tape past a
specified number of archive files on the tape.  This will allow you to
move to the beginning of an archive before extracting or reading it, or
to the end of all the archives before writing a new one.

   The syntax of the `mt' command is:

     mt [-f TAPENAME] OPERATION [NUMBER]

   where TAPENAME is the name of the tape device, NUMBER is the number
of times an operation is performed (with a default of one), and
OPERATION is one of the following:

`eof'
`weof'
     Writes NUMBER tape marks at the current position on the tape.

`fsf'
     Moves tape position forward NUMBER files.

`bsf'
     Moves tape position back NUMBER files.

`rewind'
     Rewinds the tape. (Ignores NUMBER).

`offline'
`rewoff1'
     Rewinds the tape and takes the tape device off-line. (Ignores
     NUMBER).

`status'
     Prints status information about the tape unit.


   If you don't specify a TAPENAME, `mt' uses the environment variable
TAPE; if TAPE does not exist, `mt' uses the device `/dev/rmt12'.

   `mt' returns a 0 exit status when the operation(s) were successful,
1 if the command was unrecognized, and 2 if an operation failed.

   If you use `--extract' (`--get', `-x') with the
`--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') option specified, `tar'
will read an archive label (the tape head has to be positioned on it)
and print an error if the archive label doesn't match the ARCHIVE-NAME
specified.  ARCHIVE-NAME can be any regular expression.  If the labels
match, `tar' extracts the archive.  *Note label::.  .   `tar --list
--label' will cause `tar' to print the label.


File: tar.info,  Node: Using Multiple Tapes,  Next: label,  Prev: Many,  Up: Media

Using Multiple Tapes
====================

     _(This message will disappear, once this node revised.)_

Often you might want to write a large archive, one larger than will fit
on the actual tape you are using.  In such a case, you can run multiple
`tar' commands, but this can be inconvenient, particularly if you are
using options like `--exclude=PATTERN' or dumping entire filesystems.
Therefore, `tar' supports multiple tapes automatically.

   Use `--multi-volume' (`-M') on the command line, and then `tar' will,
when it reaches the end of the tape, prompt for another tape, and
continue the archive.  Each tape will have an independent archive, and
can be read without needing the other.  (As an exception to this, the
file that `tar' was archiving when it ran out of tape will usually be
split between the two archives; in this case you need to extract from
the first archive, using `--multi-volume' (`-M'), and then put in the
second tape when prompted, so `tar' can restore both halves of the
file.)

   GNU `tar' multi-volume archives do not use a truly portable format.
You need GNU `tar' at both end to process them properly.

   When prompting for a new tape, `tar' accepts any of the following
responses:

`?'
     Request `tar' to explain possible responses

`q'
     Request `tar' to exit immediately.

`n FILE NAME'
     Request `tar' to write the next volume on the file FILE NAME.

`!'
     Request `tar' to run a subshell.

`y'
     Request `tar' to begin writing the next volume.

   (You should only type `y' after you have changed the tape; otherwise
`tar' will write over the volume it just finished.)

   If you want more elaborate behavior than this, give `tar' the
`--info-script=SCRIPT-NAME' (`--new-volume-script=SCRIPT-NAME', `-F
SCRIPT-NAME') option.  The file SCRIPT-NAME is expected to be a program
(or shell script) to be run instead of the normal prompting procedure.
When the program finishes, `tar' will immediately begin writing the
next volume.  The behavior of the `n' response to the normal
tape-change prompt is not available if you use
`--info-script=SCRIPT-NAME' (`--new-volume-script=SCRIPT-NAME', `-F
SCRIPT-NAME').

   The method `tar' uses to detect end of tape is not perfect, and
fails on some operating systems or on some devices.  You can use the
`--tape-length=1024-SIZE' (`-L 1024-SIZE') option if `tar' can't detect
the end of the tape itself.  This option selects `--multi-volume'
(`-M') automatically.  The SIZE argument should then be the usable size
of the tape.  But for many devices, and floppy disks in particular,
this option is never required for real, as far as we know.

   The volume number used by `tar' in its tape-change prompt can be
changed; if you give the `--volno-file=FILE-OF-NUMBER' option, then
FILE-OF-NUMBER should be an unexisting file to be created, or else, a
file already containing a decimal number.  That number will be used as
the volume number of the first volume written.  When `tar' is finished,
it will rewrite the file with the now-current volume number.  (This
does not change the volume number written on a tape label, as per
*Note label::, it _only_ affects the number used in the prompt.)

   If you want `tar' to cycle through a series of tape drives, then you
can use the `n' response to the tape-change prompt.  This is error
prone, however, and doesn't work at all with
`--info-script=SCRIPT-NAME' (`--new-volume-script=SCRIPT-NAME', `-F
SCRIPT-NAME').  Therefore, if you give `tar' multiple
`--file=ARCHIVE-NAME' (`-f ARCHIVE-NAME') options, then the specified
files will be used, in sequence, as the successive volumes of the
archive.  Only when the first one in the sequence needs to be used
again will `tar' prompt for a tape change (or run the info script).

   Multi-volume archives

   With `--multi-volume' (`-M'), `tar' will not abort when it cannot
read or write any more data.  Instead, it will ask you to prepare a new
volume.  If the archive is on a magnetic tape, you should change tapes
now; if the archive is on a floppy disk, you should change disks, etc.

   Each volume of a multi-volume archive is an independent `tar'
archive, complete in itself.  For example, you can list or extract any
volume alone; just don't specify `--multi-volume' (`-M').  However, if
one file in the archive is split across volumes, the only way to extract
it successfully is with a multi-volume extract command `--extract
--multi-volume' (`-xM') starting on or before the volume where the file
begins.

   For example, let's presume someone has two tape drives on a system
named `/dev/tape0' and `/dev/tape1'.  For having GNU `tar' to switch to
the second drive when it needs to write the second tape, and then back
to the first tape, etc., just do either of:

     $ tar --create --multi-volume --file=/dev/tape0 --file=/dev/tape1 FILES
     $ tar cMff /dev/tape0 /dev/tape1 FILES

* Menu:

* Multi-Volume Archives::       Archives Longer than One Tape or Disk
* Tape Files::                  Tape Files


File: tar.info,  Node: Multi-Volume Archives,  Next: Tape Files,  Prev: Using Multiple Tapes,  Up: Using Multiple Tapes

Archives Longer than One Tape or Disk
-------------------------------------

     _(This message will disappear, once this node revised.)_

To create an archive that is larger than will fit on a single unit of
the media, use the `--multi-volume' (`-M') option in conjunction with
the `--create' (`-c') option (*note create::).  A "multi-volume"
archive can be manipulated like any other archive (provided the
`--multi-volume' (`-M') option is specified), but is stored on more
than one tape or disk.

   When you specify `--multi-volume' (`-M'), `tar' does not report an
error when it comes to the end of an archive volume (when reading), or
the end of the media (when writing).  Instead, it prompts you to load a
new storage volume.  If the archive is on a magnetic tape, you should
change tapes when you see the prompt; if the archive is on a floppy
disk, you should change disks; etc.

   You can read each individual volume of a multi-volume archive as if
it were an archive by itself.  For example, to list the contents of one
volume, use `--list' (`-t'), without `--multi-volume' (`-M') specified.
To extract an archive member from one volume (assuming it is described
that volume), use `--extract' (`--get', `-x'), again without
`--multi-volume' (`-M').

   If an archive member is split across volumes (ie. its entry begins on
one volume of the media and ends on another), you need to specify
`--multi-volume' (`-M') to extract it successfully.  In this case, you
should load the volume where the archive member starts, and use `tar
--extract --multi-volume'--`tar' will prompt for later volumes as it
needs them.  *Note extracting archives::, for more information about
extracting archives.

   `--info-script=SCRIPT-NAME' (`--new-volume-script=SCRIPT-NAME', `-F
SCRIPT-NAME') is like `--multi-volume' (`-M'), except that `tar' does
not prompt you directly to change media volumes when a volume is
full--instead, `tar' runs commands you have stored in SCRIPT-NAME.  For
example, this option can be used to eject cassettes, or to broadcast
messages such as `Someone please come change my tape' when performing
unattended backups.  When SCRIPT-NAME is done, `tar' will assume that
the media has been changed.

   Multi-volume archives can be modified like any other archive.  To add
files to a multi-volume archive, you need to only mount the last volume
of the archive media (and new volumes, if needed).  For all other
operations, you need to use the entire archive.

   If a multi-volume archive was labeled using `--label=ARCHIVE-LABEL'
(`-V ARCHIVE-LABEL') (*note label::) when it was created, `tar' will not
automatically label volumes which are added later.  To label subsequent
volumes, specify `--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') again in
conjunction with the `--append' (`-r'), `--update' (`-u') or
`--concatenate' (`--catenate', `-A') operation.

`--multi-volume'
`-M'
     Creates a multi-volume archive, when used in conjunction with
     `--create' (`-c').  To perform any other operation on a
     multi-volume archive, specify `--multi-volume' (`-M') in
     conjunction with that operation.

`--info-script=PROGRAM-FILE'
`-F PROGRAM-FILE'
     Creates a multi-volume archive via a script.  Used in conjunction
     with `--create' (`-c').

   Beware that there is _no_ real standard about the proper way, for a
`tar' archive, to span volume boundaries.  If you have a multi-volume
created by some vendor's `tar', there is almost no chance you could
read all the volumes with GNU `tar'.  The converse is also true: you
may not expect multi-volume archives created by GNU `tar' to be fully
recovered by vendor's `tar'.  Since there is little chance that, in
mixed system configurations, some vendor's `tar' will work on another
vendor's machine, and there is a great chance that GNU `tar' will work
on most of them, your best bet is to install GNU `tar' on all machines
between which you know exchange of files is possible.


File: tar.info,  Node: Tape Files,  Prev: Multi-Volume Archives,  Up: Using Multiple Tapes

Tape Files
----------

     _(This message will disappear, once this node revised.)_

To give the archive a name which will be recorded in it, use the
`--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') option.  This will write a
special block identifying VOLUME-LABEL as the name of the archive to
the front of the archive which will be displayed when the archive is
listed with `--list' (`-t').  If you are creating a multi-volume
archive with `--multi-volume' (`-M') (), then the volume label will have
`Volume NNN' appended to the name you give, where NNN is the number of
the volume of the archive.  (If you use the `--label=ARCHIVE-LABEL'
(`-V ARCHIVE-LABEL') option when reading an archive, it checks to make
sure the label on the tape matches the one you give.  *Note label::.

   When `tar' writes an archive to tape, it creates a single tape file.
If multiple archives are written to the same tape, one after the
other, they each get written as separate tape files.  When extracting,
it is necessary to position the tape at the right place before running
`tar'.  To do this, use the `mt' command.  For more information on the
`mt' command and on the organization of tapes into a sequence of tape
files, see *Note mt::.

   People seem to often do:

     --label="SOME-PREFIX `date +SOME-FORMAT`"

   or such, for pushing a common date in all volumes or an archive set.


File: tar.info,  Node: label,  Next: verify,  Prev: Using Multiple Tapes,  Up: Media

Including a Label in the Archive
================================

     _(This message will disappear, once this node revised.)_

`-V NAME'
`--label=NAME'
     Create archive with volume name NAME.

   This option causes `tar' to write out a "volume header" at the
beginning of the archive.  If `--multi-volume' (`-M') is used, each
volume of the archive will have a volume header of `NAME Volume N',
where N is 1 for the first volume, 2 for the next, and so on.

   To avoid problems caused by misplaced paper labels on the archive
media, you can include a "label" entry--an archive member which
contains the name of the archive--in the archive itself.  Use the
`--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') option in conjunction with
the `--create' (`-c') operation to include a label entry in the archive
as it is being created.

   If you create an archive using both `--label=ARCHIVE-LABEL' (`-V
ARCHIVE-LABEL') and `--multi-volume' (`-M'), each volume of the archive
will have an archive label of the form `ARCHIVE-LABEL Volume N', where
N is 1 for the first volume, 2 for the next, and so on.  , for
information on creating multiple volume archives.

   If you list or extract an archive using `--label=ARCHIVE-LABEL' (`-V
ARCHIVE-LABEL'), `tar' will print an error if the archive label doesn't
match the ARCHIVE-LABEL specified, and will then not list nor extract
the archive.  In those cases, ARCHIVE-LABEL argument is interpreted as
a globbing-style pattern which must match the actual magnetic volume
label.  *Note exclude::, for a precise description of how match is
attempted(1).  If the switch `--multi-volume' (`-M') is being used, the
volume label matcher will also suffix ARCHIVE-LABEL by ` Volume [1-9]*'
if the initial match fails, before giving up.  Since the volume
numbering is automatically added in labels at creation time, it sounded
logical to equally help the user taking care of it when the archive is
being read.

   The `--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') was once called
`--volume', but is not available under that name anymore.

   To find out an archive's label entry (or to find out if an archive
has a label at all), use `tar --list --verbose'.  `tar' will print the
label first, and then print archive member information, as in the
example below:

     $ tar --verbose --list --file=iamanarchive
     V--------- 0 0        0 1992-03-07 12:01 iamalabel--Volume Header--
     -rw-rw-rw- ringo user 40 1990-05-21 13:30 iamafilename

`--label=ARCHIVE-LABEL'
`-V ARCHIVE-LABEL'
     Includes an "archive-label" at the beginning of the archive when
     the archive is being created, when used in conjunction with the
     `--create' (`-c') option.  Checks to make sure the archive label
     matches the one specified (when used in conjunction with the
     `--extract' (`--get', `-x') option.

   To get a common information on all tapes of a series, use the
`--label=ARCHIVE-LABEL' (`-V ARCHIVE-LABEL') option.  For having this
information different in each series created through a single script
used on a regular basis, just manage to get some date string as part of
the label.  For example:

     $ tar cfMV /dev/tape "Daily backup for `date +%Y-%m-%d`"
     $ tar --create --file=/dev/tape --multi-volume \
          --volume="Daily backup for `date +%Y-%m-%d`"

   Also note that each label has its own date and time, which
corresponds to when GNU `tar' initially attempted to write it, often
soon after the operator launches `tar' or types the carriage return
telling that the next tape is ready.  Comparing date labels does give
an idea of tape throughput only if the delays for rewinding tapes and
the operator switching them were negligible, which is ususally not the
case.

   ---------- Footnotes ----------

   (1) Previous versions of `tar' used full regular expression
matching, or before that, only exact string matching, instead of
wildcard matchers.  We decided for the sake of simplicity to use a
uniform matching device through `tar'.


File: tar.info,  Node: verify,  Next: Write Protection,  Prev: label,  Up: Media

Verifying Data as It is Stored
==============================

`-W'
`--verify'
     Attempt to verify the archive after writing.

   This option causes `tar' to verify the archive after writing it.
Each volume is checked after it is written, and any discrepancies are
recorded on the standard error output.

   Verification requires that the archive be on a back-space-able
medium.  This means pipes, some cartridge tape drives, and some other
devices cannot be verified.

   You can insure the accuracy of an archive by comparing files in the
system with archive members.  `tar' can compare an archive to the file
system as the archive is being written, to verify a write operation, or
can compare a previously written archive, to insure that it is up to
date.

   To check for discrepancies in an archive immediately after it is
written, use the `--verify' (`-W') option in conjunction with the
`--create' (`-c') operation.  When this option is specified, `tar'
checks archive members against their counterparts in the file system,
and reports discrepancies on the standard error.  In multi-volume
archives, each volume is verified after it is written, before the next
volume is written.

   To verify an archive, you must be able to read it from before the end
of the last written entry.  This option is useful for detecting data
errors on some tapes.  Archives written to pipes, some cartridge tape
drives, and some other devices cannot be verified.

   One can explicitely compare an already made archive with the file
system by using the `--compare' (`--diff', `-d') option, instead of
using the more automatic `--verify' (`-W') option.  *Note compare::.

   Note that these two options have a slightly different intent.  The
`--compare' (`--diff', `-d') option how identical are the logical
contents of some archive with what is on your disks, while the
`--verify' (`-W') option is really for checking if the physical
contents agree and if the recording media itself is of dependable
quality.  So, for the `--verify' (`-W') operation, `tar' tries to
defeat all in-memory cache pertaining to the archive, while it lets the
speed optimization undisturbed for the `--compare' (`--diff', `-d')
option.  If you nevertheless use `--compare' (`--diff', `-d') for media
verification, you may have to defeat the in-memory cache yourself,
maybe by opening and reclosing the door latch of your recording unit,
forcing some doubt in your operating system about the fact this is
really the same volume as the one just written or read.

   The `--verify' (`-W') option would not be necessary if drivers were
indeed able to detect dependably all write failures.  This sometimes
require many magnetic heads, some able to read after the writes
occurred.  One would not say that drivers unable to detect all cases
are necessarily flawed, as long as programming is concerned.


File: tar.info,  Node: Write Protection,  Prev: verify,  Up: Media

Write Protection
================

Almost all tapes and diskettes, and in a few rare cases, even disks can
be "write protected", to protect data on them from being changed.  Once
an archive is written, you should write protect the media to prevent
the archive from being accidently overwritten or deleted.  (This will
protect the archive from being changed with a tape or floppy drive--it
will not protect it from magnet fields or other physical hazards).

   The write protection device itself is usually an integral part of the
physical media, and can be a two position (write enabled/write
disabled) switch, a notch which can be popped out or covered, a ring
which can be removed from the center of a tape reel, or some other
changeable feature.


File: tar.info,  Node: Index,  Prev: Media,  Up: Top

Index
*****

* Menu:

* --list with file name arguments:       list.
* -backup:                               backup.
* -suffix:                               backup.
* -version-control:                      backup.
* abbreviations for months:              Calendar date item.
* absolute file names:                   Remote Tape Server.
* Adding archives to an archive:         concatenate.
* Adding files to an Archive:            appending files.
* Age, excluding files by:               after.
* ago in date strings:                   Relative item in date strings.
* Alaska-Hawaii Time:                    Timezone item.
* am in date strings:                    Time of day item.
* Appending files to an Archive:         appending files.
* archive:                               Definitions.
* Archive creation:                      file.
* archive member:                        Definitions.
* Archive Name:                          file.
* Archives, Appending files to:          appending files.
* Archiving Directories:                 create dir.
* Atlantic Standard Time:                Timezone item.
* authors of getdate:                    Authors of getdate.
* Avoiding recursion in directories:     recurse.
* Azores Time:                           Timezone item.
* backup files, type made:               backup.
* backup options:                        backup.
* backup suffix:                         backup.
* backups, making:                       backup.
* Baghdad Time:                          Timezone item.
* beginning of time, for Unix:           Date input formats.
* Bellovin, Steven M.:                   Authors of getdate.
* Berets, Jim:                           Authors of getdate.
* Berry, K.:                             Authors of getdate.
* Block number where error occured:      verbose.
* blocking factor:                       Blocking Factor.
* Blocking Factor:                       Blocking Factor.
* Blocks per record:                     Blocking Factor.
* bug reports:                           Reports.
* Bytes per record:                      Blocking Factor.
* calendar date item:                    Calendar date item.
* case, ignored in dates:                General date syntax.
* cat vs concatenate:                    concatenate.
* Central Alaska Time:                   Timezone item.
* Central European Time:                 Timezone item.
* Central Standard Time:                 Timezone item.
* Changing directory mid-stream:         directory.
* Character class, excluding characters from: Wildcards.
* China Coast Time:                      Timezone item.
* Choosing an archive file:              file.
* comments, in dates:                    General date syntax.
* Compressed archives:                   gzip.
* concatenate vs cat:                    concatenate.
* Concatenating Archives:                concatenate.
* corrupted archives <1>:                gzip.
* corrupted archives:                    Full Dumps.
* DAT blocking:                          Blocking Factor.
* date format, ISO 8601:                 Calendar date item.
* date input formats:                    Date input formats.
* day in date strings:                   Relative item in date strings.
* day of week item:                      Day of week item.
* daylight savings time:                 Timezone item.
* Deleting files from an archive:        delete.
* Deleting from tape archives:           delete.
* Descending directories, avoiding:      recurse.
* Directing output:                      file.
* Directories, Archiving:                create dir.
* Directories, avoiding recursion:       recurse.
* Directory, changing mid-stream:        directory.
* Disk space, running out of:            Scarce.
* displacement of dates:                 Relative item in date strings.
* Double-checking a write operation:     verify.
* dumps, full:                           Full Dumps.
* dumps, incremental:                    Inc Dumps.
* East Australian Standard Time:         Timezone item.
* Eastern European Time:                 Timezone item.
* Eastern Standard Time:                 Timezone item.
* End-of-archive entries, ignoring:      Reading.
* entry:                                 Naming tar Archives.
* epoch, for Unix:                       Date input formats.
* Error message, block number of:        verbose.
* Exabyte blocking:                      Blocking Factor.
* exclude:                               exclude.
* exclude-from:                          exclude.
* Excluding characters from a character class: Wildcards.
* Excluding file by age:                 after.
* Excluding files by file system:        exclude.
* Excluding files by name and pattern:   exclude.
* existing backup method:                backup.
* exit status:                           Synopsis.
* Extraction:                            extract.
* extraction:                            Definitions.
* Feedback from tar:                     verbose.
* file name:                             Definitions.
* File Name arguments, alternatives:     files.
* File name arguments, using --list with: list.
* File names, excluding files by:        exclude.
* File names, terminated by NUL:         nul.
* File names, using symbolic links:      dereference.
* File system boundaries, not crossing:  one.
* first in date strings:                 General date syntax.
* Format Options:                        Format Variations.
* Format Parameters:                     Format Variations.
* Format, old style:                     old.
* fortnight in date strings:             Relative item in date strings.
* French Winter Time:                    Timezone item.
* full dumps:                            Full Dumps.
* general date syntax:                   General date syntax.
* getdate:                               Date input formats.
* Getting more information during the operation: verbose.
* Greenwich Mean Time:                   Timezone item.
* Guam Standard Time:                    Timezone item.
* Hawaii Standard Time:                  Timezone item.
* hour in date strings:                  Relative item in date strings.
* Ignoring end-of-archive entries:       Reading.
* incremental dumps:                     Inc Dumps.
* Information during operation:          verbose.
* Information on progress and status of operations: verbose.
* Interactive operation:                 interactive.
* International Date Line East:          Timezone item.
* International Date Line West:          Timezone item.
* ISO 8601 date format:                  Calendar date item.
* items in date strings:                 General date syntax.
* Japan Standard Time:                   Timezone item.
* Labeling an archive:                   label.
* Labelling multi-volume archives:       Multi-Volume Archives.
* Labels on the archive media:           label.
* Large lists of file names on small machines: Reading.
* last DAY:                              Day of week item.
* last in date strings:                  General date syntax.
* Lists of file names:                   files.
* MacKenzie, David:                      Authors of getdate.
* member:                                Definitions.
* member name:                           Definitions.
* Members, replacing with other members: append.
* Meyering, Jim:                         Authors of getdate.
* Middle European Time:                  Timezone item.
* Middle European Winter Time:           Timezone item.
* Middle of the archive, starting in the: Scarce.
* midnight in date strings:              Time of day item.
* minute in date strings:                Relative item in date strings.
* minutes, timezone correction by:       Time of day item.
* Modes of extracted files:              Writing.
* Modification time, excluding files by: after.
* Modification times of extracted files: Writing.
* month in date strings:                 Relative item in date strings.
* month names in date strings:           Calendar date item.
* months, written-out:                   General date syntax.
* Mountain Standard Time:                Timezone item.
* Multi-volume archives:                 Multi-Volume Archives.
* Naming an archive:                     file.
* New Zealand Standard Time:             Timezone item.
* next DAY:                              Day of week item.
* next in date strings:                  General date syntax.
* Nome Standard Time:                    Timezone item.
* noon in date strings:                  Time of day item.
* now in date strings:                   Relative item in date strings.
* ntape device:                          Many.
* NUL terminated file names:             nul.
* Number of blocks per record:           Blocking Factor.
* Number of bytes per record:            Blocking Factor.
* numbered backup method:                backup.
* numbers, written-out:                  General date syntax.
* Old style archives:                    old.
* Old style format:                      old.
* option syntax, traditional:            Old Options.
* Options when reading archives:         Reading.
* Options, archive format specifying:    Format Variations.
* Options, format specifying:            Format Variations.
* ordinal numbers:                       General date syntax.
* Overwriting old files, prevention:     Writing.
* Pacific Standard Time:                 Timezone item.
* Permissions of extracted files:        Writing.
* Pinard, F.:                            Authors of getdate.
* pm in date strings:                    Time of day item.
* Progress information:                  verbose.
* Protecting old files:                  Writing.
* pure numbers in date strings:          Pure numbers in date strings.
* Reading file names from a file:        files.
* Reading incomplete records:            Reading.
* Record Size:                           Blocking Factor.
* Records, incomplete:                   Reading.
* Recursion in directories, avoiding:    recurse.
* relative items in date strings:        Relative item in date strings.
* remote tape drive:                     Remote Tape Server.
* Removing files from an archive:        delete.
* Replacing members with other members:  append.
* reporting bugs:                        Reports.
* Resurrecting files from an archive:    extract.
* Retrieving files from an archive:      extract.
* return status:                         Synopsis.
* rmt:                                   Remote Tape Server.
* Running out of space:                  Reading.
* Running out of space during extraction: Scarce.
* Salz, Rich:                            Authors of getdate.
* simple backup method:                  backup.
* SIMPLE_BACKUP_SUFFIX:                  backup.
* Small memory:                          Reading.
* Space on the disk, recovering from lack of: Scarce.
* Sparse Files:                          sparse.
* Specifying archive members:            Selecting Archive Members.
* Specifying files to act on:            Selecting Archive Members.
* Standard input and output:             file.
* Standard output, writing extracted files to: Writing.
* Status information:                    verbose.
* Storing archives in compressed format: gzip.
* Swedish Winter Time:                   Timezone item.
* Symbolic link as file name:            dereference.
* tape blocking:                         Blocking Factor.
* tape marks:                            Many.
* tape positioning:                      Many.
* Tapes, using --delete and:             delete.
* tar:                                   What tar Does.
* tar archive:                           Definitions.
* tar entry:                             Naming tar Archives.
* tar file:                              Naming tar Archives.
* tar to standard input and output:      file.
* this in date strings:                  Relative item in date strings.
* time of day item:                      Time of day item.
* timezone correction:                   Time of day item.
* timezone item:                         Timezone item.
* today in date strings:                 Relative item in date strings.
* tomorrow in date strings:              Relative item in date strings.
* Ultrix 3.1 and write failure:          Remote Tape Server.
* Universal Coordinated Time:            Timezone item.
* unpacking:                             Definitions.
* Updating an archive:                   update.
* USSR Zone:                             Timezone item.
* uuencode:                              Applications.
* Verbose operation:                     verbose.
* Verifying a write operation:           verify.
* Verifying the currency of an archive:  compare.
* Version of the tar program:            verbose.
* version-control Emacs variable:        backup.
* VERSION_CONTROL:                       backup.
* week in date strings:                  Relative item in date strings.
* West African Time:                     Timezone item.
* West Australian Standard Time:         Timezone item.
* Western European Time:                 Timezone item.
* Where is the archive?:                 file.
* Working directory, specifying:         directory.
* Writing extracted files to standard output: Writing.
* Writing new archives:                  file.
* year in date strings:                  Relative item in date strings.
* yesterday in date strings:             Relative item in date strings.
* Yukon Standard Time:                   Timezone item.


