6/8/24, 1:53 PM Exploration: Introduction to Operating Systems: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Introduction to Operating

Systems
Introduction
An Operating System (OS) is a software program that sits between software
applications and the computer hardware. All applications interact with the OS in some fashion.
Relatively few of you are likely to work on the code of an OS itself. However, to be a good
application developer you need to understand the capabilities of the OS and how best to utilize
them to write applications that perform well and are secure.

The OS provides convenient abstractions over the hardware resources, and standard services
that application programmers can use in their programs. In fact, the major focus of this course is
to help you learn these abstractions and services, and how to use them in your programs. Due
to this focus on learning, explaining and programming using these abstractions and services,
courses with similar content use titles like "System Programming," or "Principles of Computer
Systems" or "Introduction to Computer Systems" at some universities.

Goals of an OS
As mentioned above, a major goal of an OS is to provide a convenient software interface to
hardware resources. The OS takes physical resources such as the processor, memory and disk,
and provides software abstractions over these resources. The OS also works to maximize
utilization of the hardware resources and to manage contention of resources among different
users of the OS. OS provides standardized software libraries to allows programs to interact with
the provided abstractions. Additional goals of the OS include providing security and supporting
software development.

OS Services
Standard services provided by OS include:

Process management
An OS is responsible for starting a new program and for ending programs.
OS provides this functionality via the process abstraction, which we can think of as a running
program.

File and input/output management

An OS provides file and directory abstractions, where a file organizes bits into meaningful
structures and directories organize files into meaningful structures.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-introduction-to-operating-systems?module_item_id=24111727 1/3
6/8/24, 1:53 PM Exploration: Introduction to Operating Systems: OPERATING SYSTEMS I (CS_374_400_S2024)

An OS also provides interfaces for reading and writing files, as well as interfaces to
communicate with external devices.

Inter-process communication (IPC)

Process running on the same machine as well those running on different machines
frequently need to communicate with each other. This is called Inter-process communication
or IPC.
OS provides support for IPC via various abstractions including signals, pipes, and network
sockets.

Process coordination
Different processes running an OS may need to access shared resources, e.g., files,
devices, etc. Access to these resources may need to be coordinated and OS provides
support for managing concurrent access to shared resources.

OS Kernel
In addition to providing the services listed above, an OS typically provides additional services for
application developers and users. These can include software to interact with the user, such as
shells and graphical user interfaces, as well as libraries for application developers.

A distinction is generally made between the OS Kernel, and the additional software for user
interaction and application developers that is bundled with an OS but is not part of the kernel.
The kernel is responsible for providing the standard services that we listed above and is the
program that is always running on the computer. The kernel is allocated its own memory space
which is called kernel memory. To keep an OS running even when applications fail or act
maliciously, kernel memory must be protected from direct access by the applications running on
the OS. Access to kernel services and memory is controlled by providing system calls, which
is an application programming interface (API) provided by an OS to applications for interacting
with the kernel.

Interacting with OS
At a higher level, we can consider two different types of interactions with an OS, interaction by
users and interaction by program.

Interaction by Users
There are two primary modes by which users interact with the OS.

Command Line Shells

These require the user to type commands to access OS services. Early OSs only supported
command line shells.

Graphical User Interfaces (GUIs)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-introduction-to-operating-systems?module_item_id=24111727 2/3
6/8/24, 1:53 PM Exploration: Introduction to Operating Systems: OPERATING SYSTEMS I (CS_374_400_S2024)

Learning commands to type at command line shell imposed a high learning curve on the end
user. This prompted the development of GUIs where users can interact with the OS using
graphical elements.

Interaction by Programs
OS exposes its services via system calls which is the programming way a program requests
services from an OS. When writing an application program, you may or may not have direct
access to make the system calls. However, most programming languages provide APIs that
make system calls behind the scenes. We will study system calls and API related to system
calls in great details in the course.

Exercises
Think about all the electronic devices you use on a daily basis.

What OS is running on each of these devices?

What are the different interface you use to interact with each of these OSs?
Do you think the goals of these OSs may differ? If so, in what ways?

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

Timeline of Operating Systems

(https://en.wikipedia.org/wiki/Timeline_of_operating_systems)
Usage share of Operating Systems
(https://en.wikipedia.org/wiki/Usage_share_of_operating_systems)
Graphical User Interfaces (https://en.wikipedia.org/wiki/Graphical_user_interface)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-introduction-to-operating-systems?module_item_id=24111727 3/3
6/8/24, 1:53 PM Exploration: Unix, Linux and POSIX: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Unix, Linux and POSIX

Unix
Unix is almost certainly the most influential OS in history. Furthermore, Unix and its
derivatives are the most used OSs in the world. Let take a brief look at the history of Unix and
its derivatives.

Multics
The roots of Unix are in project called MULTiplexed Information and Computer Services or
Multics which was a new time-sharing OS developed by AT&T Bell Labs, MIT and General
Electric. The Multics project was started in 1964. It was a large project that was beset by delays.

Unix
Some Bell Labs researchers who had been working on Multics decided to implement a new
project around 1970. They named their project Uniplexed Information and Computing Service,
or Unics , as a play on name Multics. The name of the project later became Unix. Key people in
the Unix project included Ken Thompson and Dennis Ritchie, who were both later awarded ACM
(Association of Computing Machinery) Turing Award "for their development of generic operating
systems theory and specifically for the implementation of the UNIX operating system." The
Turning Award is universally considered the highest award in computer science.

C Programming Language
Unix was originally written in the assembly programming language. In 1973, Unix Version 4 was
rewritten in the C programming language, which was also originally developed by Dennis
Ritchie. C and C++, an object-oriented programming language derived from C, are still the most
widely used languages for implementing OS.

Unix Derivatives
Linux
Unix became widely popular starting in late 70s and early 80s. Many commercial software
companies started providing Unix and Unix-like systems. In early 1990s, Linus Torvalds, a
Finnish-American software engineer, developed the initial version of Linux. Linux was a Unix-
like OS, which was open source and also was not beholden to expensive license agreements
with AT&T. Today there are many distributions of Linux. Linux is very widely used for computer
servers and you can also run it at home.

Mobile OS

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-linux-and-posix?module_item_id=24111728 1/2
6/8/24, 1:53 PM Exploration: Unix, Linux and POSIX: OPERATING SYSTEMS I (CS_374_400_S2024)

Linux in-turn has spawned many derivative OSs. One of them is Android, the most popular
mobile OS since 2013. Other derivative OSs of Linux and Android run on smart televisions,
tablets, and wearables. Currently iOS from Apple is the second most popular OS. iOS is derived
from Apple's macOS, which again is derived from Unix!

POSIX
To maintain compatibility between OSs, IEEE Computer Society specified a family of standards
called Portable Operating System Interface or POSIX. POSIX defines standards for software
compatibility across Unix variants as well as other OSs.

Of particular interest to us in this course is the POSIX standard related to system calls. Recall
that system calls are the API provided by an OS that a program uses to request services from
the OS. In addition to system calls, POSIX also includes standards command line shells and OS
utility interfaces.

Exercises

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

Unix (Wikipedia) (https://en.wikipedia.org/wiki/Unix)

Linux (Wikipedia) (https://en.wikipedia.org/wiki/Linux)
Linux Man Pages (http://man7.org/linux/man-pages/index.html)
Android (Wikipedia) (https://en.wikipedia.org/wiki/Android_(operating_system))
POSIX Specification (https://pubs.opengroup.org/onlinepubs/9699919799/)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-linux-and-posix?module_item_id=24111728 2/2
6/8/24, 1:54 PM Exploration: Unix Shell: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Unix Shell

What is the Shell?
The shell is a user-interface to the OS. It is a text-based, command-line interpreter.
The shell provides access to all Unix user-level programs. Using the shell you can, e.g.,

Start programs
Kill programs
Connect processes together (using pipes)
Manage I/O to and from processes
Create, delete and manage files and directories

There are many different shells that are typically installed on Unix/Linux distributions. These
shells (and the standard path to the shell command on most installations), include the following:

Bourne Shell (/bin/sh)

C-Shell (/bin/csh)
BASH "Bourne-again shell" (/usr/local/bin/bash, or /bin/bash)
TCSH enchanced C-Shell (/usr/local/bin/tcsh, or /bin/bash)
Korn Shell (/bin/ksh)

In this class, we will use the BASH shell , which is commonly written as bash.

Common Unix Commands

Let's now look at some common Unix commands related to files and directories.

Accessing Online Reference Manual

man

Unix systems provide access to an online reference manual via the man command. This
command can be used to read the reference manual for shell commands, system calls, and
many functions in the standard C library. To see the detailed description of a command use the
man command with the name of the command. For example, you can view the reference for the
cp command using the following command:

$ man cp

Directory/file management

pwd
Print working directory
Which directory am I in?

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-shell?module_item_id=24111729 1/6
6/8/24, 1:54 PM Exploration: Unix Shell: OPERATING SYSTEMS I (CS_374_400_S2024)

cd
Change directory
Moves your current working directory to a different one
ls
Display the files in a given directory
mkdir
Create directory
rmdir
Remove directory
rm
Remove files (and directories if used recursively)
mv
Move or rename files and directories
cp
Copy files and directories
chmod
Change mode, i.e., change the permissions of files or directories

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-shell?module_item_id=24111729 2/6
6/8/24, 1:54 PM Exploration: Unix Shell: OPERATING SYSTEMS I (CS_374_400_S2024)

  0:00 / 6:16   1x    

File viewing and selecting

cat
Concatenate character data stored in a file with another file
Primary use is to dump data to the terminal
more
Take character data and display one screen-full at a time
less
Similar to more
head
Display the beginning of a text file
tail
Display the (tail) end of a text file
grep
Search a text file

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-shell?module_item_id=24111729 3/6
6/8/24, 1:54 PM Exploration: Unix Shell: OPERATING SYSTEMS I (CS_374_400_S2024)

  0:00 / 4:36   1x    

Shell Scripting
All the commands that are accessible from the shell can be placed in a shell "script." Shell
scripts are executed line by line, as if the lines where being typed in one by one. Shell scripts
provide the features of high-level programming languages, such as, variables, conditional
expressions, loops, etc.

Shell scripts are commonly used to automate frequent tasks and to simplify complex
commands. For example, scripts may be written to run nightly backups of data, or to start up
servers. Sometime scripts are written for small programs that you need to create quickly or you
need to change frequently. Scripts are also used as a glue to connect together other programs.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-shell?module_item_id=24111729 4/6
6/8/24, 1:54 PM Exploration: Unix Shell: OPERATING SYSTEMS I (CS_374_400_S2024)

  0:00 / 1:39   1x    

Exercise
The wccommand prints various counts about data in a text file. Read the man page for wc
(http://man7.org/linux/man-pages/man1/wc.1.html) for details. What options you can use with wc
to print the longest line in the text file wc_test.txt
(https://canvas.oregonstate.edu/courses/1971495/files/103693470/download) .

Answer

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

List of Unix commands (https://en.wikipedia.org/wiki/List_of_Unix_commands)

Bash scripting cheat sheet (https://devhints.io/bash)
Linux man pages online (http://man7.org/linux/man-pages/index.html)
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-shell?module_item_id=24111729 5/6
6/8/24, 1:54 PM Exploration: Unix Shell: OPERATING SYSTEMS I (CS_374_400_S2024)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-unix-shell?module_item_id=24111729 6/6
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: System Calls, and Reading

and Writing Files in C
Introduction
In the previous exploration we studied the Unix shell which is an interactive user
interface to use services provided by the OS. We will now look at System Calls which provides a
programmatic way of using services provided by the OS. We will also begin our learning of the
C programming language and how we can use C to programmatically accesses OS services.

System Calls
System calls are the mechanism by which a user program asks the OS to perform services for
it. In fact, the shell commands also make system calls to invoke OS services. One popular
categorization of system calls into 6 categories is as follows:

Process control
create process
terminate process
load, execute
get/set process attributes
wait for time, wait event, signal event
allocate and free memory

File management
create file, delete file
open, close
read, write, reposition
get/set file attributes

Device management
request device, release device
read, write, reposition
get/set device attributes
logically attach or detach devices

Information maintenance
get/set time or date
get/set system data

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 1/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

get/set process, file, or device attributes

Communication
create, delete communication connection
send, receive messages
transfer status information
attach or detach remote devices

Protection
get/set file permissions

"Hello World" in C
By convention, the first program when you are learning a language is the "Hello World" program.
Here is a "Hello World" program in C.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 2/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

In C, as in many other languages, the main() function is special: when you run a C program the
main() function is where the program execution starts. Functions have a return type, in this
case int , and may take arguments. In the case of our program, the function returns an int
and doesn't take any arguments.

The body of the function is wrapped in curly braces and in this example has just 2 lines. The first
line prints "Hello, world!" to the terminal when you run the program. The second line returns the
integer 0. The first line of the program has an include statement to include stdio.h , the header
for the standard C library for input and output.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 3/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

"Hello World" using a System Call

In the "Hello World" example we just studied, our program calls the function printf() to write
data to the terminal. In Unix, the terminal is modeled as a file (we will study the details later), so
in effect printf() is writing to a file. Behind the scene, printf() uses the system call write()
to write to the file. In our C program, instead of calling printf() , we can directly call write() as
in the following program

1_4_hello_world_put @cs344

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 4/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

Note: In this exploration, we are not going to look into the details of the write() system
call. However, over the next few explorations we will have learned every concept employed
in this program.

System Calls for File Management in C

As mentioned before, system calls are programmatic interfaces that an OS provides to access
various services. As way of an example, let us look at a few system calls related to files.

In Unix, files are simply a linear array of bytes. Let us now see how we can carry out basic
operations related to file managing, such as creating a file, reading from a file, writing to a file.

Note: At this point in the course, we are not going to look into the details of the following
program. However, over the next few explorations we will have learned every concept
employed in this program.

Creating a File
We can create a file by using the open system call and passing it the O_CREAT flag. In this
program, we are also passing the flag O_TRUNC which will truncate the file if it already exists. If
you run the following program, it will create a file named grades.txt . You can use the ls

command from the shell to confirm that the program created the file.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 5/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

1_4_createfile.c @cs344

Reading a File and Writing to a File

The open system call has a wider use than just creating a file. With open system call we can
also open existing files for a variety of purposes, e.g., reading only, writing only, or for both
reading and writing. To write to a file, we can use the write system call, while the read system
call can be used to read from a file. The following program:

Uses the open system call to create a new file named "newFile.txt" or if should a file exists,
truncates it and opens it, then
Uses the write system call to write the text "THE BUSINESS" to this a file, then
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 6/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

Uses the read system call to read the contents of this file and prints them to the terminal.

Exercise
Study the man page for the open system call (http://man7.org/linux/man-
pages/man2/open.2.html) and modify the flags passed to open in the above program so that if a
file already exists, open does not overwrite the contents of the file. Click the answer button for
solution.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 7/8
6/8/24, 1:54 PM Exploration: System Calls, and Reading and Writing Files in C: OPERATING SYSTEMS I (CS_374_400_S2024)

Answer

System Calls & Library Functions

As we saw in the previous examples when we are writing programs in C, many times our
programs do not directly invoke system calls. Instead, our program may invoke a C library
function, such as printf() , that in turn invokes a system call, such as write() , behind the
scenes. As another example, the C standard library provides the function fopen() to open a file.
Internally, fopen() uses the open() system call to open a file. It is typically easier to code using
the C library functions than coding using the underlying system calls.

The GNU C Library (glibc)

ANSI is an organization that defines standards. The ANSI C standard specifies a standard
library for implementations of the C programming language. Different implementations of Unix
have different implementations of the standard C library. The most common of these on Linux is
the GNU C library, commonly called glibc. In this course, we will use glibc.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

The categorization of system calls given above is from Operating System Concepts, by
Abraham Silberschatz, Greg Gagne, and Peter B Galvin, 2018
Chapter 4 of The Linux Programming Interface has a detailed discussion on file I/O in Linux.
We are going to study files in more detail in subsequent modules.
The Linux man-pages project (https://www.kernel.org/doc/man-pages/) provides
extensive documentation on Linux system calls and the C standard library. This
documentation is an essential reference for you to use during this course.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-system-calls-and-reading-and-writing-files-in-c?module_item_id=24111730 8/8
6/8/24, 1:54 PM Exploration: Variables & Data Types, Input & Output in C: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Variables & Data Types, Input

& Output in C
Introduction
Let us start with a simple C program that asks the user for two integers and then
prints all the multiples of the first integer between 1 and the second integer. We will start writing
the program in this exploration and finish it in a later exploration.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-variables-and-data-types-input-and-output-in-c?module_item_id=24111731 1/5
6/8/24, 1:54 PM Exploration: Variables & Data Types, Input & Output in C: OPERATING SYSTEMS I (CS_374_400_S2024)

1_5_multiples @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@xx
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td88@8@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI��`@H���@H��`@�V �D��f.�@�8`H=8`t�H��t
�8`��f��Df.��8`H��8`H��H��H��?H
�H��t�H��t�8`���Df.��=
uUH���~�����
9
]�D�Df.���f.�@UH��H��
�E�H�t@������H��@H�u��E�������H��@�E�������H��@H�u��E��������u��U�H�@
�E���r���1҉E���H�� ]�DAWAVI��AUATL�%� UH�-� SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter a positive
integer whose multiples you want printed: %dEnter another positive
integer up to which you want to see multiples printed: You entered %d
for denominator and %d for boundary
10
;
<����8���Xh����(���������(���(

zR
x
�
����+
zR
x
�
����$0h���0FJ
w�?;*3$"X`����A�C
11 �Dx����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
12 d@�
13 `�
14 `���ox@@�@
15 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 8.4.0-
1ubuntu1~18.04) 8.4.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@@�@�@�@

Main entry point

As we mentioned in the previous exploration, execution begins with the body of the main
function. In our program, the function main is defined such that it doesn’t take any arguments
and returns an int . When the program is run, it returns the value 0 to the OS. On most OS a
return value of 0 indicates that the program executed successfully, while a non-zero value
indicates an error.

Variables & Data Types

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-variables-and-data-types-input-and-output-in-c?module_item_id=24111731 2/5
6/8/24, 1:54 PM Exploration: Variables & Data Types, Input & Output in C: OPERATING SYSTEMS I (CS_374_400_S2024)

In our program, we declare 2 variables

int denominator;
int boundary;

In C, the data type of each variable must be explicitly declared at compile-time. This is in
contrast with other languages such as Python, where the type of a variable does not need to be
explicitly specified and can be inferred at run-time.

A variable of type int can only store an integer value. In addition to int , historically C has
provided three additional basic data types. These are as follows:

float : can be used to store floating-point numbers, i.e., numbers containing decimal points
double : similar to float, it can be used to store floating-point numbers, but it has double the
precision of float
char : can be used to store a single character. The character value is specified within single
quotes. E.g., 'A' or '1' or ','

Note that string is not supported as a basic type in C!

#include directive
In our program, we call two functions multiple times. These functions are printf() and
scanf() . But these functions are not defined in our program. In C we can use functions defined
elsewhere by including the header files that contain the descriptions of these functions. This is
being done in the following line of code where we are including the header file stdio.h

#include stdio.h

As our C program is transformed into an executable program, the contents of this header file are
copied into our program. Header files typically contain description of functions and definition of
variables.

Output using printf()

The header file stdio.h contains the description of many functions related to input and output.
Let us first look at printf() . We used in three times in our program:

printf("Enter a positive integer whose multiples you want printed: ");

printf("Enter another positive integer up to which you want to see multiples printed: ");

printf("You entered %d for denominator and %d for boundary\n", denominator, boundary);

The first two calls are very similar. The function is being called with one argument, which is a
string. As we had learned C doesn’t support strings as a basic data type. We are going to look at
strings in greater detail later, but here is a quick introduction.

A string in C is an array of characters which is terminated by the null character. The null
character is represented by escape sequence \0 . Unlike a single character, a string is

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-variables-and-data-types-input-and-output-in-c?module_item_id=24111731 3/5
6/8/24, 1:54 PM Exploration: Variables & Data Types, Input & Output in C: OPERATING SYSTEMS I (CS_374_400_S2024)

enclosed in double quotes. Thus, the following two variables have different values and data
types:

char oneChar = 'A';

char stringWithCharA[] = "A";

The data type of the variable oneChar is character, whereas the data type of the variable
stringWithCharA is an array of characters. The [] at the end of stringWithCharA indicate that it
is an array. The number of characters in stringWithOneChar is 2, the first character is A and the
second character is the null character '\0' which terminates the string and is automatically
added when we enclose the characters in double quotes to create a string.

The 3rd call is a little different.

printf("You entered %d for denominator and %d for boundary\n", denominator, boundary);

Here printf() is called with three parameters. The first parameter is a string (or equivalently an
array of characters), while the other two parameters are integer values. The string provided as
the first parameter to printf() contains two occurrences of %d . printf() interprets each
occurrence of %d as saying that a corresponding integer value will be provided as an additional
argument to printf() . The d in %d stands for decimal. printf() replaces the first %d with the
value of the variable denomiator and the second %d with the value of the variable boundary . To
print variables of some other common types using printf() , you can use the following
characters after % (for a complete list see the man pages (https://man7.org/linux/man-
pages/man3/printf.3.html) for printf() )

printf() paramaters

Parameter Data Type

%d or %i Decimal Integer
%x Hexadecimal integer
%f Floating-point number
%c ASCII character

Exercise
Run the program and input a number greater than 15 when asked for the second integer.
Observe the output. Now change %d to %x in the 3rd statement that uses printf() and run
the program again by entering the same numbers as the previous numbers. Observe the output
and explain the reason for any differences in the output after the change .

Answer

Input using scanf()

We used scanf() two times in our program to get an integer value from the user

scanf("%d", &denominator);

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-variables-and-data-types-input-and-output-in-c?module_item_id=24111731 4/5
6/8/24, 1:54 PM Exploration: Variables & Data Types, Input & Output in C: OPERATING SYSTEMS I (CS_374_400_S2024)

scanf("%d", &boundary);

The first argument to scanf() is a string that contains formatting instructions to read input. Just
as %d in printf() means print a decimal integer, %d in scanf() means read a decimal
integer. The second argument to scanf() contains the name of the variable to which scanf()
assigns the value of the integer it read in (for now ignore the &, we will discuss it later).

In our example, the first call to scanf() assigns the integer value entered by the user to the
variable denominator . The second call to scanf() assigns the second value entered by the user
to the variable boundary .

The formatting characters available for use in scanf() are similar to the characters available in
printf() . A few of these are listed below. For a complete list see the man pages

(https://man7.org/linux/man-pages/man3/scanf.3.html) for scanf() .

scanf() parameters

Parameter Data Type

%d Decimal Integer
If the number starts with 0 interpret it as
Octal, if it starts with 0x interpret it as Hexa-
%i
decimal, otherwise interpret it as decimal
integer
%x Hexadecimal integer
%f Floating-point number
%c ASCII character

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

C Programming Crash Course (https://media.oregonstate.edu/media/t/1_gkq6zhjw) An

instructional Youtube video introducing C
For a discussion of scanf() see Chapter 14.2 of Modern C.
Jens Gustedt. Modern C. Manning, 2019.
C for Python Programmers
(http://www.cs.toronto.edu/~patitsas/cs190/c_for_python.html)
Carl Burch. C for Python Programmers. Hendrix College, 2011.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-variables-and-data-types-input-and-output-in-c?module_item_id=24111731 5/5
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: From C Programs to Machine

Code
Introduction
If your previous programming experience has been with a language like Python, you
may have noticed a difference in how you execute your Python programs vs. your C programs.
C is a compiled language. What that means is that before a C program can be executed it must
be first transformed into machine code where machine code is simply the binary version of
assembly instructions. This process of transforming a C program into machine code can be
broken into a few steps, so let’s look at those steps.

  0:00 / 11:05   1x    

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 1/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

Pre-processing
The C pre-processor is responsible for analyzing and processing some special statements that
are identified with a #. We have already seen one example of such statements, namely, the
#include directive which is used to include header files in a program. Header files typically
contain the description of functions and variables needed by the program.

Another type of special statement that is processed by the C pre-processor is called a macro.
Macros are defined with #define . Here is an example:

#define PI 3.14

If a program includes the above macro, the C pre-processor will replace all instances of PI in
the program with the value 3.14. A common use of macros is to define a symbolic constant once
and use them in multiple places in the program. Note that there is no semi-colon at the end of
the #define directive.

Additional directives that the pre-processor is responsible for are #ifdef , #endif , #else , and
#ifndef which are used for conditional compilation. You can find details of that in the

references provided in Additional Resources.

Compilation
The C compiler is responsible for parsing your code, checking it for errors and generating
assembly language code. The compiler then calls the assembler which converts the assembly
code into machine binary code. A file with machine binary code is commonly referred to as an
object file and has the extension .o .

We will use the gcc compiler in this course. gcc provides many compilation options, some of the
mostly useful ones are listed below

-g Compile with debugging info for GDB

-c Compiles only, without linking
-S Generates assembly code
-O3 Optimizes as much as possible
-o Specifies the name of the output file
-Wall Turns on all warnings
-llibrary Adds support for library when linking (for example, -lpthread, more later)
-std=c99 Use C99 standard
-std=gnu99 Use C99 standard with GNU extensions

Compiler Warnings
If the compiler finds an error in your program the compilation will fail. E.g., if you misspell the
name of the function main to mian compilation will fail and the compiler will report an error.

In addition to errors, the compiler can also report warnings which are diagnostic messages
indicating possible problems with your program. By default warnings do not cause compilation
to fail and your program may even run correctly in the presence of warnings. However, warnings
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 2/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

indicate possible issues with your program that can cause program execution to fail or have
unspecified behavior.

Example

In the following program change %d to %f in line 20. If you now press "Run" you will see a
warning but the program will successfully compile. However, when you run the program the
behavior is incorrect.

2_1_multiplier.c @cs344

Show files Open on Replit

Options Related to Warnings

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 3/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

gcc supports many options related to warnings. The most commonly used of these is -Wall

which despite its name does not cover all possible warnings! You can find more information in
the GCC manual's section on Warning Options. (https://gcc.gnu.org/onlinedocs/gcc-
4.8.5/gcc/Warning-Options.html)

Tip: Always review and fix all warnings reported by the compiler.

Linking

Virtually all C programs depend on multiple files. As an example, even a simple hello_world.c
program that prints a Hello World message to the screen needs to include stdio.h in order to
use the printf function. stdio.h includes the description of printf , but does not include its
code. Linker or link editor is the part of the compilation chain that stitches or links together the
various object files with each other and creates one executable file.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 4/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

  0:00 / 4:43   1x    

In addition to linking object files, the linker will also link library archives which are collections of
object files (.o) gathered into a single large file. Library archive files have indexes that make
accessing them fast and usually a lot faster than having to read every .o file. This is especially
useful when the object files in the library seldom change. The standard C library libc contains
the object code for standard C functions, such as printf and is automatically linked in by gcc
without you needing to specify it with the gcc command.

repl.it & the clang compiler

We will extensively use repl.it (https://repl.it/) in this course. repl.it is a free online service that
allows you to write, compile and run programs in various languages using your browser. A code
example in repl.it is called a repl. The explorations have many embedded repls for code
examples and exercise. You are strongly encouraged to experiment with these examples and do
all the exercises. You do not need to create a repl.it account in order to do that.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 5/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

When you click the "Run" icon on a repl, the program is compiled and executed. For a C repl,
the following commands are run by default:

clang-7 -pthread -lm -o main main.c

./main

As you can see, repl.it uses the clang compiler to compile the file main.c to an executable file
named main and then runs this executable. For course assignments you are required to use the
gcc compiler on os1. Should you optionally want to use the gcc compiler with a repl, here are 2
ways to do this

1. Run the gcc command from the command line.

When you click the "Run" icon, a command line shell is opened to execute the default
commands shown above.
You can run gcc from this command line.
2. Create a .replit file and put the gcc command in that file
If a .replit file exists in a repl, when you click the "Run" icon the commands in this file
are executed instead of the default commands shown above.
Example: The following repl includes a .replit file which
Runs the gcc compiler with the C99 standard and -Wall option and creates an
executable file named multiplier , and then
Runs the command ./multiplier to run the executable file multiplier from the
current directory

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 6/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

1_6_multiplier_replit.c @cs344

Show files Open on Replit

Tip: To view a list of all the files in a repl, click the Files icon on the left side.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

Discussion of Macros (https://gcc.gnu.org/onlinedocs/cpp/Macros.html)

Standard Library libc on Linux (http://man7.org/linux/man-pages/man7/libc.7.html)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 7/8
6/8/24, 1:54 PM Exploration: From C Programs to Machine Code: OPERATING SYSTEMS I (CS_374_400_S2024)

Manual (https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/) for GCC Version 4.8.5 (version

currently installed on os1)
GCC Warning Options (https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Warning-
Options.html)
User manual for Clang Compiler (https://clang.llvm.org/docs/UsersManual.html)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-from-c-programs-to-machine-code?module_item_id=24111732 8/8
6/8/24, 1:54 PM Exploration: Getting in the Mindset of a C Programmer: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Getting in the Mindset of a C

Programmer
C is the standard language for operating systems and systems programming. Programming in C
is very different from other languages, like python or C++. Whereas python and C++ have
thousands of individual library functions and extensive language documentation, a motivated
student could read through the majority of the C standard in an hour or two.

Take some time to read through the C Language (https://en.cppreference.com/w/c/language)

documentation to understand the syntax, operators, preprocessor directives, etc. The
preprocessor macros can be a bit confusing, so don't worry if that part is over your head for now.
You may also notice that some things have (C99) or (C11) after them. This denotes which
standard they first appeared in, as the language evolved. We are using the C99 standard in this
course, so some of the features that C11, C17 and C23 added are irrelevant to us and you can
skip these parts. This decision is not arbitrary -- C99 is the standard used for the vast majority of
operating system source code and systems programming, and the additions of the subsequent
standards are fairly minor.

Next, look over the methods available for File input/output (https://en.cppreference.com/w/c/io)
and for manipulating Null-terminated byte strings (https://en.cppreference.com/w/c/string/byte)
. Reading and writing to files and string manipulation are two fundamental skills for C
programming, and a significant amount of your assignments' code will be devoted to these tasks.
You don't need to memorize all of this, but you should have a general idea of what kinds of
functionality the standard library provides to you, and where you could find the information to
actually use these functions.

You should constantly refer to documentation to ensure you are properly calling the functions,
checking return values and handling errors.

Another major difference between C and other languages is that safe C programming requires a
lot of explicit error/return value checking and careful memory management. Programs should be
broken down into very small functions, each with clearly defined arguments, return values, and
effects they might have on program state (such as modifying global variables). A general rule of
thumb is that an individual function should be short enough to fit in a terminal window.

Throughout this course, the content will highlight useful functions and commands, and you should
regularly refer to the manual pages for each one to understand how to use them properly.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-getting-in-the-mindset-of-a-c-programmer?module_item_id=24111733 1/1
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Conditionals, Loops and

Variable Scope
Making Decisions Using Conditionals
C supports various ways to make decisions using conditionals.

if statements
C’s if statements very similar to if statements in other programming languages. Note the
parentheses around the Boolean expression and the use of braces for the code blocks. We
have the basic if statement which will execute if the provided expression evaluates to true.
We can also have the familiar if-then-else statement, were we have add additional else if
branches with expressions and optionally an else branch without an expression which will be
executed if none of the expressions provided to the other branches evaluate to true

if (expr) {
//...
} else if (expr2) {
// ...
} else {
// ...
}

The parentheses around the Boolean expression are mandatory. But if a code block contains
only one statement, we can omit the braces.

switch statements
In many programs, we end up using an if-then-else statement that compares the same variable
to different values.

Example: Consider the following program in which an integer value entered by the user is
compared to many different values:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 1/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

e2_2_if_then_else.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@X X
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td@@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI��0@H���@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��0�E�H�D@������H��@H�u��E�������H��@�E����
����}�
�E��H��@�������E����}��H��@��c����E����}��H��@��@����E����}
��H��@������E��d�}��H�
@�������E��<�}��H�
11 @�������E��H�@�������E������1�H��0]�f.�AWAVI��AUATL�% UH�-
SA��I��L)�H��H���/���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Hi! What is your
favorite day of the week? Enter it as an integer with Sunday as 1,
Monday as 2, ... and Saturday as 7
12 %dYour favorite day of the week is:
SundayMondayTuedayWednesdayThursdayFridaySaturday
;8$����T���T�����D���
���������$

zR
x
�
����+
zR
x
�
����$0����0FJ w�?;*3$"X����V
A�
C
13 Q
Dx����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
14 4@�
15 `�
16 `���ox@@�@
17 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-

Such if-then-else statements are frequent enough that C provides a switch statement
construct to code them. Here is the same program using the switch statement:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 2/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

e2_2_switch.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@� �
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td@@@@@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI�� @H���@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��P�E��h@��1����ȈM��������@��H�u��M��E������
����@�‫׊‬M��E���������U�����փ��E�H�u��U���H�E�H��8@��H�@��f����E���H�
11 @��M����E��xH�@��4����E��_H�@������E��FH�%@������E��-H�.@�������E��H�5
@�������E�H��@������1ɉE���H��P]�f.�DAWAVI��AUATL�%. UH�-.
SA��I��L)�H��H���?���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
�@�@ @$@=@V@Hi!
What is your favorite day of the week? Enter it as an integer with
Sunday as 1, Monday as 2, ... and Saturday as 7
12 %dYour favorite day of the week is:
SundayMondayTuedayWednesdayThursdayFridaySaturday
;<����0���X`����
����p��������(

zR
x
�
����+
zR
x
�
����$0`���0FJ w�?;*3$"XX���A

A�C
13 <
Dx����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
14 $@�
15 `�
16 `���ox@@�@
17 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-

Note that the expression is evaluated once. Then the matching case branch is executed. The
code to be executed for the branch ends with a break statement. If none of the case branches
match, the default branch will be executed.

Conditional operator
A conditional operator is a very succinct way of coding a simple decision. The general format of
the conditional operator is as follows:

condition ? expression1 : expression2

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 3/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

In this case, the condition will be evaluated. If the condition is true, then expression1 is
evaluated and its value is returned. Otherwise, expression2 is evaluated and its value is
returned. A common usage of the conditional operator is to set the value of a variable to one of
two expressions based on a condition.

e2_2_conditionalop.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@88
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H�� @H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��0�E�H��@������H��@H�u��E�������H��@�E����
���H��@H�u��E��������M�;M��E�� �E��E���E��E‫܋‬E‫܉‬E��u��U��M�H��@��L���1ɉE؉
�H��0]�f.�DAWAVI��AUATL�%� UH�-� SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter an integer:
%dEnter a different integer: %d is the bigger of %d and %d
11
;
<H����x���X�����h����(��������(

zR
x
�
���+
zR
x
�
���$0����0FJ
w�?;*3$"X�����A�C
12 �Dx@���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�h���P@ @



* @
13 �@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@@�@�@�@
�@

Loops
Looping with for

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 4/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

We now complete the program from a previous exploration that asks the user for two integers
and then prints multiples of the first integer between 1 and the the second integer. To do this we
will use the for loop.

2_1_multiplier.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H��P@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��0�E�H��@������H�@H�u��E�������H�@�E�����
��H�@H�u��E��������u��U�H�b@�E���r����E�
�E‫܋‬E�;E��:�E���}
�����u�H��@��8����E���E���
�E������H��@�����1ɉEԉ�H��0]�@AWAVI��AUATL�%
� UH�-� SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter a positive
integer whose multiples you want printed: %dEnter another positive
integer up to which you want to see multiples printed: Here are all the
multiples of %d between 1 & %d
11 %d
;<���������X��������������(���(

zR
x
�
x���+
zR
x
�
|
���$0���0FJ w�?;*3$"X����A�C
12 �Dx����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
13 �@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git

The for statement has the following general form:

for(initialization statement; loop condition; repeating statement){

Statement or statements to execute
}

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 5/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

The initialization statement is executed once. The loop condition is evaluated for each execution
of the loop, including the first execution. If the condition evaluates to true, the body of the for
loop is executed. After the body has been executed, the repeating statement is executed. Next
the loop condition is evaluated again. The for loop continues until the loop condition evaluates to
false.

Here is the code for the for loop in our program

for(int i = 1; i <= boundary; i++){

if(i % denominator == 0){
printf("%d ", i);
}
}

In this example, the initialization statement sets the value of the variable i to 1. The loop
condition checks the value of i with the variable boundary . As long as i is less than or equal
to the value of boundary , the loop will continue to execute. After the body of the for loop is
executed, the repeating statement is executed which increments i by 1. Therefore, this for
loop will execute the same number of times as the value of boundary .

Note: In the above example of for loop, the variable i is declared in the initialization
statement. Allowing variables to be declared within the loop's initialization statement is an
enhancement added by C99 standard. When compiling the code with gcc, make user to
use C99 or GNU99 standard by using the flag -std=gnu99 or -std=c99 .

Looping with while

The while statement in C is pretty similar to the while statement you have likely encountered
in other languages. The basic syntax is:

while(expr) {
Statement or statements to execute
}

The expression expr is evaluated. If it evaluates to true then the body of the while loop is
executed; otherwise the loop ends. The while loop will keep executing the body as long as
expr evaluates to true. If the body of the while loop has only one statement, braces aren’t
required.

Exercise
Modify the program shown below to use while loop instead of the for loop.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 6/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

2_1_multiplier.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H��P@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��0�E�H��@������H�@H�u��E�������H�@�E�����
��H�@H�u��E��������u��U�H�b@�E���r����E�
�E‫܋‬E�;E��:�E���}
�����u�H��@��8����E���E���
�E������H��@�����1ɉEԉ�H��0]�@AWAVI��AUATL�%
� UH�-� SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter a positive
integer whose multiples you want printed: %dEnter another positive
integer up to which you want to see multiples printed: Here are all the
multiples of %d between 1 & %d
11 %d
;<���������X��������������(���(

zR
x
�
x���+
zR
x
�
|
���$0���0FJ w�?;*3$"X����A�C
12 �Dx����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
13 �@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
View the Solution (https://repl.it/@cs344/22whileanswerc#main.c)

Looping with do
The do statement is similar to the while statement with one crucial difference: the expression
is evaluated after the body has been executed. The basic syntax is:

do {
statement or statements to execute
} while(expr)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 7/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

This means that a do loop will execute at least once. This will happen even if expr is false
when the do loop is to be executed the first time.

Breaking Out of a Loop Using Break

Let’s modify our example program to print at most 5 multipliers of the number entered by the
user. Here is one way we can get this behavior.

2_2_multiplier5.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H��p@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��@�E��E��E�H��@������H�0@H�u��E�������H�3
@�E�������H�0@H�u��Eܰ������u��U�H��@�E‫�ذ‬d����E�
�EԋE�;E��O�E���}
����,�E�;E��
�u�H��@������u���
�u��E���E���
�E������H��@������1ɉẺ�H��@]ÐAWAVI��AUATL�
%n UH�-n SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter a positive
integer whose multiples you want printed: %dEnter another positive
integer up to which you want to see multiples printed: Here are all the
multiples of %d between 1 & %d
11 %d
;
<���������X���������������(���(

zR
x
�
X���+
zR
x
�
\���$0����0FJ
 w�?;*3$"X����
A�C
12 
13
Dx����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
14 �@�
15 `�
16 `���ox@@�@
17 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-

In this program, the for loop can continue to execute even when we have printed 5 multiplier.
The break statement provides us a way to break out a loop as soon as we want rather than

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 8/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

waiting for the loop’s condition to become false.

In the following program, we modify the previous program to use the break statement to break
out of the for loop as soon as the desired number of multipliers have been printed.

2_2_mult_break.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@ 
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI��@H���@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����

This program will break out of the for loop as soon as the desired number of multipliers has
been printed.

Skipping to the Next Iteration of a Loop Using Continue

The continue statement causes a loop to skip ahead to the next execution without breaking out
of the loop. Any statements in the body of the loop that come after the continue statement will
be skipped. This statement is used when you want to skip some statements in the body of the
loop when a certain condition holds.

Scope of a Variable: Local vs. Global

The scope of a variable in C determines where the variable is accessible. A local variable is
accessible only within the region it is defined, whereas a global variable is accessible
everywhere in the program. Let’s look at an example program to understand this concept:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 9/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

2_2_scope.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�tdhh@h@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H��p@H�Ǡ@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����

Two variables are defined in this program. The variable numerator is defined within the function
main and is termed a local variable. This means that numerator can only be used inside main.
In general, a local variable is local to the block, defined by { } , in which it is defined. E.g., in
the following example, the variable k is local to the for loop and cannot be accessed anywhere
else even in the function in which this for loop is used:

for(int k = 1; k < 10; k++){

statements
}

The variable denominator is defined outside any function. Such a variable is called a global
variable. A global variable can be used anywhere in the program. In this program, we see it is
being used in both of the functions main and isDivisible .

Static Variables
Static variables in C are initialized just once. These variables remain in memory until the end of
the program. If a static variable is defined inside a function, it retains its value across multiple
invocations of the function, as in the following example:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 10/11
6/8/24, 1:55 PM Exploration: Conditionals, Loops and Variable Scope: OPERATING SYSTEMS I (CS_374_400_S2024)

2_2_static.c @cs344

Show files Open on Replit

main

1 ELF

>
@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `DH ``�
�
TT@T@ P�td((@(@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI���@H���@H��`@�� �D��f.�@U�8`H=8`H��t�H��t
8 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=}
uUH���~����k

]�D��@f.�UH��]��f�UH��H���E�
�E���
�E��u�H�@�������4%0`��
�4%0`�4%

A static variable is declared as follows:

static data_type variableName;

where data_type is the type of the variable, e.g., int , char , float , etc.

Exercise
Write a program that prompts the user for an integer between 1 and 20 and then prints the
factorial of that integer.

View the Solution (https://repl.it/@cs344/2factorialc#main.c)

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

C for Python Programmers

(http://www.cs.toronto.edu/~patitsas/cs190/c_for_python.html)
Carl Burch. C for Python Programmers. Hendrix College, 2011.
The C Book (https://archive.org/details/TheCBook/mode/2up) – somewhat old, somewhat
dated, but free
Mike Banahan, Declan Brady, and Mark Doran. The C Book, 1991.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-conditionals-loops-and-variable-scope?module_item_id=24111737 11/11
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Arrays & Structures

Introduction
Arrays allow us to store a group of elements of the same data type together in
memory while structures allow us to group elements of different type.

Arrays
We can define arrays of any of the basic data types (in addition to other user defined types as
we will see later). You can declare an array by specifying the name of the array, the data type of
its elements and the number of elements the array can store. Let’s look at a program that uses
an array of integers

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 1/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

2_3_int_array.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@pp
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td44@4@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H��p@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10

]�D��@f.�UH��]��f�UH��H��@�E��E��E���H��H�U�H��H���H��H)�H��H�M��E
�H�u؋E�;E��HH��@������Hc}�H��H�M�H
�H�@H�ΉE԰�w����EЋE���
�E������H�
11 @��E����E��E̋E�;E��-HcE�H�M4؋�H�.@������EȋE���
�E�������E�H�E�H�ċE�H��]�
f.�f�AWAVI��AUATL�%n UH�-n SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter an integer:
%dYou entered the following numbers: %d

;8����<���Tl����,����<��������$

zR
x
�
����+
zR
x
�
����$0p���0F
J w�?;*3$"Xh���
A�C
12 �DxX���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�����P@ @



* @
13 �@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@@�@�@�@
�@

In this program, we have declared an array of size 5. Note that individual elements of an array
are read and written to just like an ordinary variable of that type. Elements in the array are
referenced via a 0-based index whose value goes up to the size of the array minus 1. In our
example, the element index goes from 0 to 4 as shown in the following figure.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 2/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

The elements of an array are allocated together in memory:The index of the first element
in the array is 0.

Strings - arrays of characters

In C, a string is an array of characters terminated with the special null character \0. Let us look
at an example:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 3/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

2_3_string.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI��@@H���@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10
]�D��@f.�UH��]��f�UH��H��
�%T@�E�H�X@������H�u�H��@�E�������H�U�H�u�H��@�E�������1ɉE���H��
]�f.�f�AWAVI��AUATL�% UH�- SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Hi!Enter the 2-
letter code for the state you live in: %s%s you live in %s
11
;8���������T����������,��������$

zR
x
�
p���+
zR
x
�
t���$0���0F
J w�?;*3$"X����dA�C
12 _DxH���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�p���P@ @



* @
13 D@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@@�@�@�@
�@
17 @ @@p@
18 D@P@�@�@�

In the program we declare two arrays of characters. Let’s first look at the array of characters
named message . We didn’t specify the size of the array. However, we initialize this array to the
string "Hi!" which is 4 characters long as shown in the table below.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 4/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

A string is terminated with a null character: You must make sure that the array is large
enough to hold the null character in addition to the other characters in the string.

Instead of using

char message[] = {"Hi!"};

we could equivalently have explicitly written the size of the array as follows:

char message[4] = {"Hi!"};

Yet another way of declaring an equivalent array would be to individually specify the characters
as follows:

char message[] = {'H', 'i', '!', '\0'};

In our program, we also have a character array named state of size 3. We use this array to
store the input entered by the user.

scanf("%s", state);

As we see in this program, both printf and scanf work with strings. The format character
used for strings is %s . scanf will read the user input until whitespace is encountered and store
the value in state terminating the value with a null character. Note that we didn’t write an &
before state . We will look at the reason for this in the next exploration. A second thing to keep
in mind is that the size of name entered by the user must not be larger than the size of the array
state .

Passing Arguments from the Command Line

All the programs we have written so far were executed by running the command

./main

If the program required input from the user, we used scanf to get that input. However, it is also
possible to pass arguments to our C program from the command line. To do this, we use a

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 5/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

version of main() that takes two arguments as follows

int main(int argc, const char * argv[])

When a program with this version of main is executed, the integer argument argc is set to the
number of space delimited strings entered on the command line and the array argument
argv holds each of the strings entered on the command line. For example, if the program is

executed as follows:

./main

then argc will be1 and the array argv will have one element with the value "./main"

As another example, if we run a program as follows:

./main file.txt 8

then argc will be 3 and the array argv will have 3 string elements with the values "./main",
"file.txt" and "8"

The C standard library provides a function atoi (https://man7.org/linux/man-

pages/man3/atoi.3.html) (ASCII to integer) that takes a string argument, interprets its contents as
an integer, parses it and returns an int value. We can use this function to convert an integer
argument passed from a command line from the string representation in argv to an integer
variable in our program.

Example
The following program is a variation of the factorial program from the previous exploration. This
program must be called with an integer value and it will compute and print the factorial of this
integer value.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 6/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

2_factorial_args.c @cs344

Show files Open on Replit

main

1 ELF

>
@@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�tdpp@p@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4@
;libm.so.6__gmon_start__libpthread.so.0libc.so.6printfatoi__libc_start_m
ainGLIBC_2.2.5

*ui R�`�``
`H��H�� H��t��H����5� �%� @�%�
h������%� h
�����1�I��^H��H���PTI���@H��P@H�ǀ@��
�D��f.�@U�8`H=8`H��t�H��t
8 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=A
uUH���~����/
]�D��@f.�UH��]��f�UH���}
�H�E�
�E�
�E�;E��HcE�H�E�H�E��E���
�E������H�E�]�f.�UH��H��0�E��}
�H�u��}��4H��@��o���H�@�E���[����E�
�E��sH�E�H�x�O����E��}�
�
9 �}�� H�@������E�
�E��/�u��}��u��
10 ���H�R@�u�H�°������E��E؋E�H��0]�AWAVI��AUATL�%� UH�-�
SA��I��L)�H��H���w���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Please specify an
integer value between 1 and 20
11 Usage: ./main intVal
12 The number you entered is outside the allowed values
13 The factorial of %d is %ld
14
;D���������`�����������������
P���P

zR
x
�
h���+
zR
x
�
l���$0���
�0FJ w�?;*3$"X����CA�C
15 ~x ����A�C
16 �D�����eB�B�E �B(�H0�H8�M@r8A0A(B BBB����� @�@



*�@
17 �@�
18 `�
19 `���ox@@�@
20 ^ `0�@�@0 ���ox@���o
���on@`&@6@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-

To run this program, on the command line specify an integer value between 1 and 20 after the
command for the program. For example,

./main 10

Structures
Structures provide a way to group members together which can have different data types.
Structures in C are somewhat like a class in Java or C# but without the methods. We refer to the

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 7/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

members (or elements) of a structure by using a dot after the name of a variable of struct data
type.

Example
In the following program, we define a structure student with the elements name , studentId and
major . We then create two variables with this struct as their data type.

3_struct.c @cs344

Show files Open on Replit

main

1 ELF

>
@@p@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `@H ``�
�
TT@T@ P�tdpp@p@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI��@H���@H���@�� �D��f.�@U�0`H=0`H��t�H��t
8 ]�0`��D]�fD�0`UH��0`H��H��H��H��?H
�H��t�H��t ]�0`��]�fD�=y
uUH���~����g

]�D��@f.�UH��]��f�UH��H��@�E�H�@H�E��E�X
H�@H�E�H�u��U�H�M�H�.@���
���H�%X@H�M�H�%`@H�M�H�%h@H�M�H�uȋU�H�M�H�.@�Eİ�o���1҉E���H��@]�f�AWAV
I��AUATL�%N UH�-N SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
John DoeComputer
Science%s has id %d and major %s
9 Jane DoeI@�
@
;<p��������X����������
��������(

zR
x
�
0���+
zR
x
�
4���$0���� FJ w�?;*3$"X�����A�C
10 �Dx8���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�`����@�@



*�@
11 @�
12 `�
13 `���ox@�@�@
14 Y `�@�@0 ���o`@���o
���oR@`�@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@�@R@`@�@
�@
15 �@ �@@
16 @@p@�@�
17 `�

Linked lists in C are frequently created by defining a structure that includes a pointer (which are
discussed in the next exploration) to its type, e.g.,

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 8/9
6/8/24, 1:56 PM Exploration: Arrays & Structures: OPERATING SYSTEMS I (CS_374_400_S2024)

struct student {
char* name;
int studentId;
char* major;
struct student *next;
};

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

C for Python Programmers (http://www.toves.org/books/cpy/)

Carl Burch. C for Python Programmers. Hendrix College, 2011.
The C Book (https://archive.org/details/TheCBook/mode/2up) – somewhat old, somewhat
dated, but free
Mike Banahan, Declan Brady, and Mark Doran. The C Book, 1991.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-arrays-and-structures?module_item_id=24111738 9/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Pointers
Introduction
We now come to pointers - one of the most powerful and unique features of C.
Pointers hold addresses of variables in memory and allow us to indirectly access these
variables. Proper use of pointers facilitates writing very performant programs in C. On the other
hand, improper use of pointers is the cause of many bugs and vulnerabilities in C programs!

Pointers in C
A pointer in C is a pointer to a specific data type. We can thus have a pointer to an int, char,
float, etc. We can use pointers as variable and in expressions. There are two fundamental
operators related to pointers:

*p This operator returns the value pointed to by p

&i This operator returns the address of variable i

In general, we can declare a pointer either of the two following ways:

type* var;
type *var;

Here type is the type of the variable of whose address the pointer will hold, e.g., int* , char* ,
etc.

Let’s look at a program to understand these operators.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 1/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

2_4_pointer_intro @cs344

Show files Open on Replit

main

1 ELF

>
@@p@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `@H ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI�� @H���@H���@�� �D��f.�@U�0`H=0`H��t�H��t
8 ]�0`��D]�fD�0`UH��0`H��H��H��H��?H
�H��t�H��t ]�0`��]�fD�=y
uUH���~����g

]�D��@f.�UH��]��f�UH��H��0�E��E�
H�E�H�E�H�4@H�ư�����H�u�H�G@�E����
���H�u��6H�X@�E�������H�}��7��
H�}��7H�}
��7H�a@�E���s����u�H��@�E���\���1��E‫�܉‬H��0]�f.�DAWAVI��AUATL�%. UH�-.
SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
address of i = %p
9 value of p = %p
10 *p = %d
11 *p, i.e., i after increment = %d
12 i is now = %d
13
;8L����l���T�����\������������$

zR
x
�
���+
zR
x
�
���$0����
FJ w�?;*3$"X�����A�C
14 �Dx8���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�`����@�@



*�@
15 $@�
16 `�
17 `���ox@�@�@
18 Y `�@�@0 ���o`@���o
���oR@`�@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@�@R@`@�@

In the program, we declare two variables

i which is an int, and

p which is a pointer to an int.

We set the value of the pointer p to the address in memory where the variable i is stored via
the following statement

p = &i;

Thus, when you run the program you will see that &i and p have the same value.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 2/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

Aside: printf prints values of pointers via %p , printf also requires that the type of the
pointer to be printed should be cast to (void*) . We will study type casting in a later
exploration.

When p holds the value of the address of i , we can access the value of i by using *p , as in
the following statement:

printf("*p = %d\n", *p); // This prints the value of i

This is called dereferencing a pointer.

Using p , not only can we access the value in i , but additionally by using *p on the left-hand
side of an assignment statement, we can also update the value of i as in the following
statement:

*p = *p + 1; // This adds 1 to the value of i

*p = 10; // This will set the value of i to 10

A pointer holds the address of the memory location of a variable

Referencing variables allocated in one function in another

function
Pointers provide a way for C functions to reference memory allocated outside the function by
passing parameters by reference rather than by value. Let us look at two example programs
that try to swap the value of the arguments to a function, unsuccessfully in the first example,
and successfully in the second example.

If you run the following program, you will see that the value of the parameters remains the same
in main even after swap is called. This is an example of what is sometimes termed pass-by-
value. Here is what is happening:

In the function main , memory is allocated for the two integers i and j
When the function swap is called, memory is allocated for its parameters val1 and val2

The value of i is copied into the memory allocated for val1 and value of j is copied into
the memory allocated for val2
Within the function swap the values of val1 and val2 are indeed swapped with each other
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 3/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

But the values of i and j in main remain unchanged by this swap

2_4_swap_unsuccess.c @cs344

Show files Open on Replit

Now let’s look at another version of swap where swap is passed pointers to i and j .

Within the body of swap we dereference these pointers to swap the values of the variables, i.e.,
i and j whose address is stored in these pointers.

This style of providing access to a variable allocated outside a function by passing a pointer to
the variable is sometimes called pass-by-reference or call-by-reference.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 4/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

2_4_swap_success.c @cs344

Show files Open on Replit

main

1 ELF

>
@@�@8 @@@@@@�
�
88@8@

@@hh
�

2 �
3 `�
4 `@H ``�
�
TT@T@ P�td@@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI���@H��p@H�� @�� �D��f.�@U�0`H=0`H��t�H��t
8 ]�0`��D]�fD�0`UH��0`H��H��H��H��?H
�H��t�H��t ]�0`��]�fD�=y
uUH���~����g
]�D��@f.�UH��]��f�UH��H�}
�H�u�H�u���E�H�u��H�u���E�H�u��]�@UH��H���E��E�
�E�
9 H�}�H�u�������u��U�H��@������1҉E���H��]�f�AWAVI��AUATL�%n UH�-n
SA��I��L)�H��H���'���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
i = %d j = %d
10
;@���������\,�������������l���
����L

zR
x
�
����+
zR
x
�
����$08
��� FJ w�?;*3$"X ���,A�C
11 gx0���NA�C
12 ID�`���eB�B�E �B(�H0�H8�M@r8A0A(B BBB������@�@



*�@
13 �@�
14 `�
15 `���ox@�@�@
16 Y `�@�@0 ���o`@���o
���oR@`�@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@�@R@`@�@
�@
17 �@ �@@
18 �@�@@H@�
19 `�

Pointers to Arrays & Pointer Arithmetic

In C, an expression with the name of the array is considered the same as a pointer to the first
element of the array. For example, if we have an array of integers:

int numbers[10];

then the following 2 statements are equivalent

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 5/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

int* ptr = numbers;

int* ptr = &numbers[0];

C supports arithmetic operations on pointers. For example, if we set the pointer to the start of an
array and then add one to the value of the pointer, we get the address of the next element of the
array. This means that given the declaration of numbers and ptr above, the expressions in
each of the following lines are equivalent:

Pointers to Arrays & Pointer Arithmetic

Equivalent Equivalent Equivalent

Value of the expression
expression expression expression

Address of the 1st element

ptr numbers &numbers[0]
of the array

Address of ith element of

(ptr +i) numbers + i &numbers[i]
the array

Value of the 1st element of

*ptr *numbers numbers[0]
the array

Value of the ith element of

*(ptr + i) *(numbers + i) numbers[i]
the array

When we pass an array as an argument to a function, the array is passed by reference, i.e., the
parameter value is the address of the first element of the array. Let’s look at a program that
illustrates these concepts:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 6/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

2_4_array_arg @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td@@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI���@H��`@H���@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10
]�D��@f.�UH��]��f�UH��H�}�H�}���E��E�
�}
��5H�E�HcM���;U��H�E�HcM����U���E���
�E�������E�]�@UH��H��0�E��E��}
��HH��@��_���Hc}�H��H�M�H
�H�@H�ΉE‫�ذ‬I����EԋE‫�
�܃‬E������H�}��/
���H��@�ư����1��EЉ�H��0]�f.�DAWAVI��AUATL�%~ UH�-~
SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Enter an integer:
The max number you entered was
%d
;@$����T���\�����D���������D���
����L

zR
x
�
����+
zR
x
�
����$
0����0FJ w�?;*3$"Xx���\A�C
11 Wx�����A�C
12 �D�8���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�`���P@ @



* @
13 �@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@@�@�@�@

main calls the function findMax as findMax(numbers) . Thus, the argument to findMax is a
pointer to the first element of the array numbers
In findMax we process the array by adding an integer value to this pointer and then
dereferencing it to get the value of the element at that index. Specifically:
The expression ptr +i adds the integer i to the pointer ptr and evaluates to the
address of the element at index i in the array numbers
The expression *(ptr + i) dereferences this pointer to get the value of the element at
index i in the array numbers

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 7/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

Behind the scene, C automatically computes the address of the element based on the size of the
data type. In this example, the value of ptr + 1 will be the value of ptr plus the size of an int. If
we had a pointer fPtr which was a pointer to a float then the value of fPtr + 1 will be value of
fPtr plus the size of a float.

Exercise
The following program defines a function stringLength that returns the length of a string. The
code of the function is incomplete. At the point indicated in the program comments, add a line to
complete the function.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 8/9
6/8/24, 1:56 PM Exploration: Pointers: OPERATING SYSTEMS I (CS_374_400_S2024)

2_4_strlen_ex.c @cs344

Show files Open on Replit

main

1 ELF

>
@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `@H ``�
�
TT@T@ P�td<<@<@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI��@H���@H��0@�� �D��f.�@U�0`H=0`H��t�H��t
8 ]�0`��D]�fD�0`UH��0`H��H��H��H��?H
�H��t�H��t ]�0`��]�fD�=y
uUH���~����g
]�D��@f.�UH��]��f�UH��H�}
��E�H�E������E���
�E�������E�]�f.�@UH��H��H�}
��E��%@�E�f�%@f�M��%@�U������H�@�ư�u���1��E���H��]��AWAVI��AUATL�
%N UH�-N SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Hello!"Hello!" is
%d characters long
9
;@���������\���������������T���
����L

zR
x
�
`���+
zR
x
�
d���$0�
�� FJ w�?;*3$"X����2A�C
10 mx���XA�C
11 SD�H���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�p����@�@



*�@
12 @�
13 `�
14 `���ox@�@�@
15 Y `�@�@0 ���o`@���o
���oR@`�@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@�@R@`@�@
�@
16 �@ �@@
17 @@<@�@�
View the Solution (https://repl.it/@cs344/24strlenc)

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

Chapter 11 of Modern C discusses pointers.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pointers?module_item_id=24111739 9/9
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Memory Allocation

Introduction
To run a program, the OS creates a process and load the program into memory. In
this exploration, we will examine the layout of a process’s memory. We will then study dynamic
memory allocation which is an important feature of C. We will end this exploration by identifying
common pitfalls associated with accessing memory in C programs.

Process Memory Layout

The memory of a process is organized in a few segments. From the lowest address to the
highest address the segments are Code, Data, Heap and Stack. Code and Data segment have
fixed size. Heap and Stack can grow and shrink during the execution of a process. Typically
(particularly on x86 architecture) heap grows towards higher address and stack grows towards
lower address. These segments are shown in the figure below:

Memory Layout of a C Program: From the lowest address to the highest address the
segments are Code, Data, Heap and Stack. Code and Data segment have fixed size. Heap
grows towards higher address. Stack grows towards lower address.

Text Segment

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 1/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

The text segment, which is also called, code segment contains the object code for the program.
The size and contents of this segment doesn’t change over the execution of the process.

Data Segment
The data segment contains the memory allocated for global and static variables. This memory is
allocated at the start of the program. Note that at a more granular level, separate segments
exist for uninitialized global and static variables, and initialized global and static variables. But
we are going to ignore this level of granularity.

Stack Segment
The stack segment contains memory for non-static and non-global variables. The contents of
the stack segment are maintained in a LIFO (last in first out) order, just like a stack data
structure that you have studied in your data structure class. When a function is called, the stack
grows. The arguments of the function are placed on the stack segment, followed by the return
address of the calling function and then the local variables of the function itself. This is referred
to as the stack frame (or activation frame) of the function. When a function returns, the stack
frame of the function is removed from the stack segment, and the stack segment shrinks in size.
Thus, the stack segment grows and shrinks as the process execution continues.

Heap Segment
The heap segment contains memory that is dynamically allocated. The C functions malloc and
calloc are used to allocate memory on the heap, while the function free is used to deallocate
or free-up previously allocated memory.

Dynamic Memory Allocation

Many times, a program needs to allocate memory dynamically at run-time, rather than at
compile-time. For example, consider a program where we want to create an array to hold
integers entered by the user, but we want to size the array based on how many integers the
user tells us they want to enter. In this case, the size of the array will only be known after the
program starts executing, so we cannot specify the size of the array at compile-time.

The malloc and calloc functions

The C standard library provides two functions, malloc and calloc that can be used to
dynamically allocate memory at run time. Note that this memory is allocated from the heap
segment.
malloc is declared as follows:

void* malloc(size_t size);

malloc takes one argument which is the size in bytes of the block of memory being requested
( size_t type is defined as an unsigned int ). If malloc is successful it returns a pointer to the
memory it allocated. If malloc fails to allocate a block of memory of the requested size, it
returns NULL . This can happen, e.g., if there isn’t any block of memory available in the heap
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 2/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

segment that can satisfy the request. malloc doesn’t initialize the memory it returns.
calloc is declared as follows:

void *calloc(size_t numItems, size_t size);

The first argument to calloc specifies how many elements to allocate while the second
argument specifies size of each element. calloc will try to allocate a block of numItems * size
bytes. calloc initializes the memory to 0. Just like malloc , calloc will return a pointer to the
memory it allocated on success, and a NULL on failure.

sizeof Operator
C provides a sizeof operator that returns the size of its argument in bytes. The argument of
sizeof can be a data type, a variable, an expression. This operator is very commonly used
when calling malloc or calloc , as in the following example:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 3/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

3_malloc.c @cs344

Show files Open on Replit

main

1 ELF

>
@@0@8 @@@@@@�
�
88@8@

@@� �
�

2 �
3 `�
4 `X` ``�
�
TT@T@ P�td00@0@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


HV
O94libm.so.6__gmon_start__libpthread.so.0libc.so.6exit__isoc99_scanfpri
ntfmalloc__libc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 hui r�`�``
`(`0`H��H�] H��t��H����5R �%T @�%R
h������%J h
������%B h������%:
h�����1�I��^H��H���PTI���@H��P@H��`@��
9 �D��f.�@�H`H=H`t�H��t �H`��f��Df.��H`H��H`H��H��H��?
H
�H��t�H��t�H`���Df.��=�
10 uUH���~����
11
]�D�Df.���f.�@UH��H�� �}
�H�u��E��E�;E��-H�E�HcM��4�H��@�������E��E���
�E������H�@��p����E�H��
]��UH��H��0�E�H��@��@���H��@H�u��E���H���Hcu�H��H���E��%���H�E�H�}
��H�
@�������
�E������E��E�;E��PH�@������H�}�HcM�H��H
�H��@H�}
�H��H�u؉E԰������EЋE���
�E�������}�H�u������1�H��0]ÐAWAVI��AUATL�%� UH�-
� SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
%d How many
integers you want to enter: %dMemory allocation failed
12 Enter an integer:
;D���������`���������0����
���
����P

zR
x
�
h���+
zR
x
�
l���$0����PFJ w�?;*3$"X����iA�C
13 dx@����A�C
14 �D����eB�B�E �B(�H0�H8�M@r8A0A(B BBB�8����@�@



*�@
15 �@�
16 `�
17 `���ox@@@�@
18 ~ ``0@@0 ���o�@���o
���o�@`�@�@�@�@GCC: (Ubuntu 8.4.0-
1ubuntu1~18.04) 8.4.0clang version 7.0.0 ([email protected]:apple/swift-

The free function

As discussed earlier, memory allocated on the stack segment is freed up when a function
returns and its stack frame is removed from the stack segment. In contrast to this, memory
allocated on the heap segment is only freed by calling the free function which is declared as
follows:

void free(void *ptr);

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 4/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

This function takes one argument, a pointer to the start of the memory block to be returned to
the heap segment. This would be the value that is returned by calloc or malloc when the
memory block is allocated.

Example
In the following program, we create a linked list with elements of type struct customer by using
malloc to allocate memory for each element of the linked list. Note that the members of a

pointer to a structure are accessed by using -> rather than a dot.

3_2_linked_list.c @cs344

Show files Open on Replit

main

1 ELF

>
�@@�@8 @@@@@@�
�
88@8@

@@` `
�

2 �
3 `�
4 `hp ``�
�
TT@T@ P�td� � @� @LLQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4XJfQ
_;libm.so.6__gmon_start__libpthread.so.0libc.so.6strcpy__isoc99_scanfpri
ntfcallocstrlenmalloc__libc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 xui ��`�``
`(`0`8`@`H��H��
9 H��t��H����5�
10 �%�
11 @�%�
12 h������%�
13 h
������%�
14 h������%�
15 h������%�
16 h������%�
17 h�����1�I��^H��H���PTI�� @H���@H�Ǡ@�6
18 �D��f.�@U�X`H=X`H��t�H��t
19 ]�X`��D]�fD�X`UH��X`H��H��H��H��?H
�H��t�H��t ]�X`��]�fD�=
20 uUH���~�����
]�D��@f.�UH��]��f�UH��H��@���H�}
�H�u�H��������
��H�E�H�}
�H�u������H��
H��H�u�������
��H�M�H�
H�E�H�8H�E�H�u�H���D���H�}
�H�E��G���H��
H��H�u��W���H�M�H�AH�E�H�xH�u�����H�M�H�AH�M�H�E�H��H��@]Ð
UH��H��H�}�H�}��4H�E�H�0H�E�H�PH�4
@������H�U�H�RH�U��E������H��]�f.�DUH��H��`�E�H�E�H�E�H�;
@�������E��E��}���H�j @��[���H�u�H�� @�E���s���H�� @�E���/���H�u�H��
@�E���G���H�u�H�}��E��7���H�E�H�}
��H�E�H�E�H�E�H�E��H�E�H�M�H�AH�E�H�E���E���
�E��F���H�}
������1�H��`]�f.��AWAVI��AUATL�%. UH�-. SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A Ðf.���H��H���
%s %s

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 5/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

Pitfalls
The power of C features such as pointers and dynamic memory allocation can lead to bugs if
these aren’t used properly. We now discuss some of the most common memory-related bugs in
C programming.

Memory leaks
A memory leak occurs when a program allocates memory on the heap, but doesn’t free this
memory even when it is no longer needed, as in the following program:

3_mem_leak.c @cs344

Show files Open on Replit

main.c

1 #include <stdio.h>
2 #include <stdlib.h>
3
4 void memoryLeak(){
5 // Memory is dynamically allocated on the heap but ptr goes out of
scope when the funciton returns
6 // As long as the program runs, this memory is not available for
allocation, but will never be used because the only reference to is gone
7 int* ptr = (int*) malloc(sizeof(int) * 10);
8 return;
9 }
10
11 int main(void) {
12 memoryLeak();
13 return 0;
14 }

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 6/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

Memory leaks reduce the amount of heap segment that is available for memory allocation. In
long running programs, such as servers and daemons, this can be severe problem that can
result in program termination when requests for memory allocation can no longer be serviced
because of large number of memory leaks.

Buffer Overflow
A buffer overflow happens when a program writing data to a buffer in memory overruns the
boundary of the buffer. Let’s look at the following program to see an example:

2_3_string.c @cs344

Show files Open on Replit

main

1 ELF

>
p@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


CJ
4libm.so.6__gmon_start__libpthread.so.0libc.so.6__isoc99_scanfprintf__li
bc_start_mainGLIBC_2.7GLIBC_2.2.5
*ii
8 \ui f�`�``
`H��H�� H��t��H����5� �%� @�%� h������%�
h
�����1�I��^H��H���PTI��@@H���@H��`@�V �D��f.�@U�8`H=8`H��t�H��t
9 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=
uUH���~�����
10
]�D��@f.�UH��]��f�UH��H��
�%T@�E�H�X@������H�u�H��@�E�������H�U�H�u�H��@�E�������1ɉE���H��
]�f.�f�AWAVI��AUATL�% UH�- SA��I��L)�H��H������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
Hi!Enter the 2-
letter code for the state you live in: %s%s you live in %s
11
;8���������T����������,��������$

zR
x
�
p���+
zR
x
�
t���$0���0F
J w�?;*3$"X����dA�C
12 _DxH���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�p���P@ @



* @
13 D@�
14 `�
15 `���ox@@�@
16 r `0�@�@0 ���o�@���o
���o�@`V@f@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@@�@�@�@
�@
17 @ @@p@
18 D@P@�@�@�

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 7/8
6/8/24, 1:56 PM Exploration: Memory Allocation: OPERATING SYSTEMS I (CS_374_400_S2024)

Here the user is asked to enter the 2 letter code for the state they live in. If instead they enter a
very long string, our program can run into problems. For example, run the program and enter
the string Thisnameisveryverylong at the prompt. The program will crash due to the following
reason:

scanf tries to store the name into the array state .

This array is allocated in the stack segment and has a fixed size of 3 characters.
The attempt by scanf to store Thisnameisveryverylong in this array causes the array to
overflow and the program crashes.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

Chapters 12 and 13 of Modern C discuss memory allocation in C.

For a more detailed discussion of memory related bugs in C programs see Computer
Systems : A Programmer's Perspective
(https://search.library.oregonstate.edu/permalink/f/ueodtl/CP71323036590001451)
Bryant, R. E., O'Hallaron, David Richard, Manasa, S., & Tahiliani, Mohit P. (2016). Computer systems : a
programmer's perspective (Third edition, global edition.). Boston: Pearson.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-memory-allocation?module_item_id=24111741 8/8
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Strings
Introduction
Strings in C are simply an array of characters terminated by the null character. It is
not a basic data type, unlike many other “newer” languages, such as Java or C++. C includes
many functions for working with strings. We will first look at various ways of declaring strings
and their implication on how memory is allocated for the string. We will then study some basic C
library functions for manipulating strings.

Declaring Strings & Memory Allocation

Let’s look at 2 different ways of declaring the same string which has 10 characters including the
null character at the end:

1. char* myString = "my string";

2. char myString[] = "my string";

While both these declarations will create a string with the same characters, there are important
differences in how memory is allocated in each case. Let’s look at each of these in turn.

String allocation in the Data Segment

Let us consider the first declaration:

char* myString = "my string";

In the following program, we initialize the variable myString using this declaration and later try
to change the value of a character in myString .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 1/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

3_4_stringdec.c @cs344

Show files Open on Replit

main

1 ELF

>
@@p@8 @@@@@@�
�
88@8@

@@00
�

2 �
3 `�
4 `@H ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI���@H��P@H���@�� �D��f.�@U�0`H=0`H��t�H��t
8 ]�0`��D]�fD�0`UH��0`H��H��H��H��?H
�H��t�H��t ]�0`��]�fD�=y
uUH���~����g
]�D��@f.�UH��]��f�UH��H��
�E�H��@H�E�H�u�H��@������H�u��FeH�u�H��@�E�������1ɉE���H��
]ÐAWAVI��AUATL�%� UH�-� SA��I��L)�H��H���G���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
my stringmyString
is %s
9
;<��������X@��������`��������(

zR
x
�
����+
zR
x
�
����$0P���
FJ w�?;*3$"X8���_A�C
10 ZDxx���eB�B�E �B(�H0�H8�M@r8A0A(B BBB������@�@



*�@
11 �@�
12 `�
13 `���ox@�@�@
14 Y `�@�@0 ���o`@���o
���oR@`�@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@�@R@`@�@
�@
15 �@ �@@
16 �@�@�@0@�
17 `�
18 ``�`` `0`
��@@p@!�@7
0`
F
�

If you run the program, it will crash. Here is what causes this crash:

The data type of myString is a pointer to a character.

myString is allocated on the stack when the function is called.
The string "my string" is stored in the Data Segment in the read-only part of that segment.
myString pointer stores the address in memory where "my string" is stored in the Data

Segment.
When we try to change a character using the pointer myString , we are trying to change
memory in the read-only portion of the Data Segment, which causes the program to crash.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 2/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

String allocation in the Stack Segment

Both of the following declarations cause the string to be allocated in the Stack Segment. In each
case, 10 bytes of memory will be allocated in the Stack Segment for a variable named
myString :

char myString[] = "my string";

char myString[10] = "my string";

The memory allocated on the stack is editable, so the following program runs successfully.

3_4_str_stack.c @cs344

Show files Open on Replit

main

1 ELF

>
@@p@8 @@@@@@�
�
88@8@

@@@@
�

2 �
3 `�
4 `@H ``�
�
TT@T@ P�td@@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;
libm.so.6__gmon_start__libpthread.so.0libc.so.6printf__libc_start_mainGLI
BC_2.2.5

*ui M�`�``
H��H�% H��t��H����5" �%$ @�%"
h�����1�I��^H��H���PTI���@H��`@H���@�� �D��f.�@U�0`H=0`H��t�H��t
8 ]�0`��D]�fD�0`UH��0`H��H��H��H��?H
�H��t�H��t ]�0`��]�fD�=y
uUH���~����g
]�D��@f.�UH��]��f�UH��H��
H�u��E�H�%�@H�E�f�%�@f�M�H��@������H�u��E�eH��@�E�������1҉E���H��
]�f.��AWAVI��AUATL�%~ UH�-~ SA��I��L)�H��H���7���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
my stringmyString
is %s
9
;<��������X0���������`��������(

zR
x
�
����+
zR
x
�
����$0@���
FJ w�?;*3$"X(���eA�C
10 `Dxx���eB�B�E �B(�H0�H8�M@r8A0A(B BBB������@�@



*�@
11 �@�
12 `�
13 `���ox@�@�@
14 Y `�@�@0 ���o`@���o
���oR@`�@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git
34250a6eef79ee8a83c5cfb4deb1583176dcbb63)
8@T@x@�@�@R@`@�@
�@
15 �@ �@@
16 �@�@@@@�
17 `�
18 ``�`` `0`
��@@p@!�@7
0`
F
�

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 3/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

Basic String Functions

The header file string.h contains the declaration of many string library functions. We list the
declaration and description of some of these below. Example usage of these functions is shown
in the following program:

3_4_str_functions.c @cs344

Show files Open on Replit

main

1 ELF

>
�@@�@8 @@@@@@�
�
88@8@

@@0 0
�

2 �
3 `�
4 `px ``�
�
TT@T@ P�td� � @� @<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


;4QCfJ_
Xlibm.so.6__gmon_start__libpthread.so.0libc.so.6strcpystrncmpprintfcallo
cstrlenstrcatstrcmp__libc_start_mainGLIBC_2.2.5

*ui x�`�``

`(`0`8`@`H` H��H��
8 H��t��H����5�
9 �%�
10 @�%�
11 h������%�
12 h
������%�
13 h������%�
14 h������%�
15 h������%�
16 h������%�
17 h�����1�I��^H��H���PTI�� @H���@H�Ǡ@�
18 �D��f.�@U�``H=``H��t�H��t
19 ]�``��D]�fD�``UH��``H��H��H��H��?H
�H��t�H��t ]�``��]�fD�=�
uUH���~�����
]�D��@f.�UH��]��f�UH��H����E�H�$ @H�E�H�%/
@H�E�f�%7 @f�M��%9 @�U�H�u�H�}�H�u��m���H�: @H�u�H�°�e���H�u�H�}
��E��u������H�m @��;����E��H�� @��"����E�� ��H�u�H�}���������H�W
@�������E��H�� @�������E��
��H�}�H�u������H��
H��H�u������H�E�H�}
�H�u������H�u�H�� @H�E��������
��H�}�H�U�H�}�H�‫׉‬E�H�u��U���H�}
�H�E��H���H�U�H
�H��
H��H�u��Q���H�u�H�E�H�}�H�E�H��x���H������H�}
�H��x���H��p����;���H�u�H��
@H��h���������1ɉ�d�����H�Ġ]�f.�f�AWAVI��AUATL�%> UH�->
SA��I��L)�H��H���G���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A Ðf.���H��H���
my string1my

strcmp & strncmp

int strcmp(const char *s1, const char *s2);

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 4/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

This function compares the strings s1 and s2. If both strings are equal it returns 0, otherwise it
returns a non-zero value. Note that you mustn’t use == operator to compare two strings for
equality because that will compare the values of the two pointers rather than the contents of the
strings.

The related function strncmp takes a 3rd argument n and compares the first n characters of the
two strings.

strlen
size_t strlen(const char *s);

The function strlen returns the length of the string pointed to by the variable s . This length
doesn’t include the null character at the end of the string.

strcpy
char *strcpy(char *dest, const char *src);

The function strcpy copies the string pointed to by src to the buffer pointed to by dest . It
returns the pointer dest . The copied string includes the null character at the end. If the
destination buffer isn’t large enough to hold the string, this will cause buffer overflow.

The related function strncpy takes a 3rd argument n and copies the first n characters of src to
dest . If src is shorter than n bytes, then strncpy sets the remaining bytes to the null

character. If the first n bytes of the source string don’t contain the null character, then dest will
not be null terminated.

strcat
char *strcat(char *dest, const char *src);

The function strcat appends the string pointed to by src to the string pointed to by dest . The
function overwrites the terminating null character in dest and adds a terminating null character
at the end of the concatenated string. It returns the pointer dest . The array of characters
pointed to by dest must have enough space for the concatenated string, otherwise buffer
overflow will occur.

The related function strncat takes a 3rd argument n and concatenates at most n characters of
src to dest .

strdup
char *strdup(const char *s);

The function strdup creates a duplicate of the string s using malloc and returns a pointer to
this new string.

strtok
char *strtok(char *str, const char *delim);

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 5/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

strtok can break a string into a sequence of nonempty tokens using the characters provided in
the delim string as delimiters. The token returned by strtok is a null-terminated string that
doesn’t include the character corresponding to the delimiting character using to tokenize the
input string. If no more tokens are found then strktok returns NULL.

The following program shows the use of strtok :

3_4_strtok.c @cs344

Show files Open on Replit

main

1 ELF

>
P@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�tdHH@H@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4B
;libm.so.6__gmon_start__libpthread.so.0libc.so.6printfstrtok__libc_start
_mainGLIBC_2.2.5

*ui T�`�``
`H��H�� H��t��H����5� �%�
@�%� h������%� h
�����1�I��^H��H���PTI���@H��@@H��@@�v
�D��f.�@U�8`H=8`H��t�H��t
8 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=1
uUH���~����
]�D��@f.�UH��]��f�UH��H��@H�}
��E�H�%�@H�E�H�%�@H�E�f�%�@f�M�H��@�����H�E�H�u�H��@������1҉�H��@�E�
�����H�E�H�u�H�@��b���1҉�H�@�E��\���H�E�H�u�H�@��3���1҉�H�@�E��-
���H�E�H�u�H�&@�����1҉Eȉ�H��@]��AWAVI��AUATL�%� UH�-�
SA��I��L)�H��H�������H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
This.is my/string
./1st token = %s
9 2nd token = %s
10 3rd token = %s
11 No more tokens. We get back %s
12
;
<��������X8��������������h���(

zR
x
�
����+
zR
x
�
����$08���0FJ
w�?;*3$"X0����A�C
13 �Dx���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�8���0@@



*@
14 �@�
15 `�
16 `���ox@@�@
17 ` `0�@�@0 ���o�@���o
���op@`6@F@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)

We highlight a few points from the example:

The string to be parsed is provided as the first argument in the first call to strtok

In subsequent calls to parse the current string, the first argument should be NULL.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 6/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

If a call to strtok passes a non-null string as the first argument, then strtok will start parsing
this string, regardless of whether the previous string had been completely parsed or not.
The characters in delim can be different in successive calls that are parsing the same
string.

When parsing a string strtok overwrites the delimiter character at the end of the current token
by the null character. This means that strtok changes the input string during the parsing.
Therefore, if we pass a string that has been allocated in the read-only Data Segment to strtok
for tokenizing, the program will crash. strtok considers that a sequence of more than one
contiguous delimiter characters terminate one token in the parsed string.

strktok_r
char *strtok_r(char *str, const char *delim, char **saveptr);

strktok_r function is a reentrant version of strtok . We will study the concept of reentrant
functions in a later module. But for tokenizing strings, this means that with strtok_r we can
parse different strings concurrently, whereas with strtok we cannot parse different strings
concurrently. With strtok_r , the 3rd argument saveptr is used to maintain context between
successive calls to parse a string.

Example

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 7/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

3_4_strtok_r.c @cs344

Show files Open on Replit

main

1 ELF

>
P@@�@8 @@@@@@�
�
88@8@

@@��
�

2 �
3 `�
4 `HP ``�
�
TT@T@ P�td��@�@<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


4;D
libm.so.6__gmon_start__libpthread.so.0libc.so.6printfstrtok_r__libc_start
_mainGLIBC_2.2.5

*ui V�`�``
`H��H�� H��t��H����5� �%�
@�%� h������%� h
�����1�I��^H��H���PTI���@H���@H��@@�v
�D��f.�@U�8`H=8`H��t�H��t
8 ]�8`��D]�fD�8`UH��8`H��H��H��H��?H
�H��t�H��t ]�8`��]�fD�=1
uUH���~����
]�D��@f.�UH��]��f�UH��H��pH�}
��E�H�%@H�E�H�%@H�E�f�%
@f�M�H�%0@H�E�H�%8@H�E�H�%@@H�E�H�P@H�U������H�E�H�u�H�T@��i���H�}
�H�P@H�U��E��_���H�E�H�u�H�l@��6���E1�D��H�P@H�U��E��*���H�E�H�u�H��@�
�
���E1�D��H�P@H�U��E������H�E�H�u�H��@������E1��E�D��H��p]�f.�AWAVI��
AUATL�%^ UH�-^ SA��I��L)�H��H���O���H��t
1��L��L��D��A��H��
H9�u�H��[]A\A]A^A_Ðf.���H��H���
This.is my/stringA
very different string ./1st token in str1 = %s
9 1st token in str2 = %s
10 2nd token = %s
11
;8���������T���������������\���$

zR
x
�
`���+
zR
x
�
d���$0����0
FJ w�?;*3$"X����3
A�C
12 .
Dx���eB�B�E �B(�H0�H8�M@r8A0A(B BBB�0���0@@



*@
13 �@�
14 `�
15 `���ox@@�@
16 b `0�@�@0 ���o�@���o
���or@`6@F@GCC: (Ubuntu 7.5.0-
3ubuntu1~18.04) 7.5.0clang version 7.0.0 ([email protected]:apple/swift-
clang.git 5c9d04dc0697297a47b5edb0c1a581b306a42bdb)
([email protected]:apple/swift-llvm.git

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

string.h at Open Group C Specification

(https://pubs.opengroup.org/onlinepubs/9699919799/)
The Open Group. “The Open Group Base Specifications Issue 7, 2018 Edition,” 2018.
Arrays as Strings (GNU C Reference) (https://www.gnu.org/software/gnu-c-manual/gnu-
c-manual.html#Arrays-as-Strings)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 8/9
6/8/24, 1:57 PM Exploration: Strings: OPERATING SYSTEMS I (CS_374_400_S2024)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-strings?module_item_id=24111743 9/9
6/8/24, 1:57 PM Exploration: Debugging C: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Debugging C
Introduction
Modern IDEs (Integrated Development Environment) such as Visual Studio, Eclipse,
Visual Studio Code, etc., come with excellent tools for code generation, compilation, debugging
and stepping through live code. However, most Unix system come with the debugger gdb
installed on them. Additionally, the tool valgrind is also helpful in finding memory leaks in C
programs on Unix. We take a look at gdb and valgrind next.

gdb
gdb is a debugger we can use with gcc . We need to compile our program with the -g flag.
This will cause gcc to add debugging information in the executable which is used by gdb . We
can then start the debugger on the executable program. For example, we can compile a file
testit.c and run the debugger on the executable file testit by running the following 2
commands:

gcc -g testit.c -o testit

gdb ./testit

When running gdb, here are some key commands you can run:

run :: (re)starts the program running; will stop at breakpoint (can add args, e.g.: run 6 myfile)
break :: sets a breakpoint where the debugger will stop and allow you to examine variables
or
single step
step :: executes a single line of C code; will enter a function call
next :: executes a single line of C code; will not enter a function call
continue :: continues execution again until another breakpoint is hit or the program
completes
print :: prints out a variable
quit :: stop debugging (exit gdb)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-debugging-c?module_item_id=24111745 1/3
6/8/24, 1:57 PM Exploration: Debugging C: OPERATING SYSTEMS I (CS_374_400_S2024)

  0:00 / 12:16   1x    

valgrind
valgrind is a tool that helps find memory leaks in C programs. We need to compile the program
with the -g flag to add better diagnostics and then can run the program with valgrind using
appropriate flags.

$ gcc -o leaky -g leaky.c

$ valgrind --leak-check=yes --show-reachable=yes ./leaky

Some of the most useful valgrind flags are as follows:

--leak-check=yes Turn on detailed memory leak checker

--show-reachable=yes Is the memory not freed reachable?
--track-origins=yes Keep track of origins of uninitialized values
--log-file Write to a log file

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-debugging-c?module_item_id=24111745 2/3
6/8/24, 1:57 PM Exploration: Debugging C: OPERATING SYSTEMS I (CS_374_400_S2024)

  0:00 / 4:06   1x    

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

GCC Debugging Options (https://gcc.gnu.org/onlinedocs/gcc/Debugging-Options.html)

GDB Project Home Page (https://www.gnu.org/software/gdb/)
Valgrind Home Page (https://valgrind.org/)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-debugging-c?module_item_id=24111745 3/3
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Data Types, Modifiers,

Qualifiers & Conversion
Introduction
We have studied basic data type, arrays and pointers in a previous module. In this
exploration, we look at additional important topics related to data types in C.

Booleans
C didn’t have a basic Boolean data type for a long time. C99 added a basic data type
called _Bool which stores a value 0 or 1; it has the funny name to avoid name conflicts with
legacy code that often had custom type aliases (e.g. typedef char bool ). The header file
stdbool.h defines the type alias bool for _Bool . This header files also defines the
preprocessor macros true (1) and false (0). Typically, you should include this header and use
the "friendly" names provided, rather than the _Bool type. This gives legacy programs that
option to avoid name conflicts by not including stdbool.h .

In C, the value 0 is considered "false", while any non-zero value is considered "true"--for
example, as the controlling expression of an if, while, or for statement. The same is true with
bool : when assigning a non-zero value to a bool object, it is assigned the value 1 (true),

otherwise, 0 (false).

This value conversion step introduces an additional, often unnecessary, compiler overhead.
With most data types, type conversion rules are designed to mimic the behavior of a single mov
instruction in assembly. In contrast, assigning a bool is usually two instructions, for example,

test edi, edi

setne al

Additionally, beware of type conversions in comparisons: 0 == false , but 2 != true for the
same reason 2 != 1 .

Example
In the following program we can see that the values 2.0 , 'a' , evaluate to true.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 1/15
 Source Editor: C source #1
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <stdio.h>
#include <stdbool.h>

int main(void) {
_Bool b = 1;
bool aBool = true;
char c = 'a';
float f = 2.0;

if(b){
printf("variable b evaluates to true\n");
}

if(aBool){
printf("aBool is true\n");
}

if(c){
printf("variable c evaluates to true\n");
}

if(f){
printf("variable f evaluates to true\n"); Edit on Compiler Explorer
}

Unions
Union data types in C are similar to structures in that we define unions with members that have
different names and types. However, an actual object of a union data type can hold only one of
the members at a time--all of the members share overlapping storage. Essentially unions
provide a means for the same object to hold a value of a different data type based on which
union member was last assigned a value.

Example

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 2/15
 Source Editor: hello_world.c
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <stdio.h>

int main(void) {
/* A `union token` type can hold either a value of type `int` or `char` */
union token{
int num;
char oper;
};

/* tok1 stores a number */

union token tok1 = {.num = 78704};
printf("tok1: %d\n", tok1.num);

/* tok2 stores a char */

union token tok2 = {.oper = '*'};
printf("tok2: %c\n", tok2.oper);

/* tok2 now stores an integer */

tok2.num = 4;
printf("tok2: %d\n", tok2.num);

return 0;
} Edit on Compiler Explorer

Unions are commonly used in embedded programming contexts where memory is limited,
because they allow the same storage to be reused for different purposes.

Additionally, unions are used in low-level programming for type-punning: data may be written in
as one data type using one member, and read as another data type using another member. The
language guarantees that the data bytes of the type used to write in a value will be directly
reinterpreted as data bytes of the type used to read out a value. This can allow the same
physical data to be viewed according to different interpretations, but requires an understanding
of the actual representation of objects, which is implementation-defined. For example the
following real-life code example shows how unions and structures are used to represent the
registers of an AMD64 CPU,

#include <stdint.h>

#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)

/* Force packing of struct members with no padding */
#pragma pack(push, 1)
struct amd64_regs {
/* Register A */
union {
struct {
uint8_t al;
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 3/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)
uint8_t ah;
};

uint16_t ax;
uint32_t eax;
uint64_t rax;
};

/* Register C */
union {
struct {
uint8_t cl;
uint8_t ch;
};

uint16_t cx;
uint32_t ecx;
uint64_t rcx;
};

/* Register D */
union {
struct {
uint8 t dl;

Additional Integer Types

There are several additional integer types which are formed with the combination of the signed,
unsigned, short, and long keywords. These keywords may appear in any order, but for
simplicity's sake we'll look at how they're typically written. Each of these types has a different
minimum size and range, allowing for the programmer to choose suitable types for different
scenarios. Fundamentally, these are related to the pseudo-registers on AMD64; for example,
register A:

64 bit Low 32-bits Low 16-bits Low 8-bits

AMD64 Register name rax eax ax al

C equivalent type long long long short char

signed and unsigned

Integers are signed by default, but every integer type has an unsigned counterpart which is the
same size and can hold only non-negative values. These types are denoted by adding the
unsigned keyword, such as unsigned int . Unsigned and signed integers behave similarly,
except that while overflow of signed integers is undefined behavior, unsigned integer overflow is
well-defined to simply wrap around. For example, UINT_MAX + 1 == 0.

The signed keyword can also be used to explicitly denote a signed integer type, although this is
redundant-- signed int and int are the same exact type. However, there is one exception: the
types char , unsigned char , and signed char are distinct. The signed char and unsigned char
types are generic integer types with a size of one byte. In contrast, char is a special type which
is intended to be used only for representing ASCII characters. Since ASCII only uses values 0-
127, either a signed or unsigned single-byte value can be accommodate that range, and the
decision is left up the the implementation to use whichever is most efficient.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 4/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

short
The type short int , which can also be written more concisely as short , is an integer type with
a minimum range equivalent to a 16-bit integer.

long
The type long int , which can also be written more concisely as long , is an integer type with a
minimum range equivalent to a 32-bit integer. On Unix systems, it is typically a 64-bit integer
with the same size as long long .

long long
The type long long int , which can also be written more concisely as long long , is an integer
type with a minimum range equivalent to a 64-bit integer.

int
The plain int type, is an integer type that is defined as the native word size of the target
architecture's processor registers. Its minimum size is 16 bits, but typically it is 32 bits on
modern systems.

Example
The following program prints out the size of the basic integer types. Note that the value returned
may be different on different machines and compiler settings, depending on the data model
(https://en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models) used.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 5/15
 Source Editor: C source #1
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <stdio.h>

#define print_size(t) \
printf("sizeof (" #t ") == %zu\n", sizeof (t))

int main(void) {
print_size(char);
print_size(short);
print_size(long);
print_size(long long);
print_size(int);
return 0;
}

Edit on Compiler Explorer

Type Qualifiers
C provides a few type qualifiers, const , volatile , and restrict , of which const is the most
(mis)used.

const
Optimizing compilers examine the usage of objects in a program--if they can determine
conclusively that an object is never modified, they can make a lot of important optimizations. For
example, they can store such an object in read-only memory, and if the value of such an object
is known at compile-time, it can be directly substituted into any expressions where that object is
evaluated. Additionally, if an object is never modified, the compiler can reorder accesses to it in
order to optimize the overall program. All of these tricks can dramatically improve the
performance and resource usage of a program.

However, there are certain boundaries that are opaque to a compiler--for example, it cannot
possibly determine if externally linked objects are ever modified outside of the current source
file. Likewise, if the address of an object is ever passed to an external function defined in
another source file, the compiler can no longer determine that such an object is never modified.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 6/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

For example, carefully compare how the compiler is able or unable to optimize the following
three functions,

Source Editor: C source #1

/* x has external linkage. It can be directly accessed from other
* source files that aren't visible to the compiler. Therefore the compiler
* can't know that x is never modified. It also has to explicitly allocate
* storage for x.
*/
int x = 37;
int get_x() { return x; }

/* y has internal linkage. It can not be directly accessed outside of this

* source file. Since the address of y is never passed across a boundary that
* the compiler can't see through, the compiler can easily see the y is never
* modified and optimize the entire variable out. No storage is allocated for y.
*/
static int y = 37;
int get_y() { return y; }

/* z has internal linkage, but its address is still exposed externally. The
* compiler cannot guarantee that z is never modified. No optimizations are
* possible, just as with x */
static int z = 37;
int *zp = &z; /* expose the address of z externally */

Compiler Output x86 64 gcc 13 2 (Editor #1) Edit on Compiler Explorer

int get_z() { return z; }

The C language gives the programmer the ability to explicitly assure the compiler than an object
is never modified, by qualifying its type with the const qualifier. This allows the compiler to
make optimizations it otherwise would have not been able to, but requires the programmer to
ensure that the constraint is observed--it is undefined behavior for a const-qualified object to be
modified. Notice how const-qualifying the declarations in the example above allow the compiler
to make the same optimizations in each example,

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 7/15
 Source Editor: C source #1
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

/* x has external linkage and is const-qualified. It can be directly accessed

* from other source files that aren't visible to the compiler, but the compiler
* has been assured that it is never modified. Therefore the compiler can
* optimize accesses to its value. It still must allocate storage for x so that
* other source files can access it.
*/
int const x = 37;
int get_x() { return x; }

/* y has internal linkage. It can not be directly accessed outside of this

* source file. Since the address of y is never passed across a boundary that
* the compiler can't see through, the compiler can easily see the y is never
* modified and optimize the entire variable out. The const-qualification does
* not confer any extra optimization benefit in this case. */
static int const y = 37;
int get_y() { return y; }

/* z has internal linkage, and its address is still exposed externally, but it
* is const-qualified. The compiler has been assured that z is never modified.
* Just like with x, z can be optimized, but unlike y, space must still be
* allocated for it since its address might need to be known */
static int const z = 37;
int const *zp = &z; /* expose the address of z externally */ Edit on Compiler Explorer

Most compilers attempt to warn on attempted modification of const-qualified objects, but they
aren't required to. In fact, in situations where const-qualification helps the compiler make
optimizations it wouldn't have been able to otherwise, it's also not capable of identifying if the
constraint is being violated by an illegal modification. In essence, don't mistake const-
qualification for a safety-net. Actually, it is the opposite--it is a promise made to the compiler that
the programmer will ensure that an object in question is never be modified. A great many bugs
are the result of programmers failing to understand this.

Type Conversion
Type conversion, also called type casting, is a way of changing the data type of one expression
into another data type. In C, type conversion may be implicit or explicit. When a value of one
type is converted to another type, any component of the value, such as a fractional component
on a float to int conversion, that cannot be represented in the target type may be lost--
additionally, for certain types, like the signed integers, conversion from a value outside the
representable range (overflow) is undefined behavior.

Implicit Type Conversion

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 8/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

Implicit type conversion is automatically performed by the compiler. A frequent case is when the
compiler performs implicit type conversion on arithmetic expressions that include objects of
different data types, as in the following example:

Source Editor: C source #1

#include <stdio.h>

int main() {
int i = 1;
float f = 10.2;

// i and f have different data types

// f is converted to int, thus losing the fractional part
int k = i + f;

printf("k = %d\n", k);

return 0;
}

Edit on Compiler Explorer

In the example, the value of a variable is converted from float to int . This causes truncation
of the value as the fractional part is lost.

Explicit Type Conversion

Explicit type conversion can be accomplished with a type-cast operator, as in the following
example:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 9/15
 Source Editor: C source #1
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <stdio.h>

int main() {
/* In this example, the addition operation is carried out with types `float`.
* Next, the result, 3.8f, is converted to an `int`, value 3, on assignment.
*/
int a = 1.9f + 1.9f;
printf("a = %d\n", a);

/* In this example, both operands are explicitly converted to `int`, value 1,

* before addition. The addition operation is carried out with types `int`,
* and the result, value 2, is assigned. */
int b = (int)1.9f + (int)1.9f;
printf("b = %d\n", b);
return 0;
}

Edit on Compiler Explorer

Tip: Be careful when mixing arithmetic data types to avoid issues caused by unexpected
type conversion.

Pointer Conversions and void*

A void pointer, void* , is a special type of pointer that can be pointed to values of any data type.
We can convert pointers to specific data types to void pointers. We can also convert void pointers
pointing to a value of a specific data type to a pointer to that specific data type. We will see code
examples of conversion from void pointers to int pointers in the very next section, Pointers to
functions.

Pointers to Functions
In C we can define pointers to functions, just as we can define pointers to data types. To declare a
pointer to a function, we need to specify the name of the pointer, the return type of the function
and the types of its arguments.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 10/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

Example

The following statement declares fptr as a pointer to a function which takes 2 integers as its
arguments and returns an integer.

int (*fptr) (int, int);

Notice that this is different from int *fptr(int, int); which instead would declare a function with
return type int * .

Example
In the following program, we declare a function pointer fptr and then initialize this function
pointer to a function mult .

Source Editor: C source #1

#include <stdio.h>

int mult(int a, int b) { return a * b; }

int add(int a, int b) { return a + b; }

int main(void) {
/* fptr is a pointer to a function that returns an int and takes 2 arguments,
* both of which are int */
int (*fptr)(int, int);

/* We assign fptr the address of the function function mult() */

fptr = mult;

/* We can then call the function `mult` through the pointer `fptr` */
printf("fptr(10, 20) = %d\n", fptr(10, 20));

/* We reassign ftpr the address of the function add() */

fptr = add;

/* We can then call the function add() through the pointer `fptr` */
printf("fptr(10, 20) = %d\n", fptr(10, 20));

Edit on Compiler Explorer

t 0
A very well-known function in the standard C library that takes a function pointer as an argument
is the qsort function which implements the Quick Sort algorithm. Here is the declaration of qsort
and its description from the Linux man pages (https://man7.org/linux/man-
pages/man3/qsort.3.html) :

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 11/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

void qsort(void *base, size_t nmemb, size_t size,

int (*compar)(const void *, const void *));

The qsort() function sorts an array with nmemb elements of size size . The base argument
points to the start of the array.

The contents of the array are sorted in ascending order according to a comparison function
pointed to by compar , which is called with two arguments that point to the objects being
compared.

The function that must be provided as compar takes two values and returns an integer. It is
required that this function should return

an integer less than zero if the first argument is less than the second argument
0 if the arguments are equal
an integer greater than 0 if the first argument is greater than the second argument.

Exercise
Fill in the code for the function comparator so that it can be passed to qsort .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 12/15
 Source Editor: C source #1
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <stdio.h>
#include <stdlib.h>

/* void* is used as a "generic" pointer to data of any type. */

int comparator(const void *a, const void *b) {
/* Convert the void pointers to int pointers
* Note: It is the responsibility of the caller to ensure that a and b point
* to integers and not something else, otherwise this would be undefined
* behavior
*/
int const *_a = a;
int const *_b = b;
/* TODO: Return the correct value that represents the comparison of the values
* _pointed at_ by _a and _b */
return 0;
}

int main(void) {
int values[] = {10, 6, 8, 2, 12, 13};

qsort(&values, sizeof values / sizeof values[0], sizeof(int), comparator);

for (int i = 0; i < sizeof values / sizeof values[0]; ++i) { Edit on Compiler Explorer
i tf("%d " l [i])
View the Solution (https://cs374.godbolt.org/#g:!((g:!((g:!((h:codeEditor,i:
(filename:'1',fontScale:14,fontUsePx:'0',j:1,lang:___c,selection:
(endColumn:1,endLineNumber:20,positionColumn:1,positionLineNumber:20,selectionStartColumn:1,
selectionStartLineNumber:20,startColumn:1,startLineNumber:20),source:'%23include+%3Cstdio.h%3
E%0A%23include+%3Cstdlib.h%3E%0A%0A/*+void*+is+used+as+a+%22generic%22+pointer+to+data
+of+any+type.+*/%0Aint+comparator(const+void+*a,+const+void+*b)+%7B%0A++/*+Convert+the+voi
d+pointers+to+int+pointers%0A+++*+Note:+It+is+the+responsibility+of+the+caller+to+ensure+that+a
+and+b+point%0A+++*+to+integers+and+not+something+else,+otherwise+this+would+be+undefined
%0A+++*+behavior%0A+++*/%0A++int+const+*_a+%3D+a%3B%0A++int+const+*_b+%3D+b%3B%0A
++/*+TODO:+Return+the+correct+value+that+represents+the+comparison+of+the+values%0A+++*+_
pointed+at_+by+_a+and+_b+*/%0A++return+*_a+-
+*_b%3B%0A%7D%0A%0Aint+main(void)+%7B%0A++int+values%5B%5D+%3D+%7B10,+6,+8,+2,+12
,+13%7D%3B%0A%0A++qsort(%26values,+sizeof+values+/+sizeof+values%5B0%5D,+sizeof(int),+co
mparator)%3B%0A%0A++for+
(int+i+%3D+0%3B+i+%3C+sizeof+values+/+sizeof+values%5B0%5D%3B+%2B%2Bi)+%7B%0A++++pr
intf(%22%25d+%22,+values%5Bi%5D)%3B%0A++%7D%0A++printf(%22%5Cn%22)%3B%0A++return+
0%3B%0A%7D'),l:'5',n:'0',o:'C+source+%231',t:'0')),k:100,l:'4',m:50,n:'0',o:'',s:0,t:'0'),(g:!((h:executor,i:
(argsPanelShown:'1',compilationPanelShown:'0',compiler:cg132,compilerName:'',compilerOutShown

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 13/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

:'0',execArgs:'',execStdin:'',fontScale:14,fontUsePx:'0',j:1,lang:___c,libs:!
(),options:'',source:1,stdinPanelShown:'1',wrap:'1'),l:'5',n:'0',o:'Executor+x86-64+gcc+13.2+
(C,+Editor+%231)',t:'0')),header:(),l:'4',m:50,n:'0',o:'',s:0,t:'0')),l:'3',n:'0',o:'',t:'0')),version:4)

New Type Names Using typedef Statements

You may have noticed that the data type of the argument size in qsort is size_t . However, we
haven’t come across this type so far in our discussion. C provides a keyword called typedef that
can be used to assign type aliases. This allows, for example, libraries to select appropriate data
types on different systems, and expose type alias as the portable public interface.

Example
In the following example, we declare two type names, char_p for a pointer to a character and
osu_student for struct student .

Now instead of char* we can use char_p (don't actually do this, it's just for demonstration).
Similarly, instead of struct student we can use osu_student

Source Editor: C source #1

#include <stdio.h>

/* Declare string as an alias for char*

*/
typedef char *string;

struct student {
string name;
int id;
string major;
};

/* Declare student as an alias for struct student

*/
typedef struct student student;

void print_student(student s)
{
printf("%s (id: %d) is a %s student at OSU!", s.name, s.id, s.major);
}

int main(void) {

Edit on Compiler Explorer

t d t {

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 14/15
6/8/24, 1:58 PM Exploration: Data Types, Modifiers, Qualifiers & Conversion: OPERATING SYSTEMS I (CS_374_400_S2024)

Additional Resources
C Data Types Including Details of Modifiers (https://en.wikipedia.org/wiki/C_data_types)
Type Conversion in C Like Languages (https://en.wikipedia.org/wiki/Type_conversion#C-
like_languages)
For a discussion of typedef see Chapter 6.4 in the book Modern C

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-data-types-modifiers-qualifiers-and-conversion?module_item_id=24111748 15/15
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Files
Introduction
Files are key abstractions provided by an OS. For a system programmer, a file is a
stream of bytes that can be accessed as a linear array of bytes. In Unix, all I/O devices are
modeled as files. A very visible aspect of this is using files to provide access to persistent data
stored on secondary storage. But additionally, other I/O devices, such as networks, terminals
and printers are also modeled as files.

Path
A file or a directory can be identified by its path, which specifies a unique location for it A path
can be absolute or relative.

Absolute Path

An absolute path always starts with a / and specifies the location of the file or directory relative
to the root of the directory tree structure.

Example: If we run the shell command pwd , it will display the current working directory as an
absolute path as the following example shows:

$ pwd
/nfs/stak/users/chaudhrn

Relative Path

A relative path starts at the current working directory. It does not start with a /. Here are some
examples of specifying relative paths

The path to the file foo.txt in the current working directory

foo.txt

The path to the file foo.txt in the current working directory using a dot which is short-cut to the
current working directory

./foo.txt

The path to the file bar.txt in the directory txtFiles in the current working directory

textFiles/bar.txt

The path to the file bar.txt in the directory txtFiles in the current working directory using a
dot

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 1/7
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

./textFiles/bar.txt

The path to the file baz.txt in the parent directory using the double dot short-cut which goes
one level up

../baz.txt

Opening and Closing a File

In order to access a file, an application opens it by calling the open system call, which is
declared as follows:

int open(const char *pathname, int flags, mode_t mode);

The pathname is the path to the file which can be relative or absolute.
The next argument is flags
This argument must include one of the three access modes that specify how the
process wants to access the file
O_RDONLY for reading only,
O_WRONLY for writing only, or
O_RDWR for both read and write.
In addition it can also include zero or more file creation and file status flags which are
OR-ed together.
The file creation flags impact the behavior of the open operation
The file status flags impact the I/O operations carried out on the file after open
The mode argument specifies the access permission to be set when a new file is created
and is relevant only when a file is to be created and is ignored otherwise.

Note: The Linux Manual Page for open (https://man7.org/linux/man-

pages/man2/open.2.html) contains a full list of file creation and file status flags, as well as
full list of symbolic constants for the mode argument.

Example

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 2/7
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

3_5_open_close.c @cs344

Show files Open on Replit

In the example

We are opening the file for reading and writing using the flag O_RDWR.
We are specifying two file creation flags O_CREAT and O_TRUNC . The flag O_CREAT asks for
creating an empty file if one does not exist and O_TRUNC asks for truncating the file if it
already exists. Another useful flag is O_APPEND . If we want every write operation to append to
the end of the file, we will use the flag O_APPEND .
The values of the mode argument create the file so that it is readable and writeable by the
file owner. We discuss file permissions in a later exploration in this module.

If the open system call succeeds it returns a file descriptor, which is a small non-negative
integer. The file descriptor can be used in subsequent calls to read from and write to the file. If
the open system call fails, it returns the value -1 and the reason for the error is stored in errno .
And can be printed by using perror function.

When a process is done with a file, it can close it by calling the close function:

int close(int fd);

Close a file descriptor makes it available for reuse in the process.

Exercise
The following C program tries to open a non-existent file. In the code, set the flags argument
so that the open system call fails. What is the error message printed by perror ?

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 3/7
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

3_4_open_fail.c @cs344

Show files Open on Replit

View the Solution (https://repl.it/@cs344/34filefailsolc)

Reading and Writing Files

Programs can perform input and output by calling read and write system calls. The OS
maintains a file pointer, also called a file offset for each open file. This offset is incremented
when a file is read or written to. We can also modify this pointer by using the lseek system call.

read system call

ssize_t read(int fd, void *buf, size_t count);

The read system call reads from the file descriptor fd starting at the current file pointer into
the buffer pointed to by buf . The argument count specifies how many bytes read should
attempt to read. Read returns the number of bytes it transferred into the buffer. If there is an
error, the value of -1 is returned. If read encounters end-of-file, it returns 0.

The read system call does not allocate memory for the buffer. Thus, the buffer must be large
enough to accommodate count bytes. Read also does not put in a null character at the end of
the buffer. If needed, we must do that ourselves and the buffer must be large enough to add that
character. There are cases where read will transfer fewer than count bytes. This will happen
when, e.g., we are near the end of a file and read encounters the end of the file before count
bytes. At the end of read, the file offset will be incremented by the number of bytes read by read.

write system call

ssize_t write(int fd, const void *buf, size_t count);

The write system call reads bytes from the buffer buf to the file corresponding to the file
descriptor fd . The argument count specifies the number of bytes to write. Write returns the
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 4/7
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

number of bytes it writes to the file. This number may be less than count if, e.g., there is
insufficient space on the disk where the file is stored. If there is an error, the value of -1 is
returned. The file offset is incremented by the number of bytes that were written. Recall that we
can open a file with the O_APPEND flag. In that case, the file offset will first be set to the end of
the file and then write will write the bytes to the file.

Exercise
Run the following example of writing to a file and reading from it:

3_4_read.c @cs344

Show files Open on Replit

The following example is only slightly different from the above program. However, the read
system call does not read anything from the file. Why is that?

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 5/7
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

3_4_read_fail.c @cs344

Show files Open on Replit

Answer

lseek system call

off_t lseek(int fd, off_t offset, int whence);

The lseek system call repositions the file offset associated with the file descriptor fd to the
argument offset based on the directive whence whose possible values include the following:

SEEK_SET set the file pointer to the byte specified in the argument offset
E.g., move to byte #16
lseek(fd, 16, SEEK_SET)

SEEK_CUR set the file pointer to the current value plus offset bytes
E.g., move forward 4 bytes
lseek(fd, 4, SEEK_CUR)
SEEK_END set the file pointer to the end of file plus offset bytes
E.g., move to 8 bytes from the end
lseek(fd, -8, SEEK_END)

Exercise
Modify the following program to read from the start of the file by using lseek system call:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 6/7
6/8/24, 1:58 PM Exploration: Files: OPERATING SYSTEMS I (CS_374_400_S2024)

3_4_read_fail.c @cs344

Show files Open on Replit

View the Solution (https://repl.it/@cs344/34readwithlseekc)

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

The man page for the open system call is available here (https://man7.org/linux/man-
pages/man2/open.2.html)
File manipulation is discussed in Chapter 4 of the book The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.
A good discussion of files is provided in the chapter Files and Directories
(http://pages.cs.wisc.edu/~remzi/OSTEP/file-intro.pdf) in the book Operating Systems: Three
Easy Pieces
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files?module_item_id=24111749 7/7
6/8/24, 1:58 PM Exploration: stdin, stdout, stderr & C I/O library: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: stdin, stdout, stderr & C I/O

library
Introduction
Stream is another abstraction for I/O in Unix. Streams provide buffered I/O. They contain a buffer
and a reference to a file. Many system calls are at the level of the file abstraction, but as we will
see in this exploration C standard IO library functions provide support for streams which are at a
higher level of abstraction than files.

stdin, stdout, stderror

Each process in Unix is preconnected with three open files, standard input, standard output and
standard error.

"Schema of POSIX and C Standard Streams (stdio)"

(https://upload.wikimedia.org/wikipedia/commons/7/70/Stdstreams-notitle.svg) by Danielpr85 based on Graphviz source of
TuukkaH is in the Public Domain (https://wiki.creativecommons.org/Public_domain)

Schema of POSIX and C standard input, output and error: the image shows that a process
standard input is associated with the keyboard, standard output and standard error with the text
terminal.

Standard Input (stdin)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-stdin-stdout-stderr-and-c-i-slash-o-library?module_item_id=24111750 1/4
6/8/24, 1:58 PM Exploration: stdin, stdout, stderr & C I/O library: OPERATING SYSTEMS I (CS_374_400_S2024)

Standard input has the file descriptor value of 0. A program reads its input data from standard
input. Instead of using the magic number 0, we can use the constant STDIN_FILENO for the file
descriptor which is defined in unistd.h . When we run a program from a shell, by default standard
input is associated with the keyboard.

Standard Output (stdout)

Standard output has the file descriptor value of 1. A program writes its output to the standard
output. Instead of using the magic number 1, we can use the constant STDOUT_FILENO for the file
descriptor which is defined in unistd.h . When we run a program from a shell, by default standard
output is associated with the terminal.

Standard Error (stderr)

Standard error has the file descriptor value of 2. A program typically writes error messages to the
standard error. Instead of using the magic number 2, we can use the constant STDERR_FILENO for
the file descriptor which is defined in unistd.h . When we run a program from a shell, by default
standard error is associated with the terminal.

Redirecting Standard Input and Output

When running a program from the bash shell, we can redirect any or all of standard input, output
and error. E.g., we can get the input from a file instead of the keyboard by redirecting the standard
input. Similarly, we can redirect the output to write to a file by redirecting the standard output.
Input redirection is done by using the operator < and output redirection is done by using the
operator >.

Example: The echo commands displays a line of text. By default, it will display that line of text on
the terminal

$ echo 'this is a line'

this is a line

We can redirect this output to a file named echo.txt by using the output redirect operator as
follows:

$ echo 'this is a line' > echo.txt

$ cat echo.txt
this is a line

Some I/O Functions in C Standard Library

Instead of using system calls for I/O, most application developers use input and output functions
provided in the C I/O library stdio.h . Many of these functions work on input and output streams
that abstract the underlying file. A stream is represented by a FILE* type defined in stdio.h . We
now describe some of the most common I/O functions.

Opening and Closing a Stream

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-stdin-stdout-stderr-and-c-i-slash-o-library?module_item_id=24111750 2/4
6/8/24, 1:58 PM Exploration: stdin, stdout, stderr & C I/O library: OPERATING SYSTEMS I (CS_374_400_S2024)

FILE *fopen(const char *pathname, const char *mode)

fopen (https://man7.org/linux/man-pages/man3/fopen.3.html) opens a file in the specified mode ,

associates a stream with it and returns the stream.

int fclose(FILE *stream)

fclose (https://man7.org/linux/man-pages/man3/fclose.3.html) flushes the stream and closes the

underlying file descriptor associated with this stream

Reading from a Stream

int fgetc(FILE *stream)

fgetc (https://man7.org/linux/man-pages/man3/fgetc.3.html) reads the next character from a

stream. It returns EOF on end of file or an error

char *fgets(char *s, int size, FILE *stream)

fgets (https://man7.org/linux/man-pages/man3/fgetc.3.html) reads at most one less than size

characters into the buffer pointed to by s . It stops reading if it encounters end-of-file or a newline.
If it reads a newline it stores it in the buffer. It null terminates the buffer.

ssize_t getline(char **lineptr, size_t *n, FILE *stream)

We have already seen getline (https://man7.org/linux/man-pages/man3/getline.3.html) which is

used to read an entire line from a stream.

int fscanf(FILE *stream, const char *format, ...)

fscanf (https://man7.org/linux/man-pages/man3/fscanf.3.html) is similar to scanf , but for

reading formatted data from the specified stream rather than from stdin.

Writing to a Stream

int fputc(int c, FILE *stream)

fputc (https://man7.org/linux/man-pages/man3/fputc.3.html) writes the specified character to a

stream.

int fputs(const char *s, FILE *stream)

fputs (https://man7.org/linux/man-pages/man3/fputc.3.html) writes the string s to a stream

without the terminating null character.

int fprintf(FILE *stream, const char *format, ...)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-stdin-stdout-stderr-and-c-i-slash-o-library?module_item_id=24111750 3/4
6/8/24, 1:58 PM Exploration: stdin, stdout, stderr & C I/O library: OPERATING SYSTEMS I (CS_374_400_S2024)

fprintf (https://man7.org/linux/man-pages/man3/fprintf.3.html) is similar to printf , but for

writing formatted data to the specified stream rather than to stdout.

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)

fread (https://man7.org/linux/man-pages/man3/fread.3.html) and fwrite

(https://www.man7.org/linux/man-pages/man3/fwrite.3.html) functions are for reading/writing blocks
to data from/to a stream. These are used for binary files.

Repositioning a Stream
stdio also provides functions (https://man7.org/linux/man-pages/man3/fseek.3.html) to reposition
a stream. One such function is fseek which is stdio version of lseek , and sets the file position
indicator for the specified stream

int fseek(FILE *stream, long offset, int whence)

Checking and Resetting Stream Status

Finally, stdio provides some functions (https://man7.org/linux/man-pages/man3/feof.3.html) to
check the status of a stream and to reset a stream. These functions include

int feof(FILE *stream) to test the end-of-file indicator for a stream

int fileno(FILE *stream) to get the file descriptor associated with a stream

int ferror(FILE *stream) to test if an error indicator is set on a stream

void clearerr(FILE *stream) to clear the end-of-file and error indicators for a stream

Using fscanf vs. fgets or getline

We can use scanf or fscanf to get user input. However, dealing with certain incorrect data
types in user input can be somewhat difficult when using these functions. For example, if scanf
expects an integer and the user enters a string, that string isn't automatically removed from the
stdin stream.

As an alternative, we can use fgets or getline to read user input. In certain cases, this can
require us to do some parsing of the user input that fscanf can automatically do based on the
formatting string provided to it.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

C stdio Functions (https://en.wikipedia.org/wiki/C_file_input/output)

“C File Input/Output.” In Wikipedia, May 1, 2020.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-stdin-stdout-stderr-and-c-i-slash-o-library?module_item_id=24111750 4/4
6/8/24, 1:58 PM Exploration: Directories: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Directories
Introduction
In this exploration, we study directories. We first look at directories and API for
manipulating them. We then discuss how we can get meta-data about files and directories.

Directories
A directory is in many ways a file. In Unix, it is just a text file. Logically, a directory is a linear
array of bytes. Internally, it connects a human readable text filename to an inode. An inode is a
structure that is maintained by the OS file system. Each entry in a directory refers to either files
or to other directories.

We can create and remove directories using mkdir and rmdir system calls:

mkdir

int mkdir(const char *pathname, mode_t mode);

mkdir (https://man7.org/linux/man-pages/man2/mkdir.2.html) attempts to create a directory named

pathname while the argument mode specifies the permissions for the directory.

rmdir

int rmdir(const char *pathname);

rmdir (https://man7.org/linux/man-pages/man2/rmdir.2.html) attempts to delete the directory

specified by pathname . It is required that this directory must be empty.

Opening, reading and closing directories

The steps to read a directory are very similar to the ones for reading a file. We open a directory,
read it and the close the directory.

opendir
To open a directory, we use the function opendir (https://man7.org/linux/man-
pages/man3/opendir.3.html)

#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);

The opendir function opens the directory corresponding to the specified name and returns a
pointer to the directory stream. This stream is positioned at the first entry in the directory. Note
that there is a file descriptor associated with the directory stream, but the directory stream

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-directories?module_item_id=24111751 1/5
6/8/24, 1:58 PM Exploration: Directories: OPERATING SYSTEMS I (CS_374_400_S2024)

provides us a higher level abstraction with the file descriptor automatically associated with the
stream.

closedir
To close a directory, we use the function closedir (https://man7.org/linux/man-
pages/man3/closedir.3.html)

#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);

The closedir function closes the directory stream corresponding to the argument dirp . This
call will also close the underlying file descriptor.

readdir
To read the directory entries, we use the function readdir (https://www.man7.org/linux/man-
pages/man3/readdir.3.html)

#include <dirent.h>
struct dirent *readdir(DIR *dirp);

The readdir function returns a pointer to a structure dirent which corresponds to the next
directory entry in the directory stream associated with dirp . When we have reached the end of
the directory stream, readdir will return a NULL value.

The dirent structure has many fields. Only 2 fields are mandated by POSIX.1 that correspond
to the inode number and the filename. The structure definition is shown below with those 2
fields:

struct dirent {
ino_t d_ino; /* Inode number */
…
char d_name[256]; /* Null-terminated filename */
};

Example
Let us look at example of using these functions to read a directory:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-directories?module_item_id=24111751 2/5
6/8/24, 1:58 PM Exploration: Directories: OPERATING SYSTEMS I (CS_374_400_S2024)

3_4_directory.c @cs344

Show files Open on Replit

Getting File and Directory Meta-Data

The function stat returns meta-data about a file (or directory) including information on its size,
time of last access, time of last modification, etc.

stat

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *pathname, struct stat *statbuf);

The stat (https://man7.org/linux/man-pages/man2/stat.2.html) function returns this information

in the struct pointed to by statbuf . The stat structure contains the following fields, among
others:

dev_t st_dev; /* ID of device containing file */

ino_t st_ino; /* Inode number */
mode_t st_mode; /* File type and mode */
uid_t st_uid; /* User ID of owner */
gid_t st_gid; /* Group ID of owner */
off_t st_size; /* Total size, in bytes */
time_t st_atime; /* time of last access */
time_t st_mtime; /* time of last modification */

Example

In the following program, we use the stat function to find out the name of the file or directory
whose name starts with the prefix student and which was modified last in the current directory:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-directories?module_item_id=24111751 3/5
6/8/24, 1:58 PM Exploration: Directories: OPERATING SYSTEMS I (CS_374_400_S2024)

3_5_stat_example.c @cs344

Show files Open on Replit

In this program

We open the current directory and loop through all the entries in the directory by calling
readdir in a loop

We get the meta-date for the entry, which may be a file or a directory, by calling stat
The last modification time of the entry is specified in the element st_mtime
We use the C standard library function difftime (https://man7.org/linux/man-
pages/man3/difftime.3.html) to compare st_mtime with the latest modification time we have
currently seen
Whenever we find an entry with a last modification time later than any entry previously seen,
we call the function memset (https://www.man7.org/linux/man-pages/man3/memset.3.html)
to clear out the buffer entryName and use strcpy to copy the name of this entry into
entryName

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

For more details on the system calls and functions discussed in this exploration see the
Linux manual page web site (https://www.kernel.org/doc/man-pages/) .
Chapter 18 of the book The Linux Programming Interface discuss directories.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.
A good discussion of directories is provided in the chapter Files and Directories
(http://pages.cs.wisc.edu/~remzi/OSTEP/file-intro.pdf) in the book Operating Systems: Three
Easy Pieces
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-directories?module_item_id=24111751 4/5
6/8/24, 1:58 PM Exploration: Directories: OPERATING SYSTEMS I (CS_374_400_S2024)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-directories?module_item_id=24111751 5/5
6/8/24, 1:58 PM Exploration: Permissions: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Permissions
Introductions
In this exploration we will discuss file and directory permissions in Unix. We will also understand
how to specify permissions when creating a file or directory.

File & Directory Permissions

Permissions for file and directories in Unix are managed is 3 scopes: owner or user, group and
others. For each of these scopes, 3 types of permissions can be granted:

Read: Read permission on a file allows reading the file. Read permission on a directory allows
reading the names of files in the directory.
Write: Write permission on a file allows modifying the file. Write permission on a directory
allows creating, deleting and renaming the files, but only if the execute permission is also
granted on the directory.
Execute: Execute permission on a file allows an executable program to be executed. Without
this permission the OS will not allow execution of a file. Execute permission on a file allows
access to file content and meta-data if the file name is known. Reading the names of the files
requires read permission.

This means that in all there are 9 permissions associated with a file or directory:

read, write and execute for user,

read, write and execute for group, and
read, write and execute for others.

You can see the permissions by using the command ls -l which displays these permissions in a
symbolic notation consisting of 3 sets of 3 characters, of which:

the first set is for the owner

the second set is for the group and
the third set is for others.

In each set:

the first character is r is the read permission has been given,

the second character is w if the write permission has been given, and
the third character is x if the execute permission has been given

The lack of any permission is displayed with a -.

Example
Let us look at an example:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-permissions?module_item_id=24111752 1/5
6/8/24, 1:58 PM Exploration: Permissions: OPERATING SYSTEMS I (CS_374_400_S2024)

ls -l
total 20
-rw-------. 1 chaudhrn upg11000 1147 Apr 19 11:39 catch-signals.c
-rwxr-x---. 1 chaudhrn upg11000 228 Apr 19 11:39 sigtest.sh

For the file catch-signals.c

The owner is chaudhrn and the owner permissions are set to rw- . This means the file can be
read and written to by the owner chaudhrn , but the owner cannot execute it.
The group is upg11000 and the group permissions are set to --- . This means no permissions
have been granted to the group
The permissions for others are also set to --- . This means that anyone who is not the owner
or is in the group upg11000 doesn't have any permissions on the file.

As for the file sigtest.sh

The owner chaudhrn has permissions rwx and is therefore allowed to read, write and execute
the file,
All members of the group upg11000 have the permissions r-x and are allowed to read and
execute the file, but cannot write the file.
Others don't have any permissions on the file.

You may have noticed that there is one character with the value - that appears before the
owner's permissions. This character shows the type of the file and - means that it is a simple file.
For a directory, this character will have the value d .

Octal Representation of the Permissions

Octal Notation for Permissions

Another representation of Unix file permissions is a numeric representation as an octal (i.e., base
8) integer. In this representation, each scope is represented by one octal digit. Thus, the full 9
permissions are represented by 3 octal digits as follows:

The highest order octal digit corresponds to the owner.

The middle octal digit corresponds to the group.
The lowest order octal digit corresponds to others.

The value of the octal digit for a scope corresponds to the symbolic notation as follows:

Read permission adds 4 to the octal digit

Write permission adds 2 to the octal digit
Execute permission adds 1 to the octal digit

Thus, for a particular scope the value of the octal digit corresponds to the permissions for the
scope as follows:

Symbolic & Octal Representations of Permissions for One Scope

Symbolic Octal Digit Description

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-permissions?module_item_id=24111752 2/5
6/8/24, 1:58 PM Exploration: Permissions: OPERATING SYSTEMS I (CS_374_400_S2024)

Symbolic Octal Digit Description

rwx 7 read, write, & execute
rw- 6 read & write
r-x 5 read & execute
r-- 4 read
-wx 3 write & execute
-w- 2 write
--x 1 execute
--- 0 No permissions

Now let's look at examples of the full 9 permissions in the symbolic notation along with
the corresponding octal notation (recall that octal integer literal have a 0 at the start, just as hexa-
decimal literals have a 0x at the start).

Symbolic & Octal Representations of Permissions for All 3 Scopes

Symbolic Octal Notation Description

---------- 0000 no permissions
-rwx------ 0700 read, write, & execute only for owner
read, write, & execute for owner and
-rwxrwx--- 0770
group
read, write, & execute for owner, group
-rwxrwxrwx 0777
and others
---x--x--x 0111 execute
--w--w--w- 0222 write
--wx-wx-wx 0333 write & execute
-r--r--r-- 0444 read
-r-xr-xr-x 0555 read & execute
-rw-rw-rw- 0666 read & write

owner can read, write, & execute; group

-rwxr----- 0740 can only read;

others have no permissions

mode argument in open and mkdir

We studied the open and mkdir system calls in earlier explorations in this module. Both of these
system calls take a mode argument. We can pass the permissions for the newly created file or
directory using the octal notation.

Example

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-permissions?module_item_id=24111752 3/5
6/8/24, 1:58 PM Exploration: Permissions: OPERATING SYSTEMS I (CS_374_400_S2024)

The following example is reproduced from the Exploration: Files,

(https://canvas.oregonstate.edu/courses/1971495/pages/exploration-files) section "Opening and
Closing a File."

3_5_open_close.c @cs344

Show files Open on Replit

The value of the mode argument is 0600. This corresponds to the symbolic notation rw------- .
This means that the owner can read and write to the file, but cannot execute it. There are no
permission granted to group and others on this file.

umask: File Mode Creation Mask

The permissions set on a newly created file or directory depends on one additional value in
addition to the value of the argument mode . This value is called the file mode creation mask or
umask . Each process has an associated umask value which is the standard octal representation

of the file permissions. However, while the mode argument specifies the permissions that should
be granted to the new file or directory, the umask value of the process specifies the permissions

that must be denied to the new file or directory. umask thus helps to guard against cases where a
user might inadvertently grant dangerous permissions to a group or to others.

Example
Suppose we are calling mkdir with the mode argument set to 0777, i.e., grant all permissions on
the directory to the owner, the group and others. Consider the value of umask for the process is
set to 0007, i.e., deny grant of all permissions to others. Then the directory will be created with the
permissions 0770.

The umask command and system call

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-permissions?module_item_id=24111752 4/5
6/8/24, 1:58 PM Exploration: Permissions: OPERATING SYSTEMS I (CS_374_400_S2024)

We can view the current value of umask by using the shell command umask

(https://man7.org/linux/man-pages/man1/umask.1p.html) . For example, on os1 the value of umask

is set to 007 when the umask command was executed.

os1 ~ 1001$ umask

0007

We can change the value of umask in a process by calling the umask system call
(https://man7.org/linux/man-pages/man1/umask.1p.html) .

mode_t umask(mode_t mask)

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

The example table showing symbolic and octal representation is from the Wikipedia page on
File-system permissions (https://en.wikipedia.org/wiki/File-
system_permissions#Numeric_notation) (last accessed Oct 10, 2020).
Chapter 15 of the book The Linux Programming Interface discusses file attributes.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-permissions?module_item_id=24111752 5/5
6/8/24, 1:59 PM Exploration: Process Concept & States: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Process Concept & States

Introduction
A program is executable code. A process is an instance of a running program.
Process management is a key functionality of an OS. We start our study of processes by giving
a high-level overview of processes and the various OS APIs related to process management.

Process ID
In Unix, each process has a unique identity, called the process ID or pid. The process ID is a
non-negative integer. At any given time, all processes are guaranteed to have a unique ID.
However, when a process terminates, its ID can be reused. The value of the process ID can be
obtained by using the getpid() function.

#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);

A related function getppid() returns the process id of a process’s parent process (we will look
at parent and child processes later in this module). Let’s see an example of calling these
functions:

#include <stdio.h> // printf

#include <sys/types.h> // pid_t, not used in this example
#include <unistd.h> // getpid, getppid

int main(void) {
printf("My pid is %d\n", getpid());
printf("My parent's pid is %d\n", getppid());
return 0;
}

The process with ID 1 is generally the init process. When the OS is finishing its startup, it
starts the init process.

Process API
Unix, as well as other modern OSs, provides an API for processes which typically include
systems call related to the following areas:

Creating Processes
When we open a new shell, the OS creates a new process. When we run a command in a shell,
the OS creates another new process.

Each process has its own memory space which is allocated for it when the OS creates this
process. The OS abstracts this memory so that to the process this memory space starts at byte

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-concept-and-states?module_item_id=24111756 1/4
6/8/24, 1:59 PM Exploration: Process Concept & States: OPERATING SYSTEMS I (CS_374_400_S2024)

0 even though in the physical memory this allocated memory might start at a different address.
The OS loads this memory with the code of the program that the process is executing. The OS
also allocates memory for the stack and the heap. Recall that C programs use the stack for
function arguments, local variables and return addresses, and the heap for dynamically
allocated memory.

The OS provides an API to create new processes and to run specific programs in a process.
Relevant system calls for this include fork() and the exec() family of system calls.

Terminating Processes
Many processes will stop by themselves when they are complete.

Example: When we run the ls command in a shell, a new process is created to run the
program corresponding to the ls command. This process exits when the command is
completed.

However, the OS also needs to be able to terminate processes when required.

Example: Suppose we start an editor to edit a file. Like all programs, this editor will run in a
process. When we are done updating a file, we want the OS to terminate this process perhaps
by clicking on an exit button.

Controlling & Monitoring Processes

Sometimes a process needs to wait for another process to finish.

Example: When a shell runs the ls command, it wants to wait for ls to finish before again
showing the prompt to the user.

Functions wait() and waitpid() allow a process to wait for another process to finish.

In addition to wait() and waitpid() , there are additional system calls related to controlling and
monitoring process. These include the following:

We can get or change the priority of a process by using getpriority() and setpriority()

We can get statistics about the time a process has spent on CPU by using times()

Process States
Over its lifetime, a program may do many different types of operations. E.g., a browser will get
data from a website across the network at some points, and at other times it might write a
downloaded file to the disk. This means that in general a single program cannot utilize the CPU
or the I/O devices all the time.

Modern operating systems provide multi-programming, where they keep multiple processes
ready to run on the CPU, thus giving the user the impression that multiple programs are running
simultaneously. At the level of individual processes this means that a process will be in different
states during its lifetime. The three primary states of a process are as follows:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-concept-and-states?module_item_id=24111756 2/4
6/8/24, 1:59 PM Exploration: Process Concept & States: OPERATING SYSTEMS I (CS_374_400_S2024)

Ready
In the ready (or runnable) state, a process is ready to be put on the CPU. However, currently
the OS has allocated the CPU to some other process. Or in the case of a system with multiple
CPUs, the OS has allocated all the CPUs to some other processes.
Running
In the running state, the process is running on the CPU, i.e., the instructions of the process are
being executed.
Waiting
In the waiting (or blocked) state, a process is waiting for some event to happen before it can
be ready to run again. An example is when a process initiates an I/O operation and then has to
wait until the I/O operation completes. The process goes to the waiting state and the CPU can
be allocated to another process.

Important Process States in Unix

A Ready process goes to the Running state when the OS schedules it to run on the CPU. A
Running process goes to the Ready state when the OS unschedules it from the CPU. A
Running process goes to the Waiting state when the process initiates some action that blocks
it, e.g., it issues an I/O call and waits for its completion. A Waiting process goes to the Ready
state when the action that it was waiting for gets done. E.g., the I/O it was waiting for is
complete.

Additional Resources
For more discussion see the chapter The Abstration: The Process
(http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-intro.pdf) in the book Operating Systems: Three
Easy Pieces by Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau.
Arpaci-Dusseau, R. H., & Arpaci-Dusseau, A. C. (2018). Operating systems: Three easy pieces. Arpaci-Dusseau
Books LLC.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-concept-and-states?module_item_id=24111756 3/4
6/8/24, 1:59 PM Exploration: Process Concept & States: OPERATING SYSTEMS I (CS_374_400_S2024)

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-concept-and-states?module_item_id=24111756 4/4
6/8/24, 1:59 PM Exploration: Process API – Creating and Terminating Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Process API – Creating and

Terminating Processes
Introduction
In this exploration, we look at the Unix API for creating new processes and
terminating processes.

Creating Processes Using Fork

The fork() system call creates a new process.

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

The new process is referred to as the child process, while the original process that called
fork() is referred to as the parent process. The child process is almost an exact duplicate of
the parent process. The child process has its own memory space which is a copy of the parent's
memory space. The program counter is also copied and will have the same value for the child
process. But there are some differences. The most crucial difference is that fork() returns the
value 0 in the child process, while the pid of the child process is returned by fork() in the
parent process. This allows the child process and the parent process to diverge in their
behavior. Typically, the statement executed immediately after fork() is a branching statement
( if-else or switch ) which uses the value returned by fork() to pick a different branch to
execute in the child process vs. the branch picked for execution in the parent process.

Example
The following program has an integer variable intVal with initial value 10. When we run the
program, the process running the program calls fork() . This creates a new child process. The
switch statement uses the value returned by fork() to run different code in the child process
vs. the parent process. In the child process, 1 is added to the variable intVal , whereas in the
parent process 1 is subtracted from the variable intVal . When you run the program, you will
see that in the parent the value of the variable intVal is 9 and in the child it is 11.

If you run the program multiple times, it is very likely that the order in which the parent output
and the child output are printed will vary across multiple runs of this program. This is because
the order in which statements in the child process and the statements in the parent process get
executed depends on when the OS schedules these two processes and thus can vary over
multiple runs of the program. There may also be runs in which the child process output is not
printed. We will study the reason for that later in the course.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-creating-and-terminating-processes?module_item_id=24111757 1/4
6/8/24, 1:59 PM Exploration: Process API – Creating and Terminating Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

4_fork_example.c @cs344

Show files Open on Replit

So why does the value of the variable differ in the parent process vs. the child process? This is
because the child process runs in its own memory space. At the time fork is executed this
memory space is a duplicate of the parent process’s memory space. This means that both the
processes have the same variables and these variables have the same value. But as the
example demonstrates, the memory writes done by one process do not affect the memory of the
other process. Hence, when the child updates the value of a variable, it is done in its own
memory space and does not impact the memory space of the parent process. Similarly, when
the parent process updates the value of a variable, it is done in the parent process's memory
space and does not impact the memory space of the child process.

Tree of Processes
When a process calls fork() to spawn a child, the child process may in turn calls fork() to
create its own child, and so on. Thus, over time the parent-child relationship between different
processes leads to a tree structure.

Multiple fork() calls create a tree of processes

Multiple fork() calls create a tree of processes The process with PID 538 calls fork and a child

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-creating-and-terminating-processes?module_item_id=24111757 2/4
6/8/24, 1:59 PM Exploration: Process API – Creating and Terminating Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

process with PID 648 is created. Later process with PID 538 again calls fork and another child
process with PID 932 is created. The process with PID 932 calls fork and its child process with
PID 1008 is created.

What Does a Child Inherit?

The child process inherits a number of properties from the parent, including the following:

The list of open file descriptors

Current working directory
Process group ID
Environment variables
Resource limits
Settings about how to handle signals.

We are going to discuss many of these items in later explorations or modules.

Failure of fork()
If fork fails it returns the value of -1. The most likely reasons are either that there are too many
processes already running in the system or that creating the new processes will cause the
resource limit to exceed.

Terminating Processes
A process can terminate for two reasons:

Normal Termination
The process completes its execution and exits itself. This is considered normal termination.
There are two cases to consider:

Case 1:

The process completed what it was supposed to do. This happens, e.g., when a process
executes a return statement from its main function. Note that when the main function
executes a return statement, internally this calls the exit() function with the value specified in
the return statement. E.g., when main executes return 0; this results in the function call
exit(0) .

Case 2:

The process encountered an error condition, recognized it, and exited by calling the exit
function. This is still considered normal termination because the process is terminating itself,
rather than the process being terminated by some other process.

Here is the synopsis of the exit function:

#include <stdlib.h>
void exit(int status);

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-creating-and-terminating-processes?module_item_id=24111757 3/4
6/8/24, 1:59 PM Exploration: Process API – Creating and Terminating Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

By convention, when the process successfully completes what it was supposed to do, i.e., Case
1 above, the status value should be 0 and for Case 2, the status value should be non-zero. The
value of the exit status is transmitted to the parent process.

It is possible to register functions, termed exit handlers, by calling the function atexit() . The
exit function calls all these exit handler functions. It flushes all the standard IO streams. It then
calls the _exit() function. The _exit() function closes all the files and cleans up the process.

Abnormal Termination
A process termination is considered abnormal when it receives a signal which causes it to
terminate. We will study signals in the next module.

Process Termination & Child Processes

What happens to a child process if it is still running and its parent process terminates? In such
cases, the init process becomes the parent process of the "orphaned" child processes.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration:

For more discussion see the chapter The Process API

(http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-api.pdf) in the book Operating Systems: Three
Easy Pieces by Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau.
Arpaci-Dusseau, R. H., & Arpaci-Dusseau, A. C. (2018). Operating systems: Three easy pieces. Arpaci-Dusseau
Books LLC.
Chapters 24 and 25 of the book The Linux Programming Interface discuss process creation
and termination in great detail.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-creating-and-terminating-processes?module_item_id=24111757 4/4
6/8/24, 1:59 PM Exploration: Process API - Monitoring Child Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Process API - Monitoring

Child Processes
Introduction
In many cases a parent process wants to know when and how its child process or
processes have terminated. For example, when a command is run from a shell, the process
running the shell wants to know when the child process created to run the command has
terminated so that the command prompt can be shown to the user. Unix provides the system
calls wait() and waitpid() that can be used to check for the termination of the child process.

wait
#include <sys/wait.h>
pid_t wait(int *wstatus);

The wait system call blocks until any one of its child processes terminates. It returns the
process ID of the terminated child. If a child process has already terminated, wait will return
immediately. The termination status of that child is put in the memory location pointed to be
wstatus .

Example
In the following example, the parent process blocks when it calls wait and resumes its
execution only after the child process terminates:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main(){
pid_t spawnpid = -5;
int childStatus;
int childPid;
// If fork is successful, the value of spawnpid will be 0 in the child, the child's
pid in the parent
spawnpid = fork();
switch (spawnpid){
case -1:
perror("fork() failed!");
exit(1);
break;
case 0:
// spawnpid is 0 in the child
printf("I am the child. My pid = %d\n", getpid());
break;
default:
// spawnpid is the pid of the child

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-monitoring-child-processes?module_item_id=24111758 1/5
6/8/24, 1:59 PM Exploration: Process API - Monitoring Child Processes: OPERATING SYSTEMS I (CS_374_400_S2024)
printf("I am the parent. My pid = %d\n", getpid());
childPid = wait(&childStatus);
printf("Parent's waiting is done as the child with pid %d exited\n", childP
id);
break;
}
printf("The process with pid %d is returning from main\n", getpid());
return 0;
}

waitpid
The wait system call has a few limitations. If the parent process has created several children,
wait does not support waiting for the completion of a specific child, we wait for whichever child
that will terminate next. With the wait system call, there is also no possibility of doing a non-
blocking wait, i.e., if no child has terminated the parent process will block when it calls wait . It
is not possible for the parent process to just check the status of the child and continue to do
something else if it has not terminated. The waitpid system call addresses some of these
limitations of wait .

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);

The value of the argument pid determines which child process or child processes the waitpid
system call will wait for. The options for this value include (among others) the following options:

If the value of pid is greater than 0, then waitpid will wait for the child whose process ID
equals pid .
If the value of pid is -1, then waitpid will wait for any child process, similar to the wait
system call.

Example
In the following example, the parent process creates two child processes and then blocks until a
specific child (the second child) terminates. We have added a call to the function sleep()
(https://man7.org/linux/man-pages/man3/sleep.3.html) in the child processes which will cause
each of these processes to sleep for 10 seconds. This makes sure that the child processes have
not terminated before the parent process calls wait and we can verify that the parent process
is blocked until the second child has terminated.

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main(){
int childStatus;
printf("Parent process's pid = %d\n", getpid());
pid_t firstChild = fork();
if(firstChild == -1){
perror("fork() failed!");
exit(1);
} else if(firstChild == 0){
// The first child process execute this
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-monitoring-child-processes?module_item_id=24111758 2/5
6/8/24, 1:59 PM Exploration: Process API - Monitoring Child Processes: OPERATING SYSTEMS I (CS_374_400_S2024)
printf("First child's pid = %d\n", getpid());
sleep(10);
} else{
// Parent process executes this
// Fork another child
pid_t secondChild = fork();
if(secondChild == -1){
perror("fork() failed!");
exit(1);
} else if(secondChild == 0){
// The second child process execute this
printf("Second child's pid = %d\n", getpid());
sleep(10);
} else{
// Parent process executes this to
// wait for the second child
pid_t childPid = waitpid(secondChild, &childStatus, 0);
printf("The parent is done waiting. The pid of child that terminate
d is %d\n", childPid);
}
}
printf("The process with pid %d is returning from main\n", getpid());
return 0;
}

Non-blocking Wait Using WNOHANG

The options argument controls the behavior of waitpid . This argument is a bit mask that can
include the OR-ed value of 3 constants. Two of these constants, WUNTRACED and WCONTINUED are
non-standard and we will not discuss them further. The third flag is WNOHANG and specifying it
makes waitpid non-blocking, i.e., if WNOHANG flag is specified and no child process has
terminated, then waitpid will return immediately with the return value of 0,

Example
In the following example, the parent process creates a child process and then calls waitpid
with the option WNOHANG . However, the child process sleeps for 10 seconds. This means that
when the parent calls waitpid the child has not terminated. But because of the use of WNOHANG
the parent process is not blocked and it continues its execution.

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(){
printf("Parent process's pid = %d\n", getpid());

int childStatus;
pid_t childPid = fork();

if(childPid == -1){
perror("fork() failed!");
exit(1);
} else if(childPid == 0){
// Child process executes this branch
sleep(10);
} else{
// The parent process executes this branch
printf("Child's pid = %d\n", childPid);
// WNOHANG specified. If the child hasn't terminated, waitpid will immediat
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-monitoring-child-processes?module_item_id=24111758 3/5
6/8/24, 1:59 PM Exploration: Process API - Monitoring Child Processes: OPERATING SYSTEMS I (CS_374_400_S2024)
ely return with value 0
childPid = waitpid(childPid, &childStatus, WNOHANG);
printf("In the parent process waitpid returned value %d\n", childPid);
}
printf("The process with pid %d is returning from main\n", getpid());
return 0;
}

Interpreting the Termination Status

The functions wait and waitpid place the termination status of the child process that
terminated in the variable wstatus . The status value stored in this variable tells us whether the
child process terminated normally or abnormally, and additional information about the
termination. Specifically, we can get the following information from wstatus

Did the child terminate normally, by calling exit() ? Or did the child terminate abnormally?
In case of normal termination, we can find the value of the exit status
In case of abnormal termination, we can find the signal that caused the child to be
terminated.

However, the value of wstatus does not directly provide this information. To get this information,
we must decode wstatus by calling the following macros with the value placed in wstatus
variable:

Macro Description
This macro returns true if the child was terminated normally. Note that
WIFEXITED(wstatus)
exactly one of WIFEXITED and WIFSIGNALED will return true.
If WIFEXITED returned true, WEXITSTATUS will return the status value the
WEXITSTATUS(wstatus) child passed to exit() . Note that if WIFSIGNALED returned true,
WEXITSTATUS may return a garbage value.

This macro returns true if the child was terminated abnormally. Note that
WIFSIGNALED(wstatus)
exactly one of WIFEXITED and WIFSIGNALED will return true.

If WIFSIGNALED returned true, WTERMSIG will return the signal number that
WTERMSIG(wstatus) caused the child to terminate. Note that if WIFEXITED returned true,
WTERMSIGN may return a garbage value.

Example
In the following example, the parent process calls wait to wait for its child process to terminate.
Once the wait call returns, the parent process calls an if statement with WIFEXITED macro in the
condition to check if the process terminated normally. Since the child process terminated
normally, the if statement evaluates to true. The parent process then gets the return value from
the child by using the macro WEXITSTATUS .

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-monitoring-child-processes?module_item_id=24111758 4/5
6/8/24, 1:59 PM Exploration: Process API - Monitoring Child Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

int main(){
printf("Parent process's pid = %d\n", getpid());

int childStatus;
pid_t childPid = fork();

if(childPid == -1){
perror("fork() failed!");
exit(1);
} else if(childPid == 0){
// Child process
sleep(10);
} else{
printf("Child's pid = %d\n", childPid);
childPid = waitpid(childPid, &childStatus, 0);
printf("waitpid returned value %d\n", childPid);
if(WIFEXITED(childStatus)){
printf("Child %d exited normally with status %d\n", childPid, WEXIT
STATUS(childStatus));
} else{
printf("Child %d exited abnormally due to signal %d\n", childPid, W
TERMSIG(childStatus));
}
}
return 0;
}

Zombie Processes
If the parent of a process does not wait for a child to terminate, then the child becomes a
“zombie” process on termination. Most of the resources allocated to a zombie process are
recycled, e.g., its memory, open file descriptors, etc. However, an entry for a zombie process is
retained in the process table. If the parent process of a zombie later uses waitpid to check the
termination status of this child, then the zombie process is removed from the process table.

If a parent process terminates without cleaning its zombie child processes, then the zombies
become children of the init process. The init process periodically waits for all its terminated
children, including zombies and the zombies will get cleaned up by the init process.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

The Linux man pages give a good overview of wait and waitpid
(https://man7.org/linux/man-pages/man2/wait.2.html) .
Chapter 26 of the book The Linux Programming Interface discusses process monitoring.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-monitoring-child-processes?module_item_id=24111758 5/5
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Process API - Executing a

New Program
Introduction
The fork function creates a new process, but this child process still runs the same
program as the parent process. So how can we run a new program? To do this, we can use a
function from the exec family of functions which we will study in this exploration.

The exec Family of Functions

The exec family of functions provides a number of functions that can be used to replace a
running program with a new program we specify. A process can replace its current program by
calling one of the exec functions. This can be done in conjunction with fork if we want to run a
new program in the child process, or we can use these functions to replace the program even if
we have not created a new process. Calling an exec function does not change the process ID
of the calling process, but these functions replace the text, data, heap, and stack segments of
the currently running program.

Note: There is no function with the specific name exec . Instead, the name exec is used to
refer to the family of exec functions.

Here is the list of the exec family of functions.

#include <unistd.h>
int execl(const char *pathname, const char *arg, ... /* (char *) NULL */);
int execlp(const char *filename, const char *arg, ... /* (char *) NULL */);
int execle(const char *pathname, const char *arg, ... /*, (char *) NULL, char * const envp[]
*/);
int execv(const char *pathname, char *const argv[]);
int execvp(const char *filename, char *const argv[]);
int execve(const char *pathname, char *const argv[], char *const envp[]);

execv
We first look at execv, before looking at the other functions and the differences between them.

int execv(const char *pathname, char *const argv[]);

The function execv executes the file provided as the argument pathname . The file corresponding
to pathname must be either a binary executable, or an executable script. The value of pathname
can be absolute, e.g., /bin/myfile ) or relative, e.g., mydir/myfile .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 1/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)

The array argv is an array of strings that is passed as an argument to the new program. The first
element of this array, i.e., argv[0] , must be the same as pathname . The last element of argv
must be a null pointer.

Example
Suppose we want to run the command ls -al in a program without creating a new process. In
the following example, we use execv to do that. In the call to execv , we pass "/bin/ls" as the
pathname . We pass the following array as argv

{"/bin/ls", "-al", NULL};

The first element of the array is again the path to the program that should replace the existing
program. The second element is "-al" which is the argument we want to pass to the ls
command. The last element is a NULL.

When execv is called the program in the original process is replaced by the executable file
/bin/ls and the program /bin/ls is passed the argument -al

#include <stdio.h> // for perror

#include <stdlib.h> // for exit
#include <unistd.h> // for execv

int main(){
// Run /bin/ls and pass it the argument -al
char *newargv[] = { "/bin/ls", "-al", NULL };
execv(newargv[0], newargv);
/* exec returns only on error */
perror("execv");
exit(EXIT_FAILURE);
}

When an exec function fails

Note that an exec function returns to the program that it only on error. Let's use an example to
understand this concept.

Consider the following program gets compiled to an executable file called my_shell

#include <stdio.h> // for perror

#include <stdlib.h> // for exit
#include <unistd.h> // for execv

int main(){
// Run /bin/ls and pass it the argument -al
char *newargv[] = { "/bin/ls", "-al", NULL };
execv(newargv[0], newargv);
/* exec returns only on error */
perror("execv"); // This and the following statement will only be executed if execv retur
ns an error
exit(EXIT_FAILURE);
}

Let's suppose a process with PID 87 is running my_shell . This means the code segment of
process 87 is loaded with the executable file my_shell . When my_shell executes the statement
that calls execv() then
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 2/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)

If execv() succeeds, then the code segment of the process 87 is updated so that the
executable my_shell is replaced in memory by the executable for the program /bin/ls and
the process 87 executes the instructions of /bin/ls until that program exits and the process
terminates.
If execv()fails, the code segment of process 87 is still loaded with the executable for
my_shell . In this case, execv() returns a value back to my_shell . If this happens, then the
statements following the call to execv() in my_shell code are executed. These statement
print the error message and then the last statement calls the exit() function, at which point
the process terminates.

Using exec() with fork()

However, there are cases when we want the original program to keep running and want a child
process to run a new program. As an example, consider a shell. When a shell runs a command
entered by the user, it resumes its execution when that command ends. The shell then prompts
the user for another command and this cycle continues until the shell is terminated.

We can do this by using execv and fork as follows:

The parent process corresponds to the shell and displays a prompt to the user.
When the user enters a command, the parent process uses fork to create a child process.
The parent process then waits for the child to terminate.
This child process, which is a copy of the parent and thus is loaded with the shell program,
uses execv to replace the shell program with the program corresponding to the command
entered by the user.
When the command ends, the child process terminates.
When the child process terminates, the parent now loops back and again shows the prompt to
the user for entering the next command.

Example
In the following program, the parent process forks a child process and then waits for the
termination of this child. The child process uses execv to run the ls -al command. When the
child process terminates, the parent process resumes its execution.

#include <sys/wait.h> // for waitpid

#include <stdio.h> // for printf and perror
#include <stdlib.h> // for exit
#include <unistd.h> // for execv, getpid, fork

/*
The following program forks a child process. The child process then replaces
the program using execv to run "/bin/ls". The parent process waits for the
child process to terminate.
*/
int main(){
char *newargv[] = { "/bin/ls", "-al", NULL };
int childStatus;

// Fork a new process

pid_t spawnPid = fork();

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 3/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)
switch(spawnPid){
case -1:
perror("fork()\n");
exit(1);
break;
case 0:
// In the child process
printf("CHILD(%d) running ls command\n", getpid());
// Replace the current program with "/bin/ls"
execv(newargv[0], newargv);
// exec only returns if there is an error
perror("execve");
exit(2);
break;
default:
// In the parent process
// Wait for child's termination
spawnPid = waitpid(spawnPid, &childStatus, 0);
printf("PARENT(%d): child(%d) terminated. Exiting\n", getpid(), spawnPid);
exit(0);
break;
}
}

Other exec Functions

In addition to execv , Linux provides several other functions that can execute a new program but
differ in terms of how we specify the program name, the list of arguments and the environment of
the new program.

The differences between the functions are summarized in the following table:

Search for executable specified as Arguments as list Can pass new

Function the first argument in PATH or vector/array? environment as an
name environment variable? l -> list argument?
p at the end -> Yes v -> vector/array e at the end -> Yes
execl - List -
execle - List Yes
execlp Yes List -
execv - Array -
execve - Array Yes
execvp Yes Array -

The first difference is that the functions whose name ends with a p , i.e., execvp and execlp ,
take a filename as an argument and search the PATH environment variable for an executable with
this filename. As opposed to this, the other functions, i.e., execl, execv, execle and execve , are
provided with the pathname of the executable.

The second difference between the functions is how arguments for the new program are passed
to the function. This is indicated by the letter l for list or v for vector immediately after exec
in the names of the functions:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 4/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)

The l in the name indicates a list of arguments. execl functions require that each
argument that we want to pass to the new program should be provided as a separate
argument to the execl function. This list of arguments must be terminated by an argument
with NULL value. The functions execl, execlp and execle thus require a list of arguments.
The v in the name indicates a vector , i.e., an array, of arguments. execv functions require
that the arguments to be passed to the new program should be provided as an array of
strings terminated with a NULL element. The functions execv, execvp and execve thus
require an array of arguments.

The third difference between the functions is that the functions whose name ends in e , i.e.,
execle and execve , allow passing in a new list of environment variables to the new program. This
is provided via the last argument envp which is an array of strings which by convention have the
form key=value . Just like argv , the last element of envp must be a null pointer. The other four
functions, whose name does not end in e, run the new program with a copy of the existing
environment. (Environments are discussed in the next exploration).

Examples
execl

int execl(const char *pathname, const char *arg, ... /* (char *) NULL */);

The execl function takes the new program to run as the first argument. This is followed by the list
of command line arguments to be passed to the new program. This list has the new program to
run as the first argument and the last argument in the list is NULL.

The following example uses execl to run the ls program passing it the argument -al :

#include <stdio.h> // for perror

#include <stdlib.h> // for exit
#include <unistd.h> // for execv

int main(){
// Run /bin/ls and pass it the argument -al
execl("/bin/ls", "/bin/ls", "-al", NULL);
/* exec returns only on error */
perror("execl");
exit(EXIT_FAILURE);
}

The following example also uses execl to run ls -al but forks a child process to run this
command while the parent process waits for the termination of the child process:

#include <sys/wait.h> // for waitpid

#include <stdio.h> // for printf and perror
#include <stdlib.h> // for exit
#include <unistd.h> // for execv, getpid, fork

/*
The following program forks a child process. The child process then replaces
the program using execv to run "/bin/ls". The parent process waits for the
child process to terminate.
*/

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 5/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)
int main(){
int childStatus;

// Fork a new process

pid_t spawnPid = fork();

switch(spawnPid){
case -1:
perror("fork()\n");
exit(1);
break;
case 0:
// In the child process
printf("CHILD(%d) running ls command\n", getpid());
// Replace the current program with "/bin/ls"
execl("/bin/ls", "/bin/ls", "-al", NULL);
// exec only returns if there is an error
perror("execl");
exit(2);
break;
default:
// In the parent process
// Wait for child's termination
spawnPid = waitpid(spawnPid, &childStatus, 0);
printf("PARENT(%d): child(%d) terminated. Exiting\n", getpid(), spawnPid);
exit(0);
break;
}
}

execlp

int execlp(const char *filename, const char *arg, ... /* (char *) NULL */);

The execlp function differs from execl function in that the first argument is the name of the file
and execlp will search the PATH environment variable for the executable with this file name.

The following example uses execlp to run the ls program passing it the argument -al :

#include <stdio.h> // for perror

#include <stdlib.h> // for exit
#include <unistd.h> // for execlp

int main(){
// Run ls and pass it the argument -al
execlp("ls", "ls", "-al", NULL);
/* exec returns only on error */
perror("execlp");
exit(EXIT_FAILURE);
}

Note that the first argument to execlp is simply "ls" instead of "/bin/ls" which in the example
for execl was the first argument. This is because execlp finds ls by searching the path and we
do not need to specify the complete path as we had to do for execl .

execv
In all the previous exec examples, the new program we ran is the ls program. Now we look at
an example where a program uses exec to run an arbitrary program that is provided to it as an
argument.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 6/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)

Note: to view all the files in a repl.it, click the "Files" icon on the left-side of the repl.it.

In the following example, adapted from the Linux man pages (https://man7.org/linux/man-
pages/man2/execve.2.html) , the program execv_example.c uses execv to run a new program that
is provided to it as an argument. It passes the array newargv as arguments for the new program
to run.

If you hit the “run” button, the commands in the file .replit will be executed. The .replit file
syntax is specific to the Rep.it (https://repl.it/) website, but here is an explanation of what the
commands in this file are doing:

Compile myecho.c to the executable myecho

Compile execv_example.c to the executable execv_example
Run ./execv_example and give it the argument ./myecho

What happens when the program runs?

When execv_example runs, it uses exec to replace itself with the argument passed to it, i.e.,
the program ./myecho ,
This new program is passed the arguments in the array newargv
When any program is executed, its main() function gets called
In this case, the main function of myecho will get called.
As we see from the code in myecho.c , this main function simply prints out the arguments
passed to it.

#include <stdio.h>
#include <stdlib.h>

/*
* Just print out the arugments passed in argv
*/
int main(int argc, char *argv[]){
int j;

for (j = 0; j < argc; j++)

printf("argv[%d]: %s\n", j, argv[j]);

exit(EXIT_SUCCESS);
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[]){

char *newargv[] = { NULL, "hello", "world", NULL };

if (argc != 2) {
fprintf(stderr, "Usage: %s <file-to-exec>\n", argv[0]);
exit(EXIT_FAILURE);
}

// Put the name of the program being executed as element 0 of the arguments
// passed to the program to be run by execve
newargv[0] = argv[1];

// Now use execv to run this program

execv(argv[1], newargv);
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 7/8
6/8/24, 1:59 PM Exploration: Process API - Executing a New Program: OPERATING SYSTEMS I (CS_374_400_S2024)
perror("execv"); /* execve() returns only on error */
exit(EXIT_FAILURE);
}

Exercise
Using execv_example.c and myecho.c as models, write the following 2 programs:

hello_world_driver.c that
Prompts the user for their name
Uses execv to call hello_world.c and passes it the name entered by the user
hello_world.c that

Has a main function

Prints a “Hello” greeting to the string value that is specified as the first argument to the
main function

View the Solution (https://repl.it/@cs344/44helloworldexecc#hello_world_driver.c)

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

Chapter 27 of the book The Linux Programming Interface discusses the exec family of
functions.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-process-api-executing-a-new-program?module_item_id=24111759 8/8
6/8/24, 1:59 PM Exploration: Environment: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Environment
Introduction
Each process has an associated array of strings which is called the process’s
environment. In this exploration, we study process environment.

Environment & Environment Variables

As we just stated, the environment of a process consists of an array of strings. Each string in
this array is a text variable in the form of name=value . Each of these names is called an
environment variable. Collectively these names are called the environment variables. Note
that the interpretation of these variables is up to the program.

Environment variables and the shell

A shell typically has many environment variables. In a bash shell you can view the environment
variables for the shell process by using the command printenv . In the following figure, we see
an example of running this command from a bash shell (with some of the less interesting
environment variables removed from the output).

DISPLAY=:0
HOME=/Users/dmcgrath
LESS=-R
LOGNAME=dmcgrath
LSCOLORS=Gxfxcxdxbxegedabagacad
OLDPWD=/Users/dmcgrath/Documents/OSU Documents
PAGER=less
PATH=/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Applicati
ons/VMware Fusion.app/Contents/Public:/opt/X11/bin:/Library/Apple/usr/bin:/Users/dmcgrath/.
antigen/bundles/robbyrussell/oh-my-zsh/lib:/Users/dmcgrath/.antigen/bundles/robbyrussell/oh
-my-zsh/plugins/sudo:/Users/dmcgrath/.antigen/bundles/robbyrussell/oh-my-zsh/plugins/zsh-in
teractive-cd:/Users/dmcgrath/.antigen/bundles/zdharma/fast-syntax-highlighting:/Users/dmcgr
ath/.antigen/bundles/zsh-users/zsh-autosuggestions:/Users/dmcgrath/.antigen/bundles/greymd/
docker-zsh-completion:/Users/dmcgrath/.antigen/bundles/srijanshetty/zsh-pip-completion:/Use
rs/dmcgrath/.antigen/bundles/robbyrussell/oh-my-zsh/plugins/autojump:/Users/dmcgrath/.antig
en/bundles/robbyrussell/oh-my-zsh/plugins/git:/Users/dmcgrath/.antigen/bundles/robbyrussel
l/oh-my-zsh/plugins/docker:/Users/dmcgrath/.antigen/bundles/robbyrussell/oh-my-zsh/plugins/
tmuxinator:/Users/dmcgrath/.antigen/bundles/robbyrussell/oh-my-zsh/plugins/mosh:/Users/dmcg
rath/.antigen/bundles/robbyrussell/oh-my-zsh/plugins/extract:/Users/dmcgrath/.antigen/bundl
es/robbyrussell/oh-my-zsh/plugins/zsh_reload:/Users/dmcgrath/.antigen/bundles/psprint/zsnap
shot:/Users/dmcgrath/.antigen/bundles/ael-code/zsh-colored-man-pages:/Users/dmcgrath/.antig
en/bundles/unixorn/autoupdate-antigen.zshplugin:/Users/dmcgrath/.antigen/bundles/psprint/zs
napshot:/Users/dmcgrath/bin:/opt/010editor/
PWD=/Users/dmcgrath/Documents/OSU Documents/cs344
SHELL=/bin/zsh
SHLVL=1
SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.63nuZ4c4q9/Listeners
TERM=screen-256color
TMPDIR=/var/folders/pj/9z5x9d812dl9p649xhdmyz_h0000gn/T/
TMUX=/tmp//tmux-501/default,1984,20
TMUX_PANE=%30
TMUX_PLUGIN_MANAGER_PATH=/Users/dmcgrath/.tmux/plugins/

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-environment?module_item_id=24111760 1/4
6/8/24, 1:59 PM Exploration: Environment: OPERATING SYSTEMS I (CS_374_400_S2024)
USER=dmcgrath
ZSH=/Users/dmcgrath/.oh-my-zsh
LANG=en_US.UTF-8
_=/usr/bin/printenv

Here are some interesting environment variables shown in the above output:

PATH
The PATH variable contains a list of directories with the entries separated by a colon. When a
user enters a command on the shell, the shell searches these directories, in their order of
appearance in this variable, to find a program corresponding to this command. A PATH variable
entry with just a . means that the current directory will be searched for the command that the
user enters on the shell.
HOME
The HOME variable contains the pathname of the user’s login directory.
PWD
The PWD variable contains the pathname of the current working directory.

Setting & Unsetting Variables in Bash

Shells, including bash, allow updating the values of existing variable and setting the values of
new variables by using the export command. The unset command allows removing the value
of an environment variable.

Examples
1. We can set the value of a new or existing variable by using the export command. E.g., we
set the value of MYVAR to foo as follows:

export MYVAR=foo

2. An environment variable can be removed by unsetting it using the unset command as

follows:

unset MYVAR

3. We can access the value of an environment variable by using bash's echo command and
adding a $ before the name of the variable. E.g., to print the current value of the PATH variable,
we can use the following command:

echo $PATH

4. We can append something to the current value of a variable by getting the value by adding a
$ before the name to get the current value, follow this by the value we want to append to the
current value, and then using export to update the value. E.g., we can append . to the end of
the PATH variable as follows:

export PATH=$PATH:.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-environment?module_item_id=24111760 2/4
6/8/24, 1:59 PM Exploration: Environment: OPERATING SYSTEMS I (CS_374_400_S2024)

Getting and Setting Environment Variables in C Programs

C provides functions getenv , setenv , and unsetenv to manipulate environment variables.

getenv

#include <stdlib.h>
char *getenv(const char *name);

The function getenv looks for the environment variable name . If this variable is defined, the
function returns a pointer to its value. If this variable is not in the environment list, then NULL is
returned.

setenv

#include <stdlib.h>
int setenv(const char *name, const char *value, int overwrite);

The function setenv adds the variable name to the environment list with the value value . If the
environment variable name already exists, the behavior is determined by the argument
overwrite .

If overwrite is 0 and the variable name already exists, then the value is not changed.
If overwrite is non-zero and the variable name already exists, then the value is still
changed.

The function setenv creates copies of the strings name and value when adding them to the
environment.

unsetenv

#include <stdlib.h>
int unsetenv(const char *name);

The function unsetenv deletes the variable name from the environment list. If no variable name
exists in the environment, the function leaves the environment unchanged and still succeeds.

Environment Variables Across Parent and Child Process

When a parent process forks a child process, the child process inherits the environment of its
parent process. Thus, environment variables provide a way to transfer information from a parent
process to a child process. However, once a child process has been created, the parent and
child have their own environment. This means that changing the value of an environment
variable in the child process does not impact the environment of the parent process. Similarly,
changing the value of an environment variable in the parent process does not impact the
environment in the child process.

Example

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-environment?module_item_id=24111760 3/4
6/8/24, 1:59 PM Exploration: Environment: OPERATING SYSTEMS I (CS_374_400_S2024)

The following program shows an example of using setenv and getenv functions to add and
read environment variables, and highlights the fact that changing the environment variable in a
child process does not change that variable in its parent process.

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(){
int childStatus;
char* varName = "MYVAR";
// We set the value of MYVAR to foo in the parent process
setenv(varName, "foo", 1);

printf("%s in parent is %s\n", varName, getenv(varName));

pid_t spawnPid = fork();
switch(spawnPid){
case -1:
perror("fork() failed!");
exit(1);
break;
case 0:
// Child process
// The child inherits the environment from the parent, so the value of
// MYVAR is foo
printf("%s in child is %s\n", varName, getenv(varName));
// We set the value of MYVAR to bar in the child
setenv(varName, "bar", 1);
printf("%s in child has been updated to %s\n", varName, getenv(varName));
break;
default:
// Parent process
// Wait for the child to terminate
spawnPid = waitpid(spawnPid, &childStatus, 0);
// The value of MYVAR was set in the child, but that doesn't impact the
// value of this variable in the parent
printf("%s in parent is still %s\n", varName, getenv(varName));
break;
}
return 0;
}

Additional Resources
Chapter 7 of the book The Linux Programming Interface discusses process environment
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-environment?module_item_id=24111760 4/4
6/8/24, 1:59 PM Exploration: Shell Commands Related to Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Shell Commands Related to

Processes
Introduction
The Unix shell supports numerous commands that provide information and control
over processes. We look at some of the most useful commands in this exploration.

Using ps to Get Information About Current Processes

The ps command gives information about a selection of current processes in the system. The
selection of processes and the information displayed about these processes by ps depends on
the options and arguments provided to the command.

Basic ps
The basic ps command, without any options or arguments, displays the processes that are
running from the current terminals for the user who is logged in. The information displayed
includes the process ID in the PID column, and the command corresponding to the process in
the CMD column, as shown in the following example:

$ ps
PID TTY TIME CMD
19766 pts/18 00:00:00 bash
20096 pts/18 00:00:00 ps

Creating an Augmented Command for Process Information

However, ps supports many options and arguments to control both the selection of the
processes that will be displayed, and the information that will be shown about these processes.
We use the following augmented command that uses ps options and bash features to show us
more details about the current processes.

ps -o ppid,pid,pgid,sid,euser,stat,%cpu,rss,args | head -n 1; ps -eH -o ppid,pid,pgid,sid,e

user,stat,%cpu,rss,args | grep chaudhrn

We will not go into understanding the details of this command, but here are a few high-level
comments about the command:

The ; character separates commands. When the first command ends, the second will be run.
The | character is the pipe command. It sends the output of the command before the pipe to
the input of the command after the pipe. Or in other words, it redirects the standard output of
the command before the pipe to the standard input of the command after the pipe (we will
discuss Unix pipes in greater detail in a later module).
The augmented command is thus composed of the following two commands
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-shell-commands-related-to-processes?module_item_id=24111764 1/6
6/8/24, 1:59 PM Exploration: Shell Commands Related to Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

ps -o ppid,pid,pgid,sid,euser,stat,%cpu,rss,args | head -n 1
ps -eH -o ppid,pid,pgid,sid,euser,stat,%cpu,rss,args | grep chaudhrn
The first command
Runs ps and
The output is piped to the head -n 1 command which takes only the first row of ps
output, which is displayed as the header of augmented command
The second command
Runs ps with flags that show the parent-child hierarchy and other info and
The output is piped to the grep command to only show those rows that contain the
pattern chaudhrn
For reference, the column headers in the output of the augmented ps command are described
below:

Column Header Descripton

PPID Parent process ID
PID Process ID
PGID Process Group ID – relevant for jobs discussed in the next exploration
SID Session ID – relevant for jobs discussed in the next exploration
EUSER Effective User
STAT Process State
%CPU %age of CPU time this process occupies
RSS Real Set Size – kilobytes of RAM in use by this process
COMMAND The command corresponding to the process

The following video shows a detailed example of running this command and how to interpret the
output:

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-shell-commands-related-to-processes?module_item_id=24111764 2/6
6/8/24, 1:59 PM Exploration: Shell Commands Related to Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

Process State Information Displayed by ps

The state column has one or more characters. The first character is termed the Process State
Code and we list the important values from the man pages of ps

Interpreting State Information Displayed by ps

State according to the discussion of

Char Description
process states in Module 4
D uninterruptible sleep (usually IO) Waiting
R running or runnable (on run queue) Ready or Running
interruptible sleep (waiting for an event to
S Waiting
complete)
T stopped by job control signal Waiting
defunct ("zombie") process, terminated but
Z Zombie
not reaped by its parent

Additional characters in the state column give more detail about the process. We list the
important values from the man pages of ps

Char Description Notes

high-priority (not nice to other
<
users)
low-priority (nice to other
N The OS will prioritize giving CPU to other processes
users)
Termination of the session leader will terminate all the
s is a session leader
child processes
is in the foreground process
+
group

The following video shows an example of running our augmented ps command and interpreting
the state column of the output of the command.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-shell-commands-related-to-processes?module_item_id=24111764 3/6
6/8/24, 1:59 PM Exploration: Shell Commands Related to Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

In the video, we used the following program to create the zombie process. In this program, the
child process exits immediately. However, the parent process sleeps for 10 seconds before
waiting for the child. During these 10 seconds, the child process is in the Zombie state because
it has been terminated but its parent has not yet reaped it.

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(){
pid_t spawnpid = -5;
int childExitStatus;

spawnpid = fork();
switch (spawnpid){
case -1:
perror("fork() failed!");
exit(1);
break;
case 0:
printf("CHILD termination\n");
break;
default:
printf("PARENT: making child a zombie for 10 seconds");
fflush(stdout);
sleep(10);
spawnpid = waitpid(spawnpid, &childExitStatus, 0);
break;
}
}

Job Control
A job is a group of processes that share the same process group ID. Job Control is a feature of
Unix shells that allows us to start multiple jobs from a single terminal and control the access of

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-shell-commands-related-to-processes?module_item_id=24111764 4/6
6/8/24, 1:59 PM Exploration: Shell Commands Related to Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

these jobs to the terminal. If we use the pipe command to create a pipeline of processes, then
each of these processes has the same process group ID and hence belong to the same job.

Example

Running the command ps -eH -o ppid,pid,pgid,sid,euser,stat,%cpu,rss,args | grep chaudhrn

will create a job with two processes, one running the ps command and the other running the
grep command. However, if we run a command such as vi to edit a file, then the job consists

of just one process which is running the vi command.

Foreground and Background Jobs

At any given time, there can only one job running in the foreground while multiple jobs may be
running the background. The process or processes that are part of the foreground job can
freely interact with the terminal, whereas the jobs running in the background have limited access
to the terminal. Job control allows us to control whether a job runs in the foreground or the
background.

When we are at the command prompt, the foreground job consists of one process – the shell
itself. When the user enters a command at a shell that is intended to run in the foreground, i.e.,
a normal command, a process is started to run this command. This process runs to completion
before the user is prompted again. As opposed to this, when a user enters a command that is
intended to be run in the background, the user is immediately prompted again after the process
(or processes) in the command is started. In other words, a background job does not interrupt
the input to the terminal.

We start a job in the background by specifying an ampersand as the last character in the
command. E.g., the following command will run ping in the background:

$ ping oregonstate.edu &

Standard output and standard error of background jobs still goes to the terminal, i.e., if we run
the ping command in the background, its output will keep printing to the shell.

Commands related to Job Control

The jobs command

To see which jobs are running in a terminal, we can use the jobs command. This command
lists the jobs with a job number for each job. Using the -l option with the jobs commands
additionally displays the process ID for the processes in the jobs.

The fg and bg commands

The commands fg and bg allow us to manipulate jobs using the job number provided by the
jobs command. The fg command can bring a job from the background to the foreground. The

bg command can restart a specific background job that is currently stopped while keeping it in
the background.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-shell-commands-related-to-processes?module_item_id=24111764 5/6
6/8/24, 1:59 PM Exploration: Shell Commands Related to Processes: OPERATING SYSTEMS I (CS_374_400_S2024)

Stopping a job

We can stop the foreground job by entering Control-z on the command prompt. This stops the
job and puts it into the background. Control-z sends a TSTP signal to the job. We can also send
this signal using the kill command. E.g., the following command will stop the job with job number
1.

$ kill -TSTP %1

Example: Using job control commands

Additional Resources
Job control is discussed in Chapter 34 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-shell-commands-related-to-processes?module_item_id=24111764 6/6
6/8/24, 1:59 PM Exploration: Signals – Concepts and Types: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Signals – Concepts and

Types
Introduction
A signal is a mechanism for one process to notify another process of an event.
Signals are used by the OS kernel to notify processes, as well as by user processes to notify
other user processes. We discuss signals in this and the next exploration.

Basic Concepts
Signals are often termed software interrupts, as they interrupt the normal flow of control, i.e.,
the order in which individual statements are executed in the program of a process. Signals
cause the process to stop the current program and jump to execute the signal handler, which
is a function that is invoked whenever the signal corresponding to this handler is received by the
process. The OS provides default signal handlers for all signals. However, for most signals the
OS supports the capability to register custom signal handlers.

Example: Consider we are running the ping command from a shell. If we enter Control-Z on
this shell, a signal called SIGTSTP is sent to the process running the ping command. The
process will stop executing the ping program and instead will start executing the signal handler
function corresponding to SIGTSTP. If no custom signal handler has been registered for
SIGTSTP, the default signal handler will be executed. The default signal handler for SIGTSTP
stops the program currently running, i.e., ping , and returns control to the shell.

There are a fixed set of signals. This means that we cannot create our own signals. However,
we can control the programmatic response to, as well as the meaning of, most signals. As we
will see there are two signals that have no inherent meaning at all. These are provided so that
we can assign meaning to these signals.

Uses for Signals

Signals tell a process to do something – take an action because of a user command or an
event. Common uses of signals from the OS kernel to a user process include the following:

The process has done something wrong, e.g., made an invalid memory reference.
The process had set a timer which has now expired.
A child process has completed execution.
An event associated with the terminal has occurred, e.g., the user entered Control-Z.
The process was communicating with another process which has died.

Common uses of signals from one user process to another may include:

A process wants the other process to resume execution, suspend, or terminate.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signals-concepts-and-types?module_item_id=24111765 1/6
6/8/24, 1:59 PM Exploration: Signals – Concepts and Types: OPERATING SYSTEMS I (CS_374_400_S2024)

A process wants the other process to change its communication method, e.g., switch to a
different port from the one currently being used for communication.

Sending Signals from the Shell

We can use the kill command to send a signal to a process. The basic syntax of the command is
as follows:

kill -WXYZ PID

where

WXYZ is the name of the signal. If the name of the signal is omitted, the TERM signal will be
sent which terminates the process.
PID is the process ID of the process to which we want to send the signal. Note that if the
value of PID is 0 or negative, then it is interpreted differently and the details can be found in
the man pages (https://man7.org/linux/man-pages/man1/kill.1.html) .

Signal Types & Default Action

Note: you are not expected to memorize these details. Read this section to get a high-level
understanding of the functionality.

We now look at some of the most common or useful signals. We have grouped the signals
based on common functionality. Information about the signals is summarized in tables with more
detailed description given after the table. Here is a description of the table headers:

Signal
Name of the signal.
#
The POSIX standard specifies the signal number for certain signals. However, keep in mind
that for most signals the signal number is implementation dependent.
Easy name
An easy name to describe the signal.
Catchable
A signal is catchable if we can register a custom signal handler for it. Most signals are
catchable. The exceptions are SIGKILL and SIGSTOP
Default action if not caught
The default action that will be taken if we don’t register a custom signal handler for this signal.
Core Dump
When certain signals are received by a process, they cause the process to terminate
abnormally. An example is when a process makes an illegal memory reference that results in a
segmentation fault. When this happens, a file is created with dump of the memory which
contains the contents of all variables, hardware registers, the kernel process info at the time
the termination occurred. This file is called the core dump and can be used after the fact to

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signals-concepts-and-types?module_item_id=24111765 2/6
6/8/24, 1:59 PM Exploration: Signals – Concepts and Types: OPERATING SYSTEMS I (CS_374_400_S2024)

identify what went wrong. Depending on the configuration of a machine, core dump files can
be difficult to locate.

Signals Related to Process Termination

Signals Related to Process Termination

Signal # Easy name Catchable Default Action if not caught Core Dump
SIGABRT 6 Abort Yes Terminate Yes
SIGINT 2 Interrupt Yes Terminate No
SIGKILL 9 Kill No Terminate, not catchable No
SIGQUIT 3 Quit Yes Terminate Yes
SIGTERM 15 Terminate Yes Terminate No

SIGABRT

SIGABRT is sent to a process telling it to abort, i.e., terminate, itself. It is usually sent by a
process itself when it calls abort() which performs no cleanup unlike exit() .

SIGINT

SIGINT is sent by a terminal to the foreground process group when the user types the interrupt
character, which is usually Control-C.

SIGKILL

SIGKILL always terminates a process. It cannot be caught, blocked or ignored. It is handled

entirely by the kernel.

SIGQUIT

SIGQUIT is sent by a terminal to the foreground process group when the user types the quit
character, which is usually Control-\. This signal results in creating a dump file, unlike SIGINT.

SIGTERM

SIGTERM is sent to terminate a process, but it is catchable unlike SIGKILL. This means that
SIGTERM allows the process to perform cleanup. It is thus preferable to terminate a process
using SIGTERM as opposed to SIGKILL.

Signals Notifying of Errors

Signals Notifying of Errors

Signal # Easy name Catchable Default Action if not caught Core Dump
SIGBUS - Bus Error Yes Terminate Yes
SIGFPE 8 Floating Point Error Yes Terminate Yes
SIGILL 4 Illegal Instruction Yes Terminate Yes
SIGPIPE 13 Pipe Yes Terminate Yes
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signals-concepts-and-types?module_item_id=24111765 3/6
6/8/24, 1:59 PM Exploration: Signals – Concepts and Types: OPERATING SYSTEMS I (CS_374_400_S2024)

Signal # Easy name Catchable Default Action if not caught Core Dump
SIGSEV 11 Segmentation Fault Yes Terminate Yes
SIGSYS - System Call Yes Terminate Yes

SIGBUS

SIGBUS is used to indicate some memory-access errors, such as a process trying to access
non-existent physical address.

SIGFPE

SIGFPE is sent when a process executes an erroneous arithmetic operation such as divide-by-
zero. This signal can be sent for floating-point operations as well as for integer operations, even
though the letters FPE stands for Floating Point Error.

SIGILL

SIGILL is sent when a process attempts an illegal hardware instruction, e.g., malformed or
unknown.

SIGPIPE

SIGPIPE is sent when a process writes to a pipe but there is no reader at the other end of the
pipe.

SIGSEV

SIGSEV is sent when a process makes an illegal memory reference. This is usually the result of
a programming bug, such as dereferencing a pointer that has not been initialized.

SIGSYS

SIGSYS is sent when a process passes incompatible argument to a system call. It is rare to
encounter this because we typically use libraries that make system calls.

Signals Related to Control

Signals Related to Control

Signal # Easy name Catchable Default Action if not caught Core Dump
SIGALARM 14 Alarm Yes Terminate No
SIGCONT Continue Yes Continue -
SIGHUP 1 Hang up Yes Terminate No
SIGSTOP Stop No Stop, not catchable -
SIGTSTP Terminal Stop Yes Stop -
SIGTRAP 5 Trap Yes Terminate No

SIGALARM

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signals-concepts-and-types?module_item_id=24111765 4/6
6/8/24, 1:59 PM Exploration: Signals – Concepts and Types: OPERATING SYSTEMS I (CS_374_400_S2024)

SIGALARM is sent to a process when a timer that the process had set by calling the alarm()
function has expired. It is usually sent and caught to execute actions at a specific time.

SIGCONT

If SIGCONT is sent to a process that is currently stopped, the process will move to the runnable
state. If the process is not currently stopped, the signal is ignored.

SIGHUP

SIGHUP is sent to a process when its controlling terminal disconnects.

SIGSTOP

SIGSTOP stops a process. It is not catchable by a handler and cannot be blocked or ignored.

SIGTSTP

SIGTSTP is issued at a terminal to stop the process group currently running in the foreground. It
is commonly sent by typing Control-Z on the terminal.

SIGTRAP

SIGTRAP is sent when a trap occurs for debugging, e.g., the value of a variable changes, or a
function starts. It is used by debuggers to implement breakpoints.

SIGCHLD
SIGCHLD

Signal # Easy name Catchable Default Action if not caught Core Dump
SIGCHLD Child Terminated Yes None -

SIGHLD is sent by the kernel to a process when a child process of this process has terminated
or stopped or resumed its execution. Normally, wait() and waitpid() will suspend a process
until one of its child processes has terminated. Using the signal SIGCHLD allows a parent
process to do other work instead of going to sleep and be notified via signal when a child
terminates. Then, when SIGCHLD is received, the process can (immediately or later) call
wait() or waitpid() when ready, perhaps leaving the child a zombie for just a little while.

Signals for Programmer Use

Signals for Programmer Use

Signal # Easy name Catchable Default Action if not caught Core Dump
SIGUSR1 User 1 Yes Terminate No
SIGUSR2 User 2 Yes Terminate No

Both signals have no meaning to the kernel. These signals are provided for custom use of the
programmer. The interpretation of these 2 signals is up to the programmers who have code the

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signals-concepts-and-types?module_item_id=24111765 5/6
6/8/24, 1:59 PM Exploration: Signals – Concepts and Types: OPERATING SYSTEMS I (CS_374_400_S2024)

sending and receiving process. The kernel never sends these signals.

Additional Resources
A very good overview of signals is provided in the Linux manpages
(https://man7.org/linux/man-pages/man7/signal.7.html)
Basic concepts about signals are discussed in Chapter 20 of The Linux Programming
Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signals-concepts-and-types?module_item_id=24111765 6/6
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Signal Handling API

Introduction
When a process is notified to of a signal, the default action listed in the previous
exploration will happen. However, if the signal is catchable, we can assign our own custom
defined signal handler function to override the default action. In this exploration, we will learn
how to program custom signal handlers. We will also study some utility functions that are
relevant to signals.

Signal Sets
Many times, we want to customize signal-related functionality for a group of signals, e.g., we
may want to ignore a set of signals. A signal set is a list of signal types which is defined using
the special type sigset_t defined in signal.h . Many utility functions are also provided to
manipulate signals sets which we describe below:

sigset_t my_signal_set;

Declare a signal set named my_signal_set

int sigemptyset(&my_signal_set);

Initialize or reset the signal set my_signal_test to empty, i.e., contain no signal types
Returns 0 on success and -1 on error.

int sigfillset(&my_signal_set);

Initialize or reset the signal set my_signal_test to have all signal types.
Returns 0 on success and -1 on error.

int sigaddset(&my_signal_set, signal);

Add a single signal type to the set my_signal_test

Returns 0 on success and -1 on error.
E.g., sigaddset(&my_signal_set, SIGINT) will add SIGINT signal type to my_signal_set .

int sigdelset(&my_signal_set, signal);

Remove a single signal type from the set my_signal_test

Returns 0 on success and -1 on error.

Handling Signals: sigaction() function & sigaction structure

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 1/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

We can register signal handling functions using the sigaction() function some of whose
parameters are variables of the structure sigaction . Yes, it is somewhat confusing that the
function and the structure share the same name!

sigaction()

#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

The function sigaction() registers a signal handling function that a programmer has created for
a specified set of signals. It has three parameters:

The first parameter signum is the signal type for which we are registering the handler. It can
be any valid signal except SIGKILL and SIGSTOP, which as you may recall cannot be
caught.
The second parameter is a pointer to a data-filled sigaction struct which describes the
action to be taken upon receipt of the signal given in the first parameter
The third parameter can be null or it can be a pointer to another sigaction struct. If it is not
null, then the sigaction() function will write to this structure the handling settings for this
signal before this change was requested.

The sigaction structure

Let us now look at the sigaction structure and its attributes.

struct sigaction {
void (*sa_handler)(int);
sigset_t sa_mask;
int sa_flags;
void (*sa_sigaction)(int, siginfo_t*, void*);
};

sa_handler

The first attribute is named sa_handler . It is a pointer to the function which we want to be
invoked to handle this signal, i.e., the signal handler function. We had discussed pointers to
functions in an earlier module, but let us examine the type of this attribute:

The * in front of the name sa_handler , and the parentheses around it, indicate that this is a
pointer to a function.
The void indicates that the signal handler function does not return anything.
The int indicates that the signal handler function must take exactly one parameter whose
type is integer.
This integer parameter will hold the signal number when the signal handler is called. This is
important because multiple signals may be registered with a struct. The only way to tell the
signal handler function which signal caused it to start is via this integer parameter.

Instead of passing the a pointer to a function defined by us, we can also pass one of the
following two constants as the value of sa_handler

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 2/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

SIG_DFL – specifying this value means we want the default action to be taken for the signal
type.
SIG_IGN – specifying this value means that the signal type should be ignored

sa_mask

The sa_mask attribute is of type sigset_t . It contains a set of signals which should be blocked
while the signal handler is executing. Blocking means that the signals arriving during the
execution of sa_handler are held until the signal handler is done executing. At this point the
signals will be delivered in order to the process. Note that multiple signals of the same type
arriving while the signal type is blocked may be combined, so we cannot use this to count how
many occurrences of a signal type occurred during this period.

sa_flags

The third attribute of the sigaction struct provides additional instructions (flags):

SA_RESTHAND – this flag resets the signal handler to SIG_DFL (default action) after the
first signal has been received and handled
SA_SIGINFO – this flag tells the kernel to call the function specified in the fourth attribute,
i.e., sa_sigaction , instead of the function specified in the first attribute, i.e., sa_handler .
More detailed information can be passed to this function specified as the argument
sa_sigaction , as you can see by the additional arguments for this function.
Set to 0 - if we aren't planning to set any flags

sa_sigaction

The fourth attribute, sa_sigaction , specifies an alternative signal handler function to be called.
Most of the time you will use sa_handler and not sa_sigaction , so we will not discuss this
further.

Using pause() to Wait for Signals

If a process has nothing to do, we can call sleep() to suspend its execution. However, a
process which is sleeping cannot respond to signals. If we want to suspend execution of a
process until it is interrupted by a signal, we can use the pause() function.

#include <unistd.h>
int pause(void)

When a process is suspended after calling pause() and it receives a signal, one of the following
actions takes place

If the signal is set to be ignored, then pause() continues to be in effect

If a signal causes a termination, then the process dies
If a signal is caught, the appropriate signal handler function will be called.
After the signal handler function is done, pause() returns -1 and the process resumes
execution.
If the process wanted to pause again, then it can call pause() again.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 3/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

Examples: Catching & Ignoring Signals

We will now use the signal handling API to incrementally build up a C program that illustrates
the concepts discussed in this exploration.

Example: No custom signal handler

The following program prints some information then calls pause() . When we send it the signal
SIGINT by entering Control-C from the shell, the default signal handler is called and the process
terminates.

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

int main(){
printf("Send the signal SIGINT to this process by entering Control-C\n");
fflush(stdout);
pause();
// When Control-C is entered, the process will terminate due to the default
// signal handler. The following line will not be printed
printf("pause() ended. The process will now end.\n");
return 0;
}

Example: Custom Handler for SIGINT

Now we augment our program with a signal handler for SIGINT. The name of the handler
function is handle_SIGNIT() . When the handler is called it outputs a message, sleeps for 10
seconds and then returns. If we send SIGINT to this program while it is executing pause()

When SIGINT signal is received, pause() will end

However SIGINT does not terminate this process, which is the default behavior when a
process receives SIGINT
This happens because instead of the default handler, this program has registered the
function handle_SIGINT() as the custom handler for SIGINT
The function handle_SIGINT() prints a message and then sleeps for 10 seconds
When handle_SIGINT() finishes its execution, then the next statement in the program
immediately after pause() is executed

#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

/* Our signal handler for SIGINT */

void handle_SIGINT(int signo){
char* message = "Caught SIGINT, sleeping for 10 seconds\n";
// We are using write rather than printf
write(STDOUT_FILENO, message, 39);
sleep(10);
}

int main(){
// Initialize SIGINT_action struct to be empty

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 4/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)
struct sigaction SIGINT_action = {0};

// Fill out the SIGINT_action struct

// Register handle_SIGINT as the signal handler
SIGINT_action.sa_handler = handle_SIGINT;
// Block all catchable signals while handle_SIGINT is running
sigfillset(&SIGINT_action.sa_mask);
// No flags set
SIGINT_action.sa_flags = 0;

// Install our signal handler

sigaction(SIGINT, &SIGINT_action, NULL);

printf("Send the signal SIGINT to this process by entering Control-C. That will cau
se the signal handler to be invoked\n");
fflush(stdout);

// Calling pause() causes the process to sleep until it is sent a signal.

// Enter Control-C to end pause
pause();
// If pause is ended by SIGINT, then after handle_SIGINT ends, the execution
// proceeds with the following statement.
printf("pause() ended. The process will now end.\n");
return 0;
}

Example: Custom Handlers for SIGINT, SIGUSR2, and Ignoring SIGTERM, etc.
In the next version of the program we do the following:

We register a signal handler for SIGINT that sleeps for 10 seconds and then raises
SIGUSR2
We register a signal handler for SIGUSR2 that terminates the program
We register the SIG_IGN constant as the handler for SIGTERM, SIGHUP and SIGQUIT.
This means that these 3 signals will be ignored by this program.

Note: the code is in the file signalexample.c. You can view the list of files by clicking the "Files"
icon on the left-hand side of the replit. Then click on signalexample.c to view the code.

#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

// Handler for SIGNINT

void handle_SIGINT(int signo){
char* message = "Caught SIGINT, sleeping for 10 seconds\n";
write(STDOUT_FILENO, message, 39);
// Raise SIGUSR2. However, since this signal is blocked until handle_SIGNIT
// finishes, it will be delivered only when handle_SIGINT finishes
raise(SIGUSR2);
// Sleep for 10 seconds
sleep(10);
}

// Handler for SIGUSR2

void handle_SIGUSR2(int signo){
char* message = "Caught SIGUSR2, exiting!\n";
write(STDOUT_FILENO, message, 25);
exit(0);
}

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 5/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)
int main(){
struct sigaction SIGINT_action = {0}, SIGUSR2_action = {0}, ignore_action = {0};

// Fill out the SIGINT_action struct

// Register handle_SIGINT as the signal handler
SIGINT_action.sa_handler = handle_SIGINT;
// Block all catchable signals while handle_SIGINT is running
sigfillset(&SIGINT_action.sa_mask);
// No flags set
SIGINT_action.sa_flags = 0;
sigaction(SIGINT, &SIGINT_action, NULL);

// Fill out the SIGUSR2_action struct

// Register handle_SIGUSR2 as the signal handler
SIGUSR2_action.sa_handler = handle_SIGUSR2;
// Block all catchable signals while handle_SIGUSR2 is running
sigfillset(&SIGUSR2_action.sa_mask);
// No flags set
SIGUSR2_action.sa_flags = 0;
sigaction(SIGUSR2, &SIGUSR2_action, NULL);

// The ignore_action struct as SIG_IGN as its signal handler

ignore_action.sa_handler = SIG_IGN;

// Register the ignore_action as the handler for SIGTERM, SIGHUP, SIGQUIT.

// So all three of these signals will be ignored.
sigaction(SIGTERM, &ignore_action, NULL);
sigaction(SIGHUP, &ignore_action, NULL);
sigaction(SIGQUIT, &ignore_action, NULL);

pid_t pid = getpid();

printf("This process PID is %d\n", pid);
printf("Send signals to the process using the kill command, e.g., kill -SIGTERM %d
\n", pid);
printf("SIGTERM, SIGHUP, and SIGQUIT are disabled, so will be ignored.\n");
printf("SIGUSR2 signal will kill this program.\n");
printf("SIGINT signal will cause the program to sleep 10 seconds, then will then ki
ll this program by raising SIGUSR2.\n");

while(1)
pause();
return 0;
}

If you click the “run,” button, the program is compiled to an executable names signalexample.
Now execute this program in the background by issuing the following command on the
command prompt in repl.it

$ ./signalexample &

You can now observe the behavior of the program by sending it various signals by following the
directions printed by the program.

Reentrant Functions
In the above programs where we registered custom signal handlers, you may have noticed that
in the code of the signal handler we used the write function instead of using printf . The
reason for this is that write is a reentrant function while printf is non-reentrant. Let us
explain this concept.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 6/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

A signal interrupts the sequence of instructions that the process is executing. The instructions in
the signal handler will be executed. Then, if the signal handler does not terminate the process,
the sequence of instructions for the process will be resumed.

But what if the process was interrupted while it was executing a function that uses a global data
structure and the signal handler calls the same function as well? The call by the signal handler
can change the state of the global data structure in such a way that when the process’s
instructions are resumed, the function that had been interrupted fails on resumption due to the
change in that global data structure.

Because of this reason, we have to be careful about which functions we call in a signal handler.
Functions that are safe to use in a signal handler are called reentrant. A reentrant function
achieves its functionality even if its execution is interrupted and a signal handler executes the
same function. Functions that use local variables are guaranteed to be reentrant.

printf and other members of the standard I/O library use some global data structures in such a
way that they are not reentrant. Therefore, in signal handlers we use the write function
because it is reentrant.

write()

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);

write() writes up to count bytes from the buffer buf to the file referred to by the file descriptor
fd . On success this function returns the number of bytes it has written. On error, it returns -1.

One scenario in which write may write fewer than count bytes is when it is interrupted by a
signal handler. If it is interrupted before it has written any bytes, it falls with the error EINTR.
However, if it has written at least one byte, it succeeds and returns the number of bytes it has
written.

In our example program, you may have noticed that the call to write gave the value of count as
an integer rather than using strlen to get the length of the string we want to write. For
example, the code is:

char* message = "Caught SIGUSR2, exiting!\n";

write(STDOUT_FILENO, message, 26);

rather than

char* message = "Caught SIGUSR2, exiting!\n";

write(STDOUT_FILENO, message, strlen(message));

The reason? Like printf , strlen is also a non-reentrant function and thus should not be used
in a signal handler!

Signals and Interrupted Functions

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 7/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

A signal interrupts the sequence of instructions that the process is executing. The instructions in
the signal handler will be executed. Then, if the signal handler does not terminate the process,
the sequence of instructions for the process will be resumed.

When certain system calls, or library functions that use these system calls, are interrupted by a
signal, they return an error. An example of this is the function getline() which returns an error
if it is interrupted by a signal. Here are two ways to address this issue.

Use SA _RESTART Flag in the Signal Handler

The easier solution is using SA_RESTART flag in the signal handler. We do this by setting the
sa_flags variable in sigaction struct to SA_RESTART as in the following example:

SIGTSTP_action.sa_flags = SA_RESTART;

Setting this flag will cause an automatic restart of the interrupted system call or library function
after the signal handler gets done.

Check for an error and clear it using clearerr

If we don't set automatic restart, then the system call or library function will return an error. We
will need to check for the error and reset the stream the system call is reading from.

Example
The following code checks for errors from getline() when it is reading from stdin and resets
the status of stdin in case of errors.

int numChars= getline(&userInput, &bufferSize, stdin);

if (numChars == -1)
{
clearerr(stdin); // reset stdin status
}
else
{ // process the input
...
}

For more details see the man pages for clearerr (https://man7.org/linux/man-
pages/man3/clearerr.3.html) .

Child Processes and Inheritance of Signals

When calling fork() , child processes inherit and get their own instance of the signal handler
functions declared in the parent . These signal handlers are automatically assigned to the same
signals as the parent.

However, calling any of the exec() family of functions in a process removes any special signal
handler function assigned to sa_handler or sa_sigaction previously! The exception is
that SIG_DFL and SIG_IGN are preserved through an exec() .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 8/9
6/8/24, 2:00 PM Exploration: Signal Handling API: OPERATING SYSTEMS I (CS_374_400_S2024)

This means that if we use exec() to run programs we didn't write (e.g., ls , or other bash
commands), we cannot set up arbitrary signal handlers for these programs. The only way to
customize signal handling for such programs to use SIG_IGN to tell these programs to ignore
particular signals.

Additional Resources
The signal handling API is discussed in Chapter 21 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-signal-handling-api?module_item_id=24111766 9/9
6/8/24, 2:00 PM Exploration: Processes and I/O: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Processes and I/O

Introduction
In this exploration, we look at a few topics related to Unix I/O functionality,
particularly the relationship of file descriptors across parent and child processes, and how to
redirect standard input and output of processes.

fork, exec and File Descriptor Inheritance

When a process uses fork() to spawn a child process, the child inherits the open file
descriptors of the parent process. Each child process has the same files open as its parent.
Furthermore, functions that read and write to these shared file descriptors move the same file
pointer inside the file when called from the child process or the parent process. This sharing of
file descriptors is also maintained if the child process now calls an exec function to run a
different program.

Example
In the following program, the parent process opens a file and writes to it. It then spawns a child
process and waits for it. The child process inherits the open file descriptor and the file pointer.
As the child process writes to the file the file pointer moves. When the child terminates, the
position of the file pointer in the parent reflects the updated value due to the write done by the
child process.

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

int main(){
// Parent opens a file
char *newFilePath = "./newFile.txt";
printf("PARENT: Opening file %s.\n", newFilePath);
int fileDescriptor = open(newFilePath, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUS
R);
if (fileDescriptor == -1) {
printf("open() failed on \"%s\"\n", newFilePath);
exit(1);
}

// Parent writes to a file

printf("PARENT: Writing 01234 to file.\n");
write(fileDescriptor, "01234", 5);
// We use lseek to get the current position of the file pointer
printf("PARENT: FP position (FP positions are zero-indexed): %ld\n", lseek(fileDesc
riptor, 0, SEEK_CUR));
// Flush the standard output to make sure it shows up on the terminal
fflush(stdout);
printf("PARENT: Spawning child.\n");
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-processes-and-i-slash-o?module_item_id=24111767 1/5
6/8/24, 2:00 PM Exploration: Processes and I/O: OPERATING SYSTEMS I (CS_374_400_S2024)

// Spawn the child process

int childExitMethod;
pid_t spwanPID = fork();

switch (spwanPID){
case -1:
perror("fork() failed\n");
exit(1);
break;
case 0:
printf("CHILD: started. FP position: %ld\n", lseek(fileDescriptor, 0, SEEK_
CUR));
printf("CHILD: Writing AB to file.\n");
fflush(stdout);
write(fileDescriptor, "AB", 2);
printf("CHILD: After write, new FP position: %ld\n", lseek(fileDescriptor,
0, SEEK_CUR));
fflush(stdout);
default:
// Wait for the child
waitpid(spwanPID, &childExitMethod, 0);
printf("PARENT: child terminated, FP position is: %ld\n", lseek(fileDescrip
tor, 0, SEEK_CUR));
//fflush(stdout);
break;
}
return 0;
}

In many cases this sharing is desirable. For example, consider we enter a command, such as
ls , on the shell. The shell spawns a child process to run ls . The output of ls gets written to
the standard output and it advances the file pointer. When the child process ends, the shell
which is waiting for this child resumes and writes something to standard output. Since the child
process running the ls program and the parent process running the shell program share the
same file pointer, this means that when the child process ends, the file pointer for standard
output in the parent process has also been advanced. The writes by the parent process to the
standard output do not intermix with what had been written by the child process.

If we want to prevent this sharing, then we can have one of the parent or the child close the file
and then re-open it to allocate a new file descriptor. Now read and writes by the parent and child
processes will move different file pointers.

Redirecting Input and Output

When a new process is created, the OS automatically opens stdin , stdout , and stderr for
the process as follows:

stdin: File descriptor is 0. Defaults to reading from the terminal.

stdout: File descriptor is 1. Defaults to writing to the terminal.
stderr: File descriptor is 2. Defaults to writing to the terminal.

In a previous module, we discussed how to do input and output redirection when using the shell.
Let us now look at how we can do such redirection programmatically using the dup2 function.

dup2()
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-processes-and-i-slash-o?module_item_id=24111767 2/5
6/8/24, 2:00 PM Exploration: Processes and I/O: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <unistd.h>
int dup2(int oldfd, int newfd);

The dup2() system calls duplicates a file descriptor. If it executes successfully, then newfd will
point to a copy of oldfd . The two file descriptors can be used interchangeably and share the
same file pointer. If the newfd was previously open it will be automatically closed. If it successful
it returns the new file descriptor, otherwise it returns -1.

Using dup2 for Redirection

Example: Output Redirection

Let us see an example of how we can redirect standard output using dup2 . In the following
program, we first open the file whose name is provided as an argument to our program and
store the open file descriptor for this file in the variable targetFD . We then use dup2 to point
file descriptor 1, i.e., standard out, to targetFD . After we have done this, whatever the program
writes to standard out, will get written to the file.

For example, if we run the program as follows

./main foo.txt

then the printf statement executed after the call to dup2 will write its ouput to the file foo.txt.
You can view the contents of this file by running the cat command, e.g.,

cat foo.txt

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char* argv[]){

if (argc == 1){
printf("Usage: ./main <filename to redirect stdout to>\n");
exit(1);
}

int targetFD = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0640);

if (targetFD == -1) {
perror("open()");
exit(1);
}
// Currently printf writes to the terminal
printf("The file descriptor for targetFD is %d\n", targetFD);

// Use dup2 to point FD 1, i.e., standard output to targetFD

int result = dup2(targetFD, 1);
if (result == -1) {
perror("dup2");
exit(2);
}
// Now whatever we write to standard out will be written to targetFD
printf("All of this is being written to the file using printf\n");
return(0);
}

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-processes-and-i-slash-o?module_item_id=24111767 3/5
6/8/24, 2:00 PM Exploration: Processes and I/O: OPERATING SYSTEMS I (CS_374_400_S2024)

Example: Redirecting both Stdin and Stdout

In the following example, we redirect standard input to read from a file and standard out to write
to a file. The program itself uses execlp() to run the shell command sort
(https://www.man7.org/linux/man-pages/man1/sort.1.html) . The program will thus sort the input
file and write the sorted contents to the output file.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char* argv[]){

if (argc != 3) {
printf("Usage: ./main <input filename> <output filename>\n");
exit(1);
}
// Open source file
int sourceFD = open(argv[1], O_RDONLY);
if (sourceFD == -1) {
perror("source open()");
exit(1);
}
// Written to terminal
printf("sourceFD == %d\n", sourceFD);

// Redirect stdin to source file

int result = dup2(sourceFD, 0);
if (result == -1) {
perror("source dup2()");
exit(2);
}

// Open target file

int targetFD = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (targetFD == -1) {
perror("target open()");
exit(1);
}
printf("targetFD == %d\n", targetFD); // Written to terminal

// Redirect stdout to target file

result = dup2(targetFD, 1);
if (result == -1) {
perror("target dup2()");
exit(2);
}
// Run the sort program using execlp.
// The stdin and stdout are pointing to files
execlp("sort", "sort", NULL);
return(0);
}

On os1, you can test the program by running the following commands:

echo -e "shrimps\nlobsters\noyesters" > inputfile.txt

cat inputfile.txt
./main inputfile.txt outputfile.txt
cat outputfile.txt

The first command creates a file inputfile.txt and writes each of the 3 words in a row by itself.
Running our program reads the contents of the input file, passes it to the sort command, and

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-processes-and-i-slash-o?module_item_id=24111767 4/5
6/8/24, 2:00 PM Exploration: Processes and I/O: OPERATING SYSTEMS I (CS_374_400_S2024)

results in the words being written to outputfile.txt in alphabetical order.

Our C program thus runs the equivalent of the following shell command:

sort < inputfile.txt > outputfile.txt

Close File Descriptor On Exec

There can be cases where a parent process does not want to share an open file with a child
process that may later execute another program. Perhaps a file contains secure or sensitive
data that must not be shared with the new program. The function fcntl allows us to change the
properties of a file that is already open and can be used to prevent such sharing.

#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* int arg */ );

Using fcntl we can set a flag FD_CLOEXEC on a file-by-file basis. This flag is inherited through
fork. So if a parent uses fcntl to set this flag on a file, a child that later calls an exec function
will trigger the close on exec flag and the corresponding file descriptor will be closed. Sample
code that uses this feature might look like the following:

#include
...
int fd;
fd = open("file", O_RDONLY);
…
fcntl(fd, F_SETFD, FD_CLOEXEC);
// Now whenever this process or one of its child processes calls exec, the file descriptor
fd will be closed in that process

Additional Resources
The system call dup2() and its use are discussed in Chapters 4 and 5, while close-on-exec
is discussed in Chapter 18 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-processes-and-i-slash-o?module_item_id=24111767 5/5
6/8/24, 2:00 PM Review - Module 3: OPERATING SYSTEMS I (CS_374_400_S2024)

Review - Module 3
Key Take-Aways
At this point, you should be able to answer all of the following questions.

What is a process and what are the different states it can go through?
What is a parent process and a child process?
What does the fork system call do? How can you use it to create new processes?
What happens when a process calls the exit function?
How can a parent process wait for a child process? What do wait and waitpid functions do?
How can a new program be executed?
What do the functions in the exec family of functions accomplish?
What is the environment of a process?
How can the environment variables be accessed or modified when using the bash shell?
How can the environment variables be accessed or modified in C programs?
What is the relationship between the environment of a parent process and a child process?
How to use the ps command to get information on currently running processes?
How to manipulate foreground and background jobs from the shell?
What is a signal and what is a signal handler?
What are the different uses of signals?
How can you send a signal from the command line?
How can your write custom signal handlers?
How can you block signal in your C programs?
How are file descriptors inherited by a child process?
What is the use of the dup2() system call?
How can you redirect standard input and/or standard output?
How can you force an open file to automatically close whenever a process uses an exec
function to run a new program?

Check the Explorations and Task List in the Module 3 - Overview

(https://canvas.oregonstate.edu/courses/1971495/pages/module-3-overview) to review learning
materials and make sure you have completed all required activities for this module.

(https://canvas.oregonstate.edu/courses/1971495/modules)

https://canvas.oregonstate.edu/courses/1971495/pages/review-module-3-2?module_item_id=24111761 1/1
6/8/24, 2:00 PM Module 4 - Overview: OPERATING SYSTEMS I (CS_374_400_S2024)

Module 4 - Overview

Introduction
In this module, we look at multi-programming and possible issues related to concurrent
execution of multiple processes. We then introduce the thread abstraction and contrast it with
the process abstraction. We then study Unix APIs for safe execution of concurrent threads.

Module Learning Outcomes

1. Explain the concepts and motivation for multiprogramming and multiprocessing
(CLO 1)
What is multiprogramming?
What is multiprocessing?
What function does an OS scheduler perform and how is this role relevant to
multiprogramming and multiprocessing?
2. Explain important terms related to concurrent execution of processes (CLO 1, CLO 3, CLO
4)
What is a race condition and what problems can be caused by it?
What is the critical section of a program?
What is mutual exclusion and why is it an important property to maintain when
developing programs that may concurrently access shared resources?
3. Compare and contrast the process and thread abstractions (CLO 1, CLO 2, CLO 3, CLO 4,
CLO 7)
What is the thread abstraction provided by an OS?
How do threads compare to processes?
What is the difference between kernel-level and user-level threads?
4. Write safe multi-threaded programs using the Pthreads API (CLO 2, CLO 3, CLO 4, CLO 7)
What is the API you can use to create and destroy threads?
How can a thread wait for the termination of another thread?
How to use the Pthreads API to enforce mutual exclusion?
What is the Producer-Consumer problem and why is the use of mutual exclusion by itself
inadequate to solve the problem?
What are condition variables and how can you use them?

Banner Art: Pixabay (https://pixabay.com/)

https://canvas.oregonstate.edu/courses/1971495/pages/module-4-overview?module_item_id=24445917 1/2
6/8/24, 2:00 PM Module 4 - Overview: OPERATING SYSTEMS I (CS_374_400_S2024)

(https://pixabay.com/)

https://canvas.oregonstate.edu/courses/1971495/pages/module-4-overview?module_item_id=24445917 2/2
6/8/24, 2:00 PM Exploration: Concurrency: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Concurrency
Multiprogramming and Multiprocessing
When studying process states, we learnt that an OS can switch the CPU between
multiple processes that are all ready to run. This gives the impression that multiple programs are
being run concurrently and is called multiprogramming. The part of an OS that makes
decisions about which process should be run on the CPU is called the scheduler.

The scheduler may give the CPU to another process because the process that was running
on the CPU is now in the blocked state, e.g., because it is waiting for an I/O request to
complete.
The scheduler may give the CPU to another process even if the currently running process
can still run instructions on the CPU. This may be done by the scheduler if the currently
running process has been on the CPU for a long time, and just letting this process run on the
CPU will no longer give the impression that multiple programs are being run concurrently.

On a system with multiple CPUs, many processes can be on the CPU at the same time. This is
called multiprocessing. However, even on such systems, the scheduler will make scheduling
decisions about which processes should be run on each of the CPUs and for how long they
should be allowed to run on the CPU.

When one process is moved off the CPU and another process is run on the CPU, a context
switch is said to have occurred. During a context switch, the OS needs to store the state of the
process removed from the CPU and restore the state of the process that will now be run on the
CPU. Specifically:

The OS stores the contents of the CPU’s registers and the program counter for the process
that has been removed from the CPU. This is done so that when this process is again given
a run on the CPU, the registers and the program counter can be restored to these values
and the process will continue exactly from where it was stopped.
The OS then sets the CPU registers and the program counter corresponding to the process
which will now be run on the CPU.

Context switch is an expensive operation. It is also an overhead in the sense that during the
context switch the CPU is essentially doing bookkeeping rather than doing the useful work of
running the programs.

Potential Pitfalls of Concurrency

If multiple processes are running concurrently, then problems can arise if they access, and in
particular update, the same data.

Example

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-concurrency?module_item_id=24111770 1/4
6/8/24, 2:00 PM Exploration: Concurrency: OPERATING SYSTEMS I (CS_374_400_S2024)

Consider a program to withdraw money from an ATM machine has been coded as follows:

1. Read the balance of an account from a file into a local variable named balance .
2. Subtract the withdrawal amount from the local variable balance .
3. Write back the updated value of the local variable balance to the file.

Consider further that this file with the balance information is shared by multiple ATMs over the
network and the account balance of a particular user is $100. If $20 is withdrawn from this
account at about the same time from two different ATMs, the actions of the programs running on
each of these ATMs can interleave in the following order (time increases as we go down the
following table).

Issue Caused by Interleaved Execution of Threads

Account
Process 1 Process 2
Balance
$100
Reads value $100 from the file into the
$100
local variable balance
Reads value $100 from the file into the
$100
local variable balance
Subtracts $20 from the local variable
$100 balance. The value of the local variable
balance is now $80
Subtracts $20 from the local variable
$100 balance. The value of the local variable
balance is now $80
$80 Writes back $80 back to the file
$80 Writes back $80 back to the file

So even though $40 were withdrawn from the account, the balance is $80 instead of $60!

Race Conditions, Critical Sections and Mutual Exclusion

In the above example after $20 have been withdrawn from both the ATMs, the correct result for
the account balance is $60. However, as we saw, depending on the timing of how the 2
processes access and update the shared file, the result can be incorrect. This situation when
multiple processes execute operations on a shared resource and the result depends on the
timing of when the operations are executed is termed a race condition.

The part of code that accesses or modifies a shared resource is termed a critical section. If
multiple processes are accessing the same resource and execute their critical sections at the
same time, a race condition will occur. What we want is that when one process is in its critical
section, no other processes accessing this resource should be executing their critical section.
This property is called mutual exclusion.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-concurrency?module_item_id=24111770 2/4
6/8/24, 2:00 PM Exploration: Concurrency: OPERATING SYSTEMS I (CS_374_400_S2024)

Note that since the scheduler can remove a running process from the CPU to schedule another
process, it is possible that the scheduler removes a process while it is in the middle of executing
its critical section, and schedules another process that accesses the same resource and will
start executing its critical section. To ensure mutual exclusion, we needs some sort of “lock”
where only one process can own the lock at any given time, and only that process is allowed in
the critical section. Once the process is no longer in the critical section, it should give up the
lock so that other processes can run the critical section.

Concurrency Within a Program

We have talked about the benefit of concurrency in the context of multiple processes running
concurrently. Those processes may be running the same or different programs. But as we will
see even a single process can benefit from concurrent execution of tasks within the program it
is running.

Example: Consider a process is running a browser. Many tabs can be simultaneously open in
the browser and a user may switch between these tabs.

First consider a single tab in which a web page is being downloaded.

There are opportunities for concurrent execution of different tasks in that single tab.
Downloading a webpage typically requires multiple network requests, e.g., downloading
each image to be displayed requires a separate network request.
Additionally, while the process is waiting for some files to download, it could still do useful
work, e.g., rendering a previously downloaded image in the browser.
Now consider that typically a user has many tabs open in a browser at the same time.
Thus, there are additional opportunities to concurrently download files and render web
pages for multiple tabs in the same browser process.

One way to achieve concurrency in a browser could be to spawn multiple processes for the
browser. Then these processes will cooperatively work to concurrently do the tasks we
described above. This way when one process is waiting for an image to be downloaded from the
network, the CPU could schedule another process for this browser which could render an image
that had been previously downloaded. These cooperating processes will need some way to
communicate with each other. The OS provides various mechanisms to support Inter-Process
Communication (IPC), such as shared memory, pipes, etc., which we will study in a later
module in the course.

However, OSs provide a simpler and less resource intensive mechanism to implement
concurrency within a program called threads. We will study threads in detail in the coming
explorations in this module. In particular, we will study the POSIX standard Pthreads API for
creating and managing threads, and for implementing mutual exclusion on Unix based OSs.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-concurrency?module_item_id=24111770 3/4
6/8/24, 2:00 PM Exploration: Concurrency: OPERATING SYSTEMS I (CS_374_400_S2024)

An extremely infamous example of the real-world disastrous consequences of incorrect

coding of concurrency is the Therac–25 radiation therapy machine. Bugs having to do with
concurrent execution of code in this machine resulted in the death and injury of multiple
people. Therac-25 (https://en.wikipedia.org/wiki/Therac-25) (“Therac-25.” In Wikipedia, February
14, 2020).

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-concurrency?module_item_id=24111770 4/4
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Threads - Concepts & API

Basic Concepts
Threads provide a mechanism for a process to do multiple things concurrently. A process can
contain multiple threads. Like a process, each thread has its own stack, registers, program
counter. However, all threads in a process share the memory allocated to that process (also
known as the address space). Within the address space, all threads share the code, data and
heap segments. However, in a multi-threaded process the stack segment is broken up such
that each thread has its own stack area. This arrangement has the following consequences:

Creation of a thread is less expensive than the creation of a process because a new thread
will share the address space already allocated to the process in which this thread is created.
If one thread of a process is blocked, e.g., waiting for an I/O request to complete, the
process does not necessarily have to be blocked, because another thread of the process
may still be runnable and can be scheduled to run on the CPU.
A context switch to move one thread off the CPU and put another thread on the CPU is
much faster than the context switch from one process to another.
Communication between threads in a process can be simpler and faster than
communication between different processes.

Due to threads being very similar to processes, yet being a lot less resource intensive,
sometimes threads are referred to as lightweight processes in contrast to a heavyweight
process running just one thread.

Memory layout of a C program with multiple threads: all threads share the same Heap, Data
and Code segments. The Stack segment is broken up into pieces for the stack area of each
thread.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 1/7
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

Kernel-Level vs. User-Level Threads

In Linux, threads are controlled by the OS. The scheduler knows about threads and allocates
CPU time at the thread level. Such threads are called kernel-level threads.

However, another possibility is that a library provides user-level threads. In this case the OS
does not know about the threads but only knows about and schedules processes. The threading
library manages the threads in a process and is responsible for switching between them. User-
level threads are sometimes called green threads.

Pthreads API
Pthreads API is a standard API for threads in Unix. It is a POSIX standard and is available on
most Unix systems. The header file for the Pthreads library is pthread.h and the library includes
a large number of functions to, e.g., create, join, and destroy threads.

Example: “Hello World” Threaded Version

Before we study important functions in Pthreads API, let us look at our first example program
that uses Pthreads. In the following program

The main() function creates a new thread using the function pthread_create() and then
waits for the thread to complete by calling pthread_join() .
The thread created by main runs the function helloWorld which prints “Hello World” and
returns.
Once this thread returns, the main function resumes execution and executes its own return
statement.

6_2_thread_hello.c @cs344

Show files Open on Replit

main

1 ELF

>
�@@@8 @@@@@@�
�
88@8@

@@((
�

2 �
3 `�
4 `PX ``�
�
TT@T@ P�td��@�@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


*PW
9libm.so.6__gmon_start__libpthread.so.0pthread_createpthread_joinlibc.so
.6printf__libc_start_mainGLIBC_2.2.5

F ui i

ui i�`�``

`(`H��H�� H��t��H����5� �%� @�%� h������%z h
������%r
h�����1�I��^H��H���PTI���@H��0@H���@� �D��f.�@�@`H=@`t�H��t
�@`��f��Df.��@`H��@`H��H��H��?H
�H��t�H��t�@`���Df.��=�
8 uUH���~�����

Creating a Thread
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 2/7
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <pthread.h>

int pthread_create(pthread_t *thread,

const pthread_attr_t *attr,
void *(*start_routine) (void *),
void *arg);

The function pthread_create() starts a new thread in the process that has called this function.
Its arguments are as follows:

thread points to a variable into which the ID of the new thread is written. Its type is
pthread_t which is platform dependent, but is likely to be an unsigned long.
attr points to a pthread_attr_t struct that contains option flags. This argument can be
NULL if we don’t want to pass any flags.
start_routine points to a function that will be the starting point of execution for the new
thread. This function take an argument which is a void pointer and it return a void pointer.
arg points to the sole argument that is passed into start_routine . If multiple arguments
need to be passed, we can pass a struct. If no arguments need to be passed, we pass a
NULL.

In the example program, we created a thread in the following line:

pthread_create(&tid, NULL, helloWorld, NULL);

In this case, the start_routine is the function helloWorld . We are not passing any flags or
arguments to the call to pthread_create .

Note that to compile and link a program that uses the Pthread API, we need to use the flag -
pthread with the gcc command. E.g.,

gcc -std=gnu99 -pthread -o main main.c

Example: Using a structure to pass "multiple arguments" to a thread

In the following program we pass a data to a thread using a structure. When we want pass
multiple arguments to a thread, using a structure gets around the issue that the API only allows
passing a single argument to a thread.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 3/7
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

6_2_thread_many_args.c @cs344

Show files Open on Replit

main

1 ELF

>
�@@�@8 @@@@@@�
�
88@8@

@@� �
�

2 �
3 `�
4 `px ``�
�
TT@T@ P�tddd@d@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


|*\jc
9PUlibm.so.6__gmon_start__libpthread.so.0pthread_createpthread_joinlibc
.so.6exitstrdupprintfcalloc__libc_start_mainfreeGLIBC_2.2.5

 ui 
�

Fui ��`�``
`(`0`8`@`H` H��H��
8 H��t��H����5�
9 �%�
10 @�%�

Ending a Thread
A thread can end in one of the following ways:

The thread calls pthread_exit() (discussed below).

The thread returns from the start_routine . This is equivalent to calling pthread_exit() . In
our example program, the thread running helloWorld function ended when it executed a
return statement.
Another thread cancels this thread by calling pthread_cancel() (discussed below).
Any thread in the process calls exit() or the main() function performs a return. This
causes the termination of the process and all threads in that process.

pthread_exit()

void pthread_exit(void *retval);

This function (https://www.man7.org/linux/man-pages/man3/pthread_exit.3.html) terminates

the calling thread. It returns a value via the pointer retval .

pthread_cancel()

int pthread_cancel(pthread_t thread);

This function sends a cancellation request to the target thread that is provided as an argument.
The target thread has control over whether or when it decides to cancel. The details can be
found in the man pages for this function (https://man7.org/linux/man-
pages/man3/pthread_cancel.3.html) .

Waiting for a thread to terminate

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 4/7
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

When we were discussing the process API, we learnt how a parent process can wait for the
termination one or more of its child processes. Similar to this, a thread in a process can wait for
the termination of one or more other threads in that process by calling pthread_join .

int pthread_join(pthread_t thread, void **retval);

A thread that calls this function waits for the thread thread to terminate. If the target thread has
already terminated, the function returns immediately. If multiple threads try to join the same
thread, the result is undefined.

However, unlike the process API where a parent can wait for its children, but not the other way
round, there is no such hierarchy among the various threads in a process. Threads in a process
are peers of each other and any thread in the process can wait for the termination of another
thread in that process by calling pthread_join on that thread.

Example: Waiting for Threads to End

In the following program, we create a number of threads from the thread running the main()

function. This thread running main() then waits for the termination of for all the threads it has
created by calling pthread_join on each of these threads. After all these threads have
terminated, the main() function returns, thus terminating the thread running it, and hence the
process.

6_2_thread_example.c @cs344

Show files Open on Replit

main

1 ELF

>
�@@�@8 @@@@@@�
�
88@8@

@@�
2 �
3
�
4 �
5 `�
6 `hp ``�
�
TT@T@ P�td� � @� @DDQ�tdR�td�
7 �
8 `�
9 `
/lib64/ld-linux-x86-64.so.2
GNU


*cUw
j9Plibm.so.6__gmon_start__libpthread.so.0pthread_createpthread_joinlibc
.so.6exit__assert_failprintfpthread_self__libc_start_mainGLIBC_2.2.5


F ui �

ui ��`�``
`(`0`8`@`H��H��
10 H��t��H����5�

Getting the ID of the Current Thread

A thread can find its own ID by calling the function pthread_self()

(https://www.man7.org/linux/man-pages/man3/pthread_self.3.html) . This function always

succeeds and return a value of the data type pthread_t .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 5/7
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

Example: Printing the Thread ID

We adapt the "Hello World Threaded Version" to print the values of the thread ID of both the
main thread, and the helloWorld thread that is created by the main thread.

6_2_thread_ids.c @cs344

Show files Open on Replit

main

1 ELF

>
@@@@8 @@@@@@�
�
88@8@

@@0 0
�

2 �
3 `�
4 `X` ``�
�
TT@T@ P�td��@�@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


*Pd
W9libm.so.6__gmon_start__libpthread.so.0pthread_createpthread_joinlibc.s
o.6printfpthread_self__libc_start_mainGLIBC_2.2.5

F ui v

ui
v�`�``
`(`0`H��H�M H��t��H����5B �%D @�%B h������%:
h
������%2 h������%* h�����1�I��^H��H���PTI��P@H���@H��P@��
8 �D��f.�@�H`H=H`t�H��t �H`��f��Df.��H`H��H`H��H��H��?
H
�H��t�H��t�H`���Df.��=�

Note: As explained in the next section, definition of pthread_t is platform dependent. The
above program prints the value of pthread_t by assuming it is an integer. This program will
work on Linux, but is not guaranteed to work on other flavors of Unix. Printing pthread_t
by assuming it is an integer can still be useful for debugging on Linux and other platforms
where this works.

Testing Two Threads for Equality

The definition of pthread_t is platform dependent. There is no guarantee that it will be a
number. For example, a Unix system can implement it as a structure. Therefore, if we want to
write code which will work on all Unix systems, we cannot compare two pthread_t values using
the equality operator == . Instead, we need to use the function pthread_equal to test two
threads for equality.

int pthread_equal(pthread_t t1, pthread_t t2);

This function returns a value of nonzero if the two thread are identical, otherwise it returns the
value 0.

Exercise

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 6/7
6/8/24, 2:00 PM Exploration: Threads - Concepts & API: OPERATING SYSTEMS I (CS_374_400_S2024)

Our goal in the following program is that the main() function will create two threads which will
run concurrently. Does the program achieve its goal? If not, why not and how can you fix it?

6_2_threads_gone_wrong.c @cs344

Show files Open on Replit

main

1 ELF

>
P@@x@8 @@@@@@�
�
88@8@

@@H H
�

2 �
3 `�
4 ``h ``�
�
TT@T@ P�td��@�@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


*Ui
\9Plibm.so.6__gmon_start__libpthread.so.0pthread_createpthread_joinlibc
.so.6exitprintfpthread_self__libc_start_mainGLIBC_2.2.5

F ui
{

ui {�`�``
`(`0`8`H��H� H��t��H����5 �% @�%
h������%
8 h
������% h������%�
9 h������%�

Answer

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

The Pthreads API is discussed at length in Chapters 29, 30, 31 and 32 of The Linux
Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.
An introduction to concurrency and threads is given in Chapter 26 Concurrency: An
Introduction (http://pages.cs.wisc.edu/~remzi/OSTEP/threads-intro.pdf) in the book
Operating Systems: Three Easy Pieces.
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-threads-concepts-and-api?module_item_id=24111771 7/7
6/8/24, 2:01 PM Exploration: Synchronization for Concurrent Execution: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Synchronization for

Concurrent Execution
Race Conditions Revisited
In an earlier exploration, we had introduced the term race condition for the
situation where multiple processes execute operations on a shared resource in such a manner
that the result depends on the timing of when the operations are executed. We had used
concurrent withdrawal from ATMs as an example. Race conditions can also occur within one
process if that process is running multiple threads and those threads execute operations on a
shared resource in an unsafe manner. In fact, because it is a lot easier for multiple threads in
the same process to access and modify shared memory, the risk of race conditions can be even
greater in a multi-threaded program than in multiple single-threaded processes accessing
shared resources.

Example: Counter with Race Condition

Let us look at a multi-threaded program that gives incorrect results due to a race condition.

6_3_bad_threads.c @cs344

Show files Open on Replit

main

1 ELF

>
@@X@8 @@@@@@�
�
88@8@

@@( (
�

2 �
3 `�
4 `X` ``�
�
TT@T@ P�td��@�@DDQ�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU


*U\
9Plibm.so.6__gmon_start__libpthread.so.0pthread_createpthread_joinlibc.s
o.6exitprintf__libc_start_mainGLIBC_2.2.5

F ui n

ui n�`�``

`(`0`H��H�U H��t��H����5R �%T @�%R h������%J h
������%B
h������%: h�����1�I��^H��H���PTI��p@H��@H��0@��
8 �D��f.�@�H`H=H`t�H��t �H`��f��Df.��H`H��H`H��H��H��?
H
�H��t�H��t�H`���Df.��=�

In the above program, we spawn NUM_THREADS threads. Each of these threads increments the
same shared variable counter . Each thread increments this variable COUNT_TO times. With
NUM_THREADSset to 3 and COUNT_TO set to 10,000,000, a correct execution of the program
should end with the value of counter set to 10,000,000 * 3, i.e., to 30,000,000. However, if you

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-for-concurrent-execution?module_item_id=24111772 1/5
6/8/24, 2:01 PM Exploration: Synchronization for Concurrent Execution: OPERATING SYSTEMS I (CS_374_400_S2024)

run the program even once, you are likely to see a different value. If you the program multiple
times, almost certainly the result will be different each time. So what is causing this issue?

The issue is caused by unsafe concurrent access and modification of the variable counter . In
the program, the value of counter is incremented in the following line:

counter += 1;

The critical section of the program comprises this line because this is the only part of the
program where a shared resource is being modified. When we compile the program, this single
line of C code will be compiled to more than one instruction in machine language. The
compilation may, for example, comprise the following 3 instructions:

Instruction 1: Load the shared variable counter into a register.

Instruction 2: Increment the value in the register.
Instruction 3: Store the incremented value from the register back into the variable counter .

Recall the OS scheduler can at any time remove one thread from the CPU and instead run
another thread. Because of this, it is possible that two threads running concurrently may end up
executing the above instructions to increment this variable in the following interleaved order:

1. Thread 1 executes Instruction 1 and loads the value of counter into a register. Let’s say this
value was 100.
2. Thread 1 executes Instruction 2 and sets the value in the register to 101.
3. The OS removes Thread 1 from the CPU and instead gives the CPU to Thread 2. As part of
the context switch, the OS will save the value of all the registers so as that it can restore
them when Thread 1 resumes execution.
4. Thread 2 executes Instruction 1 and loads the value of counter into a register. Since Thread
1 had only updated the register, but had not yet updated the value of the variable counter ,
the value of the variable is still 100.
5. Thread 2 executes Instruction 2 and sets the value in the register to 101.
6. Thread 2 executes Instruction 3 and stores the value 101 from the register into the variable
counter .
7. The OS removes Thread 2 from the CPU and schedules Thread 1 again. As part of the
context switch, the OS restores the value 101 to the register that it had saved in Step 3.
8. Thread 1 executes Instruction 3 and stores the value 101 from the register into the variable
counter .

As a result of the interleaved execution, at the end of the two threads executing the increment
statement, the value of the variable has only been incremented once, instead of twice. This is
why the program gives an incorrect result.

Exercise: Different Results on Multiple Runs

If you run the previous example multiple times, the result was mostly likely different on each run.
Why do you think this happens?

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-for-concurrent-execution?module_item_id=24111772 2/5
6/8/24, 2:01 PM Exploration: Synchronization for Concurrent Execution: OPERATING SYSTEMS I (CS_374_400_S2024)

Answer

Exercise: Correct Results for Small Values

Change the value of COUNT_TO in the above program to 100 and run the program. The result is
mostly likely correct. Why do you think this happens?

Answer

Synchronizing Access Via Mutex Locks

To ensure that only one thread will update a shared resource at a time, we can use the mutex
functionality provided by the Pthreads API. Mutex stands for mutual exclusion and is basically a
lock that a thread can set before accessing the shared resource. Once a mutex is locked, any
other thread trying to lock it will block. Thus, by adding mutex lock and unlock statements
around the critical section of our code, we ensure that only one thread can be in the critical
section at any given time.

Initializing and Destroying a Mutex

The data type of a mutex variable is pthread_mutex_t . There are two ways to initialize a mutex:

Initialize it by setting it to the constant PTHREAD_MUTEX_INITIALIZER , e.g., as follows:

pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;

Call pthread_mutex_init() function.

If a mutex has been dynamically allocated, we need to call pthread_mutex_destroy() function

before freeing the memory.

Locking and Unlocking a Mutex

The API to lock and unlock a mutex comprises the following functions:

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

Calling pthread_mutex_lock() on a mutex will give the mutex to the calling thread. However,
if this mutex is already locked, the calling thread will block. A thread that has locked the
mutex is also sometimes referred to as holding the mutex.
As an alternative to this, the function pthread_mutex_trylock() can be used to make a non-
blocking attempt to lock the mutex. This function will return 0 if it is able to lock the mutex,
otherwise it will return a non-zero value.
A thread unlocks a mutex it has previously locked by calling pthread_mutex_unlock() .

Example: An Accurate Counter

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-for-concurrent-execution?module_item_id=24111772 3/5
6/8/24, 2:01 PM Exploration: Synchronization for Concurrent Execution: OPERATING SYSTEMS I (CS_374_400_S2024)

In the following program, we fix the race condition from the previous program by using a mutex
to synchronize access to the critical section where the value of the shared variable counter is
incremented.

6_3_granular_sync.c @cs344

Show files Open on Replit

main

1 ELF

>
`@@�@8 @@@@@@�
�
88@8@

@@�
2 �
3
�
4 �
5 `�
6 `x� ``�
�
TT@T@ P�tdt t @t @DDQ�tdR�td�
7 �
8 `�
9 `
/lib64/ld-linux-x86-64.so.2
GNU


f�*�
�u�@Slibm.so.6__gmon_start__libpthread.so.0pthread_mutex_destroypthrea
d_mutex_initpthread_mutex_lockpthread_createpthread_joinpthread_mutex_unl
ocklibc.so.6exitprintf__libc_start_mainGLIBC_2.2.5

� ui �

ui 
��`�``
`(`0`8`@`H` P`

With the change, each thread calls pthread_mutex_lock before it can increment the value of
counter by executing counter += 1 .

pthread_mutex_lock(&counterMutex);
counter += 1;
pthread_mutex_unlock(&counterMutex);

If multiple threads try to execute the increment statement at the same time, the thread which
first called pthread_mutex_lock will lock the mutex and go through to this statement, while the
other threads will be blocked. Thus the race condition has been eliminated, and this program will
always give the same correct result.

Note: When one thread has locked the mutex, all other threads that want the mutex are
blocked. For this reason a mutex must be locked for the shortest time that is necessary to
synchronize access to the shared resource. Any statements that are irrelevant to the
shared resource must be executed either before requesting the lock on the mutex or after
unlocking the mutex. Doing otherwise reduces the concurrency of the program because a
thread that has locked the mutex while executing statements that don't require the mutex is
unnecessarily blocking the other threads.

Additional Resources

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-for-concurrent-execution?module_item_id=24111772 4/5
6/8/24, 2:01 PM Exploration: Synchronization for Concurrent Execution: OPERATING SYSTEMS I (CS_374_400_S2024)

The Pthreads API is discussed at length in Chapters 29, 30, 31 and 32 of The Linux
Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.
The Pthreads API is also discussed in Chapter 27 Interlude: Thread API
(http://pages.cs.wisc.edu/~remzi/OSTEP/threads-api.pdf) in the book Operating Systems:
Three Easy Pieces.
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-for-concurrent-execution?module_item_id=24111772 5/5
6/8/24, 2:01 PM Exploration: Synchronization Mechanisms Beyond Mutex: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Synchronization Mechanisms

Beyond Mutex
Synchronization Mechanisms Beyond Mutex
As we have seen, mutexes can be used to synchronize threads to prevent multiple threads from
accessing a shared resource at the same time. But, there are situations where threads need to
synchronize their activities beyond accessing a shared resource one at a time. A common case for
this is when one thread wants to wait until a condition is true and another thread informs it when
the condition becomes true. For such cases, Unix and other OS supports a synchronization
mechanism called condition variables. In this exploration, we will motivate the need for condition
variables using a well-known example called the Producer-Consumer Problem. In the next
exploration, we will study how condition variables provide a solution for this problem and how the
Pthreads API supports condition variables.

Producer-Consumer Problem
The Producer-Consumer problem, also called the bounded buffer problem, is a classic
example of multiple threads (or multiple processes) needing to synchronize their actions. In its
simplest form the problem consists of two threads, one of which is called the producer and the
other is called the consumer. The producer and the consumer share a common buffer of a
bounded size. The producer generates data and puts it in the common buffer. The consumer picks
data from the buffer and consumes it. If the buffer is full, the producer must wait until there is
space in the buffer to put data. Similarly, if the buffer is empty, then the consumer must wait until
there is data in the buffer to consume.

We can summarize the requirements for the producer and consumer as follows:

Producer should put data only when the buffer is not full
Consumer should get data only when the buffer is not empty

Examples of Producer-Consumer Problem

Here are a couple of real-world examples of applications that use the Producer-Consumer model
for multiple processes or threads

The Unix pipe | command can be used in a shell to send the output of one command to the
input of another command. To connect the output of one command to the input of another
command, the Unix kernel creates a bounded buffer. E.g., the bash command cat foo.txt |
more displays the file foo.txt one screen at a time. cat foo.txt puts the contents of foo.txt
in this buffer, while more picks up this data from the buffer and displays it one screen at a

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-mechanisms-beyond-mutex?module_item_id=24111773 1/4
6/8/24, 2:01 PM Exploration: Synchronization Mechanisms Beyond Mutex: OPERATING SYSTEMS I (CS_374_400_S2024)

time. Thus, the command cat foo.txt is the producer and the command more is the
consumer in this example.
In many cases, there can be multiple producers and/or multiple consumers. An example of real
systems with such an architecture are multi-threaded web servers that process HTTP
requests. A producer thread puts the HTTP requests received by the web server in a bounded
buffer. Multiple consumer threads pick up these requests from the buffer and process them to
send back HTTP responses.

Solving Producer-Consumer Problem Using Mutex

We first look at an example program that uses a mutex to solve the Producer-Consumer Problem.

The program uses a mutex to synchronize access to the shared buffer.

The main() function creates a producer thread and a consumer thread, and waits for these
threads to finish.
The producer thread runs the function producer() . This function locks the mutex and then
checks whether there is space in the buffer to place an item.
If there is space in the buffer, it places an item in the buffer, increments the count of items
in the buffer and unlocks the mutex.
If the buffer is full, the producer thread gives up the mutex and sleeps for a while before
again checking if the buffer has any space.
The consumer thread runs the function consumer() . This function locks the mutex and then
checks whether there is data in buffer to consume.
If there is data in the buffer, it picks up the next item in the buffer, decrements the count of
items in the buffer and unlocks the mutex.
If the buffer is empty, the consumer thread gives up the mutex and sleeps for a while
before again checking if the buffer has any data.

6_4_prodcons_mutex.c @cs344

Show files Open on Replit

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-mechanisms-beyond-mutex?module_item_id=24111773 2/4
6/8/24, 2:01 PM Exploration: Synchronization Mechanisms Beyond Mutex: OPERATING SYSTEMS I (CS_374_400_S2024)

The above program successfully enforces the requirements that the producer should not put data
when the buffer is full and the consumer should not get data when the buffer is empty. However,
the solution is very inefficient. When the buffer is full, the producer sleeps for a second and then
again checks the buffer, wasting CPU time if the buffer is still full. Similarly, when the buffer is
empty, the consumer may repeatedly check the buffer again wasting CPU time. We could
decrease this inefficient use of the CPU by increasing the time the producer and the consumer
sleep when they cannot use the buffer. However, this will mean that the response time of the
application degrades because the producer or the consumer might be sleeping when they could
be using the buffer.

When Should the Threads Terminate?

When the number of items that a producer will produce is known beforehand, the producer thread
can terminate when it has put that number of items in the buffer. Similarly, the consumer thread
can terminate when it has consumed that number of items from the buffer.

However, typically in Producer-Consumer problems the number of items is not known beforehand.
Instead, the producer finds out that there are no more items to produce when it encounters some
sort of marker.

E.g., consider a scenario where the producer is processing a file and putting the file line-by-
line in the shared buffer for the consumer. In this case, end-of-file is the marker that tells the
producer that there is no more data for it to put in the buffer.

In such situations, the producer thread must not terminate as soon as it sees the maker. Before
terminating it must place a marker in the shared buffer so that the consumer can also know that
no more data will be put in the buffer. Otherwise, after consuming all the items in the buffer, the
consumer thread will forever keep checking the buffer to see if there are any more items to
consume.

In the above program, we use a special value -1 as a marker to indicate that the producer will
not put any more data in the shared buffer. The producer first puts this marker in the shared
buffer and then terminates the producer thread. When the consumer gets this marker from the
shared buffer, it terminates its thread.
In the program the number of items to produce/consume is available in the variable
num_iterations . So we could have instead coded the consumer thread to terminate when it

had consumed num_iterations items. We instead used the marker approach to illustrate that
idea.

Also note that it will be incorrect for the program to terminate as soon as the producer thread
terminates. Doing that doesn't allow the consumer thread to consume any items that may still be
in the shared buffer. Instead, the consumer thread should terminate when it knows there are no
more items to consume. Only after that the program can terminate.

Summary

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-mechanisms-beyond-mutex?module_item_id=24111773 3/4
6/8/24, 2:01 PM Exploration: Synchronization Mechanisms Beyond Mutex: OPERATING SYSTEMS I (CS_374_400_S2024)

In this exploration we looked at the Producer-Consumer problem. We found that while using a
mutex can provided the synchronization needed by the producer and consumer threads, the use
of mutex leads to an inefficient solution to the problem.

Additional Resources
A very good discussion of the producer-consumer problem is given in Chapter 30 Condition
Variables (http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf) in the book Operating
Systems: Three Easy Pieces.
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-synchronization-mechanisms-beyond-mutex?module_item_id=24111773 4/4
6/8/24, 2:01 PM Exploration: Condition Variables: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Condition Variables

Condition Variables
What we want is that the consumer should sleep whenever the buffer is empty, but as soon as
data is available in the buffer it should resume execution. Similarly, the producer should sleep
whenever the buffer is full, but as soon as there is space in the buffer it should resume execution.

Condition variables can be used to implement exactly this behavior. A condition variable allows a
thread to sleep until another thread indicates to this thread that a condition is now true and the
first thread should wake up. In the producer-consumer problem

When the buffer is empty, the consumer thread will sleep. When the producer puts an item in
the buffer, the buffer is no longer empty. The producer thread will indicate to the consumer
thread to resume execution.
Similarly, when the buffer is full, the producer thread will sleep. When the consumer consumes
data from the buffer, the buffer is no longer full. The consumer thread will indicate to the
producer thread to resume execution.

Note that the modification of the shared resource still requires a mutex to be shared between the
producer and the consumer. However, instead of calling sleep() to sleep for a fixed amount of
time, and then checking the buffer again, the producer and the consumer can instead use
condition variables.

Pthreads API for Condition Variables

Condition variables in the Pthreads API have the data type pthread_cond_t . We can initialize a
statically allocated condition variable by assigning it the value PTHREAD_COND_INITIALIZER . The
most useful functions for condition variables are as follows:

#include <pthread.h>
pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *m);
pthread_cond_signal(pthread_cond_t *cond);

To call the function pthread_cond_wait , the thread calling the function must hold the mutex m .
As a result of calling this function, the thread gives up the mutex m and blocks on the
condition variable cond until another thread calls pthread_cond_signal on cond .
When a thread calls pthread_cond_signal on a condition variable, a thread that has called
on that condition variable is unblocked and tries to acquire the mutex that it
pthread_cond_wait
had released when it called pthread_cond_wait .

Calling pthread_cond_wait is called waiting for the condition variable and calling
pthread_cond_singal is called signalling the condition variable. Note that the term signal here is
not related to the signal mechanism in Unix, but "signal" here is used in the sense of "indicate."

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-condition-variables?module_item_id=24111774 1/4
6/8/24, 2:01 PM Exploration: Condition Variables: OPERATING SYSTEMS I (CS_374_400_S2024)

Example: Producer-Consumer Using Condition Variables

We will illustrate the use of these functions with an example program. The following program
modifies the previous Producer-Consumer program to use two condition variables empty and
full , in addition to a mutex.

The main() function creates a producer thread and a consumer thread, and waits for these
threads to finish similar to the previous example program.
The producer thread runs the function producer() . This function locks the mutex and then
checks whether there is space in the buffer to place an item.
If there is space in the buffer, it places an item in the buffer and increments the count of
items in the buffer. It then signals the condition variable full to indicate that the buffer has
data and unlocks the mutex
If there is no space in the buffer, the producer thread calls pthread_cond_wait on the
condition variable empty . This will result in the producer thread unlocking the mutex and
blocking until the consumer thread signals this condition variable empty .
The consumer thread runs the function consumer() . This function locks the mutex and then
checks whether there is data in buffer to consume.
If there is data in the buffer, it picks up the next item in the buffer and decrements the count
of items in the buffer. It then signals the condition variable empty to indicate that the buffer
has space and unlocks the mutex.
If there is no data in the buffer, the consumer thread calls pthread_cond_wait on the
condition variable full . This will result in the consumer thread unlocking the mutex and
blocking until the producer thread signals this condition variable full .

64_prod_cons_cv.c @cs344

Thus, by using the two condition variables empty and full , the producer and consumer threads
can coordinate the production and consumption of data in the shared buffer such that
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-condition-variables?module_item_id=24111774 2/4
6/8/24, 2:01 PM Exploration: Condition Variables: OPERATING SYSTEMS I (CS_374_400_S2024)

The producer only puts data in the buffer when there is space in the buffer
The consumer only gets data from the buffer when there is data in the buffer, and
Neither thread does a busy wait by unnecessarily using CPU time to check if it can use the
buffer.

Producer-Consumer with Unbounded Buffer

In some applications, the Producer-Consumer problem is modeled with an unbounded buffer,
instead of a bounded buffer. In such applications, a producer does not need to block because the
buffer will never be full. However, a consumer will need to block if the buffer is empty. The
producer and the consumer threads with unbounded buffer can synchronize their actions using
just one condition variable full for which the consumer thread waits and the producer signals.

Exercise: Producer-Consumer Unbounded Buffer

In the following program, the buffer shared between the producer and consumer has size 15. The
number of items that will be produced (and consumed) including the end marker is 13. This
means that the buffer is large enough that it will never be full and hence we can model it as an
unbounded buffer. Your task:

Modify the program so that synchronization is achieved using only one condition variable.

6_4_prod_cons_unbound.c @cs344

Answer

Summary
Condition variables provide another synchronization mechanisms for use by multiple threads in a
process. We illustrated the use of condition variables for the Producer-Consumer problem with a
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-condition-variables?module_item_id=24111774 3/4
6/8/24, 2:01 PM Exploration: Condition Variables: OPERATING SYSTEMS I (CS_374_400_S2024)

bounded buffer as well as an unbounded buffer. We only looked at scenarios where there was one
producer and one consumer. There are variations of the Producer-Consumer problem where there
can be multiple producers and/or multiple producers. In addition to the Producer-Consumer
problem, condition variables are also widely used in multi-threaded programs for other
synchronization problems.

Additional Resources
Pthread APIs support for condition variables is discussed in Ch 30.2 of The Linux
Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.
A very good discussion of the producer-consumer problem and the use of condition variables
is given in Chapter 30 Condition Variables
(http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf) in the book Operating Systems: Three
Easy Pieces.
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.
The Dining Philosophers problem (Wikipedia link
(https://en.wikipedia.org/wiki/Dining_philosophers_problem) ) is another well-know example
problem that is used to illustrate synchronization issues. A solution to this problem using
condition variables is given here
(http://www.cs.fsu.edu/~baker/realtime/restricted/notes/philos.html) .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-condition-variables?module_item_id=24111774 4/4
6/8/24, 2:01 PM Review - Module 4: OPERATING SYSTEMS I (CS_374_400_S2024)

Review - Module 4
Key Take-Aways
At this point, you should be able to answer all of the following questions.

What is multiprogramming?
What is multiprocessing?
What function does an OS scheduler perform and how is this role relevant to
multiprogramming and multiprocessing?
What is a race condition and what problems can be caused by it?
What is the critical section of a program?
What is mutual exclusion and why is it an important property to maintain when developing
programs that may concurrently access shared resources?
What is a thread and how do threads compare to processes?
What is the Pthreads API to create and destroy threads?
How can you use the Pthreads API to write multi-threaded programs with correct concurrent
behavior?
What are condition variables?
What is the Producer-Consumer problem and how are condition variables useful for
implementing solutions for this problem?

(https://canvas.oregonstate.edu/courses/1971495/modules)

https://canvas.oregonstate.edu/courses/1971495/pages/review-module-4-2?module_item_id=24111775 1/1
6/8/24, 2:02 PM Exploration: Inter-Process Communication: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Inter-Process Communication

Introduction
In this exploration, we will take a tour of the mechanisms provided by Linux for
processes to communicate with each other, i.e., functionality for Inter-Process Communication
or IPC. We have already studied signals in an earlier module which are used by one process to
notify another process, and thus provide a form of (limited) IPC. In another module, we explored
mutex locks in the Pthreads API which is a facility that multiple threads in one process can use
to synchronize their actions. In this exploration, we will look at the breadth of IPC facilities, and
then, in later explorations in this module, we will study some of these facilities in greater depth .

Categories of IPC
At a high level, we can categorize IPC facilities into communication facilities which help
processes exchange data, and synchronization facilities which help processes (or threads)
coordinate their actions.

Communication Facilities for IPC

We can further categorize communication facilities into two categories, the ones where
processes communicate by transferring data and the ones where processes communicate via
shared memory.

IPC Using Data Transfers

These facilities follow a pattern where one process writes data that is read by another process.
In some of these facilities, the data is exchanged as byte streams. The writer writes data as a
byte stream and a read operation reads an arbitrary number of bytes from the byte stream. In
other facilities, data is exchanged as a complete message. The writer writes the data as
messages. Each read operation reads a complete message and cannot read parts of a
message. Data transfer facilities include the following:

Pipes
A pipe is a unidirectional data channel for processes on one machine in which one process
writes to the pipe and another process reads from the pipe. A pipe can only be used between
processes that are forked by a common ancestor. A pipe can be used, e.g., for a parent process
to write to the child process, or vice versa. Pipes exchange data as byte streams. We will study
pipes in the next exploration.

FIFO
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-inter-process-communication?module_item_id=24111778 1/4
6/8/24, 2:02 PM Exploration: Inter-Process Communication: OPERATING SYSTEMS I (CS_374_400_S2024)

FIFO stands for First-in, First-out. These are similar to pipes in that one process writes to a
FIFO and another process on the same machine reads from it. However, FIFO can be used for
communication between two process even if these processes are not related to each other.
Unlike pipes, FIFOs have name and they are also called named pipes. FIFOs exchange data
as byte streams. We will study FIFOs in the next exploration.

Message Queues
Message queues are used to exchange data in the form of messages. Messages in the queue
have a type field, a length field and the actual message bytes. Messages can be fetched in first-
in, first-out order. But it is also possible to fetch messages in a non-FIFO order using the type
field.

Sockets

Sockets are different from the other IPC facilities that we have discussed in that these can be
used for IPC by processes running on the same machine as well processes that are on different
machines. Datagram sockets provide message based communication, whereas stream
sockets support byte streams. We will study sockets in depth in another module.

IPC Using Shared Memory

As we have discussed, when a process is forked it gets its own memory which is protected from
access by other processes. By using IPC facilities for shared memory, special memory
segments can be created which are shared among multiple processes. The processes can then
exchange information by reading and writing to this shared memory region. A variation on
shared memory is memory mapped file where a part or whole of a file is mapped to memory
using the mmap() (https://man7.org/linux/man-pages/man2/mmap.2.html) system call
(https://man7.org/linux/man-pages/man2/mmap.2.html) . Once the file has been mapped into
memory, the file contents are accessed as if they were in a buffer in memory rather than
accessing them using read() or write() system calls.

Comparing Data Transfer & Shared Memory Facilities

Communication is a lot faster with shared memory than with data transfer. Once the shared
memory has been set up, processes do not need to make system calls in order to read or
write the data. Data transfer facilities typically require transferring data from the memory of
the writer process to kernel memory during write, and then a transfer from kernel memory to
the memory of the reader process.
Synchronization of read and write operations is a lot easier with data transfer. A call to read
data blocks if no data is available, and a call to write blocks if the data channel is full.
However, in case of shared memory, it is the responsibility of the processes to use
appropriate synchronization facilities, such as semaphores, to synchronize access to the
shared memory. For example, if one process is updating a data structure in shared memory,
other processes should be prevented from accessing this data structure.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-inter-process-communication?module_item_id=24111778 2/4
6/8/24, 2:02 PM Exploration: Inter-Process Communication: OPERATING SYSTEMS I (CS_374_400_S2024)

With data transfer, reading the data removes it from the communication facilities. This means
that only one process can read the data. As opposed to this, multiple processes can read the
data when shared memory is used.

Exercises
Communication facilities, such as pipes and FIFOs, allow communication between processes.
Do you think it would be important to provide similar communication facilities for multiple threads
in the same process? If yes, why? If no, why not?

Answer

Synchronization Facilities
Processes and threads use synchronization facilities to coordinate their action, especially, when
modifying or accessing shared resources, such as memory or files. Let us look at different types
of synchronization facilities.

Semaphores
A semaphore is an integer whose value is always 0 or more. Processes, or threads in a
process, can use semaphores to coordinate their actions. There are two fundamental operations
that a process can do on a semaphore - increments its value and decrement its value. If the
value is already 0, then decrement operation is blocked until another process increments the
value of the semaphore.

To enforce mutual exclusion, processes can use a binary semaphore whose value is either 0
or 1. A process wanting to gain exclusive access to a shared resource will try to decrement the
value of the binary semaphore. It will succeed if the value is 1; otherwise it will be blocked.

However, if processes want to access a shared resource with multiple resources, they can use
counting semaphores where the value of the semaphore can go up to the number of shared
resources. We will study semaphore in a later exploration in this module.

Mutexes and Condition Variables (for threads)

We have already studied mutexes and condition variables which can be used to synchronize
access by multiple threads in the same process. However, these facilities cannot be used for
synchronization by multiple processes.

File Locks
File locks are a specialized synchronization facility to coordinate operations on a file by multiple
processes. File locks can be created for complete files or at the finer granularity of portions of a
file.

Additional Resources
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-inter-process-communication?module_item_id=24111778 3/4
6/8/24, 2:02 PM Exploration: Inter-Process Communication: OPERATING SYSTEMS I (CS_374_400_S2024)

Here are some references to learn more about the topics we discussed in this exploration.

Chapter 43 of The Linux Programming Interface contains an excellent overview of the

different IPC facilities provided in Linux. The categorization of IPC facilities in this exploration
is adapted from that overview.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-inter-process-communication?module_item_id=24111778 4/4
6/8/24, 2:02 PM Exploration: Pipes & FIFO: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Pipes & FIFO

Introduction
In a previous exploration, we had used the dup2() function to redirect standard
input and standard output of a process. But what if two processes wanted to send each other
data? We could set up a data channel between them by using an intermediate file, and then
redirecting the sender/writer process’s standard output to write to this file and redirecting the
receiver/reader process’s standard input to read from that file. Pipes and FIFOs provide us
simple mechanisms for achieving such communication between processes.

Pipes
Pipes are used for Inter-process communication (IPC) between two processes that are forked
by a common ancestor process. A pipe is a unidirectional data channel that connects a write-
only file descriptor in one process to a read-only file descriptor in another process.

Creating a Pipe
Pipes are possible because file descriptors are shared across fork() and exec() family of
functions. Here is how pipes are created and used:

A parent process creates a pipe by calling the pipe() function. This results in two new open
file descriptors, one for input and one for output.
The parent process then calls fork() and possibly exec() . Now both the parent and the
child have the two file descriptors that were created by the pipe() function.
If a pipe is to used for the parent process to send data to the child process, then the parent
process writes to the output file descriptor and the child process reads from the input file
descriptor.
Conversely, if a pipe is to be used for the child process to send data to the parent process,
then the child process writes to the output file descriptor and the parent process reads from
the input file descriptor.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pipes-and-fifo?module_item_id=24111779 1/5
6/8/24, 2:02 PM Exploration: Pipes & FIFO: OPERATING SYSTEMS I (CS_374_400_S2024)

Using a pipe to send data from the writer process to the reader process

The pipe() function

#include <unistd.h>
int pipe(int pipefd[2]);

The pipe function (https://man7.org/linux/man-pages/man2/pipe.2.html) takes one argument

whose data type is an array of two file descriptors. The function returns two file descriptors in
this array. The file descriptor in pipefd[0] refers to the read end of the pipe, and the file
descriptor in pipefd[1] refers to the write end of the pipe. The kernel buffers the data written to
the write end of the file until the process at the read end of the pipe reads it. On success, the
function returns the value 0. On error, the function returns the value –1.

Example: Using Pipes

In the following program, we create a pipe that is used by the child process to send data to the
parent process. The child process uses the write() system call (which we discussed in Module
5) to write data to the pipe. The parent process, which is the reader, uses read() system call to
read data from the pipe. When data is available read() immediately returns the data. The
return value of read() tells you how many bytes were read which can be less than how many
you requested. If there is no data available in the pipe, the call to read() is blocked until data
becomes available.

7_1_pipes.c @cs344

Show files Open on Replit

a.out

1 ELF

>
�@8+@8 @@@@�
�
888

PP
XX X �� hh h �
�
TTTDDP�td

2 
3 
4 <<Q�tdR�tdXX X ��
/lib64/ld-linux-x86-
64.so.2
GNUGNU3�‫���ܴ�ڬ‬Z�_zL


� &7>XLm� Q �
^"!Elibc.so.6exitpipeperrorputsfork__stack_chk_failprintfmemsetstrstrrea
dstrcatclose__cxa_finalize__libc_start_mainwriteGLIBC_2.4GLIBC_2.2.5_ITM_
deregisterTMCloneTable__gmon_start___ITM_registerTMCloneTable

i
i
5 �ui �X � ` �   � 
� 
6 �  � � p x � � � � � �  � � 
7 � � � H��H�- H��t��H����5� �%� @�%� h������%� h
������%z
h������%r h������%j h������%b h������%Z h������%R h�p����%J

Note that pipes have a certain size. On Linux this size is typically 65,536 Bytes, i.e., 64 KBytes.
If a pipe fills up and there is no more room, then write() will block until space becomes
available which will happen when the reader process reads the data from the pipe.

The read() function

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pipes-and-fifo?module_item_id=24111779 2/5
6/8/24, 2:02 PM Exploration: Pipes & FIFO: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);

The read() function reads data from the file descriptor fd . It attempts to read up to count
bytes into the buffer pointing at by buf . On success, read() returns the number of bytes it
read. This number can be less than count if, for example, there are fewer bytes available to
read, hence this does not indicate an error. read() returns –1 on error and returns 0 on
encountering end-of-file.

The strstr() function

In the program we use the string function strstr() (https://man7.org/linux/man-
pages/man3/strstr.3.html) to find the termination indicator, @@, inside the data that is read in.
Let’s look at this function:

#include <string.h>
char *strstr(const char *haystack, const char *needle);

The strstr() function finds the first occurrence of the substring needle in the string haystack .
If the substring is found then the function returns a pointer to the beginning of the located
substring. If the substring is not found then it returns NULL.

Closing Pipes
What happens if one of the processes closes its end of the pipe?

If the reader process closes the input pipe, then when the writer process tries to write to the
pipe, write() will return –1. Additionally, the writer process will be sent the SIGPIPE signal
which we described in the exploration related to signals.
If the writer process closes the output pipe, then the process reading from the pipe will read
end-of-file after it has read all remaining data in the pipe and will return 0.

FIFO
FIFO stands for First-in, First-out. FIFO are very similar to pipes with the crucial difference that a
FIFO has a name. This allows FIFOs to be used for communication between two process on the
same machine even if these processes are not related to each other. Because FIFOs have
names and they are similar to pipes, they are also called named pipes.

A FIFO is essentially a persistent pipe, which is represented by a special file. We create a FIFO
by calling the function mkfifo() . Once a FIFO is created any process can open a FIFO with
open() and then use it just like using a pipe. When opening a FIFO, open() called by the first

process will block. The first process will unblock once the second process also calls open()

The mkfifo()function

#include <sys/types.h>
#include <sys/stat.h>

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pipes-and-fifo?module_item_id=24111779 3/5
6/8/24, 2:02 PM Exploration: Pipes & FIFO: OPERATING SYSTEMS I (CS_374_400_S2024)

int mkfifo(const char *pathname, mode_t mode);

This function (https://man7.org/linux/man-pages/man3/mkfifo.3.html) creates a FIFO with the

given pathname and the permissions specified by mode .

Example: FIFO
In the following example, there are two programs, a reader program and a writer program. The
programs use @@ as a terminal indicator, i.e., to indicate that the message is complete.

Note: Click on the "File" icon on the left side of the repl to view a list of files. The file
7_1_reader.c is the reader program, and the file 7_1_writer.c is the writer program.

The reader program

Creates a FIFO by calling mkfifo()

Opens the FIFO by calling open()

Reads from the FIFO by calling read()

When it finds the terminal indicator in the data, the reader program prints the complete
message to standard output and exits.

The writer program

Opens the FIFO by calling open()

Writes to the FIFO by calling write() and exits.
A small sleep has been added in the beginning of the writer to make sure that the FIFO has
been created by the reader before the writer tries to open it.

7_1_fifo.c @cs344

Show files Open on Replit

Creating FIFOs from the shell

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pipes-and-fifo?module_item_id=24111779 4/5
6/8/24, 2:02 PM Exploration: Pipes & FIFO: OPERATING SYSTEMS I (CS_374_400_S2024)

A FIFO can also be created from the shell, by using the command mkfifo

(https://man7.org/linux/man-pages/man1/mkfifo.1.html) . Since a FIFO is a file, it will be listed by

the ls command. For example, the following command will create a FIFO named my_fifo in
the current directory, which is listed by the ls command as a special file indicated by the
character p in the first column.

$ mkfifo my_fifo
$ ls -l my_fifo
prw-rw----. 1 chaudhrn upg11000 0 May 25 06:13 my_fifo

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

Pipes and FIFOs are discussed in Chapter 44 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-pipes-and-fifo?module_item_id=24111779 5/5
6/8/24, 2:02 PM Exploration: Semaphores: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Semaphores
Introduction
We have already studied the use of Pthreads mutexes to synchronize access of
multiple threads in a process to a shared resource. POSIX semaphores provide another
mechanism that allows threads to synchronize their actions. However, in addition to threads,
semaphores can also be used by multiple processes to synchronize their actions. Additionally,
semaphores support the implementation of more complex synchronization between processes
or threads that goes beyond mutual exclusion.

Basic Concepts
A semaphore is an integer whose value is always 0 or more. To synchronize actions,
semaphores provide two fundamentals operations:

1. Decrement the value of the semaphore by one. This operation succeeds only if the current
value of the semaphore is greater than 0. This is called locking the semaphore. But if the
current value of the semaphore is 0, then the decrement operation blocks until the value
becomes greater than 0.
2. Increment the value of the semaphore by one. This is called unlocking the semaphore.

Semaphore API
Semaphores can be named or unnamed. In this exploration, we will only look at unnamed
semaphores. We

Initialize an unnamed semaphore by calling sem_init()

Destroy it by calling sem_destroy()
Lock it by calling sem_wait()
Unlock it by calling sem_post()

Let us look at these functions. Note that although semaphores can be used by multiple threads
in a process or by multiple processes, to keep the explanation simple we will many times use
only the term "process", or "thread", instead of repeatedly writing the whole term “process or
thread.”

sem_init()

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);

The sem_init() function (https://man7.org/linux/man-pages/man3/sem_init.3.html)

initializes the unnamed semaphore pointed to by sem .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-semaphores?module_item_id=24111780 1/5
6/8/24, 2:02 PM Exploration: Semaphores: OPERATING SYSTEMS I (CS_374_400_S2024)

The value of the argument pshared specifies whether this semaphore will be shared
between multiple threads of a process, or between multiple processes. The value 0 means
that it will shared between threads of a process, and 1 means it will be shared between
multiple processes.
The argument value specifies the initial value of the semaphore.
If the function is successful, it return 0, otherwise it returns -1.

sem_destroy()

#include <semaphore.h>
int sem_destroy(sem_t *sem);

This function (https://man7.org/linux/man-pages/man3/sem_destroy.3.html) destroys the

unnamed semaphore pointed to by sem . A semaphore should only be destroyed when there are
no other processes or threads that are blocked on it. The behavior is undefined is a semaphore
is destroyed while other processes or threads are blocked on it.

sem_wait()

#include <semaphore.h>
int sem_wait(sem_t *sem);

This function (https://man7.org/linux/man-pages/man3/sem_wait.3.html) tries to decrement the

semaphore sem .

If the semaphore’s current value is greater than 0, the function succeeds and returns
immediately.
If the semaphore’s current value is 0, then any process that calls this function will block.
When the value of the semaphore again become greater than 0, then one process among all
the processes that are blocked on this function will be unblocked. This unblocked process
will decrement the value of the semaphore and continue its execution.
The function returns 0 on success, and -1 on error.

sem_post()

#include <semaphore.h>
int sem_post(sem_t *sem);

This function (https://man7.org/linux/man-pages/man3/sem_post.3.html) increments the

semaphore sem . If this increment causes the value of the semaphore to become greater than 0
and one or more processes are currently blocked in a call to sem_wait() on this semaphore,
then the following will happen:

One of these processes will be unblocked

This process will decrement the value of the semaphore and will now proceed with execution
All other processes will remain blocked on sem_wait()

The function returns 0 on success, and -1 on error.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-semaphores?module_item_id=24111780 2/5
6/8/24, 2:02 PM Exploration: Semaphores: OPERATING SYSTEMS I (CS_374_400_S2024)

Binary Semaphores
Semaphores with an initial value of 1 are called binary semaphores.

Let us consider that a semaphore binary_sem is initialized with the value 1 and is shared
between threads of a process.

If two threads T1 and T2 call sem_wait() at about the same time, one of them, say T1, will
succeed in decrementing the value to 0 while T2 will be blocked at this call because the
value is now 0.
T1 can then proceed with its execution and can access or modify the shared resource.
When T1 is done, it will call sem_post() . This will cause the value of binary_sem to
increment to 1.
Now T2 will be unblocked. It will decrement the value to 0 and proceed with its execution.
If T1 again calls sem_wait() , it will be blocked until T2 calls sem_post() .

Note how this use of a semaphore with an initial value of 1 to enforce mutual exclusion is similar
to how we used pthread_mutex_lock and pthread_mutex_unlock to implement mutual exclusion
using Pthreads API in the previous module.

Exercise
The following program implements an incorrect counter because of a race condition between
the two threads when updating the shared variable counter . Modify the the function
perform_work and add calls to sem_post() and sem_wait() to synchronize access to counter
so that the program always produces the correct result.

7_2_sem_exercise.c @cs344

Answer

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-semaphores?module_item_id=24111780 3/5
6/8/24, 2:02 PM Exploration: Semaphores: OPERATING SYSTEMS I (CS_374_400_S2024)

Answer (https://repl.it/@cs344/72semthreadsc#main.c)

Counting Semaphores
A semaphore with an initial value greater than 1 is called a counting semaphore. Counting
semaphores are used where we want to allow more than 1 process to simultaneously access a
pool of shared resources, but still impose an upper limit on how many processes can
simultaneously access this pool of shared resources. This is done by setting the initial value of
the counting semaphore to the number of resources that can be simultaneously used.

Example: Sharing a Pool of Resources

In the following example, we show how threads in a process can share a pool of resources such
that if all resources in the pool are being used by other threads, then a thread must wait for a
resource to be released.

We create a counting semaphore and set its initial value to POOL_SIZE, i.e., to the number
of resources in the pool.
Each thread calls sem_wait() on the semaphore before using the resource. If any resources
are available for use, the value of the semaphore will be decremented and the thread can
proceed with using the resource by calling use_resource() .
When the number of threads that are currently using a resource equals POOL_SIZE, then
the value of the semaphore will be 0. At this time, any thread which calls sem_wait() will be
blocked.
When a thread gets done using the resource, i.e., it returns from use_resource() it calls
sem_post() which will increment the value of the semaphore. If there are threads currently

blocked on the semaphore, one of them will be unblocked, the semaphore value will be
decremented, and the thread can proceed with calling use_resource() .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-semaphores?module_item_id=24111780 4/5
6/8/24, 2:02 PM Exploration: Semaphores: OPERATING SYSTEMS I (CS_374_400_S2024)

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

The man page for sem_overview (https://www.man7.org/linux/man-

pages/man7/sem_overview.7.html) gives a good overview of semaphores.
POSIX semaphores are discussed in Chapter 53 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.
The Wikipedia article on semaphores
(https://en.wikipedia.org/wiki/Semaphore_(programming)) includes examples of use of
semaphores to solve some classic synchronization problems
“Semaphore (Programming).” In Wikipedia, May 12, 2020.
Chapter 31 Semaphores (http://pages.cs.wisc.edu/~remzi/OSTEP/threads-sema.pdf) in the
book Operating Systems: Three Easy Pieces discusses semaphores.
Arpaci-Dusseau, Remzi H., and Andrea C. Arpaci-Dusseau. Operating Systems: Three Easy Pieces, 2018.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-semaphores?module_item_id=24111780 5/5
6/8/24, 2:02 PM Exploration: Network Programming: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Network Programming

Introduction
IPC over a network typically follows a Client/Server architecture. A server process
continually runs at a machine which has a well-known address on the network. The server waits
to service requests from client processes that are running on other machines on the network.
The interaction between the client and server typically consists of the following steps:

1. The client sends a request to the server to perform some service.

2. The server receives the request.
3. The server performs the service.
4. The server sends a response back to the client.
5. The client receives the response and manipulates it.

As a specific example, consider that we open up browser on our home computer to view the
home page of Oregon State University. The client in this case is our browser, and the server is
the Web Server set up by our university’s IT team. Leaving out details (such as caching), at a
high level the interaction between the browser and Oregon State’s web server corresponds to
the following steps:

1. Our browser sends a request to view the page at https://oregonstate.edu/

(https://oregonstate.edu/) .
2. The Web Server for oregonstate.edu receives the request.
3. The Web Server locates the files corresponding to the homepage.
4. The Web Server sends back these files to the browser.
5. The browser renders the files to display the page.

In order for the client/server interaction to succeed, the client and the server need to follow a
common protocol, i.e., a standard way to communicate. In this module, we will primarily look at
network programming for the Transmission Control Protocol/Internet Protocol (TCP/IP).

Network Layer Model

The TCP/IP Protocol is composed of five layers. The following table lists these layers, along with
some popular protocols used at each layer

Network Layers and Common Protocols at Each Layer

Layer Name Common Protocols

Application HTTP, SFTP, DNS
Transport TCP, UDP
Network IP
Link Ethernet, 802.11

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-network-programming?module_item_id=24111784 1/6
6/8/24, 2:02 PM Exploration: Network Programming: OPERATING SYSTEMS I (CS_374_400_S2024)

Layer Name Common Protocols

Physical Twisted pair copper, fiber

The Application Layer is where an application creates data that needs to be sent over the
network. The application layer uses the services of transport layer to send the data from one
host machine to the other.
The Transport Layer is responsible for controlling how data is sent from one host all the
way to the other, irrespective of the number of nodes, hops, or intermediate networks the
data passes through. The transport layer does not interpret the bytes in the data it is
communicating. It is up to the application layer protocol to interpret the data. The two
protocols used at this layer are as follows:
1. Transmission Control Protocol (TCP):
TCP is the most commonly used protocol for transferring information across a
network.
It is a connection-oriented protocol that provides a byte-stream interface, much like
stdio.
TCP sends out network traffic in bundles that are called packets. TCP guarantees
that packets will arrive in the order in which they are sent.
As an example, the application layer protocol HTTP uses TCP as its transport layer
protocol.
2. Universal Datagram Protocol (UDP):
UDP is a connectionless protocol that does not guarantee delivery of data. UDP
breaks up data into unit called datagrams.
UDP does not guarantee that datagrams will be delivered in order, not does it
guarantee that datagrams will not be dropped by the network.
However, UDP has much lower overhead than TCP and can transfer data much
faster.
As an example, the application layer protocol DNS (Domain Name System) uses
UDP as its transport layer protocol.
The Network Layer is responsible for addressing and organization of a particular set of
connected hosts. The Internet Protocol (IP) is the protocol used at this layer in TCP/IP. The
Internet Protocol provides support for addressing and naming of the host machines, and for
routing from host to host and across network.
The Link Layer is responsible for getting data from just one node to the next neighboring
node. Protocols at this layer include Ethernet and 802.11, aka, Wi-fi.
The Physical Layer is responsible for physical moving the data between two hosts. It is the
actual hardware, which may be copper wires or radios to enable wireless devices to
communicate.

Programmer’s View of the Internet

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-network-programming?module_item_id=24111784 2/6
6/8/24, 2:02 PM Exploration: Network Programming: OPERATING SYSTEMS I (CS_374_400_S2024)

For a programmer, the Internet is a collection of host machines where a process on one host
can communicate with a process on another host using the TCP/IP protocol suite. A process
running on one host specifies which host it needs to send data to by using the addressing and
naming scheme supported by TCP/IP. TCP/IP provides two fundamental facilities for addressing
and naming:

1. IP Address:
In IP Version 4, IPv4, the set of hosts is mapped to a set of 32-bit addresses. Therefore,
IPv4 has 232 or 4,294,967,296 unique addresses.
Each interface of a host has its own IP address.
E.g., if a machine has wired Ethernet as well as Wireless 802.11,, then these two
interface will have their own IP addresses.
Thus, a host may have multiple IP addresses.
To keep up with the extremely rapid growth in the demand for addresses, a newer
version of IP, IP Version 6, IPv6, uses a set of 64-bit addresses.
However, in our examples, we will use the 32-bit addresses provided by IPv4.
2. Internet Domain Name:
IP addresses are long numbers which can be difficult for humans to remember.
The Internet defines domain names which are more human friendly and supports the
mapping of a set of domain names to a set of IP addresses.

Let us now look at IP Addresses and Domain Names in more detail including the API Unix
provides to use them.

IP Addresses
IP addresses in Unix are structures of type in_addr defined as follows:

#include <netinet/in.h>
struct in_addr {
unsigned int s_addr;
}

A more human-readable representation of a 32-bit IP address is called the dotted-decimal

notation. In this representation each of the 4 bytes of the IP address is specified by its decimal
value, and each of the decimal values is separated by a dot.

Example: Here is the same IP address represented in different number systems and in the
dotted-decimal notation

Binary: 00100011.10100001.01100010.00110110
Decimal: 597778998
Hexa-Decimal: 0x23.0xa1.0x62.0x36
Dotted-Decimal Notation: 35.161.98.54

Converting Between IP Addresses and Dotted-Decimal Notation

Unix provides functions that can covert between IP addresses and dotted-decimal notation in
both directions. The function inet_ntoa() (https://man7.org/linux/man-

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-network-programming?module_item_id=24111784 3/6
6/8/24, 2:02 PM Exploration: Network Programming: OPERATING SYSTEMS I (CS_374_400_S2024)

pages/man3/inet_ntoa.3p.html) converts an IP address to the dotted-decimal notation, while the

function inet_aton() (https://man7.org/linux/man-pages/man3/inet_aton.3.html) converts in
the other direction.

Internet Domain Names

While the dotted-decimal notation provides a more human-friendly form of an IP address, it is
still difficult for people to remember long numbers. Internet supports domain names that are
easier to remember, and also provides facilities to map domain names to IP addresses. An
example of a difficult to remember IP address is 35.161.98.54 which has a much more easy to
remember domain name oregonstate.edu .

The mapping between IP addresses and domain names is maintained in a distributed database
called Domain Name System (DNS). Entries in DNS can be looked up both by domain names
and by IP addresses.

API for DNS

Entries in DNS are structs of type hostent

#include <netdb.h>
struct hostent {
char *h_name; /* official name of host */
char **h_aliases; /* an array of alternate names, terminated by a null pointer
*/
int h_addrtype; /* host address type. One of AF_INET or AF_INET6 at present.
*/
int h_length; /* length of address */
char **h_addr_list; /* an array of addresses, terminated by a null pointer */
}

The function gethostbyname() (https://man7.org/linux/man-pages/man3/gethostbyname.3.html)

can be used to look up the DNS entry by domain name and the function gethostbyaddr()

(https://man7.org/linux/man-pages/man3/gethostbyaddr.3.html) looks up the entry by IP address.

Example: In the following example, we use the function gethostbyname() to look up the DNS
entry for the given domain name. We print out the list of all aliases of this domain name, as well
as all the IP addresses corresponding to this domain name.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-network-programming?module_item_id=24111784 4/6
6/8/24, 2:02 PM Exploration: Network Programming: OPERATING SYSTEMS I (CS_374_400_S2024)

8_1_dns_by_name @cs344

Show files Open on Replit

Network Byte Order and Host Byte Order

Before we conclude this exploration, we want to point out one pitfall that we should be aware of
when writing network programs. This relates to the order of bytes in integer data items and
whether the most significant byte of a word is stored at the smallest memory address or at the
largest memory address.

Systems that store the most significant byte of a word at the smallest memory address and
the least significant byte at the largest address are called big-endian.
Systems that store the least significant byte of a word at the smallest memory address and
the most significant byte at the largest address are called little-endian.

TCP/IP uses big-endianness which means that the most significant byte is transmitted first. This
is termed network byte order and applies to all data items sent in a header across the network.
This means that in the struct in_addr the field s_addr stores the IP address in big-endian order.
Unix provides a number of functions (https://man7.org/linux/man-pages/man3/htonl.3.html)
are provided to convert from host byte order to network byte order and vice versa. These
include:

htonl() to convert an unsigned long int from the host byte order to the network byte order
htons() to convert an unsigned short int from the host byte order to the network byte

order
ntohl() to convert an unsigned long int from the network byte order to the host byte order
ntohs() to convert an unsigned short int from the network byte order to the host byte

order

Additional Resources

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-network-programming?module_item_id=24111784 5/6
6/8/24, 2:02 PM Exploration: Network Programming: OPERATING SYSTEMS I (CS_374_400_S2024)

Here are some references to learn more about the topics we discussed in this exploration.

Fundamentals of TCP/IP networks are discussed in Chapter 58 of The Linux Programming

Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-network-programming?module_item_id=24111784 6/6
6/8/24, 2:02 PM Exploration: Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Sockets
Introduction
Unix provides the sockets API for writhing applications that communicate over the
network. A socket is the endpoint of a communication link between two processes. A client and
a server communicate via a pair of sockets, one socket is at the client process and the other is
at the server process. The sockets API presents the socket for use as an open file with a
(socket) descriptor. Sockets can be used for communication between processes on the same
machine as well as for processes that are running on different machines.

Creating a Socket
To create a socket, we use the function socket() (https://man7.org/linux/man-
pages/man2/socket.2.html) .

#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);

The arguments for this function are as follows:

The argument domain specifies a communication domain which determines the protocol
suite which will be used for communication. We will pass the value AF_INET for this
argument which corresponds to IPv4. To specify IPv6, this argument’s value would be
AF_INET6 .
The argument type specifies the type of the socket. We will use the argument SOCK_STREAM
which is the type for TCP sockets. To create UDP sockets, this argument’s value would be
SOCK_DGRAM .
The argument protocol is useful when multiple protocols exist for a particular socket type
within a given protocol suite. We will pass the value 0 for this argument.

The function socket() creates an endpoint for communication and returns a socket descriptor
that refers to that endpoint. On error, the function returns the value –1. The socket descriptor
returned by socket() is added to the open file descriptor table, which includes entries for all
open files, including stdin , stdout , and stderr .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-sockets?module_item_id=24111785 1/4
6/8/24, 2:02 PM Exploration: Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

Open sockets are included in the file descriptor table: The file descriptor table for a
process includes descriptors for all open sockets in addition to descriptors for all open files,
such as stdin, stdout and stderr.

However, at this point, this socket is not yet ready to be used for reading and writing. Further
calls needs to be made to completely open a socket for reading and writing, which we will study
in the next exploration. Here we look at socket addresses.

Address of a Socket
An IP address identifies an interface on a host machine. But many different processes can be
running on a host. For this reason, an IP address by itself is insufficient to uniquely identify a
process that has opened a socket for communication on the network. In order to uniquely
identify a specific process on a machine, a port number is used in addition to the IP address. A
port number is a 16-bit unsigned integer. Thus, the value of a port number ranges from 0 to
65,535.

Lower numbered port numbers are called well-known ports or system ports. These port
numbers are reserved by applications that implement common services, so that servers for that
application can receive client requests at these ports. Examples of well-known ports include
ports 80 and 8080 for HTTP servers, 22 for SSH, etc.

Ports in the range 49152–65535 are called ephemeral ports or dynamic or private ports. These
port numbers cannot be reserved. A client socket is allocated an ephemeral port number by the
OS.

A socket address consists of an IP address and a port number, and is denoted by

address::port . Socket addresses are stored in structures of type sockaddr_in which is
described below:
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-sockets?module_item_id=24111785 2/4
6/8/24, 2:02 PM Exploration: Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

struct sockaddr_in {
sa_family_t sin_family; /* Address family: AF_INET */
in_port_t sin_port; /* Port number in network byte order */
struct in_addr sin_addr; /* IP address */
};

Note that the values of the address and the port are stored in network byte order. We will need
to call appropriate conversion functions, such as htons() , ntohs() , etc., to convert these value
between network byte order and host byte order.

Example
In the following example, we create a socket address corresponding to the hostname and the
port number passed in as arguments to the program.

8_2_socketaddress.c @cs344

Show files Open on Replit

main

1 ELF

>
�@@(@8 @@@@@@�
�
88@8@

@@ 
�

2 �
3 `�
4 `�� ``�
�
TT@T@ P�td� � @� @<<Q�tdR�td�
5 �
6 `�
7 `
/lib64/ld-linux-x86-64.so.2
GNU

9��?9rIy^q
Pl4W�`libm.so.6__gmon_start__libpthread.so.0libc.so.6exithtonsinet_nt
oamemsetmemcpystderrgethostbynameatoifprintf__libc_start_mainGLIBC_2.14GL
IBC_2.2.5
*����ui ��`�`�``
`(`0`8`@`H` P`
8 X` H��H�
9 H��t��H����5
10 �%

Exercise
Add code to the above program to print the value of the port number value in the variable
address .

Answer

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-sockets?module_item_id=24111785 3/4
6/8/24, 2:02 PM Exploration: Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

A very good free tutorial on network programming using sockets is provided in Beej's Guide
to Network Programming: Using Internet Sockets (http://beej.us/guide/bgnet/) .
Sockets are discussed in Chapter 59 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-sockets?module_item_id=24111785 4/4
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Client-Server Communication

Via Sockets
Introduction
As mentioned in the previous exploration, a newly created socket is not yet ready to
be used for reading and writing. In order to completely open a socket for reading and writing, a
few other system calls need to be made. Different system calls need to made in a client program
to completely open a socket than those that need to be made in a server program. The overall
interaction between the client program and the server program using the socket API, and the
system calls a client and a server need to make, are depicted in the following figure.

Overview of Client & Server Programs for IPC Using Sockets:

The server program creates a listening socket, binds it to a port, and starts listening for
connections.
The server program then starts a loop in which it accepts connections using accept()
system call which creates a connected socket for communication with a client.
The client program creates a socket and then connects to the server socket using the
connect() system call.
Once the connection is established, the client sends data to the server using the send()
system call and receives data from the server using the recv() system call.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 1/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

The server receives data from the client using the recv() system call and sends data to the
client using the send system call.
When communication with this client is complete, the server closes the connected socket
that was being used for communication with this client.

In this exploration, we will first discuss the client program and then the server program.

Note: You may not be able to run the client and the server programs in this exploration on
the repl.it website (https://repl.it) .

Copy the client.c and server.c files to a Unix machine.

Compile these files using gcc and run each of them in a different shell.

Client Program
To communicate to a server process over a socket, the client program does the following:

1. Creates a socket endpoint for the client by calling the function socket() .
2. Sets up a socket address structure sockaddr_in with the IP address and the port number for
the server socket.
3. Calls the function connect() to connect the client socket to the server socket. Successful
call to connect() makes the client socket ready for reading and writing.
4. Uses send() and recv() , or write() and read() , to send data to the server and receive
data from the server over the sockets.
5. Closes the client socket when done.

Example
Here is an example client program that prompts the user for input, sends this input to the server,
and then prints the message received from the server.

Note: You can view the list of files in the repl by using the "Files" icon on the left side. The
file with the client code is named client.c .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 2/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

8_3_client.c @cs344

Show files Open on Replit

client

1 ELF

>
@@8-@8 @@@@@@�
�
88@8@

@@��
``��   `

`�
�
TT@T@ P�tddd@d@LLQ�tdR�td``�
�

/lib64/ld-linux-x86-
64.so.2
GNU
�
��fUa9���!cS8?�DyK�2f� Xt$ ,� `_� `
2 @libc.so.6socketexithtonsperrorconnectstdinfgetsstrlensendmemsetstrcspnr
ecvmemcpystderrgethostbynameatoiclosefprintf__libc_start_mainGLIBC_2.14GL
IBC_2.2.5__gmon_start__


����ui ��` �`
3 � `� ` `
`( `0 `8 `@ `H `P `X `
4 ` ` h `p `x `� `� `� `� `H��H� H��t��H����5 �% @�%
h������%� h
������%� h������%� h������%� h������%� h������%�
h������%� h�p����%� h�`����%� h �P����%� h
5 �@����%� h �0����%� h� ����%� h
6 �����%� h�����%� h������%� h�����1�I��^H��H���PTI��@H���
7 @H���

You can compile the program as follows:

gcc -std=gnu99 -o client client.c

Successfully running the client program requires that the server must already be started. The
client program requires two arguments - the hostname where the server is running and the port
where the server process is listening.

./client $hostname $port

E.g., if the server is running on the same machine as the client and the port number is 49123,
we run the client as follows

./client localhost 49123

Setup the Address Structure for the Server Socket

In the example, we use the function gethostbyname() to look up the DNS entry for the server’s
hostname. We then set up a sockaddr_in structure with the IP address and the port number for
the server socket.

Use connect() to connect the Client Socket to a Server Socket

A client connects to the server socket by calling the connect() system call.

#include <sys/types.h>
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 3/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

The connect() system call connects the client socket specified in the file descriptor sockfd to
the server socket whose address is specified by addr . The addrlen argument specifies the
size of the structure addr . If the connection succeeds, then the function returns 0, otherwise it
returns –1.

Send the Data Using send()

In our program, the client sends data to the server socket using the send() system call
(https://man7.org/linux/man-pages/man2/send.2.html) .

#include <sys/types.h>
#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

This function sends len bytes of data in the buffer buf over the socket sockfd . We are going
to set the flags argument to 0. Note that with flags set to 0, send() system call is equivalent
to the write() system call.

If send() is successful, it returns the number of bytes sent. This number may be less than the
number of bytes we had specified in the len argument because the kernel could not send the
data in one chunk. It is therefore important to check how many bytes were actually sent by
send() and handle partial sends by keep calling send() until all the remaining bytes have been
sent.

Receive the Data Using recv()

In our program, the client receives data from the server socket by using the recv() system call
(https://man7.org/linux/man-pages/man2/recv.2.html) .

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

The recv() system call reads len bytes into the buffer buf from the socket sockfd . We are
going to set the flags argument to 0. Note that with flags set to 0, recv() system call is
equivalent to the read() system call.

By default, the recv() function will block if the connection is open but no data is available. Data
may arrive in odd size bundles. recv() will return exactly the amount of data that has already
arrived. Since data may arrives in odd size bundles, we may need to call the recv() function
multiple times to read the complete message sent on the socket, similar to how we need to
handle partial sends on the send side of the socket.

If the size of the data being sent is not known or can vary, we can use special control codes to
mark the termination of the message. This is similar to how we use @@ as the terminating
characters when using pipes for IPC in a previous module.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 4/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

Note: it is possible to use fcntl() system call to set up the socket to not block on recv() if
there is no data.

Close the Client Socket

When the request has been serviced, the client program closes the client socket.

Server Program
To service client requests over a socket connection, a server process does the following:

1. Creates a socket endpoint for the server by calling the function socket() .
2. Sets up a socket address structure sockaddr_in with the port number at which the server
socket will listen for connections.
3. Call bind() to associate the socket with the socket address.
4. Call listen() on this socket to start listening for client connections. This listening socket

typically exists until the server process ends.

5. Loop and accept connections on the listening socket by calling accept() . Whenever a client
connection request is accepted, a new connected socket is created as the end point of the
connection established between the client and the server.
6. Uses read() and write() , or send() and recv() , to receive and send data to the client
using the connected socket.
7. Closes the connected socket when this client’s service request has completed.

Example
Here is an example server program that accepts connection requests from clients, receives the
message sent by the client, prints out this message, and sends back a response to the client
that the message was received.

Note: You can view the list of files in the repl by using the "Files" icon on the left side. The
file with the server code is named server.c .

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 5/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

8_3_server.c @cs344

Show files Open on Replit

main.c

You can compile the program as follows:

gcc -std=gnu99 -o server server.c

This server program requires one argument - the port where the the server will listen for
connections.

./server $port

e.g.,

./server 49123

Note: Directions to run the client program and the server program from the same shell

Add & at the end of the server startup command, i.e., ./server $port & .
This will start the server process in the background.
Now we can start the client program from that shell as well.

Let us look at socket API for server side programming.

Use bind() to Bind a Socket to a Port

To run a server, we need to specify a port where the clients can send connection requests. The
function bind() is used to associate a socket with the chosen port.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 6/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

#include <sys/types.h>
#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

A socket created by calling the function socket() does not have an address assigned to it. We
use the bind() system call to assign the address addr to the socket sockfd . On success this
function returns 0, otherwise it returns –1.

Use listen() to Listen for Connections

The server will ignore any connection attempts until we tell the socket to start listening for
connections by calling listen() .

#include <sys/types.h>
#include <sys/socket.h>

int listen(int sockfd, int backlog);

The system listen() marks the socket sockfd as a listening socket that will be used to
accept incoming connections using the accept() system call. The argument backlog specifies
the maximum number of pending connection requests for this socket that will be queued up.
Once the queue reaches this number, any client connection requests will receive an error until
the queue gets smaller than this number. On success this function returns 0, other it returns –1.

Accept Client Connection Requests by Calling accept() in a Loop

Servers generally run continually, waiting for clients to contact them. Thus, a server has an
“infinite loop” that continually processes connections from clients by using the accept() system
call.

#include <sys/types.h>
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

The accept() system call takes the first connection request off of the listen queue for the
socket. If the queue is empty and the socket is marked as a blocking socket, then the accept()
call blocks the process until a connection request arrives. The accept() system call creates a
new connected socket for the connection established for this client and returns the file
descriptor of this connected socket. The original listening socket sockfd remains unaffected by
accept() and continues to be used to accept new client connection requests. On error,

accept() returns –1.

Receive the Data Using recv() & Send the Data Using send()
The system calls to receive and send the data in the server program are the same as those
used in the client program.

Close the Connected Socket

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 7/8
6/8/24, 2:02 PM Exploration: Client-Server Communication Via Sockets: OPERATING SYSTEMS I (CS_374_400_S2024)

When the client request has been serviced, the server program closes the connected socket
that had been created for this client request. Note that the listening socket remains open
through the lifetime of the server.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

A very good free tutorial on network programming using sockets is provided in Beej's Guide
to Network Programming: Using Internet Sockets (http://beej.us/guide/bgnet/) . The
tutorial includes sample code (http://beej.us/guide/bgnet/html/#sendall) to handle partial
sends.
Sockets are discussed in Chapter 59 of The Linux Programming Interface.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-client-server-communication-via-sockets?module_item_id=24111786 8/8
6/8/24, 2:02 PM Exploration: Server Design: OPERATING SYSTEMS I (CS_374_400_S2024)

Exploration: Server Design

Introduction
When implementing a server to provide a service, ideally we want our server to
provide low (i.e., rapid) response time, high throughput and get maximum utilization of CPU. We
also want the server design and implementation to be easy. In this exploration, we will examine
various architectures for designing and implementing servers, and how these architectures
compare in providing the desirable properties.

Iterative Servers
We implemented a server in the previous exploration. The server in that example picks up the
client connection at the head of the queue of waiting client requests, services the request of this
client, and then picks up the next client. This server handles only one client at a time, while any
additional clients must wait for all previous requests to complete. Such servers are called
iterative servers.

Iterative servers are easy to design, implement and maintain. However if a service receives a
large number of concurrent client requests, then an iterative server for that service will provide
poor response time to the clients. Furthermore, an iterative server will not maximize CPU
utilization because it will block when it makes an I/O request and will not service other pending
client connections even though it can use the CPU for them until the I/O request completes.

Concurrent Servers
Concurrent servers service, or at least appear to service, multiple client connections at the
same time. Servers can provide concurrency in two ways:

1. Real Concurrency: A server that uses multiple threads or multiple processes to concurrently
service requests from multiple clients.
2. Apparent Concurrency: A server running a single thread of execution that gives the
appearance of concurrency by switching to servicing another client connection whenever an
I/O request blocks servicing one client connection.

Real Concurrency
A server can provide real concurrency by using either multiple threads or multiple processes to
service client connections. Since performance can deteriorate after too many concurrent
connections, such servers put an upper limit on concurrent connections.

Concurrent servers maximize CPU utilization, provide good response time and high throughput.
However, such servers are harder to design, implement, and maintain. There are four different
architectures for such servers, depending on whether they employ threads or processes, and

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-server-design?module_item_id=24111787 1/5
6/8/24, 2:02 PM Exploration: Server Design: OPERATING SYSTEMS I (CS_374_400_S2024)

whether they use a pool of available processes/threads or create a process/thread for each
client connection.

1. One Process Per Client Connection

In this design, the server program forks a new process to handle every connection.

Advantages: The server design and implementation is very simple. There is minimal shared
state between processes that we need to worry about.
Disadvantages: Process creation via fork() is slow. Context-switching between processes
is also slow, but minor compared to fork() .

2. Pool Of Processes For Client Connections

In this design, the server program creates a pool of available processes. When requests for
client connections arrive, an idle process from this pool is assigned to service the request.

Advantages: Since servicing a request does not require the overhead of forking a new
process, the response to client requests is rapid as long as there is an idle process
available.
Disadvantage: Managing the pool of processes can be complex. There is still the overhead
of context switching between processes.

3. One Thread Per Client Connection

In this design, the server program consists of one process which creates a new thread to handle
every connection.

Advantages: Creation of new threads is a lot faster than creation of a new process. Context
switching between threads is also a lot faster than context switching between processes.
Disadvantages: Implementation of such a server is complex because code must be thread-
safe and must not inadvertently share data across different client requests.

4. Pool Of Threads For Client Connections

In this design, the server program consists of one process which creates a pool of threads.
When requests for client connections arrive, an idle thread from this pool is assigned to service
the request.

Advantages: Since servicing a request does not require creation of a new thread, the
response to client requests is rapid as long as there is an idle thread available.
Disadvantages: Implementing the server is complex because of need for thread-safety,
guarding against inadvertent data sharing, and managing the thread pool.

Apparent Concurrency
A server can service multiple client requests concurrently by using I/O multiplexing. In this
design, when an I/O request may block, the server switches to servicing another client. At a
given time, there will be only one active process/thread of execution while other
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-server-design?module_item_id=24111787 2/5
6/8/24, 2:02 PM Exploration: Server Design: OPERATING SYSTEMS I (CS_374_400_S2024)

processes/threads are blocked on I/O. While this approach increases CPU utilization and
throughput, it adds complexity due to the need to track connections, detecting blocking calls and
choosing what to run next.

Using select() for I/O Multiplexing

The basic idea is to use the select() function to suspend the process until one or more of a
specified set of file descriptors are available for use. The select() function allows a program to
monitor multiple file descriptors, waiting until one or more of the file descriptors become “ready”.
A file descriptor is considered to be ready when it is possible to use it to perform an I/O
operation, such as read() or write() , without blocking. Let us look at the details of this
function.

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,

fd_set *exceptfds, struct timeval *timeout);

The three parameters readfds , writefds , and exceptfds are of type fd_set . fd_set is a bit
mask where each bit of the number refers to one file descriptor. Bit 0 is file descriptor 0, bit 1 is
file descriptor 1, and so on.

The arguments of select() are as follows:

nfds : select() will check file descriptors with values up to nfds . nfds should be set to the
highest-numbered file descriptor in any of the three sets, plus 1.
readfds : select() will watch this set to see if reading from any file descriptors in this set
will not block. This will be true if there is data available for reading or if the file descriptor is
already on end-on-file.
writefds : select() will watch this set to see if writing to any file descriptors in this set will

not block, i.e., if space is available for write. However, a large write may still block.
exceptfds : select() will watch this set for exceptional conditions (we will not study the topic

of what exceptional conditions select() watches for).

timeout : This argument specifies a timeout value which is the maximum time select() will
block even if none of the file descriptors being watched become ready.

The select() call blocks until either of the following three conditions becomes true:

A file descriptor becomes ready,

The call is interrupted by a signal handler, or
The timeout expires.

When select() is unblocked, it returns:

A positive integers, if any file descriptors are ready. This integer equals the number of ready
file descriptors,
0 if the timeout expired,
–1 if an error occurred.
https://canvas.oregonstate.edu/courses/1971495/pages/exploration-server-design?module_item_id=24111787 3/5
6/8/24, 2:02 PM Exploration: Server Design: OPERATING SYSTEMS I (CS_374_400_S2024)

The API provides the following macros to manipulate these bit masks:

void FD_ZERO(fd_set *set) sets all bits in set to 0.

void FD_CLR(int fd, fd_set *set) sets the bit in set corresponding to fd to 0.
void FD_SET(int fd, fd_set *set) sets the bit in set corresponding to fd to 1.
int FD_ISSET(int fd, fd_set *set) returns 1 if the bit corresponding to fd is set to 1 in
set , otherwise it returns 0.

Example
The following program uses the select() function to watch stdin for input.

8_4_select.c @cs344

Show files Open on Replit

Here are some comments on the arguments we pass to select() in our program:

We are only watching stdin, i.e., file descriptor 0. We set the value of nfds to 0 + 1, i.e., 1.
We are not interested in watching any file descriptors for writing or for exceptional
conditions, so we set the corresponding arguments to NULL.
We set the timeout value to 25 seconds. If no data is available in stdin for 25 seconds, the
select() function will timeout.

We can run and test this program by clicking on “run” and then using the following three
commands from the command line:

mkfifo myfifo
./main < myfifo &
echo "text" > myfifo

These commands hooks the output of an echo command to the input of our program through a
FIFO.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-server-design?module_item_id=24111787 4/5
6/8/24, 2:02 PM Exploration: Server Design: OPERATING SYSTEMS I (CS_374_400_S2024)

The 1st command creates a FIFO named myfifo .

The 2nd command redirects stdin of our program to myfifo and starts the program as a
background process.
The 3rd command writes data to myfifo .

This causes the select call in our program to detect that stdin has data and our program is
unblocked.

Additional Resources
Here are some references to learn more about the topics we discussed in this exploration.

Server design is discussed in Chapter 60 of The Linux Programming Interface, while I/O
multiplexing is discussed in Chapter 63.
Kerrisk, M. (2010). The Linux programming interface : a Linux and UNIX system programming handbook. San
Francisco: No Starch Press.

https://canvas.oregonstate.edu/courses/1971495/pages/exploration-server-design?module_item_id=24111787 5/5
6/8/24, 2:03 PM Review - Module 5: OPERATING SYSTEMS I (CS_374_400_S2024)

Review - Module 5
Key Take-Aways
At this point, you should be able to answer all of the following questions.

What are the different categories of IPC facilities?

What are the IPC facilities for communication and how do these facilities compare with each
other?
What are the IPC facilities for synchronization?
What are pipes and FIFOs?
What is the API for using pipes and FIFOs?
What are semaphores?
What is the appropriate use case for binary semaphores?
What is the appropriate use case for counting semaphores?
How can you use the API for semaphores to co-ordinate the action of multiple processes or
threads?
What is a server and what is a client?
What is the typical interaction between a client and a server?
What are the different layers in the TCP/IP model?
What common protocols are used at different layers?
What is an IP address?
What are domain names and what is DNS?
What is network byte order and what is host byte order? How do you ensure that your
programs properly handle any difference in network vs. host byte orders?
What is a socket and how we can create sockets?
What is a socket address?
What functions does a client need to call to connect with a server and send requests using
sockets?
What functions does a server need to call to service requests from a client over socket
connections?
What are iterative servers and what are concurrent servers?
What are the different designs for implementing concurrent servers?
What is I/O multiplexing and how can we use it in our programs?

(https://canvas.oregonstate.edu/courses/1971495/modules)

https://canvas.oregonstate.edu/courses/1971495/pages/review-module-5-2?module_item_id=24445919 1/1