CSE 221: Homework 1
Due Thursday, February 1 at 11:59pm
Answer the following questions. For questions asking for short
answers, there may not necessarily be a "right" answer, although some
answers may be more compelling and/or much easier to justify. But I
am interested in your explanation (the "why") as much as the answer
itself. Also, do not use shorthand: write your answers using complete
Submit your homework by uploading it to Gradescope.
- (45 pts) 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 when crossing domains, and (e) how the OS determines whether to
allow the domain crossing.
Support your answers with a bit of explanation, such as a concise
summary explanation in your own words (a quote of a phrase or sentence
from the papers is fine as well). For instance, two possible answers
to part (a) for Hydra are:
In other words, we're looking for more than just "local name space"
— but at the same time your answers don't have to be lengthy
discussions. The balance in the example above is fine.
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).
- (25 pts) 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
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,
- Why must a traditional operating system like Unix explicitly
provide support (e.g., system calls) 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 (e.g.,
pipes) and coordination (e.g., synchronization) 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 Python 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
- (30 pts) Some of the systems we have read about take advantage of
language features. For each of the following systems, briefly
describe what language feature(s) the system uses and how the system
benefits from the feature(s).
Of those features, are there any that modern commercial operating
systems take advantage of today?