*Case Study*

*Linux Operating System*

 Name:- Sanket P. Ingale

Roll No:-606

 Name:- Rahul S. Pawar

Roll No:-580
  Introduction Of LINUX:-
Linux is a popular version of the UNIX Operating System. It is open source as its
source code is freely available. It is free to use. Linux was designed considering UNIX
compatibility. Its functionality list is quite similar to that of UNIX.

Components of Linux System

Linux Operating System has primarily three components:-

 Kernel:

Kernel is the core part of Linux. It is responsible for all major activities of this
operating system. It is consists of various modules and it interacts directly with the
underlying hardware. Kernel provides the required abstraction to hide low level hardware
details to system or application programs.

 System Library:

System libraries are special functions or programs using which application

programs or system utilities accesses Kernel's features. These libraries implement most of
the functionalities of the operating system and do not require kernel module's code access
rights.

 System Utility:

System Utility programs are responsible for doing specialized, individual level
tasks.
  Structure/Design Of LINUX:-
An operating system is an interface between the user of a computer and the computer
hardware. It is a collection of software that manages computer hardware resources and offers
common services for programs of the computer. The short term of the operating system is OS.
And, it is, an essential component of the system software in a computer system. The main
purpose of an OS is to afford an environment in which a user can execute a program in an
efficient or convenient manner. This article gives an overview of what is the Linux Operating
System; the types of operating systems; their architecture and features.

Operating systems are categorized into six types based on the types of computers they
control such as single user single task operating systems, real time operating systems, single
user, multitasking operating systems, multiuser operating systems, distributed operating systems,
and embedded operating systems. The typical services that an operating system provides
include: a task scheduler, memory manager, disk manager, network manager, Other I/O services
and Security manager.
  Memory Management Techniques in LINUX:-
The Linux memory manager implements demand paging with a copy-on-write strategy
relying on the 386's paging support. A process acquires its page tables from its

parent (during a fork()) with the entries marked as read-only or swapped. Then, if the process
tries to write to that memory space, and the page is a copy-on-write

page, it is copied, and the page is marked read-write. An exec() results in the reading in of a page
or so from the executable. The process then faults in any other

pages it needs.

Each process has a page directory which means it can access 1 KB of page tables pointing to 1
MB of 4 KB pages which is 4 GB of memory. A process' page

directory is initialized during a fork by copy_page_tables(). The idle process has its page
directory initialized during the initialization sequence.

Each user process has a local descriptor table that contains a code segment and data-stack
segment. These user segments extend from 0 to 3 GB (0xc0000000). In

user space, linear addresses and logical addresses are identical.

On the 80386, linear address run from 0GB to 4GB. A linear address points to a particular
memory location within this space. A linear address is not a physical

address--it is a virtual address. A logical address consists of a selector and an offset. The selector
points to a segment and the offset tells how far into that segment

the address is located)

The kernel code and data segments are priveleged segments defined in the global descriptor table
and extend from 3 GB to 4 GB. The swapper page directory

(swapper_page_dir is set up so that logical addresses and physical addresses are identical in
kernel space.

The space above 3 GB appears in a process' page directory as pointers to kernel page tables. This
space is invisible to the process in user mode but the mapping

becomes relevant when privileged mode is entered, for example, to handle a system call.
Supervisor mode is entered within the context of the current process so

address translation occurs with respect to the process' page directory but using kernel segments.
This is identically the mapping produced by using the swapper_pg_dir
and kernel segments as both page directories use the same page tables in this space.
Only task[0] (the idle task, sometimes called the swapper task for historical

reasons, even though it has nothing to do with swapping in the Linux implementation) uses
the swapper_pg_dir directly.

 The user process' segment_base = 0x00, page_dir private to the process.

 user process makes a system call: segment_base=0xc0000000 page_dir = same
user page_dir.
 swapper_pg_dir contains a mapping for all physical pages from 0xc0000000 to
0xc0000000 + end_mem, so the first 768 entries in swapper_pg_dir are 0's, and then
there are 4 or more that point to kernel page tables.
 The user page directories have the same entries as swapper_pg_dir above 768. The first
768 entries map the user space.

The upshot is that whenever the linear address is above 0xc0000000 everything uses the same
kernel page tables.

Memory Management data in the process table

Here is a summary of some of the data kept in the process table which is used for memory
managment:

Process memory limits

ulong start_code, end_code, end_data, brk, start_stack;

Page fault counting

ulong min_flt, maj_flt, cmin_flt, cmaj_flt

Local descriptor table

struct desc_struct ldt[32] is the local descriptor table for task.

rss
number of resident pages.

swappable
if 0, then process's pages will not be swapped.

kernel_stack_page
pointer to page allocated in fork.

saved_kernel_stack
V86 mode stuff

struct tss
 Stack segments

esp0
kernel stack pointer (kernel_stack_page)
ss0
kernel stack segment (0x10)
esp1
= ss1 = esp2 = ss2 = 0
unused privelege levels.

 Segment selectors: ds = es = fs = gs = ss = 0x17, cs = 0x0f

All point to segments in the current ldt[].
 cr3: points to the page directory for this process.
 ldt: _LDT(n) selector for current task's LDT.
  Storage System Constraints Of LINUX:-
How the storage attaches to the platform is key to the overall storage architecture. Three
general architectures cover the vast majority of models:
 Direct-Attached Storage (DAS)
 Storage Area Networks (SAN)
 Network-Attached Storage (NAS)
Of course, Linux supports all three and has evolved with the changes that are occurring with
these models.

 Direct-Attached Storage:-
Linux supports a large variety of DAS interfaces, including old standards like
parallel Advanced Technology Attachment (ATA)—Integrated Drive Electronics [IDE]/ATA—
parallel SCSI, and Fibre Channel as well as new storage interfaces like serial attached SCSI
(SAS), serial ATA (SATA), and external SATA (eSATA). You'll also find advanced storage
technologies such as USB3 (Extensible Host Controller Interface [xHCI]) and Firewire (Institute
of Electrical and Electronics Engineers 1394).

 Storage Area Network:-

The SAN provides consolidation of block-level storage so that it can be shared
among a number of servers. The storage appears local to the servers, where the endpoint storage
device may implement additional services for the client devices (such as backup and replication).
Protocols and interfaces for SANs are wide and varied. You can find the typical SAN protocols
in Linux such as Fibre Channel as well as its extension over IP (iFCP). Newer protocols, such as
SAS, Fibre Channel over Ethernet (FCoE), and Internet SCSI (iSCSI), are also present, as are
more domain-specific protocols like iSCSI Extensions for remote direct memory access
(RDMA—iSER) and the SCSI RDMA Protocol (SRP), which extends SCSI over RDMA for
Infiniband. The emergence of Ethernet as a storage protocol has been fully realized in Linux, as
it illustrates the power and flexibility of these approaches. Further, 10-gigabit Ethernet (10GbE)
is fully supported in Linux, permitting construction of high-performance SANs. You can also
find protocols like ATA over Ethernet (ATAoE), which extends the ATA protocol over the
ubiquitous Ethernet protocol.

 Network-Attached Storage:-
Last but not least is NAS. NAS is a consolidation of storage over a network for
access by heterogeneous clients at the file level. Two of the most popular protocols, which are
fully supported in Linux, are Network File System (NFS) and Server Message Block/Common
Internet File System (SMB/CIFS).
Although the original SMB implementation was proprietary, it was reverse-engineered to be
supported in Linux. The later SMB revisions were openly documented to allow simpler
development in Linux.
Linux has continued to evolve with the various enhancements and extensions made to NFS. NFS
is now a stateful protocol and includes optimizations for data and metadata separation as well as
data access parallelism. You can read more about the evolution of NFS using the links in Related
topics. As with Ethernet-based SANs, 10GbE support in Linux enables high-performance NAS
repositories.
  Applications Of LINUX:-

Nowadays, Linux is a multi billion dollar industry. Thousands of companies and

governments around the world are using Linux OS due to affordability, lower licensing fee and
time and money. Linux is used in a number of electronic devices, which are available for
consumers worldwide. The list of some of popular Linux based electronic devices includes:-

 Dell Inspiron Mini 9 and 12

 Garmin Nuvi 860, 880, and 5000
 Google Android Dev Phone 1
 HP Mini 1000
 Lenovo IdeaPad S9
 Motorola MotoRokr EM35 Phone
 One Laptop Per Child XO2
 Sony Bravia Television
 Sony Reader
 TiVo Digital Video Recorder
 Volvo In-Car Navigation System
 Yamaha Motif Keyboard