Understanding Operating Systems Sixth Edition Chapter 16 Linux Operating System

Understanding Operating Systems Sixth Edition

Chapter 16Linux Operating System

Understanding Operating Systems, Sixth Edition 2

Learning Objectives

After completing this chapter, you should be able to describe:

• The design goals for the Linux operating system

• The flexibility offered by using files to manipulate devices

• The differences between command-driven and menu-driven interfaces

• The roles of the Memory, Device, File, Processor, and Network Managers

• Some strengths and weaknesses of Linux


Overview• Linux is POSIX-compliant and portable with versions

available to run:– cell phones, supercomputers, and most computing

systems in between.• Its source code is freely available, allowing

programmers to configure it to run any device and meet any specification.

• The frequent inclusion of several powerful desktop GUIs continues to attract users.

• It is also highly modular, allowing multiple modules to be loaded and unloaded on demand, making it a technically robust operating system.


Overview• Linux is an open source program.

– Its source code is freely available to anyone for improvement.

– If someone sends a better program or coding sequence to Linus Torvalds, the author of Linux, and if it’s accepted as a universal improvement to the OS, then the new code is added to the next version made available to the computing world.

• Updates are scheduled every six months.– In this way, Linux is under constant development by

uncounted contributors around the world, most of whom have never met.

• The name Linux remains a registered trademark of Linus Torvalds.


History• Linus Torvalds wanted to create an OS that would greatly

enhance the limited capabilities of the Intel 80386 microprocessor.

• He started with MINIX (a miniature UNIX system developed primarily by Andrew Tanenbaum) and rewrote certain parts to add more funcxtionality.

• When he had a working OS, he announced his achievement on an Internet usegroup.

• It was August, 1991.• This new OS, originally created to run a small

microcomputer, was built with substantial flexibility and it features many of the same functions found on expensive commercial OS.


History (cont’d)• Linux brought much of the speed, efficiency, and

flexibility of UNIX to small desktop computers.

• The first Linux OS required typed and sometimes cryptic commands.

• Now users can enter commands using either a command-driven interface (terminal mode) or a menu-driven interface or graphical user interface (GUI), greatly expanding the usability of the OS.

• The first primary corporate supporter of Linux was Red Hat Linux, the world’s leading Linux distributor until 2003.


History (cont’d)• In September of that year, the company split its efforts

in two directions:– The Fedora Project to encourage continuation of open-

source development of the Linux Kernel;– Red Hat Enterprise Linux (RHEL) to meet the growing

needs of organizations willing to pay for and enterprise-wide OS and dedicated technical support.

• As shown in Table 16.1, the Fedora Project issues updates free to the public about every six months.

• Because Linux is written and distributed under the GNU General Public License, its source-code is freely distributed and available to the general public.


History (cont'd.)


History (cont'd.)


Design Goals• Linux has three design goals:

– Modularity– Simplicity– Portability

• To achieve these goals, Linux administrators have access to numerous standard utilities, eliminating the need to write special code.

• Many of these utilities can be used in combination with each other so that users can select and combine appropriate utilities to carry out specific tasks.

• As shown in Table 16.2, Linux accommodates numerous functions.


Design Goals (cont'd.)


Design Goals (cont’d)• Linux conforms to the specifications for Portable

Operating System Interface (POSIX).– A registered trademark of the IEEE.

• POSIX is an IEEE standard that defines OS interfaces to enhance the portability of programs from one OS to another.


Memory Management• When Linux allocates space, it allocates:

– 1GB of high-order memory to the kernel– 3GB of memory to executing processes.

• This 3GB address space is divided among:– Process data;– Shared library data used by the process;– The stack used by the process.

• When a process begins execution, its segments have a fixed size.– There are cases when a process has to handle

variables with an unknown number and size.


Memory Management (cont’d)• When a process begins execution, its segments have a

fixed size (cont’d).– Therefore, Linux has system calls that change the size of

the process data segment, either by expanding it to accommodate extra data values or reducing it when certain values positioned at the end of the data segment are no longer needed.

• Linux offers memory protection based on the type of information stored in each region belonging to the address space of a process.– If a process modifies access authorization assigned to a

memory region, the kernel changes the protection information assigned to the corresponding memory pages.


Memory Management (cont'd.)• When a process requests pages, Linuz loads them

into memory.• When the kernel needs the memory space, the

pages are released using a least recently used algorithm (LRU).– Linux maintains a dynamically managed area in

memory, a page cache, where new and old pages requested by processes are inserted, and from which pages are deleted when they’re no longer needed.

– If any pages marked for deletion have been modified, they’re rewritten to the disk.

– The swap device could be a partition on the disk or it could be a normal file.


Memory Management (cont'd.)– Linux shows added flexibility with swap devices

because, if necessary, Linux can deactivate them without having to reboot the system.

– When this takes place, all pages saved on that device are reloaded into memory.

• To keep track of free and busy pages, Linux uses a system of page tables.

• Virtual memory in Linux is managed using a multiple-level table hierarchy, which accommodates both 64- and 32-bit architectures.– Table 16.3 shows how each virtual address is made

up of four fields, which are used by the Memory Manager to locate the instruction or data requested.


Memory Management (cont'd.)

• Virtual memory managed using multiple-level table hierarchy– Four fields in virtual address


Memory Management (cont'd.)• Each page has its own entry in the main directory,

which has pointers to each page’s middle directory.• A page’s middle directory contains pointers to its

corresponding page table directories.• In turn, each page table directory has pointers to the

actual page frame, as shown in Figure 16.2.• Finally, the page offset field is used to locate the

instruction or data within the requested page (Line 214).




Memory Management (cont'd.)• Virtual memory is implemented in Linux through

demand paging.

• Up to a total of 256MB of usable memory can be configured into equal-sized page frames, which can be grouped to give more contiguous space to a job.

• These groups can also be split to accommodate smaller jobs.


Memory Management (cont'd.)• This process of grouping and splitting is known as

the buddy algorithm.– Let’s consider the case where main memory consists

of 64 page frames and Job 1 requests 15 page frames.

– The buddy algorithm first rounds up the request to the next power of 2 (15 is rounded up to 16).

– Then the group of 64 page frames is divided into two groups of 32, and the lower section is then divided in half.

– Now there is a group of 16 page frames that can satisfy the request, so the job’s 16 pages are copied into the page frames as shown in Figure 16.3 (a).


Memory Management (cont'd.)• The buddy algorithm (cont’d).

– When the next job, Job 2, requests 8 page frames, the second group of 16 page frames is divided into two and the lower half with 8 page frames is given to Job 2 (Figure 16.3 (b)).

– Later, when Job 2 releases its page frames, they are combined with the upper 8 page frames to make a group of 16 page frames (Figure 16.3 (c)).




Memory Management (cont'd.)• The page replacement algorithm is an expanded

version of the clock page replacement policy (Chapter 3).

• Instead of using a single reference bit, Linux uses an eight-bit byte to keep track of a page’s activity.– Referred to as “age”.

• Each time a page is referenced, this age variable is incremented.

• Behind the scenes, at specific intervals, the Memory Manager checks each of these age variables and decreases their value by 1.


Memory Management (cont'd.)• As a result, if a page is not reference frequently,

then its age variable will drop to 0 and the page will become a candidate for replacement if a page swap is necessary.

• On the other hand, a page that is frequently used will have a high age value and will not be a good choice for swapping.

• Therefore, we can see that Linux uses a form of the least frequently used (LFU) replacement policy.


Processor Management• Linux uses the same parent-child process

management design found in UNIX (Chapter 13).

• Linux also supports the concept of “Personality” to allow processes coming from other OS to be executed.

• Each process is assigned to an execution domain specifying the way in which system calls are carried out and the way in which messages are sent to processes.


Organization of Process Table• Each process is referenced by a descriptor which

contains approximately 70 fields describing the process attributes together with the information needed to manage the process.

• The kernel dynamically allocates these descriptors when processes begin execution.

• All process descriptors are organized by a doubly linked list, and the descriptors of processes that are ready or in execution are put in another doubly linked list with fields indicating:

• “Next run” • “Previously run”

• There are several macro instructions used by the Scheduler to manage and update these process descriptor lists as needed.


Process Synchronization• Linux provides wait queues and semaphores to

allow two processes to synchronize with each other.• A Wait queue is a linked circular list of process

descriptors.• Semaphores (Chapter 6) are used to solve the

problems of mutual exclusion and the problems of producers and consumers.

• In Linux, the semaphore structure contains three fields:– The semaphore counter;– The number of waiting processes;– The list of processes waiting for the semaphore.


Process Synchronization (cont’d)• In Linux, the semaphore structure contains three

fields (cont’d).– The semaphore counter may contain only binary

values, except when several units of one resource are available, and the semaphore counter then assumes the value of the number of units that are accessible concurrently.


Process Management• The Linux scheduler:

– Scans the list of processes in the READY state; – Using predefined criteria, chooses which process to

execute.

• The scheduler has three different scheduling types:– Two for real-time processes;– One for normal processes.

• The combination of type (Table 16.4) and priority is used by the scheduler to determine the scheduling policy used on processes in the READY queue.


Process Management (cont'd.)


Process Management (cont'd.)• From among the processes with the highest priority

(SCHED_FIFO), the scheduler selects the process with the highest priority and executes it using the First in, first out algorithm.– This process is normally not preemptible and runs to

completion unless one of the following situations occur:• The process goes into the WAIT state (waiting for I/O, or

another event, to finish).• The process relinquishes the processor voluntarily, in

which case the process is moved to a WAIT state and other proceses are executed.

– Only when all FIFO processes are completed does the scheduler proceed to execute processes of lower priority.


Process Management (cont'd.)• When executing a process of the second type

(SCHED_RR), the scheduler chooses those from this group with the highest priority and uses a round robin algorithm with a small time quantum.– When the time expires, other higher priority processes

(FIFO, RR ) may be selected and executed before the first process is allowed to complete.


Process Management (cont'd.)• The third type of process (SCHED_OTHER) has the

lowest priority and is executed only when there are no processes with higher priority in the READY queue.

• From among these processes, the scheduler selects processes on order after considering their dynamic priorities.– Set by the user using system calls and by a factor

computed by the system.• From among the SCHED-OTHER processes, the

priorities of all processes that are CPU-bound are lowered during execution.– They may earn a lower priority than processes that are

not executing or those with a priority that has not been lowered.


Device Management• Linux is device independent, which improves

portability from one system to another.

• Device drivers supervise the transmission of data between main memory and the peripheral unit.

• Devices are assigned not only a name but also descriptors that further identify each device and are stored in the device directory (Figure 16.4)


Device Management (cont'd.)


Device Classifications• Linux identifies each device by a:

– Minor device number:• Passed to the device driver as an argument • Is used to access one of several identical physical

devices.

– Major device number:• Used as an index to the array to access the appropriate

code for a specific device driver.

• Each class has a Configuration Table that contains an array of entry points into the device drivers.– This table is the only connection between the system

code and device driver.– It allows the system programmers to create new device

drivers quickly to accommodate differently configured systems.


Device Drivers• Linux supports the standard classes of devices

introduced by UNIX.• Linux allows new device classes to support new

technology.• Device classes are not rigid in nature.

– Programmers may choose to create large, complex device drivers to perform multiple functions.

– Such programming is discouraged because:• Code can be shared among Linux users and there is a

wider demand for several simple drivers than for a single complex one.

• Modular code is better able to support Linux’s goals of system scalability and extendibility.


Device Drivers (cont'd.)– Programmers are urged to write device drivers that

maximize the system’s ability to use the device effectively.

• A notable feature of Linux is its ability to accept new device drivers on the fly, while the system is up and running.

• Administrators can give the kernel additional functionality by loading and testing new drivers without having to reboot each time to reconfigure the kernel.– Devices are treated in Linux in the same way all files

are treated.


Device Drivers (cont'd.)• Two common features of Linux device drivers are

open and release, which essentially allocate and deallocate the appropriate device.– The operation to open a device should perform the

following functions:• Verify that the device is available and in working order.

• Increase the usage counter for the device by 1, so the subsystem knows that the module cannot be unloaded until its file is appropriately closed.

• Initialize the device so that old data is removed and the device is ready to accept new data.

• Identify the minor number and update the appropriate pointer if necessary.

• Allocate any appropriate data structure.


Device Drivers (cont'd.)– The release function (called device_close or

device_release) performs these tasks:• Deallocate any resources that were allocated with the

open function;

• Shut down the device;

• Reduce the usage counter by 1 so the device can be released to another module.


Device Classes

• Three standard classes


Device Classes (cont'd.)• The three standard classes of devices supported b y

Linux are character devices, block devices and network devices (Figure 16.5).

• Character (char) devices– Can be accessed as a stream of bytes

• Communications port, monitor, other byte-stream-fed device.

– At a minimum, drivers for these devices usually implement the open, close, read, and write system calls.

– Accessed by file system nodes, and, from a functional standpoint, these devices look like an ordinary data area.


Device Classes (cont'd.)• Character (Char) Devices (contid).

– Their drivers are treated the same way as ordinary files with the exception that char device drivers are data channels that must be accessed sequentially.

• Block devices– Can host a file system (hard disk).– Accessed by file system nodes in /dev directory

• These devices are transferred in blocks of data of any size from a few bytes to many.

– Appear as ordinary files with the exception that the block drivers can access a file system in connection with the device (not possible with char device).


Device Classes (cont'd.)• Network interfaces

– Are dissimilar from both char and block devices because their function is to send and receive packets of information as directed by the network subsystem of the kernel.

– Each system device is handled by a device driver that is, in turn, under the direction of a subsystem of Linux.


File Management• All Linux files are organized in directories that are

connected to each other in a tree-like structure.

• Linux specifies five file types (Table 16.5).


Data Structures

• Files organized in directories– Connected in treelike structure

• Five file types


Filename Conventions• Filenames are case sensitive so Linux recognizes

both uppercase and lowercase letters in filenames.• Filenames can be up to 255 characters long.• Can contain alphabetic characters, underscores,

and numbers.• File suffixes (similar to file extensions) are optional.• Filenames can include a space; however, this can

cause complications if you’re running programs from the command-line– A program named interview notes would be viewed as

a command to run two files: interview and notes.– To avoid confusion, the two words can be enclosed in

quotes: “interview notes”


Filename Conventions (cont'd.)


Filename Conventions (cont’d)• To copy the file called checks for october (Figure

16.6), the user can type from any other folder:

cp/memo/job_expenses/checks for october

• The first slash indicates that this is an absolute path name that starts at the root directory.

• If the file you are seeking is in a local directory, you can use a relative path name – one that doesn’t start at the root directory.

• Two examples of relative path names from Figure 16.6 are: Job_expense/checks for october memo/music 10a


Filename Conventions (cont'd.)• A few rules apply to all path names:

– If the path name starts with a slash, the path starts at the root directory.

– A path name can be either one name or a list of names separated by slashes.

• The last names on the list is the name of the file requested.

• All names preceding the file’s name must be directory names.

– Using two periods (..) in a path name will move you upward in the hierarchy; all other path names go down the tree.


Filename Conventions (cont'd.)• Data structures:

• To allow processes to access files in a consistent manner, the kernel has a layer of software that maintains an interface between system calls related to files and the file management code.

– This layer is known as the Virtual File System (VFS).

• Any process-initiated system call to files is directed to the VFS, which performs file operations independent of the format of the file system involved.

• The VFS then redirects the request to the module managing the file.


Directory Listings• While directory listings can be created from

Terminal mode using typed commands (ls or ls -l command), many Linux users find that the easiest way to list files in directories is from the GUI desktop.

• A typical listing shows:– The name of the file or directory;– Its size;– The date and time of modification.

• Information about file permissions can be accessed from the View option on the menu bar.


Directory Listings (cont'd.)


Directory Listings (cont’d)– The Permissions column shows a code with the file’s

type and access privileges (Figure 16.8).– To understand the specific kind of access granted,

notice the order of letters in this column.• The first character in the column describes the nature

of the folder entry:– The dash (-) indicates a file;– d indicates a directory file;– l indicates a link;– b indicates a block special file.


Directory Listings (cont’d)• The next three characters (rwx) describe the access

privileges granted to other members of the user’s group.– A group is defined as a set of users, excluding the owner,

who have something in common.» The same project, same class, same department, etc.

– rwx for characters 5-7 means group users can also read, write, and/or execute that file.

» A dash (-) indicates that access is denied fo rthat operation.

• The last three characters describe the access privileges granted to others, defined as users at large (sometimes called the world) but excluding the owner and members of the owner’s group.


Directory Listings (cont'd.)

• Change file security– Owner (and only the owner) opens file properties to

be protected • File-Properties from the File menu

– Click on Permissions tab– Choose the appropriate access

• For owner, group, others


User Interface• Early Linux versions required typed commands and

a thorough knowledge of valid commands (Table 16.6).

• Although most current versions include the powerful and intuitive menu-driven interfaces, users can still use Terminal mode to type commands that are very similar to those used for UNIX, which can be helpful for those migrating from an OS that’s command-driven.


Command-Driven Interfaces• The general syntax for typed commands is:

command arguments filename• The command is any legal OS command.• The arguments are required for some commands

and optional for others. • The filename can be the name of a file and can

include a relative or absolute path name.• Commands are interpreted by the shell (such as the

Bash shell).• The shell is technically known as the command

interpreter, but it isn’t only an interactive command interpreter; it’s also the key to the coordination and combination of system programs.


Command-Driven Interfaces (cont'd.)


Graphical User Interfaces• Most Linux OS are delivered with multiple graphical

user interfaces (often free), allowing the end users to choose the GUI that best meets their needs or those of the organization.– In certain environments, different GUIs can be used

by different users on same system.– This flexibility has spurred the ever-widening

acceptance of Linux and has helped it become more competitive.

• In addition to GUIs, many Linux versions also come equipped with Windows-compatible word processors and spreadsheet and presentation applications (some at no cost).


Graphical User Interfaces– These software tools make it possible for Linux users

to read and write documents that are generated, or read, by colleagues using proprietary software from competing OS distributors.

– Because competing programs can cost hundreds of dollars, the availability of these affordable applications is one factor that has spurred the popularity of Linux.


System Monitor• Information about the status of the system is

available using the System Monitor window (Figure 16.10).

• Shows the immediate history of the CPU, memory, and network usage.

• Other information available from this window includes supported file systems and information about processes currently running.


System Monitor (cont'd.)


Service Settings• Administrators can implement a variety of services

to help manage the system.

• Options may vary from one system to another.


System Logs• Administrators use system logs that provide a

detailed description of activity on the system.

• These logs are invaluable to administrators tracking the course of a system malfunction, a firewall failure, disabled device and more.

• These log files for some Linux OS can be found in the /var/log directory.


System Logs (cont'd.)


Keyboard Shortcuts• To allow users to easily switch from one task to

another, Linux supports keyboard shortcuts, many of which are identical to those commonly used on Windows operating systems, easing the transition from one OS to the other. – Example: CTRL-V

• A quick way to issue a PASTE command in Linux, UNIX, and Windows.


Summary

• Originally designed to gain more microcomputer chip power– Evolved into powerful, flexible operating system

• Runs supercomputers, cell phones, many devices

• Unparalleled popularity among programmers– Contribute standard code set enhancements

• Supports broad range of applications– Available for minimal cost and easy to install– Growing acceptance among non-programmers

• Large organizations– Commercial Linux products available

Documents

Understanding Operating Systems Sixth Edition Chapter 16 Linux Operating System