Operating systems-POS-U1.2.pdf cse gghhu

Dhbfh

1. Operating-System Services

2. 2.2
Operating System Services
•Operatingsystemsprovideanenvironmentforexecutionof
programsandservicestoprogramsandusers
•Onesetofoperating-systemservicesprovidesfunctionsthatare
helpfultotheuser:
–Userinterface-Almostalloperatingsystemshaveauser
interface(UI).
•VariesbetweenCommand-Line(CLI),GraphicsUserInterface
(GUI),touch-screen,Batch
–GUI-theinterfaceisawindowsystemwithamousethatservesas
apointingdevicetodirectI/O,choosefrommenus,andmake
selectionsandakeyboardtoentertext.
–Mobilesystemssuchasphonesandtabletsprovideatouch-
screeninterface,enablinguserstoslidetheirfingersacrossthe
screenorpressbuttonsonthescreentoselectchoices
•CLI-usestextcommandsandamethodforenteringthem(Ex:
keyboardfortypingincommandsinaspecificformatwithspecific
options)

3. 2.3
Operating System Services
–Programexecution-Thesystemmustbeabletoloadaprogram
intomemoryandtorunthatprogram,endexecution,either
normallyorabnormally(indicatingerror)
–I/Ooperations-ArunningprogrammayrequireI/O,whichmay
involveafileoranI/Odevice
–File-systemmanipulation-Thefilesystemisofparticular
interest.Programsneedtoreadandwritefilesanddirectories,
createanddeletethem,searchthem,listfileInformation,
permissionmanagement.
–Communications–Processesmayexchangeinformation,onthe
samecomputerorbetweencomputersoveranetwork
•Communicationsmaybeviasharedmemory(twoormore
processesreadandwritetoasharedsectionofmemory)or
throughmessagepassing(packetsofinformationin
predefinedformatsaremovedbetweenprocessesbytheOS)

4. 2.4
Operating System Services (Cont.)
–Error detection –OS needs to be constantly aware of
possible errors
•May occur in the CPU and memory hardware, in I/O
devices, in user program
•For each type of error, OS should take the appropriate
action to ensure correct and consistent computing
•Debugging facilities can greatly enhance the user’s and
programmer’s abilities to efficiently use the system

5. 2.5
Operating System Services (Cont.)
•AnothersetofOSfunctionsexistsforensuringtheefficient
operationofthesystemitselfviaresourcesharing
–Resourceallocation-Whenmultipleusersormultiplejobs
runningconcurrently,resourcesmustbeallocatedtoeachof
them
•Manytypesofresources-CPUcycles,mainmemory,file
storage,I/Odevices.
–Accounting/Logging-Tokeeptrackofwhichusersusehow
muchandwhatkindsofcomputerresources
–Protectionandsecurity-Theownersofinformationstoredina
multiuserornetworkedcomputersystemmaywanttocontrol
useofthatinformation,concurrentprocessesshouldnot
interferewitheachother
•Protectioninvolvesensuringthatallaccesstosystem
resourcesiscontrolled
•Securityofthesystemfromoutsidersrequiresuser
authentication,extendstodefendingexternalI/Odevices
frominvalidaccessattempts

6. 2.6
A View of Operating System Services

7. 2.7
Command Line interpreter (CLI)
•CLIallowsdirectcommandentry
•Sometimesimplementedinkernel,sometimesbysystems
program
•Sometimesmultipleflavorsimplemented–shells
•Ex:onUNIXandLinuxsystems,ausermaychooseamongseveral
•differentshells,includingtheCshell,Bourne-Againshell,Korn
shell,andothers
•Primarilyfetchesacommandfromuserandexecutesit
•Sometimescommandsbuilt-in,sometimesjustnamesofprograms
–Ifthelatter,addingnewfeaturesdoesn’trequireshell
modification
User and Operating-System Interface

8. 2.8
Bourne Shell Command
Interpreter
The bash shell command interpreter in macOS.

9. 2.9
User Operating System Interface -GUI
•User-friendlydesktopmetaphorinterface
–Usuallymouse,keyboard,andmonitor
–Iconsrepresentfiles,programs,actions,etc
–Variousmousebuttonsoverobjectsintheinterfacecause
variousactions(provideinformation,options,execute
function,opendirectory(knownasafolder)
–InventedatXeroxPARC
•ManysystemsnowincludebothCLIandGUIinterfaces
–MicrosoftWindowsisGUIwithCLI“command”shell
–AppleMacOSXis“Aqua”GUIinterfacewithUNIXkernel
underneathandshellsavailable
–UnixandLinuxhaveCLIwithoptionalGUIinterfaces(CDE,
KDE,GNOME)

10. 2.10
Touchscreen Interfaces
•users interact by making gestures
on the touch screen—for
example, pressing and swiping
fingers across the screen.
•Touchscreen devices require new
interfaces
–Mouse not possible or not
desired
–Actions and selection based on
gestures
–Virtual keyboard for text entry
•Voice commands
The iPhone touch screen.

11. 2.11
The Mac OS X GUI

12. 2.12
System Calls
•ProgramminginterfacetotheservicesprovidedbytheOS
•Systemcallsprovideaninterfacetotheservicesmade
availablebyanoperatingsystem.
•Typicallywritteninahigh-levellanguage(CorC++)
•Mostlyaccessedbyprogramsviaahigh-levelApplication
ProgrammingInterface(API)ratherthandirectsystemcalluse
•TheAPIspecifiesasetoffunctionsthatareavailabletoan
applicationprogrammer,includingtheparametersthatare
passedtoeachfunctionandthereturnvaluestheprogrammer
canexpect
•ThreemostcommonAPIsareWin32APIforWindows,POSIX
APIforPOSIX-basedsystems(includingvirtuallyallversionsof
UNIX,Linux,andMacOSX),andJavaAPIfortheJavavirtual
machine(JVM)

13. 2.13
Example of System Calls
•System call sequence to copy the contents of one file to
another file

14. 2.14
System Call Implementation
•a number is associated with each system call
–System-callinterfacemaintains a table indexed according to
these numbers
•The system call interface invokes the intended system call in OS
kernel and returns status of the system call and any return values
•The caller need know nothing about how the system call is
implemented
–Just needs to obey API and understand what OS will do as a
result call
–Most details of OS interface hidden from programmer by API
•Managed by run-time support library (set of functions
built into libraries included with compiler)

15. 2.15
API –System Call –OS Relationship

16. 2.16
System Call Parameter Passing
•Often, more information is required than simply identity of
desired system call
–Exact type and amount of information vary according to OS
and call
•Three general methods used to pass parameters to the OS
–Simplest: pass the parameters in registers
•In some cases, may be more parameters than registers
–Parameters stored in a block, or table, in memory, and
address of block passed as a parameter in a register
•This approach taken by Linux and Solaris
–Parameters placed, or pushed, onto the stackby the
program and poppedoff the stack by the operating system
–Block and stack methods do not limit the number or length
of parameters being passed

17. 2.17
Parameter Passing via Table

18. 2.18
Types of System Calls
•Systemcallscanbegroupedroughlyintosixmajorcategories:
processcontrol,filemanagement,devicemanagement,
informationmaintenance,communications,andprotection.
•Processcontrol
–createprocess,terminateprocess
–end,abort
–load,execute
–getprocessattributes,setprocessattributes
–waitfortime
–waitevent,signalevent
–allocateandfreememory
–Dumpmemoryiferror
–Debuggerfordeterminingbugs,singlestepexecution
–Locksformanagingaccesstoshareddatabetweenprocesses

19. 2.19
Types of System Calls (Cont.)
•File management
–create file, delete file
–open, close file
–read, write, reposition
–get and set file attributes
•Device management
–request device, release device
–read, write, reposition
–get device attributes, set device attributes
–logically attach or detach devices

20. 2.20
Types of System Calls (Cont.)
•Information maintenance
–get time or date, set time or date
–get system data, set system data
–get and set process, file, or device attributes
•Communications
–create, delete communication connection
–send, receive messages if messagepassingmodelto
hostnameor processname
•Fromclienttoserver
–Shared-memorymodelcreate and gain access to
memory regions
–transfer status information
–attach and detach remote devices

21. 2.21
Types of System Calls (Cont.)
•Protection
–Control access to resources
–Get and set permissions
–Allow and deny user access

22. 2.22
Examples of Windows and Unix System Calls

23. 2.23
Example: MS-DOS
•Single-tasking
•Shell invoked when
system booted
•Simple method to run
program
–No process created
•Single memory space
•Loads program into
memory, overwriting all
but the kernel
•Program exit -> shell
reloaded At system startup running a program

24. 2.24
Example: Arduino
•Single-tasking
•No operating system
•Programs (sketch) loaded
via USB into flash memory
•Single memory space
•Boot loader loads
program
•Program exit -> shell
reloaded
At system startup running a program

25. 2.25
Example: FreeBSD
•Unix variant
•Multitasking
•User login -> invoke user’s choice of
shell
•Shell executes fork() system call to
create process
–Executes exec() to load program into
process
–Shell waits for process to terminate
or continues with user commands
•Process exits with:
–code = 0 –no error
–code > 0 –error code
FreeBSD running multiple programs

26. 2.26
System Services/ System Programs
•Systemservices,alsoknownassystemutilitiesorSystem
programsprovideaconvenientenvironmentforprogram
developmentandexecution.Theycanbedividedinto:
–Filemanipulation
–Statusinformationsometimesstoredinafile
–Programminglanguagesupport
–Programloadingandexecution
–Communications
–Backgroundservices
–Applicationprograms
•Mostusers’viewoftheoperatingsystemisdefinedbysystem
programs,nottheactualsystemcalls

27. 2.27
System Services (Cont.)
•Provideaconvenientenvironmentforprogramdevelopment
andexecution
–Someofthemaresimplyuserinterfacestosystemcalls;
othersareconsiderablymorecomplex
•Filemanagement-Create,delete,copy,rename,print,dump,
list,andgenerallymanipulatefilesanddirectories
•Statusinformation
–Someaskthesystemforinfo-date,time,amountof
availablememory,diskspace,numberofusers
–Othersprovidedetailedperformance,logging,and
debugginginformation
–Typically,theseprogramsformatandprinttheoutputto
theterminalorotheroutputdevices
–Somesystemsimplementaregistry-usedtostoreand
retrieveconfigurationinformation

28. 2.28
System Services (Cont.)
•Filemodification
–Texteditorstocreateandmodifyfiles
–Specialcommandstosearchcontentsoffilesorperform
transformationsofthetext
•Programming-languagesupport-Compilers,assemblers,
debuggersandinterpreterssometimesprovided
•Programloadingandexecution-Absoluteloaders,relocatable
loaders,linkageeditors,andoverlay-loaders,debugging
systemsforhigher-levelandmachinelanguage
•Communications-Providethemechanismforcreatingvirtual
connectionsamongprocesses,users,andcomputersystems
–Allowuserstosendmessagestooneanother’sscreens,
browsewebpages,sendelectronic-mailmessages,login
remotely,transferfilesfromonemachinetoanother

29. 2.29
System Services (Cont.)
•Background Services
–Launch at boot time
•Some for system startup, then terminate
•Some from system boot to shutdown
–Provide facilities like disk checking, process scheduling,
error logging, printing
–Run in user context not kernel context
–Known as services, subsystems, daemons
•Application programs
–Don’t pertain to system
–Run by users
–Not typically considered part of OS
–Launched by command line, mouse click, finger poke

30. 2.30
Linkers and Loaders
•Source code compiled into object files designed to be loaded into
any physical memory location –relocatableobjectfile
•Linkercombines these into single binary executablefile
–Also brings in libraries
•Program resides on secondary storage as binary executable
•Must be brought into memory by loaderto be executed
–Relocationassigns final addresses to program parts and adjusts code
and data in program to match those addresses
•Modern general purpose systems don’t link libraries into
executables
–Rather, dynamicallylinkedlibraries(in Windows, DLLs) are loaded as
needed, shared by all that use the same version of that same library
(loaded once)
•Object, executable files have standard formats, so operating system
knows how to load and start them

31. 2.31
The Role of the Linker and Loader

32. 2.32
•DesignandImplementationofOSisnot“solvable”,butsome
approacheshaveprovensuccessful
•InternalstructureofdifferentOperatingSystemscanvary
widely
•Startthedesignbydefininggoalsandspecifications
•Affectedbychoiceofhardware,typeofsystem
•UsergoalsandSystemgoals
–Usergoals–operatingsystemshouldbeconvenienttouse,
easytolearn,reliable,safe,andfast
–Systemgoals–operatingsystemshouldbeeasytodesign,
implement,andmaintain,aswellasflexible,reliable,error-
free,andefficient
•SpecifyinganddesigninganOSishighlycreativetaskof
softwareengineering
Operating System Design and Implementation

33. 2.33
Policy and Mechanism
•Policy: What needs to be done?
–Example: Interrupt after every 100 seconds
•Mechanism: Howto do something?
–Example: timer
•Important principle: separate policy from mechanism. Mechanisms
determine how to do something, policies decide what will be done
•The separation of policy from mechanism is a very important
principle, it allows maximum flexibility if policy decisions are to be
changed later.
–Example: change 100 to 200
Specifying and designing an OS is highly creative task of software
engineering

34. 2.34
Implementation
•Much variation
–Early OSes in assembly language
–Then system programming languages like Algol, PL/1
–Now C, C++
•Actually usually a mix of languages
–Lowest levels in assembly
–Main body in C
–Systems programs in C, C++, scripting languages like PERL,
Python, shell scripts
•More high-level language easier toportto other hardware
–But slower
•Emulationcan allow an OS to run on non-native hardware

35. 2.35
Operating System Structure
•General-purpose OS is very large program
•Various ways to structure ones
–Simple structure –MS-DOS
–More complex –UNIX
–Layered –an abstraction
–Microkernel –Mach

36. 2.36
Simple Structure --MS-DOS
•MS-DOS –written to provide
the most functionality in the
least space
–Not divided into modules
–Although MS-DOS has
some structure, its
interfaces and levels of
functionality are not well
separated

37. 2.37
Monolithic Structure –Original UNIX
•simpleststructurefororganizinganoperatingsystemisno
structureatall.
•allofthefunctionalityofthekernelintoasingle,staticbinaryfile
thatrunsinasingleaddressspace
•UNIX–limitedbyhardwarefunctionality,theoriginalUNIX
operatingsystemhadlimitedstructuring.
•TheUNIXOSconsistsoftwoseparableparts
–Systemsprograms
–Thekernel
•Consistsofeverythingbelowthesystem-callinterfaceand
abovethephysicalhardware
•Providesthefilesystem,CPUscheduling,memory
management,andotheroperating-systemfunctions;a
largenumberoffunctionsforonelevel

38. 2.38
Traditional UNIX System Structure
Beyond simple but not fully layered
•knownasatightlycoupledsystembecausechangestoonepartof
thesystemcanhavewide-rangingeffectsonotherparts

39. 2.39
Linux System Structure
Monolithic plus modular design

40. 2.40
Layered Approach
•Theoperatingsystemisdivided
intoanumberoflayers(levels),
eachbuiltontopoflowerlayers.
Thebottomlayer(layer0),isthe
hardware;thehighest(layerN)
istheuserinterface.
•Withmodularity,layersare
selectedsuchthateachuses
functions(operations)and
servicesofonlylower-level
layers
•looselycoupledsystem-systemisdividedintoseparate,smaller
componentsthathavespecificandlimitedfunctionality.
•Theadvantageofthismodularapproachisthatchangesinone
componentaffectonlythatcomponent,andnoothers,allowing
systemimplementersmorefreedomincreatingandchangingthe
innerworkingsofthesystem.

41. 2.41
•Themainadvantageofthelayeredapproachissimplicityof
constructionanddebugging.Thelayersareselectedsothateach
usesfunctions(operations)andservicesofonlylower-levellayers.
•Thisapproachsimplifiesdebuggingandsystemverification.
•Thefirstlayercanbedebuggedwithoutanyconcernfortherestof
thesystem,because,bydefinition,itusesonlythebasichardware
toimplementitsfunctions.
•Oncethefirstlayerisdebugged,itscorrectfunctioningcanbe
assumedwhilethesecondlayerisdebugged,andsoon.Ifanerror
isfoundduringthedebuggingofaparticularlayer,theerrormust
beonthatlayer,becausethelayersbelowitarealreadydebugged.
Thus,thedesignandimplementationofthesystemaresimplified.
•Eachlayerisimplementedonlywithoperationsprovidedbylower-
levellayers.Alayerdoesnotneedtoknowhowtheseoperations
areimplemented;itneedstoknowonlywhattheseoperationsdo.
•eachlayerhidestheexistenceofcertaindatastructures,
operations,andhardwarefromhigherlevellayers

42. 2.42
Microkernels
•Moves as much from the kernel into user space
•Machis an example of microkernel
–Mac OS X kernel (Darwin) partly based on Mach
•Communication takes place between user modules using
messagepassing
•Benefits:
–Easier to extend a microkernel
–Easier to port the operating system to new architectures
–More reliable (less code is running in kernel mode)
–More secure
•Detriments:
–Performance overhead of user space to kernel space
communication

43. 2.43
Microkernel System Structure

44. 2.44
Modules
•Manymodernoperatingsystemsimplementloadablekernel
modules(LKMs)
–Usesobject-orientedapproach
–Eachcorecomponentisseparate
–Eachtalkstotheothersoverknowninterfaces
–Eachisloadableasneededwithinthekernel
•Overall,similartolayersbutwithmoreflexible
–Linux,Solaris,etc.

45. 2.45
Solaris Modular Approach

46. 2.46
Hybrid Systems
•Mostmodernoperatingsystemsarenotonepuremodel
–Hybridcombinesmultipleapproachestoaddress
performance,security,usabilityneeds
–LinuxandSolariskernelsinkerneladdressspace,so
monolithic,plusmodularfordynamicloadingof
functionality
–Windowsmostlymonolithic,plusmicrokernelfordifferent
subsystempersonalities
•AppleMacOSXhybrid,layered,AquaUIplusCocoa
programmingenvironment
–BelowiskernelconsistingofMachmicrokernelandBSD
Unixparts,plusI/Okitanddynamicallyloadablemodules
(calledkernelextensions)

47. 2.47
macOS and iOS Structure

48. 2.48
Darwin

49. 2.50
Android
•DevelopedbyOpenHandsetAlliance(mostlyGoogle)
–OpenSource
•SimilarstacktoiOS
•BasedonLinuxkernelbutmodified
–Providesprocess,memory,device-drivermanagement
–Addspowermanagement
•Runtimeenvironmentincludescoresetoflibrariesand
Dalvikvirtualmachine
–AppsdevelopedinJavaplusAndroidAPI
•JavaclassfilescompiledtoJavabytecodethen
translatedtoexecutablethnnrunsinDalvikVM
•Librariesincludeframeworksforwebbrowser(webkit),
database(SQLite),multimedia,smallerlibc

50. 2.51
Android Architecture

51. 2.52
Building and Booting an Operating System
•Operating systems generally designed to run on a class of
systems with variety of peripherals
•Commonly, operating system already installed on purchased
computer
–But can build and install some other operating systems
–If generating an operating system from scratch
•Write the operating system source code
•Configure the operating system for the system on
which it will run
•Compile the operating system
•Install the operating system
•Boot the computer and its new operating system

52. 2.53
Building and Booting Linux
•Download Linux source code (http://www.kernel.org)
•Configure kernel via “make menuconfig”
•Compile the kernel using “make”
–Produces vmlinuz, the kernel image
–Compile kernel modules via “make modules”
–Install kernel modules into vmlinuzvia “make
modules_install”
–Install new kernel on the system via “make install”

53. 2.54
System Boot
•Whenpowerinitializedonsystem,executionstartsatafixed
memorylocation
•Operatingsystemmustbemadeavailabletohardwareso
hardwarecanstartit
–Smallpieceofcode–bootstraploader,BIOS,storedinROMor
EEPROMlocatesthekernel,loadsitintomemory,andstartsit
–Sometimestwo-stepprocesswherebootblockatfixedlocation
loadedbyROMcode,whichloadsbootstraploaderfromdisk
–ModernsystemsreplaceBIOSwithUnifiedExtensible
FirmwareInterface(UEFI)
•Commonbootstraploader,GRUB,allowsselectionofkernelfrom
multipledisks,versions,kerneloptions
•Kernelloadsandsystemisthenrunning
•Bootloadersfrequentlyallowvariousbootstates,suchassingle
usermode

54. 2.55
Operating-System Debugging
•Debuggingisfindingandfixingerrors,orbugs
•Alsoperformancetuning
•OSgeneratelogfilescontainingerrorinformation
•Failureofanapplicationcangeneratecoredumpfilecapturing
memoryoftheprocess
•Operatingsystemfailurecangeneratecrashdumpfilecontaining
kernelmemory
•Beyondcrashes,performancetuningcanoptimizesystem
performance
–Sometimesusingtracelistingsofactivities,recordedforanalysis
–Profilingisperiodicsamplingofinstructionpointertolookfor
statisticaltrends
Kernighan’sLaw:“Debuggingistwiceashardaswritingthecodeinthe
firstplace.Therefore,ifyouwritethecodeascleverlyaspossible,you
are,bydefinition,notsmartenoughtodebugit.”

55. 2.56
Performance Tuning
•Improve performance by removing bottlenecks
•OS must provide means of computing and displaying measures
of system behavior
•For example, “top” program or Windows Task Manager

56. 2.57
Tracing
Collects data for a specific event, such as steps involved in a
system call invocation
Tools include
•strace–trace system calls invoked by a process
•gdb–source-level debugger
•perf –collection of Linux performance tools
•tcpdump–collects network packets

57. 2.58
BCC
Debugging interactions between user-level and kernel code
nearly impossible without toolset that understands both and an
instrument their actions
BCC (BPF Compiler Collection) is a rich toolkit providing tracing
features for Linux
•See also the original DTrace
For example, disksnoop.py traces disk I/O activity
Many other tools (next slide)

58. 2.59
Linux bcc/BPF Tracing Tools