What does it mean to pin memory?  How is pinning/unpinning
implemented? Is it a flag or a separate table somewhere?

Nothing more than guaranteeing that the VM system won't page it out to
disk until it gets unpinned. If we have various lists for the kinds of
pages in the system, all pinning needs to mean is that there's a list
of pages that can't be evicted. When the page is pinned, it's removed
from its current list and put on the pinned list.



Why did you have to buy IBM equipment to read paper?

Chances are you would have wanted to have some lower-paid people type
things in, and then you could have the higher-paid people figure out
what to do after that. So, the process of using large numbers of
lower-paid people to enter data would have required buying lots of
data-entry terminals. Recall that this was some time ago - a typical
data-entry terminal was designed as office furniture since it was as
large as a desk.



Can we have 2 different types of fork - one that copies everything and
one that doesn't?

Good question. Some systems did have a cheper version of fork - check
out vfork() on solaris. What this did was allow the child process to
use the parent's resources until it was ready to do the exec(). On
systems that use copy-on-write to logically copy everything, fork
costs are much lower, and vfork() is considered less safe to use.



Is there a hierarchy on which processes can kill/terminate others?

I believe that the general rule is that a process can send another one
a signal only if they belong to the same user or if the sender is the
superuser (root). Otherwise, you cannot send signals to the process.



How does copy-on-write know to copy the pages only once, so that the
first process to write gets a copy, and the remaining one gets the
original?

Realize that copy-on-write can involve more than two processes.  So,
the general way of doing this is to make a copy of the page whenever
someone tries to write, and then decrement the ref count of the
original page. If that ref count drops to one, remove the "read only"
flag from it.  One optimization, then, would be to wait until a
process tries to write, and if the ref count is one, just remove the
read-only flag at that time.



Various suggestions for avoiding project bugs in the future.

Unfortunately, there's always some amount of pain involved when the
class changes from previous years. It's a tradeoff with sometimes
getting inconvenienced (a bad thing) versus having some flexibility to
adapt to a changing world (a good thing). In theory, it's possible to
have more safeguards in place to make sure that bad things don't
happen, but the reality is that the safeguards are only as good as the
people who handle them and the time they can devote to the matter.
So, I appreciate the suggestions, and will try to implement some of
them, but given the time constraints of the people involved, it may be
an uphill battle. TA's can be expected to do about 20 hours/week of
work for a class, and between grading and answering questions, it does
cut into what's left for development.