API

Question 1

fork

Answer 1

int fork(void);
create a new process that is an exact copy of the old process
- returns pid of new process in parent
- returns 0 in child
gets called once, returns twice

Question 1

waitpid

Answer 1

int waitpid(int pid, int * status, int options);
attempt to get exit status of child
- returns pid or -1 on error
- pid = pid to wait for, -1 for any
- status = exit value/signal of child
- options = 0 means wait for child to terminate, WNOHANG means do not wait

Question 2

exit

Answer 2

void exit(int status);
exit the current process
- status = shows up if waitpid called
0 is success, non-zero is failure

Question 3

kill

Answer 3

int kill(int pid, int sig);
sends signal to a process
- pid = pid of target
- sig = code
SIGTERM most common, kills process by default but app can catch for cleanup
SIGKILL is stronger, always kills

Question 4

execve

Answer 4

int execve(char * prog, char ** argv, char ** envp);
replace the current program with a new one
- prog = path to new program
- argv = arguments to prog’s main
- envp = environment for new program

Question 5

execvp

Answer 5

int execvp(char * prog, char ** argv);
searches PATH for prog, uses current environment

Question 6

execlp

Answer 6

int execlp(char * prog, char * arg, …);
execvp, but listing each argument terminated by NULL

Question 7

dup2

Answer 7

int dup2(int oldfd, int newfd);
makes newfd an exact copy of oldfd
closes newfd, if it was valid
both fds share the same offset (lseek on one affects both)

Question 8

pipe

Answer 8

int pipe(int fds[2]);
output of fds[1] is input to fds[0]
- returns 0 on success, -1 on error
- when fds[1] is invalidated, fds[0] returns EOF

Question 9

x86 lock

Answer 9

makes the following instruction atomic

Question 10

x86 lfence

Answer 10

waits for all reads to be done before continuing

Question 11

sfence

Answer 11

waits for all writes to be done before continuing

Question 12

mutex_lock implementation

Answer 12

while(xchg(mutex, true)) {};
uses atomic test and set

Question 13

_Atomic

Answer 13

wrap most basic types with _Atomic() and all standard operations are seqcon

Question 14

atomic_flag

Answer 14

special type:
- atomic bool, no load/store
- uses test_and_set or clear instead

Question 15

relaxed

Answer 15

no ordering

Question 16

consume

Answer 16

slightly relaxed acquire

Question 17

acquire

Answer 17

reads/writes after the load cannot be reordered before

Question 18

release

Answer 18

reads/writes before the store cannot be reordered after

Question 19

acq_rel

Answer 19

acquire and release

Question 20

seq_cst

Answer 20

full seqcon

Question 21

how syscalls are performed

Answer 21

1. load syscall args into registers
2. load syscall number into rdi
3. int 60 (T_SYS = 60)
4. interrupt handler looks to IDT for entry point
5. jumps to the entry point

Question 22

TLB instructions

Answer 22

tlbwr, tlbwi, tlbr, tlbp
to use each, load:
c0_entryhi
c0_entrylo
c0_index

Question 23

tlbwr

Answer 23

TLB write a random slot

Question 24

tlbwi

Answer 24

TLB write a specific slot

Question 25

tlbr

Answer 25

TLB read a specific slot

Question 26

tlbp

Answer 26

probe the entry that matches c0_entryhi

Question 27

brk

Answer 27

char * brk(const char * addr);
- set and return new value of breakpoint

Question 28

sbrk

Answer 28

char * sbrk(int incr);
- increment value of the breakpoint and return the old value

Question 29

mmap

Answer 29

void * mmap(void * addr, size_t len, int prot, int flags, int fd, off_t offset);
- treat a file as if it were memory
- map the file fd to the virtual address addr, except that changes are backed up to the file
- file can be shared with other processes
- addr = NULL, let kernel choose addr
- prot specifies protection of region (PROT_EXEC | PROT_READ | PROT_WRITE | PROT_NONE)
- flags: MAP_SHARED - modifications seen by everyone, MAP_PRIVATE - modifications are private, MAP_ANON - anonymous memory (no file associated with this address range)

Question 30

munmap

Answer 30

int munmap(void * addr, size_t len);
- remove mmapped object from address space

Question 31

mprotect

Answer 31

int mprotect(void * addr, size_t len, int prot);
- change protection on pages to prot

Question 32

msync

Answer 32

int msync(void * addr, size_t len, int flags);
flush changes of mmapped file to backing store i.e. the file

Question 33

mincore

Answer 33

int mincore(void * addr, size_t len, char * vec);
- return which pages present in RAM (i.e. core) vs swap space in vec

Question 34

madvise

Answer 34

int madvise(void * addr, size_t len, int behav);
- advise the OS on memory use e.g. MADV_RANDOM (don’t prefetch) vs MADV_SEQUENTIAL
- MADV_WILLNEED or MADV_DONTNEED (don’t prefetch)

Question 35

sigaction

Answer 35

int sigaction(int sig, const struct sigaction * act, struct sigaction * oact);
- specify what function to call for SIGSEGV or other signals
- if oact not null, save the old sigaction in oact

Question 36

p_nice

Answer 36

user-set weighting factor in [-20, 20], negative -> higher priority

Question 37

p_estcpu

Answer 37

per-process estimated CPU usage
- incremented whenever it got preempted
- decayed every second while process runnable

Question 38

load (with p_nice, p_estcpu)

Answer 38

the sampled average length of the run queue + short term sleep queue over last minute
- the higher the load, the less p_estcpu is reduced