Talk:COMP 3000 Final Exam Study Guide 2012 - Revision history

Cdelahou: flocking

2012-12-13T21:46:06Z

flocking

← Older revision		Revision as of 21:46, 13 December 2012
Line 72:		Line 72:
	* file permissions: users, groups, others, rwx, where are they stored?		* file permissions: users, groups, others, rwx, where are they stored?
	* Basic file-level concurrency, flock		* Basic file-level concurrency, flock

			Flock uses a file based mutex. -x means exclusive lock, 200> writes that file on file descriptor 200. The file is located where most locks are... /var/lock/mylockfile.lock

			( flock -x 200
			...
			) 200> /var/lock/mylockfile.lock



	* Ubuntu/Debian alternatives system		* Ubuntu/Debian alternatives system

Cdelahou: added a bit more stuff

2012-12-13T18:34:01Z

added a bit more stuff

← Older revision		Revision as of 18:34, 13 December 2012
Line 63:		Line 63:
	* The process hierarchy and zombie processes		* The process hierarchy and zombie processes

			Basically a tree rooted at init. Every node's parent is its parent process.

			Zombie processes are children that have stopped running but haven't been reaped by parents. They still exist on the OS's process table. You get rid of them by killing the parent.

			Unix uses terrible metaphors.

	* Files, directories, inodes, sparse files		* Files, directories, inodes, sparse files
Line 68:		Line 73:
	* Basic file-level concurrency, flock		* Basic file-level concurrency, flock
	* Ubuntu/Debian alternatives system		* Ubuntu/Debian alternatives system

			Series of symlinks pointed to and from various binaries. Allows you to run multiple versions of binaries (netcat tradition/netcat bsd) and set defaults (www-browser --> links2). The heart of the system lies in /etc/alternatives.

	* Basic package management on Ubuntu: apt-get, dpkg		* Basic package management on Ubuntu: apt-get, dpkg

			dpkg: installs, keeps track and maintains debian packages.

			apt-get: wrapper for dpkg that finds and downloads packages and satisfies dependencies.

	* Basic package development: dpkg-dev, dpkg-buildpackage, fakeroot		* Basic package development: dpkg-dev, dpkg-buildpackage, fakeroot
	* filesystem administration: mkfs, fsck, mount, /etc/fstab		* filesystem administration: mkfs, fsck, mount, /etc/fstab
	* block versus character devices and how they are used		* block versus character devices and how they are used
	* upstart and init		* upstart and init

			upstart is init. It controls the boot process and when whatever process gets run. We call these runlevels.

	* init and process hierarchy		* init and process hierarchy

			Init has PID 1

	* upstart versus System V init scripts		* upstart versus System V init scripts

			System V is a few shell scripts being run sequentially, perfect for single core processors from the 90's.

			Upstart takes concurrency to heart. Uses dependencies.

	* upstart scripts, basic structure, purpose, common options		* upstart scripts, basic structure, purpose, common options
	* SysV init scripts, basic structure and purpose		* SysV init scripts, basic structure and purpose
	* device drivers		* device drivers

			Code used by the kernel to communicate with hardware. It's an abstraction for the hardware. The kernel creates another abstraction which will be used by users and developers.

	* environment variables and command line arguments: how they are passed, how are they stored and accessed		* environment variables and command line arguments: how they are passed, how are they stored and accessed
	* static versus dynamic linking		* static versus dynamic linking

Cdelahou: added main syscall stuff

2012-12-13T18:00:32Z

added main syscall stuff

@@ Line 24: / Line 24: @@
 * signal handling: what can be handled, who calls them, how do they work?
 * Major system calls: fork, execve, open, close, read, write, lseek, mmap
 * The process hierarchy and zombie processes
 * Files, directories, inodes, sparse files
 * file permissions: users, groups, others, rwx, where are they stored?

Cdelahou: answered first few questions

2012-12-13T17:23:09Z

answered first few questions

New page

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 [http://en.wikipedia.org/wiki/CPU_modes 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
* 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)