Govt.
Graduate College Sheikhupura
(PU Affiliated)
CC-311L Operating Systems Lab
Lab Manual 3
This lab is about syntax and usage of the following system
calls
1. read() 2. write()
Instructions:
read() and write() system calls are used to read and write data respectively to a
file descriptor. To understand the concept of write()/read() system calls let us
first start with write() system call.
write() system call is used to write to a file descriptor. In other words write() can
be used to write to any file (all hardware are also referred as file in Linux) in the
system but rather than specifying the file name, you need to specify its file
descriptor.
Syntax:
#include<unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
The first parameter (fd) is the file descriptor where you want to write. The data
that is to be written is specified in the second parameter. Finally, the third
parameter is the total bytes that are to be written.
To understand better lets look at the first program below:
Program1: To write some data on the standard output device (by default –
monitor)
//Name the program file as “write.c”
#include<unistd.h>
int main()
{
write(1,"hello\n",6); //1 is the file descriptor, "hello\n"
is the data, 6 is the count of characters in data
}
Lecturer: Muhammad Kamran
Govt. Graduate College Sheikhupura
(PU Affiliated)
How it works?
The write() system call takes three parameters: “1” which is the file descriptor of
the file where we want to write. Since we want to write on standard output
device which is the screen, hence the file descriptor, in this case, is ‘1’, which is
fixed (0 is the file descriptor for standard input device (e.g. keyboard) and 2 is for
standard error device)).
Next thing is what we want to write on the screen. In this case its “hello\n” i.e.
hello and newline(\n), so a total of 6 characters, which becomes the third
parameter. The third parameter is how much you want to write, which may be
less than the data specified in the second parameter. You can play around and
see the change in output.
Output:
Once you compile and run this, the output on the screen will be the word “hello”,
as shown below
On success, the write() system call returns the ‘number of bytes written’ i.e. the
count of how many bytes it could write. This you can save in an integer variable
and checked. The write() system call on failure returns -1.
Note: students get confused by thinking that write() return the data that is
written. Remember, it returns the count of characters written. Refer to the
program below.
Program 2
#include<stdio.h>
#include<unistd.h>
int main()
{
int count; count=write(1,"hello\n",6); printf("Total bytes
written: %d\n",count);
}
How it Works?
The program is similar to the previous one except that this time it also explicitly
prints the count of bytes that write() system call was able to write on file
descriptor 1.
Lecturer: Muhammad Kamran
Govt. Graduate College Sheikhupura
(PU Affiliated)
Output:
Variations
Try making the changes as shown in the codes below and observe the output to
understand the working of the write() system call in detail.
Program 3:
#include<unistd.h>
int main()
{
write(1,"hello\n",60); //the bytes to be printed (third
parameter) are more than the data specified in 2nd parameter
}
Program4:
#include<unistd.h>
int main()
{
write(1,"hello\n",3);//the bytes to be printed (third
parameter) are less than the data specified in 2nd parameter
}
Program5:
#include<unistd.h>
#include<stdio.h>
int main()
{
int count; count=write(3,"hello\n",6); //the file descriptor
is not one of the pre-specified ones i.e., 0, 1 or 2
printf("Total bytes written: %d\n",count);
}
Will this call to write() be successful? If not then what will it return?
Lecturer: Muhammad Kamran
Govt. Graduate College Sheikhupura
(PU Affiliated)
read()
The use of read() system call is to read from a file descriptor. The working is
same as write(), the only difference is read() will read the data from file pointed to
by file descriptor.
Syntax:
#include<unistd.h>
ssize_t read(int fd, const void *buf, size_t count);
The first parameter is the file descriptor. The second parameter is the buffer
where the read data will be saved. Lastly, the third parameter is the number of
bytes that you want to read.
Think of the buffer as a temporary storing area. As you are reading from this
page and before typing the program on your system you temporarily store it in
your brain. So your brain is the buffer. Although this page contains a lot of data,
you might want to read only 20 characters. Hence, the third parameter (count)
tells, how much you want to read?
Program 6: To read data from the standard input device and write it on the
screen
//read.c
#include<unistd.h>
int main()
{
char buff[20]; read(0,buff,10);//read 10 bytes from
standard input device(keyboard), store in buffer (buff)
write(1,buff,10);//print 10 bytes from the buffer on the
screen
}
How it works?
The read() system call reads the input typed by the user via the keyboard (file
descriptor 0) and stores it in the buffer (buff) which is nothing but a character
array. It will read a maximum of 10 bytes (because of the third parameter). This
can be less than or equal to the buffer size. No matter how much the user types
only first 10 characters will be read.
Finally, the data is printed on the screen using the write() system call. It prints the
same 10 bytes from the buffer (buff) on the screen (file descriptor 1).
Output:
Lecturer: Muhammad Kamran
Govt. Graduate College Sheikhupura
(PU Affiliated)
Variations: you can try different values of the third parameter in read and write to
understand the working better.
The read() system call returns -1 on failure and “the count of bytes read” on
success.
Important:
A common question that comes to our mind is that as a programmer you can
not guarantee how much the user will type as an input. Hence, you can not
specify the correct bytes in write() systemc all’s 3rd parameter. Hence, the
output may vary from what you expect.
Now, remember what read() returns on success! the number of bytes read, and
that’s the key as demonstrated below.
Program 7: To read data from the standard input device and write it on the
screen
//read.c
#include<unistd.h>
int main()
{
int nread; char buff[20]; nread=read(0,buff,10);//read 10
bytes from standard input device(keyboard), store in buffer
(buff) write(1,buff,nread);//print 10 bytes from the buffer
on the screen
}
How it works?
This time we store the count of bytes read by read() in nread variable and then
use variable in the write() to print exactly the same number of bytes on the
screen.
Lecturer: Muhammad Kamran
Govt. Graduate College Sheikhupura
(PU Affiliated)
Practice Programs on write()/read() system call
Q1. Write a program to read a maximum of 15 characters from the user and print
them on the screen.
Q2. Write a program to print the count of characters read by the read() system
call.
Viva Questions on write()/read() system call
Q1. What does the write() system call return on success?
Q2. What does the write() system call return on failure?
Q3. Can you use write() system to send data to a printer?
Q4. Can write system be used to write into a file “xyz.txt” without knowing the
file descriptor of xyz.txt?
Q5. How to access the manual page of write()?
Q6. What does the read() system call return on success
Lecturer: Muhammad Kamran
