Introducing Linux

=================

Design and Implications

------------------------

A Linux-based system is a modular Unix-like operating system, deriving much of its basic design from principles established in Unix earlier. Such a system uses a monolithic kernel, called the Linux kernel, which handles process control, networking, and peripheral and file system access. Device drivers are integrated directly with the kernel. Separate projects that interface with the kernel provide much of the system's higher-level functionality. The GNU userland is an important part of most Linux-based systems, providing the most common implementation of the C library, a popular shell, and many of the common Unix tools which carry out many basic operating system tasks. The graphical user interface (or GUI) used by most Linux systems is based on the "X Window System".

Reasons for Using Linux

-----------------------

- Linux is free:

As in "free beer". Linux can be downloaded in its entirety from the Internet completely for free. No registration fees, no costs per user, free updates, and freely available source code in case you want to change the behavior of your system.

Most of all, Linux is free as in "free speech":

- Linux is portable to any hardware platform:

A vendor, who wants to sell a new type of computer and who does not know what kind of OS his/her new machine will run, can take a Linux kernel and make it work on his/her hardware, because documentation related to this activity is freely available.

- Linux was made to keep on running:

As with UNIX, a Linux system expects to run without rebooting all the time. That is why a lot of tasks are being executed at night or scheduled automatically for other times, resulting in higher availability during busier periods and a more balanced use of the hardware. This property allows for Linux to be applicable to environments where people do not have the time or the possibility to control their systems constantly.

- Linux is secure and versatile:

The security model used in Linux is based on the UNIX idea of security, which is known to be robust and of proven quality. But Linux is not only safe from attacks from the Internet: it will adapt equally to other situations, utilizing the same high standards for security.

- Linux is scalable:

Getting Started

================

Logging in, activating the user interface and logging out

----------------------------------------------------------

When you see the login screen again, asking to enter user name and password, logout was successful.

Basic Commands

===============

ls

---

	$ ls

	jeeves.rst psmith.html blandings.html

cd

---

One dot '.' represents the current directory while two dots '..' represent the parent directory.

“ cd -” will return you to the previous directory (a bit like an “undo”).

You can also use cd absolute path or cd relative path (see below):

Absolute paths:

    An “ absolute path” is easily recognised from the leading forward slash, /. The / means that you start at the top level directory and continue down.

For example to get to /boot/grub you would type::

	$cd /boot/grub

This is an absolute path because you start at the top of the hierarchy and go downwards from there (it doesn't matter where in the filesystem you were when you typed the command).

Relative paths:

    A “ relative path” doesn't have a preceding slash. Use a relative path when you start from a directory below the top level directory structure. This is dependent on where you are in the filesystem.

    For example if you are in root's home directory and want to get to /root/music, you type::

	$ cd music

Please note that there is no / using the above cd command. Using a / would cause this to be an absolute path, working from the top of the hierarchy downward.

who

----

The standard Unix command *who* displays a list of users who are currently logged into a computer.

The *who* command is related to the command *w*, which provides the same information but also displays additional data and statistics.::

	$who

	beeblebrox tty7         2009-09-08 10:50 (:0)

	beeblebrox pts/0        2009-09-08 11:25 (:0.0)

	dumbledore pts/1        2009-09-08 18:11 (potter.xyz.in)

	beeblebrox pts/2        2009-09-08 18:53 (:0.0)

The command can be invoked with the arguments *am i* or *am I* (so it is invoked as *who am i* or * who am I*), showing information about the current terminal only (see the *-m* option below, of which this invocation is equivalent).

mkdir

-----

This command is used to make a new directory. Normal usage is as straightforward as follows::

	$mkdir name_of_directory

Where *name_of_directory* is the name of the directory one wants to create. When typed as above (ie. normal usage), the new directory would be created within the current directory. On Unix, multiple directories can be specified, and *mkdir* will try to create all of them.

Getting Help

============

apropos and whatis

-------------------

This is a command to search the manual pages files in Unix and Unix-like operating systems. ::

	$ apropos grep

	egrep       egrep (1)       Search a file for a pattern using full regular expressions

	fgrep       fgrep (1)       Search a file for a fixed-character	string

	fmlgrep     fmlgrep (1)     Search a file for a pattern

	grep        grep (1)        Search a file for a pattern

	gzgrep      gzgrep (1)      Search a possibly compressed file for a regular expression

	nisgrep     nismatch (1)    Utilities for searching NIS+ tables

	pgrep       pgrep (1)       Find or signal a process by name or other attribute

	zgrep       zgrep (1)       Search a possibly compressed file for a regular expression

	...

In this example, the user uses *apropos* to search for the string "grep", and apropos returns the indicated *man* pages that include the term "grep".

A short index of explanations for commands is available using the *whatis* command, like in the examples below::

	$whatis ls

	ls (1) 		 - list directory contents

This displays short information about a command, and the first section in the collection of man pages that contains an appropriate page.

If you don't know where to get started and which man page to read, *apropos* gives more information. Say that you do not know how to start a browser, then you could enter the following command::

	$apropos browser

	gmusicbrowser (1)    - Jukebox for large collections of audio files

	infobrowser (1)      - read Info documents

	libsmbclient (7)     - An extension library for browsers and that 		can be used...

	opera (1)            - a standards-compliant graphical Web browser

	sensible-browser (1) - sensible editing, paging, and web browsing

	smbtree (1)          - A text based smb network browser

	tvtk_doc (1)         - A GUI based TVTK documentation search browser.

	viewres (1)          - graphical class browser for Xt

	w3m (1)              - a text based Web browser and pager

	www-browser (1)      - a text based Web browser and pager

	...

man

----

Man pages (short for "manual pages") are the extensive documentation that comes preinstalled with almost all substantial Unix and Unix-like operating systems. The Unix command used to display them is *man*. Each page is a self-contained document.

To read a manual page for a Unix command, one can use::

	$ man <command_name>

at a shell prompt; for example, "man ftp". In order to simplify navigation through the output, *man* generally uses the less terminal pager.

	$man man

The previous example will take you to the "Manual" page entry about manual pages!

info

-----

*info* is a software utility which forms a hypertextual, multipage documentation and help viewer working on a command line interface, useful when there is no GUI available.

The syntax is ::

	$ info <command_name>

*info* processes info files, which are Texinfo formatted files, and presents the documentation as a tree, with simple commands to traverse the tree and to follow cross references. For instance

    - *n* goes to the next page.

    - *p* goes to the previous page.

    - *u* goes to the upper page.

    - *l* goes to the last(visited) node

    - To follow a cross reference, the cursor can be moved over a link (a word preceded by a `*`) and enter pressed.

info was initially written for use with GNU/Linux and then ported to other Unix-like operating systems.

--help

-------

Most GNU commands support the --help, which gives a short explanation about how to use the command and a list of available options. Below is the output of this option with the *cat* command::

	$ userprompt@host: cat --help

	Usage: cat [OPTION] [FILE]...

	Concatenate FILE(s), or standard input, to standard output.

	  -A, --show-all           equivalent to -vET

	  -b, --number-nonblank    number nonempty output lines

	  -e                       equivalent to -vE

	  -E, --show-ends          display $ at end of each line

	  -n, --number             number all output lines

	  -s, --squeeze-blank      suppress repeated empty output lines

	  -t                       equivalent to -vT

	  -T, --show-tabs          display TAB characters as ^I

	  -u                       (ignored)

	  -v, --show-nonprinting   use ^ and M- notation, except for LFD and 		  TAB

	  --help     display this help and exit

      	  --version  output version information and exit

	With no FILE, or when FILE is -, read standard input.

	Examples:

	  cat f - g  Output f's contents, then standard input, then g's 	  contents.

	  cat        Copy standard input to standard output.

	Report bugs to <bug-coreutils@gnu.org>.

Basic file handling

===================

cp

---

*cp* is the command entered in a Unix shell to copy a file from one place to another, possibly on a different filesystem. The original file remains unchanged, and the new file may have the same or a different name.

Usage

~~~~~

To copy a file to another file::

To copy a file to a directory::

To copy a directory to a directory::

Flags

~~~~~

*-P* – makes the cp command copy symbolic links. The default is to follow symbolic links, that is, to copy files to which symbolic links point.

*-i* (interactive) – prompts you with the name of a file to be overwritten. This occurs if the TargetDirectory or TargetFile parameter contains a file with the same name as a file specified in the SourceFile or SourceDirectory parameter. If you enter y or the locale's equivalent of y, the cp command continues. Any other answer prevents the cp command from overwriting the file.

*-p* (preserve) – duplicates the following characteristics of each SourceFile/SourceDirectory in the corresponding TargetFile and/or TargetDirectory:

    * The time of the last data modification and the time of the last access.

    * The user ID and group ID (only if it has permissions to do this)

    * The file permission bits and the SUID and SGID bits.

*-R* (recursive) – copy directories (recursively copying all the contents)

Examples

~~~~~~~~

To make a copy of a file in the current directory, enter::

    $ cp prog.c prog.bak

This copies prog.c to prog.bak. If the prog.bak file does not already exist, the cp command creates it. If it does exist, the cp command replaces it with a copy of the prog.c file.

To copy a file in your current directory into another directory, enter::

    $ cp zaphod /home/books/hhgg

This copies the jones file to /home/books/hhgg/zaphod.

To copy a file to a new file and preserve the modification date, time, and access control list associated with the source file, enter::

    $ cp -p martin_luther_king martin_luther_king.jr

This copies the *martin_luther_king* file to the *martin_luther_king.jr* file. Instead of creating the file with the current date and time stamp, the system gives the *martin_luther_king.jr* file the same date and time as the *martin_luther_king* file. The *martin_luther_king.jr* file also inherits the *martin_luther_king* file's access control protection.

To copy all the files in a directory to a new directory, enter::

    $ cp /home/galactica/clients/* /home/hhgg/customers

This copies only the files in the clients directory to the customers directory.

To copy a directory, including all its files and subdirectories, to another directory, enter:

    $ cp -R /home/hhgg/clients /home/hhgg/customers

This copies the clients directory, including all its files, subdirectories, and the files in those subdirectories, to the customers/clients directory.

To copy a specific set of files of any extension to another directory, enter::

    $ cp zaphod arthur ford /home/hhgg/clients

This copies the *zaphod*, *arthur*, and *ford* files in your current working directory to the /home/hhgg/clients directory.

To use pattern-matching characters to copy files, enter::

    $ cp programs/*.py .

This copies the files in the programs directory that end with *.py* to the current directory, signified by the single "." (dot). You must type a space between the *py* and the final dot.

mv

---

*mv* (short for move) is a Unix command that moves one or more files or directories from one place to another. The original file is deleted, and the new file may have the same or a different name. If possible (i.e. when the original and new files are on the same file system), *mv* will rename the file instead. Write permission is required on all directories being modified.

Conflicting existing file

~~~~~~~~~~~~~~~~~~~~~~~~~~

In all cases, when a file is moved to have the name of an existing file (in the same directory), the existing file is deleted. If the existing file is not writable but is in a directory that is writable, then the mv command asks for confirmation if possible (i.e. if run from a terminal) before proceeding, unless the -f (force) option is used.

Differences with copy and delete

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Note that, usually, when moving files within the same volume, moving (and/or renaming) is not the same as simply copying and then deleting the original. When moving a file, the link is simply removed from the old parent directory and added to the new parent directory. However, the file itself is untouched (i.e. it has the same inodes and resides at the same place on the disk). For example, you cannot copy a file you cannot read, but you can move (and/or rename) it (provided you have write permission to its old and new parent directories). Also, suppose there is a non-empty directory you do not have write permission to. You cannot delete this directory (since you cannot delete its contents); but you can move (and/or rename) it. Also, since moving between filenames on a single volume does not involve copying, it is faster and does not place strain of lots of reads and writes on the disk. Moving files across different volumes, however, does necessitate copying and deleting.

Examples

~~~~~~~~

::

	$ mv myfile mynewfilename    renames a file

	$ mv myfile /myfile          moves 'myfile' from the current 		directory to the root directory

	$ mv myfile dir/myfile       moves 'myfile' to 'dir/myfile' relative 		to the current directory

	$ mv myfile dir              same as the previous command (the 		filename is implied to be the same)

	$ mv myfile dir/myfile2      moves 'myfile' to dir and renames it to 		'myfile2'

	$ mv foo bar baz dir         moves multiple files to directory dir

	$ mv --help                  shows a very concise help about the 		syntax of the command

	$ man mv                     prints an extensive user manual for 		'mv' in the terminal

In all cases, the file or files being moved or renamed can be a directory.

Note that when the command is called with two arguments (as *mv name1 name2* or *mv name1 /dir/name2*), it can have three different effects, depending on whether *name2* does not exist, is an existing file, or is an existing directory. If the user intends to refer to an existing directory, */.* (or in some Unix versions */* is sufficient) may be appended to the name to force the system to check this. To move a file to a new directory, the directory must be created first.

rm

---

*rm* (short for "remove") is one of several basic Unix command lines that operates on files. It is used to delete files from a filesystem. The data is not actually destroyed. Only the index listing where the file is stored is destroyed, and the storage is made available for reuse. There are undelete utilities that will attempt to reconstruct the index and can bring the file back if the parts were not reused.

Here's example to remove a file named "foo" from a directory, here shown with the -i option::

  	$ rm -i foo

    	remove foo? y

Options

~~~~~~~

Common options that rm accepts include:

    * *-r*, which removes directories, removing the contents recursively beforehand (so as not to leave files without a directory to reside in) ("recursive")

    * *-i*, which asks for every deletion to be confirmed ("interactive")

    * *-f*, which ignores non-existent files and overrides any confirmation prompts ("force")

    * *-v*, which shows what is being removed as it happens ("verbose")

*rm* is often aliased to "rm -i" so as to avoid accidental deletion of files. If a user still wishes to delete a large number of files without confirmation, they can manually cancel out the -i argument by adding the -f option (as the option specified later on the expanded command line "rm -i -f" takes precedence).

*rm -rf* (variously, rm -rf /, rm -rf `*`, and others) is frequently used in jokes and anecdotes about Unix disasters. The rm -rf variant of the command, if run by a superuser on the root directory, would cause the contents of every writable mounted filesystem on the computer to be deleted.

*rm* is often used in conjunction with xargs to supply a list of files to delete::

	xargs rm < filelist

When *rm* is used on a symbolic link, it deletes the link, but does not affect the target of the link.

Permissions

~~~~~~~~~~~

Usually, on most filesystems, deleting a file requires write permission on the parent directory (and execute permission, in order to enter the directory in the first place). (Note that, confusingly for beginners, permissions on the file itself are irrelevant. However, GNU rm asks for confirmation if a write-protected file is to be deleted, unless the -f option is used.)

Basic Text Processing

======================

head

-----

*head* is a program on Unix and Unix-like systems used to display the first few lines of a text file or piped data. The command syntax is::

	$ head [options] <file_name>

By default, *head* will print the first 10 lines of its input to the standard output. The number of lines printed may be changed with a command line option. The following example shows the first 20 lines of filename::

	$ head -n 20 filename

This displays the first 5 lines of all files starting with *foo*::

	$ head -n 5 foo*

Flags

~~~~~

::

	-c <x number of bytes> Copy first x number of bytes.

tail

----

*tail* is a program on Unix and Unix-like systems used to display the last few lines of a text file or piped data.

The command-syntax is::

	$ tail [options] <file_name>

By default, *tail* will print the last 10 lines of its input to the standard output. With command line options the number of lines printed and the printing units (lines, blocks or bytes) may be changed. The following example shows the last 20 lines of filename::

	$ tail -n 20 filename

This example shows the last 15 bytes of all files starting with *foo*::

	$ tail -c 15 foo*

This example shows all lines of filename from the second line onwards::

	$ tail -n +2 filename

File monitoring

~~~~~~~~~~~~~~~

*tail* has a special command line option *-f* (follow) that allows a file to be monitored. Instead of displaying the last few lines and exiting, tail displays the lines and then monitors the file. As new lines are added to the file by another process, tail updates the display. This is particularly useful for monitoring log files. The following command will display the last 10 lines of messages and append new lines to the display as new lines are added to messages::

	$ tail -f /var/adm/messages

To interrupt tail while it is monitoring, break-in with *Ctrl+C*. This command can be run "in the background" with &, see job control.