System Calls and I/O

CS 241
January 27, 2012

Copyright ©: University of Illinois CS 241 Staff 1

This lecture
  Goals
  Get you familiar with necessary basic system & I/O calls to
do programming

  Things covered in this lecture

  Basic file system calls
  I/O calls
  Signals

  Note: we will come back later to discuss the above

things at the concept level
Copyright ©: University of Illinois CS 241 Staff 2
System Calls versus Function
Calls?

Copyright ©: University of Illinois CS 241 Staff 3

 System Calls versus Function
Calls
Function Call

Process

fnCall()

Caller and callee are in the same

Process
- Same user
- Same “domain of trust”

Copyright ©: University of Illinois CS 241 Staff 4

 System Calls versus Function
Calls
Function Call System Call

Process Process

fnCall() sysCall()

OS

Caller and callee are in the same

Process
- Same user - OS is trusted; user is not.
- Same “domain of trust” -  OS has super-privileges; user does not
-  Must take measures to prevent abuse
Copyright ©: University of Illinois CS 241 Staff 5
System Calls
  System Calls
  A request to the operating system to perform some activity
  System calls are expensive
  The system needs to perform many things before
executing a system call
  The computer (hardware) saves its state
  The OS code takes control of the CPU, privileges are
updated.
  The OS examines the call parameters
  The OS performs the requested function
  The OS saves its state (and call results)
  The OS returns control of the CPU to the caller

Copyright ©: University of Illinois CS 241 Staff 6

 Steps for Making a System
Call (Example: read call)
count = read(fd, buffer, nbytes);

9: Return to user
6: Switch to kernel mode
mode (return
address saved on 10: Return to user
stack) program (via trap)
4 – 5: Library call
(puts syscall # in 11: Clean up
CPU register)
1 – 3: Push
parameter (in
7: Find system call
reverse order) handler
8: Run handler
(index via table of
pointers to
Copyright ©: University of Illinois CS 241 Staff
syscall handles)
7
Examples of System Calls

  Examples
  getuid() //get the user ID
  fork() //create a child process
  exec() //executing a program
  Don’t mix system calls with standard library
calls
man syscalls
  Differences?
  Is printf() a system call?
  Is rand() a system call?

Copyright ©: University of Illinois CS 241 Staff 8

 Major System Calls
Process Management
pid = fork( ) Create a child process identical to the parent

pid = waitpid(pid, &statloc, options) Wait for a child to terminate

s = execve(name, argv, environp) Replace a process’ core image

exit(status) Terminate process execution and return status

File Management Today

fd = open(file, how, ...) Open a file for reading, writing or both

s = close(fd) Close an open file

n = read(fd, buffer, nbytes) Read data from a file into a buffer

n = write(fd, buffer, nbytes) Write data from a buffer into a file

position = lseek(fd, offset, whence) Move the file pointer

s = stat(name, &buf) Get a file’s status information

Copyright ©: University of Illinois CS 241 Staff 9

 Major System Calls
Directory and File System Management
s = mkdir(name, mode) Create a new directory

s = rmdir(name) Remove an empty directory

s = link(name, name) Create a new entry, name, pointing to name

s = unlink(name) Remove a directory entry

s = mount(special, name, flag) Mount a file system

s = umount(special) Unmount a file system

Miscellaneous
s = chdir(dirname) Change the working directory

s = chmod(name, mode) Change a file’s protection bits

s = kill(pid, signal) Send a signal to a process

seconds = time(&seconds) Get the elapsed time since January 1, 1970

Copyright ©: University of Illinois CS 241 Staff 10

File System and I/O Related
System Calls

  A file system
  A means to organize, retrieve, and
updated data in persistent storage
  A hierarchical arrangement of directories
  Bookkeeping information (file metadata)
  File length, # bytes, modified timestamp, etc
  Unix file system
  Root file system starts with “/”

Copyright ©: University of Illinois CS 241 Staff 11

Why does the OS control I/O?

  Safety
  The computer must ensure that if a program has
a bug in it, then it doesn't crash or mess up
  The system
  Other programs that may be running at the same time
or later
  Fairness
  Make sure other programs have a fair use of
device

Copyright ©: University of Illinois CS 241 Staff 12

Basic Unix Concepts
  Input/Output – I/O
  Per-process table of I/O channels
  Table entries describe files, sockets, devices, pipes, etc.
  Table entry/index into table called “file descriptor”
  Unifies I/O interface

user space kernel

system open file
file
table

pipe

Per-process file
descriptor socket
table

Copyright ©: University of Illinois CS 241 Staff 13

Basic Unix Concepts
  Error Model
  errno variable
  Unix provides a globally accessible integer variable that contains an
error code number
  Return value
  0 on success
  -1 on failure for functions returning integer values
  NULL on failure for functions returning pointers
  Examples (see errno.h)
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define ENXIO 6 /* No such device or address */

Copyright ©: University of Illinois CS 241 Staff 14

System Calls for I/O
  Get information about a file
int stat(const char* name, struct stat* buf);
  Open (and/or create) a file for reading, writing or both
int open (const char* name, in flags);
  Read data from one buffer to file descriptor
size_t read (int fd, void* buf, size_t cnt);
  Write data from file descriptor into buffer
size_t write (int fd, void* buf, size_t cnt);
  Close a file
int close(int fd);

Copyright ©: University of Illinois CS 241 Staff 15

System Calls for I/O

  They look like regular procedure calls but

are different
  A system call makes a request to the operating
system by trapping into kernel mode
  A procedure call just jumps to a procedure
defined elsewhere in your program
  Some library procedure calls may
themselves make a system call
  e.g., fopen() calls open()

Copyright ©: University of Illinois CS 241 Staff 16

File: Statistics
#include <sys/stat.h>
int stat(const char* name, struct stat* buf);
  Get information about a file
  Returns:
  0 on success
  -1 on error, sets errno
  Parameters:
  name: Path to file you want to use
  Absolute paths begin with “/”, relative paths do not
  buf: Statistics structure
  off_t st_size: Size in bytes
  time_t st_mtime: Date of last modification. Seconds since January 1,
1970
  Also
int fstat(int filedes, struct stat *buf);

Copyright ©: University of Illinois CS 241 Staff 17

Example - (stat())
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
int main(int argc, char **argv) {
struct stat fileStat;
if(argc != 2)
return 1;
if(stat(argv[1], &fileStat) < 0)
return 1;
printf("Information for %s\n",argv[1]);
printf("---------------------------\n");
printf("File Size: \t\t%d bytes\n", fileStat.st_size);
printf("Number of Links: \t%d\n", fileStat.st_nlink);
printf("File inode: \t\t%d\n", fileStat.st_ino);
Copyright ©: University of Illinois CS 241 Staff 18
Example - (stat())
printf("File Permissions: \t");
printf( (S_ISDIR(fileStat.st_mode)) ? "d" : "-");
printf( (fileStat.st_mode & S_IRUSR) ? "r" : "-");
printf( (fileStat.st_mode & S_IWUSR) ? "w" : "-");
printf( (fileStat.st_mode & S_IXUSR) ? "x" : "-");
printf( (fileStat.st_mode & S_IRGRP) ? "r" : "-");
printf( (fileStat.st_mode & S_IWGRP) ? "w" : "-");
printf( (fileStat.st_mode & S_IXGRP) ? "x" : "-");
printf( (fileStat.st_mode & S_IROTH) ? "r" : "-");
printf( (fileStat.st_mode & S_IWOTH) ? "w" : "-");
printf( (fileStat.st_mode & S_IXOTH) ? "x" : "-");
printf("\n\n"); printf("The file %s a symbolic link\n",
(S_ISLNK(fileStat.st_mode)) ? "is" : "is not");
return 0;
}

Copyright ©: University of Illinois CS 241 Staff 19

Useful Macros: File types

  Is file a symbolic   Is file a block

link device
  S_ISLNK   S_ISBLK
  Is file a regular file   Is file a FIFO
  S_ISREG   S_ISFIFO
  Is file a character   Is file a unix socket
device   S_ISSOCK
  S_ISCHR

Copyright ©: University of Illinois CS 241 Staff 20

Useful Macros: File Modes
  S_IRWXU   S_IRGRP
  read, write, execute/   read permission, group
search by owner   S_IRWXO
  S_IRUSR   read, write, execute/
  read permission, owner search by others
  S_IWUSR
  write permission, owner
  S_IXUSR
  execute/search
permission, owner

Copyright ©: University of Illinois CS 241 Staff 21

Example - (stat())
Information for testfile.sh
---------------------------
File Size: 36 bytes
Number of Links: 1
File inode: 180055
File Permissions: -rwxr-xr-x

The file is not a symbolic link

Copyright ©: University of Illinois CS 241 Staff 22

File: Open
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open (const char* path, int flags [, int mode ]);
  Open (and/or create) a file for reading, writing or both
  Returns:
  Return value ≥ 0 : Success - New file descriptor on success
  Return value = -1: Error, check value of errno
  Parameters:
  path: Path to file you want to use
  Absolute paths begin with “/”, relative paths do not
  flags: How you would like to use the file
  O_RDONLY: read only, O_WRONLY: write only, O_RDWR: read and write,
O_CREAT: create file if it doesn’t exist, O_EXCL: prevent creation if it already
exists

Copyright ©: University of Illinois CS 241 Staff 23

Example (open())
#include <fcntl.h>
#include <errno.h>
Argument: string
extern int errno; Output: the string, a colon, and a
description of the error condition
main() { stored in errno
int fd;
fd = open("foo.txt", O_RDONLY | O_CREAT);
printf("%d\n", fd);
if (fd=-1) {
printf ("Error Number %d\n", errno);
perror("Program");
}
}
Copyright ©: University of Illinois CS 241 Staff 24
File: Close
#include <fcntl.h>
int close(int fd);
  Close a file
  Tells the operating system you are done with a file
descriptor
  Return:
  0 on success
  -1 on error, sets errno
  Parameters:
  fd: file descriptor

Copyright ©: University of Illinois CS 241 Staff 25

Example (close())
#include <fcntl.h>
main(){
int fd1;

if(( fd1 = open(“foo.txt", O_RDONLY)) < 0){

perror("c1");
exit(1);
}
if (close(fd1) < 0) {
perror("c1");
exit(1);
}
printf("closed the fd.\n");
Copyright ©: University of Illinois CS 241 Staff 26
Example (close())
#include <fcntl.h>
main(){
int fd1;

if(( fd1 = open(“foo.txt", O_RDONLY)) < 0){

perror("c1");
exit(1);
} After close, can you still use the
file descriptor?
if (close(fd1) < 0) {
perror("c1");
exit(1); Why do we need to close a file?
}
printf("closed the fd.\n");
Copyright ©: University of Illinois CS 241 Staff 27
File: Read
#include <fcntl.h>
size_t read (int fd, void* buf, size_t cnt);
  Read data from one buffer to file descriptor
  Read size bytes from the file specified by fd into the memory location
pointed to by buf
  Return: How many bytes were actually read
  Number of bytes read on success
  0 on reaching end of file
  -1 on error, sets errno
  -1 on signal interrupt, sets errno to EINTR
  Parameters:
  fd: file descriptor
  buf: buffer to read data from
  cnt: length of buffer
Copyright ©: University of Illinois CS 241 Staff 28
File: Read
size_t read (int fd, void* buf, size_t cnt);
  Things to be careful about
  buf needs to point to a valid memory location with length
not smaller than the specified size
  Otherwise, what could happen?
  fd should be a valid file descriptor returned from open()
to perform read operation
  Otherwise, what could happen?
  cnt is the requested number of bytes read, while the
return value is the actual number of bytes read
  How could this happen?

Copyright ©: University of Illinois CS 241 Staff 29

 Example (read())
#include <fcntl.h> sz = read(fd, c, 10);
main() { printf("called
char *c; read(%d, c, 10).
int fd, sz; returned that %d
bytes were
c = (char *) malloc(100 read.\n", fd, sz);
* sizeof(char)); c[sz] = '\0';
fd = open(“foo.txt",
O_RDONLY); printf("Those bytes
if (fd < 0) { are as follows:
perror("r1"); %s\n", c);
exit(1); close(fd);
} }
Copyright ©: University of Illinois CS 241 Staff 30
File: Write
#include <fcntl.h>
size_t write (int fd, void* buf, size_t cnt);
  Write data from file descriptor into buffer
  Writes the bytes stored in buf to the file specified by fd
  Return: How many bytes were actually written
  Number of bytes written on success
  0 on reaching end of file
  -1 on error, sets errno
  -1 on signal interrupt, sets errno to EINTR
  Parameters:
  fd: file descriptor
  buf: buffer to write data to
  cnt: length of buffer

Copyright ©: University of Illinois CS 241 Staff 31

File: Write
size_t write (int fd, void* buf, size_t cnt);
  Things to be careful about
  The file needs to be opened for write operations
  buf needs to be at least as long as specified by
cnt
  If not, what will happen?
  cnt is the requested number of bytes to write,
while the return value is the actual number of
bytes written
  How could this happen?

Copyright ©: University of Illinois CS 241 Staff 32

Example (write())
#include <fcntl.h> sz = write(fd, "cs241\n",
main() strlen("cs241\n"));
{
int fd, sz; printf("called write(%d,
\"cs360\\n\", %d).
fd = open("out3", it returned %d\n",
O_RDWR | O_CREAT | fd, strlen("cs360\n"),
O_APPEND, 0644); sz);
if (fd < 0) {
perror("r1"); close(fd);
exit(1); }
}

Copyright ©: University of Illinois CS 241 Staff 33

File Pointers

  All open files have a "file pointer" associated

with them to record the current position for
the next file operation
  On open
  File pointer points to the beginning of the file
  After reading/write m bytes
  File pointer moves m bytes forward

Copyright ©: University of Illinois CS 241 Staff 34

File: Seek
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);
  Explicitly set the file offset for the open file
  Return: Where the file pointer is
  the new offset, in bytes, from the beginning of the file
  -1 on error, sets errno, file pointer remains unchanged
  Parameters:
  fd: file descriptor
  offset: indicates relative or absolute location
  whence: How you would like to use lseek
  SEEK_SET, set file pointer to offset bytes from the beginning of the file
  SEEK_CUR, set file pointer to offset bytes from current location
  SEEK_END, set file pointer to offset bytes from the end of the file
Copyright ©: University of Illinois CS 241 Staff 35
File: Seek Examples

  Random access
  Jump to any byte in a file
  Move to byte #16
newpos = lseek(fd, 16, SEEK_SET);
  Move forward 4 bytes
newpos = lseek(fd, 4, SEEK_CUR);
  Move to 8 bytes from the end
newpos = lseek(fd, -8, SEEK_END);

Copyright ©: University of Illinois CS 241 Staff 36

 Example (lseek())
c = (char *) malloc(100 * i = lseek(fd, 0, SEEK_CUR);
sizeof(char)); printf("lseek(%d, 0, SEEK_CUR)
fd = open(“foo.txt", O_RDONLY); returns that the current
if (fd < 0) { offset is %d\n\n", fd, i);
perror("r1");
exit(1); printf("now, we seek to the
} beginning of the file and
call read(%d, c, 10)\n",
fd);
sz = read(fd, c, 10); lseek(fd, 0, SEEK_SET);
printf("We have opened in1, and sz = read(fd, c, 10);
called read(%d, c, 10).\n",
fd); c[sz] = '\0';
printf("The read returns the
c[sz] = '\0';
following bytes: %s\n", c);
printf("Those bytes are as
…
follows: %s\n", c);

Copyright ©: University of Illinois CS 241 Staff 37

Standard Input, Standard
Output and Standard Error
  Every process in Unix has three predefined file descriptors
  File descriptor 0 is standard input (STDIN)
  File descriptor 1 is standard output (STDOUT)
  File descriptor 2 is standard error (STDERR)
  Read from standard input,
  read(0, ...);
  Write to standard output
  write(1, ...);
  Two additional library functions
  printf();
  scanf();

Copyright ©: University of Illinois CS 241 Staff 38

 I/O Library Calls
  Every system call has paired procedure calls from the
standard I/O library:
  System Call   Standard I/O call (stdio.h)
  open   fopen
  close   fclose
  read/write   getchar/putchar, getc/
putc, fgetc/fputc,
fread/fwrite, gets/
puts, fgets/fputs,
scanf/printf, fscanf/
fprintf
  lseek   fseek

Copyright ©: University of Illinois CS 241 Staff 39

Stream Processing - fgetc()
int fgetc(FILE *stream);
  Read the next character from stream

  Return
  An unsigned char cast to an int
  EOF on end of file Similar functions for writing:
  Error int fputc(int c, FILE *stream);
int putchar(int c);
int getchar(void); int putc(int c, FILE *stream);
  Read the next character from stdin
int getc(void);
  Similar to , but implemented as a macro, faster and
potentially unsafe
Copyright ©: University of Illinois CS 241 Staff 40
Stream Processing - fgets()
char *fgets(char *s, int size, FILE
*stream);
  Read in at most one less than size characters
from stream
  Stores characters in buffer pointed to by s.
  Reading stops after an EOF or a newline.
  If a newline is read, it is stored into the buffer.
  A '\0' is stored after the last character in the buffer.
  Return Similar:
int fputs(const char *s, FILE *stream);
  s on success
  NULL on error or on EOF and no characters read

Copyright ©: University of Illinois CS 241 Staff 41

Stream Processing
char *gets(char *s);
  Reads a line from stdin

  NOTE: DO NOT USE

  Reading a line that overflows the array pointed to by s
causes undefined results.
  The use of is fgets() recommended

Copyright ©: University of Illinois CS 241 Staff 42

Stream Processing - fputs()
int fputs(const char *s, FILE *stream);
  Write the null-terminated string pointed to by s to
the stream pointed to by stream.
  The terminating null byte is not written
  Return
  Non-neg number on success
  EOF on error
char *puts(char *s);
  Write to stdout
  Appends a newline character

Copyright ©: University of Illinois CS 241 Staff 43

Example: (fgets()- fputs())
#include <stdio.h>
int main() {
FILE * fp = fopen("test.txt", "r");
char line[100];
while( fgets(line, sizeof(line), fp) != NULL )
fputs(line, stdout);
fclose(fp);
return 0;
}

Copyright ©: University of Illinois CS 241 Staff 44

Stream Processing - fscanf()
int scanf(const char *format, ... );
  Read from the standard input stream stdin
  Stores read characters in buffer pointed to by s.
  Return
  Number of successfully matched and assigned input items
  EOF on error

int fscanf(FILE *stream, const char *fmt, ... );

  Read from the named input stream
int sscanf(const char *s, const char *fmt, ... );
  Read from the string s

Copyright ©: University of Illinois CS 241 Staff 45

Example: (scanf())
  Input: 56789 56a72

#include <stdio.h>
int main() {
What are i, x, and name
int i; after the call to
float x; scanf()?
char name[50];
scanf("%2d%f %[0123456789]", &i, &x, name);
}
What will a subsequent call to
getchar()return?
Copyright ©: University of Illinois CS 241 Staff 46
Example: stdin
int x;
char st[31]; What will
this code
/* read first line of input */ really do?
printf("Enter an integer: ");
scanf("%d", &x);

/* read second line of input */

printf("Enter a line of text: ");
fgets(st, 31, stdin);

Copyright ©: University of Illinois CS 241 Staff 47

Example: stdin
int x;
char st[31]; What will
this code
/* read first line of input */ really do?
printf("Enter an integer: ");
scanf("%d", &x);

/* read second line of input */

printf("Enter a line of text: ");
fgets(st, 31, stdin);
Input is buffered, but scanf() did not read all of
the first line
Copyright ©: University of Illinois CS 241 Staff 48
Example: stdin
int x; void dump_line( FILE *
char st[31]; fp ) {
/* read first line */ int ch;
printf("Enter an while((ch = fgetc(fp))
integer: "); != EOF &&
scanf("%d", &x); ch != '\n' )
dump_line(stdin); /* null body */;
/* read second line */ }
printf("Enter a line of Read and dump all
text: ");
characters from input
fgets(st, 31, stdin);
buffer until a '\n'
after scanf()
Copyright ©: University of Illinois CS 241 Staff 49