Talk:COMP 3000 Final Exam Study Guide 2012

There's what I would put down. There may be mistakes...

Concepts

Processes, threads (particularly in terms of execution contexts and address spaces)

Processes are execution environments with a minimum of one running thread. They all have their own virtual memory address spaces. A process can have many threads.

What code is in the kernel and what isn't

The kernel boots before anything, so it can't rely on any userland libraries like the C std library. The kernel re-implements much functionality found in said library (printf vs printk).

Supervisor versus user mode

These are CPU modes. Supervisor allows unrestricted access to the system. Only kernel code (with a few exceptions).

User mode only grants access to the system via system calls.

See CPU Modes

virtualization basics: what is a VM, what does machine look like inside a VM
Signals (SIGTERM, SIGKILL, SIGSTOP, SIGCONT, SIGCHLD, SIGSEGV, etc.)
signal handling: what can be handled, who calls them, how do they work?
Major system calls: fork, execve, open, close, read, write, lseek, mmap

fork: creates a new process and copies the current process image into the newborn execution context

execve: fills the current process with a new an image from a path.

int execve(const char *filename, char *const argv[],char *const envp[]);

open: grants access to file. Returns a file descriptor referring to that file or -1 for errors. Updates OS table of open files.

int open(const char *pathname, int flags, mode_t mode);

close: terminates access to a file. Flushes buffer, free's allocated space, updates metadata and a buncha other cool stuff.

int close(int fd);

read: reads a certain amount of bytes (count) from a file descriptor (fd) to a buffer pointer (*buf)

ssize_t read(int fd, void *buf, size_t count);

write: writes count bytes to a file descriptor fd from buffer pointed at by *buf. Returns number of bytes written, 0 or -1 for errors. Writes after current file offset (see lseek)

ssize_t write(int fd, const void *buf, size_t count);

lseek: reposition read/write file offset off_t lseek(int fd, off_t offset, int whence);

whence = SEEK_SET SEEK_CUR SEEK_END

mmap: requests a new memory mapping of a given space within the current process's virtual memory address space. Similar to malloc.

see an answer on SO

The process hierarchy and zombie processes

Files, directories, inodes, sparse files
file permissions: users, groups, others, rwx, where are they stored?
Basic file-level concurrency, flock
Ubuntu/Debian alternatives system
Basic package management on Ubuntu: apt-get, dpkg
Basic package development: dpkg-dev, dpkg-buildpackage, fakeroot
filesystem administration: mkfs, fsck, mount, /etc/fstab
block versus character devices and how they are used
upstart and init
init and process hierarchy
upstart versus System V init scripts
upstart scripts, basic structure, purpose, common options
SysV init scripts, basic structure and purpose
device drivers
environment variables and command line arguments: how they are passed, how are they stored and accessed
static versus dynamic linking
basics of how dynamic linking is implemented (strace-level view)
strace and ltrace
Kernel: proc filesystem basics, structure of kernel, relation to C library
netcat: basic usage
PATH environment variable and the shell
basic command line I/O redirection: <, >>, >, |
shell commands: if, while, for, touch, test (with common tests), echo
built-in versus external shell commands (and relationship to processes)