Operating Systems

Fall 2024
OS Chapter 2
Dr. John Templeton
Todays Class Outline
Logistics/General Housekeeping
Quiz
Lecture
Summary
Final Notes
Logistics/General Housekeeping
Syllabus/Course Updates
• TA Office Hours Link – Also made a Canvas Announcement about this
• Undergraduate OS Book Added to syllabus as extra reference.
• Final Exam - Dec 12, 2024 | 12:30 – 2:30pm
• https://www.usf.edu/space/documents/final-exam-matrix.pdf
• Note at the bottom of the webpage: This exam schedule is subject to change without
notice. Check online for the most up‐to‐date version
Logistics/General Housekeeping
• Attendance
• I have updated the attendance accordingly based on who reached out to me.
• I am obligated to fill out the attendance by Friday so if your attendance assignment is
not completed prior you will be dropped from the class…

“47 72 61 64 20 4F 53 0A”

• Updated Xv6 documentation

• Project 0
• Demo Instructions posted with multiple work arounds to make sure the system gets
installed.
Logistics/General Housekeeping
• Read Ch. 1-2 of Operating System Concepts (OSC)
• Optionally also Ch. 1-2 of OSTEP
• Read through the syllabus on Canvas (especially those who have just
registered for the course)
• Start Project 0
• setting up xv6, understanding the code, and selecting project 1 groups
• complete individually
• due next Tuesday (Sep 3)
Quiz
• Please put everything away except for a pencil.
• Quizzes will last for the first 10 minutes of class unless everyone is done
prior to that time.
• When finished, please turn your quiz over and sit quietly until time is up.
• Do not pull other items (phones, tablets, computers, notes, etc.) out until I
have collected all the quizzes.
Review
• The two roles that an OS plays are: I_________________ &
R_________________.
• Three Fundamental Concepts of an OS are: V________________,
C______________, and P__________________.
Lecture - Chapter 2
• Operating System Services • Why Applications are Operating System Specific
• User and Operating System-Interface • Design and Implementation
• System Calls • Operating System Structure
• System Services • Building and Booting an Operating System
• Linkers and Loaders • Operating System Debugging
Operating System Services
• Operating systems provide an environment for the execution of
programs and provides services to both programs and users.
• One set of operating-system services provides functions that are
helpful to the user – this allows for high usability of the system.
• Another set of operating system services provide functions that are
helpful to programs – this exists for ensuring the efficient operation of
the system itself via resource sharing.
Operating System Services - User
• User interface - Almost all operating • I/O operations - A running
systems have a user interface (UI). program may require I/O, which
• Varies between Command-Line may involve a file or an I/O device
(CLI), Graphics User Interface • File-system manipulation - The file
(GUI), touch-screen, Batch, etc. system is of particular interest.
• Program execution - The system Programs need to read and write
must be able to load a program into files and directories, create and
memory and to run that program, delete them, search them, list file
end execution, either normally or Information, permission
abnormally (indicating error) management.
Operating System Services – User & Program
• Communications – Processes may • Error detection – OS needs to be
exchange information, on the same constantly aware of possible errors
computer or between computers • May occur in the CPU and
over a network memory hardware, in I/O
• Communications may be via devices, in user program
shared memory or through • For each type of error, OS
message passing (packets should take the appropriate
moved by the OS) action to ensure correct and
consistent computing
• Debugging facilities can greatly
enhance the user’s and
programmer’s abilities to
efficiently use the system
Operating System Services – Programs
• Resource allocation - When multiple jobs • Protection and security - The owners of
are running concurrently, resources must information stored in a multiuser or
be allocated to each of them networked computer system may want to
• Many types of resources - CPU cycles, control use of that information,
main memory, file storage, I/O concurrent processes should not interfere
devices. with each other
• Logging - To keep track of how much and • Protection involves ensuring that all
what kinds of computer resources are access to system resources is
being used controlled
• Security of the system from outsiders
requires user authentication, extends
to defending external I/O devices
from invalid access attempts
View of Operating System Services
CLI – Command Line Interpreter
• CLI allows direct command entry
• Sometimes implemented in kernel,
sometimes by systems program
• Sometimes multiple flavors implemented –
shells
• Primarily fetches a command from user and
executes it
• Sometimes commands built-in, sometimes
just names of programs
• If the latter, adding new features doesn’t
require shell modification
GUI – Graphical User Interface
• User-friendly desktop metaphor interface
• Usually mouse, keyboard, and monitor
• Icons represent files, programs, actions, etc
• Various mouse buttons over objects in the interface cause various actions (provide
information, options, execute function, open directory (known as a folder)
• Invented at Xerox PARC
• Many systems now include both CLI and GUI interfaces
• Microsoft Windows is GUI with CLI “command” shell
• Apple Mac OS X has a GUI interface with UNIX kernel underneath and shells
available
• Unix and Linux have CLI with optional GUI interfaces (CDE, KDE, GNOME)
Touch-Screen Interface
• Mobile devices require new interfaces
• Mouse not possible or not desired
• Actions and selection based on gestures
• Virtual keyboard for text entry
• Voice commands
User Choices
• The choice of whether to use a
CLI or GUI interface is mostly
one of personal preference.
• On some systems, only a
subset of system functions are
available via the GUI.
• On others, although there are
ways to have a CLI interface for
iOS and Android systems, they
are rarely used…
 Example

System Calls Source

• Programming interface to the services provided by

the OS
• Typically written in a high-level language (C or C++)
• Mostly accessed by programs via a high-level
Application Programming Interface (API) rather
than direct system call use
• Three most common APIs are Win32 API for
Windows, POSIX API for POSIX-based systems
(including virtually all versions of UNIX, Linux, and
Mac OS X), and Java API for the Java virtual
machine (JVM) Destination
Standard API
• Application Programming Interface specifies a set
of functions available to an application
programmer
• Includes parameters that are passed to each
function and can return values that the
programmer can expect
• So why would a programmer prefer this method to
actual system calls?
• Program Portability – Can expect this program
to compile and run on any system that
supports the same API.
• Cons: Architectural differences may make this
process difficult.
System Call Implementation
• Typically, a number is associated with each system call
• System-call interface maintains a table indexed according to these numbers
• The system call interface invokes the
intended system call in the 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
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
• Parameters placed, or pushed, onto the
stack by the program and popped off the
stack by the operating system
• These methods DON’T limit the number
or length of parameters being passed
Types of System Calls
• Process control • File management
• create process, terminate process • create file, delete file
• end, abort • open, close file
• load, execute • read, write, reposition
• get process attributes, set process • get and set file attributes
attributes • Device management
• wait for time, event, signal event • request device, release device
• allocate and free memory • read, write, reposition
• Dump memory if error • get device attributes, set device
• Debugger for determining bugs, single attributes
step execution • logically attach or detach devices
• Locks for managing access to shared
data between processes
Types of System Calls - Continued
• Information maintenance • Communications
• get time or date, set time or date • create, delete communication
• get system data, set system data connection
• get and set process, file, or device • send, receive messages if message
attributes passing model to host name or
process name
• Protection
• From client to server
• Control access to resources
• Shared-memory model create and
• Get and set permissions gain access to memory regions
• Allow and deny user access • transfer status information
• attach and detach remote devices
Examples
• There are so many facets of and variations in process control that we will look at two
examples
• Single-Tasking System (Arduino)
• Multi-Tasking System (FreeBSD)
• Arduino is a simple hardware platform consisting of a microcontroller and input sensors.
• FreeBSD is a free and open-source Unix-like variant OS descended from the Berkeley
Software Distribution.
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

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
System Services
• System services/utilities provide a convenient
environment for program development and
execution. They can be divided into:
• File manipulation
• Status information sometimes stored in a file
• Programming language support
• Program loading and execution
• Communications
• Background services
• Application programs
• Most users’ view of the OS is defined by system
services, not the actual system calls
System Services Continued
• Provide a convenient environment for program development and execution
• Some of them are simply user interfaces to system calls; others are considerably
more complex
• File management - Create, delete, copy, rename, print, dump, list, and generally
manipulate files and directories
• Status information
• Some ask the system for info - date, time, amount of available memory, disk space,
number of users
• Others provide detailed performance, logging, and debugging information
• Typically, these programs format and print the output to the terminal or other
output devices
• Some systems implement a registry - used to store and retrieve config information
System Services Continued (still)
• File modification
• Text editors to create and modify files
• Special commands to search contents of files or perform transformations of the text
• Programming-language support - Compilers, assemblers, debuggers and interpreters
sometimes provided
• Program loading and execution- Absolute loaders, relocatable loaders, linkage editors,
and overlay-loaders, debugging systems for higher-level and machine language
• Communications - Provide the mechanism for creating virtual connections among
processes, users, and computer systems
• Allow users to send messages to one another’s screens, browse web pages, send
electronic-mail messages, log in remotely, transfer files from one machine to another
System Services Continued (finally)
• 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
Linkers and Loaders
• Source code compiled into object files designed to be loaded into any physical memory
location – relocatable object file
• Linker combines these into single binary executable file && brings in libraries
• Program resides on secondary storage as binary executable
• Must be brought into memory by loader to be executed
• Relocation assigns 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, dynamically linked libraries (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
Linkers and Loaders
• When the ./main is run the shell first creates a
new process to run the program using the fork()
system call.
• The shell then invokes the loader with the exec()
system call, passing exec() the name of the
executable file.
• The loader then loads the specified program into
memory using the address space of the newly
created process.
• Same with a GUI interface when an icon double-
click is used.
Why Applications are OS Specific?
• Apps compiled on one system usually not executable on other operating systems
• Each operating system provides its own unique system calls
• Own file formats, etc.
• Apps can be multi-operating system
• Written in interpreted language like Python, Ruby, and interpreter available on
multiple operating systems
• App written in language that includes a VM containing the running app (like Java)
• Use standard language (like C), compile separately on each operating system to run
on each
• Application Binary Interface (ABI) is architecture equivalent of API, defines how different
components of binary code can interface for a given operating system on a given
architecture, CPU, etc.
Design and Implementation
• Design and Implementation of OS is not “solvable”, but some approaches have proven
successful
• Internal structure of different Operating Systems can vary widely
• Start the design by defining goals and specifications
• Affected by choice of hardware, type of system
• User goals and System goals
• User goals – operating system should be convenient to use, easy to learn, reliable,
safe, and fast
• System goals – operating system should be easy to design, implement, and maintain,
as well as flexible, reliable, error-free, and efficient
• Specifying and designing an OS is highly creative task of software engineering
Policy and Mechanism
• Policy: What needs to be done?
• Example: Interrupt after every 100 seconds
• Mechanism: How to do something?
• Example: timer
• Important principle: separate policy from mechanism
• 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
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
• Pros: Easier to port to other hardware, written faster, more compact, easier to understand
• Cons: Reduced Speed and increased storage requirements.
• Emulation can allow an OS to run on non-native hardware
Operating System Structure
• General-purpose OS is very large program
• Various ways to structure ones OS
• Simple structure – MS-DOS
• More complex – UNIX
• Layered – an abstraction
• Microkernel – Mach
Monolithic Structure – Original UNIX
• UNIX – limited by hardware functionality, the
original UNIX operating system had limited
structuring.
• The UNIX OS consists of two separable parts
• Systems programs
• The kernel
• Consists of everything below the
system-call interface and above the
physical hardware
• Provides the file system, CPU
scheduling, memory management, and
other operating-system functions; a
large number of functions for one level
Linux System Structure
• Monolithic+ (plus) modular design
• Monolithic → All support for system
functionality, such as device drivers, is built
directly into the kernel.
• Monolithic+ → Expanding on the monolithic
approach to include slight modularization
allows for better implementation and
extension
• Monolithic can be modular
and can dynamically load modules
• glibc standard C library is used when
communicating with the system call interface
to the kernel.
• provides the core libraries for the GNU system
and GNU/Linux systems, as well as many other
systems that use Linux as the kernel
Layered Approach
• The operating system is divided into a
number of layers (levels), each built on top
of lower layers. The bottom layer (layer 0),
is the hardware; the highest (layer N) is the
user interface.
• With modularity, layers are selected such
that each uses functions (operations) and
services of only lower-level layers.
Microkernels
• Moves as much from the kernel into user space
• Mach is an example of microkernel
• Mac OS X kernel (Darwin) partly based on Mach
• Communication takes place between user modules using message passing
• Pros:
• 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
• Cons:
• Performance overhead of user space to kernel space communication
Modules
• Many modern operating systems implement loadable kernel modules (LKMs)
• Uses object-oriented approach
• Each core component is separate
• Each talks to the others over known interfaces
• Each is loadable as needed within the kernel
• Overall, similar to layers but with more flexiblity
• Linux, Solaris, etc.
Hybrid Systems
• Most modern operating systems are not one pure model
• Hybrid combines multiple approaches to address performance, security,
usability needs
• Linux and Solaris kernels in kernel address space, so monolithic, plus modular
for dynamic loading of functionality
• Windows mostly monolithic, plus microkernel for different subsystem
personalities
• Apple Mac OS X hybrid, layered, Aqua UI plus Cocoa programming environment
• Below is kernel consisting of Mach microkernel and BSD Unix parts, plus I/O
kit and dynamically loadable modules (called kernel extensions)
macOS and iOS structure
Darwin
Android
• Developed by Open Handset Alliance (mostly Google)
• Open Source
• Similar stack to iOS
• Based on Linux kernel but modified
• Provides process, memory, device-driver management
• Adds power management
• Runtime environment includes core set of libraries and Dalvik VM
• Apps developed in Java plus Android API
• Java class files compiled to Java bytecode then translated
to executable then runs in Dalvik VM
• Libraries include frameworks for web browser (webkit), database
(SQLite), multimedia, smaller libc
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 you can build and install some other operating systems – Dual boot
• 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
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 vmlinuz via “make modules_install”
• Install new kernel on the system via “make install”
System Boot
• When power initialized on system, execution starts at a fixed memory location
• Operating system must be made available to hardware so hardware can start it
• Small piece of code – bootstrap loader, BIOS, stored in ROM or EEPROM locates the
kernel, loads it into memory, and starts it
• Sometimes two-step process where boot block at fixed location loaded by ROM
code, which loads bootstrap loader from disk
• Modern systems replace BIOS with Unified Extensible Firmware Interface (UEFI)
• Common bootstrap loader, GRUB, allows selection of kernel from multiple disks,
versions, kernel options
• Kernel loads and system is then running
• Boot loaders frequently allow various boot states, such as single user mode
Operating-System Debugging
• Debugging is finding and fixing errors, or bugs
• Also includes performance tuning
• OS generate log files containing error information
• Failure of an application can generate core dump file capturing memory of the process
• Operating system failure can generate crash dump file containing kernel memory
• Beyond crashes, performance tuning can optimize system performance
• Sometimes using trace listings of activities, recorded for analysis
• Profiling is periodic sampling of instruction pointer to look for statistical trends
Kernighan’s Law: “Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are, by definition, not smart
enough to debug it.”
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
• Counters
• Amount of system activity – e.g., number
of system calls or operations performed
• Per-Process
• System-Wide
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
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)

Linux BCC/BPF Tracing Tools
Summary
• An operating system provides an environment for the execution of programs by providing
services to U_________ and P____________.
• The three primary approaches for interacting with an operating system include: (1) CLI, (2)
_______ , and (3) ___________.
• System calls provide an interface to the services made available by an OS. Programmers use
________ for accessing system call services.
• System calls can be divided into six major categories: (1) Process Control, (2)File
Management,(3) D_______ Management,(4)Information maintenance,
(5)C______________, and (6) Protection.
• The standard C library provides the system-call interface for both U____ & L____ Systems.
Summary
• A L_________ combines several relocatable object modules into a single binary executable
file and a L_________ places the executable file into memory, where it becomes eligible to
run on an available CPU.
• There are several reasons why applications are operating-system specific. Ex?
• An OS should be designed with specific goals in mind. They determine the systems
P________ which are implemented via specific M___________.
• A monolithic OS has ____ structure → all functionality is provided in a single static binary
file that runs in a single address space.
• A layered operating system is divided into a number of discrete layers, where the bottom is
the ______ and the top is the __________.
Summary
• The microkernel approach for designing OS uses a minimal Kernel. How does
communication take place?
• Many contemporary operating systems are constructed as H_______ systems using a
combination of a monolithic kernel and modules. Benefits include?
• The performance of an OS can be monitored using either C_________ (a collection of
system wide or per process stats) or T__________ (the execution of a program through the
OS.
End of Chapter 2
• General Housekeeping
• Attendance
• I am obligated to fill out the attendance by Friday so if your attendance assignment
is not completed prior you will be dropped from the class…

“47 72 61 64 20 4F 53 0A”

• Updated Xv6 documentation

• Project 0
• Demo Instructions posted with multiple work arounds to make sure the system gets
installed.