1 / 15

File and I/O system calls int open(const char* path, int flags, mode_t modes) int creat(const char *path, mode_t mode)

File and I/O system calls int open(const char* path, int flags, mode_t modes) int creat(const char *path, mode_t mode) ssize_t read(int fd, void *buf, size_t nbyte) ssize_t write(int fd, const void *buf, size_t nbyte) int close(int fd) off_t lseek(int fd, off_t offset, int reference)

ekram
Télécharger la présentation

File and I/O system calls int open(const char* path, int flags, mode_t modes) int creat(const char *path, mode_t mode)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. File and I/O system calls int open(const char* path, int flags, mode_t modes) int creat(const char *path, mode_t mode) ssize_t read(int fd, void *buf, size_t nbyte) ssize_t write(int fd, const void *buf, size_t nbyte) int close(int fd) off_t lseek(int fd, off_t offset, int reference) int stat(const char *file_name, struct stat *buf)

  2. Each process records all the files opened in its context, the file descriptor table in the process table entry. Process context process descriptor file descriptor table 0 1 2 3 4 File info file descriptor table contains all the files opened by the process

  3. open/creat: find the first empty slot in the file descriptor table, use the slot to store a pointer to the file information. • Linear search • close(fd) : among other things, makes the entry fd in the file descriptor table available. • read/write: get the file information (such as current position) through the file descriptor table.

  4. //example1.cpp #include <sys/types.h> #include <unistd.h> #include <fcntl.h> #include <iostream> using namespace std; main() { int f1, f2, f3, f4, f5, f6; f1 = open(“open.cpp”, O_RDONLY); cout << “f1 = “ << f1 << “\n”; f2 = open(“open.cpp”, O_RDONLY); cout << “f2 = “ << f2 << “\n”; f3 = open(“open.cpp”, O_RDONLY); cout << “f3 = “ << f3 << “\n”; close(f1); f4 = open(“open.cpp”, O_RDONLY); cout << “f4 = “ << f4 << “\n”; } Why f1 = 3, but not 1?

  5. First three slots in the file descriptor table are occupied for standard I/O operation when the process is created. • Slot 0 ==> for standard input. • Slot 1 ==> for standard output. • Slot 2 ==> for standard error. • Every time UNIX searches for an available slot in the open file table, it does a linear search starting from slot 0. • The return of the first open == ?

  6. Slots 0, 1, and 2 in the file descriptor table • used for standard I/O • They can be used just like regular files. Main() { main() { cout << “hello, world!!\n”; ==> write(1, “hello, world!!\n”, } strlen(“hello, world!!\n”); } // example2.cpp • no need to open and close files 0, 1, 2 -- taken care of by the OS when it creates the process.

  7. Let us redo the following program with read calls: main() { int I; cin >> I; cout << I; } See example2a.cpp

  8. What if we close the standard I/O files? • See example2b.cpp. • Lost I/O capability!!

  9. What if we close the standard I/O files and open files again? • What is return value of the open call? • See example4.cpp • Now what happens when you do cout in example4.cpp? • This is called I/O redirection, instead of read from keyboard and print to the screen, cin will read from a file and cout will print to a file!!

  10. #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <iostream.h> main() { int f1, f2, f3, f4, f5, f6; f1 = open(“open.cpp”, O_RDONLY); cout << “f1 = “ << f1 << “\n”; f2 = open(“open.cpp”, O_RDONLY); cout << “f2 = “ << f2 << “\n”; close(1); f3 = open(“aaa”, O_RDONLY | O_WRONLY | O_CREAT, 0666); cout << “f3 = “ << f3 << “\n”; cerr << “f3 = “ << f3 << “\n”; } // example4.cpp, Output redirection What happens in This program?

  11. Another way of redirect a file into standard I/O • Duplicate an file descriptor: dup() • #include <unistd.h> • int dup(int fd); • return a new file descriptor having the common open file, file pointer and access mode with fd. • Note: UNIX does a linear search in the file descriptor table for the available slot.

  12. Difference between dup and open/create (Why dup instead of open) • Using dup, the file position of the two duplicated open files is shared. • Using open one file two times, there are two file positions for the two open files (open file != file) • See extra1.cpp and extra2.cpp.

  13. Using dup() to do standard I/O redirection. Implementing I/O redirection #include <fcntl.h> #include <unistd.h> #include <iostream> #include <stdio.h> #include <stdlib.h> main() { char buf[100]; int fd; fd = open(“tmp111”, O_CREAT|O_WRONLY, 00777); close(1); dup(fd); close(fd); cout << “what is going on?\n”; cerr << “1111111\n”; } // example5.cpp

  14. execv system call revisit: • format: int execv(const char *path, char * argv[]) • Wipe out the original process and load the new • executable path into memory and execute path. • When the system call execv is successful, every thing after the execv call in the original program will NOT be executed. • Wipe out everything??? NOT precise!!!!! • The open file descriptor table remains unchanged -->implication? • If you do something to the file descriptor table before you call execv, you can redirect the standard I/O in the command to be executed!!!

  15. void runcommand(char *cmd, char*argv[], char* readfile, char* writefile) { int status; if (fork() == 0) { if (readfile != NULL) { int fd = open(readfile, O_RDONLY); if (fd == -1) {cerr << “error\n”, exit(0);} close(0); dup(fd); close(fd); } if (writefile != NULL) { int fd = open(writefile, O_CREAT | O_WRONLY, 00777); if (fd == -1) {cerr << “error\n”, exit(0);} close(1); dup(fd); close(fd); } int stat = execv(cmd, argv); if (stat == (-1)) {cerr << “error\n”, exit(10);} } int stat = wait(&status); if (stat == -1) {cerr << “error return from wait\n”;} } // example6.cpp Running cmd with I/O redirection

More Related