Geek Gadgets 1/ADE-1.bin/ade-dist/fileutils-3.13-bin.lha/info/fileutils.info-2

GNU Info File | 1996-10-12 | 41KB | 830 lines

This is Info file fileutils.info, produced by Makeinfo-1.64 from the
input file /ade-src/fsf/fileutils/doc/fileutils.texi.
START-INFO-DIR-ENTRY
* File utilities: (fileutils).  GNU file utilities.
* chgrp: (fileutils)chgrp invocation.           Change file groups.
* chown: (fileutils)chown invocation.           Change file owners/groups.
* chmod: (fileutils)chmod invocation.           Change file permissions.
* cp: (fileutils)cp invocation.                 Copy files.
* dd: (fileutils)dd invocation.                 Copy and convert a file.
* df: (fileutils)df invocation.                 Report filesystem disk usage.
* dir: (fileutils)dir invocation.               List directories briefly.
* dircolors: (fileutils)dircolors invocation.   Color setup for ls.
* du: (fileutils)du invocation.                 Report on disk usage.
* install: (fileutils)install invocation.       Copy and change attributes.
* ln: (fileutils)ln invocation.                 Make links between files.
* ls: (fileutils)ls invocation.                 List directory contents.
* mkdir: (fileutils)mkdir invocation.           Create directories.
* mkfifo: (fileutils)mkfifo invocation.         Create FIFOs: (named pipes).
* mknod: (fileutils)mknod invocation.           Create special files.
* mv: (fileutils)mv invocation.                 Rename files.
* rm: (fileutils)rm invocation.                 Remove files.
* rmdir: (fileutils)rmdir invocation.           Remove empty directories.
* sync: (fileutils)sync invocation.             Synchronize memory and disk.
* touch: (fileutils)touch invocation.           Change file timestamps.
* vdir: (fileutils)vdir invocation.             List directories verbosely.
END-INFO-DIR-ENTRY
   This file documents the GNU set of file utilities.
   Copyright (C) 1994, 95, 96 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.
File: fileutils.info,  Node: cp invocation,  Next: dd invocation,  Up: Basic operations
`cp': Copy files and directories
================================
   `cp' copies files (or, optionally, directories).  The copy is
completely independent of the original.  You can either copy one file to
another, or copy arbitrarily many files to a destination directory.
Synopsis:
     cp [OPTION]... SOURCE DEST
     cp [OPTION]... SOURCE... DIRECTORY
   If the last argument names an existing directory, `cp' copies each
SOURCE file into that directory (retaining the same name).  Otherwise,
if only two files are given, it copies the first onto the second.  It
is an error if the last argument is not a directory and more than two
non-option arguments are given.
   Generally, files are written just as they are read.  For exceptions,
see the `--sparse' option below.
   By default, `cp' does not copy directories (see `-r' below).
   `cp' generally refuses to copy a file onto itself, with the
following exception: if `--force --backup' is specified with SOURCE and
DEST identical, and referring to a regular file, `cp' will make a
backup file, either regular or numbered, as specified in the usual ways
(*note Backup options::.).  This is useful when you simply want to make
a backup of an existing file before changing it.
   The program accepts the following options.  Also see *Note Common
options::.
`--archive'
     Preserve as much as possible of the structure and attributes of the
     original files in the copy (but do not preserve directory
     structure).  Equivalent to `-dpR'.
`--backup'
     Make backups of files that are about to be overwritten or removed.
     *Note Backup options::.
`--no-dereference'
     Copy symbolic links as symbolic links rather than copying the
     files that they point to, and preserve hard links between source
     files in the copies.
`--force'
     Remove existing destination files.
`--interactive'
     Prompt whether to overwrite existing regular destination files.
`--link'
     Make hard links instead of copies of non-directories.
`--preserve'
     Preserve the original files' owner, group, permissions, and
     timestamps.
`--parents'
     Form the name of each destination file by appending to the target
     directory a slash and the specified name of the source file.  The
     last argument given to `cp' must be the name of an existing
     directory.  For example, the command:
          cp --parents a/b/c existing_dir
     copies the file `a/b/c' to `existing_dir/a/b/c', creating any
     missing intermediate directories.
     Copy directories recursively, copying any non-directories and
     non-symbolic links (that is, FIFOs and special files) as if they
     were regular files.  This means trying to read the data in each
     source file and writing it to the destination.  Thus, with this
     option, `cp' may well hang indefinitely reading a FIFO, unless
     something else happens to be writing it.
`--recursive'
     Copy directories recursively, preserving non-directories (see `-r'
     just above).
`--sparse=WHEN'
     A "sparse file" contains "holes"--a sequence of zero bytes that
     does not occupy any physical disk blocks; the `read' system call
     reads these as zeroes.  This can both save considerable disk space
     and increase speed, since many binary files contain lots of
     consecutive zero bytes.  By default, `cp' detects holes in input
     source files via a crude heuristic and makes the corresponding
     output file sparse as well.
     The WHEN value can be one of the following:
    `auto'
          The default behavior: the output file is sparse if the input
          file is sparse.
    `always'
          Always make the output file sparse.  This is useful when the
          input file resides on a filesystem that does not support
          sparse files (the most notable example is `efs' filesystems
          in SGI IRIX 5.3 and earlier), but the output file is on
          another type of filesystem.
    `never'
          Never make the output file sparse.  If you find an
          application for this option, let us know.
`--symbolic-link'
     Make symbolic links instead of copies of non-directories.  All
     source file names must be absolute (starting with `/') unless the
     destination files are in the current directory.  This option merely
     results in an error message on systems that do not support
     symbolic links.
`-S SUFFIX'
`--suffix=SUFFIX'
     Append SUFFIX to each backup file made with `-b'.  *Note Backup
     options::.
`--update'
     Do not copy a nondirectory that has an existing destination with
     the same or newer modification time.
`--verbose'
     Print the name of each file before copying it.
`-V METHOD'
`--version-control=METHOD'
     Change the type of backups made with `-b'.  The METHOD argument
     can be `numbered' (or `t'), `existing' (or `nil'), or `never' (or
     `simple').  *Note Backup options::.
`--one-file-system'
     Skip subdirectories that are on different filesystems from the one
     that the copy started on.
File: fileutils.info,  Node: dd invocation,  Next: install invocation,  Prev: cp invocation,  Up: Basic operations
`dd': Convert and copy a file
=============================
   `dd' copies a file (from standard input to standard output, by
default) with a changeable I/O blocksize, while optionally performing
conversions on it.  Synopsis:
     dd [OPTION]...
   The program accepts the following options.  Also see *Note Common
options::.
   The numeric-valued options below (BYTES and BLOCKS) can be followed
by a multiplier: `b'=512, `c'=1, `k'=1024, `w'=2, `xM'=M.
`if=FILE'
     Read from FILE instead of standard input.
`of=FILE'
     Write to FILE instead of standard output.  Unless `conv=notrunc'
     is given, `dd' truncates FILE to zero bytes (or the size specified
     with `seek=').
`ibs=BYTES'
     Read BYTES bytes at a time.
`obs=BYTES'
     Write BYTES bytes at a time.
`bs=BYTES'
     Both read and write BYTES bytes at a time.  This overrides `ibs'
     and `obs'.
`cbs=BYTES'
     Convert BYTES bytes at a time.
`skip=BLOCKS'
     Skip BLOCKS `ibs'-byte blocks in the input file before copying.
`seek=BLOCKS'
     Skip BLOCKS `obs'-byte blocks in the output file before copying.
`count=BLOCKS'
     Copy BLOCKS `obs'-byte blocks from the input file, instead of
     everything until the end of the file.
`conv=CONVERSION[,CONVERSION]...'
     Convert the file as specified by the CONVERSION argument(s).  (No
     spaces around any comma(s).)
     Conversions:
    `ascii'
          Convert EBCDIC to ASCII.
    `ebcdic'
          Convert ASCII to EBCDIC.
    `ibm'
          Convert ASCII to alternate EBCDIC.
    `block'
          For each line in the input, output `cbs' bytes, replacing the
          input newline with a space and padding with spaces as
          necessary.
    `unblock'
          Replace trailing spaces in each `cbs'-sized input block with a
          newline.
    `lcase'
          Change uppercase letters to lowercase.
    `ucase'
          Change lowercase letters to uppercase.
    `swab'
          Swap every pair of input bytes.  GNU `dd', unlike others,
          works when an odd number of bytes are read--the last byte is
          simply copied (since there is nothing to swap it with).
    `noerror'
          Continue after read errors.
    `notrunc'
          Do not truncate the output file.
    `sync'
          Pad every input block to size of `ibs' with trailing zero
          bytes.
File: fileutils.info,  Node: install invocation,  Next: mv invocation,  Prev: dd invocation,  Up: Basic operations
`install': Copy files and set attributes
========================================
   `install' copies files while setting their permission modes and, if
possible, their owner and group.  Synopses:
     install [OPTION]... SOURCE DEST
     install [OPTION]... SOURCE... DIRECTORY
     install -d [OPTION]... DIRECTORY...
   In the first of these, the SOURCE file is copied to the DEST target
file.  In the second, each of the SOURCE files are copied to the
destination DIRECTORY.  In the last, each DIRECTORY (and any missing
parent directories) is created.
   `install' is similar to `cp', but allows you to control the
attributes of destination files.  It is typically used in Makefiles to
copy programs into their destination directories.  It refuses to copy
files onto themselves.
   The program accepts the following options.  Also see *Note Common
options::.
`--backup'
     Make backups of files that are about to be overwritten or removed.
     *Note Backup options::.
     Ignored; for compatibility with old Unix versions of `install'.
`--directory'
     Create each given directory and any missing parent directories,
     setting the owner, group and mode as given on the command line or
     to the defaults.  It also gives any parent directories it creates
     those attributes.  (This is different from the SunOS 4.x
     `install', which gives directories that it creates the default
     attributes.)
`-g GROUP'
`--group=GROUP'
     Set the group ownership of installed files or directories to
     GROUP. The default is the process's current group.  GROUP may be
     either a group name or a numeric group id.
`-m MODE'
`--mode=MODE'
     Set the permissions for the installed file or directory to MODE,
     which can be either an octal number, or a symbolic mode as in
     `chmod', with 0 as the point of departure (*note File
     permissions::.).  The default mode is 0755--read, write, and
     execute for the owner, and read and execute for group and other.
`-o OWNER'
`--owner=OWNER'
     If `install' has appropriate privileges (is run as root), set the
     ownership of installed files or directories to OWNER. The default
     is `root'.  OWNER may be either a user name or a numeric user ID.
`-l LOGFILE'
`--log=LOGILE'
     Create a log file with name, size and date of all installed files.
     LOGFILE should be a path like /var/install-logs/fileutils-3.13.
`--strip'
     Strip the symbol tables from installed binary executables.
`-S SUFFIX'
`--suffix=SUFFIX'
     Append SUFFIX to each backup file made with `-b'.  *Note Backup
     options::.
`-V METHOD'
`--version-control=METHOD'
     Change the type of backups made with `-b'.  The METHOD argument
     can be `numbered' (or `t'), `existing' (or `nil'), or `never' (or
     `simple').  *Note Backup options::.
File: fileutils.info,  Node: mv invocation,  Next: rm invocation,  Prev: install invocation,  Up: Basic operations
`mv': Move (rename) files
=========================
   `mv' moves or renames files (or directories).  Synopsis:
     mv [OPTION]... SOURCE DEST
     mv [OPTION]... SOURCE... DIRECTORY
   If the last argument names an existing directory, `mv' moves each
other given file into a file with the same name in that directory.
Otherwise, if only two files are given, it renames the first as the
second.  It is an error if the last argument is not a directory and
more than two files are given.
   `mv' can move only regular files across filesystems.
   If a destination file exists but is normally unwritable, standard
input is a terminal, and the `-f' or `--force' option is not given,
`mv' prompts the user for whether to replace the file.  (You might own
the file, or have write permission on its directory.)  If the response
does not begin with `y' or `Y', the file is skipped.
   The program accepts the following options.  Also see *Note Common
options::.
`--backup'
     Make backups of files that are about to be overwritten or removed.
     *Note Backup options::.
`--force'
     Remove existing destination files and never prompt the user.
`--interactive'
     Prompt whether to overwrite each existing destination file,
     regardless of its permissions.  If the response does not begin
     with `y' or `Y', the file is skipped.
`--update'
     Do not move a nondirectory that has an existing destination with
     the same or newer modification time.
`--verbose'
     Print the name of each file before moving it.
`-S SUFFIX'
`--suffix=SUFFIX'
     Append SUFFIX to each backup file made with `-b'.  *Note Backup
     options::.
`-V METHOD'
`--version-control=METHOD'
     Change the type of backups made with `-b'.  The METHOD argument
     can be `numbered' (or `t'), `existing' (or `nil'), or `never' (or
     `simple').  *Note Backup options::.
File: fileutils.info,  Node: rm invocation,  Prev: mv invocation,  Up: Basic operations
`rm': Remove files or directories
=================================
   `rm' removes each given FILE.  By default, it does not remove
directories.  Synopsis:
     rm [OPTION]... [FILE]...
   If a file is unwritable, standard input is a terminal, and the `-f'
or `--force' option is not given, or the `-i' or `--interactive' option
*is* given, `rm' prompts the user for whether to remove the file.  If
the response does not begin with `y' or `Y', the file is skipped.
   The program accepts the following options.  Also see *Note Common
options::.
`--directory'
     Remove directories with `unlink' instead of `rmdir', and don't
     require a directory to be empty before trying to unlink it.  Only
     works if you have appropriate privileges.  Because unlinking a
     directory causes any files in the deleted directory to become
     unreferenced, it is wise to `fsck' the filesystem after doing this.
`--force'
     Ignore nonexistent files and never prompt the user.
`--interactive'
     Prompt whether to remove each file.  If the response does not begin
     with `y' or `Y', the file is skipped.
`--recursive'
     Remove the contents of directories recursively.
`--verbose'
     Print the name of each file before removing it.
   One common question is how to remove files whose names being with a
`-'.  GNU `rm', like every program that uses the `getopt' function to
parse its arguments, lets you use the `--' option to indicate that all
following arguments are non-options.  To remove a file called `-f' in
the current directory, you could type either:
     rm -- -f
     rm ./-f
   The Unix `rm' program's use of a single `-' for this purpose
predates the development of the getopt standard syntax.
File: fileutils.info,  Node: Special file types,  Next: Changing file attributes,  Prev: Basic operations,  Up: Top
Special file types
******************
   This chapter describes commands which create special types of files
(and `rmdir', which removes directories, one special file type).
   Although Unix-like operating systems have markedly fewer special file
types than others, not *everything* can be treated only as the
undifferentiated byte stream of "normal files".  For example, when a
file is created or removed, the system must record this information,
which it does in a "directory"--a special type of file.  Although you
can read directories as normal files, if you're curious, in order for
the system to do its job it must impose a structure, a certain order,
on the bytes of the file.  Thus it is a "special" type of file.
   Besides directories, other special file types include named pipes
(FIFOs), symbolic links, sockets, and so-called "special files".
* Menu:
* ln invocation::               Make links between files.
* mkdir invocation::            Make directories.
* mkfifo invocation::           Make FIFOs (named pipes).
* mknod invocation::            Make block or character special files.
* rmdir invocation::            Remove empty directories.
File: fileutils.info,  Node: ln invocation,  Next: mkdir invocation,  Up: Special file types
`ln': Make links between files
==============================
   `ln' makes links between files.  By default, it makes hard links;
with the `-s' option, it makes symbolic (or "soft") links.  Synopses:
     ln [OPTION]... SOURCE [DEST]
     ln [OPTION]... SOURCE... DIRECTORY
   If the last argument names an existing directory, `ln' links each
SOURCE file into a file with the same name in that directory.  (But see
the description of the `--no-dereference' option below.) If only one
file is given, it links that file into the current directory.
Otherwise, if only two files are given, it links the first onto the
second.  It is an error if the last argument is not a directory and more
than two files are given.  By default, it does not remove existing
files.
   A "hard link" is another name for an existing file; the link and the
original are indistinguishable.  (Technically speaking, they share the
same inode, and the inode contains all the information about a
file--indeed, it is not incorrect to say that the inode *is* the file.)
On all existing implementations, you cannot make a hard links to
directories, and hard links cannot cross filesystem boundaries.  (These
restrictions are not mandated by POSIX, however.)
   "Symbolic links" ("symlinks" for short), on the other hand, are a
special file type (which not all kernels support; in particular, system
V release 3 (and older) systems lack symlinks) in which the link file
actually refers to a different file, by name.  When most operations
(opening, reading, writing, and so on) are passed the symbolic link
file, the kernel automatically "dereferences" the link and operates on
the target of the link.  But some operations (e.g., removing) work on
the link file itself, rather than on its target.  *Note Symbolic Links:
(library)Symbolic Links.
   The program accepts the following options.  Also see *Note Common
options::.
`--backup'
     Make backups of files that are about to be overwritten or removed.
     *Note Backup options::.
`--directory'
     Allow the super-user to make hard links to directories.
`--force'
     Remove existing destination files.
`--interactive'
     Prompt whether to remove existing destination files.
`--no-dereference'
     When given an explicit destination that is a symlink to a
     directory, treat that destination as if it were a normal file.
     When the destination is an actual directory (not a symlink to one),
     there is no ambiguity.  The link is created in that directory.
     But when the specified destination is a symlink to a directory,
     there are two ways to treat the user's request.  `ln' can treat
     the destination just as it would a normal directory and create the
     link in it.  On the other hand, the destination can be viewed as a
     non-directory--as the symlink itself.  In that case, `ln' must
     delete or backup that symlink before creating the new link.  The
     default is to treat a destination that is a symlink to a directory
     just like a directory.
`--symbolic'
     Make symbolic links instead of hard links.  This option merely
     produces an error message on systems that do not support symbolic
     links.
`--verbose'
     Print the name of each file before linking it.
`-S SUFFIX'
`--suffix=SUFFIX'
     Append SUFFIX to each backup file made with `-b'.  *Note Backup
     options::.
`-V METHOD'
`--version-control=METHOD'
     Change the type of backups made with `-b'.  The METHOD argument
     can be `numbered' (or `t'), `existing' (or `nil'), or `never' (or
     `simple').  *Note Backup options::.
File: fileutils.info,  Node: mkdir invocation,  Next: mkfifo invocation,  Prev: ln invocation,  Up: Special file types
`mkdir': Make directories
=========================
   `mkdir' creates directories with the specified names.  Synopsis:
     mkdir [OPTION]... NAME...
   It is not an error if a NAME is already a directory; `mkdir' simply
proceeds.  But if a NAME is an existing file and is anything but a
directory, `mkdir' complains.
   The program accepts the following options.  Also see *Note Common
options::.
`-m MODE'
`--mode=MODE'
     Set the mode of created directories to MODE, which is symbolic as
     in `chmod' and uses 0777 (read, write and execute allowed for
     everyone) minus the bits set in the umask for the point of the
     departure.  *Note File permissions::.
`--parents'
     Make any missing parent directories for each argument.  The mode
     for parent directories is set to the umask modified by `u+wx'.
     Ignore arguments corresponding to existing directories.
`--verbose'
     Print a message for each created directory.  This is most useful
     with `--parents'.
File: fileutils.info,  Node: mkfifo invocation,  Next: mknod invocation,  Prev: mkdir invocation,  Up: Special file types
`mkfifo': Make FIFOs (named pipes)
==================================
   `mkfifo' creates FIFOs (also called "named pipes") with the
specified names.  Synopsis:
     mkfifo [OPTION] NAME...
   A "FIFO" is a special file type that permits independent processes
to communicate.  One process opens the FIFO file for writing, and
another for reading, after which data can flow as with the usual
anonymous pipe in shells or elsewhere.
   The program accepts the following option.  Also see *Note Common
options::.
`-m MODE'
`--mode=MODE'
     Set the mode of created FIFOs to MODE, which is symbolic as in
     `chmod' and uses 0666 (read and write allowed for everyone) minus
     the bits set in the umask for the point of departure.  *Note File
     permissions::.
File: fileutils.info,  Node: mknod invocation,  Next: rmdir invocation,  Prev: mkfifo invocation,  Up: Special file types
`mknod': Make block or character special files
==============================================
   `mknod' creates a FIFO, character special file, or block special
file with the specified name.  Synopsis:
     mknod [OPTION]... NAME TYPE [MAJOR MINOR]
   Unlike the phrase "special file type" above, the term "special file"
has a technical meaning on Unix: something that can generate or receive
data.  Usually this corresponds to a physical piece of hardware, e.g.,
a printer or a disk.  (These files are typically created at
system-configuration time.)  The `mknod' command is what creates files
of this type.  Such devices can be read either a character at a time or
a "block" (many characters) at a time, hence we say there are "block
special" files and "character special" files.
   The arguments after NAME specify the type of file to make:
     for a FIFO
     for a block (buffered) special file
     for a character (buffered) special file
     for a character (unbuffered) special file
   When making a block or character special file, the major and minor
device numbers must be given after the file type.
   The program accepts the following option.  Also see *Note Common
options::.
`-m MODE'
`--mode=MODE'
     Set the mode of created files to MODE, which is symbolic as in
     `chmod' and uses 0666 minus the bits set in the umask as the point
     of departure.  *Note File permissions::.
File: fileutils.info,  Node: rmdir invocation,  Prev: mknod invocation,  Up: Special file types
`rmdir': Remove empty directories
=================================
   `rmdir' removes empty directories.  Synopsis:
     rmdir [OPTION]... DIRECTORY...
   If any DIRECTORY argument does not refer to an existing empty
directory, it is an error.
   The program accepts the following option.  Also see *Note Common
options::.
`--parents'
     Remove any parent directories that become empty after an argument
     DIRECTORY is removed.
   *Note rm invocation::, for how to remove non-empty directories
(recursively).
File: fileutils.info,  Node: Changing file attributes,  Next: Disk usage,  Prev: Special file types,  Up: Top
Changing file attributes
************************
   A file is not merely its contents, a name, and a file type (*note
Special file types::.).  A file also has an owner (a userid), a group
(a group id), permissions (what the owner can do with the file, what
people in the group can do, and what everyone else can do), various
timestamps, and other information.  Collectively, we call these a file's
"attributes".
   These commands change file attributes.
* Menu:
* chown invocation::            Change file owners and groups.
* chgrp invocation::            Change file groups.
* chmod invocation::            Change access permissions.
* touch invocation::            Change file timestamps.
File: fileutils.info,  Node: chown invocation,  Next: chgrp invocation,  Up: Changing file attributes
`chown': Change file owner and group
====================================
   `chown' changes the user and/or group ownership of each given file.
Synopsis:
     chown [OPTION]... NEW-OWNER FILE...
   The first non-option argument, NEW-OWNER, specifies the new owner
and/or group, as follows (with no embedded white space):
     [OWNER] [ [:.] [GROUP] ]
   Specifically:
OWNER
     If only an OWNER (a user name or numeric user id) is given, that
     user is made the owner of each given file, and the files' group is
     not changed.
OWNER`.'GROUP
OWNER`:'GROUP
     If the OWNER is followed by a colon or dot and a GROUP (a group
     name or numeric group id), with no spaces between them, the group
     ownership of the files is changed as well (to GROUP).
OWNER`.'
OWNER`:'
     If a colon or dot but no group name follows OWNER, that user is
     made the owner of the files and the group of the files is changed
     to OWNER's login group.
`.'GROUP
`:'GROUP
     If the colon or dot and following GROUP are given, but the owner
     is omitted, only the group of the files is changed; in this case,
     `chown' performs the same function as `chgrp'.
   The program accepts the following options.  Also see *Note Common
options::.
`--changes'
     Verbosely describe the action for each FILE whose ownership
     actually changes.
`--silent'
`--quiet'
     Do not print error messages about files whose ownership cannot be
     changed.
`--no-dereference'
     Act on symbolic links themselves instead of what they point to.
     Only available if the `lchown' system call is provided.
`--verbose'
     Verbosely describe the action (or non-action) taken for every FILE.
`--recursive'
     Recursively change ownership of directories and their contents.
File: fileutils.info,  Node: chgrp invocation,  Next: chmod invocation,  Prev: chown invocation,  Up: Changing file attributes
`chgrp': Change group ownership
===============================
   `chgrp' changes the group ownership of each given FILE to GROUP,
which can be either a group name or a numeric group id.  Synopsis:
     chgrp [OPTION]... GROUP FILE...
   The program accepts the following options.  Also see *Note Common
options::.
`--changes'
     Verbosely describe the action for each FILE whose group actually
     changes.
`--silent'
`--quiet'
     Do not print error messages about files whose group cannot be
     changed.
`--no-dereference'
     Act on symbolic links themselves instead of what they point to.
     Only available if the `lchown' system call is provided.
`--verbose'
     Verbosely describe the action or non-action taken for every FILE.
`--recursive'
     Recursively change the group ownership of directories and their
     contents.
File: fileutils.info,  Node: chmod invocation,  Next: touch invocation,  Prev: chgrp invocation,  Up: Changing file attributes
`chmod': Change access permissions
==================================
   `chmod' changes the access permissions of the named files.  Synopsis:
     chmod [OPTION]... MODE FILE...
   `chmod' never changes the permissions of symbolic links, since the
`chmod' system call cannot change their permissions.  This is not a
problem since the permissions of symbolic links are never used.
However, for each symbolic link listed on the command line, `chmod'
changes the permissions of the pointed-to file.  In contrast, `chmod'
ignores symbolic links encountered during recursive directory
traversals.
   The first non-option argument, MODE, specifies the new permissions.
See the section below for details.
   The program accepts the following options.  Also see *Note Common
options::.
`--changes'
     Verbosely describe the action for each FILE whose permissions
     actually changes.
`--silent'
`--quiet'
     Do not print error messages about files whose permissions cannot be
     changed.
`--verbose'
     Verbosely describe the action or non-action taken for every FILE.
`--recursive'
     Recursively change permissions of directories and their contents.
File: fileutils.info,  Node: touch invocation,  Prev: chmod invocation,  Up: Changing file attributes
`touch': Change file timestamps
===============================
   `touch' changes the access and/or modification times of the
specified files.  Synopsis:
     touch [OPTION]... FILE...
   If the first FILE would be a valid argument to the `-t' option and
no timestamp is given with any of the `-d', `-r', or `-t' options and
the `--' argument is not given, that argument is interpreted as the
time for the other files instead of as a file name.
   Any FILE that does not exist is created empty.
   If changing both the access and modification times to the current
time, `touch' can change the timestamps for files that the user running
it does not own but has write permission for.  Otherwise, the user must
own the files.
   The program accepts the following options.  Also see *Note Common
options::.
`--time=atime'
`--time=access'
`--time=use'
     Change the access time only.
`--no-create'
     Do not create files that do not exist.
`--date=time'
     Use TIME instead of the current time.  It can contain month names,
     timezones, `am' and `pm', etc.  *Note Date input formats::.
     Ignored; for compatibility with BSD versions of `touch'.
`--time=mtime'
`--time=modify'
     Change the modification time only.
`-r FILE'
`--reference=FILE'
     Use the times of the reference FILE instead of the current time.
`-t MMDDhhmm[[CC]YY][.ss]'
     Use the argument (months, days, hours, minutes, optional century
     and years, optional seconds) instead of the current time.
File: fileutils.info,  Node: Disk usage,  Next: Index,  Prev: Changing file attributes,  Up: Top
Disk usage
**********
   No disk can hold an infinite amount of data.  These commands report
on how much disk storage is in use or available.  (This has nothing
much to do with how much *main memory*, i.e., RAM, a program is using
when it runs; for that, you want `ps' or `pstat' or `swap' or some such
command.)
* Menu:
* df invocation::               Report filesystem disk space usage.
* du invocation::               Estimate file space usage.
* sync invocation::             Synchronize memory and disk.
File: fileutils.info,  Node: df invocation,  Next: du invocation,  Up: Disk usage
`df': Report filesystem disk space usage
========================================
   `df' reports the amount of disk space used and available on
filesystems.  Synopsis:
     df [OPTION]... [FILE]...
   With no arguments, `df' reports the space used and available on all
currently mounted filesystems (of all types).  Otherwise, `df' reports
on the filesystem containing each argument FILE.
   Disk space is shown in 1024-byte blocks by default, unless the
environment variable `POSIXLY_CORRECT' is set, in which case 512-byte
blocks are used (unless the `-k' option is given).
   If an argument FILE is a disk device file containing a mounted
filesystem, `df' shows the space available on that filesystem rather
than on the filesystem containing the device node (i.e., the root
filesystem).  GNU `df' does not attempt to determine the disk usage on
unmounted filesystems, because on most kinds of systems doing so
requires extremely nonportable intimate knowledge of filesystem
structures.
   The program accepts the following options.  Also see *Note Common
options::.
`--all'
     Include in the listing filesystems that have a size of 0 blocks,
     which are omitted by default.  Such filesystems are typically
     special-purpose pseudo-filesystems, such as automounter entries.
     Also, filesystems of type "ignore" or "auto", supported by some
     operating systems, are only included if this option is specified.
`--human-readable'
     Append a size letter such as `M' for megabytes to each size.
`--inodes'
     List inode usage information instead of block usage.  An inode
     (short for index node) is contains information about a file such
     as its owner, permissions, timestamps, and location on the disk.
`--kilobytes'
     Print sizes in 1024-byte blocks.  This overrides the environment
     variable `POSIXLY_CORRECT'.
`--megabytes'
     Print sizes in megabyte (that 1,048,576 bytes) blocks.
`--no-sync'
     Do not invoke the `sync' system call before getting any usage data.
     This may make `df' run significantly faster on systems with many
     disks, but on some systems (notably SunOS) the results may be
     slightly out of date.  This is the default.
`--portability'
     Use the POSIX output format.  This is like the default format
     except that the information about each filesystem is always
     printed on exactly one line; a mount device is never put on a line
     by itself.  This means that if the mount device name is more than
     20 characters long (e.g., for some network mounts), the columns
     are misaligned.
`--sync'
     Invoke the `sync' system call before getting any usage data.  On
     some systems (notably SunOS), doing this yields more up to date
     results, but in general this option makes `df' much slower,
     especially when there are many or very busy filesystems.
`-t FSTYPE'
`--type=FSTYPE'
     Limit the listing to filesystems of type FSTYPE.  Multiple
     filesystem types can be specified by giving multiple `-t' options.
     By default, nothing is omitted.
`--print-type'
     Print each filesystem's type.  The types printed here are the same
     ones you can include or exclude with `-t' and `-x'.  The particular
     types printed are whatever is supported by the system.  Here are
     some of the common names (this list is certainly not exhaustive):
    `nfs'
          An NFS filesystem, i.e., one mounted over a network from
          another machine.  This is the one type name which seems to be
          used uniformly by all systems.
    `4.2, ufs, efs...'
          A filesystem on a locally-mounted hard disk.  (The system
          might even support more than one type here; Linux does.)
    `hsfs, cdfs'
          A filesystem on a CD-ROM drive.  HP-UX uses `cdfs', most other
          systems use `hsfs' (`hs' for `High Sierra').
    `pcfs'
          An MS-DOS filesystem, usually on a diskette.
`-x FSTYPE'
`--exclude-type=FSTYPE'
     Limit the listing to filesystems not of type FSTYPE.  Multiple
     filesystem types can be eliminated by giving multiple `-x'
     options.  By default, no filesystem types are omitted.
     Ignored; for compatibility with System V versions of `df'.
File: fileutils.info,  Node: du invocation,  Next: sync invocation,  Prev: df invocation,  Up: Disk usage
`du': Estimate file space usage
===============================
   `du' reports the amount of disk space used by the specified files
and for each subdirectory (of directory arguments).  Synopsis:
     du [OPTION]... [FILE]...
   With no arguments, `du' reports the disk space for the current
directory.  The output is in 1024-byte units by default, unless the
environment variable `POSIXLY_CORRECT' is set, in which case 512-byte
blocks are used (unless `-k' is specified).
   The program accepts the following options.  Also see *Note Common
options::.
`--all'
     Show counts for all files, not just directories.
`--bytes'
     Print sizes in bytes, instead of kilobytes.
`--total'
     Print a grand total of all arguments after all arguments have been
     processed.  This can be used to find out the total disk usage of a
     given set of files or directories.
`--dereference-args'
     Dereference symbolic links that are command line arguments.  Does
     not affect other symbolic links.  This is helpful for finding out
     the disk usage of directories, such as `/usr/tmp', which are often
     symbolic links.
`--human-readable'
     Append a size letter, such as `M' for megabytes, to each size.
`--kilobytes'
     Print sizes in kilobytes.  This overrides the environment variable
     `POSIXLY_CORRECT'.
`--count-links'
     Count the size of all files, even if they have appeared already
     (as a hard link).
`--dereference'
     Dereference symbolic links (show the disk space used by the file
     or directory that the link points to instead of the space used by
     the link).
`--megabytes'
     Print sizes in megabyte (that 1,048,576 bytes) blocks.
`--summarize'
     Display only a total for each argument.
`--separate-dirs'
     Report the size of each directory separately, not including the
     sizes of subdirectories.
`--one-file-system'
     Skip directories that are on different filesystems from the one
     that the argument being processed is on.
   On BSD systems, `du' reports sizes that are half the correct values
for files that are NFS-mounted from HP-UX systems.  On HP-UX systems,
it reports sizes that are twice the correct values for files that are
NFS-mounted from BSD systems.  This is due to a flaw in HP-UX; it also
affects the HP-UX `du' program.
File: fileutils.info,  Node: sync invocation,  Prev: du invocation,  Up: Disk usage
`sync': Synchronize data on disk with memory
============================================
   `sync' writes any data buffered in memory out to disk.  This can
include (but is not limited to) modified superblocks, modified inodes,
and delayed reads and writes.  This must be implemented by the kernel;
The `sync' program does nothing but exercise the `sync' system call.
   The kernel keeps data in memory to avoid doing (relatively slow) disk
reads and writes.  This improves performance, but if the computer
crashes, data may be lost or the filesystem corrupted as a result.
`sync' ensures everything in memory is written to disk.
   Any arguments are ignored, except for a lone `--help' or `--version'
(*note Common options::.).