CA170 - Introduction to Operating Systems

What is this script doing?

grep string file > /dev/null
if test "$?" = "0"
then
...

Listing the lines of the file in which the string occurs, then querying the number of arguments to the program.
Building an output file of the lines on which the string occurs, and then proceeding with a test of whether there were any such lines.
Listing the lines of the file in which the string occurs.
Testing whether or not the string occurs in the file, without listing the lines on which it does.

In my Shakespeare directory, you want to count on how many lines the string "King" appears in Shakespeare. Which of the following will answer that question?

grep -i King */act*
grep -c King */act* | wc -l
grep King */act* | wc -l
grep -ic King */act*
grep -c King */act*
grep King */act*
grep -i King */act* | wc -l
grep -ic King */act* | wc -l

One of the following file protections will break your web page:

-------r--
-rwx---r--
-rwxr-x--x
-rwx---r-x
-------r-x
-rwxr-xr--
-rwxr-xr-x

Which of the following fails to find lines containing "Scotland" in a group of files?

grep scotland *html
grep -i Scotland *html
grep Scotland *html
grep -i scotland *html

As a result of the "unused RAM is wasted RAM" idea, we may:

Allocate more memory than processes need.
Keep data from terminated processes in memory. And pre-load processes that may be run later.
Run OS processes until memory is full.
Run more processes until memory is full.
Pre-load processes that may be run later.
Keep data from terminated processes in memory.

This shell conditional:
if test "$1" = "1"
is true if:

The first argument is the string "1".
The number of arguments = 1.
1 = 1 (i.e. is always true).
The variable "1" is true.
The first argument is true.

This character should be avoided in Unix filenames:

all numbers
* (star)
- (dash)
. (period)
_ (underscore)

This command:
sed -e 's|<|\<|g'

is redirecting output to a file.
is displaying the start of HTML tags but not getting them interpreted.
is a syntax error.
is removing HTML tags.
is blanking out the start of HTML tags.

On Linux, when you type a normal command, it should be in the PATH to run. Yet when you run ps -f you see a program running that is not in the PATH. How can this happen?

You can run programs that are not in the PATH.
ps -f will not show this.
There must be a system error.
This always happens.
The PATH must be wrong.
This cannot happen.

Swapping a process or part of a process to disk works with:

Run-time binding only.
Load-time binding only.
Any type of binding.
Load-time binding or run-time binding.

With compile-time binding, the memory locations used can be changed if the program is re-compiled. Why does the OS not do this?

The source code may not be available.
The program may no longer work.
It would take a large amount of time.
The user's data may be lost.

In a modern OS, one of these is false:

My file may be scattered in pieces around the disk.
My running program is not running constantly, but is getting periodic timeslices of the CPU.
My running program may be scattered in pieces around memory and disk.
My running program may be in memory at the same time as other user's programs.
My running program may be scattered in pieces around memory.
My running program is normally saved to disk when I shut down.
My running program may be in memory at the same time as other programs.

I am in the directory /stuff/and/things and I type: cd ../../../more/things - What directory am I in now?

The command is an error.
/stuff/and/more/things
/stuff/and/things/more/things
/stuff/more/things
/more/things

You write a simple program in assembly language (or "machine code", or "native instructions"). You then want to run the program on a different type of machine (different chip). Which is normally true:

The program must be re-assembled.
The program must be re-compiled.
The program must be re-written.
It should run without change.

I am in the directory /stuff/and/things and I type: cd more/things - What directory am I in now?

The command is an error.
/more/things
/stuff/and/things/more/things
/stuff/and/more/things
/stuff/more/things

Linux dominates supercomputers and other specialist computer niches because:

Open source Linux can be customised to unusual hardware.
Linux does not dominate that market.
Unix/Linux pulled ahead in the server market first.
Microsoft does not write for supercomputers.
Windows Server dominates the server market.
Windows can be customised to unusual hardware.
Microsoft does not write for servers.

One of these is true.

A command-line system is easier to automate than a GUI system.
Android's Unix-like command-line was key to its success.
Apple's Unix-like command-line was key to its success.
GUIs came before command-lines.
All users need the command-line.
Unix systems rarely have a GUI.
A command-line system is easier to use than a GUI system.

This program:

// define a function:
function f() { f(); } // function calls itself
// start the program:
f();

Runs forever, time-sliced.
Runs time-sliced until it crashes with a bad memory access.
Is detected by the Operating System and terminated.
Blocks all other processes from running.
Runs time-sliced until it crashes by running out of stack space.

The relationship of Paging to Swapping is:

Memory is used as a high-speed overflow of disk, so that the system slows down gracefully rather than suddenly.
They have no relationship. Paging is about memory. Swapping is about disk.
Disk is used as extra memory. Treated the same as other memory.
Most pages should expect to be swapped to disk as the program runs.
We can predict if running the next program will crash the system with a memory overflow.
Disk is used as a slow-speed overflow of memory, so that the system slows down gracefully rather than suddenly.

The commands "cd" followed by "cd public_html" followed by "mkdir ../stuff" make a directory called:

/stuff
$HOME/../stuff
/public_html/stuff
$HOME/stuff
$HOME/public_html/stuff
It does not make a directory.

We are searching for text in chapters of a book, called names like chap17.html. One of these is definitely not right:

grep Scotland ./chap*html
grep Scotland /*chap*html
grep Scotland chap*html
grep Scotland *chap*html
grep Scotland ../chap*html
grep Scotland */*/chap*html
grep Scotland \*chap*html
grep Scotland */chap*html

A program is a stream of instructions to be executed. When an OS runs a program, it starts the CPU executing that stream of instructions. How does the OS ever get control of the machine back?

The program will terminate.
The program will wait for some I/O at some point.
The program will be swapped when inactive.
The program will receive periodic timer interrupts.
The program will wait for user input at some point.

What will this Shell script do?

for i in *
do
rm i
done

Remove all the files in the current directory, except for hidden files.
Remove a file called i, perhaps multiple times.
Remove all hidden files in the current directory.
Remove all the files in the current directory.
It is a syntax error.
Remove all the files given in the arguments to the program.

When we run multiple programs at the same time, we need:

File protection.
Multiple terminals.
Multiple CPUs.
Memory protection.
We cannot do this.

On a multi-user system, when one user's program divides by zero:

It keeps running, interleaved with other users' programs.
The program has to be re-loaded.
It keeps running, but no other user's program can run.
An interrupt is generated and the program is terminated.