第六版Unix操作系统解析

需积分: 3 189 浏览量更新于2024-07-21 收藏 542KB PDF 举报

"这是一份关于第六版Unix操作系统详解的文档，由J.Lions撰写，旨在为新南威尔士大学的学生提供课程6.602B和6.657G的辅助材料，作为对《UNIX操作系统源代码，第六级》的补充和评注。这个系统由K.Thompson和D.Ritchie在贝尔实验室开发，并由西方电气公司授权使用。文档可能包含受多个许可证、版权和非披露协议保护的信息，其分发受到限制，只有获得UNIX软件系统许可的持有者才能获取。这份文档详细介绍了Unix操作系统，包括其系统工具、其他相关文档、程序员手册以及源代码的选段，是理解第六版Unix操作系统的宝贵资料。" 在第六版Unix操作系统中，我们能够深入了解到这个经典的多用户、多任务操作系统的核心原理和设计哲学。由K.Thompson和D.Ritchie创造的Unix系统，以其简洁、高效和可移植性而闻名，是现代操作系统设计的基础。这份文档首先引入了Unix操作系统的基本概念，强调了其在提供基础服务、管理和调度硬件资源以及提供用户接口方面的重要性。 "Utilities"部分讲述了Unix系统中的各种实用工具，这些工具构成了Unix shell环境的一部分，包括文本处理命令、文件管理工具以及系统管理命令等，它们极大地提高了用户的工作效率。例如，`ls`、`cd`、`cp`、`mv`等命令，以及管道（pipe）和重定向功能，都是Unix强大之处的体现。 "Other Documentation"和"UNIX Programmer's Manual"提到了Unix系统的完整文档集，这对于开发者来说是极其宝贵的资源，它提供了详细的API和系统调用说明，帮助开发者理解和利用Unix系统进行软件开发。 "UNIX Documents"涵盖了Unix系统的各种官方文档，包括系统管理员指南、网络配置手册、设备驱动程序文档等，这些文档帮助管理员管理和维护Unix系统，确保其稳定运行。 "UNIX Operating System Source Code"部分则关注了源代码的分析，对于学习操作系统原理和进行系统级编程的人员来说，直接查看源代码可以提供深入的理解。源代码的选段可能包括了关键子系统的实现，如进程调度、内存管理、文件系统和I/O操作等。这份第六版Unix操作系统评注不仅对于历史上的计算机科学教育具有重要意义，而且对于今天的系统开发者、管理员和研究人员来说，依然是理解操作系统设计和实现的宝贵参考资料。通过这份文档，读者可以深入到Unix的内核，探索其优雅的结构和设计，从而更好地理解和应用这个对现代计算影响深远的操作系统。

2 FUNDAMENTALS UNIX 6th Edition Commentary

Each pair of registers controls the mapping of

one page i.e. one eighth part of the virtual address

space which 8K bytes (4K words).

Each page may be regarded as an aggregate of

128 blocks, each of 64 bytes (32 words). This latter

size is the “grain size” for the memory mapping

function, and as a practical consequence, it is also

the “grain size” for memory allocation.

Any virtual address belongs to one page or

other. The corresponding physical address is gener-

ated by adding the relative address within the page

to the contents of the corresponding PAR to form

an extended address (18 bits on the PDP11/40 and

11/45; 22 bits on the 11/70).

Thus each page address register acts as a relo-

cation register for one page.

Each page can be divided on a 32 word bound-

ary into two parts, an upper part and lower part.

Each such part has a size which is a multiple of 32

words. In particular one part may be null, in which

case the other part coincides with the whole page.

One of the two parts is deemed to contain valid

virtual addresses. Addresses in the remaining part

are declared invalid. Any attempt to reference an

invalid address will be trapped by the hardware.

The advantage of this scheme is that space in the

physical memory need only be allocated for the

valid r)art of a page.

2.9 Page Description Register

The page description register deﬁnes:

(a) the size of the lower part of the page. (The

number stored is actually the number of 32

word blocks less one);

(b) a bit which is set when the upper part is the

valid part. (Also known as the “expansion

direction” bit);

only access” or “read/write access”.

Note that if the valid part is null, this fact must

be shown by setting the access bits to “no access”.

2.10 Memory Allocation

The hardware does not dictate the way areas in

physical memory which correspond to the valid

parts of pages should be allocated (except to the

extent that they must begin and end on a 32 word

boundary). These areas may be allocated in any

order and may overlap to any extent.

In practice the allocation of areas of physical

memory is much more disciplined as we shall see

in Chapter Seven. Areas for pages which are re-

lated are most often allocated contiguously and in

the order of their page numbers, so that all the

segment areas associated with a single program are

contained within one or at most two large areas of

physical memory.

2.11 Memory Management Status Reg-

isters

In addition to the segmentation registers, on the

PDP11/40 there are two memory management sta-

tus registers:

SR0 contains abort error ﬂags and other essential

information for the operating system. In par-

ticular memory management is enabled when

bit 0 of SR0 is on;

SR2 is loaded with the 16 bit virtual address at

the beginning of each instruction fetch.

2.12 “i” and “d” Spaces

In the PDP11/45 and 11/70 systems, there are ad-

ditional sets of segmentation registers. Addresses

created using the pc register (r7) are said to belong

to “i” space, and are translated by a diﬀerent set of

segmentation registers from those used for the re-

maining addresses which are said to belong to “d”

space.

The advantage of this arrangement is that both

“i” and “d” spaces may occupy up to 32K words,

thus allowing the maximum space which can be al-

located to a program to be increased to twice the

space available on the PDP11/40.

2.13 Initial Conditions

When the system is ﬁrst started after all the devices

on the Unibus have been reinitialised, the memory

management unit is disabled and the processor is

in kernel mode.

Under these circumstances, virtual (byte) ad-

dresses in the range 0 to 56K are mapped into iden-

tically valued physical addresses. However the high-

est page of the virtual address space is mapped into

the highest page of the physical address space, i.e.

on the PDP11/40 or 11/45, addresses in the range

0160000 to 0177777

are mapped into the range

0760000 to 0777777

2.14 Special Device Registers

The high page of physical memory is reserved for

various special registers associated with the proces-

sor and the peripheral devices. By sacriﬁcing one

3 READING “C” PROGRAMS UNIX 6th Edition Commentary

3 Reading “C” Programs

Learning to read programs written in the “C” lan-

guage is one of the hurdles that must be overcome

before you will be able to study the source code of

UNIX eﬀectively.

As with natural languages, reading is an easier

skill to acquire than writing. Even so you will need

to be careful lest some of the more subtle points

pass you by.

There are two of the “UNIX Documents” which

relate directly to the “C” language:

“C Reference Manual”, by Dennis Ritchie

“Programming in C – A Tutorial”, by Brian

Kernighan

You should read them now, as far as you can,

and return to reread them from time to time with

increasing comprehension.

Learning to write “C” programs is not required.

However if you have the opportunity, you should

attempt to write at least a few small programs.

This does represent the accepted way to learn a

programming language, and your understanding of

the proper use of such items as:

semicolons;

“=” and “==”

“{” and “}”

“++” and “−−”

declarations;

“if” and “for” statements

You will ﬁnd that “C” is a very convenient lan-

guage for accessing and manipulating data struc-

tures and character strings, which is what a large

part of operating systems is about. As beﬁts a

terminal oriented language, which requires concise,

compact expression, “C” uses a large character set

and makes many symbols such as “*” and “&” work

hard. In this respect it invites comparison with

APL.

There many features of “C” which are reminis-

cent of PL/1, but it goes well beyond the latter in

the range of facilities provided for structured pro-

gramming.

3.1 Some Selected Examples

The examples which follow are taken directly from

the source code.

3.2 Example 1

The simplest possible procedure, which does noth-

ing, occurs twice(!) in the source code as “nullsys”

(2864) and “nulldev” (6577), sic.

6577 nulldev ()

{

}

While there are no parameters, the parentheses,

“(” and “)”, are still required. The brackets “{” and

“}” delimit the procedure body, which is empty.

3.3 Example 2

The next example is a little less trivial:

6566 nodev ()

{

u.u_error = ENODEV;

}

The additional statement is an assignment state-

ment. It is terminated by a semicolon which is part

of the statement, not a statement separator as in

Algol-like languages.

“ENODEV” is a deﬁned symbol, i.e. a symbol

which is replaced by an associated character string

by the compiler preprocessor before actual compila-

tion. “ENODEV” is deﬁned on line 0484 as 19. The

UNIX convention is that deﬁned symbols are writ-

ten in upper case, and all other symbols in lower

case.

“=” is the assignment operator, and “u.u error”

is an element of the structure “u”. (See line 0419.)

Note the use of “.” as the operator which selects

an element of a structure. The element name is

“u error” which may be taken as a paradigm for the

way names of structure elements are constructed in

the UNIX source code: a distinguishing letter is

followed by an underscore followed by a name.

3.4 Example 3

6585 bcopy (from, to, count)

int *from, *to;

{

a = from;

b = to;

c = count;

*b++ = *a++;

while (--cc);

}

The function of this procedure is very simple: it

copies a speciﬁed number of words from one set of

consecutive locations to another set.

There are three parameters. The second line

int *from, *to;

UNIX 6th Edition Commentary 3 READING “C” PROGRAMS

speciﬁes that the ﬁrst two variables are pointers to

integers. Since no speciﬁcation is supplied for the

third parameter, it is assumed to be an integer by

default.

The three local variables, a, b, and c, have been

assigned to registers, because registers are more ac-

cessible and the object code to reference them is

shorter. “a” and “b” are pointers to integers and

“c” is an integer. The register declaration could

have been written more pedantically as

to emphasise the connection with integers.

The three lines beginning with “do” should be

studied carefully. If “b” is a “pointer to integer”

type, then

denotes the integer pointed to. Thus to copy the

value pointed to by “a” to the location designated

by “b”, we could write

*b = *a;

If we wrote instead

b = a;

this would make the value of “b” the same as

the value of “a”, i.e. “b” and “a” would point to

the same place. Here at least, that is not what is

required.

Having copied the ﬁrst word from source to des-

tination, we need to increase the values of “b” and

“a” so that the point to the next words of their

respective sets. This can be done by writing

b = b+1; a = a+1;

but “C” provides a shorter notation (which is more

useful when the variable names are longer) viz.

b++; a++;

Now there is no diﬀerence between the state-

ments “b++;” and “++b;” here.

However “b++” and “++b” may be used as

terms in an expression, in which case they are dif-

ferent. In both cases the eﬀect of incrementing “b”

is retained, but the value which enters the expres-

sion is the initial value for “b++” and the ﬁnal

value for “++b”.

The “−−” operator obeys the same rules as the

“++” operator, except that it decrements by one.

Thus “−−c” enters an expression as the value after

decrementation.

The “++” and “−−” operators are very useful,

and are used throughout UNIX. Occasionally you

will have to go back to ﬁrst principles to work out

exactly what their use implies. Note also there is a

diﬀerence between *b++ and (*b)++.

These operators are applicable to pointers to

structures as well as to simple data types. When a

pointer which has been declared with reference to

a particular type of structure is incremented, the

actual value of the pointer is incremented by the

size of the structure.

We can now see the meaning of the line

*b++ = *a++;

The word is copied and the pointers are incre-

mented, all in one hit.

The line

while (--c);

delimits the end of the set of statements which be-

gan after the “do”. The expression in parentheses

“−−c”, is evaluated and tested (the value tested

is the value after decrementation). If the value is

non-zero, the loop is repeated, else it is terminated.

Obviously if the initial value for “count” were

negative, the loop would not terminate properly.

If this were a serious possibility then the routine

would have to be modiﬁed.

3.5 Example 4

6619 getf (f)

{

rf = f;

if (rf < 0 || rf >= NOFILE)

goto bad;

fp = u.u_ofile[rf];

if (fp != NULL)

return (fp);

bad:

u.u_error = EBADF;

return (NULL);

}

The parameter “f” is a presumed integer, and is

copied directly into the register variable “rf”. (This

pattern will become so familiar that we will now

cease to remark upon it.)

The three simple relational expressions

rf < 0 rf >=NOFILE fp != NULL

are each accorded the value one if true, and the

value zero if false. The ﬁrst tests if the value of

“rf” is less than zero, the second, if “rf” is greater

than the value deﬁned by “NOFILE” and the third,

if the value of “fp” is not equal to “NULL” (which

is deﬁned to be zero).

3 READING “C” PROGRAMS UNIX 6th Edition Commentary

The conditions tested by the “if” statements are

the arithmetic expressions contained within paren-

theses.

If the expression is greater than zero the test is

successful and the following statement is executed.

Thus if for instance, “fp” had the value 001375,

then

fp != NULL

is true, and as a term in an arithmetic expression, is

accorded the value one. This value is greater than

zero, and hence the statement

return(fp);

would be executed, to terminate further execution

of “getf”, and to return the value of “fp” to the

calling procedure as the result of “getf”.

The expression

rf < 0 || rf >= NOFILE

is the logical disjunction (“or”) of the two simple

relational expressions.

An example of a “goto” statement and associ-

ated label will be noted.

“fp” is assigned a value, which is an address,

from the “rf”-th element of the array of integers

“u oﬁle”, which is embedded in the structure “u”.

The procedure “getf” returns a value to its call-

ing procedure. This is either the vale of “fp” (i.e.

an address) or “NULL”.

3.6 Example 5

2113 wakeup (chan)

{

c= chan;

p= &proc[0];

i= NPROC;

do {

if (p->p_wchan == c) {

setrun(p);

}

p++;

} while (--i);

}

There are a number of similarities between this

example and the previous one. We have a new con-

cept however, an array of structures. To be just a

little confusing, in this example it turns out that

both the array and the structure are called “proc”

(yes, “C” allows this). They are declared on Sheet

03 in the following form:

0358 struct proc

{

char p_stat;

..........

int p_wchan;

..........

} proc[NPROC];

“p” is a register variable of type pointer to a

structure of type “proc”.

p = &proc[0];

assigns to “p” the address of the ﬁrst element of

the array “proc”. The operator “&” in this context

means “the address of”.

Note that if an array has n elements, the ele-

ments have subscripts 0, 1, .., (n-1). Also it is per-

missible to write the above statement more simply

p = proc;

There are two statements in between the “do”

and the “while”. The ﬁrst of these could be rewrit-

ten more simply as

if (p->p wchan == c) setrun (p);

i.e. the brackets are superﬂuous in this case, and

since “C” is a free form language, the arrangement

of text between lines is not signiﬁcant.

The statement

setrun (p);

invokes the procedure “setrun” passing the value of

“p” as a parameter (All parameters are passed by

value.). The relation

p->p_wchan == c

tests the equality of the value of “c” and the value

of the element “p wchan” of the structure pointed

to by “p”. Note that it would have been wrong to

have written

p.p_wchan == c

because “p” is not the name of a structure.

The second statement, which cannot be com-

bined with the ﬁrst, increments “p” by the size of

the “proc” structure, whatever that is. (The com-

piler can ﬁgure it out.)

In order to do this calculation correctly, the

compiler needs to know the kind of structure

pointed at. When this is not a consideration, you

will notice that often in similar situations, “p” will

be declared simply as

剩余114页未读，继续阅读

酱油王

粉丝: 7
资源: 25

第六版Unix操作系统解析

A Commentary on the Sixth Edition Unix Operating System

A COMMENTARY ON THE SIXTH EDITION UNIX OPERATING SYSTEM 【J. Lions 】.pdf.7z

A COMMENTARY ON THE sixth edition UNIX 简明版

Code Commentary On The Linux Virtual Memory Manager

Lion's Commentary on Unix

lions_commentary_to_UNIX

commentary_on_Android

The New C Standard：A Cultural and Economic Commentary

UNIX.6th.Edition.with.rar_UNIX

a simple, Unix-like teaching operating system-rev8.pdf

最新资源