DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

Even Semester
OPERATING SYSTEMS

ASSIGNMENT III:ANSWER KEY

[Link] in detail the file system in LINUX system.

The Linux File System

The Linux file system is the hierarchical structure used to organize and store files and
directories on a computer. It is designed to efficiently handle various types of storage devices,
such as hard drives, SSDs, USB drives, and network filesystems. The file system provides a
way for programs and users to access and manage files.

Here's a detailed breakdown of the key components and features of the Linux file system:

1. Hierarchical Structure

At its core, the Linux file system is organized in a tree-like structure, with the root directory
(/) as the top-most node. All other files and directories are nested within this root. The root
directory contains essential system files and can include a variety of subdirectories.

Key points about this structure:

Root directory (/): The base of the file system. All files and directories stem from this root.

Directories: Other directories are located under the root directory or other directories in the
hierarchy.

Files: The leaf nodes in the hierarchy, where actual data is stored.

2. Key Directories in Linux File System

Here are some important directories in a typical Linux file system:

/ (Root): The root directory, where everything begins. It contains the entire file
system.

/bin: Essential system binaries (programs). These programs are required for the
system to run in single-user mode, and are available for use by all users. Examples:
ls, cp, rm.

/sbin: System binaries, similar to /bin, but these programs are generally used for
system administration (root) tasks. Examples: fsck, shutdown.

/etc: Configuration files for the system and installed software. This includes files
like /etc/passwd (user account information) and /etc/fstab (file system table).
 /dev: Device files. This directory contains special files that represent hardware
devices such as disks, terminals, and printers. For example, /dev/sda represents the
first hard disk, and /dev/tty1 is the first virtual terminal.

/home: Home directories for regular users. Each user typically has a directory here
named after their username (e.g., /home/john).

/lib:Shared library files that programs depend on, similar to dynamic-link libraries
(DLLs) in Windows. These are necessary for programs to run.

/usr: User-related programs and files. This contains subdirectories like /usr/bin
(binaries for user programs) and /usr/lib (libraries for user programs). It also
contains system-wide documentation.

3. File Types in Linux

Linux supports various types of files. Here are some common file types:

Regular files: The most common file type. These can be text files, binary files, images, etc.
Represented by - in file listings.

Directories: Special files that contain other files and directories. Represented by d in file
listings.

Symbolic links: Similar to shortcuts in Windows, these files point to another file or
directory. Represented by l in file listings.

Device files: Represent hardware devices like disks, printers, or terminals. These can be
character devices (e.g., /dev/ttyS0) or block devices (e.g., /dev/sda).

Named pipes (FIFOs): These files are used for inter-process communication (IPC) between
processes.

Sockets: These are used for communication between processes over a network.

4. File Permissions and Ownership

Linux uses a permission-based model for file access. Each file and directory has three main
components: owner, group, and others. These components are associated with specific
permissions.

Owner: The user who owns the file.

Group: A group of users who are granted access to the file.

Others: All other users.

Each of these components can have three types of permissions:

 Read (r): Permission to view the file contents.

Write (w): Permission to modify the file.

Execute (x): Permission to run the file (if it is executable).

Permissions are often represented by a 3-digit number, e.g., 755, which corresponds to:

7 (owner: read, write, execute)

5 (group: read, execute)

In the command line, you can view file permissions using the ls -l command

5. Mounting and Filesystem Types

In Linux, all devices are represented as files in the /dev directory. Before you can use a
storage device (e.g., a hard disk or USB stick), you must "mount" it, meaning you attach it to
a directory so that it can be accessed.

Mounting: The process of associating a file system with a directory in the Linux hierarchy.
For example, to access an external hard drive, you mount it to a directory, such as
/mnt/external_drive.

Unmounting: The process of safely detaching a file system from the directory.

Filesystem types: Linux supports a wide range of file system types. Common types include:

ext4: The default and most commonly used file system in modern Linux
distributions.

NTFS: A file system used by Windows. Linux can read/write NTFS with
proper drivers.

FAT32/exFAT: Older file systems commonly used for external drives and
flash drives, especially in cross-platform environments.

XFS: A high-performance file system often used for large-scale applications.

Btrfs: A newer file system offering advanced features such as snapshots,

checksums, and integrated volume management.

6. Inodes

An inode (index node) is a data structure used by the file system to store information about a
file or directory. Each file or directory has a unique inode number. The inode contains
metadata about the file, such as:

File type
 File size

Permissions

Owner and group information

Timestamps (e.g., creation time, modification time)

Pointers to the data blocks where the file's actual contents are stored

Inodes do not store the file name or the data itself, but only metadata and pointers to the
actual file content. The file name is stored in a directory entry that maps to the inode.

7. File System Management

Linux provides several tools to manage and interact with file systems:

df: Shows disk space usage for mounted file systems.

du: Shows disk usage for files and [Link]:

Used to mount file systems.

umount: Used to unmount file systems.

fsck: A utility to check and repair file systems.

[Link] about Android Architecture in detail

Android Architecture is a complex system that enables smartphones, tablets,

smartwatches, TVs, and other devices to run Android applications efficiently. Understanding
Android’s architecture is essential for developers, as it provides insight into how the
operating system works and how applications interact with the hardware and other system
components.

Android architecture is divided into five main layers. Let’s break them down and explain
each layer in detail:

1. Linux Kernel Layer

At the very base of the Android architecture is the Linux Kernel, which provides low-level
functionality for the operating system.

Key Functions

Hardware Abstraction: The kernel provides drivers for the underlying hardware, such as the
touchscreen, camera, Wi-Fi, Bluetooth, GPS, and others. These hardware drivers help the
operating system communicate with the physical hardware.
Memory Management: Manages the system’s memory resources efficiently, including
virtual memory and memory swapping.

Power Management: Handles power-saving mechanisms, including scheduling when the

CPU should be active or idle.

Security: Implements a security model that isolates apps and protects the system from
potential malicious activity. This is essential for ensuring that apps don’t access unauthorized
data or interfere with system resources.

System Calls and Process Management: The kernel manages processes, multitasking,
thread execution, and system calls that allow higher layers to interact with the hardware.

The Linux kernel is an essential part of the Android operating system, but it doesn't expose
this functionality directly to applications. Instead, it provides a controlled environment in
which higher layers can operate.

2. Hardware Abstraction Layer (HAL)

The Hardware Abstraction Layer (HAL) provides a standard interface between the
hardware and the Android OS. It sits between the Linux kernel and the Android system
libraries and allows Android to access the hardware components of the device without
needing to interact with them directly.

Key Functions:

Abstraction: HAL abstracts the details of the hardware components such as sensors,
cameras, GPS, and other peripherals. This makes it possible to work with a wide range of
hardware without needing to rewrite code for each individual component.

Device-Specific Code: HAL provides device-specific code to communicate with hardware.

This means Android devices from different manufacturers (e.g., Samsung, Google, Xiaomi)
can run the same version of Android while using different hardware components.

HAL is made up of several modules (e.g., camera HAL, sensor HAL), and each module
contains an interface that is used by Android system services to interact with the hardware.

3. Android Runtime (ART) & Core Libraries

At the third level is the Android Runtime (ART), which is responsible for running Android
applications. ART replaced the older Dalvik Virtual Machine (DVM) in Android 5.0
(Lollipop) to improve performance and efficiency.

Key Components:

Android Runtime (ART):

ART is a managed runtime environment that compiles Android applications into native
machine code.
Ahead-of-Time Compilation (AOT): In ART, apps are compiled into native code before
they are run, which helps to improve the performance and speed of Android applications.

Garbage Collection: ART handles automatic memory management by collecting unused

memory and reclaiming it to avoid memory leaks.

Optimization: ART performs runtime optimizations for improved performance, battery life,
and responsiveness.

Core Libraries: The Android runtime provides core libraries that are essential for the
functioning of applications. These libraries provide functionality such as:

Data storage (SQLite, SharedPreferences)

User interface elements (Widgets, Views)

Networking (HTTP, WebSocket)

Security (Encryption)

File I/O

Math, string handling, etc.

4. Application Framework Layer

The Application Framework provides a set of higher-level services to developers. It is the

layer where Android exposes a lot of its functionality to developers through APIs
(Application Programming Interfaces).

Key Components:

Activity Manager: Manages the lifecycle of all activities and applications in the system. It
handles tasks like launching applications, switching between activities, and managing
backstack.

Window Manager: Controls the layout and positioning of the application’s window on the
screen.

Content Providers: Enable data sharing between applications. For example, one app can
request contacts from the contacts app via a content provider.

View System: Provides the UI components (Views, Widgets) for building interactive user
interfaces.

Notification Manager: Handles displaying notifications to the user (e.g., SMS, email, or
app-specific notifications).

Resource Manager: Manages access to app resources, such as strings, drawables, and
layouts.
Package Manager: Manages the installed applications and provides information about them.

Telephony Manager: Deals with all the phone-related features, including voice calls,
messages, and network status.

At this level, developers interact directly with Android APIs. These APIs abstract the low-
level hardware details and provide an easy-to-use interface for developers to build and
manage apps.

5. Applications Layer

At the top of the Android architecture is the Applications Layer, which contains both system
apps and user apps.

Key Components:

System Applications: These are the apps that come pre-installed on Android devices and
provide essential services, such as the phone dialer, messaging, camera, email, and settings.
These apps rely on the lower layers (e.g., application framework and services) to function.

Third-Party Applications: These are user-installed apps from the Google Play Store or other
sources. These apps run within the Android runtime (ART) and interact with the operating
system using the Android APIs exposed in the Application Framework layer.

Developers write Android apps using Java or Kotlin programming languages. These apps
are packaged in APK (Android Package) format and can utilize the full range of Android
features via the system APIs.

How the Layers Interact:

Linux Kernel provides a foundation and communicates with hardware.

HAL abstracts hardware specifics and makes them accessible to higher layers.

Android Runtime (ART) executes Android apps, performing optimizations like

AOT compilation and memory management.

Application Framework offers a higher-level API for building apps and managing
system services.

Applications Layer consists of the actual apps (system and third-party apps) that
interact with the user