CSE 221: Homework 1
Due: Tuesday, October 19, 2010 at the start of class (3:30pm)
Answer the following questions. For questions asking for short
answers, there may not necessarily be a "right" answer, although some
wanswers may be easier to justify. Finally, do not use shorthand:
write your answers using complete sentences.
- A fundamental aspect of protection in operating systems is rights
amplification. Rights amplification enables a more privileged
protection domain to perform an operation on behalf of a less
privileged protection domain in a controlled fashion without violating
protection in the system.
For each of the following operating systems, state (a) the
protection domain that they support, (b) the mechanism for crossing
protection domains, (c) how rights are represented, (d) how rights are
amplified crossing domains, and (e) how the OS determines whether to
allow the domain crossing.
Support your answers with material from the papers (e.g., a quote
of a phrase or sentence), or with your own critical arguments, as
appropriate (the Lampson protection paper is fair game). I am
interested in your justifications as much as the answer itself —
and the more often you can quote from a paper, the less you have to
justify. For instance, two possible answers to part (a) for Hydra
A protection domain in Hydra is the "local name space" (LNS). An
LNS represents the current set of objects and rights to which a
process has access, and those objects and rights change when a process
moves from one LNS to another.
A protection domain in Hydra is the "local name space" (LNS): "At
any instant, the execution environment (domain) of a program is
defined by an LNS object associated with it...the rights lists in each
capability define the permissible access rights of this program at
this instant." (Hydra p. 341).
- Operating systems go to great lengths to provide isolation and
protection among processes executing on the system. Process
debugging, however, represents a necessary, interesting feature that
is made more difficult by process isolation and protection, and
requires support from the operating system to function correctly.
To the extent possible and where appropriate, when answering the
following questions support your answers with approaches for debugging
support found in the papers you have read to this point (e.g., Tenex,
Lampson Protection, Pilot).
- Why must a traditional operating system like Unix explicitly
provide support for process debugging?
- List two distinct operations that a debugger must perform that
require support from the operating system.
- Because processes are protected and isolated from each other,
operating systems must also provide support for communication and
coordination among processes. Why can't debuggers just use the
support that operating systems already provide for process
communication and coordination?
- Do language runtime environments like Java and Perl require
operating system support for debugging programs in those languages?
Why or why not?
- When working on an operating system, developers also need
to use a debugger on the operating system itself. Why is debugging
the kernel of an operating system more challenging than debugging a
user-level process? What is one option for where to run a kernel
- Some of the systems we have read about and discussed use
specialized hardware to facilitate their implementation. Choose one
such instance, describe the hardware that was used, and what advantage
it gave the system implementors and designers. What is one drawback of
relying upon specialized hardware? Do we still use hardware of this
- Pilot made a strong and persuasive argument for tailoring the
design and implementation of operating systems to personal computers.
We have also seen commercial operating systems like MSDOS, Windows before
NT, and "classic" MacOS tailored towards
personal computers as well. Why do you think we still run multi-user
timesharing systems like Unix on our PCs? (Consider, for example, the
requirements we have of the systems that we use today.)