UNIX System Calls. Sys Calls versus Library Func

Transcription

1 UNIX System Calls Entry points to the kernel Provide services to the processes One feature that cannot be changed Definitions are in C For most system calls a function with the same name exists in the library Both library functions and system calls provide services to application programs Sys Calls versus Library Func malloc() versus sbrk() more functionality versus minimal interface malloc(): provide a simple, general-purpose memory allocation package using sbrk sbrk(): changes the amount of space allocated for the calling process's data segment 1

2 System Calls: Major Areas File I/O open, read, write a file File system properties of a file, directories and inodes Process control creation of new processes, executing programs and terminating processes Interprocess communication half duplex pipes Signals UNIX System Calls blue 303 % man -s2 intro NAME Intro, intro - introduction to system calls and error numbers SYNOPSIS #include <errno.h> DESCRIPTION This section describes all of the system calls. Most of these calls return one or more error conditions. An error condition is indicated by an otherwise impossible return value. This is almost always -1 or the null pointer; the individual descriptions specify the details. An error number is also made available in the external variable errno, which is not cleared on successful calls, so it should be tested only after an error has been indicated. 2

3 Error Processing All system calls can incur errors Usually a return value of -1 indicates error, however this does not tell us what went wrong System also leaves an error number in an external integer called errno errno is used as an index into table (sys_errlist) to get a description The standard library function perror can be use to print system error messages: void perror(const char *s); Example: errno/perror blue 338 % cat badfileio.c #include<stdio.h> #include<errno.h> #define SIZE 512 int main(int argc, char *argv[]) { char buf[size]; int n; n = read(4, buf, sizeof buf); perror(argv[0]); printf("n = %d, errno = %d\n", n, errno); return 1; blue 339 % cc badfileio.c blue 340 % a.out a.out: Bad file number n = -1, errno = 9 blue 341 % For a list of errno values see man -s2 intro errno in initially set to zero It must be reset if program continues after an error 3

4 Applications do File I/O read/write files in chunks of convenient sizes Kernel does buffer data in chunks that match peripheral devices, and schedules operations to optimize performance All I/O including terminals, peripheral devices and interprocess communication are done using files File Descriptors A file descriptor is a small non-negative integer used by the Kernel to refer to an open file Before reading/writing a file, we need to open or create it Upon successful open or create operation the system returns a file descriptor All access to the file is done through the file descriptor Structure of type FILE contains a file descriptor which can be accessed using fileno() 4

5 File Descriptors By convention shells associate 0 with standard input 1 with standard out 2 with standard error Not a feature of kernel but applications need to follow When a program opens other files they will have numbers 3, 4, etc. File I/O Most file IO is performed using: int open(const char *path, int oflag, /* mode_t mode */...); ssize_t read(int fildes, void *buf, size_t nbyte); ssize_t write(int fildes, const void *buf, size_t nbyte); off_t lseek(int fildes, off_t offset, int whence); int close(int fildes); Primitive system data types (*_t): usually defined in <sys/types.h> and included by <unistd.h> 5

6 #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> System Calls: open int open(const char *path, int oflag, /* mode_t mode */...); path points to a pathname naming the file lowest file descriptor not currently open for that process is returned description is new and not shared with other processes offset is set to the beginning of the file status flags and access modes are set according to oflag mode argument is used only when O_CREAT is specified System Calls: open Values for oflag are constructed by a bitwiseinclusive-or of flags defined in <fcntl.h> Applications must specify exactly one of the values (file access modes) in oflag: O_RDONLY Open for reading only. O_WRONLY Open for writing only. O_RDWR writing. Open for reading and Most implementations define O_RDONLY = 0, O_WRONLY = 1, O_RDWR = 2 6

7 Example: open/read/write blue 474 % cat fileio.c #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int main(int argc, char *argv[]) { int nw, nr, fd; char buf[] = "COSC2031"; fd = open(argv[1], O_CREAT O_RDWR, 0640); if (fd == -1){ perror(argv[0]); return 1; nw = write(fd, buf, sizeof buf); if (nw!= sizeof buf){ perror(argv[0]); return 1; close(fd); mode cannot overwrite umask value may also use creat for creating a new file How Many Open Files There is a limit for number of open files for a given process => close the ones you do not need for (i =0; i < 10000; i++){ fd = open(argv[1], O_CREAT O_RDWR, 0640); printf("fd = %d\n", fd); if (fd == -1){ perror(argv[0]); exit(1);.. fd = 254 fd = 255 fd = -1 a.out: Too many open files 7

8 System Calls: read/write All I/O is done by read and write nread = read(fd, buf, n); read n bytes from fd file to buf nwrite = write(fd, buf, n); write n bytes from buf to fd file Both return number of bytes actually transferred (nread == 0) => eof (nwrite!= n) => error Random Access: lseek pos = lseek (fd, offset, whence); sets the file pointer based on whence SEEK_SET: to offset bytes SEEK_CUR: to current location + offset SEEK_END: to the size of the file + offset offset may be negative returns current position Note that file I/O is sequential read/write takes place in current position 8

9 File Status: stat, lstat, fstat Obtains information about the file #include <sys/types.h> #include <sys/stat.h> int stat(const char *path, struct stat *buf); int lstat(const char *path, struct stat *buf); int fstat(int fildes, struct stat *buf); stat Structure A stat structure includes members: mode_t st_mode; /* File mode (see mknod(2)) */ ino_t st_ino; /* Inode number */ dev_t st_dev; /* ID of device containing */ dev_t st_rdev; /* ID of device */ nlink_t st_nlink; /* Number of links */ uid_t st_uid; /* User ID of the file's owner */ gid_t st_gid; /* Group ID of the file's group */ off_t st_size; * File size in bytes */ time_t st_atime; /* Time of last access */ time_t st_mtime; /* Time of last data modification */ time_t st_ctime; /* Time of last file status change */ 9

10 Process Control pid_t fork(void); create a new process exec, execl, execv, execle, execve, execlp, execvp execute a file void exit(int status); terminate a process #include <sys/types.h> #include <unistd.h> Example: fork/wait int main (int argc, char *argv[]) { int pid = fork(); if (pid == -1){ perror(argv[0]); exit(1); if (pid == 0) { /* child executes here */ printf("child output: %s\n", argv[1]); exit(0); else { /* parent executes here */ int childstatus; wait(&childstatus); printf("parent output: %s\n", argv[2]); exit(0); 1

11 System Calls: fork/wait fork creates a new process The new process (child process) is an exact copy of the calling process (parent process) The child process inherits, among other things, the following attributes from the parent process: real user ID, real group ID, effective user ID, effective group ID environment open file descriptors current working directory root directory file mode creation mask blue 373 % cat race.c int main () { int pid, i; if ( (pid = fork()) == 0) { /* child executes here */ for (i=0; i < 5; i++) printf("%s\n", "Child"); else { /* parent executes here */ for (i=0; i < 5; i++) printf("%s\n", "Parent"); Race Condition blue 372 % a.out Parent Child Child Parent Child Child Child Parent Parent Parent blue 373 % 1

12 System Calls: fork/wait The child starts running at the first statement after the fork After the fork two processes are independent Children can create children of their own The parent may execute a wait to wait for the child to complete its task wait returns the process-id of the terminated child System Calls: exec Family exec, execl, execv, execle, execve, execlp, execvp Each functions replaces the current process image with a new process image The new image is constructed from a regular, executable file: either an executable object file, or a file of data for an interpreter Calling process image is overlaid by the new process image NO RETURN from a successful exec 1

13 System Calls: exec Family #include <unistd.h> int execl(const char *path, const char *arg0,..., const char *argn, char * /*NULL*/); int execv(const char *path, char *const argv[]); int execle(const char *path, const char *arg0,..., const char *argn, char * /*NULL*/, char *const envp[]); int execve(const char *path, char *const argv[], char *const envp[]); int execlp(const char *file, const char *arg0,..., const char *argn, char * /*NULL*/); int execvp(const char *file, char *const argv[]); blue 422 % cat exec2.c #include <unistd.h> Example: exec int main() { char *a[] = {"grep", "^root","/etc/passwd", NULL; if (fork() == 0) execl("/usr/bin/date", "date", NULL); else if (fork() == 0) execlp("echo", "echo", "$SHELL", NULL); else execvp("grep", a); blue 423 % a.out Mon Mar 18 23:54:04 EST 2002 $SHELL root:x:0:1:super- User:/:/sbin/sh blue 424 % 1

14 Intreprocess Communication Pipes are oldest form of Unix IPC: half duplex: data flows in one direction only used between processes sharing a common ancestor #include <unistd.h> int pipe(int fildes[2]); returns two file descriptors, fildes[0] and fildes[1] fildes[0] and fildes[1] are both opened for reading and writing read from fildes[0] accesses the data written to fildes[1] on a FIFO basis Pipes: Reading/Writing Reading: if write end is closed, read returns EOF after all data is read if write end is open, process sleeps until input becomes available if read more bytes than available, reads what is available Writing if read end closed, write will fail (SIGPIPE) 1

15 #include<unistd.h> int main() { int n, fd[2]; pipe(fd); if (fork() == 0){ /* child s code */ else { /* parent s code */ exit(0); Example: pipe /* child s code */ close(fd[0]); write(fd[1], "I am the child\n", 15); /* parent s code */ char buf[20]; close(fd[1]); n = read(fd[0], buf, 20); write(stdout_fileno, buf, n); 1