******************************************************************************
// QUIZ PROGRAM SOLUTION
// orig
#define MAX 1024
lock_t l; // lock protects process_list
int process_list[MAX];
int get_new_process_id()
{
  int i;
  for (i=0; i<=MAX; i++) { // off-by-1, array out of bounds
    if (process_list[i]=0) { // need '==' not assign '=' (gcc -Wall)
      process_list[i]=1;
      return(i);
  }}
}

// version 1
/*
 * return new PID to caller
 * valid values are 1..1024
 * on error, return -1
 */
int get_new_process_id1(void)
{
  int i;
  lock(l);
  for (i=0; i<MAX; i++) {
    if (process_list[i]==0) {
      process_list[i]=1;
      unlock(l);
      return(i+1); // return PIDs 1..1024 (not 0..1023)
    } // end of 'if'
  } // end of 'for' loop
  unlock(l); // unlock here too, else could leave fxn w/ lock held.
  return -1; // return an error code
}

// gcc -Wall will catch an assignment inside a cond. and produce a warning
// you can quiet gcc by adding a second level of ()
int foo()
{
  if (x = 0) // produce a gcc warning
    printf();
  if (x == 0) // no warning, assuming you intended a comparison
    printf();
  if ((x = 0)) // no gcc warning, add a second ()
    printf();
  // best if intended an assignment
  x = 0;
  if (x)
    printf();
}

// other issues
// array is not initialized: when os starts, need to memset(0) the array

// can add un/lock() inside "for" loop, helps concurrency and interleaving,
// but more complex code.  locking outside for loop is simpler, but longer
// critical section (CS).  Always a tension b/t avoiding races (increase the
// CS), vs. improving performance (decrease CS).

// some locks are more/less expensive to acquire, a consideration

// always make code functional first, THEN worry about optimizations

// process_list consumes 32 bits but only needs 1 per pid
// can convert to a bitmap, use logical shift, AND, OR ops, to find and set
// the right bit corresponding to a PID number.
// 'i' counter only needs to count up to 1024, so can use a "short" 16bit
// int.

// missing a fxn to release a pid upon exit(3) of a process
// under a lock, set the right process_list slot (or bit) to 0.
// a test: if asked to reset a slot that's NOT marked as '1': bug (probably
// a serious bug somewhere in the kernel, may want to panic kernel).


******************************************************************************
* system calls

code running inside kernel, in privileged mode, on behalf of user.

syscall: open(filename, mode), read(fd, buf, len)
libc:    malloc(size), printf(...)

both cases: fxn has a name, takes 0+ args, may return a value, and may have
side effects (malloc creates mem, write modifies a file).  But syscalls are
more expensive.

Kernel executes code for user as if the kernel is a "remote" entity.  Not
much different than executing network remote procedure calls (RPCs): pack
fxn name and args, ship it to remote side, wait for response w/ errors
and/or return data/values.

(A) In userland

1. process invokes system call foo(arg1, arg2, arg3)
2. invoking a libc "wrapper" for syscall: syscall3(NR_FOO, arg1, arg2, arg3)
- prog have to pass to kernel the args and "id" of syscall (fixed number is
  faster than a string)
- need a shared medium for prog. to pass info to kernel: memory, cpu
  registers.
3. libc wrapper, stores NR_FOO into register 1 (R1), then args into R2,
   R3, ...
4. libc wrapper will invoke a special syscall interrupt, to tell kernel to
   run the syscall.  Sometimes called "int80H".

(B) In kernel mode

1. CPU is stopped from executing whatever it's running (the user program)
2. CPU register state is preserved (e.g., in some memory)
3. invoke syscall interrupt handler
4. put user process to sleep (WAIT state)
- possible to defer this till we know how expensive the actual syscall is
  (e.g., would it have any I/O? some syscalls don't have any I/O, like
  getpid(2)).
5. syscall handler gets the preserved info about the syscall: namely the
   syscall number and its arguments.
6. based on syscall#, invoke a syscall dispatch table of syscall functions,
   setup stack frame with content of arg1/arg2/arg3/etc. as passed from user
   program.
7. Invokes function named like sys_FOO(args...).  May be prefixed by
   "asmlinkage".
8. system call is running....
- we'll discuss this in great detail in later lectures.


* next time

finish return part to userland
syscall nums must be coordinated
show example code
syscall efficiency

writing syscall code:
- error checking
- error code style