Brands of commercial UNIX
Some of the most famous and widely used brands of UNIX include Sun’s Solaris and Hewlett Packard’s HP-UX.

Solaris is a binary-compatible operating system, which means that Sun have gone to some lengths to ensure that one version of their UNIX will run on all of their hardware. Solaris also features integrated Java support, although Java can be downloaded for any UNIX
distribution.

Sun also manufacture UNIX for Intel hardware as well as their own proprietary hardware.

By comparison, HP manufacture four different versions of their operating system, each fine tuned for a specific purpose. Hewlett Packard’s UNIX variants all support both RISC architecture and the new breed of Itanium chips from Intel.

Other commercial UNIX variants include IBM’s AIX and Silicon Graphics’s IRIX system.

Brands of open source UNIX
There are an increasingly large number of offshoots of open-source UNIX. However, two names are significant: BSD and Linux.

BSD UNIX is one of the oldest forms of UNIX in existence, and pioneered such technologies as the TCP/IP stack and virtual memory. It’s widely in use across the Internet as a web server.

Linux is a port of the UNIX kernel to i386 (Intel) hardware, and is one of the fastest growing and most widespread UNIXes in use today. In fact, some hardware vendors who traditionally developed proprietary UNIX systems now offer the choice of shipping their
hardware with Linux installed. For example, even though IBM have their own proprietary UNIX, they now offer the option of shipping their xSeries servers with Linux pre-installed.

As a conclusion on choosing Unix, UNIX comes in two main flavors: commercial and open source. The strength of commercial UNIX lies in its support and stability, while open source’s strength lies in innovation and portability. Well known commercial UNIXes include Sun Solaris and Hewlett Packard’s HP-UX. Well known open-source UNIXes include BSD and Linux.

When tasked as a web or database server, a properly configured UNIX system will provide unparalleled periods of uptime, requiring little service. The structure of UNIX means that in the case of a hardware failure, sections of a data structure can be taken offline, replaced and put online again without shutting down the system. This makes UNIX a good choice for mission critical applications.

UNIX’s multi-user capabilities make it highly resistant to attack. It’s designed in such a way that even if a malicious party did gain access to the system, their activities would be restricted to the user account they had access to, leaving them unable to damage critical system resources.

For this reason, there are very few viruses that target UNIX systems, and even fewer that pose any real threat. In fact, most UNIX virus scanners, for example, those running on mail servers – do most of their work removing viruses intended for other operating systems, to which they are immune.

UNIX is also long term cost effective; because by design it’s independent of the hardware it runs on. It will obviously run faster on more powerful hardware, but it does not require powerful hardware to begin with, so existing computers in your network rarely become obsolete.

Which Unix to use
Brand names aside, UNIX comes in two main variants: commercial distributions and open source distributions. Each has it’s own distinct features and advantages that need to be carefully considered when choosing which product is right for you.

Commercial UNIX
Commercial UNIX has the distinct advantage of having IT vendor’s support. When something goes wrong in the system, there’s usually someone you can call that will help you with the problem you’re having.

Commercial distributions often adhere to established standards, so chances are high that the software you need will run reliably on your system. Commercial UNIX often utilizes proprietary code to ensure that the system is as stable as possible.

Some distributors write commercial UNIX specifically for a particular set of hardware. Examples of this include Sun’s Solaris for their SPARC range, and IBM’s AIX for their pSeries. The advantage of this approach is that the software can be highly optimized for
that hardware, giving maximum performance and a greater level of stability.

Using commercial UNIX with proprietary code does mean that the software will be guaranteed scalable, but it also means you may be locked into a particular upgrade path and can only use hardware from one specific company.

Open Source UNIX
Open source UNIX is a hotbed of emerging technology. Because the code is open and available, you can compile UNIX for just about any hardware. It is free, because open source UNIX is distributed under the GNU General Public License (GPL).

The GPL allows you to make any modifications you see fit to the code in order to improve on any system component, provided you make your changes available to the rest of the open source community under the same license, and provide them with the modified source. GPL software has no warranty of any kind.

FreeBSD, a widely used open source UNIX, works a little differently. The bulk of its code is covered by the GPL, but FreeBSD incorporates functionality from several proprietary modules, including some from the original version of BSD. So FreeBSD is covered by the GNU GPL, the BSD copyright, and has restrictions on the redistribution of several proprietary components. Ultimately this makes FreeBSD a bit of a hybrid.
One of the fastest growing UNIX variants is Linux, the UNIX-clone created by Linus Torvalds. It is particularly interesting in that it has been ported to many different platforms, from desktop machines to PDAs and mobile phones. With the arrival of UNIX desktops, such as Gnome and KDE, Linux has started to make inroads in the desktop computing market as well.

You can download open source versions of UNIX, including FreeBSD and Linux, without paying for them. But because of the terms of the GPL, you usually cannot get support for such distributions.

However, because of the wide user base, you can get support for open source UNIXes by turning to the Web, where there is a wealth of documentation and user group expertise to draw from. Alternatively, you can choose to buy commercial support from a company that
specializes in supporting open source UNIX.

Also, the flexibility to compile code for any processor doesn’t guarantee that the software will be compatible with other hardware in your system, such as the particular brand of graphics card or network hub you have. However, if you search the Internet you will often find that there is a driver project underway by others who have encountered the same difficulty.

After get known on which UNIX to choose, commercial UNIX, and open source UNIX, will talk about “Brands of commercial UNIX“, “Brands of open source UNIX” on How to Choose Unix [Part 2]

Here the list of eBook

List of these ebooks:

Addison Wesley – Moving to Ubuntu Linux (2006)
Apress – Beginning Ubuntu Linux 3rd Edition (2008)
Apress – Beginning Ubuntu Linux 4th Edition (2009)
Apress – Beginning Ubuntu LTS Server Administration 2nd Edition (2008)
Apress – Beginning Ubuntu Server Administration, From Novice to Professional (2008)
Apress – Pro Ubuntu Server Administration (2009)
Apress – Ubuntu on a Dime, The Path to Low-Cost Computing (2009)
McGraw-Hill – How to Do Everything Ubuntu (2008)
McGraw-Hill – Ubuntu Server Administration (2008)
McGraw-Hill – Ubuntu, The Complete Reference (2008)
No Starch – Ubuntu for Non-Geeks 2nd Edition (2007)
No Starch – Ubuntu Linux for Non Geeks (2006)
O’Reilly – Learning Debian GNU Linux (1999)
O’Reilly – Ubuntu Hacks (2006)
O’Reilly – Ubuntu Hacks (2006)
Pragmatic – Ubuntu Kung Fu (2008)
Prentice Hall – A Practical Guide to Ubuntu Linux (2007)
Prentice Hall – The Official Ubuntu Book (2006)
Sams – Ubuntu 7.10 Linux Unleashed 3rd Edition (2008)
Sams – Ubuntu Unleashed 2008 Edition (2008)
The Ubuntu Packaging Guide

Thomson Course Technology – Introducing Ubuntu, Desktop Linux (2008)
Ubuntu Desktop Guide
Ubuntu Pocket Guide and Reference (2009)
Unofficial Ubuntu Starter Guide
Wiley – Hacking Ubuntu (2007)
Wiley – Ubuntu Linux Bible (2007)
Wiley – Ubuntu Linux For Dummies (2007)
Wiley – Ubuntu Linux Secrets (2009)
Wiley – Ubuntu Linux Toolbox, 1000+ Commands for Ubuntu and Debian Power Users (2008)

Download Ubuntu Ebook Collection:
hxxp://ho*tfile.com/dl/19291496/7542101/Ubuntu_ebook_collection.part1.rar.html
hxxp://hotfil*e.com/dl/19292673/243a760/Ubuntu_ebook_collection.part2.rar.html
hxxp://hot*file.com/dl/19292847/42ec0cc/Ubuntu_ebook_collection.part3.rar.html
hxxp://h*otfile.com/dl/19293117/d98b4b8/Ubuntu_ebook_collection.part4.rar.html

Linux stores files in plain-text format. This allows you to use different processing, or filtering, utilities on the text. These utilities let you format, analyze, and manipulate text in many different ways. For example, you can format pages and paragraphs, check spelling, add page numbers and headers, and count the lines, words, and characters that a file contains.

Text-processing utilities

The general command syntax used for text-processing commands is

command [option ] filename(s)

Reading files
To work with files, you need to know what information they contain. One way of doing this is to use the cat command to display the contents of a file on your terminal screen. This command provides a number of options.

Options for the cat command

Viewer commands
A quicker way of viewing the contents of a file is by using viewer commands, which display the information at the start or end of a file. Examples of viewer commands include head and tail.

By default, the head command displays the first 10 lines of a file, and the tail command displays the last 10 lines of a file. Additional options can be used with these commands to view more specific areas of a file. For example, you can use the -n option with the commands to specify the number of lines they must display.

Pager commands
If a particular file is longer than one screen, it may scroll past too quickly for you to read it. You can scroll through documents at your own pace by using pager commands, which display documents one screen at a time. Examples of pager commands include less and more.

The more command is the original pager command and derives from the Berkeley version of UNIX. It enables you to move through a document in a forward direction only.

The less command was developed to replace the more command and provides a wider range of options for viewing files.

Pager command options

This happens when we create, delete, move, update and copy files from one location to another. This is because our computer system cannot or have not enough contiguous space to store a complete file as a unit and instead puts parts of it in gaps between other files. In long time period, the accumulation of fragments in hard disk become bigger and bigger, it will affects the system performance, your will feel the processing become slower and slower. In the end, system slowdown, system files crash, or even more serious will decrease hard disk life span.

So, I would like to introduce a helpful application called Advanced Defrag to help you do disk defragmentation.

By using Advanced Defrag, it will assist you in analyze and defrag your hard disk completely and thoroughly. How does it work? It will search for any hard disk bad sector, unresolved file, removes any infected and corrupted file. Then it will defrag the entire related file in same location. By doing this, it will effectively maximize your system performance and improve computer system efficiency.

Besides that, it will also enhance your windows operating system, accelerate the launching time of the program and improve the file access speed. This is because hard disk no longer needs such a long time to search for a data file in different location. At the same time, it will also extend our hard disk life span. You can save up the money for other changes or further upgrade on the hard disk.

At last, I strongly recommend for Advanced Defrag. It is a user-friendly application. However, the most important is it really does done a good job on defragmentation and efficiently speed up our computer system.

Quotas can specify

• the maximum amount of total disk space allotted to a user or group
• The maximum number of files a user or group can create

You assign quotas by partition, so an individual or group who creates files on two partitions may have a different quota for each partition, or a quota for only one of the two partitions.

User and group quotas
User quotas and group quotas are independent of each other – so the value of the group quota is not the sum of the values of the users’ quotas in a group. When a user attempts to create a file, Linux first checks if there is a group quota for the user’s group. If a group quota for the group to which the user belongs has already been filled, the user can’t create the file, regardless of the status of the user’s quota. To create the file, the user must change groups. Every file that an individual user creates counts towards the quota of the user’s group. If the user isn’t part of a quota-restricted group, or if group quotas aren’t switched on for a partition, the user can create files on the partition as long as the user’s quota isn’t filled.

Hard and soft limits
When you set quotas, you can specify both a hard and a soft limit. When a user exceeds a soft limit, a warning is issued, but the user can continue to create files for the duration of a grace period. The default grace period is seven days, but the administrator can change this period. At the end of the grace period, the user must reduce their disk usage so that they don’t exceed the soft limit. The soft limit acts as a warning to the user that they are approaching a hard limit. When the user reaches a hard limit, they can no longer create files at all.

Viewing quotas
The quota command checks the file system in the /etc/fstab directory for quotas and reports them. As a root user, you can use the quota command to view the quotas of any user or group on a system. Users can check their own quotas and the quotas of any groups to which they belong. The syntax for viewing quotas is

quota option who

In the syntax, who can be either a username or a group name.

The following options are used with the quota command:

• g checks a group quota
• u checks a user quota
• q checks which quotas have been filled

Users can use the -g option and the -u option together, to check both their user and group quotas.

The repquota command reports quotas and provides a summary of disk usage for a specified file system. So you can see how many files a user or group owns in a file system and how much space they occupy. The syntax for using the repquota command is

repquota options file_system

The following table shows the repquota command options.

Options for the repquota command

As for the quota command, the root user can use the repquota command to view all quotas in the system, whereas other users can view only their own user and group quotas.

Filename completion characters

Filename completion characters are metacharacters that enable you to abbreviate filenames or directory names. This saves time and lets you process files selectively, even if you don’t know their full names or locations.

Commonly used filename completion characters are included in the table below.

Filename completion characters

The * character (asterisk) is the most frequently used file completion character. You can use the string b*, for example, to match all the filenames beginning with the letter “b”. You can also use multiple asterisks to define a file. For example, *xx*.gif retrieves any filename that contains “xx” anywhere in its name and that has the .gif extension.

The ? character (question mark) represents any single character, so the string ??? refers to all files with a three-letter name. This special character is more restrictive than the asterisk, because it requires the character to be present. For example, the code file?.txt signifies all files that begin with “file”, include one additional character, and have the .txt extension. So the filename “file1.txt” matches, but “file.txt” and “file01.txt” don’t.

Using [] characters (square brackets) allows for a more selective approach to retrieving files. The string [abc] will find files a, b, and c only. You can include a hyphen between characters inside the brackets to match a continuous range of characters. To specify the characters 0 through 9, for example, it is a lot easier and less time-consuming to type [0-9] rather than [0123456789]. If the brackets precede an asterisk, as in [0-9]*, filenames starting with any numbers between 0 and 9 are found. The pattern *[0-9] will match filenames ending with numbers between 0 and 9. Inserting an exclamation mark inside the brackets, as in [!b], will invert the pattern, matching any characters or ranges not specified in the brackets but ignoring those that are.

The $ (dollar sign) is used to identify shell variables at the command line. Variables are values that have been associated in memory with some kind of identifier. Variables have many uses in Linux. To give a simple example, a variable with the identifier PATH contains the list of directories within which the shell can search for executable files. To view this list, you invoke the following command:

echo $PATH

If you entered the command echo PATH, it would print the literal string “PATH”, rather than the value of the PATH variable, on your terminal.

The ~ character (tilde) enables you to refer quickly and easily to your home directory, no matter where in the file system you might be. Say that your current working directory is /usr/local/bin and you have a file called “usernames” in your own home directory, which you want to edit with vi. Rather than having to type the complete path to the file, you can just issue the command

vi ~/usernames

Quoting special characters

There are occasions when you might want to suppress the special meanings of metacharacters. A special character must be quoted in order to represent its own literal meaning rather than its special meaning to the shell. Quoting causes the shell to overlook the unique capabilities of special characters and negate parameter expansion. This mechanism uses the following quote symbols:

• \ (backslash)
• ” (double quotes)
• ‘ (single quotes)
• ` (backquote)

The backslash is also known as the bash shell escape character. This is because it turns off or “escapes” the special meaning of the character that follows it. For example, as we have already seen, the following command returns the value of the PATH environment variable:

echo $PATH

However, the following command will return the literal output “$PATH”, because the backslash negates the special meaning of the dollar sign:

echo \$PATH

If a line itself ends with a backslash, it acts as a continuation character for the line and the newline character is ignored.

Single quotes negate the translation of all special characters. They prevent the substitution of alternative values for the characters. For example, the following command will output a list of single-character filenames:

ls ?

However, this command will attempt to list the file with the literal name “?”:

ls ‘?’

Double quotes cause most metacharacter special meanings to be ignored. The exceptions to this rule are the dollar sign, backquote, and backslash. So double quotes have the effect of canceling the process of filename generation by the shell, but still allow the expansion of shell variables and command substitution. The dollar sign and backquote continue to function as special characters when included between double quotes. The backslash character only does so when it’s followed by a dollar sign, backquote, double quote, backslash, or a newline character. In these circumstances, the backslash itself is removed and the special meaning of the following character is ignored. This makes it possible to quote a double quote between double quotes if it is preceded by a backslash. For example, the commands echo”\”" or echo\” output a double quote character by suppressing the special meaning of the embedded double quote.

The backquote is still often used for command substitution, although the $() combination (a dollar sign and brackets) is generally preferred. The shell interprets the text between a pair of backquotes as a command before translating the rest of the command line. The output of the command replaces the original backquoted text.
In the following code, the double quotes disable the date command:

> echo “date”
date

However, the backquotes in this command enable command substitution to occur:

>echo ‘date’
Thu Jun 10 17:18:56 IST 2004

Advantages of using a shell

Greater control
A shell is a program that acts as an interface between the user and the operating system, just as a GUI does. However, a shell works without graphics – when you use one, you issue instructions to the operating system by typing in commands. In fact, the shell is often referred to as a command interpreter.

This may seem like a return to basic computing, but a command-line interface lets you exercise a degree of control over the operating system that would otherwise be lacking. There are a number of reasons for this:

• with a GUI, only the options provided by the interface are available to the user
• lack of space on a screen can limit the number of options that a GUI displays
• no standard methods exist within GUIs for performing standard command-line tasks, such as linking commands in sequences, redirecting output from one destination to another, or collecting commands into scripts

A disadvantage of using a command-line interface is that the user needs to learn a wide variety of sometimes cryptic commands and their associated options. However, the commands are more powerful and adaptable than their GUI counterparts, because they can be extended and fine-tuned through the use of options. An expert user of a command-line interface can issue complex commands very quickly. Techniques also exist to link multiple commands together with pipes and redirections, so that the output of one command becomes the input of another. Linux can interpret commands issued using the shell more quickly than GUI commands. This is because shell commands are nothing more than simple ASCII text. Some shells even enable you to define your own commands.

Automation of common tasks
A shell has another advantage over a GUI in that it keeps a history list of recently issued commands. This enables a user to step back and forth through this list, reusing commands at any point. In addition, a shell enables you to string commands together to form a shell script. These scripts work in a similar way to batch files, issuing multiple commands as one. You can use them to automate common tasks that would otherwise require you to issue several, consecutive commands.

Speed and efficiency
In hardware terms, a shell is a more attractive proposition than a GUI. Shells are much less resource-intensive than GUIs – they require less memory, for example. This means that a command issued in the shell will run more quickly and efficiently than the same command run in a GUI. It also means that a shell supports Linux’s multitasking environment, in which multiple tasks run simultaneously, more comfortably than a GUI, in which the GUI itself competes for CPU resources.

Shell evolution

Since its creation as a derivative of UNIX, Linux has given rise to a number of shells, which have evolved along with the operating system itself. When a new shell is developed, it doesn’t spell the end for all previous shells. Many different Linux shells are available, and each has particular strengths. The one you use depends on your own preferences and on the task you wish to undertake.

The default shell in most Linux installations is the Bourne Again shell, or /bin/bash. It is a successor to the Bourne shell, or /bin/sh, which was an early and less powerful Linux shell. The Bourne Again shell was created and is distributed by the Free Software Foundation. It offers features such as command-line editing and filename completion. It is an ideal first shell for Linux newcomers. In addition, bash supports the syntax used by another Linux shell called the C shell, or /bin/csh, which increases its flexibility.

You can find out which shell you’re running at any time by typing the command echo $SHELL at the shell prompt. The default shell is specified in the /etc/passwd file and can be changed there for each user.

Since we are talking about Linux here, you might want to know how to mount linux file system also understand on Linux File Types.

It is an important part of the role of the Linux system administrator to ensure that file systems are mounted correctly, whether at boot time or manually, to ensure that all required data is available at the expected locations.

Advantages of mounting Linux file systems and devices

Devices are mounted at predetermined directories below the root file system. These are usually, although not always, special directories created for the purpose. The file systems that belong under the /var, /home, and /usr directories, for example, are kept on separate partitions or devices from the root file system. Network machines are frequently configured so that the /home data for all machines is actually stored on a single Network File System (NFS) server, which is then mounted under the /home directory on each individual machine. This enables users to access their own home directories in the usual locations, regardless of which computers they are actually logged on at.

Because all devices and file systems appear below the root directory, the transition from one device or file system to another is entirely seamless. So a user can access a file on an NFS server over a network as though the file were on the local hard drive.

Linux makes it easy to expand the space available to overloaded file systems by mounting new partitions. For example, say the directory /home/project is filling up with so much data that it threatens to take over the hard drive on which it is stored. The system administrator can easily move the data from the existing /home/project to an empty disk partition with more available space, and remount the new partition at /home/project. To users, there won’t be a difference between the old configuration and the new one – they still access their files under /home/project, even though the files are now stored on a completely different hard drive.

It is important to mount file systems in the correct order. This is sometimes necessary to ensure that the mount point required by a given file system exists and is available when the mount command is issued. Taking the /home/project example again, the project data exists on one disk partition and all the remaining /home data is on another, including the /home/project directory under which the /home/project partition is to be mounted. Clearly, if an attempt is made to mount the /home/project partition before the /home partition, this will result in an error, as the /home/project directory doesn’t yet exist. The correct order is to mount the /home partition first, followed by the /home/project partition.

It is also important to be aware when mounting devices under a given directory that any files previously available under that directory will be hidden while the device is mounted. So any files that still remain in the /home/project directory of the /home partition will become invisible as soon as the /home/project partition is mounted in that directory. Furthermore, the disk space those files occupy will remain unavailable to the system until the project partition is unmounted. You should therefore check what already exists in a directory before you use it as the mount point for some other file system, to avoid duplicating files or wasting disk space.

File system mounting management

To assist in the management of file system mounting, a special directory called /mnt exists in most Linux distributions. This directory contains dedicated directories for mounting specific devices such as CD-ROM, floppy disk, and zip disk drives. This is a convenient way to ensure that such devices have a suitable mount point available to them at all times.

Removable media

It is impossible to access the data on removable media without mounting them first. To use a floppy disk drive, for example, you need to issue the mount command before the disk contents will be visible to the system.

Similarly, when you have finished using any kind of removable medium, it is very important to unmount the device using the umount command before removing the disk from the drive. This is because Linux improves efficiency by often storing information in memory buffers rather than writing it directly to the disk. If a removable disk is removed without being unmounted first, there is a high probability of data loss, just as there is from a hard drive if you shut down the system by turning off the power without running the proper shutdown procedure.

Linux uses four basic file types:

• ordinary files
• directories
• symbolic links
• block and character device files

You determine a file’s type by issuing the ls -l command and reading the first character of each row of the output.
The typical output of the ls command is as follows:

$ ls –l
total 8
-rw-r–r–     1 root   root       22 Oct  6 15:33 anormalfile
brw-rw—-     2 root   disk  41,   0 May  5 1998 blockdev
crw-rw-rw-     2 root   root   5,   0 May  5 1998 characterdev
drwxr-xr-x     2 root   root     4096 Oct  6 15:33 subdir
lrwxrwxrwx     1 root   root       11 Oct  6 15:35 symbolic -> anormalfile

Ordinary files begin with a dash (-), directories begin with d, symbolic links begin with the character l, block devices are prefaced with the character b, and character devices begin with the letter c.

Ordinary files
An ordinary file can consist of any kind of data, including executable programs. Most of the files in the Linux file system are of this type.

Directories
A directory is a file that contains other files and directories, and provides pointers to them.
It performs a similar function to a folder in a filing cabinet, in that it enables you to group related files in an organized fashion. However, whereas folders can normally contain files only, directories can contain additional directories, often referred to as subdirectories.

Symbolic links
A symbolic – or soft – link points to the name and location of a completely separate file. So when you open, copy, move or otherwise refer to the link, the operation is in fact performed on the referenced file. This distinction is usually invisible to the user. If the referenced file is removed or renamed, the link is broken and an error occurs if you try to open it.

You can also create hard links. A hard link points to the actual data in a file in exactly the same way as an ordinary file does. Therefore, other than the name, there is no difference between the original file and a hard link that points to the same data, and both can be regarded as ordinary files. You can distinguish a hard link from any other ordinary file only by the number of links that each one has. The number of links is displayed in the second field of an ls -l listing. If this number is greater than one, then you know there are additional hard links to the data.

Device files
All the physical devices that Linux uses are represented by device files.
Device files can be classified as character special or block special. Character-special files represent devices that interact with Linux on a character-by-character, or serial, basis. Printers and terminals are examples of this type of device. Block-special files represent devices such as hard or floppy disks and CD-ROMs, which interact with Linux using blocks of data.

All the device files are contained in the /dev directory – for example, the file associated with the system’s first floppy drive is /dev/fd0.

Device files are extremely powerful because they enable users to access hardware devices such as disk drives, modems, and printers as though they were data files. Therefore, you can move, copy, and transfer data between such devices easily, often without having to use special commands or syntax.

Filenames and pathnames

Every file is assigned a filename, which can be up to 256 characters long. This name can consist of a mixture of uppercase and lowercase letters, numbers, and certain punctuation marks such as the period, dash, or underscore.

Certain characters cannot be used in filenames. For example, you cannot use characters that represent a field separator – such as a comma – or other special characters that have particular meaning to the shell. The special characters that you cannot use are

! @ # $ % ^ & * ( ) [ ] { } ‘ ” \ / | ; < > ‘

Pathnames
You can navigate between directories on the command line using pathnames. To use pathnames, you must understand the directory structure of the Linux file system. The highest-level directory in the Linux file system is the root directory, which is represented by a forward slash (/). Located under the root directory are the top-level directories, followed by one or more subdirectory levels.

File structure of a Linux file system
You can move between directories using relative or absolute pathnames.

A relative pathname starts with your current directory. For example, if you want to change to the expenses directory from within your home directory, you enter

cd expenses

Relative pathnames can begin with the name of a file or directory, or with symbolic references to the current directory (.) or its parent directory (..), but never with a forward slash.

A simple example of a Linux file system
An absolute pathname shows the full pathname from the root directory (/). For example, the following command allows you to move from your current directory directly to the applic subdirectory in the usr directory that’s located under the root directory:

cd /usr/applic

Inodes, blocks, and special files

Inodes
Every file is assigned a unique inode number. An inode is a structure that defines the file’s location and attributes. You can check for a file’s inode number using the -i option with the ls command. You can view the information that a file’s inode contains using the stat filename syntax. This command output (the stat results) displays the information related to the “results” file’s inode.

$ stat results
File: ”results”
Size: 8
Filetype: Regular file
Mode: (0644/-rw-r–r–)
Uid: (     0/     root)
Gid: (     0/     root)
Device: 3,7    Inode: 123256    Links: 1
Access: Tue Jul 25 16:45:00 2000 (00072.18:31:07)
Modify: Thu Jul 20 12:35:20 2000 (00077.22:40:47)
Change: Thu Jul 20 12:35:20 2000 (00077.22:40:47)

In this example, some of the attributes that are displayed include the file type, file size, the owner’s User ID (UID), the number of hard links associated with it, and the file’s creation, access, and modification times.

An inode does not store a file’s name. Filenames are stored in directories with their associated inode numbers. In the example of the stat command, the name of the file is obtained from the filename parameter that you entered.

Blocks
In the Linux file system, files are stored in blocks, which are identically sized segments of disk space. Generally, the size of a block varies from 512 bytes to 32 KB, depending on the Linux installation. The maximum size of a file depends on the block size used in the file system. For example, the maximum file size for an ext2 file system is 2 GB if it uses 512-byte blocks.

Disk systems retrieve data in block-sized chunks, so the larger the block size the more efficient the access. The problem with creating large blocks is that it can waste disk space. For example, if the block size is 4 KB and most files contain only a few bytes of data, most of the 4096 bytes of disk space is wasted for each file. But if you make the block sizes small, disk access will be relatively less efficient.

Some commands, such as df, output disk information in 1 KB blocks, even if the installation stores files in a different block size. A simple way to check your system’s block size is to use the du command to display the disk usage. In this example, the disk usage for all files beginning with “m” is displayed.

$ du -h m*
36k mail
4.0k mail.rc
12k mailcap
12k mailcap.vga
4.0k man.config
4.0k mc.global
148k midi
40k mime-magic
104k mime-magic.dat
8.0k mime.types
4.0k minicom.users
0 motd
4.0k mtab

In this example, the du command output displays the file sizes on the disk in increments of the block size, which is 4.0 KB in this case. One exception to this rule is when zero is displayed, which indicates that the file is completely empty.

Special files
In addition to other file types, Linux makes use of special files, which are system-defined files that perform unique functions when accessed.

Special files and their functions

For example, if you need to get rid of unwanted output from a command, you can redirect the output to the /dev/null file. In this example, any errors generated by the find command are redirected from stderr to /dev/null.

$ find / -n myfile 2> /dev/null