System Calls - Introduction
0 likes200 views
System calls allow programs to request services from the operating system kernel. Some common system calls include read and write for file access, fork for creating new processes, and wait for a parent process to wait for a child process to complete. The steps a system call takes include the program pushing parameters onto the stack, calling the library procedure to place the system call number in a register, triggering a trap instruction to switch to kernel mode, the kernel dispatching the system call to the appropriate handler, the handler running, then returning control to the user program after completing the operation.
![Example
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include <sys/wait.h>
int main(){
int fd[2],n;
char buffer[100];
pid_t p;
pipe(fd);
p = fork();
}
if(p>0){
close(fd[0]);
printf("Passing value to child!n");
write(fd[1],"Hello my child!!",15);
printf("n");
wait(NULL);
}
else{
close(fd[1]);
n = read(fd[0], buffer, 100);
write(1,buffer,n);
}](https://image.slidesharecdn.com/systemcalls-introductionos-230415061220-2ff1182d/85/System-Calls-Introduction-17-320.jpg)
System Calls - Introduction
- 2. Know it! In computing, a system call is a programmatic way in which a computer program requests a service from the kernel of the operating system it is executed on. A system call allows programs to interact with the operating system. A computer program makes a system call when it makes a request to the operating system’s kernel. All programs needing resources must use system calls.
- 3. Example For example, if we need to write a program code to read data from one file, copy that data into another file. The first information that the program requires is the name of the two files, the input and output files. In an interactive system, this type of program execution requires some system calls by OS. First call is to write a prompting message on the screen Second, to read from the keyboard, the characters which define the two files.
- 6. Kernel Mode Vs User Mode
- 7. Some system calls -
- 8. Some use cases Reading and writing from files demand system calls. If a file system wants to create or delete files, system calls are required. System calls are used for the creation and management of new processes. Network connections need system calls for sending and receiving packets. Access to hardware devices like scanner, and printer, need a system call.
- 9. wait() In some systems, a process needs to wait for another process to complete its execution. This type of situation occurs when a parent process creates a child process, and the execution of the parent process remains suspended until its child process executes. The suspension of the parent process automatically occurs with a wait() system call. When the child process ends execution, the control moves back to the parent process.
- 11. fork() Processes use this system call to create processes that are a copy of themselves. With the help of this system Call parent process creates a child process, and the execution of the parent process will be suspended till the child process executes.
- 12. Example #include<stdio.h> #include<unistd.h> int main(){ printf("PID = %dn", getpid()); return 0; }
- 13. getid() Getpid() is the function used to get the process ID of the process that calls that function. The PID for the initial process is 1, and then each new process is assigned a new Id. It is a simple approach to getting the PID.
- 14. Example #include<stdio.h> #include<unistd.h> int main(){ fork(); printf("PID = %dn", getpid()); return 0; } fork() system call is used to create a separate, duplicate process)
- 15. Example #include<stdio.h> #include<unistd.h> int main(){ fork(); fork(); fork(); printf("PID = %dn", getpid()); return 0; } Prints 8 times!!
- 16. P1 P2 P6 P4 P3 P5 P8 P7
- 17. Example #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include <sys/wait.h> int main(){ int fd[2],n; char buffer[100]; pid_t p; pipe(fd); p = fork(); } if(p>0){ close(fd[0]); printf("Passing value to child!n"); write(fd[1],"Hello my child!!",15); printf("n"); wait(NULL); } else{ close(fd[1]); n = read(fd[0], buffer, 100); write(1,buffer,n); }
- 19. In steps 1-3, the calling program pushes the parameters onto the stack. The first and third parameters are called by value, but the second one is called by its address as denoted by the & symbol. In step 4, the actual call to the library procedure is made. This instruction is the normal procedure call instruction used to call all procedures. In step 5, the library procedure places the system call number in a place where the operating system expects it, such as a register. In step 6, the library procedure executes a TRAP instruction to switch from user mode to kernel mode and start execution at a fixed address within the kernel. In step 7, the kernel examines the system call number and then dispatches it to the correct system call handler. This correct number is given in the table of system call handlers by pointers referenced at the system call number. In step 8, the system call handler runs. In step 9, the operation is completed, and the user is given back control once the TRAP instruction is set. In step 10, this procedure returns to the user program, like how all normal library procedures do. In step 11, the operating system has to clear the stack, so it increments it enough so that it is empty.
- 20. Practice #include<stdio.h> #include<unistd.h> int main(){ fork(); fork(); fork(); fork(); printf("PID = %dn", getpid()); return 0; } How many times would the printf statement be executed??
- 21. Practice #include<stdio.h> #include<unistd.h> int main(){ fork(); fork(); fork(); fork(); printf("PID = %dn", getpid()); return 0; } 16 process | 15 child process | 1 root process
- 22. Thank you!!