MODULE-1 INTRODUCTION

TO UNIX
UNIX OPERATING SYSTEM
Summary of UNIX
UNIX is a groundbreaking operating system developed
in the 1970s by Ken Thompson, Dennis Ritchie, and
others at AT&T Bell Labs. It serves as the foundation
for many modern operating systems like Linux,
macOS, and POSIX-compliant systems. Initially
designed for developers, UNIX played a crucial role in
software development and computing environments.
Key Features:
 Multiuser & Multitasking: Supports multiple
users and simultaneous processes.
 Shell Scripting: Enables automation through
powerful command-line scripts.
 Security: Implements robust security models with
user permissions.
 Portability: Runs on various hardware platforms.
 Process Tracking & Communication: Manages
CPU usage, disk space, and supports inter-user
communication.
System Structure:
UNIX follows a layered architecture:
1. Hardware – The physical components.
 2. Kernel – The core of the system, managing
memory, files, and processes.
3. Shell – Acts as an interface between users and the
kernel, processing commands.
4. Application Layer – Executes external
applications.
UNIX vs. Linux:
 Linux is an open-source UNIX-like OS, whereas
UNIX is proprietary.
 Linux supports GUI and CLI, while traditional
UNIX is mostly CLI-based.
 Linux is more portable and flexible than UNIX.
Advantages of UNIX:
✅ Highly stable and secure
✅ Scalable and flexible for various computing needs
✅ Efficient command-line interface for advanced
users
Disadvantages of UNIX:
❌ Complex for beginners
❌ Costly in some versions
❌ Limited software availability and lack of
standardization across versions
Despite its learning curve, UNIX remains widely used in
enterprise computing, scientific research, and
web servers, influencing modern OS development
significantly. 🚀
UNIX ARCHITECTURE
Well, we know that Unix is an Operating System. Like
any other Operating System, Unix also acts as an
interface between the user and the hardware, i.e. the
user and the computer itself. Unix mainly focuses on
the concept of Kernel and Shell division of an Operating
System due to which it is so powerful.
 Kernel: The kernel is a program in the Operating
System software that keeps on running in the
background when the machine is on and it is
responsible for allocating the resources to the
processes, handling and coordinating the multiple
processes running together.
 Shell: However, since the kernel is such an
essential program in the Operating System and
performs almost all of the major tasks, it should
not be directly accessible to the user. So, there is a
program between the user and the kernel that
helps the user interact with the kernel. This
program is called the shell.
The Unix architecture has 4 layers. These layers are as
shown below:
Hardware: Hardware is the most simple and least
powerful layer in the Unix Architecture. Hardware is the
components that are humanly visible. Whatever
hardware is connected to a Unix operating system-
based machine, comes in the hardware layer.
Kernel: This is the most powerful layer of the Unix
architecture. The kernel is responsible for acting as an
interface between the user and the hardware for the
effective utilization of the hardware. The kernel handles
the hardware effectively by using the device drivers.
The kernel is also responsible for process management.
So, the main 2 features of the kernel are process
management and file management.
 Process Management: The processes that execute
within the operating system require a lot of
management in terms of memory being allocated
to them, the resource allocation to the process,
 process synchronization, etc. All this is done by the
Kernel in Unix OS. This is done using various
Operating System Techniques like paging, framing,
virtual memory, swapping, context-switching, etc.
 File Management: File management involves
managing the data stored in the files. This also
includes the transmission of data stored in these
files to the processes as and when they request it.
Shell: We understood the importance of the kernel and
that it handles most of the important and complex
tasks of Unix OS. Since the kernel is such an important
program of the Unix Operating System, its direct access
to the users can be dangerous. Hence, the Shell comes
into the picture. Shell is an interpreter program that
interprets the commands entered by the user and then
sends the requests to the kernel to execute those
commands. When the execution of the process is
completed, the shell again sends a request to the
kernel to display the program/information on the screen
to the user. So, Kernel is an interface between the user
and the hardware and the Shell is an interface between
the user and the Kernel. The shell can be used for
opening a file, writing into the files, executing
programs, etc. There are 3 types of shells in the Unix
Operating system.
  Bourne Shell (sh): It is the most widely available
shell on Unix OS devices across the world. This was
the first shell available in the Unix OS. It is simply
called a shell.
 C Shell (csh): The University of California (Berkeley)
developed C Shell is another Unix shell that
removes some of the obsolete features or
problems from the Bourne Shell. So, it enhances
the performance of the Bourne Shell.
 Korn Shell (ksh): The name of the Korn Shell is
based on its creator, David Korn. This shell
enhances the C shell further by removing the
shortcomings of the C shell and also enhancing the
user interaction of the Bourne Shell.
Applications/Application Programs: The last layer of the
Unix architecture is the Application Program layer. As
the name suggests, this outermost layer of Unix
Architecture is responsible for executing the application
programs.
In Unix, files and processes are core concepts. Here's a
simple overview:

1. Files in Unix
  Everything in Unix is treated as a file: documents,
directories, hardware devices, and even running
processes (through /proc).
 Files are organized in a single hierarchical directory
structure (starting from /, the root).
Types of Files:
 Regular files: text files, images, binaries, etc.
 Directories: folders that contain other files.
 Special files:
o Character device files (e.g., keyboard input)
o Block device files (e.g., hard drives)
 Links:
o Hard links: multiple directory entries point to
the same inode.
o Symbolic links (symlinks): like shortcuts.
 Sockets and named pipes: used for inter-process
communication (IPC).
Important file commands:
 ls — list files
 cat, less, more — view contents
 cp, mv, rm — copy, move, remove
 chmod, chown — change permissions and
ownership

2. Processes in Unix
  A process is an instance of a running program.
 Each process has a unique Process ID (PID).
 Processes can spawn child processes (parent and
child relationship).
States of a Process:
 Running: currently executing.
 Sleeping: waiting for some event (like input).
 Stopped: process is halted.
 Zombie: completed execution but still has an entry
in the process table.
Important process commands:
 ps — view currently running processes.
 top — dynamic real-time view of system processes.
 kill PID — send a signal to a process (default is
SIGTERM to terminate).
 kill -9 PID — forcefully kill a process (SIGKILL).
 nice, renice — change the priority of a process.
 bg, fg, jobs — manage background and foreground
jobs.

3. Relationship Between Files and Processes

 Processes interact heavily with files.
 Processes open files, read from or write to them.
 File Descriptors are used internally:
o 0 → Standard Input (stdin)
 o 1 → Standard Output (stdout)
o 2 → Standard Error (stderr)
 Processes inherit file descriptors from their parent
processes.

SYSTEM CALLS
The interface between a process and an operating
system is provided by system calls. In general, system
calls are available as assembly language instructions.
They are also included in the manuals used by the
assembly level programmers.
Unix System Calls
System calls in Unix are used for file system control,
process control, interprocess communication etc.
Access to the Unix kernel is only available through
these system calls. Generally, system calls are similar
to function calls, the only difference is that they remove
the control from the user process.
There are around 80 system calls in the Unix interface
currently. Details about some of the important ones are
given as follows -

System
Description
Call

This checks if a calling process has access to

access()
the required file

chdir() The chdir command changes the current

System
Description
Call

directory of the system

The mode of a file can be changed using this

chmod()
command

chown() This changes the ownership of a particular file

This system call sends kill signal to one or more

kill()
processes

A new file name is linked to an existing file

link()
using link system call.

This opens a file for the reading or writing

open()
process

The pause call suspends a file until a particular

pause()
signal occurs.

stime() This system call sets the correct time.

times() Gets the parent and child process times

The alarm system call sets the alarm clock of a

alarm()
process

fork() A new process is created using this command

chroot() This changes the root directory of a file.

System
Description
Call

exit() The exit system call is used to exit a process.

Features of unix
1. Multiuser System
 Many users can work at the same time.
 Resources (CPU, memory) are shared fairly.
2. Multitasking System
 One user can run many tasks together.
 Switch between tasks or run them in the
background.
3. Building-Block Approach
 Small, simple commands that do one job well.
 Commands can be combined using pipes (|).
4. UNIX Toolkit
 Collection of powerful tools: text editors, compilers,
network programs, admin tools.
5. Pattern Matching
 Special symbols (*, ?) to match file names.
 Regular expressions for advanced search.
6. Programming Facility
 Shell is both a command interpreter and a
programming language.
  You can write shell scripts to automate tasks.
7. Documentation
 man command gives help on any command.
 Tons of resources and FAQs available online.
8. Portable
 Easily runs on different types of hardware.
9. Command-Line Interface (CLI)
 Powerful text-based control through shells (like
bash, sh).
10. File System
 Organized in a hierarchical (tree-like) structure,
starting from / (root).
11. Networking
 Built-in strong support for networking (great for
servers).
12. Security
 Strong security with permissions and access
controls.
13. Open Source
 Many UNIX versions are open-source and freely
available.
14. Scalable
 Can work on small devices and huge data centers.

POSIX
What is POSIX?
POSIX stands for Portable Operating System
Interface.
It is not an operating system itself — it's a
standard.
POSIX defines rules and guidelines for how an
operating system (like UNIX) should behave so
that programs written for one system can work
on others without needing major changes.

Why POSIX Exists

 In the 1980s, many UNIX versions (like BSD,
System V, etc.) were a little different.
 Software written for one version of UNIX
often did not work on another.
 POSIX was created to standardize UNIX
behavior so programs could be portable
(easily moved from one UNIX to another).

What POSIX Covers

 System calls (how programs ask the OS for
things, like reading a file)
 Command-line utilities (like ls, cp, mv)
 Shell scripting standards
  Programming APIs (functions like fork(),
exec(), read(), etc.)

Examples of POSIX-Compliant Systems

 Linux
 macOS
 Solaris
 AIX
 FreeBSD
(Windows is not POSIX-compliant by default, but
tools like Cygwin can add a POSIX environment.)

In Short:
👉 POSIX = Set of rules that make sure UNIX-like
systems behave similarly, helping software run
across different platforms.
SINGLE UNIX SPECIFICATIONS
What is the Single UNIX Specification
(SUS)?
The Single UNIX Specification (SUS) is a
standard that defines what it means to be a
"real" UNIX operating system.
It is based on POSIX, but is broader and
stricter.
It ensures that software can run across
different UNIX systems without needing to be
rewritten.

Why was SUS Created?

 In the 1990s, many UNIX versions (Solaris,
HP-UX, AIX, etc.) had differences.
 Developers wanted one common standard.
 SUS was created by a group called The
Open Group to unify UNIX systems.

Main Parts of SUS

It defines four major areas:
Area What it Covers
Base Terms, concepts, and
Definitions conventions.
System System calls and libraries (fork(),
Interfaces read(), etc.).
Shell & Standard shell behavior (like sh)
Utilities and commands (ls, cp, etc.).
Networking Network-related programming
Services (e.g., sockets).

What Happens if a System Follows SUS?

  If an operating system meets all the SUS
rules, it can be officially called "UNIX®".
 Example of certified UNIX systems:
o IBM AIX
o HP-UX
o Oracle Solaris
(Linux is POSIX-compliant but not officially
UNIX® certified.)

SUS and POSIX — Quick Comparison

Aspect POSIX SUS
Basic standards Broader, more
Scope
(mainly APIs) detailed, stricter
Owner IEEE The Open Group
Certificatio No official UNIX Can officially call
n title system "UNIX®"

In Short:
👉 SUS = The official standard that defines what
UNIX really is.
👉 POSIX = A part of SUS focused on portability.
INTERNAL AND EXTERNAL COMMANDS
Internal vs External Commands in UNIX
Internal Commands
  These are built into the shell itself (like
bash, sh).
 When you run them, the shell executes
them directly — no separate file is
needed.
 They are faster because no separate process
is created.
 Examples:
o cd — change directory
o pwd — print working directory
o echo — display text
o exit — close the shell
o set, unset, export — environment control
➡ Internal commands = Part of the shell
program itself.

External Commands
 These are separate executable files stored
on disk.
 When you run them, the shell finds and
starts a new process to execute them.
 They are usually located in system directories
like /bin, /usr/bin, /usr/local/bin.
 Examples:
 o ls — list files
o cp — copy files
o mv — move files
o cat — view file contents
o grep — search text
o chmod — change file permissions
➡ External commands = Separate files
stored outside the shell.

Quick Summary Table

Internal External
Feature
Command Command
Stored as files (e.g.,
Location Built into the shell
/bin/ls)
Faster (no new Slower (starts a
Speed
process) new process)
Examples cd, pwd, echo ls, cat, grep
Modificatio Change by Change by
n modifying shell modifying file

How to Check?
 Internal: Use help <command> → if it shows
help, it's internal.
  External: Use which <command> → if it
shows a file path, it's external.
Example:
$ help cd # shows help → internal
$ which ls # shows /bin/ls → external

In Short:
👉 Internal = Built into shell, fast.
👉 External = Separate program, starts a new
process.
UTILITIES OF UNIX
The image you shared lists some important
UNIX utilities. Here's a clean and simple
version for you:

Common Utilities in UNIX

Utilit
Purpose
y
cal Shows a calendar.
date Displays the system date and time.
echo Displays a message or text.
bc Acts as a calculator (basic calculator tool).
Utilit
Purpose
y
passw
Changes a user's password.
d
who Shows who is currently logged in.
unam Displays system information (like OS
e name).
Shows the file name of the terminal
tty
connected to standard input.

In Short:
These are simple command-line tools that
make system tasks easy!

MODULE-2 UNIX FILE

SYSTEM
File System:
The Unix File System is a hierarchical structure
used to organize and store files and directories
efficiently. At the top is the root directory (/), from
which all files and directories descend.
Everything in Unix, including hardware devices, is
treated as a file. Devices are represented as
special files in the /dev directory, categorized as
either block or character special files. Each file
has a unique inode and can be accessed via
system calls using unique pathnames. The
system also supports symbolic links for flexible
file organization and uses permissions to manage
file access. Its robust, tree-like structure makes it
fundamental to Unix-based operating systems
and essential knowledge for system navigation
and management.
File on Unix Operating System:
 In Unix everything is treated as a file, even
devices are also treated as a special file.
 All devices are represented by files called
special files that are located in/dev directory.
 These are access in the same way as regular
file.
 Device files has two category: 1)Block Special
File , 2) Character Special File
 In Block Special File data gets transfer in
terms of block. So it has characteristics
similar to disk.
 In Character Special File data gets transfer by
stream of bits in sequential order like
keyboard.
 Every file on a Unix System has a Unique
Inode.
 Processes access files by well defined set of
system call.
  Files can be specifies by a character string
called as path name.
 Each Pathname is unique and it is converted
to an Inode.

Types of File:
The UNIX files system contains several different
types of files
Ordinary Files
An ordinary file is a file on the system that
contains data, text, or program instructions.
 Used to store your information, such as some
text you have written or an image you have
drawn. This is the type of file that you usually
work with.
 Always located within/under a directory file.
 Do not contain other files.
 In long-format output of ls -l, this type of file
is specified by the “-” symbol.
Directories
Directories store both special and ordinary files.
For users familiar with Windows or Mac OS, UNIX
directories are equivalent to folders. A directory
file contains an entry for every file and
subdirectory that it houses. If you have 10 files in
a directory, there will be 10 entries in the
directory. Each entry has two components. (1)
The Filename (2) A unique identification number
for the file or directory (called the inode number)
 Branching points in the hierarchical tree.
 Used to organize groups of files.
 May contain ordinary files, special files or
other directories.
 Never contain “real” information which you
would work with (such as text). Basically, just
used for organizing files.
 All files are descendants of the root directory,
( named / ) located at the top of the tree.
In long-format output of ls –l , this type of file is
specified by the “d” symbol.
Special Files
Used to represent a real physical device such as
a printer, tape drive or terminal, used for
Input/Output (I/O) operations. Device or special
files are used for device Input/Output(I/O) on
UNIX and Linux systems. They appear in a file
system just like an ordinary file or a directory. On
UNIX systems there are two flavors of special
files for each device, character special files and
block special files :
  When a character special file is used for
device Input/Output(I/O), data is transferred
one character at a time. This type of access
is called raw device access.
 When a block special file is used for device
Input/Output(I/O), data is transferred in large
fixed-size blocks. This type of access is called
block device access.
For terminal devices, it’s one character at a time.
For disk devices though, raw access means
reading or writing in whole chunks of data –
blocks, which are native to your disk.
 In long-format output of ls -l, character
special files are marked by the “c” symbol.
 In long-format output of ls -l, block special
files are marked by the “b” symbol.
Pipes
UNIX allows you to link commands together using
a pipe. The pipe acts a temporary file which only
exists to hold data from one command until it is
read by another.A Unix pipe provides a one-way
flow of data.The output or result of the first
command sequence is used as the input to the
second command sequence. To make a pipe, put
a vertical bar (|) on the command line between
two commands.For example: who | wc -l In long-
format output of ls –l , named pipes are marked
by the “p” symbol.
Sockets
A Unix socket (or Inter-process communication
socket) is a special file which allows for advanced
inter-process communication. A Unix Socket is
used in a client-server application framework. In
essence, it is a stream of data, very similar to
network stream (and network sockets), but all the
transactions are local to the filesystem. In long-
format output of ls -l, Unix sockets are marked by
“s” symbol.
Symbolic Link
Symbolic link is used for referencing some other
file of the file system.Symbolic link is also known
as Soft link. It contains a text form of the path to
the file it references. To an end user, symbolic
link will appear to have its own name, but when
you try reading or writing data to this file, it will
instead reference these operations to the file it
points to. If we delete the soft link itself , the data
file would still be there.If we delete the source file
or move it to a different location, symbolic file
will not function properly. In long-format output of
ls –l , Symbolic link are marked by the “l” symbol
(that’s a lower case L).
File Naming Conventions:
Here are the file naming conventions in Unix:

1. Case Sensitivity
 File names in Unix are case-sensitive.
o Example: File.txt, file.txt, and FILE.TXT
are all different files.

2. No Extension Requirement
 Unix does not require file extensions,
though they are often used for convenience.
o Example: A shell script can be named
script, script.sh, or even myscript.

3. Allowed Characters
 Most characters are allowed, except the
forward slash / (used as a directory
separator) and the null character (\0).
o Avoid using special characters like *, ?, |,
<, >, &, etc., as they have special
meanings in the shell.

4. Hidden Files
 Files beginning with a dot (.) are hidden
files.
o Example: .bashrc, .gitignore
5. Length Limits
 File names can be up to 255 characters
long (varies by file system).
 Full path length is typically limited to 4096
characters.

6. Naming Best Practices

 Use lowercase letters, underscores, or
hyphens for readability.
o Example: my_file.txt or my-file.txt
 Avoid spaces; if necessary, use quotes or
escape characters.
Parent Child Relationship:
In UNIX (and UNIX-like systems), the parent-child
relationship refers to how processes are organized
and created.

🔧 How It Works:
1.Process Creation via fork():
o In UNIX, when a process wants to create
another process, it uses the fork() system
call.
o The original process is called the parent.
 o The newly created process is the child.
2.Child Process:
o The child is a copy of the parent at the
time of creation (same code, data, and
open files).
o It gets a unique process ID (PID).
o It may be programmed to replace itself
with a different executable using exec().
3.Process IDs:
o Each process has:
 PID – its unique identifier.
 PPID – parent process ID.
4.Tracking:
o The shell (like Bash) acts as a parent to the
commands you run.
o Use ps -ef or pstree to see relationships
🧩 Key Points:
Concept Description
fork() Creates a new child process
Replaces current process image with
exec()
a new one
getpid() Returns current process ID
getppid() Returns parent process ID
Concept Description

wait() /
Parent waits for child to finish
waitpid()

🧹 Zombie and Orphan Processes:

 Zombie: Child ends but parent hasn’t called
wait() → entry lingers in the process table.
 Orphan: Parent exits before the child → child is
re-parented to init (PID 1).

Home Variable
In UNIX and Linux systems, the HOME environment
variable represents the path to the current
user's home directory.

📌 Purpose of HOME:
 Stores the default directory where a user is
taken after logging in.
 It is used by many applications and scripts as
the default location for personal files and
configuration settings.
  Commands like cd without arguments use
$HOME.
Common Use Cases:
Command Description
Takes you to the home directory
cd
(same as cd $HOME)
cd ~ Shortcut to go to the home directory
echo $HOME Displays the home directory path
cp file.txt
Copies file.txt to your home directory
$HOME/

Inode Number
What is an inode?
An inode is a file data structure that stores
information about any Linux file except its name
and data.
What are inodes used for?
Data is stored on your disk in the form of fixed-size
blocks. If you save a file that exceeds a standard
block, your computer will find the next available
segment on which to store the rest of your file.
Over time, that can get super confusing.
That’s where inodes come in. While they don’t
contain any of the file’s actual data, it stores the
file’s metadata, including all the storage blocks on
which the file’s data can be found.
Information contained in an inode:
 File size
 Device on which the file is stored
 User and group IDs associated with the file
 Permissions needed to access the file
 Creation, read, and write timestamps
 Location of the data (though not the filepath)
Inodes are also independent of filenames. That
means you can copy a single file, rename it, and
still have it point to the same inode as the original.
Absolute and Relative Path
In Unix and Linux systems, paths define the
location of files and directories within the
filesystem. They are crucial for navigating and
managing files efficiently. Paths can be classified
into two types: absolute paths and relative
paths. Let us have a better look in these paths.
What is an Absolute Path?
An absolute path is a full path that specifies the
location of a file or directory from the root directory
(‘/’). It provides a complete address that points
directly to a file or directory, regardless of the
current working directory. This path type always
begins with the root directory, followed by
subdirectories, and ends with the desired file or
directory name.
Characteristics of Absolute Paths:
 Starts with a slash (/).
 Specifies a file location from the root directory.
 Does not depend on the current directory.
For Example:
If you want to access a file named ‘abc.sql’ located
in the directory ‘/home/kt’, you would use the
following command:
$cat abc.sql
This command will work only if the
file “abc.sql” exists in your current directory.
However, if this file is not present in your working
directory and is present somewhere else say in
/home/kt , then this command will work only if you
will use it like shown below:
cat /home/kt/abc.sql
In the above example, if the first character of a
pathname is ‘/’, the file’s location must be
determined with respect to root. When you have
more than one / in a pathname, for each such /,
you have to descend one level in the file system
like in the above ‘kt’ is one level below home, and
thus two levels below root.
What is a Relative Path?
A relative path specifies the location of a file or
directory in relation to the current working
directory (often abbreviated as pwd). It does not
start with a slash (‘/’), and it utilizes navigational
shortcuts to refer to the file or directory.
Characteristics of Relative Paths:
 Does not begin with a slash (‘/’).
 Dependent on the current directory.
 Utilizes shortcuts like ‘.’ (current directory) and
‘..’ (parent directory) to navigate the
filesystem.
Using . and .. in Relative Path-names
UNIX offers a shortcut in the relative pathname–
that uses either the current or parent directory as
reference and specifies the path relative to it. A
relative path-name uses one of these cryptic
symbols:
 . (Dot): Represents the current directory.
 .. (Double Dots): Represents the parent
directory.
Now, what this actually means is that if we are
currently in directory ‘/home/kt/abc’ and now you
can use ‘..’ as an argument to ‘cd’ to move to the
parent directory /home/kt as :
$pwd
/home/kt/abc
$cd .. ***moves one level up***
$pwd
/home/kt
Note: Now ‘/ ‘ when used with ‘..’ has a different
meaning; instead of moving down a level, it moves
one level up:
$pwd
/home/kt/abc ***moves two level up***
$cd ../..
$pwd
/home
Example of Absolute and Relative Path
Suppose you are currently located in ‘home/kt’ and
you want to change your directory to
‘home/kt/abc’. Let’s see both the absolute and
relative path concepts to do this:
1. Changing directory with relative path
concept:
$pwd
/home/kt
$cd abc
$pwd
/home/kt/abc
2. Changing directory with absolute path
concept:
$pwd
/home/kt
$cd /home/kt/abc
$pwd
/home/kt/abc

Significanceof dot(.)anddotdot(..)
In computing, particularly in Unix-like operating
systems, a dot (.) refers to the current directory
and dotdot (..) refers to the parent
directory.27 These entries are automatically
created in every directory except the root
directory, and they are used to navigate the file
system.27 For example, if your directory
is /Users/Bob, then . refers
to /Users/Bob and .. refers to /Users.2
In programming, these special directories are often
not included in directory listings when they are not
needed for the specific task at hand. This can be
achieved by including QDir::NoDotAndDotDot in
the filter.2
The use of dot and dotdot is universal in
programming and computers in general.2
In file systems like FAT and NTFS, dot and dotdot
entries are created for every non-root directory,
although the exFAT specification does not provide
for them, Microsoft's implementation of exFAT still
returns these entries when listing non-root
directories.23
In summary, dot and dotdot are special directory
entries used for navigation and are present in most
file systems and directory structures.
Displaying pathname of the
current directory (pwd)
The ‘pwd,’ which stands for “print working
directory.” In this article, we will delve into the
‘pwd’ command, exploring its functionality, usage,
and various examples. It prints the path of the
working directory, starting from the root. pwd is
shell built-in command(pwd) or an actual
binary(/bin/pwd). $PWD is an environment
variable that stores the path of the current
directory. This command has two flags.
Syntax of `pwd` command in Linux
The basic syntax of the ‘pwd’ command is
pwd [OPTIONS]
This command doesn’t have any arguments or
options, but it can accept flags for specific
behavior.
Flags For Specific behavior in `pwd`
command in Linux.
 The “-L” flag resolves symbolic links and prints
the path of the target directory.
 The default behavior of the shell built-in “pwd”
is equivalent to using “pwd -L”.
 Mention the “-P” flag, which displays the actual
path without resolving symbolic links.
  The default behavior of the binary “/bin/pwd” is
the same as using “pwd -P”
pwd -L: Prints the symbolic path.
pwd -P: Prints the actual path.
How to Display the Current Working Directory
in Linux
1. Displaying the Current Working Directory
Using Built-in pwd (pwd):
To print the current working directory, simply enter:

Display the Current Working Directory

The output will be the absolute path of your current
location in the file system.
In the given example the directory
/home/shital/logs/ is a symbolic link for a target
directory /var/logs/
2. Displaying the Current Working Directory
Using Binary pwd (/bin/pwd):
Display the Current Working Directory
The default behavior of Built-in pwd is the same as
pwd -L. Using “pwd -L” to obtain the symbolic path
of a directory containing a symbolic link.
The default behavior of /bin/pwd is the same as
pwd -P. Utilizing “pwd -P” to display the actual
path, ignoring symbolic links.
3. The $PWD Environment variable.
The $PWD environment variable is a dynamic
variable that stores the path of the current working
directory. It holds the same value as ‘pwd -L’ –
representing the symbolic path.

$PWD
Executing this command prints the symbolic path
stored in the $PWD environment variable
Changing the current
directory(cd)
Cd is the abbreviation or synonym for chdir. It is a
command found inside the Windows Command
Processor (cmd) that allows for change of the
current working directory of a shell instance. The
CWD (Current Working Directory) is a path (of a
directory) inside the file system, where the shell is
currently working. The current working directory is
essential for resolving relative paths. Cd is a
generic command found in the Command
Interpreter of most operating systems.
Description of the Command :
Displays the name of or changes the current
directory.
CHDIR [/D] [drive:][path]
CHDIR [..]
CD [/D] [drive:][path]
CD [..]

.. Specifies that you want to change to the parent

directory.
Type CD drive: to display the current directory in
the specified drive.
Type CD without parameters to display the current
drive and directory.
Use the /D switch to change the current drive in
addition to changing the current directory for a
drive.
 Some of the output is truncated due to its large
length.
 In order to obtain the above text execute
the cd /? command on cmd.
 It should be noted that chdir is an alias for cd,
and therefore can be replaced for all of its
occurrences.
Using the Command :
1.Displaying the Current Working Directory :
Displaying the current working directory is not
generally not required on cmd. This is because
the default prompt in cmd displays the Current
drive and path (CWD) along with the greater
than sign ( > ) at all times ($P$G code). But for
the sake of completeness, we would be
describing it as well. To display the Current
Working Directory, execute the cd command
without any arguments.
Syntax :
cd
Apparent from the above output, it is not necessary
for us to print the cwd as it is already being
displayed by the prompt.

Make directory(mkdir)
To create a directory in Linux or Unix, you can use
the mkdir command followed by the name of the
directory you want to create. For example, to
create a new directory called newdir, you would
run the following command:
mkdir newdir
You can also create multiple directories at once by
specifying their names as arguments separated by
spaces. For instance:
mkdir dir1 dir2 dir3
To create a directory and its parent directories if
they do not exist, use the -p option:
mkdir -p
Music/{Jazz/Blues,Folk,Disco,Rock/{Gothic,Punk,Pro
gressive},Classical/Baroque/Early}
To set specific permissions for the new directory,
use the -m option followed by the desired
permissions. For example, to create a directory
with 700 permissions, which means only the user
who created the directory can access it, you would
run:
mkdir -m 700 newdir
When the -m option is not used, the newly created
directories usually have either 775 or 755
permissions, depending on the umask value.
To display a message for each created directory,
use the -v option:
mkdir -v newdir

Remove directories(rmdir)
To remove directories in Linux, you can use
the rmdir and rm commands. The rmdir command
is used to remove empty directories only. If you
need to remove a non-empty directory, you should
use the rm command with the -r option, which
stands for recursive deletion.15
The rmdir command syntax is simple and does not
require additional options for empty directories.
However, if you want to remove a directory and its
parent directories if they are empty, you can use
the -p option.1
For the rm command, the -r option is used to
remove directories and their contents recursively.
The -f option forces the removal without prompting
for confirmation, and the -i option prompts for
confirmation before each removal.15
In Windows, the rmdir or rd command is used to
remove directories. To remove a directory tree,
including subdirectories and files, you can use
the /s option. The /q option specifies quiet mode,
which does not prompt for confirmation when
deleting a directory tree.2
It's important to be cautious when using these
commands, as they permanently remove
directories and files without moving them to a
trash or recycle bin.5
 rmdir: Removes empty directories only.
 rm: Removes files and directories, including
non-empty directories with the -r option.

Listing contents of directory(ls)

The ls command in Linux is used to list files and
directories. By default, when used without any
options or arguments, it lists the names of all files
in the current working directory.34
To list the contents of a specific directory, you can
pass the directory path as an argument to
the ls command.3 For example, to list the contents
of the /etc directory, you would type ls /etc.
The -l option lists files in a long format, providing
detailed information such as file type, permissions,
owner, group, size, and modification date.13
The -a option lists all files, including hidden files
(those starting with a dot).1
Using -al or -la lists all files in long format.1
To sort the output by different criteria such as
extension, size, or time, you can use the --
sort option. For example, to sort by modification
time in reverse order, you would use ls -lt.3
To list only directories, you can use ls -d */.

Very brief idea about important

file systems of UNIX
1. /bin – Essential User Binaries
 Basic Linux commands available to all users.
 Needed for booting and single-user mode.
 Examples: ls, cp, mv, rm.

2. /usr/bin – Non-Essential User Binaries

 Applications and utilities for general use.
 Not required for system boot.
 Examples: python, gcc, vim.
3. /sbin – System Binaries
 System administration tools for root.
 Used for booting, repairing, or configuring the
system.
 Examples: fsck, ifconfig, reboot.

4. /usr/sbin – Non-Essential System Binaries

 Additional system tools and daemons for
administration.
 Typically used by superuser.
 Examples: sshd, apache2, useradd.

5. /etc – Configuration Files

 System-wide config files and startup scripts.
 No binaries stored here.
 Examples: /etc/passwd, /etc/hosts, /etc/fstab.

6. /dev – Device Files

 Represents hardware and virtual devices as
files.
 Examples: /dev/sda (hard disk), /dev/null.

7. /lib – Shared Libraries

  Essential libraries for binaries in /bin and
/sbin.
 Examples: libc.so, kernel modules.

8. /usr/lib – Application Libraries

 Libraries used by programs in /usr/bin and
/usr/sbin.
 Not needed for boot.

9. /usr/include – Header Files

 C/C++ programming header files.
 Used for compiling software.
 Examples: stdio.h, stdlib.h.

10. /usr/share/man – Manual Pages

 Documentation files (man pages).
 Accessed via man command.
 Organized into sections (man1, man5, etc).

11. /tmp – Temporary Files

 Temporary storage for programs.
 Often cleared on reboot.
 Writable by all users.
12. /var – Variable Data
 Stores log files, mail, print spool, temp data.
 Examples: /var/log, /var/mail.

13. /home – User Home Directories

 Personal directories for each user.
 Stores user files, configs, downloads.
 Example: /home/alice, /home/bob.

MODULE-3 ORDINARY FILE

HANDLING
Displaying and creating files
(cat)

In UNIX, the cat (short for concatenate)

command is used to display, create, and
combine files. Here's how it works for each of
those tasks:

🔹 1. Displaying a File
To display the contents of a file in the terminal:
cat filename.txt
✅ This shows the content of filename.txt on the
screen.

🔹 2. Creating a File
You can use cat to create a new file:
cat > newfile.txt
Then type the content you want to include. Press
CTRL + D to save and exit.
Example:
cat > hello.txt
This is a new file.
CTRL + D

🔹 3. Appending to a File
To append new content to an existing file:
cat >> existingfile.txt
Type your new content, and press CTRL + D when
done.

🔹 4. Concatenating Multiple Files

To combine several files into one:
cat file1.txt file2.txt > combined.txt
This merges file1.txt and file2.txt into
combined.txt.

🔹 Tips
 Use cat -n filename.txt to display line
numbers.
 Use cat with more or less for long files: cat
filename.txt | less.

Copying a file (cp)

In UNIX, the cp command is used to copy files
and directories. Here's how to use it:

🔹 Basic Syntax
cp [options] source destination

✅ Examples
1. Copy a File
cp file1.txt file2.txt
This copies file1.txt to a new file named file2.txt.
If file2.txt already exists, it will be overwritten
without warning (unless options are used).

2. Copy a File to a Directory

cp file.txt /path/to/directory/
This copies file.txt into the specified directory.

3. Copy a Directory (Recursively)

cp -r dir1/ dir2/
This copies the entire contents of dir1 into dir2. If
dir2 doesn’t exist, it will be created.

4. Prompt Before Overwriting

cp -i file1.txt file2.txt
The -i (interactive) option prompts you before
overwriting file2.txt.

5. Copy with Verbose Output

cp -v file1.txt file2.txt
The -v option shows what is being copied.

🔹 Common Options
Optio
Description
n
-i Prompt before overwrite
-r Copy directories recursively
-v Verbose (show files being
Optio
Description
n
copied)
-u Copy only if source is newer

Deleting a file(rm)
In UNIX, the rm command is used to delete
(remove) files and directories.

🔹 Basic Syntax
rm [options] filename

✅ Examples
1. Delete a File
rm file.txt
This removes file.txt permanently — no recycle
bin!

2. Delete Multiple Files

rm file1.txt file2.txt file3.txt
Deletes all the listed files.
3. Prompt Before Deleting
rm -i file.txt
Asks for confirmation before deleting.

4. Force Delete Without Prompting

rm -f file.txt
Deletes the file without confirmation, even if it’s
write-protected.

5. Delete a Directory and Its Contents

rm -r myfolder/
Deletes the directory myfolder and everything
inside it recursively.

6. Force Delete a Directory

rm -rf myfolder/
Deletes a directory and its contents forcefully
and recursively — use with caution!

⚠️Be Careful!
 rm does not move files to trash — once
deleted, recovery is difficult.
 Always double-check file names, especially
with -f or -r.
Renaming / moving a file(mv)
In UNIX, the mv command is used to rename or
move files and directories.

🔹 Basic Syntax
mv [options] source destination

✅ Examples
1. Rename a File
mv oldname.txt newname.txt
This renames oldname.txt to newname.txt.

2. Move a File to a Directory

mv file.txt /path/to/directory/
Moves file.txt into the specified directory.

3. Rename or Move a Directory

mv olddir newdir
Renames the directory olddir to newdir.
4. Prompt Before Overwriting
mv -i file1.txt file2.txt
Prompts before overwriting file2.txt if it exists.

5. Verbose Output
mv -v file1.txt file2.txt
Shows what’s being moved or renamed.

🔹 Common Options
Optio
Description
n
-i Prompt before overwriting
-f Force move, no prompt
Verbose (show what's
-v
happening)

⚠️Notes:
 If the destination is a file that already
exists, mv will overwrite it without warning,
unless you use -i.
 mv can both move and rename in one
step.

Paging output (more)

In UNIX, the more command is used to page
through long text output one screen at a
time, making it easier to read large files or long
command results.

🔹 Basic Syntax
more filename
This displays the contents of filename page-by-
page.

✅ Examples
1. Read a Long File
more longfile.txt
Shows the file one screen at a time. Press:
 Space → Next page
 Enter → Next line
 q → Quit
 /pattern → Search forward for a pattern

2. Use with Other Commands

cat bigfile.txt | more
OR
ls -l /etc | more
Useful when output is too long to fit on one
screen.

🔹 Navigation Keys in more

Key Action
Spac
Next screen
e
Enter Next line
Back one screen (if
b
supported)
/text Search forward for “text”
q Quit

🔄 Comparison Tip
 more is older and simpler.
 less is more powerful (can scroll up/down
freely).
Example using less:
less filename

Printing a file(lp)
In UNIX, the lp command is used to send files to
a printer — it's part of the CUPS (Common
UNIX Printing System) used in many modern
UNIX and Linux systems.

🔹 Basic Syntax
lp [options] filename

✅ Examples
1. Print a File
lp document.txt
This sends document.txt to the default printer.

2. Print to a Specific Printer

lp -d printer_name document.txt
Replaces printer_name with the actual name of
the printer you want to use.

3. Set Number of Copies

lp -n 3 document.txt
Prints 3 copies of document.txt.

4. Print with a Custom Job Name

lp -t "My Job" document.txt
Sets the print job name to "My Job".
5. Print a Directory Listing
ls -l | lp
Prints the result of the ls -l command.

🔹 Common lp Options
Optio
Description
n
-d Specify printer name
-n Number of copies
-t Job title
Set options (e.g., media
-o
size)
Connect to a remote print
-h
server

🔍 Check Printer Queue

lpq
Shows the current print jobs.

Cancel a Print Job

cancel job_id
You can find job_id using lpq.
Knowing file type(file)
In UNIX, the file command is used to determine
the type of a file — whether it's a text file,
binary, image, script, directory, etc.

🔹 Basic Syntax
file filename

✅ Examples
1. Check Type of a File
file notes.txt
Output might be:
notes.txt: ASCII text

2. Check Type of Multiple Files

file *.txt
This checks all .txt files in the directory.

3. Example Output for Various Files

file script.sh
# Output: script.sh: Bourne-Again shell script,
ASCII text executable
file image.jpg
# Output: image.jpg: JPEG image data
file data.bin
# Output: data.bin: data

🔍 Why Use file?

 It doesn’t rely on file extensions — it
examines the file content.
 Helpful when dealing with unknown files or
downloads.

Line
In UNIX file handling, a "line" refers to a
sequence of characters ending with a newline
character (\n), and it is a fundamental unit when
reading, writing, or processing files. Here's how
lines are handled in various file operations:

📁 Line-Based File Handling in UNIX

🔹 1. Reading a File Line by Line

In Shell Scripts:
while read line; do
echo "Line: $line"
done < file.txt
  Reads each line of file.txt.
 $line holds the current line content.

🔹 2. Counting Lines in a File

wc -l file.txt
 Outputs the number of lines in file.txt.

🔹 3. Viewing Specific Lines

Show line 10:
sed -n '10p' file.txt
Show line 5 using awk:
awk 'NR==5' file.txt
Show first N lines:
head -n 5 file.txt
Show last N lines:
tail -n 5 file.txt

🔹 4. Writing Lines to a File

Using echo:
echo "This is a new line" >> file.txt
 Appends a line to the file.

Using a heredoc (multiple lines):

cat << EOF >> file.txt
Line 1
Line 2
EOF

🔹 5. Removing Empty Lines

grep -v '^$' file.txt
Or use:
sed '/^$/d' file.txt

🔹 6. Finding Lines Matching a Pattern

grep "pattern" file.txt

📌 Summary of Key Commands for Line-Based File

Handling:
Task Command Example
Read line by while read line; do ... done
line < file
Count lines wc -l file.txt
Show specific
sed -n '5p' file.txt
line
Append line to
echo "text" >> file.txt
file
Task Command Example
Filter by
grep "pattern" file.txt
pattern

Word and character

counting(wc)
In UNIX, the wc (word count) command is used
to count lines, words, characters, and bytes
in a file or input.

🔹 Basic Syntax
wc [options] filename

✅ Common Examples
1. Count Lines, Words, and Characters
wc filename.txt
Example output:
10 25 120 filename.txt
This means:
 10 → Lines
 25 → Words
 120 → Characters (or bytes)
 filename.txt → File name
2. Count Only Lines
wc -l filename.txt
3. Count Only Words
wc -w filename.txt
4. Count Only Characters
wc -m filename.txt
5. Count Bytes (instead of characters)
wc -c filename.txt
(Useful for binary files where byte count ≠
character count)

6. Count from Command Output

echo "Hello world" | wc -w
Output:
2

🔹 Summary of wc Options
Optio
Meaning
n
-l Count lines
-w Count words
-m Count
Optio
Meaning
n
characters
-c Count bytes

Would you like a shell script that uses wc to

analyze multiple files or summarize directory
statistics?

Comparing files (cmp)

In UNIX, the cmp command is used to compare
two files byte by byte. It's a simple but
powerful tool to check if two files are identical or
to find where they differ.

🔹 Basic Syntax
cmp [options] file1 file2

✅ Common Examples
1. Compare Two Files
cmp file1.txt file2.txt
 If files are identical, there is no output.
 If files differ, cmp shows the byte and line
number of the first difference.
Example Output:
file1.txt file2.txt differ: byte 12, line 3

2. Silent Mode (Just Return Status)

cmp -s file1.txt file2.txt
 No output at all.
 Return status:
o 0: files are the same
o 1: files differ
o 2: an error occurred
This is useful in shell scripts.

3. Compare Binary Files

cmp image1.jpg image2.jpg
Works for binary files too — helpful when
checking for changes or corruption.

🔹 Exit Codes
Exit
Meaning
Code
Files are
0
identical
1 Files differ
2 Error occurred
🔄 Related Commands
Comman
Purpose
d
Line-by-line differences
diff
(text)
cmp Byte-by-byte comparison
Compare sorted files line-
comm
by-line

Finding common between two

files (comm)
In UNIX, the comm command is used to find
common and differing lines between two
sorted files. It compares them line by line and
outputs:
1.Lines only in the first file
2.Lines only in the second file
3.Lines common to both files
To find common lines between two files using
the comm command in UNIX, follow these steps:

🔹 Step-by-Step: Using comm to Find

Common Lines
✅ Step 1: Sort Both Files
The comm command requires sorted files.
sort file1.txt -o file1.txt
sort file2.txt -o file2.txt
This sorts the files in-place.

✅ Step 2: Use comm with the -12 Option

comm -12 file1.txt file2.txt
🟢 This displays only the lines common to both
files.

📌 Example
file1.txt
apple
banana
cherry
file2.txt
banana
cherry
date
🔸 Run:
sort file1.txt -o file1.txt
sort file2.txt -o file2.txt
comm -12 file1.txt file2.txt
✅ Output:
banana
cherry

🔹 Summary
Command Description
comm file1.txt Compare two sorted
file2.txt files
comm -12 file1.txt Show common lines
file2.txt only
comm -23 file1.txt
Lines only in file1
file2.txt
comm -13 file1.txt
Lines only in file2
file2.txt

Displaying file differences (diff)

In UNIX, the diff command is used to compare
the contents of two files line by line and
display their differences. It’s especially useful
for text files such as code, config files, or
documents.
🔹 Basic Syntax
diff [options] file1 file2

✅ Example Files
file1.txt:
apple
banana
cherry
file2.txt:
apple
banana
date
🔸 Run:
diff file1.txt file2.txt
🔸 Output:
3c3
< cherry
---
> date
🔍 Explanation:
 3c3 → line 3 changed in both files
 < cherry → line in file1.txt
 > date → line in file2.txt
🔹 Common diff Options
Option Description
-y Side-by-side comparison
Context format (adds
-c
surrounding lines)
Unified format (compact,
-u
preferred for code diffs)
--suppress- Hide lines that are the same
common-lines when using -y

🔸 Side-by-Side Comparison
diff -y file1.txt file2.txt
Output:
apple apple
banana banana
cherry | date

🔸 Unified Format (Common for Patches)

diff -u file1.txt file2.txt
Output:
--- file1.txt
+++ file2.txt
@@ -1,3 +1,3 @@
apple
banana
-cherry
+date

🔹 Summary
Task Command
Basic comparison diff file1 file2
Unified diff (e.g., for diff -u file1
Git) file2
diff -y file1
Side-by-side view
file2

Creating archive file(tar)

In UNIX, the tar command is used to create,
view, and extract archive files — usually with
a .tar extension. It's commonly used for
backups, packaging, and transferring files.

🔹 Basic Syntax
tar [options] archive_name.tar files/directories

✅ Creating an Archive
tar -cvf archive.tar file1.txt file2.txt folder/
Breakdown:
 -c → Create a new archive
 -v → Verbose (list files being archived)
 -f → Use the specified archive file name
 archive.tar → Output archive file
 file1.txt, folder/ → Files/folders to include

📦 Common Tar Operations

Task Command Example
tar -cvf files.tar file1
Create archive
file2 dir/
Extract archive tar -xvf files.tar
List contents tar -tvf files.tar
Add file to archive tar -rvf files.tar
(append) newfile.txt
tar -czvf files.tar.gz
Compress with gzip
folder/
Extract .tar.gz file tar -xzvf files.tar.gz

📝 Examples
🔸 Create an archive of a folder:
tar -cvf backup.tar myfolder/
🔸 Create and compress with gzip:
tar -czvf backup.tar.gz myfolder/
🔸 Extract an archive:
tar -xvf backup.tar
🔸 Extract a .tar.gz file:
tar -xzvf backup.tar.gz

🔹 Tip: Tar Without Compression vs With

Compression
Form Command
Description
at Example
tar -cvf file.tar
.tar Archive only
dir/
tar -czvf
.tar.gz Compressed with gzip
file.tar.gz dir/
.tar.bz Compressed with bzip2 tar -cjvf
2 (smaller) file.tar.bz2 dir/

Compress file(gzip)
In UNIX, the gzip command is used to compress
files using the GNU zip algorithm, reducing file
size and saving disk space. It creates files with
a .gz extension.
🔹 Basic Syntax
gzip [options] filename

✅ Examples
🔸 Compress a Single File
gzip myfile.txt
 This replaces myfile.txt with a compressed
file: myfile.txt.gz

🔸 Decompress a .gz File

gunzip myfile.txt.gz
 This restores the original myfile.txt

🔸 Keep Original File While Compressing

gzip -c myfile.txt > myfile.txt.gz
 -c outputs the compressed data to stdout.
 Original myfile.txt is preserved.

🔸 Compress Multiple Files

gzip file1.txt file2.txt
 Creates file1.txt.gz and file2.txt.gz
🔸 Compress a Tar Archive (Common Use
Case)
tar -czvf archive.tar.gz folder/
 -z uses gzip for compression

🔹 View Contents of a .gz File Without

Extracting
zcat myfile.txt.gz # Outputs file contents
zmore myfile.txt.gz # Scroll through contents
zgrep "text" myfile.txt.gz # Search inside
compressed file

🔹 Summary of gzip Options

Optio
Description
n
-d Decompress (gzip -d = gunzip)
-k Keep original file (gzip -k)
-c Write to stdout (used with >)
Verbose — show compression
-v
details

Uncompress file(gunzip)
In UNIX, the gunzip command is used to
uncompress files that were compressed using
the gzip command. These files typically have
a .gz extension.

🔹 Basic Syntax
gunzip [options] filename.gz

✅ Example: Uncompress a File

gunzip myfile.txt.gz
🔹 This restores the original file:
 Removes myfile.txt.gz
 Creates myfile.txt

🔸 If You Want to Keep the .gz File:

Use gzip -d with -c to keep the compressed file:
gzip -dc myfile.txt.gz > myfile.txt
 -d: decompress
 -c: write output to stdout

🔹 Uncompress Multiple Files

gunzip file1.gz file2.gz
✅ Extracts both and removes the original .gz files.
🔹 View Compressed File Without
Uncompressing
Comman
Description
d
Display contents
zcat
of .gz file
Scroll through a .gz
zmore
file
zgrep Search within a .gz file

🔹 Summary
Command Action
Uncompress and remove
gunzip file.gz
.gz
gzip -d file.gz Same as gunzip
gzip -dc file.gz > Uncompress but
file keep .gz file

Archive file (zip)

In UNIX, the zip command is used to archive
and compress files into a .zip file format —
which is widely used and compatible with many
systems, including Windows.
🔹 Basic Syntax
zip [options] archive_name.zip files_or_directories

✅ Examples
🔸 Create a ZIP Archive
zip myarchive.zip file1.txt file2.txt
 Creates myarchive.zip containing file1.txt
and file2.txt.

🔸 Create a ZIP Archive of a Folder

zip -r myfolder.zip myfolder/
 -r means recursive — includes all files and
subfolders in myfolder/.

🔸 Add a File to an Existing ZIP Archive

zip myarchive.zip newfile.txt

🔸 Compress Without Paths (Store only file

names)
cd myfolder/
zip ../myarchive.zip *
 Archives contents without storing folder
paths.
🔹 Viewing ZIP File Contents
unzip -l myarchive.zip
 Lists the files inside the ZIP archive.

🔹 Extracting a ZIP Archive

unzip myarchive.zip

🔹 Summary of Useful Options

Optio
Description
n
-r Include directories recursively
-q Quiet mode (no output)
Verbose (detailed info about
-v
compression)
Create encrypted (password-
-e
protected) ZIP

🔒 Example: Password-Protected ZIP

zip -e secret.zip confidential.txt
 Prompts you to enter a password.

Extract compress file(unzip)

In UNIX, the unzip command is used to extract
files from a .zip archive.

🔹 Basic Syntax
unzip archive.zip
 Extracts all files from archive.zip into the
current directory.

✅ Common Examples
🔸 Extract ZIP Archive
unzip myarchive.zip
 Extracts contents into the current folder.

🔸 Extract to a Specific Directory

unzip myarchive.zip -d /path/to/destination/
 Extracts files into the specified directory.

🔸 List Contents Without Extracting

unzip -l myarchive.zip
 Shows the files inside the archive.

🔸 Overwrite Without Prompting

unzip -o myarchive.zip
  Automatically overwrites existing files.

🔸 Extract Specific Files

unzip myarchive.zip file1.txt file2.txt
 Extracts only file1.txt and file2.txt from the
archive.

🔹 Summary of Useful Options

Optio
Description
n
-l List contents of the zip file
-d Specify extraction directory
Overwrite files without
-o
prompting
Quiet mode (minimal
-q
output)

Brief idea About effect of cp,rm

and mv command on directory

1. cp (Copy) and Directories

 By default, cp does not copy directories
unless you use the recursive option.
 To copy a directory and its contents, use:
cp -r source_directory target_directory
 The -r (or -R) option copies the directory and
all files/subdirectories inside it
recursively.
 Without -r, attempting to copy a directory will
give an error like:
cp: -r not specified; omitting directory 'dir'

2. rm (Remove) and Directories

 By default, rm does NOT remove
directories.
 To delete a directory, use the recursive
option:
rm -r directory_name
 The -r option removes the directory and all
its contents (files and subdirectories)
recursively.
 To force removal without prompts, add -f:
rm -rf directory_name
 Be very careful with rm -rf — it deletes
everything without confirmation.

3. mv (Move/Rename) and Directories

 mv can move or rename directories just like
files.
  Moving a directory to another location:
mv old_directory_path new_directory_path
 This moves the entire directory and its
contents.
 If the target is an existing directory, the
source directory is moved inside it.

🔹 Summary Table
Comman
Directory Action Notes
d
Requires -r to copy Without -r, will
cp
directory recursively error out
-rf for forced
Requires -r to remove
rm recursive
directory recursively
deletion
Moves or renames Moves entire
mv directories without directory and
extra flags contents

MODULE-4 FILE
ATTRIBUTES
File and directory attributes
listing and very brief idea about
the attributes
Each file has characteristics like file name, file
type, date (on which file was created), etc. These
characteristics are referred to as 'File
Attributes'. The operating system associates
these attributes with files. In different operating
systems files may have different attributes. Some
people call attributes metadata also.
Following are some common file attributes:
1.Name: File name is the name given to the
file. A name is usually a string of characters.
2.Identifier: Identifier is a unique number for
a file. It identifies files within the file system.
It is not readable to us, unlike file names.
3.Type: Type is another attribute of a file which
specifies the type of file such as archive file
(.zip), source code file (.c, .java), .docx
file, .txt file, etc.
4.Location: Specifies the location of the file on
the device (The directory path). This attribute
is a pointer to a device.
 5.Size: Specifies the current size of the file (in
Kb, Mb, Gb, etc.) and possibly the maximum
allowed size of the file.
6.Protection: Specifies information about
Access control (Permissions about Who can
read, edit, write, and execute the file.) It
provides security to sensitive and private
information.
7.Time, date, and user identification: This
information tells us about the date and time
on which the file was created, last modified,
created and modified by which user, etc.

OS File Attributes
Some Other Attributes May Include:
Attributes related to flags. These Flags
control or enable some specific property:
 1.Read-only flag: 0 for read/write; 1 for read-
only.
2.Hidden flag: 0 for normal; 1 for do not
display in listings of all files.
3.System flag: 0 for normal files; 1 for system
files.
4.Archive flag: 0 for has been backed up; 1
for needs to be backed up.
5.ASCII/binary flag: 0 for ASCII file; 1 for
binary file.
6.Random access flag: 0 for sequential
access only; 1 for random access.
7.Temporary flag: 0 for normal; 1 for deleted
file on process exit.
8.Lock flags: 0 for unlocked; nonzero for
locked.
Attribute related to keys. These are present
in files which can be accessed using key:
1.Record length: Number of bytes in a record.
2.Key position: Offset of the key within each
record.
3.Key length: Number of bytes in the key
field.
Some file systems also support extended file
attributes, such as character encoding of the
file and security features such as a file
checksum.
All above attributes are not present in all files.
Files may posses different attributes as per the
requirement. The attributes also varies from
system to system. Attributes are also stored in
secondary storage (File name and identifier are
stored in directory structure. Identifier in turn
locates other attributes). Attributes are important
because they provide that extra information
about the files which can be useful.

File ownership
In UNIX, every file and directory has an owner
and a group. File ownership is a key part of the
UNIX permissions system, which helps control
who can read, write, or execute files.

🔹 File Ownership Components

Each file/directory is associated with:
1.User (Owner) — The person who created
the file
2.Group — A set of users with shared access
3.Other — Everyone else on the system

🔍 View File Ownership

Use the ls -l command:
ls -l file.txt
Example Output:
-rw-r--r-- 1 alice staff 2048 May 15 14:22 file.txt
 alice → Owner
 staff → Group
 Permissions: Owner can read/write, group
and others can read

🔧 Changing Ownership
✅ Change File Owner
sudo chown newuser file.txt
 Changes owner of file.txt to newuser
✅ Change Owner and Group
sudo chown newuser:newgroup file.txt
 Changes owner to newuser and group to
newgroup

🔄 Changing Group Only

sudo chgrp newgroup file.txt
 Changes only the group ownership
🔄 Recursive Ownership Change (for
Directories)
sudo chown -R user:group myfolder/
 Applies changes to the folder and all files
inside it

🧠 Why Ownership Matters

 Controls access rights (read/write/execute)
 Allows administrators to delegate
permissions
 Supports multi-user system security

🔹 Summary Table
Command Purpose
ls -l View file ownership
chown user file Change file owner
chown Change owner and
user:group group
chgrp group Change group
file ownership
File permissions
Here’s a summary of file ownership and
permissions in UNIX:

🔐 File Ownership
Each file in UNIX has:
 Owner: Creator of the file
 Group: Users with shared access
 Others: Everyone else

📄 File Permissions
Permissions define who can do what with a file or
directory:
 Read (r): View contents
 Write (w): Modify or delete
 Execute (x): Run (for files) / Enter (for
directories)
Permissions are shown with ls -l:
-rwxr-xr-- 1 owner group ...
 1st character: Type (- for file, d for directory)
 Next 9 characters: Permissions for owner,
group, and others (in sets of 3)
Changing Permissions – chmod
Symbolic Mode:
 + → Add permission
 - → Remove permission
 = → Set exact permission
Examples:
chmod u+x file # Add execute for owner
chmod g=rx file # Set group to read and
execute
chmod o-wx file # Remove write/execute from
others
Absolute (Octal) Mode:
Permissions represented numerically:
Permissi Valu Symb
on e ol
None 0 ---
Execute 1 --x
Write 2 -w-
Read 4 r--
Examples:
chmod 755 file # rwx for owner, rx for group
and others
chmod 644 file # rw for owner, r for group and
others

👥 Changing Ownership
chown – Change file owner:
chown user file
chgrp – Change file group:
chgrp group file
 Only root can change ownership of others'
files.
 Users can change group ownership if they
belong to that group.

📁 Directory Permissions
 Read: List files
 Write: Add or delete files
 Execute: Enter the directory (cd) or access
its contents

Changing file permissions–

relative permission & absolute
permission
📁 File Permissions in UNIX – chmod
Command
The chmod (change mode) command is used to
change permissions on files and directories.
Only the owner or superuser (root) can
change permissions.

🧱 UNIX Permission Basics

Each file/directory has 3 types of users:
 User (u) – Owner
 Group (g) – Assigned group
 Others (o) – Everyone else
And 3 types of permissions:
 Read (r) – View contents
 Write (w) – Modify contents
 Execute (x) – Run file / access directory
Command to view permissions:
ls -l filename
Example output:
-rwxr-xr-- 1 user group 1234 date filename

🔢 1. Changing Permissions Using Absolute

Mode
Format:
chmod nnn filename
Where nnn are octal values for:
 Owner
 Group
 Others
Octal Permission Table:
Octa Symb
Description
l ol
0 --- No permissions
1 --x Execute only
2 -w- Write only
Write and
3 -wx
execute
4 r-- Read only
Read and
5 r-x
execute
6 rw- Read and write
Read, write,
7 rwx
execute
🔧 Examples:
chmod 755 file # rwx for user, r-x for group &
others
chmod 644 file # rw- for user, r-- for group &
others
chmod 700 script # rwx only for owner

⭐ 2. Setting Special Permissions in Absolute

Mode
Special permissions use a four-digit octal value
(nnnn), where the first digit represents:
Octa Special
l Permission
1 Sticky bit (t)
2 setgid (s)
4 setuid (s)
Examples:
chmod 4555 file # setuid + rwx for user, r-x for
group/others
chmod 2551 file # setgid + rx for user/others,
x for group
chmod 1777 directory # sticky bit + full access
for all

🔠 3. Changing Permissions Using Symbolic

Mode
Format:
chmod [who][operator][permissions] filename
Symbols:
Who:
 u: user
 g: group
 o: others
 a: all (user + group + others)
Operators:
 +: add permission
 -: remove permission
 =: set exact permission
Permissions:
 r: read
 w: write
 x: execute
 s: setuid/setgid
 t: sticky bit
✍️Examples:
chmod o-r file # Remove read from others
chmod a+rx file # Add read & execute for all
chmod g=rwx file # Set group to rwx exactly
📌 Notes:
 Use ls -l to verify changes.
 With ACLs (Access Control Lists), changes
may affect ACL masks. Use getfacl filename
to verify permissions if ACLs are used.

Changing File Ownership

In UNIX, every file or directory has:
 An owner (user)
 A group (group of users)
Only the file owner or superuser (root) can
change the ownership.

📌 Why Change Ownership?

 To transfer control of a file to another user.
 To change which group has access to a file.

🔧 1. chown – Change File Owner

Syntax:
chown [new_owner] filename
Example:
chown alice report.txt
✅ Changes the owner of report.txt to user alice.
🔧 2. chgrp – Change Group Ownership
Syntax:
chgrp [new_group] filename
Example:
chgrp developers report.txt
✅ Changes the group of report.txt to developers.

🔧 3. Change Owner and Group Together

Syntax:
chown new_owner:new_group filename
Example:
chown alice:developers report.txt
✅ Sets owner to alice and group to developers.

✅ Important Notes:
 Only the superuser (root) can change file
owner.
 Owners can change the group only to one
they belong to.
 Use ls -l to verify changes.

🔍 View Ownership:
ls -l filename
Example Output:
-rw-r--r-- 1 alice developers 1234 May 15 10:00
report.txt

Changing Group Ownership

Each file in UNIX has:
 An owner (a specific user)
 A group (a set of users who share access)
Sometimes, you need to change the group
associated with a file or directory—this is done
using the chgrp command.

🔧 chgrp – Change Group Ownership

🔹 Syntax:
chgrp [new_group] filename
🔹 Example:
chgrp developers project.doc
✅ This changes the group of project.doc to
developers.

🔹 Change group for multiple files:

chgrp staff file1 file2 dir1
🔹 Change group recursively (for directories and
contents):
chgrp -R editors documents/
✅ All files and subdirectories inside documents/
will now belong to group editors.

🔍 Check group ownership:

Use ls -l to see group ownership:
ls -l project.doc
Sample Output:
-rw-r--r-- 1 alice developers 2048 May 15 09:30
project.doc

⚠️Important Points:
 You must be either:
o The file owner, and a member of the new
group.
o Or the superuser (root).
 If you're not part of the target group, you
can’t assign it.
Here's a well-organized and easy-to-understand
note on File System and Inodes in UNIX –
great for study or technical documentation.

File System and Inodes

🔹 What is a File System?
A file system in UNIX is a method used by the
operating system to store, organize, and manage
data on a disk. It defines:
 How files are named, stored, and retrieved.
 How permissions and ownerships are
handled.
 The structure (directories, files, links, etc.).
UNIX uses a hierarchical file system, starting
from the root /.

🔸 Key Components of UNIX File System:

1.Files – Contain data (text, binary, etc.).
2.Directories – Special files that contain
references to other files/directories.
3.Mount Points – Where additional file
systems are attached to the main tree.
4.Links – Hard or symbolic references to files.
🧱 Inodes – The Building Blocks of UNIX File
System
🔹 What is an Inode?
An inode (index node) is a data structure that
stores metadata about a file (not the file content
or name).
Each file and directory has an associated inode.

🔸 Inode Contains:
 File type (regular, directory, link)
 Permissions (rwx)
 Owner UID
 Group GID
 Size of the file
 Timestamps (created, modified, accessed)
 Link count (how many names point to this
file)
 Pointers to disk blocks (where file data is
stored)

🔹 View inode information:

ls -i filename
Example:
ls -i myfile.txt
387136 myfile.txt
Here, 387136 is the inode number.

🔹 View detailed inode metadata:

stat filename

🔸 How UNIX Handles Files:

 File name is stored in the directory entry.
 File data and metadata are stored in the
inode.
 This means multiple file names (hard links)
can point to the same inode.

⚠️Inode Notes:
 Each file has only one inode, but many
filenames (hard links) can point to it.
 If you delete a filename, the file isn't
removed until all hard links (and open file
descriptors) are gone.
 Inodes are finite. If you run out of inodes, you
cannot create new files—even if disk space is
available.
🔧 Check inode usage on disk:
df -i

🧠 Summary
Term Description
File Organizes files and directories
System on disk
Data structure with metadata
Inode
for a file
Link Filename pointing to an inode
ls -i Shows inode number
stat Shows full inode info

Hard Link
🔹 What is a Hard Link?
A hard link is a direct reference to the inode of a
file. Multiple hard links can point to the same
inode, meaning they all share the same data and
metadata (except the file name).

🔸 Key Characteristics of Hard Links:

 A hard link is indistinguishable from the
original file.
 All hard links share the same inode number.
  Changes made to one link are reflected in all
others.
 Deleting one link does not delete the data
unless all links are removed.
 Hard links cannot span different file systems.
 Cannot be created for directories (to prevent
loops in the file system).

How to Create a Hard Link:

ln original_file hard_link_name
Example:
ln file1.txt file1_hardlink.txt
This creates a hard link file1_hardlink.txt that
points to the same inode as file1.txt.

🔍 Verify with ls -i:

ls -i file1.txt file1_hardlink.txt
Both will show the same inode number, indicating
they point to the same data.

📄 View Link Count:

ls -l file1.txt
The second column shows the link count (number
of hard links to the file's inode).
🧠 Summary Table
Feature Hard Link
Links to Inode
Shared inode Yes
Affected by Only when all links are
deletion deleted
Cross-file system
No
link
Works on No (except by root in special
directories cases)
Command to
ln source target
create

Soft link (Symbolic Link)

🔹 What is a Soft Link?
A soft link (also called a symbolic link) is a
shortcut or pointer to another file. It contains
the pathname to the original file, not the data
itself.
🔸 Key Characteristics of Soft Links:
 Soft links have their own inode and
metadata.
 They point to the file name (path), not the
actual data.
 If the original file is deleted or moved, the
soft link becomes broken (dangling).
 Can link across different file systems and
partitions.
 Can be created for directories.
 Indicated by an l at the beginning of the ls -l
output and show the path they point to.

How to Create a Soft Link:

ln -s original_file soft_link_name
Example:
ln -s file1.txt file1_symlink.txt
This creates file1_symlink.txt, which points to
file1.txt.

🔍 Verify with ls -l:

ls -l file1_symlink.txt
Output:
lrwxrwxrwx 1 user group size date
file1_symlink.txt -> file1.txt
Note the l at the beginning and the arrow ->
indicating it’s a soft link.

🧠 Summary Table
Feature Soft Link
Links to File name (path)
Shared inode No
Affected by Breaks if original file is
deletion deleted
Cross-file system
Yes
link
Works on
Yes
directories
Command to
ln -s source target
create

🧾 Comparison: Hard Link vs. Soft Link in

UNIX
 Soft Link
Feature Hard Link (Symbolic
Link)
File's inode
Points to File name (path)
(actual data)
Inode Yes (same inode No (has its own
shared as original file) inode)
File system Must be on the Can span across
limitation same file system file systems
Affects if File still
Link is broken
original accessible via
(dangling link)
deleted hard link
Can link to Usually not
Allowed
directories allowed
Command to ln original_file ln -s original_file
create hardlink_name softlink_name
Uses minimal Stores path as
Storage extra space (no text; very small
duplication) size
Starts with l and
Identificatio Appears like a
shows ->
n in ls -l regular file
pointing path

Significance of File Attributes for

Directories in UNIX
In UNIX, directories are special files that store
information about other files and directories. The
file attributes (permissions and types) for
directories control how users can interact with
the directory and its contents.

🔑 Key Attributes and Their Significance for

Directories:
Attribu Meaning for Effect / Permission
te Directory Behavior
Allows listing the
User can view the list
Read names of files
of files and
(r) inside the
subdirectories in it
directory
Allows creating,
deleting, or User can add or
Write
renaming files remove files and
(w)
inside the subdirectories
directory
Allows access to User can enter (cd)
Execut the contents and into the directory and
e (x) traversal through access files if
the directory permissions allow

📝 Summary:
  Read permission lets you see filenames
inside the directory (e.g., ls command).
 Write permission lets you modify the
directory contents (create/delete files).
 Execute permission lets you access the files
or subdirectories inside the directory and
traverse it.

Example:
 If a user has read but not execute
permission on a directory, they can see the
file names but cannot access or open them.
 If a user has execute but not read
permission, they cannot list the files but can
access files if they know the exact filename.

Why this matters?

Directory permissions control security and
accessibility of the files and subdirectories
within. Proper permission settings prevent
unauthorized users from accessing or modifying
directory contents.
Default Permissions of Files and
Directories and Using umask
1. Default Permissions
 When you create a new file or directory,
UNIX assigns it default permissions.
 These defaults depend on the system and are
modified by the umask value.
File Default Permissions (before
Type umask)
File 666 (rw-rw-rw-)
Directo
777 (rwxrwxrwx)
ry
Note: Files generally do not have execute
permission by default.

2. What is umask?
 umask (user file creation mask) determines
which permission bits will be disabled
(masked off) when a new file or directory is
created.
 It subtracts permissions from the system
defaults.

3. How umask Works

  The default permission minus the umask
value gives the final permission.
Formula:
Final Permission = Default Permission - umask

4. Example of umask
Final
umas Final File Effect on
Effect Directory
k Permissi Directorie
on Files Permissio
Value on s
n
removes
removes
write for
644 (rw-r-- write for 755 (rwxr-
022 group
r--) group and xr-x)
and
others
others
removes
removes 775
write for 664 (rw-
002 write for (rwxrwxr-
others rw-r--)
others only x)
only
removes
removes
all for
600 all for 700
077 group
(rw-------) group and (rwx------)
and
others
others

5. How to Check and Set umask

  Check current umask:
 umask
 Set umask (for example, set to 022):
 umask 022

6. Summary
File Directory
Aspect Effect of umask
Default Default
System Masks out
default 666 777 permission bits
perms from defaults
Typical 022 Removes write
022
umask (common permission for
(common)
value ) group and others

Listing Modification and Access

Time
1. File Timestamps in UNIX
Every file in UNIX has three important
timestamps:
Timestamp Description
Modification Last time file content was
Time (mtime) modified
Timestamp Description
Access Time Last time file was read or
(atime) accessed
Last time file metadata
Change Time
(permissions, ownership)
(ctime)
changed

2. Viewing File Modification and Access

Time
Use the ls command with options to display
timestamps:
 Show modification time (default):
 ls -l filename
Displays modification time (mtime).
 Show access time:
 ls -lu filename
 Show change time:
 ls -lc filename

3. Detailed Timestamp Listing with stat

For a detailed view of all timestamps:
stat filename
Output example:
Access: 2025-05-15 10:30:00
Modify: 2025-05-14 09:00:00
Change: 2025-05-15 09:45:00

4. Summary
Comman
Shows
d
Modification time
ls -l
(mtime)
ls -lu Access time (atime)
ls -lc Change time (ctime)
stat Detailed timestamps

Changing File Timestamps

(touch)
1. What is touch?
 The touch command is used to change the
access and modification times of a file.
 If the file does not exist, touch creates an
empty file with the current time as its
timestamp.

2. Basic Usage
  Update access and modification times to the
current time:
 touch filename

3. Set Specific Time and Date

 Using -t option with [[CC]YY]MMDDhhmm[.ss]
format:
 touch -t 202505151230.45 filename
Sets timestamp to May 15, 2025, 12:30:45.

4. Change Only Access or Modification Time

 Change only access time:
 touch -a filename
 Change only modification time:
 touch -m filename

5. Use Reference File’s Timestamp

 Set timestamp of a file to match another file:
 touch -r referencefile filename

6. Summary of Useful touch Options

Option Description
touch file Update access and modification
Option Description
to now
touch -a file Update access time only
touch -m file Update modification time only
touch -t time
Set specific timestamp
file
touch -r ref Use timestamp from reference
file file

File Locating with find Command

1. What is find?
 The find command searches for files and
directories in a directory hierarchy based on
various criteria.
 It is very powerful and flexible for locating
files by name, type, size, modification time,
permissions, and more.

2. Basic Syntax
find [path] [options] [expression]
 path: Directory where search begins (default
is current directory .).
 options and expression: Criteria to match
files/directories.
3. Common Examples
 Find files by name:
 find /home/user -name "file.txt"
 Find files by case-insensitive name:
 find /home/user -iname "File.TXT"
 Find all directories named docs:
 find / -type d -name "docs"
 Find all regular files with .log extension:
 find /var/log -type f -name "*.log"
 Find files modified in last 7 days:
 find /home/user -mtime -7
 Find files larger than 10MB:
 find / -size +10M
 Find files with specific permissions:
 find / -perm 644

4. Actions with find

You can also perform actions on found files using
-exec or -delete.
 Delete all .tmp files:
 find /tmp -name "*.tmp" -delete
  Change permissions of found files:
 find /var/www -type f -name "*.php" -exec
chmod 644 {} \;

5. Summary of Common Options

Option Description
Search by filename (case-
-name
sensitive)
Search by filename (case-
-iname
insensitive)
-type f/d Search for files/directories
-mtime n Modified time in days
-size +n File size greater than n
-perm mode Match permissions
-exec Execute command on each
command found file

MODULE-5 SHELL
INTERPRETIVE CYCLE OF SHELL
In UNIX, the shell is an interpreter that
processes commands entered by the user. The
interpretive cycle refers to the process the
shell follows to read, interpret, and execute
commands.

🔄 Interpretive Cycle of the UNIX Shell

Here is a step-by-step breakdown of the cycle:
1.Prompt and Input
o The shell displays a prompt (e.g., $, #, or
a custom prompt).
o The user types a command and hits
Enter.
2.Read
o The shell reads the entire input line as a
string.
3.Parse
o The shell breaks the input into tokens
(commands, arguments, operators like |,
>, etc.).
o It recognizes special characters
(wildcards *, variables $VAR, pipes |,
etc.).
4.Interpret
o It interprets built-in syntax (like variable
substitution, command substitution with
backticks or $(...), and redirections).
 o It identifies whether the command is:
 A built-in command
 An alias
 A function
 An external executable
5.Execute
o The shell executes the command.
o For pipelines (|), it sets up the necessary
input/output redirection.
o For background tasks (&), it forks a
subprocess.
6.Wait for Completion
o If it's a foreground task, the shell waits
until the command finishes.
o If it's a background task, it returns control
to the user immediately.
7.Return Output
o The shell displays output or error
messages from the command.
o It sets the exit status ($?) to reflect
success or failure.
8.Repeat
 o The shell shows the prompt again and
waits for the next command.

🧠 Summary
The interpretive cycle of the UNIX shell can
be summarized as:
Prompt → Read → Parse → Interpret →
Execute → Wait → Output → Repeat
This cycle continues as long as the user is
interacting with the shell.

TYPES OF SHELL
In UNIX and UNIX-like operating systems, a shell
is a command-line interpreter that provides a
user interface for accessing the system's
services. There are several types of shells, each
with its own features, syntax, and scripting
capabilities.

🐚 Types of Shell in UNIX

Here are the main types of shells commonly
used:
Shell Comma
Description
Name nd
Bourne sh The original UNIX shell
Shell developed by Stephen Bourne.
Shell Comma
Description
Name nd
Simple and fast, often used in
scripting.
Developed by Bill Joy. Syntax
C Shell csh similar to C programming.
Supports aliases, job control.
Developed by David Korn.
Korn Combines features of sh and
ksh
Shell csh with additional scripting
capabilities.
Default shell in many Linux
Bourne systems. Enhanced version of
Again bash sh with more features like
Shell command history, tab
completion, and arithmetic.
Powerful shell with advanced
features like themes, plugins,
Z Shell zsh
and extended globbing.
Popular among power users.
Friendly interactive shell with a
Fish focus on usability. Modern
fish
Shell features like autosuggestions
and syntax highlighting.

🧾 Shell Comparison Overview

 cs
Feature sh bash ksh zsh fish
h
Scripting ✅ ✅ ✅ ✅ ✅ ✅
Command
❌ ✅ ✅ ✅ ✅ ✅
History
Auto-completion ❌ ✅ ❌ ✅ ✅ ✅
Syntax
❌ ❌ ❌ ❌ ✅ ✅
Highlighting
Modern Mediu Lo Mediu Hig Hig
❌
Features m w m h h

Pattern Matching
In the UNIX shell (like bash, sh, zsh), pattern
matching is called globbing. It is used mainly
for filename expansion and string matching
in shell scripts.

🔸 1. Filename Globbing (Wildcard Matching)

The shell automatically expands these patterns
when dealing with files and directories.
Pattern Matches
* Zero or more characters
? Exactly one character
[abc] One character: a, b, or c
[a-z] Any lowercase letter
[!abc] or Any character except a,
[^abc] b, or c
📌 Example:
ls *.txt # All files ending in .txt
ls file?.sh # file1.sh, fileA.sh, but not file10.sh
ls [a-c]* # Files starting with a, b, or c

🔸 2. Pattern Matching in Shell Scripts (case

and [[ ]])
🧾 case statement
Pattern matching is commonly used in case
statements for decision making.
filename="report.pdf"

case "$filename" in
*.pdf) echo "PDF file";;
*.txt) echo "Text file";;
*) echo "Unknown file type";;
esac
🧾 [[ ]] conditional with pattern
You can use pattern matching with [[ and ==:
file="data.csv"
if [[ $file == *.csv ]]; then
echo "It's a CSV file"
fi
Use =~ for regex matching:
if [[ "hello123" =~ ^hello[0-9]+$ ]]; then
echo "Pattern matched!"
fi

🔸 3. Shell Options (For Advanced Globbing)

You can enable extended globbing in bash with:
shopt -s extglob
Then use:
ls !(file1.txt) # Match all except file1.txt
ls +([0-9]) # Match one or more digits

✅ Summary
Feature Syntax Use
Wildcard *, ?, [] File operations
Feature Syntax Use
matching
case, [[ Conditional
Scripting match
]] execution
Pattern match with
Regex match [[ =~ ]]
regex

Escaping in UNIX Shell

Escaping in the UNIX shell is the technique of
preventing the shell from interpreting
special characters. This allows you to treat
symbols like *, $, |, >, etc., as literal characters
instead of commands or operators.

🔸 Why Escaping Is Needed

The shell interprets special characters for:
 Wildcards: *, ?
 Variables: $VAR
 Command substitution: $(...) or `...`
 Redirection and pipes: >, <, |
 Quoting: ', ", \
To use these characters as-is, you escape
them.
🔹 1. Backslash \ – Escape a Single Character
The backslash tells the shell to treat the next
character literally.
echo \$HOME # Prints: $HOME instead of
expanding it
echo "File name is file\*.txt" # Prints: file*.txt

🔹 2. Single Quotes ' – Strong Quoting

Everything inside single quotes is taken
literally. No variable or command substitution
happens.
echo '$HOME' # Prints: $HOME
echo 'Today is `date`' # Prints: Today is `date`

🔹 3. Double Quotes " – Weak Quoting

Double quotes allow variable and command
substitution, but protect most other characters.
name="Alice"
echo "Hello $name" # Hello Alice
echo "File is *.txt" # File is *.txt

🔹 4. Escape Sequences in Shell

Common examples:
echo "Line 1\nLine 2" # Prints as one line
(because \n is not interpreted here)
echo -e "Line 1\nLine 2" # With -e, it
interprets escape sequences

🔸 Practical Examples
Escaping a wildcard:
touch file\*name.txt # Creates a file named
file*name.txt
Escaping a dollar sign:
echo "This is \$100" # Prints: This is $100
Escaping within commands:
grep "1\.0" file.txt # Match "1.0" literally (dot is
a special character in regex)

✅ Summary
Metho Substitution
Description
d Allowed?
Escapes the next
\ No
character
Strong quoting –
'...' No
everything literal
Weak quoting – protects
"..." Yes
most, but allows $, `
Quoting
Quoting in the UNIX shell is used to control
how the shell interprets special characters
like spaces, $, *, |, and more. It helps avoid
unintended behavior in commands and scripts.

🔸 Why Use Quoting?

Without quoting, the shell evaluates special
characters. Quoting prevents or controls this,
especially when dealing with:
 Filenames with spaces
 Variables containing special characters
 Command substitution
 Wildcards (*, ?), redirection (>, <), pipes (|)

🔹 1. Single Quotes '...' – Strong Quoting

 Everything inside is taken literally
 No variable expansion or command
substitution
✅ Example:
echo '$HOME' # Output: $HOME
echo 'Today is `date`' # Output: Today is `date`
Use when you want the shell to ignore all
special characters.

🔹 2. Double Quotes "..." – Weak Quoting

 Allows: variable expansion ($VAR),
command substitution (`cmd` or $(...))
 Protects: spaces, wildcards, most special
characters
✅ Example:
name="Alice"
echo "Hello $name" # Output: Hello Alice
echo "Today is $(date)" # Output: Today is Fri
May 16 ...
Use when you want some interpretation, but
also need to protect spaces or wildcards.

🔹 3. Backslash \ – Escape One Character

 Escapes a single character
 Often used inside double quotes
✅ Example:
echo \$HOME # Output: $HOME
echo "She said \"hello\"" # Output: She said
"hello"
🔹 4. No Quotes – Full Interpretation
If you don’t quote at all, the shell will interpret
everything:
 Spaces break arguments
 Wildcards expand
 Variables are expanded
⚠️Example:
file="My File.txt"
rm $file # Tries to remove `My` and `File.txt`
as two files (error!)
rm "$file" # Correct: quotes prevent word
splitting

🧾 Quick Comparison Table

Interprets Preserves
Type Use case
$, *, etc.? spaces?
'...' ❌ No ✅ Yes Literal strings
Most scripting
"..." ✅ Partially ✅ Yes
needs
❌ (for one ✅ (for one Escape just one
\char
char) char) character
No ✅ Yes ❌ No Simple
quotes commands,
 Interprets Preserves
Type Use case
$, *, etc.? spaces?
risky input

Example in Script
#!/bin/bash
name="John Doe"
echo "Hello $name" # Correct
echo Hello $name # Will treat "John" and
"Doe" as separate arguments

Redirection in UNIX Shell

Redirection in the UNIX shell allows you to
control where input comes from and where
output goes. Instead of reading input from the
keyboard and writing output to the terminal, you
can redirect them to or from files and other
commands.

📥📤 Types of Redirection
🔹 1. Standard Output Redirection (>)
Sends the output of a command to a file,
replacing its contents.
ls > file_list.txt
# Output of `ls` is written to file_list.txt
🔹 2. Append Output (>>)
Adds output to the end of a file, preserving
existing contents.
echo "New entry" >> log.txt

🔹 3. Standard Input Redirection (<)

Takes input from a file instead of the keyboard.
sort < names.txt
# Sorts lines in names.txt

🔹 4. Standard Error Redirection (2>)

Redirects error messages (stderr) to a file.
ls nonexistentfile 2> errors.txt

🔹 5. Redirect Both Output and Errors

 Combine stdout and stderr into one file:
command > output.txt 2>&1
 Or in Bash (modern shells):
command &> output.txt

🔹 6. Here Document (<<)

Feeds multi-line input directly into a command.
cat << EOF
This is line 1
This is line 2
EOF

🔹 7. Here String (<<<)

Feeds a string as input to a command.
grep "hello" <<< "hello world"

🧾 File Descriptors in UNIX

F Symb
Name Description
D ol
Standard Input from keyboard
0 <
Input or file
Standard
1 > Normal output
Output
Standard
2 2> Error messages
Error

✅ Summary Table
Operat
Purpose Example
or
> Redirect stdout ls > out.txt
Operat
Purpose Example
or
>> Append stdout echo hi >> out.txt
< Redirect stdin sort < data.txt
2> Redirect stderr ls nofile 2> error.txt
Merge stderr with command > all.txt
2>&1
stdout 2>&1
&> Redirect both (bash) command &> all.txt
See cat << EOF
<< Here Document
example
grep "foo" <<<
<<< Here String
"foobar"

Standard Input (stdin) in UNIX

Shell
In the UNIX shell, standard input (stdin) refers
to the default source of input for a command
— typically, it's the keyboard.
 It is represented by file descriptor 0.
 You can redirect stdin from a file or provide
input directly.

🔹 1. Using Standard Input by Default

Many UNIX commands read from stdin if no file
is given.
cat
# Then type something. Press Ctrl+D to signal
end of input.

🔹 2. Redirecting stdin from a File (<)

You can feed input to a command from a file
instead of typing it manually.
sort < names.txt
# Sorts the contents of names.txt

🔹 3. Piping stdin (|)

Pipes send stdout of one command as stdin
to another.
cat names.txt | sort
# Same as: sort < names.txt

🔹 4. Here Document (<<)

Feed multi-line input to stdin of a command
directly in a script or terminal.
cat << EOF
Line 1
Line 2
EOF

🔹 5. Here String (<<<)

Feed a single-line string into a command via
stdin.
grep "root" <<< "root:x:0:0:root:/root:/bin/bash"

📌 File Descriptor Reference

Nam Descript
Purpose
e or
Input (keyboard or
stdin 0
file)
stdo
1 Output (terminal)
ut
stder
2 Errors
r

🧠 Example: Script Using stdin

#!/bin/bash
echo "Enter your name:"
read name # reads from stdin
echo "Hello, $name"

✅ Summary
Metho
Description Example
d
Keyboar
Default stdin read var
d
Redirect file to
< file sort < input.txt
stdin
` ` Pipe stdout → stdin
<< Here Document cat << EOF
grep "x" <<<
<<< Here String
"example text"

Standard Output (stdout) in

UNIX Shell
In UNIX shell, standard output (stdout) is the
default destination for output from commands
— typically the terminal screen.
 It is represented by file descriptor 1.
 You can redirect stdout to a file or pipe it to
another command.

🔹 1. Standard Output by Default

Commands print to the terminal unless
redirected.
echo "Hello, World"
# Output goes to terminal via stdout

🔹 2. Redirecting stdout to a File (>)

Use > to send output to a file, replacing any
existing content.
ls > filelist.txt
# Writes output of `ls` to filelist.txt

🔹 3. Appending stdout to a File (>>)

Use >> to append output to an existing file
without overwriting.
echo "New log entry" >> logs.txt

🔹 4. Piping stdout (|)

Send stdout of one command to another
command’s stdin.
ls | sort
# Passes output of `ls` to `sort`

🔹 5. Redirecting stdout with File Descriptor

Explicitly use 1> for stdout redirection (not
always required, but allowed).
echo "Test" 1> output.txt
You can also combine with stderr:
command > out.txt 2>&1 # stdout and stderr to
same file

📌 File Descriptor Reference

Nam Descript
Description
e or
Standard input
stdin 0
(keyboard)
stdou Standard output
1
t (terminal)
stder Standard error
2
r (terminal)

🧠 Example Script Using stdout

#!/bin/bash
echo "Generating file list..."
ls > filelist.txt
echo "Done. Output saved to filelist.txt"

✅ Summary
Symb
Operation Description Example
ol
Output to (defaul
Normal stdout echo "hi"
terminal t)
 Symb
Operation Description Example
ol
Redirect to Overwrite file echo hi >
>
file with output out.txt
Append to Add output to echo hi >>
>>
file end of file out.txt
Pipe to stdout to
another ` ` next cmd’s
cmd stdin
Explicit echo test 1>
1> stdout to file
descriptor out.txt

Standard Error (stderr) in UNIX

Shell
Standard error (stderr) is the default
destination for error messages and diagnostics.
Like stdout, it usually prints to the terminal, but
separately from normal output.
 It is represented by file descriptor 2.
 Keeping stderr separate allows you to
handle errors differently from normal
output.

🔹 1. Standard Error by Default

Errors print to the terminal independently of
normal output.
ls nonexistentfile
# Error message appears on terminal (stderr)

🔹 2. Redirect stderr to a File (2>)

You can redirect error messages to a file to
review them later.
ls nofile 2> errors.txt
# Error messages go to errors.txt instead of
terminal

🔹 3. Redirect stderr to stdout (2>&1)

Combine error messages and normal output into
the same place (file or pipe).
command > alloutput.txt 2>&1
# Redirect stdout and stderr to alloutput.txt
Or with Bash shortcut:
command &> alloutput.txt

🔹 4. Redirect stderr to /dev/null (ignore

errors)
Discard error messages by redirecting to the null
device.
command 2> /dev/null

📌 File Descriptor Reference

Nam Descript
Description
e or
stdin 0 Standard input
stdou
1 Standard output
t
stde Standard error
2
rr (errors)

🧠 Example: Separate stdout and stderr

ls existingfile nofile > output.txt 2> errors.txt
# Output of existingfile goes to output.txt
# Error for nofile goes to errors.txt

✅ Summary Table
Operato
Description Example
r
Redirect stderr to a ls nofile 2>
2>
file errors.txt
Redirect stderr to command >
2>&1
stdout all.txt 2>&1
&> Redirect both stdout command &>
Operato
Description Example
r
& stderr all.txt
2> Ignore error command 2>
/dev/null messages /dev/null

/dev/null — The "Black Hole" of

UNIX
 It’s a special device file that discards all
data written to it.
 Any output redirected to /dev/null vanishes
and does not consume disk space.
 Reading from /dev/null returns EOF (end-
of-file) immediately.
Use cases:
 Suppress output or errors you don’t want
to see.
 Silence commands that produce unnecessary
output.
Examples:
# Discard stdout
command > /dev/null
# Discard stderr
command 2> /dev/null

# Discard both stdout and stderr

command &> /dev/null

/dev/tty — The Controlling

Terminal
 Represents the current user’s terminal
device (your keyboard & screen).
 Useful when you want a command to read
input from or write output to the
terminal directly, regardless of
redirections.
Use cases:
 When input/output has been redirected but
you want to interact with the user.
 Reading passwords or prompts securely.
Examples:
# Write directly to terminal even if stdout is
redirected
echo "Hello User" > /dev/tty
# Read input from terminal even if stdin is
redirected
read -p "Enter password: " password < /dev/tty

📌 Summary
Common
Device Purpose Behavior
Use
Discards Suppress
/dev/ Data is lost
everything unwanted
null (black hole)
written to it output
Current user Connects to Prompt user
/dev/tty terminal user’s during
device terminal redirected I/O

Pipe (|) in UNIX Shell

A pipe is a powerful feature in the UNIX shell that
allows you to connect the output of one
command directly as the input to another
command.

🔹 What is a Pipe?
 The pipe symbol: |
 It takes the standard output (stdout) of
the command on the left and passes it
 as standard input (stdin) to the
command on the right.
 Enables building command chains for
complex tasks.

🔹 Basic Example
ls -l | grep ".txt"
 ls -l lists files.
 grep ".txt" filters output to show only .txt
files.

🔹 More Complex Example

ps aux | grep firefox | awk '{print $2}'
 ps aux: lists running processes.
 grep firefox: filters lines containing "firefox".
 awk '{print $2}': prints the second field
(usually the PID).

🔹 Why Use Pipes?

 Combines simple tools to perform complex
operations.
 Avoids creating temporary files.
 Streamlines data processing.
🔹 Multiple Pipes
You can chain many commands:
cat file.txt | tr 'a-z' 'A-Z' | sort | uniq -c | sort -nr
 Converts text to uppercase, sorts, counts
unique lines, and sorts by frequency.

🔹 Pipes and Exit Status

 Each command runs independently.
 Exit status $? reflects the last command in
the pipe chain.
 To check status of all commands, use
PIPESTATUS array in bash.

✅ Summary
Symb Descripti
Example
ol on
Pipe stdout of one command to
` `
stdin of next

tee Command in UNIX Shell

The tee command reads from standard input
and writes it both to standard output and to
one or more files simultaneously.
🔹 What Does tee Do?
 Takes input from a command or pipe.
 Sends that input to a file (or files) AND to
the terminal (stdout).
 Useful when you want to save output to a
file but still see it on the screen.

🔹 Basic Syntax
command | tee filename

🔹 Examples
Write output to a file and display on
terminal
ls -l | tee filelist.txt
 Lists files.
 Shows output on screen.
 Saves output to filelist.txt.

Append output to a file instead of

overwriting
echo "New line" | tee -a logfile.txt
 -a flag appends instead of replacing.
Write output to multiple files
some_command | tee file1.txt file2.txt

🔹 Common Use Cases

 Logging output while monitoring it live.
 Debugging scripts or commands.
 Saving output for later analysis without losing
interactive display.

✅ Summary
Examp
Option Description
le
Write stdout to file and
None `cmd
screen
Append instead of
-a `cmd
overwrite
Multiple
Write to multiple files `cmd
files

Command Substitution in UNIX

Shell
Command substitution allows you to run a
command inside another command, and use
the output of the first command as input or
part of the second command.

🔹 Purpose
 Capture the output of a command and
store it in a variable or use it directly.
 Helps automate scripts by dynamically
generating values.

🔹 Syntax
Two common ways to do command substitution:
1.Using backticks `command` (older style)
2.Using $(command) (preferred modern style)

🔹 Examples
Using backticks
today=`date`
echo "Today's date is: $today"
Using $()
files_count=$(ls | wc -l)
echo "Number of files: $files_count"

🔹 Why prefer $() over backticks?

  Easier to nest commands without escaping.
 More readable, especially in complex scripts.

🔹 Nested command substitution example

result=$(echo "Today is $(date +%A)")
echo "$result"

🔹 Use in commands
echo "Home directory contains $(ls ~ | wc -l)
items."

✅ Summary
Syntax Description Example
`command Older command today=`dat
` substitution e`
$
Modern, preferred
(command `files=$(ls
syntax
)

Shell Variables
Shell variables store data or values that can be
used and manipulated within shell scripts or
command line sessions.
🔹 Types of Shell Variables
1.User-defined variables — created by users
or scripts.
2.Environment variables — exported to child
processes.
3.Special variables — predefined by the shell
(e.g., $?, $#).

🔹 How to Define Variables

variable_name=value
 No spaces around =.
 Values can be strings, numbers, etc.
Example:
name="Alice"
age=25

🔹 Accessing Variables
Use $ before variable name to get its value.
echo "Name is $name"
echo "Age is $age"

🔹 Exporting Variables
To make variables available to child processes,
use export:
export PATH=$PATH:/my/custom/path

🔹 Special Variables
Variabl
Meaning
e
$? Exit status of last command
$$ PID of current shell process
$# Number of arguments passed
$0 Name of the shell/script
$1, Positional parameters (arguments to
$2, ... scripts)

🔹 Example Script Using Variables

#!/bin/bash
greeting="Hello"
name="Bob"
echo "$greeting, $name!"

🔹 Tips
 Use quotes around variable values with
spaces: var="Hello World"
  Use {} for clarity: ${var}

✅ Summary
Action Syntax Example
Assign name="Alic
var=value
variable e"
Access $var or $ echo
variable {var} $name
Export export
export var
variable PATH
$?, $$, $#,
Special vars echo $?
$1

Basic Idea About UNIX

Processes
A process in UNIX is an instance of a running
program. When you run a command or start an
application, the system creates a process to
execute it.

🔹 What is a Process?
 A process is an active program with its
own:
o Process ID (PID)
 o Memory space
o Program counter (current execution
point)
o File descriptors (input/output)
o State (running, sleeping, stopped, etc.)

🔹 Process Lifecycle
1.Created — when a program starts (using
fork() and exec() system calls).
2.Running — executing instructions on the
CPU.
3.Waiting — waiting for resources or
input/output.
4.Terminated — finished execution or killed.

🔹 Process States
State Description
Runnin
Currently executing on CPU
g
Sleepin
Waiting for an event or resource
g
Stoppe
Suspended or paused
d
Zombie Finished but still has an entry in process
State Description
table (waiting for parent to acknowledge)

🔹 Process Identification
 PID (Process ID): Unique identifier for each
process.
 PPID (Parent Process ID): The PID of the
process that started (created) this process.

🔹 Viewing Processes
 Use ps to see current processes.
 Use top or htop for dynamic process
monitoring.
 Use kill to send signals to processes.
Example:
ps aux | grep firefox

🔹 Process Control
 Foreground process: Runs interactively;
shell waits until it finishes.
 Background process: Runs concurrently;
shell returns prompt immediately (run
command with &).
sleep 30 & # Run sleep in background
🔹 Signals
 Processes can receive signals to perform
actions:
o SIGTERM (terminate)
o SIGKILL (force kill)
o SIGSTOP (pause)
o SIGCONT (continue)

✅ Summary
Concept Description
Running instance of a
Process
program
PID Unique process identifier
PPID Parent process ID
Foregroun
Runs with shell waiting
d
Backgrou
Runs asynchronously
nd
Control commands to
Signals
processes
Displaying Process Attributes
Using ps Command
The ps command is used to view information
about running processes on your system. It
shows details (attributes) like process ID, user,
CPU usage, memory usage, command name, etc.

🔹 Basic Usage
ps
Shows processes running in the current shell
session.

🔹 Common Options to Display More Info

Optio Exampl
Description
n e
Shows all processes with
aux ps aux
detailed info
Full-format listing of all
-ef ps -ef
processes
-u ps -u
Processes for specific user
user alice
Information for a specific ps -p
-p PID
process 1234
🔹 Important Process Attributes Shown by ps
Column Description
PID Process ID
PPID Parent Process ID
USER Owner of the process
%CPU CPU usage percentage
%MEM Memory usage percentage
VSZ Virtual memory size (KB)
Resident Set Size (physical
RSS
mem)
STAT Process state/status
START Process start time
TIME CPU time used
COMMAN Command that started the
D process

🔹 Example: Show All Processes with Details

ps aux
Sample output snippet:
USER PID %CPU %MEM VSZ RSS TTY
STAT START TIME COMMAND
root 1 0.0 0.1 169112 5800 ? Ss
08:00 0:01 /sbin/init
alice 1234 2.3 1.2 345678 24500 pts/0 S+
09:45 0:15 bash

🔹 Filtering with grep

ps aux | grep ssh
Lists processes related to ssh.

🔹 Customize Output Columns (ps with -o)

You can specify which columns to display:
ps -eo pid,user,%cpu,%mem,comm

✅ Summary
Comman
Description
d
Show current shell
ps
processes
Show all processes with
ps aux
details
ps -ef Full-format all processes
Show info for specific
ps -p PID
process
ps -eo Customize displayed
cols columns
Displaying System Processes
System processes are usually started by the
system or root user and run in the background to
manage system tasks.

How to Display System Processes

1. Using ps Command
To list all system processes, you can use:
ps -ef
 Shows all processes with detailed info.
 Look for processes owned by root or system
users.

2. Using ps aux
ps aux
 Shows all processes.
 The USER column shows process owner;
system processes usually run as root or other
system users.

3. Filter System Processes

If you want to see only system processes
(owned by root):
ps -U root -u root u
 Lists processes owned by the root user.

4. Using top or htop

Run interactive tools to monitor all processes
dynamically:
top
or if installed,
htop
System processes are shown along with user
processes, sorted by CPU/memory use.

5. Check for system daemons

You can filter system daemons (services) by
common names or look under /etc/init.d or
systemd units.

Sample command showing system

processes
ps -eo pid,user,comm | grep '^ *[0-9]* root'

Summary:
Command Description
ps -ef Show all processes
Command Description

Show all processes with

ps aux
detailed info
ps -U root -u
Show processes owned by root
root u
top / htop Interactive process monitoring

Process Creation Cycle

When a new process is created in UNIX, it goes
through several stages involving key system
calls. Here’s the basic cycle:

1. Parent Process Calls fork()

 fork() creates a new child process by
duplicating the parent process.
 The child is an almost exact copy but has a
unique Process ID (PID).
 After fork(), two processes run concurrently:
parent and child.

2. Child Process Calls exec()

 The child process replaces its memory space
with a new program using exec() family of
functions (e.g., execl, execvp).
  This loads and runs the new program in the
child process.
 If exec() fails, the child can handle the error
or terminate.

3. Parent Process Uses wait()

 Parent may use wait() or waitpid() to wait
for the child to finish.
 This helps parent collect the child’s exit
status and clean up system resources.

Process Creation Steps Summary:

Step Description
fork(
Creates a new child process
)
exec Child process loads and runs new
() program
wait( Parent waits for child process
) termination

Diagram of Process Creation Cycle:

Parent process
|
fork()
 / \
Parent Child
|
exec()
|
New program runs
|
exit
|
wait() by parent

Example in Shell Script

#!/bin/bash
echo "Parent PID: $$"
sleep 10 &
child_pid=$!
echo "Child PID: $child_pid"
wait $child_pid
echo "Child finished"
 Here, shell creates a background process
(sleep 10 &).
 The script waits for it to complete with wait.
Shell Creation Steps
1.init Process
o The very first process started by the
kernel during boot (PID = 1).
o Responsible for initializing the system
and starting system services.
2.getty Process
o init launches getty on terminals (virtual
consoles or serial ports).
o getty manages the login prompt — it
opens the terminal, sets modes, and
waits for user input.
3.login Process
o After user enters username at getty
prompt, login authenticates the user by
verifying the password.
o On successful authentication, login sets
up the user environment (home directory,
shell, etc.).
4.User’s Shell
o Finally, login starts the user’s shell
(e.g., bash, sh, ksh).
 o The shell provides the command prompt,
accepting and executing user commands.

Flow Diagram:
Kernel boot
↓
init (PID 1)
↓
getty (terminal login prompt)
↓
login (user authentication)
↓
User’s Shell (command prompt)

Summary:
Ste
Role
p
Starts system services and
init
terminals
gett
Presents login prompt on terminal
y
logi Authenticates user and sets
n environment
Ste
Role
p
Shel Provides user interface for
l commands

Process States in UNIX

Every process in UNIX is always in one of several
states that describe what it is currently doing or
waiting for.

Common Process States

State
Full Name Description
Code
The process is actively
R Running running on the CPU or ready
to run.
The process is waiting
(sleeping) for some event or
S Sleeping
resource. Usually
interruptible sleep.
Waiting for I/O (disk,
Uninterruptibl
D network), cannot be
e Sleep
interrupted by signals.
T Stopped The process has been
stopped (usually by a signal
State
Full Name Description
Code
like SIGSTOP).
The process has terminated
but still has an entry in the
Z Zombie process table because its
parent hasn’t acknowledged
it yet.
Process is idle kernel thread
Idle (Linux
I (not always shown in all
specific)
UNIX variants).

How to See Process States?

Use ps or top commands and check the STAT or S
column.
Example:
ps aux
You’ll see a STAT column like:
R Running
S Sleeping
Z Zombie
T Stopped

Additional Notes
  Processes can move between states, for
example from Running → Sleeping → Running.
 Zombie processes are usually harmless but
indicate that the parent process hasn't
waited on the child.
 T (stopped) processes can be resumed with
kill -CONT PID.

Summary Table
Cod Example
Description
e Usage/Meaning
Running or Process currently using
R
runnable CPU or ready
Sleeping Waiting for input or
S
(interruptible) resource
Uninterruptible Waiting for I/O
D
sleep (disk/network)
Stopped or Suspended by signal (e.g.,
T
traced Ctrl+Z)
Defunct process, exited
Z Zombie
but not reaped

Zombie State
A zombie process is a process that has
completed execution but still has an entry
in the process table. It’s also called a defunct
process.

What is a Zombie Process?

 When a child process finishes, it sends an
exit status to its parent.
 The child process remains in the process
table as a zombie until the parent reads its
exit status using wait() or waitpid().
 Zombies do not consume CPU or memory,
but they use a process ID (PID).
 If the parent never collects the exit status,
zombies accumulate and may exhaust
system resources.

How Does a Zombie Appear?

 After process terminates:
o It becomes a zombie.
o It still shows up in ps output with status
Z.
Example output:
$ ps aux | grep Z
user 12345 0.0 0.0 0 0? Z 12:34
0:00 [defunct]
How to Handle Zombies?
1.Parent should call wait() to clean up the
zombie.
2.If the parent process dies, the init process
(PID 1) adopts the zombie and cleans it up.
3.To manually remove zombies, you can:
o Restart the parent process.
o Kill the parent process (if safe).

Why Zombies are Important?

 Zombies indicate that the parent process is
not properly cleaning up child processes.
 Accumulated zombies can exhaust the
maximum number of processes allowed.

Summary
Aspect Description
State
Z (Zombie / Defunct)
Code
Process terminated but not
Meaning
waited on
Consume
No CPU/memory, holds PID
s
Solution Parent calls wait() to reap
Aspect Description

Background Jobs
Background jobs let you run commands without
waiting for them to finish, so you can keep using
the shell prompt.

1. Using & Operator

 Add & at the end of a command to run it in
the background.
sleep 30 &
 Shell immediately returns prompt.
 The job runs independently.
 You can see jobs with jobs command.
 Bring job to foreground with fg %job_number.

2. Using nohup Command

 nohup (no hangup) runs a command immune
to hangup signals.
 This means the command keeps running
even if you close the terminal.
nohup long_running_command &
 Output by default goes to nohup.out.
  Useful for running jobs remotely or when
logging out.

3. Difference Between & and nohup

Aspect & nohup
Job runs in
Yes Yes
background
Survives
No (usually killed) Yes
terminal logout
Terminal (unless nohup.out by
Output file
redirected) default

4. Example
# Run script in background
./backup.sh &

# Run script in background, immune to logout

nohup ./backup.sh &

5. Managing Background Jobs

 jobs — list background jobs.
 fg %1 — bring job 1 to foreground.
 bg %1 — resume stopped job 1 in
background.
  kill %1 — terminate job 1.

Summary
Command Purpose
command & Run command in background
nohup Run command immune to
command & hangup
jobs List background jobs
fg %job / bg
Manage job state
%job

🌟 Reduce Priority of a Process Using nice in

UNIX Shell
The nice command is used to start a process
with a modified scheduling priority (called
“niceness”).
 A higher nice value means lower priority
(the process gets less CPU time).
 Default nice value is usually 0.
 Nice values range from -20 (highest
priority) to +19 (lowest priority).

Using nice to Reduce Priority

To reduce priority (make process “nicer” to
others), increase the nice value:
nice -n 10 command
This runs command with niceness 10 (lower
priority than default 0).

🔹 Example
nice -n 15 tar -czf backup.tar.gz /large/directory
 Compressing runs with low CPU priority, so
other processes get preference.

🔹 Checking Niceness of a Running Process

Use ps with ni (nice) column:
ps -o pid,ni,cmd -p <PID>
Example:
ps -o pid,ni,cmd -p 1234

🔹 Changing Priority of a Running Process

(renice)
To change priority of an existing process:
renice +10 -p 1234
This sets niceness of process 1234 to 10.

Summary:
Command Purpose
nice -n <value> Start command with given
command nice value
renice <value> -p Change nice value of
<PID> running process
ps -o pid,ni,cmd View niceness of processes

Using Signals to Kill a Process in

UNIX Shell
In UNIX, signals are used to send asynchronous
notifications to processes. You can send signals
to kill, stop, or control processes.

Common Commands to Kill Processes Using

Signals
1. kill Command
Sends a signal to a process by its PID.
kill <signal> <PID>
 Default signal is SIGTERM (signal 15) —
politely asks process to terminate.
 To force kill, use SIGKILL (signal 9).
Examples:
kill 1234 # Sends SIGTERM to process
1234
kill -9 1234 # Sends SIGKILL to force kill
process 1234
kill -SIGSTOP 1234 # Stops (pauses) the process
kill -SIGCONT 1234 # Resumes a stopped
process

2. killall Command
Kills processes by name instead of PID.
killall firefox
 Sends SIGTERM by default.
 Use -9 for force kill.

3. pkill Command
Similar to killall but more flexible (pattern
matching).
pkill -9 sshd

Common Signals for Killing

Numb
Signal Description
er
SIGTER Graceful termination
15
M request
SIGKILL 9 Force kill (cannot be
 Numb
Signal Description
er
caught)
SIGSTO
19 Stop process (pause)
P
SIGCON Continue a stopped
18
T process

How to Find Process IDs

ps aux | grep process_name
or
pidof process_name

Example
pid=$(pidof myprogram)
kill -15 $pid # politely ask to terminate
sleep 5
kill -9 $pid # force kill if still running

Summary
Command Usage
Send termination signal to
kill <PID>
process
Command Usage
kill -9
Force kill process
<PID>
killall
Kill process by name
<name>
pkill Kill processes matching
<pattern> pattern

Sending Jobs to Background and

Foreground
UNIX shells let you manage jobs by sending
them to the background or foreground.

1. Send a Job to Background (bg)

 Use bg to resume a stopped job in the
background.
 Jobs usually get stopped by pressing Ctrl + Z.
Example:
# Start a job
sleep 100
# Press Ctrl+Z to stop (pause) it
[1]+ Stopped sleep 100
# Resume it in background
bg %1
[1]+ sleep 100 &

2. Bring a Job to Foreground (fg)

 Use fg to bring a background or stopped
job to the foreground so you can interact
with it.
Example:
fg %1
 Brings job number 1 to foreground.

3. List Jobs
jobs
Shows jobs with job numbers and states.

4. Start Job Directly in Background

Add & at the end of the command:
sleep 100 &

Summary
Comman
Description
d
command
Start command in background
&
Ctrl + Z Stop (pause) running job
Resume stopped job in
bg %job
background
Bring background job to
fg %job
foreground
jobs List current jobs

Listing Jobs with jobs Command

The jobs command shows the list of jobs started
in the current shell session and their status.

What Does jobs Show?

 Job ID (number)
 Process ID (PID)
 Status (Running, Stopped, etc.)
 Command line

How to Use jobs

jobs
Example output:
[1]+ Running sleep 100 &
[2]- Stopped vim file.txt
 [1]+ is job number 1, currently running.
 [2]- is job number 2, currently stopped.
 + and - mark the current and previous job
for fg and bg.

Useful Options
Optio
Description
n
-l List jobs with PIDs
List only PIDs of the
-p
jobs
Example:
jobs -l
Shows something like:
[1]+ 2345 Running sleep 100 &
[2]- 2346 Stopped vim file.txt

Summary
Comman
Purpose
d
List current shell
jobs
jobs
jobs -l List jobs with PIDs
jobs -p List only job PIDs

Suspending a Job in UNIX Shell

How to Suspend a Running Job

 Press Ctrl + Z while the job is running in the
foreground.
 This sends the SIGTSTP signal to the
process, pausing (suspending) it.
 The job moves to a stopped state but
remains in memory.

What Happens After Suspension?

 The shell displays a message like:
[1]+ Stopped command_name
 The job can be resumed later with fg
(foreground) or bg (background).

Example Workflow
$ sleep 100
# Press Ctrl+Z
[1]+ Stopped sleep 100

$ jobs
[1]+ Stopped sleep 100

$ bg %1 # Resume in background
[1]+ sleep 100 &

$ fg %1 # Bring back to foreground

sleep 100

Summary
Command /
Action Effect
Key
Suspend job Ctrl + Z Stops the running job
List Show all
suspended jobs stopped/background
jobs jobs
bg
Resume in Continue job in
%job_numbe
background background
r
 Command /
Action Effect
Key
fg
Resume in Bring job to
%job_numbe
foreground foreground
r

Killing a Job
You can kill a job that’s running or stopped in
your current shell session by sending it a
termination signal.

Steps to Kill a Job

1. List Jobs to Identify Job Number
jobs
Example output:
[1]+ Running sleep 100 &
[2]- Stopped vim file.txt

2. Kill the Job Using kill with Job ID

Use the job ID prefixed with %:
kill %1
 This sends SIGTERM (signal 15) by default to
the job #1.
 You can force kill with SIGKILL:
kill -9 %1

3. Alternatively, Kill by PID

Find the PID using:
jobs -l
Output example:
[1]+ 2345 Running sleep 100 &
Then:
kill 2345

Summary Table
Command Description
List current shell
jobs
jobs
Kill job by job
kill %job_number
number
kill -9
Force kill job
%job_number
jobs -l List jobs with PIDs
kill PID Kill job by PID

⏰ Executing Commands at a Specified Time

in UNIX Shell — at and batch
1. at Command
 Schedules a command or script to run once
at a specific time.
 The job runs when the system clock
reaches the specified time.
 Requires the at daemon (atd) running on the
system.
Basic Usage
at 14:30
Then type commands you want to run at 2:30
PM, end input with Ctrl+D.
Example:
at 22:00
at> /home/user/backup.sh
at> <Ctrl+D>

Check Scheduled Jobs

atq

Remove Scheduled Job

atrm <job_number>

2. batch Command
  Runs commands when system load is low
(based on loadavg).
 Useful for scheduling jobs to run during idle
times without specifying exact time.
Usage
batch
Then type the commands to run, and finish with
Ctrl+D.

Summary
Comman
Purpose When It Runs
d
Schedule job at At the specified
at
specific time time
Schedule job when When system
batch
system is idle load is low

Example: Schedule Backup at 3 AM

echo "/home/user/backup.sh" | at 03:00
Or interactively:
at 03:00
at> /home/user/backup.sh
at> <Ctrl+D>
MODULE-6 Customization
Use of Environment Variables
Environment variables in UNIX are key-value
pairs that define settings and behavior for the
shell and system processes. They are inherited
by child processes and used to configure the
working environment.

🔹 Common Uses of Environment Variables

Example
Use Case Description
Variable
USER, User name and
Set user info
HOME home directory
Configure shell PATH, Set search path
behavior SHELL and shell type
Define system LANG, Language and
settings TERM terminal type
Store session- PWD, Present/previous
specific info OLDPWD working directory
Pass settings to Custom Your own defined
programs/scripts vars variables

🔹 Viewing Environment Variables

printenv # Show all environment
variables
echo $HOME # Show value of a specific
variable
env # Also lists environment variables

🔹 Setting Environment Variables

1. Temporarily (Only in Current Session)
export MYVAR="hello"
echo $MYVAR
2. For a Single Command
MYVAR="value" command_name

3. Permanently (For All Sessions)

Add to shell configuration files like:
 ~/.bashrc (for interactive shells)
 ~/.bash_profile or ~/.profile (for login shells)
Example:
export EDITOR=nano
Then run:
source ~/.bashrc
🔹 Modifying Important Environment
Variables
PATH – System path for command lookup:
echo $PATH
export PATH=$PATH:/custom/bin

🔹 Example Use in Script

#!/bin/bash
echo "Your home is $HOME"
echo "The current user is $USER"

Summary
Command Purpose
echo $VAR Show value of variable
export
Set variable (temporarily)
VAR=value
List all environment
env, printenv
variables
Remove an environment
unset VAR
variable

Common Environment Variables

Here’s a list of frequently used environment
variables in UNIX along with their meanings and
usage:

Variable Description
The path to the current user's home
HOME
directory.Example: /home/alice
A colon-separated list of directories the
shell searches for
PATH
executables.Example:
/usr/local/bin:/usr/bin:/bin
LOGNA The login name of the current user
ME (same as $USER in most cases).
The username of the currently logged-
USER
in user.
Specifies the type of terminal to
TERM
emulate (e.g., xterm, vt100).
Present Working Directory — shows the
PWD
current directory you’re in.
Primary shell prompt string — defines
how your command prompt looks.
PS1
Default: usually \u@\h:\w\$
(user@host:cwd$)
PS2 Secondary prompt — shown when a
command is incomplete (e.g., waiting
Variable Description
for more input).Default: >

🔹 Example Usage
echo $HOME # Displays your home directory
echo $PATH # Shows all paths where shell
looks for commands
echo $PWD # Shows your current working
directory

🔹 Modifying a Variable
export PATH=$PATH:/custom/bin # Add
/custom/bin to your PATH
export PS1=">> " # Change shell
prompt

🔹 Tip
To permanently change an environment
variable, add the export line to your shell config
file:
 For bash: ~/.bashrc or ~/.bash_profile
 For zsh: ~/.zshrc

Aliases
Aliases in UNIX shell are shortcuts or custom
names for longer commands. They help you
save time, reduce typing, and avoid mistakes
with frequently used or complex commands.

🔹 Create an Alias
Temporary Alias (lasts for current shell
session):
alias name='command'
Example:
alias ll='ls -l'
alias gs='git status'
alias rm='rm -i' # Prompts before deleting

🔹 Use the Alias

ll # Runs: ls -l
gs # Runs: git status

🔹 View All Defined Aliases

alias

🔹 Remove an Alias
unalias name
Example:
unalias ll

🔹 Make Alias Permanent

Add it to your shell’s config file:
 Bash: ~/.bashrc or ~/.bash_profile
 Zsh: ~/.zshrc
Example (~/.bashrc):
alias lla='ls -la'
alias c='clear'
Then run:
source ~/.bashrc

🔹 Notes
 Aliases do not accept arguments. For that,
use a function.
 You can view the actual command behind an
alias:
type ll

✅ Summary
Command Purpose
alias
Create alias
name='cmd'
Command Purpose
unalias name Remove alias
alias List all aliases
type See what an alias
alias_name maps to

Brief Idea of Command History

The command history feature in UNIX shells
lets you view, reuse, and manage previously
executed commands—saving time and effort.

🔹 View Command History

history
 Displays a numbered list of recent
commands.
 Example:
 101 ls -l
 102 cd /var/log
 103 grep "error" syslog

🔹 Reuse Past Commands

Synt
Action
ax
!! Run the last command again
!n Run command number n from history
!-n Run the command that was n steps ago
! Run the most recent command starting
string with string
Examples:
!! # Run the last command
!105 # Run command number 105
!ls # Run last command that started with
'ls'

🔹 Search History (Interactive)

 Reverse search: Press Ctrl + R and start
typing
 (reverse-i-search)`ssh`: ssh user@server
 Press Enter to execute, or arrow keys to edit.

🔹 Configuration
Where Is History Stored?
 Usually stored in ~/.bash_history (for Bash)
or ~/.zsh_history (for Zsh).
  You can view or edit this file directly.

🔹 Useful History Commands

history # View command history
history -c # Clear history (current session)
history -d N # Delete history entry number N

🔹 Customize History Behavior

Set in .bashrc or .bash_profile:
export HISTSIZE=1000 # Number of
commands to keep in memory
export HISTFILESIZE=2000 # Number of
commands to keep in .bash_history file

✅ Summary
Comman
Description
d
Show history of
history
commands
!! Repeat last command
Run specific past
!n / !cmd
command
Ctrl + R Reverse search in
Comman
Description
d
history
Clear the command
history -c
history

Prepare File for Printing Using pr

Command
The pr command in UNIX is used to format text
files for printing. It adds features like headers,
page breaks, margins, columns, and more.

🔹 Basic Syntax
pr [options] filename

🔹 Common pr Options
Option Description
-n Add line numbers
-d Double-space the output
-t Remove headers and footers
-h "text" Set a custom header
Set page length to N lines
-l N
(default is 66)
Option Description
-o N Set left margin offset to N spaces
Set page width (for multicolumn
-w N
output)
- Format output into that many
COLUMN columns

🔹 Examples
1. Format file for printing:
pr myfile.txt
Adds headers with filename, date, and page
numbers.

2. Format into 2 columns:

pr -2 myfile.txt

3. Add line numbers:

pr -n myfile.txt

4. Custom header and no footer:

pr -h "Monthly Report" -t myfile.txt

5. Format and send to printer:

pr myfile.txt | lpr
✅ Summary
The pr command is a simple but powerful tool to:
 Prepare text files for printing
 Control page layout
 Format output into columns
 Add headers, margins, and spacing

Custom Display of File Using

head and tail
The head and tail commands are used to view
specific parts of a file — typically the beginning
or end. They are very useful for quickly checking
logs, data, or config files.

🔹 head Command – Show First N Lines

Syntax:
head [options] filename
Common Usage:
Command Description
head Shows first 10 lines
filename.txt (default)
head -n 5 Shows first 5 lines
Command Description
file.txt
head -c 20 Shows first 20
file.txt bytes/characters

🔹 tail Command – Show Last N Lines

Syntax:
tail [options] filename
Common Usage:
Command Description
Shows last 10 lines
tail file.txt
(default)
tail -n 15
Shows last 15 lines
file.txt
tail -c 30 Shows last 30
file.txt bytes/characters

🔹 Live Monitoring with tail -f

tail -f /var/log/syslog
 Continuously shows new lines as they’re
added (real-time monitoring).
 Useful for logs and debug output.
🔹 Combining head and tail for Custom
Range
Example: View lines 11 to 20 of a file:
head -n 20 file.txt | tail -n 10
 head -n 20 gets the first 20 lines.
 tail -n 10 trims it to the last 10 of those =
lines 11–20.

✅ Summary
Command
Output
Example
head file.txt First 10 lines
tail file.txt Last 10 lines
Live output as file
tail -f file.txt
grows
`head -n 50 tail -n 10`

Vertical Division of File Using cut

The cut command in UNIX is used to extract
specific columns (fields or characters) from
each line of a file — this is known as vertical
division.

🔹 Syntax
cut [OPTION]... [FILE]

🔹 Common Options
Optio
Description
n
-b Select bytes
-c Select characters
Select fields
-f
(columns)
Set delimiter (used
-d
with -f)

🔹 Examples
1. Cut by Byte Position
cut -b 1-5 file.txt
→ Prints first 5 bytes from each line.

2. Cut by Character Position

cut -c 1-10 file.txt
→ Prints first 10 characters of each line.

3. Cut by Fields with Delimiter

cut -d ':' -f 1 /etc/passwd
→ Shows the first field (username) from the
colon-separated /etc/passwd file.

4. Cut Multiple Fields

cut -d ',' -f 1,3 file.csv
→ Extracts fields 1 and 3 from a CSV file.

5. Cut a Range of Fields

cut -d ':' -f 2-4 file.txt
→ Extracts fields 2 to 4 using : as the delimiter.

✅ Summary
Use Case Command Example
First 5 bytes cut -b 1-5 file.txt
First 10 characters cut -c 1-10 file.txt
2nd column from CSV cut -d ',' -f 2 data.csv
Multiple fields from cut -d ':' -f 1,3
passwd /etc/passwd

Combine Files Horizontally

Using paste
The paste command in UNIX is used to merge
lines of multiple files horizontally (i.e., side-
by-side). This is called horizontal concatenation
of file contents.

🔹 Syntax
paste [OPTION]... [FILE]...

🔹 How It Works
Each line of the input files is joined together with
a tab (by default), producing one combined line
per output line.

🔹 Examples
1. Basic Horizontal Merge
Given two files:
file1.txt
Alice
Bob
Charlie
file2.txt
Math
Science
English
paste file1.txt file2.txt
Output:
Alice

Math
Bob

Science
Charlie

English

2. Custom Delimiter
paste -d ',' file1.txt file2.txt
→ Uses , instead of a tab.
Output:
Alice,Math
Bob,Science
Charlie,English

3. Merge All Lines From One File Into One

Line
paste -s file1.txt
-s (serial) merges all lines from a file into a single
line separated by tabs.
Output:
Alice Bob

Charlie

4. Use Multiple Delimiters

paste -d ":|" file1.txt file2.txt
→ Cycles through : and | as delimiters between
columns.

✅ Summary
Option Description
paste f1 Join files line-by-line with
f2 tabs
-d DELIM Use custom delimiter
Merge all lines of each file
-s
into one

Sort File Using sort

The sort command in UNIX is used to sort lines
of text files. You can sort alphabetically,
numerically, by column, and more.
🔹 Basic Syntax
sort [OPTIONS] filename

🔹 Common Examples
1. Alphabetical Sort
sort file.txt
→ Sorts lines in ascending (A–Z) order.

2. Reverse Sort
sort -r file.txt
→ Sorts lines in descending (Z–A) order.

3. Numeric Sort
sort -n numbers.txt
→ Sorts lines based on numeric value.

4. Sort by Specific Column (Field)

Given a file:
apple 20
banana 10
grape 15
sort -k2 file.txt
→ Sorts by the second field (column).

5. Sort by Column Numerically

sort -k2 -n file.txt
→ Sorts the second column numerically.

6. Remove Duplicates While Sorting

sort -u file.txt
→ Sorts and removes duplicate lines.

🔹 Useful Options
Optio
Description
n
-r Reverse order
-n Numeric sort
-k N Sort by Nth field/column
-u Unique lines only
Set custom delimiter (default is
-t
space)
-o Write result to output file

🔹 Example with Delimiter

If you have a CSV file:
sort -t ',' -k2 file.csv
→ Sorts based on the second column, using
comma as delimiter.

✅ Summary
Command
Task
Example
Basic sort sort file.txt
Reverse sort sort -r file.txt
Numeric sort sort -n file.txt
Sort by column sort -k3 file.txt
Remove duplicatessort -u file.txt
Custom delimiter sort -t',' -k2
sort file.csv

Finding Repetition and Non-

Repetition Using uniq
The uniq command is used to filter out or
identify repeated lines in a sorted file or
input. It detects adjacent duplicate lines and
can show unique or repeated lines.

🔹 Important: uniq works on consecutive

duplicate lines
So, usually you run sort first to group duplicates
together.

🔹 Basic Syntax
uniq [OPTIONS] [input_file] [output_file]

🔹 Common Uses and Options

Command Description
Removes consecutive duplicate
uniq file.txt
lines
sort file.txt | Removes all duplicates after
uniq sorting
Prefixes lines with count of
uniq -c file.txt
occurrences
uniq -d file.txt Prints only duplicate lines
Prints only unique (non-repeated)
uniq -u file.txt
lines

🔹 Examples
Given file data.txt:
apple
apple
banana
banana
banana
cherry
apple
1. Remove consecutive duplicates:
uniq data.txt
Output:
apple
banana
cherry
apple

2. Remove all duplicates (sort first):

sort data.txt | uniq
Output:
apple
banana
cherry

3. Show counts of each line:

sort data.txt | uniq -c
Output:
3 apple
 3 banana
1 cherry

4. Show only duplicates:

sort data.txt | uniq -d
Output:
apple
banana

5. Show only unique lines (no duplicates):

sort data.txt | uniq -u
Output:
cherry

✅ Summary
Optio
Purpose
n
-c Count occurrences
Show only duplicate
-d
lines
Show only unique
-u
lines
 Manipulating Characters Using
tr
The tr command in UNIX is used to translate,
delete, or squeeze characters from standard
input and write the result to standard output. It’s
a handy tool for simple character-level
transformations.

🔹 Basic Syntax
tr [OPTION] SET1 [SET2]
 Translates characters in SET1 to
corresponding characters in SET2.
 Reads from standard input, writes to
standard output.

🔹 Common Uses of tr
Command
Operation Description
Example
Translate Convert all
lowercase to tr 'a-z' 'A-Z' lowercase letters to
uppercase uppercase
Delete tr -d '0-9' Delete all digits
 Command
Operation Description
Example
characters from input
Replace multiple
Squeeze
tr -s ' ' spaces with single
repeated chars
space
Replace 'a' with '1',
Replace tr 'abc'
'b' with '2', 'c' with
characters '123'
'3'
Delete all except
Complement
tr -cd 'a-z\n' lowercase letters
(invert set)
and newline

🔹 Examples
1. Convert lowercase to uppercase
echo "hello world" | tr 'a-z' 'A-Z'
Output:
HELLO WORLD

2. Delete digits from input

echo "abc123def456" | tr -d '0-9'
Output:
abcdef
3. Squeeze multiple spaces into one
echo "This is spaced" | tr -s ' '
Output:
This is spaced

4. Replace characters
echo "abcabc" | tr 'abc' '123'
Output:
123123

5. Remove all characters except letters and

newline
echo "Hello 123! World" | tr -cd 'A-Za-z\n'
Output:
HelloWorld

✅ Summary
Optio
Meaning
n
-d Delete characters
-s Squeeze repeated characters
Complement set (invert
-c
selection)
Searching Patterns Using grep
The grep command is a powerful tool used to
search for specific patterns or strings in files
or input text. It prints lines that match the given
pattern.

🔹 Basic Syntax
grep [OPTIONS] PATTERN [FILE...]
 PATTERN can be a simple string or a regular
expression.
 If FILE is omitted, grep reads from standard
input.

🔹 Common Examples
1. Search for a simple word in a file
grep "error" logfile.txt
→ Prints lines containing the word error.

2. Case-insensitive search
grep -i "warning" logfile.txt
→ Matches Warning, WARNING, etc.

3. Show line numbers with matching lines

grep -n "fail" logfile.txt
Output example:
23:Failed to start service
57:fail to connect

4. Search recursively in directories

grep -r "TODO" /path/to/code/
→ Search all files in directory and subdirectories.

5. Search for exact word match

grep -w "cat" file.txt
→ Matches only the whole word cat, not catalog.

6. Invert match (show lines NOT containing

pattern)
grep -v "debug" logfile.txt
→ Prints all lines that do not contain "debug".

7. Count number of matching lines

grep -c "error" logfile.txt
→ Outputs the number of lines containing "error".

🔹 Useful Options Summary

Optio
Description
n
-i Case-insensitive search
-n Show line numbers
-r Recursive search
Invert match (exclude
-v
matches)
-w Match whole word
-c Count matches
List filenames with
-l
matches

🔹 Example: Search for "fail" in all .log files,

ignore case, and show line numbers
grep -i -n "fail" *.log

Basic Regular Expressions (BRE)

Basic Regular Expressions (BRE) are a way to
describe search patterns used by commands like
grep, sed, and vi in UNIX. They allow powerful
pattern matching in text.

🔹 What is BRE?
  BRE defines a syntax for matching text
patterns.
 Used by default in commands like grep.
 Allows matching characters, ranges,
repetitions, anchors, and grouping.

🔹 Common BRE Metacharacters and Usage

Symb Examp
Meaning Matches
ol le
Any single
. a.b aab, acb, a1b
character
Zero or more of
* lo*l ll, lol, lool, loool
preceding char
Start of line Lines starting
^ ^Hello
anchor with Hello
End of line Lines ending
$ end$
anchor with end
Any vowel
[...] Character class [aeiou]
character
Negated
[^...] [^0-9] Any non-digit
character class
\ Repetition (m to a\
aa, aaa, or aaaa
{m,n\} n times) {2,4\}
\ Escape special \. Matches a literal
Symb Examp
Meaning Matches
ol le
character dot .
Grouping Zero or more
\(...\) \(ab\)*
(capture group) repetitions of ab

🔹 Example Patterns
 Find lines containing "cat" or "cot":
grep 'c[ao]t' file.txt
 Find lines starting with "Error":
grep '^Error' file.txt
 Find lines ending with ".txt":
grep '\.txt$' file.txt
 Find lines with 3 to 5 "a"s in a row:
grep 'a\{3,5\}' file.txt

🔹 Notes
 In BRE, some metacharacters like {}, (), +
need to be escaped with backslash (\).
 For extended regex (ERE), these do not
require escaping (use grep -E or egrep).

✅ Summary
 BRE Example
Task
Pattern Command
Match any
. grep 'a.b' file
character
Zero or more
* grep 'lo*l' file
repeats
Start of line ^ grep '^Start' file
End of line $ grep 'end$' file
Character class [abc] grep '[aeiou]' file
grep 'a\{2,4\}'
Repetition counts \{m,n\}
file

egrep
egrep stands for “extended grep” and is used
to search files for patterns using Extended
Regular Expressions (ERE).

🔹 What is egrep?
 It’s like grep -E.
 Supports more powerful regex features
without needing to escape special
characters like {}, +, ?, |, () that you must
escape in Basic Regular Expressions (BRE).
 Useful for complex pattern matching.
🔹 Basic Syntax
egrep [OPTIONS] PATTERN [FILE...]

🔹 Features of Extended Regular Expressions

(ERE)
Metacharac
Meaning Example
ter
Zero or one colou?r matches
?
occurrence color or colour
go+gle matches
One or more
+ gogle, google,
occurrences
gooogle
Between m and a{2,4} matches
{m,n}
n occurrences aa, aaa, or aaaa
` ` Alternation (OR)
(ab)+ matches ab,
() Grouping
abab, ababab

🔹 Examples
1. Search for lines containing “cat” or
“dog”
egrep 'cat|dog' file.txt
2. Search for words with optional "u" (color
or colour)
egrep 'colou?r' file.txt

3. Search lines with one or more 'o's in a

row
egrep 'go+gle' file.txt

4. Grouping and repetition

egrep '(ab){2,3}' file.txt
Matches lines with abab or ababab.

🔹 Note
 Modern systems often alias egrep to grep -
E.
 egrep is deprecated in some systems;
prefer grep -E.

✅ Summary
Command
Task
Example
Use alternation (OR) `egrep 'cat
Use optional egrep 'colou?r'
character file
 Command
Task
Example
One or more egrep 'go+gle'
repetitions file
Grouping and egrep '(ab){2,3}'
counts file

grep -E
grep -E is the command to use Extended
Regular Expressions (ERE) with grep. It
behaves like egrep (which is often an alias for
grep -E).

🔹 What is grep -E?

 Enables extended regex syntax for pattern
matching.
 Allows use of special characters like +, ?, {},
|, () without escaping.
 Preferred over egrep since egrep is
sometimes deprecated.

🔹 Basic Syntax
grep -E [OPTIONS] PATTERN [FILE...]

🔹 Examples Using Extended Regex

1. Match lines containing “cat” or “dog”
grep -E 'cat|dog' file.txt

2. Match “color” or “colour” (optional 'u')

grep -E 'colou?r' file.txt

3. Match one or more 'o's in a row

grep -E 'go+gle' file.txt

4. Match repeated groups

grep -E '(ab){2,3}' file.txt
Matches abab or ababab.

🔹 Summary of Extended Regex

Metacharacters Supported by grep -E
Symb
Meaning
ol
? Zero or one occurrence
One or more
+
occurrences
Between m and n
{m,n}
repetitions
` `
Symb
Meaning
ol
() Grouping

🔹 Why Use grep -E?

 More concise patterns without backslashes.
 Compatible with modern scripting.
 Same powerful matching as egrep.

If you want, I can help craft grep -E commands

tailored to your needs!