1 / 37

Client/Server Distributed Systems

Client/Server Distributed Systems. 240-322, Semester 1, 2005-2006. Objectives look at low-level operations for handling files. 4. Low-level File I/O. Overview. 1. Basic Operations 2. Why use Low-level Operations? 3. A Simple Example 4. File Descriptors 5. File Permissions Again

tillie
Download Presentation

Client/Server Distributed Systems

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. Client/Server Distributed Systems 240-322, Semester 1, 2005-2006 • Objectives • look at low-level operations for handling files 4. Low-level File I/O

  2. Overview 1. Basic Operations 2. Why use Low-level Operations? 3. A Simple Example 4. File Descriptors 5. File Permissions Again 6. open() 7. creat() continued

  3. 8. close() 9. read() 10. write() 11. copyfile.c 12. lseek() 13. File Pointers

  4. 1. Basic Operations • Name Meaningopen() Opens a file for reading or writing.creat() Creates an empty file for writing.close() Closes an open file.read() Reads data from a file.write() Writes data to a file.lseek() Moves to a specified byte in the file.unlink() Removes a file.

  5. Information on Operations • apropos <name>man -k <name> • e.g. apropos open • man <name>man <section number> <name> • e.g. man 2 open • Look in /usr/include

  6. 2. Why use Low-level Operations? • No buffering of I/O • useful for network programming and reading/writing to certain peripherals (e.g. tape drives) • No conversion of I/O • no transformation of input to integers, floats, etc.;output can be any byte sequence • Can be used as building blocks for more complex I/O.

  7. 3. A Simple Example (oprd.c) #include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>int main(){ int fd, nread; char buf[1024]; if ((fd = open("data-file", O_RDONLY)) == -1) { perror("open"); exit(-1); } :

  8. nread = read(fd, buf, 1024);close(fd); buf[nread-1] = '\0'; /* so can print */ printf("buf: %s\nnread: %d\n", buf, nread); return 0;}

  9. 4. File Descriptors • A file descriptor is a small, non-negative integer. • A file descriptor identifies an open file to the low-level operations. • Standard descriptors: 0 represents stdin1 stdout2 stderr

  10. 5. File Permissions • One way of using chmod is with letters to represent permissions: e.g. chmod a+r file • Most low-level operations (and chmod) represent permissions as octal values:e.g. chmod 0644 file

  11. File Permissions as Octals Octal Symbolic Meaning of Permission0400 r-- --- ---0200 -w- --- ---0100 --x --- ---0040 --- r-- ---0020 --- -w- ---0010 --- --x ---0004 --- --- r--0002 --- --- -w-0001 --- --- --x

  12. Example • Add octal values together to get the complete file permission:Octal Meaning0400 r-- --- --- 0200 -w- --- --- 0040 + + --- r-- --- 0004 --- --- r-- ==== =========== 0644 rw- r-- r-- • Use in chmod: chmod 0644 file

  13. 6. open() • #include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>int open(char *pathname, int flag /*, mode_t mode */ ); • Return file descriptor if ok, -1 for error

  14. Some open() Flags O_RDONLY Open file for reading only.O_WRONLY Open file for writing only.O_RDWR Open file for both reading & writing.Possibly combined with:O_APPEND Append to file when writing.O_CREAT Create file if is does not exist (requires the 3rd modeargument).O_EXCL Return -1 error if file is to be created and already exists.

  15. Using Bitwise OR • open() flags can be combined with the bitwise OR operator ‘|”: fd = open(file, O_WRONLY | O_APPEND); • Now each write(fd, buf, BUFSIZE)means append to the end of the file.

  16. 7. creat() • #include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>int creat(char *pathname, mode_t mode); • Creates a new file, or truncates an old one. • Return file descriptor if ok, -1 on error.

  17. mode gives access permission of resulting new file:0644 (rw- r-- r--) • mode only has meaning if the file is new.

  18. Create a new file #include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>void main(){ int fd; if ((fd = creat(“new-file”,0644))== -1){ printf(“cannot create new-file\n”); exit(1); } /* rest of program */}

  19. Replacing creat() with open() • creat() only opens a file for writing; to read it the file must be closed and opened for reading. • creat() can be replaced by open():open(“new-file”, O_WRONLY | O_CREAT | O_TRUNC, 0644)

  20. Other Versions • creat() version which can read and write:open(“new-file”, O_RDWR | O_CREAT | O_TRUNC, 0644) • Avoid truncation of old file (append instead): open(“new-file”, O_WRONLY|O_CREAT|O_APPEND, 0644)

  21. One User at a Time • Create lock if it doesn’t already exist, otherwise fail (and return -1): fd = open(“lock”, O_WRONLY|O_CREAT|O_EXCL, 0644); • Use lock to protect access to another file • open “accounts” only if lock can be opened • after processing “accounts”, delete lock

  22. 8. close() • #include <unistd.h>int close(int fd); • Close a file: return 0 if ok, -1 on error. • Useful since the number of open files is limited (~20)

  23. 9. read() • #include <sys/types.h>#include <unistd.h>int read(int fd, void *buffer, unsigned int nbytes); • Tries to read nbytes into the buffer array • no conversion of bytes (characters) • may read less than specified amount (e.g. at end) • Returns the no. of bytes read, 0 if end of file, -1 on error.

  24. The Read-Write Pointer • The R-W Pointer records the position of the next byte in the file to be read (or written). • It is implicit (hidden) in each use of read() and write()

  25. Count Characters (countchars.c) #include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>#define SIZE 512int main(){ char buffer[SIZE]; int fd, j; long total = 0; : continued

  26. if ((fd = open(“data-file”, O_RDONLY)) == -1){ perror("open"); exit(1); } while((j = read(fd, buffer, SIZE)) > 0) { putchar('.'); total += j; } putchar('\n'); printf(“total chars: %ld\n”, total); close(fd); return 0;}

  27. UNIX systems are often configured to read/write in blocks of 512 or 1024 bytes (the diskblocking factor). • Can use BUFSIZ from stdio.h which contains a default disk blocking factor.

  28. 10. write() • #include <unistd.h>int write(int fd, void *buffer, unsigned int nbytes); • Returns number of bytes written if ok, -1 on error. • write() starts at the current R-W pointer position, and pointer is moved as file is written.

  29. Example :int fd;char header1[512], header2[512]; :if ((fd = creat(“foo”, 0644)) != -1) : write(fd, header1, 512); write(fd, header2, 512); :

  30. 11. copyfile.c #include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>int copyfile(char *nm1, char *nm2);void main(){ printf("result: %d\n", copyfile(“test.in”, “test.out”) );} continued

  31. int copyfile(char *nm1, char *nm2){ int infd, outfd, nread; char buffer[BUFSIZ]; if ((infd = open(nm1,O_RDONLY))== -1) return -1; if ((outfd = creat(nm2,0644)) == -1){ close(infd); return -2; } : continued

  32. while ((nread = read(infd, buffer, BUFSIZ)) > 0) { if (write(outfd, buffer, nread) < nread) { close(infd); close(outfd); return -3; /* write error */ } } close(infd); close(outfd); return 0;}

  33. copyfile() & BUFSIZ • BUFSIZ Real time User time System time1 3:42.8 4.1 3:24.864 0:27.3 0.0 0:05.1511 0:24.0 0.0 0:01.9512 0:22.3 0.0 0:01.0513 0:25.1 0.0 0:02.44096 0:13.3 0.0 0:00.98192 0:12.9 0.0 0:01.1 • Most saving is made by reducing no. of system calls.

  34. 12. lseek() • #include <sys/types.h>#include <unistd.h>long int lseek(int fd, long int offset, int start); • Change position of R-W pointer: return new file offset if ok, -1 on error. • Start names (and numbers): • SEEK_SET 0 start of file • SEEK_CUR 1 current R-W pointer position • SEEK_END 2 end of file

  35. Code Fragments • :fd = open(filename, O_RDWR);lseek(fd, 0L, SEEK_END);write(fd, buffer, BUFSIZ);: • /* get filesize in bytes */long int filesize;filesize = lseek(fd, 0L, SEEK_END);

  36. 13. File Pointers • Connect a file pointer to fd’s file with:#include <stdio.h>FILE *fdopen(int fd, char *mode); • mode is usual thing: “r”, “w”, “rb”, etc. • Useful for doing formatted I/O on top of pipes and network comunication.

  37. Code Fragment • int fd = open("data", O_RDONLY);FILE *fp = fopen(fd, "r");int num;fscanf(fp, "%d", &num);

More Related