1. Week 12 - Friday

2.  What did we talk about last time?  Exam 2 post mortem

5. Programs must be written for people to read and only incidentally for machines to execute. Harold Abelson and Gerald Jay Sussman Authors of The Structure and Interpretation of Computer Programs Programs must be written for people to read and only incidentally for machines to execute. Harold Abelson and Gerald Jay Sussman Authors of The Structure and Interpretation of Computer Programs

8.  You just learned how to read and write files  Why are we going to do it again?  There is a set of Unix/Linux system commands that do the same thing  Most of the higher level calls ( fopen(), fprintf(), fgetc(), and even trusty printf() ) are built on top of these low level I/O commands  These give you direct access to the file system (including pipes)  They are often more efficient  You'll use the low-level file style for networking  All low level I/O is binary

9.  To use low level I/O functions, include headers as follows: #include  You won't need all of these for every program, but you might as well throw them all in

10.  High level file I/O uses a FILE* variable for referring to a file  Low level I/O uses an int value called a file descriptor  These are small, nonnegative integers  Each process has its own set of file descriptors  Even the standard I/O streams have descriptors StreamDescriptorDefined Constant stdin0STDIN_FILENO stdout1STDOUT_FILENO stderr2STDERR_FILENO

11.  To open a file for reading or writing, use the open() function  There used to be a creat() function that was used to create new files, but it's now obsolete  The open() function takes the file name, an int for mode, and an (optional) int for permissions  It returns a file descriptor int fd = open("input.dat", O_RDONLY);

12.  The main modes are  O_RDONLY Open the file for reading only  O_WRONLY Open the file for writing only  O_RDWR Open the file for both  There are many other optional flags that can be combined with the main modes  A few are  O_CREAT Create file if it doesn’t already exist  O_DIRECTORY Fail if pathname is not a directory  O_TRUNC Truncate existing file to zero length  O_APPEND Writes are always to the end of the file  These flags can be combined with the main modes (and each other) using bitwise OR int fd = open("output.dat", O_WRONLY | O_CREAT | O_APPEND );

13.  Because this is Linux, we can also specify the permissions for a file we create  The last value passed to open() can be any of the following permission flags bitwise ORed together  S_IRUSR User read  S_IWUSR User write  S_IXUSR User execute  S_IRGRP Group read  S_IWGRP Group write  S_IXGRP Group execute  S_IROTH Other read  S_IWOTH Other write  S_IXOTH Other execute int fd = open("output.dat", O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IRGRP );

14.  Opening the file is actually the hardest part  Reading is straightforward with the read() function  Its arguments are  The file descriptor  A pointer to the memory to read into  The number of bytes to read  Its return value is the number of bytes successfully read int fd = open("input.dat", O_RDONLY); int buffer[100]; read( fd, buffer, sizeof(int)*100 ); //fill with something int fd = open("input.dat", O_RDONLY); int buffer[100]; read( fd, buffer, sizeof(int)*100 ); //fill with something

15.  Writing to a file is almost the same as reading  Arguments to the write() function are  The file descriptor  A pointer to the memory to write from  The number of bytes to write  Its return value is the number of bytes successfully written int fd = open("output.dat", O_WRONLY); int buffer[100]; int i = 0; for( i = 0; i < 100; i++ ) buffer[i] = i + 1; write( fd, buffer, sizeof(int)*100 ); int fd = open("output.dat", O_WRONLY); int buffer[100]; int i = 0; for( i = 0; i < 100; i++ ) buffer[i] = i + 1; write( fd, buffer, sizeof(int)*100 );

16.  To close a file descriptor, call the close() function  Like always, it's a good idea to close files when you're done with them int fd = open("output.dat", O_WRONLY); //write some stuff close( fd ); int fd = open("output.dat", O_WRONLY); //write some stuff close( fd );

17.  It's possible to seek with low level I/O using the lseek() function  Its arguments are  The file descriptor  The offset  Location to seek from: SEEK_SET, SEEK_CUR, or SEEK_END int fd = open("input.dat", O_RDONLY); lseek( fd, 100, SEEK_SET ); int fd = open("input.dat", O_RDONLY); lseek( fd, 100, SEEK_SET );

18.  Use low level I/O to write a hex dump program  Print out the bytes in a program, 16 at a time, in hex, along with the current offset in the file, also in hex  Sample output: 0x000000 : 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 0x000010 : 02 00 03 00 01 00 00 00 c0 83 04 08 34 00 00 00 0x000020 : e8 23 00 00 00 00 00 00 34 00 20 00 06 00 28 00 0x000030 : 1d 00 1a 00 06 00 00 00 34 00 00 00 34 80 04 08 0x000000 : 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 0x000010 : 02 00 03 00 01 00 00 00 c0 83 04 08 34 00 00 00 0x000020 : e8 23 00 00 00 00 00 00 34 00 20 00 06 00 28 00 0x000030 : 1d 00 1a 00 06 00 00 00 34 00 00 00 34 80 04 08

19.  In Linux, files can be opened by multiple processes at the same time  Doing so carelessly can lead to race conditions  The contents of the file depend on how the programs were scheduled by the OS  All system calls ( open(), read(), etc.) are atomic  They will execute completely and won't be interrupted by another process

20.  A file descriptor is not necessarily unique  Not even in the same process  It's possible to duplicate file descriptors  Thus, the output to one file descriptor also goes to the other  Input is similar

21.  stderr usually prints to the screen, even if stdout is being redirected to a file  What if you want stderr to get printed to that file as well?  You can also redirect only stderr to a file./program > output.txt./program > output.txt 2>&1./program 2> errors.log

22.  If you want a new file descriptor number that refers to an open file descriptor, you can use the dup() function  It's often more useful to change an existing file descriptor to refer to another stream, which you can do with dup2()  Now all writes to stderr will go to stdout int fd = dup(1); //makes a copy of stdout dup2(1, 2); //makes 2 (stderr) a copy of 1 (stdout) dup2(1, 2); //makes 2 (stderr) a copy of 1 (stdout)

23.  Reading from and writing to files on a hard drive is expensive  These operations are buffered so that one big read or write happens instead of lots of little ones  If another program is reading from a file you've written to, it reads from the buffer, not the old file  Even so, it is more efficient for your code to write larger amounts of data in one pass  Each system call has overhead

24.  To avoid having too many system calls, stdio uses this second kind of buffering  This is an advantage of stdio functions rather than using low-level read() and write() directly  The default buffer size is 8192 bytes  The setvbuf(), setbuf(), and setbuffer() functions let you specify your own buffer

25.  Stdio output buffers are generally flushed (sent to the system) when they hit a newline ( '\n' ) or get full  When debugging code that can crash, make sure you put a newline in your printf(), otherwise you might not see the output before the crash  There is an fflush() function that can flush stdio buffers fflush(stdout); //flushes stdout //could be any FILE* fflush(NULL); //flushes all buffers fflush(stdout); //flushes stdout //could be any FILE* fflush(NULL); //flushes all buffers

26.  Until SSDs take over, physical hard drives are mostly electronically controlled spinning platters with magnetic coatings  Disks have circular tracks divided into sectors which contain blocks  A block is the smallest amount of information a disk can read or write at a time  Physical disks are partitioned into logical disks  Each partition is treated like a separate device in Linux  And a separate drive ( C:, D:, E:, etc.) in Windows  Each partition can have its own file system

27.  Linux supports a lot of file systems  ext2, the traditional Linux file system  Unix ones like the Minix, System V, and BSD file systems  Microsoft’s FAT, FAT32, and NTFS file systems  The ISO 9660 CD-ROM file system  Apple's HFS  Network file systems, including Sun’s widely used NFS  A range of journaling file systems, including ext3, ext4, Reiserfs, JFS, XFS, and Btrfs  And more!

28.  Virtually all file systems have each partition laid out something like this  The boot block is the first block and has information needed to boot the OS  The superblock has information about the size of the i-node table and logical blocks  The i-node table has entries for every file in the system  Data blocks are the actual data in the files and take up almost all the space Boot blockSuperblocki-node TableData blocks

29.  Every file has an i-node in the i-node table  Each i-node has information about the file like type (directory or not), owner, group, permissions, and size  More importantly, each i-node has pointers to the data blocks of the file on disk  In ext2, i-nodes have 15 pointers  The first 12 point to blocks of data  The next points to a block of pointers to blocks of data  The next points to a block of pointers to pointers to blocks of data  The last points to a block of pointers to pointers to pointers to blocks of data

30.  If a regular file system (like ext2) crashes, it might be in an inconsistent state  It has to look through all its i-nodes to try to repair inconsistent data  A journaling file system (like ext3, ext4, and Reiserfs) keeps metadata about the operations it's trying to perform  These operations are called transactions  After a crash, the file system only needs to repair those transactions that weren't completed

31.  Files have many attributes, most of which are stored in their i-node  These attributes include:  Device (disk) the file is on  i-node number  File type and permissions  Owner and group  Size  Times of last access, modification, and change  There are functions that will let us retrieve this information in a C program  stat(), lstat(), and fstat()

32.  Attributes can be stored in a stat structure struct stat { dev_t st_dev; /* IDs of device on which file resides */ ino_t st_ino; /* I-node number of file */ mode_t st_mode; /* File type and permissions */ nlink_t st_nlink; /* Number of (hard) links to file */ uid_t st_uid; /* User ID of file owner */ gid_t st_gid; /* Group ID of file owner */ dev_t st_rdev; /* IDs for device special files */ off_t st_size; /* Total file size (bytes) */ blksize_t st_blksize; /* Optimal block size for I/O (bytes)*/ blkcnt_t st_blocks; /* Number of (512B) blocks allocated */ time_t st_atime; /* Time of last file access */ time_t st_mtime; /* Time of last file modification */ time_t st_ctime; /* Time of last status change */ }; struct stat { dev_t st_dev; /* IDs of device on which file resides */ ino_t st_ino; /* I-node number of file */ mode_t st_mode; /* File type and permissions */ nlink_t st_nlink; /* Number of (hard) links to file */ uid_t st_uid; /* User ID of file owner */ gid_t st_gid; /* Group ID of file owner */ dev_t st_rdev; /* IDs for device special files */ off_t st_size; /* Total file size (bytes) */ blksize_t st_blksize; /* Optimal block size for I/O (bytes)*/ blkcnt_t st_blocks; /* Number of (512B) blocks allocated */ time_t st_atime; /* Time of last file access */ time_t st_mtime; /* Time of last file modification */ time_t st_ctime; /* Time of last status change */ };

33.  I really shouldn't tell you about these  But there are functions that can change the timestamp of a file  utime() lets you change the access and modification times for a file, with units in seconds  utimes() lets you do the same thing, but with accuracy in microseconds

36.  Networking overview  Sockets

37.  Finish Project 5  Due tonight by midnight  Read LPI Chapters 56, 57, 58, and 59