LINUX AND SHELL SCRIPTING

1. Identify a command to find all files ending with ".txt" in a directory and copy
them to a new directory named "backup".

Ans:

To find all .txt files in a directory and copy them to a new directory called backup, we use the
following command:

mkdir -p backup && find . -type f -name "*.txt" -exec cp {} backup/ \;

mkdir -p backup:
This command creates a directory named backup. The -p option ensures that no error occurs
if the directory already exists.

find . -type f -name "*.txt":

 find is used to search files and directories.

 . means current directory (search starts here).

 -type f limits the search to regular files only.

 -name "*.txt" filters files that end with .txt using a wildcard pattern.

-exec cp {} backup/ \;:

 For each .txt file found, cp (copy command) is executed.

 {} is replaced by the filename found.

 Files are copied to the backup directory.

 \; ends the -exec part.

2. Recall a command to modify the permissions of a file (initially "-rw-r--r--") to

allow the owner to execute it, without changing other permissions.

Ans:

chmod u+x filename

 chmod: Changes file permissions.

 u: Refers to the file owner.
 +x: Adds execute permission.
 This updates -rw-r--r-- to -rwxr--r--, allowing only the owner to execute the file.

The command chmod u+x adds execute permission for the owner only, which is essential for
making a script or program executable without altering group or others' access.

KR
 3. Name the command to create a symbolic link to a deeply nested directory from
your current working directory.

Ans:

Use the ln command with the -s option:

ln -s /path/to/deeply/nested/directory link1

 ln: Command to create links.

 -s: Creates a symbolic (soft) link.
 /path/to/deeply/nested/directory: Path to the target directory.
 link1: Name of the symbolic link created in the current directory.

4. Recognize the use of both relative and absolute paths in different scenarios.

Ans:

Absolute Path:

 Starts from the root directory /.

 Gives the full path to a file or directory regardless of the current working directory.

 Example: /home/user/documents/file.txt

 Use when you want to specify a file/directory location unambiguously from anywhere
in the system.

Relative Path:

 Starts from the current working directory.

 Uses . (current directory) and .. (parent directory) to navigate.

 Example: ../documents/file.txt or ./file.txt

 Use when working within a known directory structure and you want shorter paths.

Use absolute paths for scripts, commands, or programs needing fixed locations.

Use relative paths for quick access when inside related directories, making commands
shorter and flexible.

5. List the commands to display only the first 10 lines, and then the last 15 lines of
a large log file.

Ans:

KR
To display the first 10 lines of a file, use:
head filename.log

To display the last 15 lines of a file, use:

tail -n 15 filename.log

6. Recall the use of the `tar` command to create a compressed archive of a

directory.

Ans:

Use the following command to create a compressed archive (.tar.gz) of a directory:

tar -czvf archive_name.tar.gz directory_name/

 tar: Tape Archive command to create archives.

 -c: Create a new archive.

 -z: Compress the archive using gzip.

 -v: Verbose mode (shows files being processed).

 -f: Specifies the archive file name.

 archive_name.tar.gz: Name of the compressed archive file.

 directory_name/: The directory to be archived and compressed.

7. Identify wildcards to locate a file when you only know part of its name.

Ans:

Wildcards help match filenames when you only know part of the name:

 * (asterisk): Matches zero or more characters.

Example: file* matches file, file1.txt, filename.txt.

 ? (question mark): Matches exactly one character.

Example: file?.txt matches file1.txt, fileA.txt but not file12.txt.

 [] (square brackets): Matches any one character inside brackets.

Example: file[12].txt matches file1.txt or file2.txt only.

Example:

ls file*.txt

This lists all files starting with file and ending with .txt.

KR
 8. Describe the difference between hard links and symbolic links in the Linux file
system.

Ans:

Hard Link Symbolic (Soft) Link

Points directly to the inode (file data) Points to the file name (path)

Can only link to files Can link to files and directories

File remains accessible if original is deleted Link breaks if original file is deleted

Cannot cross different filesystems Can link across different filesystems

Shares the same inode number as the original Has a different inode number
file

Cannot be created for directories Can be created for directories

9. Recall a command to list files in a directory in reverse order of modification

time

Ans:

Use the ls command with -lt and -r options:

ls -ltr

 ls: Lists files and directories.

 -l: Long listing format (detailed info).

 -t: Sort by modification time (newest first).

 -r: Reverse the order (oldest first).

This command lists files with the oldest modified files at the top and the newest at the
bottom.

10. Name a command to create a new directory and its parent directories, if they do
not exist.

Ans:

Use the mkdir command with the -p option:

mkdir -p /path/to/new/directory

 mkdir: Command to create directories.

 -p: Creates parent directories as needed without error if they already exist.

KR
 11. List the commands to list the shells available in your system, and the steps to
change your login shell to Zsh.

Ans:

1. List available shells:

cat /etc/shells

This command displays the file /etc/shells which contains a list of all valid login shells
installed on the system.

2. Change login shell to Zsh:

chsh -s /bin/zsh

 chsh stands for change shell.

 The -s option specifies the new shell to use, here /bin/zsh (path to Zsh shell).
 You need to enter your password when prompted.
 After running this command, log out and log back in for the change to take effect.

12. Recall a command to display a file’s content and number each line

Ans:

Use the cat command with the -n option:

cat -n filename

 cat: Displays the content of a file.

 -n: Numbers all the output lines.

This command shows the file content with line numbers for easier reference.

13. Identify the use of `find` and `xargs` to search and delete specific file types

Ans:

 The find command searches for files based on conditions like name, type, size, etc.

 xargs takes the output of find and executes commands (like rm) on those files
efficiently.

Example to find and delete all .log files:

find /path/to/dir -name "*.log" -print0 | xargs -0 rm -f

 find /path/to/dir -name "*.log": Finds all files ending with .log.

 -print0: Prints file names separated by null character (handles spaces).

 xargs -0 rm -f: Takes input and deletes files forcefully.

KR
 14. Recall the `locate` and `updatedb` commands used to improve file search
efficiency.

Ans:

 locate: Quickly searches for files by name using a pre-built database instead of scanning
the entire filesystem in real-time.
Example:

locate filename

 updatedb: Updates the database used by locate to include the latest files and directories
on the system.
Run this command periodically or manually to keep the database current:

sudo updatedb

locate is faster than find because it searches a database; updatedb keeps that database up-
to-date.

15. List steps to construct a backup strategy using `cron` and `tar`.

Ans:

1. Create a script using tar to compress files:

tar -czf /backup/backup_$(date +%F).tar.gz /myfolder

2. Make the script executable:

chmod +x backup.sh

3. Open cron editor:

crontab -e

4. Add a cron job to run the script daily at 2 AM:

0 2 * * * /path/to/backup.sh

5. Save and exit. Backup runs automatically every day.

16. Name common Linux file systems and their characteristics.

Ans:

Common Linux File Systems and Their Characteristics

1. ext3 (Third Extended Filesystem) – Supports journaling for better reliability, and is
backward compatible with ext2. It's stable but slower compared to newer file systems.

KR
 2. ext4 (Fourth Extended Filesystem) – The default in many Linux distros. Offers faster
performance, journaling, support for large files, and better reliability than ext3.

3. XFS – A high-performance journaling file system, ideal for handling large files and
scalable systems. Often used in enterprise environments.

4. Btrfs (B-tree File System) – A modern Linux file system with advanced features like
snapshots, compression, and self-healing. It's still evolving but powerful.

5. FAT32 – Widely supported across different operating systems. Doesn’t support

journaling and has a 4GB file size limit. Commonly used in USB drives.

6. NTFS – Developed by Microsoft. Linux can access it using tools like ntfs-3g. It
supports large files, permissions, and journaling.

17. Identify the output of commands that display file and directory information

Ans:

1. ls

 Lists files and directories in the current directory.

2. ls -l

 Long listing format: shows file permissions, owner, group, size, and modification date.

Example output:

-rw-r--r-- 1 user user 1234 May 30 10:00 file.txt

3. ls -a

 Displays all files, including hidden ones (those starting with .).

4. stat filename

 Shows detailed information about a file, including size, permissions,

access/modify/change times.

5. file filename

 Tells the file type (e.g., text, executable, directory).

6. du -sh directory/

 Displays total disk usage of a directory in human-readable format.

18. List a sequence of commands to archive, compress, and then list the contents of
an archive.

Ans:

KR
 1. Archive files using tar:

tar -cf archive.tar file1 file2 dir1

 -c: create archive

 -f: filename of archive

2. Compress the archive using gzip:

gzip archive.tar

 Creates archive.tar.gz

3. List contents of the compressed archive:

tar -tf archive.tar.gz

 -t: list contents

 -f: specify archive file

These steps first create an archive (tar), compress it (gzip), and then view its contents (tar -t).

19. Define environment variables and their significance in Unix/Linux.

Ans:

Environment variables are dynamic values stored in the shell's environment that affect the
behaviour of running processes and system configuration in Unix/Linux.

Significance:

1. Configuration:
They help configure the behavior of the system or applications (e.g., PATH, HOME).

2. Access Everywhere:
Environment variables are inherited by child processes, making them accessible
globally in scripts and programs.

3. Shell Customization:
Variables like PS1, HISTSIZE, and LANG allow users to personalize their shell
environment.

4. Scripting Use:
They allow dynamic handling of user-specific or system-specific paths, options, and
credentials in shell scripts.

5. Session Information:
Variables like USER, SHELL, and PWD store current user and session-specific
information.

KR
Common examples:

 PATH – defines executable search path

 HOME – user’s home directory

 EDITOR – default text editor

20. List common shell variables and their uses.

Ans:

 PATH — Directories searched for executable commands.

Command to view: echo $PATH
 HOME — Current user’s home directory.
Command to view: echo $HOME
 USER — Username of the logged-in user.
Command to view: echo $USER
 SHELL — The user’s default shell.
Command to view: echo $SHELL
 PWD — Present working directory.
Command to view: echo $PWD

21. Recall how to create and use aliases in the shell

Ans:

Aliases are shortcuts to longer commands, making them easier to type and remember.

Syntax:

alias shortname = ‘full command’

Example:
alias ll='ls -l'

This creates an alias ll for the long listing command ls -l.

Permanent Aliases: Add them to your ~/.bashrc file.

Then run:

source ~/.bashrc

to apply the changes.

KR
 22. Describe the purpose of shell initialization files (e.g., `.bashrc`, `.bash_profile`)

Ans:

Shell initialization files are scripts that run automatically when a shell session starts. They help
set up the user environment in Unix/Linux systems.

Common Files and Their Purpose:

1. .bashrc

 Runs for interactive non-login shells (e.g., when you open a new terminal
window).

 Used to set aliases, environment variables, functions, and prompt styles.

2. .bash_profile

 Runs for login shells (e.g., when logging in via terminal or SSH).

 Typically used to set environment variables and call .bashrc.

Purpose of These Files:

 Customize the shell behavior.

 Set paths (PATH), editors (EDITOR), and aliases.

 Improve productivity by auto-loading preferences.

23. Identify the use of inline command editing features in the Bash shell.

Ans:

Inline command editing in the Bash shell allows users to edit previously typed commands
directly at the prompt using keyboard shortcuts. This feature improves efficiency and speed
in command-line operations.

Key Features and Uses:

1. Arrow Keys:

o Up/Down Arrows – Scroll through command history.

o Left/Right Arrows – Move the cursor within the current command to edit.

2. Keyboard Shortcuts:

o Ctrl + A – Move cursor to the beginning of the line.

o Ctrl + E – Move cursor to the end of the line.

o Ctrl + U – Delete everything before the cursor.

o Ctrl + K – Delete everything after the cursor.

KR
 o Ctrl + W – Delete the previous word.

o Ctrl + L – Clear the terminal screen.

3. History Expansion:

o !! – Repeats the last command.

o !n – Executes command number n from history.

o !grep – Repeats the last command that started with grep.

Purpose:

 Speeds up editing and reusing commands.

 Reduces typing errors.

 Enhances command-line productivity.

Inline editing makes Bash interactive, user-friendly, and efficient for working with past and
current commands.

24. Recall history commands to execute previous commands efficiently.

Ans:

In the Bash shell, history commands allow users to view, recall, and re-execute previously
typed commands, improving efficiency and reducing repetitive typing.

Useful History Commands:

1. history

 Displays the list of previously executed commands with line numbers.

2. !n

 Executes the command with history number n.

 Example:
!45

(executes command number 45)

3. !!

 Repeats the last executed command.

4. !string

 Executes the most recent command that starts with the given string.

KR
  Example:
!grep

5. ctrl + r (reverse search)

 Starts an interactive search through command history.

 Press repeatedly to cycle through matching commands.

Purpose:

 Speeds up command reuse.

 Saves time by avoiding retyping.

 Useful for correcting or modifying previous commands quickly.

25. Recognize the use of wildcards for flexible pattern matching in command
execution.

Ans:

Wildcards are special characters used in Unix/Linux to match file and directory names based
on patterns, making command execution more flexible and efficient.

Common Wildcards and Their Uses:

1. * (Asterisk)

Matches zero or more characters.

Example:
ls *.txt

(Lists all files ending with .txt)

2. ? (Question Mark)

Matches exactly one character.

Example:
ls file?.txt

(Matches file1.txt, fileA.txt, etc.)

3. [ ] (Square Brackets)

Matches any one character from the set.

Example:
ls file[1-3].txt

(Matches file1.txt, file2.txt, file3.txt)

KR
 4. [! ] or [^ ]

Matches any character except those in the set.

Example:

ls file[!0].txt

(Matches any file except file0.txt)

Purpose:

 Efficient file handling and searching.

 Reduces the need to type full names.

 Enables batch operations on multiple files.

Wildcards simplify working with groups of files by allowing flexible name matching in
commands like ls, cp, mv, and rm.

26. Define the concepts of redirection (`>`, `>>`, `<`) and their applications.

Ans:

Redirection in Unix/Linux allows you to change the standard input (stdin), standard output
(stdout), and standard error (stderr) streams. This is useful for saving output to files, reading
from files, or chaining commands.

Types of Redirection and Their Uses:

Symbol Meaning Example Description

> Output ls > files.txt Redirects standard output to a file

Redirection (overwrites if exists).

>> Append Output echo "done" >> Appends output to a file (does not
log.txt overwrite).

< Input wc -l < data.txt Takes input from a file instead of

Redirection keyboard.

Applications:

1. Saving Command Output

 Store results for later use or documentation.

 Example: df -h > disk_usage.txt

KR
 2. Appending Logs

 Add new entries to log files.

 Example: date >> system_log.txt

3. Providing Input to Programs

 Feed data from a file to a command.

 Example: sort < names.txt

27. Identify the use of pipes (`|`) to chain commands together

Ans:

A pipe (|) is used to pass the output of one command as input to another, enabling multiple
commands to work together efficiently.

Syntax:
command1 | command2

 command1 produces output.

 That output is passed directly as input to command2.

Applications and Examples:

1. Filter Output:

ls -l | grep "^d"

Lists only directories in long format.

2. Count Words or Lines:

cat notes.txt | wc -l

Counts the number of lines in notes.txt.

3. Sort and Remove Duplicates:

cat names.txt | sort | uniq

Sorts the names and removes duplicate entries.

Benefits of Pipes:

 Allows command chaining without intermediate files.

 Improves automation and scripting efficiency.

 Supports the UNIX philosophy: small tools working together.

KR
 28. Describe the functionality of the `tee` command.

Ans:

It reads from standard input and writes to both a file and the terminal (output).

Syntax:
command | tee filename

 Writes output to the terminal (screen) and saves it to the specified file.

 Use -a to append to the file instead of overwriting.

Examples:

1. Save and View Output at the Same Time:

ls -l | tee output.txt

Displays the directory listing and also saves it to output.txt.

2. Append Output to a File:

echo "Backup done" | tee -a log.txt

Adds the message to the end of log.txt.

3. Capture Command Output While Using Pipes:

ps aux | tee processes.txt | grep firefox

Saves all process details and filters for "firefox" at the same time.

Use Cases:

 Logging output while running scripts.

 Debugging by keeping a copy of output.

 Monitoring while saving important information.

29. Recall the concept of command substitution and how to use it

Ans:

Command substitution allows the output of a command to replace the command itself in a
shell command. It is used to embed command results directly within other commands.

Syntax:

There are two common forms:

KR
 1. Using backticks:

`command`

2. Using $():

$(command)

The $() form is preferred for readability and nesting.

Examples:

1. Assign the output of a command to a variable:

current_date=$(date +%F)
echo "Today's date is $current_date"

2. Use in a command directly:

mkdir "backup_$(date +%F)"

Creates a directory named backup_YYYY-MM-DD.

3. Nested substitution:
echo "Number of files: $(ls | wc -l)"

Use Cases:

 Dynamic filenames or directories.

 Automating tasks based on command output.

 Reducing manual input and enhancing scripts.

30. Describe how to manage running processes and jobs.

Ans:

In Unix/Linux, a process is a running instance of a program. A job is a process started by a

shell, often in the background.

Key Commands to Manage Processes and Jobs:

1. ps – Lists currently running processes.

ps aux

KR
 2. top / htop – Real-time process monitoring.
Shows CPU/memory usage and allows killing processes interactively.

3. jobs – Lists background jobs in the current shell.

jobs

4. & – Run a job in the background.

command &

5. fg – Bring a background job to the foreground.

fg %1

6. bg – Resume a suspended job in the background.

bg %1

7. kill – Terminate a process by PID.

kill 1234

8. killall – Kill all processes by name.

killall firefox

9. nice / renice – Start or change process priority.

31. Recall how to execute commands in the background.

Ans:

Executing a command in the background allows the shell to continue accepting new
commands while the current one runs without blocking the terminal.

1. Using & Symbol

To run a command in the background, append an ampersand (&) at the end:

command &

Example:

sleep 60 &

This runs the sleep command in the background and immediately returns control to the
terminal.

2. Viewing Background Jobs

jobs

KR
Lists all background jobs started in the current shell session.

3. Bringing Jobs to Foreground or Background

 fg %job_id — Brings a job to the foreground.

 bg %job_id — Resumes a stopped job in the background.

4. Kill a Background Job

kill %1

Stops the background job with job ID 1.

Running commands in the background using & improves multitasking in Linux. It’s useful for
executing time-consuming processes without blocking your terminal.

32. Identify different ways to interrupt a running process.

Ans:

Interrupting a process means pausing, terminating, or killing it before it finishes execution.

Common Ways to Interrupt a Running Process:

1. Ctrl + C
Sends the SIGINT (Interrupt) signal.
Immediately terminates a foreground process.

2. Ctrl + Z
Sends the SIGTSTP (Stop) signal.
Suspends (pauses) a foreground process and puts it into the background as a
stopped job.

3. kill PID
Sends a signal (default: SIGTERM) to a process using its Process ID (PID).
Example:

kill 1234

4. kill -9 PID
Sends SIGKILL to forcefully terminate a process (cannot be ignored).
Example:

kill -9 1234

KR
 5. killall process_name
Kills all processes with the given name.
Example:

killall firefox

6. Using top or htop

Interactive tools to view running processes.
Press k in top, enter PID, and signal (e.g., 15 or 9) to kill it.

33. Recall how to configure the Bash shell to customize the command prompt.

Ans:

The command prompt in the Bash shell is controlled by the PS1 variable, which defines what
is displayed before each command input.

1. Temporary Customization

You can temporarily change the prompt using the PS1 variable:

PS1="[\u@\h \W]$ "

Explanation of Prompt Elements:

 \u → Username

 \h → Hostname

 \W → Current working directory (basename)

 \w → Full working directory

 \t or \T → Time in 24hr / 12hr format

 \d → Date

Example:
PS1="(\u@\h:\w)\$ "

2. Permanent Customization

To make the prompt change permanent, add the line to your shell initialization file (like
~/.bashrc):

nano ~/.bashrc

Add:

PS1="[\u@\h \W]$ "

KR
Then apply changes:

source ~/.bashrc

Custom prompts can display useful information like Git branches, working directory, or even
emojis to enhance productivity and clarity in terminal sessions.

34. Recognize the output of a complex command involving pipes and redirection

Ans:

Pipes (|) and redirection operators (>, >>, <) allow combining commands and controlling
input/output streams.

Command:

ps aux | grep python | awk '{print $2, $11}' > python_processes.txt

Explanation:

 ps aux
Lists all running processes.
 | grep python
Filters for processes related to Python.
 | awk '{print $2, $11}'
Extracts and prints the Process ID ($2) and the command name ($11).
 python_processes.txt
Saves the filtered and formatted output into the file python_processes.txt.

After running the command, the python_processes.txt file will contain:

1234 python3
1240 /usr/bin/python3

35. Recall commands that use wildcards to target specific files.

Ans:

Wildcards (also called globbing patterns) help match filenames using partial names or
patterns.

Wildcard Description Example Command Effect

KR
 * Matches zero or more ls *.txt Lists all .txt files in the
characters directory

? Matches exactly one ls file?.log Matches file1.log, fileA.log,

character etc.

[ ] Matches any one ls file[123].txt Matches file1.txt, file2.txt,

character inside or file3.txt

[! ] Matches anything not ls file[!0-9].txt Matches files like fileA.txt,

inside not digits

Examples:

1. Delete all .bak files:

rm *.bak

2. Copy all .jpg and .png files:

cp *.{jpg,png} /backup/images/

3. List files starting with "data" and ending with any 2 characters:
ls data??.*

36. Identify a sequence of commands using pipes and redirection to process data.

Ans:

Example Task:
Extract the usernames from /etc/passwd, sort them, and save the top 5 unique names to a
file.

Command Sequence:

cut -d: -f1 /etc/passwd | sort | uniq | head -n 5 > usernames.txt

Explanation:

 cut -d: -f1 /etc/passwd extracts the first field (the username) from each line in
the /etc/passwd file, using the colon : as the delimiter.
 The output is piped into sort, which sorts the usernames alphabetically.
 uniq then removes any duplicate usernames from the sorted list.
 head -n 5 selects only the first 5 entries from the resulting list.
 Finally, the output is redirected using > into a file named usernames.txt.

KR
Output:

Creates a file usernames.txt containing the first 5 unique sorted usernames from
/etc/passwd.

37. Describe the function of the `tr` command and give an example

Ans:

The tr (translate) command in is used to translate, squeeze, or delete characters from

standard input and write the result to standard output.

It is commonly used to:

 Convert lowercase to uppercase (and vice versa)

 Delete specific characters

 Squeeze repeated characters

Example:

To convert lowercase letters to uppercase:

echo "hello world" | tr 'a-z' 'A-Z'

Output:
HELLO WORLD

 echo "hello world" produces the input text.

 tr 'a-z' 'A-Z' translates each lowercase letter to its uppercase equivalent.

The tr command is simple but powerful for basic text transformations directly in the shell.

38. List how to use `head` and `tail` commands to view file sections.

Ans:

head: Displays the first lines of a file.

Syntax:

head -n number filename

Example:

head -n 10 logfile.txt

KR
Shows the first 10 lines of logfile.txt.

Note: By default, head filename shows the first 10 lines if no -n option is given.

tail: Displays the last lines of a file.

Syntax:
tail -n number filename

Example:

tail -n 15 logfile.txt

Shows the last 15 lines of logfile.txt.

Note: By default, tail filename shows the last 10 lines if no -n option is given.

39. Define the purpose of the `cut` command and how to extract fields.

Ans:

Purpose of the cut Command:

The cut command is used to extract specific sections or fields from each line of a text file or
input based on delimiters or character positions. It helps to isolate columns or parts of data
for further processing.

Syntax of cut command:

cut -d 'delimiter' -f field_numbers filename

 -d 'delimiter' : Specifies the delimiter that separates fields (e.g., :, ,, \t).

 -f field_numbers : Specifies which field(s) to extract (e.g., 1 for first field, 1,3 for
first and third fields, 1-4 for range).

How to Extract Fields:

 Use the -d option to specify the delimiter (separator) that divides fields (e.g., : or ,).

 Use the -f option to specify the field number(s) to extract.

Example:

To extract the first field (username) from /etc/passwd where fields are separated by ::

cut -d ':' -f 1 /etc/passwd

This command outputs the first field of each line (usernames).

KR
 40. Recall how to use the `paste` command to combine file contents.

Ans:

Purpose of the paste Command:

The paste command is used to combine corresponding lines from two or more files side by
side, separating them with tabs (by default). It merges files horizontally.

Syntax:

paste file1 file2

This combines the first line of file1 with the first line of file2, second line with second line,
and so on.

Example:

If file1 contains:
apple
banana
cherry

and file2 contains:

red
yellow
dark red

Running
paste file1 file2

outputs:
apple red
banana yellow
cherry dark red

You can also change the delimiter with -d option if needed.

41. Describe the `sort` command and its common options.

Ans:

KR
The sort command in Linux is used to arrange lines in text files in a specified order (default is
ascending alphabetical).

Syntax
sort [options] [filename]

Common Options:

1. -r: Sort in reverse order (descending).

Example: sort -r names.txt

2. -n: Sort numerically (treat values as numbers).

Example: sort -n numbers.txt

3. -t: Specifies delimiter for sorting fields

Example: sort -t ":" -k 2 file.txt

4. -k: Sort using a specific column/field.

Example: sort -k 2 data.txt

5. -u: Remove duplicate lines.

Example: sort -u fruits.txt

6. -o: Write the result to an output file.

Example: sort names.txt -o sorted_names.txt

Example:
sort -n marks.txt

Sorts marks.txt based on numeric order.

42. Recall how the `uniq` command helps identify and remove duplicate lines.

Ans:

The uniq command in Linux is used to filter out or detect duplicate lines in a file. It compares
adjacent lines and removes or displays duplicates based on options.

It is commonly used with sort because uniq only removes consecutive duplicates.

Basic Syntax:

uniq [options] [input_file] [output_file]

KR
Purpose:

 Removes consecutive duplicate lines from a file.

 Useful in combination with sort, because uniq only removes adjacent duplicates.

Common Options:

-c - Prefixes each line with the number of occurrences.

-d - Displays only duplicate lines.

-i - ignores case

-u - Displays only unique (non-repeated) lines

Examples:

$ sort wordlist | uniq # Show unique lines

$ sort wordlist | uniq -i # Ignore case while comparing

$ sort wordlist | uniq -d # Show only lines that are repeated

$ sort wordlist | uniq -c # Show count of each unique line

43. Define regular expressions and their types (basic vs extended)

Ans:

Regular expressions (regex) are patterns used to match character combinations in strings. In
Unix/Linux, they are commonly used with tools like grep, sed, and awk to search, filter, and
manipulate text.

Types of Regular Expressions

1. Basic Regular Expressions (BRE)

 Supported by tools like grep.

 Some special characters need to be escaped with a backslash (\).

 Examples:

 . : Matches any single character.

 * : Matches zero or more of the previous character.

 \+ : Matches one or more of the preceding character (note the escape).

KR
  \? : Matches zero or one occurrence.

2. Extended Regular Expressions (ERE)

 Used with egrep or grep -E.

 Supports more powerful features without needing to escape special characters.

 Examples:

 + : Matches one or more of the preceding element.

 ? : Matches zero or one of the preceding element.

 | : Logical OR between patterns.

 () : Grouping.

Example:

grep 'a\+' file.txt # Using basic regex

grep -E 'a+' file.txt # Using extended regex

 BRE: Less powerful, more escaping.

 ERE: More features, easier syntax for complex patterns.

44. Recall how to use `grep` with basic regular expressions.

Ans:

The grep command searches for patterns in files using basic regular expressions by default.

Syntax:

grep 'pattern' filename

Common BRE Patterns:

1. . – Matches any single character.

grep 'b.t' file.txt matches "bat", "bit", "but"

2. * – Matches zero or more of the preceding character.

grep 'lo*ng' file.txt matches "lng", "long", "loooong"

3. ^ – Anchors the match to the start of a line.

grep '^The' file.txt matches lines starting with "The"

4. $ – Anchors the match to the end of a line.

grep 'end$' file.txt matches lines ending in "end"

KR
 5. [] – Matches any one character inside the brackets.
grep '[aeiou]' file.txt matches any vowel

Example:

grep '^H.*d$' hello.txt

Matches lines that start with H and end with d, with any characters in between.

45. Identify how to use `grep-E` for extended pattern matching.

Ans:

grep -E enables Extended Regular Expressions (ERE), allowing more powerful and flexible
pattern matching without needing to escape special characters.

Syntax:

grep -E 'pattern' filename

or equivalently,
egrep 'pattern' filename

Common Extended Patterns:

 + : Matches one or more of the preceding element.

Example: 'a+' matches "a", "aa", "aaa", etc.

 ? : Matches zero or one of the preceding element.

Example: 'colou?r' matches "color" or "colour"

 | : Logical OR between patterns.

Example: 'cat|dog' matches "cat" or "dog"

 () : Grouping patterns.
Example: '(cat|dog)s?' matches "cat", "cats", "dog", or "dogs"

Example:

grep -E 'cat|dog' animals.txt

Searches for lines containing either "cat" or "dog".

46. Define the concept of stream editing and syntax of the `sed` command.

Ans:

Stream editing means processing and transforming text data line-by-line from a stream (such
as a file or input) without opening it in an editor. It is useful for automated text manipulation
like search-and-replace, deletion, or insertion.

KR
sed Command

sed (Stream Editor) applies editing commands to text streams or files and outputs the
modified text.

Basic Syntax:
sed [options] 'command' filename

 command can be a text manipulation instruction (e.g., substitution, deletion).

 The output is sent to the terminal by default, but can be redirected or saved.

Example:

sed 's/old/new/g' file.txt

Replaces all occurrences of "old" with "new" in file.txt.

47. Recall how to use `sed` for basic text substitutions.

Ans:

The sed command can perform text substitution in files or input streams.

Syntax:
sed 's/pattern/replacement/flags' filename

 s stands for substitute.

 pattern is the text to find.

 replacement is the new text to replace with.

 flags are optional modifiers like:

o g — replace all occurrences in the line (global).

o i — case insensitive matching.

Example:
sed 's/oldtext/newtext/g' file.txt

This replaces all occurrences of “oldtext” with “newtext” in each line of file.txt.

You can redirect output or use the -i option to modify the file in place.

KR
 48. Describe the structure of `awk` and its syntax.

Ans:

awk is a powerful text-processing tool used to search, extract, and process patterns from files
or input.

Syntax:

awk 'pattern { action }' filename

 pattern: A condition to match lines (can be omitted to apply action to all lines).

 action: Code to execute when pattern matches (e.g., print).

 filename: The file to process.

Structure:

awk 'BEGIN { commands }

pattern { commands }

END { commands }' filename

 BEGIN: Executes before the first line is read.

 pattern: Processes matching lines.

 END: Executes after the last line is processed.

Example:

awk '{ print $1, $3 }' data.txt

This prints the 1st and 3rd fields (columns) of each line in data.txt.

49. Recall how to use `awk` to print fields from structured text.

Ans:

awk is commonly used to extract and print specific fields (columns) from structured text,
where fields are typically separated by spaces or a specified delimiter.

Basic Syntax:
awk '{ print $1, $3 }' filename

KR
  $1, $2, $3, ... represent the first, second, third fields.

 $0 represents the entire line.

Example 1: Default space-separated fields

awk '{ print $2, $4 }' data.txt

Prints the 2nd and 4th columns from each line of data.txt.

Example 2: Using a delimiter

awk -F: '{ print $1 }' /etc/passwd

 -F: tells awk to use : as the field separator.

 Prints the usernames (first field) from /etc/passwd.

50. List text-processing commands to transform data.

Ans:

Linux provides powerful text-processing commands to read, filter, format, and transform
data in files or streams.

Common Commands:

1. cut – Extracts specific fields or columns.

o Example: cut -d',' -f1 data.csv (gets the first field from a CSV file)

2. paste – Merges lines from multiple files.

o Example: paste file1.txt file2.txt (combines lines side-by-side)

3. sort – Sorts lines alphabetically or numerically.

o Example: sort -n marks.txt (sorts numbers in ascending order)

4. uniq – Removes or identifies duplicate lines (used with sort).

o Example: sort names.txt | uniq

5. tr – Translates or deletes characters.

o Example: tr 'a-z' 'A-Z' (converts lowercase to uppercase)

6. awk – Field-level data extraction and processing.

o Example: awk '{print $1, $3}' file.txt

7. sed – Stream editor for substitutions and line edits.

KR
 o Example: sed 's/error/ERROR/g' log.txt (replaces "error" with "ERROR")

51. Identify the best commands to extract information from a given file.

Ans:

To extract specific data from a file, several powerful commands are commonly used in Linux:

1. cat – Displays the entire content of a file.

o Example: cat file.txt

2. head / tail – Shows the first or last few lines.

o Example: head -n 5 data.txt

o Example: tail -n 10 logs.txt

3. grep – Searches for patterns or keywords.

o Example: grep "error" log.txt

4. cut – Extracts specific columns or fields.

o Example: cut -d',' -f2 students.csv (gets 2nd field from CSV)

5. awk – Extracts and formats fields from structured text.

o Example: awk '{print $1, $3}' report.txt

6. sed – Used to search and extract or modify lines.

o Example: sed -n '2,5p' file.txt (prints lines 2 to 5)

52. Recall regular expressions to match text patterns.

Ans:

Regular expressions (regex) are patterns used to search, match, or manipulate text. They are
commonly used in tools like grep, sed, and awk.

Common Regex Patterns:

1. . – Matches any single character

Example: gr.p matches grep, grip, grap, etc.

2. * – Matches zero or more of the preceding character

Example: lo*se matches lse, lose, loose, etc.

3. ^ – Anchors the match at the start of the line

Example: ^Name matches lines starting with "Name"

KR
 4. $ – Anchors the match at the end of the line
Example: end$ matches lines ending in "end"

5. [abc] – Matches any one character inside the brackets

Example: [aeiou] matches any vowel

6. [a-z] – Matches any lowercase letter from a to z

Example: file[0-9] matches file1, file2, etc.

7. [^0-9] – Matches any character not a digit

8. \{n,m\} – Matches the preceding pattern between n and m times (basic regex with
grep requires \)

Example:

grep "^[A-Z][a-z]*$" names.txt

Matches lines with a capitalized word only (e.g., "Alice", "John").

53. List `sed` scripts to automate text modifications.

Ans:

sed (Stream Editor) is used to automate editing of text in files or streams. It processes input
line-by-line and applies editing commands.

Common sed Scripts:

1. Substitute text
Replace "old" with "new":

sed 's/old/new/' file.txt

2. Replace all occurrences on a line

sed 's/old/new/g' file.txt

Adds g for global replacement on each line.

3. Delete specific line(s)

Delete line 3:
sed '3d' file.txt

Delete lines from 2 to 4:

sed '2,4d' file.txt

KR
 4. Insert a line before a match

sed '/pattern/i\This is inserted line' file.txt

5. Append a line after a match

sed '/pattern/a\This is appended line' file.txt

6. Change entire line if it matches

sed '/pattern/c\This replaces the whole line' file.txt

7. Write output to a new file

sed 's/foo/bar/g' file.txt > newfile.txt

54. Recall how to create `awk` scripts for summarizing structured data.

Ans:

awk is a powerful text-processing tool for scanning and analyzing structured data (like CSV
or whitespace-separated files).

Basic Syntax:
awk 'BEGIN {init_block} {main_block} END {end_block}' file.txt

Examples of Summarizing Data:

1. Sum a Column (e.g., column 2):

awk '{sum += $2} END {print "Total:", sum}' data.txt

2. Calculate Average:

awk '{sum += $2; count++} END {print "Average:", sum/count}' data.txt

3. Print Column Names and Values (e.g., Name and Score):

awk '{print "Name:", $1, "Score:", $3}' data.txt

4. Count Lines Matching a Condition (e.g., score > 50):

awk '$3 > 50 {count++} END {print "Count:", count}' data.txt

5. Group and Aggregate (if sorted):

KR
awk '{scores[$1] += $2} END {for (name in scores) print name,
scores[name]}' data.txt

Use Case:

For structured files like:

Alice 90
Bob 75
Alice 85

You can total Alice’s score:

awk '$1 == "Alice" {sum += $2} END {print sum}' file.txt

55. Describe steps in writing and executing a basic shell script.

Ans:

1. Create a new file:

Use a text editor gedit to create a new file. For example,
gedit myscript.sh

2. Write the script:

Start the script with the shebang line to specify the shell interpreter:

#!/bin/bash

Then add your commands, for example:

echo "Hello, World!"

3. Save the file:

Save and close the editor.

4. Make the script executable:

Change the file permissions to allow execution:

chmod +x myscript.sh

5. Run the script:

Execute the script using:

./myscript.sh

56. Recall how to handle command-line arguments in shell scripts.

Ans:

KR
Handling Command-Line Arguments in Shell Scripts

 Shell scripts can accept inputs called command-line arguments.

 These arguments are accessed using special variables:

o $0 : Script name

o $1, $2, … : First, second, etc., arguments

o $# : Number of arguments passed

o $@ or $* : All arguments as a list

 Example:

#!/bin/bash
echo "Script name: $0"
echo "First argument: $1"
echo "Total arguments: $#"

 To use arguments, run the script like:

./script.sh arg1 arg2

57. Define exit status and its use in shell scripting.

Ans:

 Exit status is a numeric code returned by a command or script when it finishes

execution.

 It indicates success or failure of the command:

o 0 means success (no errors).

o Non-zero values indicate different types of errors or failures.

 In shell scripting, exit status helps in decision making (e.g., using if statements to
check if a command succeeded).

 It can be accessed using the special variable $? immediately after running a

command.

Example:

mkdir testdir
if [ $? -eq 0 ]; then
echo "Directory created successfully."
else

KR
 echo "Failed to create directory."
fi

 mkdir testdir tries to create a directory.

 $? checks the exit status of mkdir.

 If it’s 0, it means success, so it prints "Directory created successfully."

 Otherwise, it prints "Failed to create directory."

58. Identify the use of `if`, `elif`, `else` statements in shell logic.

Ans:

Purpose:

 if: Tests a condition and runs code if it’s true.

 elif: (else if) Tests another condition if the previous if or elif was false.

 else: Runs code if none of the above conditions were true.

Basic Syntax:
if [ condition1 ]; then
# commands if condition1 is true

elif [ condition2 ]; then

# commands if condition2 is true
else
# commands if none of the above conditions are true
fi

Example:

num=10
if [ $num -gt 20 ]; then
echo "Number is greater than 20"
elif [ $num -eq 10 ]; then
echo "Number is exactly 10"
else

KR
 echo "Number is less than 10 and not 10"
fi

Output:
Number is exactly 10

59. Describe the `case` statement and its purpose.

Ans:

The case statement is used to match a variable against a set of patterns, acting like a multi-
way if-else ladder. It's cleaner and more readable when you have many conditions to check.

Syntax:

case variable in
pattern1)
commands ;;

pattern2)
commands ;;
*)
default commands ;;

esac

 variable: The value to match.

 pattern: Can include wildcards like * or specific strings.

 *): Acts as else (default case).

 ;;: Ends each case block.

Example:

echo "Enter a number between 1 and 3:"

read num

case $num in

1)
echo "You chose One" ;;

KR
 2)
echo "You chose Two" ;;
3)

echo "You chose Three" ;;

*)
echo "Invalid choice" ;;
esac

If user inputs 2, output will be:

You chose Two

Purpose:

 Simplifies code when checking one variable against multiple possible values.

 More readable than nested if-elif-else.

60. Recall the use of `while` loops for repetition.

Ans:

The while loop is used to repeat a set of commands as long as a condition is true.

Syntax:

bash

CopyEdit

while [ condition ]
do

commands
done

 The condition is checked before every iteration.

 Loop stops when the condition becomes false.

Example:

count=1
while [ $count -le 5 ]

KR
do
echo "Count is $count"
count=$((count + 1))

done

Output:

Count is 1
Count is 2

Count is 3
Count is 4
Count is 5

Purpose:

 Use while when you don’t know exactly how many times to repeat.

 Great for reading files line-by-line, waiting for conditions, etc.

61. Recall the use of `for` loops to iterate over items.

Ans:

The for loop is used to iterate over a list of items, such as numbers, filenames, or command
outputs.

Syntax:

for variable in list

do

commands
done

Example 1: Loop over words

for item in apple banana cherry

do
echo "Fruit: $item"
done

Output:

KR
Fruit: apple
Fruit: banana
Fruit: cherry

Example 2: Loop over numbers

for i in {1..5}
do
echo "Number $i"
done

Output:

Number 1
Number 2
Number 3
Number 4
Number 5

Use for when you know the list of values or a range you want to iterate through.

62. List ways to perform string manipulation using `expr`.

Ans:

he expr command can be used for basic string operations like length, extraction, and
comparison.

1. Get String Length

expr length "Hello"

Output: 5

2. Extract Substring

expr substr "HelloWorld" 6 5

Output: World
(starts at position 6, takes 5 characters)

KR
3. Index of a Character

expr index "HelloWorld" o

Output: 5
(finds first occurrence of 'o')

4. String Comparison

expr "apple" = "apple"

Output: 1 (true)

expr "apple" != "orange"

Output: 1 (true)

 Always put strings in quotes to avoid issues with spaces or special characters.

 Use backticks or $() to capture output if assigning to variables:

result=$(expr length "Shell")

echo "Length: $result"

63. Recall how to do arithmetic operations using `expr`.

Ans:

The expr command supports basic arithmetic operations on integers. It evaluates expressions
and returns results.

Syntax

expr operand1 operator operand2

Note: Spaces between operands and operator are required.

1. Addition

expr 5 + 3

Output: 8

2. Subtraction

expr 10 - 4

KR
Output: 6

3. Multiplication

expr 6 \* 7

Output: 42
(Escape the * using backslash \ to prevent shell expansion)

4. Division
expr 20 / 5

Output: 4

5. Modulus (Remainder)
expr 10 % 3

Output: 1

6. Using with Variables

a=15
b=3
result=$(expr $a / $b)

echo "Result: $result"

Output: Result: 5

64. Identify common file test operators and their use.

Ans:

File test operators are used in conditional expressions (like if statements) to check the
properties of files and directories.

Common file test operators:

 -e : Returns true if the file exists.

Example: [ -e file.txt ]

 -f : Returns true if the file exists and is a regular file.

Example: [ -f report.txt ]

KR
  -d : Returns true if the file exists and is a directory.
Example: [ -d /home/user ]

 -r : Returns true if the file is readable.

Example: [ -r data.csv ]

 -w : Returns true if the file is writable.

Example: [ -w notes.txt ]

 -x : Returns true if the file is executable.

Example: [ -x script.sh ]

 -s : Returns true if the file exists and is not empty.

Example: [ -s data.txt ]

 ! : Negates the condition (NOT).

Example: [ ! -e temp.txt ] (true if the file does not exist)

Example usage in an if statement:

if [ -f "myfile.txt" ]; then
echo "File exists and is a regular file."
else
echo "File does not exist."

fi

65. Recall the purpose of the `set` command in scripts.

Ans:

The set command in shell scripting is used to change the value of shell options and
positional parameters. It allows fine control over the behaviour of the script.

Common Uses:

1. Set Positional Parameters

Replaces $1, $2, etc., with new values.

Example:
set -- apple banana cherry
echo $1 # Outputs: apple

echo $2 # Outputs: banana

2. Enable Debugging or Strict Mode

 set -x: Displays each command before executing (debugging).

 set -e: Stops script execution if any command fails.

KR
  set -u: Treats unset variables as an error.

 set -o pipefail: Causes a pipeline to fail if any command fails.

Example:

set -e

echo "Starting script"

cp file1.txt backup/ # If this fails, script will exit
echo "Script done"

3. List All Shell Variables and Functions

 Running set without arguments lists all variables and functions.

 set is useful for assigning new positional parameters.

 It controls script behavior (e.g., debugging, error handling).

 Helps write safer and more reliable scripts.

66. Describe the use of `shift` to process script arguments.

Ans:

The shift command in shell scripting is used to move positional parameters to the left. It
discards the current $1 and shifts all other arguments one position left. This is especially useful
when processing multiple command-line arguments in a loop.

Syntax:
shift [n]

 n is optional (default is 1). It determines how many positions to shift.

Purpose:

 To process arguments one by one using a loop.

 After each shift, the next argument becomes $1.

Example:
#!/bin/bash
# Script to print all arguments one by one

while [ $# -gt 0 ]; do
echo "Argument: $1"

KR
 shift
done

How It Works:

If you run the script with:

./script.sh apple banana cherry

The output will be:

Argument: apple
Argument: banana

Argument: cherry

After each shift, $2 becomes $1, $3 becomes $2, and so on, until no arguments remain ($#
becomes 0).

67. Recall how to use the `trap` command for handling.

Ans:

The trap command in Linux shell scripting is used to catch and handle signals or events,
allowing you to execute specific commands when certain signals are received (like
interrupting the script with Ctrl+C).

Purpose:

 To perform cleanup actions (like deleting temporary files) before the script exits.

 To handle unexpected interruptions gracefully.

Syntax:

trap 'commands' SIGNALS

 'commands' is the command or set of commands to run when the signal occurs.

 SIGNALS are the signals to catch (e.g., SIGINT, SIGTERM, EXIT).

Common signals:

 SIGINT — Interrupt signal (Ctrl+C)

 SIGTERM — Termination signal

 EXIT — When the script exits (normal or otherwise)

Example:

#!/bin/bash

KR
trap 'echo "Caught Ctrl+C! Exiting now..."; exit' SIGINT
echo "Press Ctrl+C to test trap."
while true; do

sleep 1
done

Explanation:

 When you press Ctrl+C, the script catches the SIGINT signal.

 It runs the command inside the trap: prints a message and exits gracefully.

68. Define the purpose and syntax of here-documents (`<<`).

Ans:

Here-documents (<<) are used in shell scripting to provide multiline input directly to a
command from within a script or command line.

Purpose:
To feed a block of text or commands as input to a command without using an external file.

Syntax:

command << delimiter

line1
line2
...
delimiter

How it works:

 command reads input until it encounters the line with only the delimiter.

 All lines between the << delimiter and the ending delimiter are passed as input to
the command.

Example:
cat << EOF
This is line 1
This is line 2
EOF

This sends the two lines as input to the cat command, which outputs them.

KR
 69. Identify basic debugging techniques using `set-x`.

Ans:

Basic debugging in shell scripts can be done using the set -x command.

Purpose:
set -x enables a mode where each command and its arguments are printed to the terminal
as they are executed. This helps track what the script is doing step-by-step.

How to use:

 Insert set -x at the point where you want to start debugging.

 To stop debugging, use set +x.

Example:
#!/bin/bash
set -x # Start debugging
echo "Hello"
ls /nonexistent
set +x # Stop debugging
echo "Done"

When running this script, the shell will print each command before executing it, making it
easier to identify where errors or unexpected behaviour happen.

70. Recall the use of the `export` command for environment variables.

Ans:

The export command in Unix/Linux is used to set environment variables so that they are
available to the current shell session and any child processes started from it.

Purpose:

 Make a shell variable available to programs and scripts executed from the shell.

 Share variables between parent and child processes.

Syntax:

export VARIABLE_NAME=value

Example:

export PATH=$PATH:/usr/local/bin

KR
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk

Explanation:

 export PATH=... appends a new directory to the existing PATH environment variable
and exports it.

 After exporting, any program or script launched from this shell can access
JAVA_HOME.

71. List how to create and use arrays in shell scripts.

Ans:

Creating Arrays:
Use parentheses () to define an array with elements separated by spaces.

my_array=(apple banana cherry)

Accessing Array Elements:

Use ${array_name[index]} to access an element. Indexing starts at 0.

echo ${my_array[1]} # Outputs: banana

Getting All Elements:

Use ${array_name[@]} or ${array_name[*]} to get all elements.

echo ${my_array[@]} # Outputs: apple banana cherry

Getting Array Length:

Use ${#array_name[@]} to get the number of elements.

echo ${#my_array[@]} # Outputs: 3

Adding Elements:
Add elements by assigning a value to a new index.

my_array[3]=date

Looping Over Array Elements:

for fruit in "${my_array[@]}"

do
echo "$fruit"
done

72. Describe how to define and call shell functions

Ans:
Defining Shell Functions:

KR
You define a function by giving it a name followed by parentheses and enclosing the
commands within braces {}.

Syntax:

function_name() {
commands

Calling Shell Functions:

To run a function, just type its name followed by any arguments if needed.

Example:

greet() {
echo "Hello, $1!"
}
greet Alice

Output:
Hello, Alice!

 $1, $2, etc. inside the function represent arguments passed to the function.

 Functions help organize reusable code within scripts.

73. Define system calls and their role between user space and kernel.

Ans:

System calls are special functions provided by the operating system that allow programs
running in user space to request services from the kernel (the core part of the OS). They act
as a controlled interface between user applications and the kernel, enabling safe access to
hardware and system resources.

Role:

 User programs cannot directly access hardware or critical system resources for
security and stability reasons.

 When a program needs to perform tasks like reading a file, creating a process, or
communicating over a network, it uses system calls.

 The system call switches the CPU from user mode to kernel mode, allowing the kernel
to perform the requested operation.

KR
  After completing the task, control returns to the user program.

Example system calls: open(), read(), write(), fork(), exec(), close()

74. Describe the `open()` system call and its arguments.

Ans:

open() system call:

The open() system call is used to open a file and obtain a file descriptor, which is a reference
used for subsequent file operations like reading or writing.

Syntax:

int open(const char *pathname, int flags, mode_t mode);

Arguments:

 pathname: The path to the file to be opened.

 flags: Specifies the access mode and options, such as:

o O_RDONLY (read only),

o O_WRONLY (write only),

o O_RDWR (read and write),

o plus flags like O_CREAT (create file if it doesn’t exist), O_TRUNC (truncate file),
etc.

 mode: (Optional) Sets the file permissions if a new file is created (used with O_CREAT).

Return Value:

 On success, returns a non-negative file descriptor.

 On failure, returns -1 and sets errno.

75. Recall the purpose of `read()` and `write()` system calls.

Ans:

read() and write() system calls:

 read() is used to read data from a file descriptor into a buffer in user space. It
transfers data from the kernel to the user program.

 write() is used to write data from a user-space buffer to a file descriptor. It transfers
data from the user program to the kernel (e.g., to a file or device).

KR
Syntax:

ssize_t read(int fd, void *buf, size_t count);

ssize_t write(int fd, const void *buf, size_t count);

Parameters:

 fd: File descriptor obtained from open() or other system calls.

 buf: Pointer to a buffer where data is read into (for read) or written from (for write).

 count: Number of bytes to read or write.

Return Value:

 Number of bytes actually read or written.

 Returns 0 on end-of-file (for read()).

 Returns -1 on error.

76. Identify the process of creating a new process with `fork()`

Ans:

Creating a new process with fork() system call:

 The fork() system call is used to create a new child process by duplicating the
calling (parent) process.

 When fork() is called, the operating system creates an exact copy of the parent
process’s address space, including code, data, and stack.

 After the call:

o The parent process receives the child's process ID (a positive integer).

o The child process receives 0.

o If the call fails, fork() returns -1.

Syntax:

pid_t fork(void);

Process:

1. Parent calls fork().

2. OS creates a new child process (duplicate of parent).

3. Both processes continue execution from the point of fork().

4. They can use the return value to determine their role (parent or child).

KR
 77. Describe how `exec()` replaces the current process image

Ans:

exec() System Call and Process Replacement

 The exec() family of system calls replaces the current process image with a new
program.

 When a process calls exec(), its existing code, data, and stack are discarded, and the
new program is loaded into the process’s memory.

 The process ID (PID) remains the same, but the process begins executing the new
program from its entry point.

 If exec() is successful, it does not return to the old program; if it fails, it returns -1 and
sets an error.

Common exec() Variants:

 execl(), execv(), execle(), execve(), execlp(), execvp() — differ in

how arguments and environment variables are passed.

Syntax Example:

int execl(const char *path, const char *arg, ..., NULL);

How it works:

1. Process calls exec() with the path of the new program.

2. The OS loads the new executable into the process’s memory.

3. The old program is completely replaced.

4. The process continues execution starting at the new program’s entry point.

78. Recall the concept of daemon processes and steps to create one.

Ans:

 A daemon is a background process that runs independently of any user interaction.

 It usually starts at system boot and runs continuously to perform system or

application tasks (e.g., web servers, print spoolers).

KR
  Daemons are detached from controlling terminals and run silently in the background.

Characteristics of Daemons

 Runs in the background.

 No controlling terminal.

 Often starts at boot time.

 Runs with minimal user interaction.

 Handles system or service-related tasks.

Steps to Create a Daemon Process

1. Fork the process:

The parent exits, allowing the child to run independently.

2. Create a new session:

Use setsid() to start a new session and detach from the terminal.

3. Change the working directory:

Change to root (/) or a safe directory to avoid blocking filesystem unmounts.

4. Set file permissions mask (umask):

Typically set to 0 to have full control over file permissions.

5. Close standard file descriptors:

Close stdin, stdout, and stderr or redirect them to /dev/null.

6. Implement the daemon logic:

The daemon runs its task, usually inside an infinite loop with proper sleep or wait
mechanisms.

79. Define inter-process communication (IPC) and its techniques.

Ans:

IPC allows processes to exchange data and synchronize their actions.

Common IPC techniques:

 Pipes: Simple communication channel between processes.

 Message Queues: Send and receive messages asynchronously.

 Shared Memory: Processes share a memory area for fast data exchange.

 Semaphores: Synchronize access to shared resources.

 Sockets: Communication over networks or locally between processes.

KR
 80. Identify how to use pipes for related process communication.

Ans:

Pipes connect the output of one process to the input of another, enabling related processes
to communicate by passing data streams.

Usage:

 Symbol: |

 Example: ls -l | grep "txt"

Here, the output of ls -l is sent as input to grep "txt".

Purpose:

 Allows chaining commands.

 Facilitates data flow between processes without intermediate files.

81. Describe the usage of FIFOs (named pipes) for IPC.

Ans:

FIFOs, or named pipes, are special files used for inter-process communication (IPC) in
Unix/Linux. Unlike regular pipes, FIFOs have a name in the filesystem, allowing unrelated
processes to communicate by reading and writing through this named file.

Usage:

 Created using the mkfifo command (e.g., mkfifo myfifo).

 One process writes data to the FIFO, while another reads from it.

 Data flows in a first-in-first-out manner.

 Useful for communication between processes that do not share a parent-child

relationship.

Example:
Process 1: echo "Hello" > myfifo
Process 2: cat < myfifo

This allows Process 2 to receive the message sent by Process 1 through the FIFO.

FIFOs provide a simple way to exchange data between independent processes using the
filesystem as a communication medium.

82. List steps to develop a client-server model using IPC.

Ans:

KR
To develop a client-server model using IPC:

1. Create an IPC channel like a pipe, FIFO, or socket for communication.

2. The server initializes by creating/opening the IPC channel and waits for client
requests.

3. The client connects to the server’s IPC channel to send requests.

4. Data is exchanged: the client sends a request, the server processes it and replies.

5. Both client and server close the IPC channel after communication is complete.

83. Describe shared memory and its IPC advantages.

Ans:

Shared memory is an IPC technique where multiple processes access a common memory
area to exchange data directly.

Advantages:

 Fastest IPC method because data is shared without copying between processes.

 Efficient for large data transfer.

 Allows direct read/write access, reducing communication overhead.

 Since memory is shared, there's minimal system call overhead.

 Enables complex communication and data sharing between processes.

However, synchronization (like using semaphores) is needed to avoid conflicts when

accessing shared memory.

84. Define the concept of race conditions.

Ans:

A race condition occurs when two or more processes or threads access shared resources (like
memory or files) concurrently, and the final outcome depends on the timing of their
execution.

If these accesses are not properly synchronized, it can lead to unpredictable behavior, such
as corrupted data or unexpected results.

Example:
If two processes try to update the same variable at the same time without coordination, one
update might overwrite the other, causing a logic error.

KR
Solution:
Race conditions can be avoided by using synchronization techniques like mutexes,
semaphores, or locks to control access to shared resources.

85. Identify how mutexes are used to prevent race conditions.

Ans:

Mutex (short for Mutual Exclusion) is a synchronization primitive used to prevent race
conditions in concurrent processes or threads.

It ensures that only one process/thread can access a critical section (shared resource) at a
time.

How mutex prevents race conditions:

1. Locking: Before accessing the shared resource, a thread must acquire (lock) the
mutex.

2. Access: Once locked, no other thread can enter the critical section until the mutex is
unlocked.

3. Unlocking: After the thread finishes its task, it releases (unlocks) the mutex so others
can proceed.

Example (Pseudocode):
mutex lock

thread1:
lock(mutex)
// critical section
unlock(mutex)

thread2:

lock(mutex)
// critical section
unlock(mutex)

Using mutexes helps ensure data integrity and prevents simultaneous access to shared
resources, thereby avoiding race conditions.

86. Compare IPC mechanisms by characteristics.

KR
Ans:

Inter-Process Communication (IPC) methods allow processes to exchange data. Different IPC
mechanisms have different characteristics:

1. Pipes

 Unidirectional.

 Used between related (parent-child) processes.

 Simple and fast.

2. FIFOs (Named Pipes)

 Like pipes, but work between unrelated processes.

 Identified by a name in the filesystem.

3. Message Queues

 Messages are stored and retrieved in queue order.

 Allows communication with priority.

 Good for asynchronous data transfer.

4. Shared Memory

 Fastest method.

 Allows multiple processes to access common memory.

 Needs synchronization (mutex/semaphore).

5. Sockets

 Used for communication between processes on the same or different

machines.

 Supports bidirectional and network communication.

87. Recall scenarios to decide if synchronization is needed.

Ans:

Common Scenarios:

1. Shared Memory Access:

When two threads update the same variable at the same time.
Example: A counter shared by multiple threads.

2. File Access:
When multiple processes write to the same file, data can get mixed up.

KR
 3. Producer-Consumer Problem:
One process adds data (producer) and another removes it (consumer). They must be
synchronized to avoid overflow or underflow.

4. Banking System:
If two threads change the balance of the same account, it may lead to incorrect
results.

5. Thread Coordination:
If one thread depends on another (e.g., waiting for input), synchronization ensures
they run in the correct order.

Synchronization helps avoid conflicts and keeps data correct when tasks run at the same
time.

88. Describe a communication method using pipes or FIFOs

Ans:

Pipes and FIFOs are inter-process communication (IPC) mechanisms used to transfer data
between processes.

Pipes:

A pipe is a unidirectional communication channel used between related processes (parent-

child).

Syntax: pipe(fd);

Example:

int fd[2];
pipe(fd);
fork();
// One process writes using write(fd[1], ...), other reads using
read(fd[0], ...)

FIFOs (Named Pipes):

FIFOs allow communication between unrelated processes using a named file in the
filesystem.

Created with: mkfifo filename

Example:
mkfifo mypipe

KR
echo "Hello" > mypipe # Writing to FIFO
cat < mypipe # Reading from FIFO

Pipes are suitable for related processes, while FIFOs enable communication between any
processes. Both are simple, efficient IPC methods for stream-based data transfer.

89. Recall a simple shared memory communication example.

Ans:

Shared memory is a method of inter-process communication (IPC) where multiple processes

access a common memory region.

Example Scenario:

 A parent process creates shared memory.

 It writes a message into it.

 A child process reads the message from the same memory.

Steps:

1. Create shared memory using shmget().

2. Attach to it using shmat().

3. Parent writes data; child reads it.

4. Detach using shmdt(), and delete using shmctl().

Why it's used:

It's fast and efficient for sharing large data between processes without copying.

90. Describe a basic mutex locking mechanism for shared resources.

Ans:

A mutex (mutual exclusion) is used to prevent multiple processes or threads from accessing a
shared resource at the same time, avoiding race conditions.

How it works:

 Before accessing the shared resource, a process/thread locks the mutex.

 While locked, no other process can access the resource.

 After finishing, the mutex is unlocked, allowing others to access it.

Steps:

KR
 1. Initialize the mutex.

2. Lock the mutex before using the shared resource.

3. Access or modify the shared resource safely.

4. Unlock the mutex after done.

Purpose:
Ensures that only one process/thread accesses the resource at a time, maintaining data
consistency and preventing conflicts.

KR