undefined
Advanced Programming in the UNIX Environment
Week 4: time(3) is an illusion
Having revisited the atime, mtime, and time in our last video segment, we now have to come to terms with time(3) itself. We'll discuss managing the data structures and handling arbitrary concepts such as leap seconds, timezones, and (ugh) Daylight Savings Time. It gets silly real quick.
Advanced Programming in the UNIX Environment
Week 4: atime, mtime, ctime
In this video lecture, we start looking a little bit closer into what our systems think of "time", something that experts most accurately describe as a big ball of wibbly, wobbly, timey, wimey... stuff. In short, analyze how the atime, mtime, and ctimes of a file connect.
Advanced Programming in the UNIX Environment
Week 4: getpwuid(2) and /etc/groups
In this video lecture, we look at the library functions used to look up account information. We learn about how primary and supplementary groups are handled as well as how the hashed passwords are stored outside of the world readable /etc/passwd file.
Advanced Programming in the UNIX Environment
Week 4: /etc/passwd
In this short video, we try to answer the awkward question "Mommy, where do UIDs come from?". We look at the /etc/passwd user database and identify the various fields before we look at how things can get weird.
Advanced Programming in the UNIX Environment
Week 4: Directory Size
In this video lecture, we dive deep into the structure of the directory on a traditional Unix File System and see how its size is independent of the file sizes of its entries, but dependent on the filename lengths. We'll also use hexdump(1) to cheat a bit and look at the directory structure on disk.
Advanced Programming in the UNIX Environment
Week 4: Directories
In this video lecture, we take a look at how directories are created and removed, as well as how to move around the filesystem hierarchy. We also learn why the 'cd' command must be a shell builtin in order to work.
Advanced Programming in the UNIX Environment
Week 4: Links
In this video lecture, we'll take a look at the system calls used to create, remove, and rename both hard- and symbolic links. We'll compare expected output against trivial implementations of the ln(1) and mv(1) commands.
Advanced Programming in the UNIX Environment
Week 4: The Unix Filesystem
In this video lecture, we begin a closer look at the Unix Filesystem (UFS). We visualize how the filesystem structures the disk and organizes files and directories. We illustrate how directory entries are created and moved around.
Advanced Programming in the UNIX Environment
Week 3: Union Mounts and Whiteout Files
One of the file types we've encountered are those of type S_IFWHT, so called "whiteout" files. But what the hell is that?? Let's illustrate! We describe the concept of union mounts and see what happens when a file in the upper layer is removed while the same file still exists in the lower layer: a whiteout file is created to cover up the lower file.
Advanced Programming in the UNIX Environment
An illustration of how permission octal modes and umasks work.
Advanced Programming in the UNIX Environment
Week 3: umask(2)
In this video lecture, we'll take a look at what file ownership and permissions are applied when we create a new file. In the process, we'll learn about the concept of a process's "umask", and look at how the 'umask' shell built-in is implemented.
Advanced Programming in the UNIX Environment
Week 3: chmod(2) and chown(2)
Having seen a lot of examples in our previous videos of creating files, changing their ownership, changing their permissions, we now focus on the system calls that are used to implement the chmod(1) and chown(8) commands.
Advanced Programming in the UNIX Environment
Week 3: struct stat st_mode
In this video segment, we're looking at how the permissions defined in the `struct stat st_mode` are applied. You want to pay particular attention to the permissions on directories and the order in which they are checked.
Advanced Programming in the UNIX Environment
Week 3: UIDs intro
In this video lecture, we'll learn a little bit more about file ownership and the user IDs of a process (real, effective, saved) by looking at the seteuid(2) and setuid(2) system calls and experimenting with setting the setuid bits and observe the file access we gain.
Advanced Programming in the UNIX Environment
Week 3: stat(2) intro
In this video lecture, we meet our new best friend, the 'struct stat'. We'll cover the stat(2) system calls and begin discussing each of the fields in the struct, often by example of the ls(1) and stat(1) commands. In this way, we begin learning more about how the Unix File System is implemented.
Advanced Programming in the UNIX Environment
A we're starting to regularly write C code now, it might be good to share a few useful links:
How to C (as of 2016)
https://matt.sh/howto-c
A critique of "How to C" by Matt:
https://github.com/Keith-S-Thompson/how-to-c-response/blob/master/README.md
and, even though you kids don't have any idea what Usenet is (now get off my lawn), the comp.lang.c FAQ:
https://c-faq.com/
Advanced Programming in the UNIX Environment
Week 2: File Sharing
In this final video lecture segment for our week 2 materials, we take a look at what it means when multiple processes access the same files and what the implications of that are on the syscalls we know. We conclude with a look at /dev/fd on different operating systems, including #NetBSD, #macOS, and #Linux
Advanced Programming in the UNIX Environment
Week 2: read(2)/write(2)/lseek(2)
In this video lecture, we will go into the details of the read(2), write(2), and lseek(2). We'll also do a few weird things with file descriptors, and take a look at how we can ensure I/O efficiency when making these system calls.
Advanced Programming in the UNIX Environment
Week 2: open(2) and close(2)
Having introduced the concept of file descriptors, let's look at what happens when we try to create a file, "create" an existing file, open an existing file, truncate a file, and look at the various other flags we can pass to open(2).
We also note the perhaps surprising number of ways in which open(2) can fail and take a look at openat(2) and TOCTOU defenses.
Advanced Programming the UNIX Environment
Week 2: File Descriptors
To introduce the concept of file descriptors, let's start with a simple question: how many file descriptors can a unix process open? In the process we encounter different limits that may apply across the system, for a given user, or just a process.