OS

Lecture No. 5

operating system

1. Purpose and main functions of the operating system.

By the term “operating system” we mean a complex

programs whose functions are to control the use and

distribution of computing system resources. We said that in

a computing system has physical resources, that is, those resources that

associated with real hardware (magnetic disks, RAM,

processor operating time). We also said that in the system for its success

functioning there are logical (sometimes called virtual)

resources, that is, resources that are not in the form of real equipment

exist, but are implemented in the form of some means provided

to the user. We will simply call physical and logical resources

computing system resources.

Any operating system (OS) operates with some entities,

which, together with the methods of managing them, largely characterize it

properties. Such entities may include the concepts of file, process,

object, etc. Each OS has its own set of such entities. For example, in the OS

Windows NT such entities include the concept of an object, and already through

management of this entity is provided with all possible functions. If we

Let's look at UNIX, then in it such an entity, first of all, is

the concept of a file, and secondly, the concept of a process.

A process is a certain entity that is present practically in

all OS. A process is a program that has ownership rights to resources.

Consider two programs (that is, the code and data that are used) and

Let's consider all those resources that belong to the program (this could be:

RAM space, data on external storage device,

ownership rights to other resources, for example, communication lines). If the sets

resources belonging to two programs coincide, then in this case we do not

we can talk about these programs as two processes - this is one

process. If each program has its own set of resources, and these

sets can intersect, but not coincide, then we are talking about two

processes.

In the case where sets of resources of several processes have

non-empty intersection, then we have a question about the use, so

called shared resources. We talked about this partly last time

lectures: remember the example with the printing device. We may have several

processes, each of which has a device as its resource

printing and can access this resource with an order at any time

to print some information. Synchronization of processes using an example

printing device illustrated for us one of the functions of the OS, which is

managing the functioning of processes. Let's see what is understood

under process control.

Process management:

1. Central time management

processor.

2. Paging and input buffer management.

3. Management of shared resources.

Basic problems of process management.

The first is managing CPU time usage.

(CPU), or this problem is sometimes called CPU scheduling, that is, managing

at what point in time which of the tasks or which of the processes will be

own CPU activity: which process will the CPU run on.

The second is the management of paging and the input buffer. Let's assume the situation

when a large number of people, for example the entire course, are sitting at computers,

and everyone simultaneously launched some tasks in the form of processes. In system

a lot of problems have arisen (more than a hundred are guaranteed). And all the computing

the system cannot accept one hundred tasks for operation in multiprogram mode -

it's too much. In this case, a so-called input buffer is formed

tasks, or process input buffer, that is, a buffer in which

those processes that are waiting for the processor to begin processing. Arises

the problem of the order in which processes are selected from this buffer to begin processing.

This is a buffer scheduling problem.

Now consider the swap scheduling problem. Processor

several processes are being processed, and we are faced with the task of releasing

real RAM for other tasks. In this case, there is

the need to transfer some of the processed tasks to an external

Memory device. And what algorithm will we use to pump out these

tasks? What will be the pumping strategy? You can pump out, for example, every

even task. How to more or less profitably organize the pumping process -

This is problem.

Third is the management of shared resources. There is a set of resources

access to which at certain points in time is organized on behalf of

various processes. This is the same conflict with the printing device. One of

functions that largely determine the properties of the OS is a function

ensuring the organization of interaction between processes and the use of common

resources. The problem from the example with the printing device is easily solved, but

if two programs have a common fragment of RAM, then control

such a shared resource is a difficult task.

Now let's look at the OS design. Almost any OS has

concept of the core. The OS kernel is usually its resident part, that is, the

part of the OS that is not involved in swapping processes (it is always

present in RAM) and operates in OS mode, or in

supervisor (in that very specialized mode that we talked about

in the last lecture). The core includes basic controls for the main

entities specific to a given OS, and may also include a set

programs that provide control of certain physical devices. IN

Kernel functions, in particular, include interrupt handling.

We will sometimes call programs that manage resources drivers

devices (physical or logical). For example, the OS kernel should include

random access memory driver.

computing system. The first level mainly consists of drivers

physical devices. The next level is logical control

then file management drivers may appear in our scheme, which, on

in fact, are associated with logical disk management drivers, and those in

in turn, are associated with the drivers of real physical devices, and so on

It is not at all necessary that all OS components operate in

supervisor, or in OS mode. Many of the components that logically

sufficiently remote from the kernel, can work in an ordinary user

mode. It’s also not necessary, all these OS components run in resident

mode. Typically, many functions do not require this.

Now let's move on to a more detailed consideration of the main functions of the OS.

Controlling CPU time usage.

In fact, it depends on what algorithm for selecting a task to transfer to it

CPU activity is implemented in the OS, many real operational

properties of this OS. The choice of algorithm is determined almost entirely by those

performance criteria that are used to evaluate effectiveness

OS operation. Therefore, managing CPU time usage is with you

Let's consider it against the backdrop of considering OS types.

First situation. I have a large number of tasks or programs,

requiring large volume computing power systems. These are the tasks

which are called counting problems; they require a lot of computation

and little access to external devices. These tasks must be performed on

one computing system. What will be the criterion of effectiveness

for the operation of the system when performing this package of tasks? What a set

parameters you can take and say: if they are large, then it’s good, if

on the contrary - is it bad? For such a situation, the criterion for work efficiency

computing system is the degree of CPU utilization. If he's little

idle (i.e. it works in standby mode, and all processes are busy

exchange, or the OS takes over the time), then we can say that such

the system works efficiently. This can be achieved using

the corresponding planning algorithm, which is as follows.

We launch for processing the set of tasks that we have according to

OS capabilities (either maximum or all tasks), which is provided

multiprogramming mode. CPU time scheduling algorithm in this

case will be the following: if the CPU is allocated to one of the processes, then this

The process will occupy the CPU until one of the following situations occurs:

1. Access to an external device.

2. Completing the process.

3. Recorded fact of process cycling.

As soon as one of these situations occurs, control is transferred to

to another process. Number of control transfers from one process to

to another is minimized. Since when transferring control from one process

on another OS must perform a set of certain actions, and this is a loss

time, then these losses are minimized. This mode of operation of the OS

called burst mode. An OS that runs in this mode

called package OS.

Now imagine a situation where a significant number of people

is in a computer lab and each of them edits some

text. Each terminal has its own copy of a text editor associated with it.

Let's see what happens to the system if we apply the planning algorithm,

stated for the first case. Suppose one of the users is slightly

dozed off at the terminal and shows no activity. CPU time will be

associated with this process because this process does not exchange and does not

completed as the editor is ready to work. At this time, everyone remaining

users will be forced to wait for the sleeper to wake up. It will work out

freezing situation. This means that an algorithm that is good for the first

case, this system is not suitable even with the most powerful machine.

Therefore, for tasks that solve the problem of providing a large number of

users of computing services (interactive tasks), apply

other algorithms based on other performance criteria.

For such a system, the user waiting time criterion is suitable: s

the moment he sent an order to perform some action, until the moment

system response to this order. The more efficiently the system operates, the more

the average waiting time in the system is less.

Let's consider the situation for the second case. The system contains some

number of processes, and the scheduler’s task is to distribute CPU time so

so that the system response time to a user request is

minimal, or at least guaranteed. The following is proposed

scheme. The system uses a certain parameter (t, which is called

quantum of time (in general case, a time slice is a certain value,

which may change during system setup). All the many processes

which is in multiprogram processing is divided into two

subsets. The first subset consists of those processes that have not yet

ready to continue execution: for example, those processes that ordered

make an exchange and wait for its results. Are there processes that are ready for

execution. The work will be carried out as follows. That process

which in this moment time occupies the CPU, will own it up to

occurrence of one of the following events:

1. Handling an exchange order.

2. Completing the process.

3. Exhaustion of the quantum allocated to this process

time (t.

When one of these events occurs, the OS scheduler selects from

processes ready to execute, some process and transfers resources to it

CPU. And he chooses this process depending on the algorithm

scheduling that was used in this particular OS. For example,

the process may be chosen randomly. The second way is that

there is a sort of sequential traversal of processes, that is, we took in

work first one of the processes, then it becomes free, and the CPU time will be

given to the next process in order of those ready to run.

The third criterion by which the next task is selected may be

the time that the process was not serviced by the CPU. In this case the system

can choose the process that has the longest time. These algorithms

must be implemented in the OS, which means they must be simple, otherwise

the system will work ineffectively, on its own (although there are such systems:

in particular, the Windows family suffers from this).

This type of OS is called time-sharing OS. It works in the mode

which minimizes the system response time to a user request. IN

ideally, due to the fact that the response time to a request is minimal,

the user should be given the illusion that all system resources

provided only to him.

Now let's look at the next problem. Let's say we have an airplane,

controlled by an autopilot, which performs an operation on autopilot

reduction. Every airplane has an instrument that measures altitude from

aircraft to the surface of the earth. The aircraft operating mode is such that the control

its functions are carried out by a computer according to a given program.

So, if we have an autopilot system and the plane descends, this is the system

must control the flight altitude. The central computer of this aircraft

can solve several problems: it can control the flight altitude,

fuel level in tanks, some indicators of engine performance, etc.

Each of these functions is managed by its own process. Let's assume

We have a batch OS, and we carefully monitor the fuel level in the tanks. At

this, obviously, an emergency situation arises, because the plane continues

decrease, but the OS does not notice this.

Let's say we have a time sharing system. One of the qualities

time sharing systems are ineffective due to the fact that

the system provides for a large number of switchings from process to

process, and this function is quite labor-intensive. Same situation: height

approaches zero, and the OS is busy reinstalling the registration tables. Such

option is also not suitable.

To solve this kind of problem you need your own planning tools. IN

In this case, the so-called real-time OS is used, the main

the criterion of which is the time of the guaranteed response of the system to

the occurrence of one or another event from a set of predetermined

events. That is, the system has a set of events to which the system at any time

situations will react and process them in a predetermined time.

For our example, such an event could be the receipt of information from

height sensor. In reality, OSs of this class use fairly simple

algorithms. All planning lies in this criterion, that is

it is guaranteed that the event will be processed in a time not exceeding a certain

threshold value. But a real-time OS usually has its own

a specific device that is determined not only by this simple

planning algorithm, but also internal reorganization of the system.

Drawing a line under the usage management function

CPU time and CPU scheduling, I draw attention to two facts. First fact

this is what those algorithms that are implemented in the planning system

CPU time distribution largely determines performance properties

computing system. I specifically gave examples, suggesting

use different OS for different purposes. Second fact. We looked at three

typical types of OS: batch processing systems, separation systems

time and real time systems. Today we can talk about

that a real-time system is a separate class of OS. Guaranteed

Windows OS will not manage any objects that have this real

time is very critical. Also will not manage such objects and OS

SOLARIS or LINUX, etc., because these systems are not systems

real time.

The first two modes, batch and time sharing, can be emulated

on such generally accepted OS. In reality, large and serious operating systems are

mixed systems, i.e. they have CPU scheduling elements

both algorithms that allow you to manage counting tasks, and algorithms that

allowing you to manage interactive tasks or debugging tasks,

for which you need a little CPU.

An example of such a CPU scheduling organization would be the following:

scheme. The scheduler is built on a two-level scheme. We believe that

a set of problems may contain, say, counting problems and

interactive tasks. The first level determines the priority between the two

classes of problems and either devotes the CPU to the counting task first, or to the interactive one

task. And the second level defines what we talked about before, i.e.

how to select a task within one class and how to interrupt it. Such

a mixed system can work as follows. First level

planning will work according to this principle: if at the moment there is no

not a single interactive task ready to be executed (and this is a very real

situation if users are editing text), then the CPU

is transferred to counting tasks, but one condition is added: as soon as

at least one interactive task appears, the counting task is interrupted and

control is transferred to the block of interactive tasks. This is what it concerns

the first process control function.

Paging and input buffer management.

Here planning algorithms are necessary, but not so critical. IN

In real systems, the swap buffer is often combined, i.e. then space

on external media, where information is pumped out from the operational

memory, and process input buffer. This is the first note.

Second note. Modern OSs are quite “lazy” and pump out

often carried out not in units of process memory blocks, but pumped out

the whole process. Two questions arise here: what is the criterion for substitution?

process and what is the criterion for selecting from the buffer the process that we need

required for multiprogram processing. The simplest option

consists in using the time spent in one state or another. IN

the first case, if we decide to pump out a process from an active one

states from among those processed in the swap area, then we can take that

the process that remains in the processing state for the longest time

astronomical time. The reverse process can be symmetrical, i.e. We

we can take from the process input buffer the process that has been there the longest

located. In fact, these are simple and real planning algorithms, and

they can be modified based on different criteria. One of

criteria if all tasks are divided into different categories, i.e. they can

be OS tasks - in this case they are considered first (and

among them there is an algorithm for estimating the time they spent there) and that’s all

other tasks. This model is similar to the model of life injustice

in a society where there are omnipotent people to whom everything is permitted, but there are

people who can wait.

Shared resource management.

Here we will only indicate the problem, because its specific solutions

We will look at the example of the UNIX OS.

Suppose there are two processes that run on a common

RAM space. In this case, shared resources can

to work in different modes, i.e. it is possible that two processes

are really on different cars, but they are connected by a common operational field

memory. In this case, there is a problem with memory buffering,

because each machine has its own read buffering mechanisms -

records. Here a bad situation arises when the state of physical

memory does not correspond to its real contents. And also arise

some problems for an OS running on two machines.

Next problem. Let there be two processes that work on

one car. There must be certain means that will allow

synchronize access to shared memory, that is, they will allow you to create

conditions under which the exchange of each of the running processes with the operational

memory will occur correctly. This means that every time you read

information from shared memory must be guaranteed that all

users who started writing something to this memory already have this process

completed - there should be synchronization over the exchange with shared memory.

In reality, when solving problems, such

shared resources, like Common memory, but I would like the processes

which function simultaneously could have some influence on each other

on a friend. The effect is similar to the interrupt apparatus. To implement this in

Many operating systems have a means of passing signals between processes, then

Some software emulation of interrupts occurs. One process says -

pass the signal to another process. Another process is interrupted

execution of this process and transfer of control to some

a predefined function that must process the received signal. This

third OS function.

I drew your attention to such OS functions that affect its

operational properties. In fact, any OS also contains a huge set

other functions that ensure the operation of this system.

Lecture No. 6

In the last lecture we talked about the fact that almost any

The operating system provides I/O buffering. In fact,

it is one of the main functions of the operating system. By analogy with the fight against

different access speeds to various components of the computer system

the operating system introduces software buffering within its limits,

which also solves access time smoothing and

synchronization in general (example with a printing device). Smoothing out problems

access is that almost every operating system

has cache buffers that accumulate access to external storage

device (VZU) is similar to hardware buffering when working with operational

memory. This allows you to significantly optimize the operating system.

An indication of the presence of such buffering is a request to stop

execution of the operating system before shutting down the machine. For example, working

with the MS-DOS operating system, you can turn off the computer at any time

time, because there is no such buffering. In operating systems

like Windows and UNIX, it is considered incorrect to simply turn off the machine when

working system, in this case there is a possibility that something will happen

some loss of information (since, for example, the moments of the order for exchange and

the exchanges themselves are far from identical). The extent of this buffering

determines the real efficiency of the system. When our faculty began

Pentiums appeared, it was discovered that when working with Windows 95

there is practically no qualitative difference between whether the system works on

486 processor or Pentium. This suggests that the effectiveness

The system does not depend on the efficiency of working with an external device. If

take the UNIX operating system, then this difference will be noticeable, since

here the speed of the processor has a greater impact on the quality of the system,

than for Windows 95, because the Windows 95 system exchanges with

external media is much larger due to some “dumbness” of the algorithms

buffering work with external devices.

2. File system.

We told you that each of the operating systems operates

some entities, one of which is a process. There is a second one

an entity that is also important is the concept of a file. The file system is

component of the operating system that provides organization of creation,

storage and access to named data sets. These named sets

data are called files.

Basic file properties

1. A file is an object that has a name and allows you to operate with

a sequence of some characters, the length of which depends on the specific

operating system.

2. File independence from location. To work with a specific file

there is no need to have information about the location of this file on the external

device.

3. A set of input/output functions. Almost every operating system

uniquely defines a set of functions that ensures exchange with a file. Usually,

this set of functions consists of the following queries:

1. Open a file for work. You can open either an existing one,

or a new file. The question may arise - why open the file?

this is a means to centrally declare

operating system that the file will work with a specific

process. And from this information she can already accept some

solutions (for example, blocking access to this file for others

processes).

2. Read/write. Typically, file sharing can be arranged

some data blocks. The data block that happens to

exchange carries a dual essence. On the one hand, for any

computing system, the sizes of data blocks are known, which

most effective for exchange, that is, it is software-

hardware dimensions. On the other hand, these data blocks when

real exchange can vary quite arbitrarily

programmer. Read/write functions usually include size

blocks of data to be exchanged and the number of data blocks that

must be read or written. From the selected block size

data may depend on the effectiveness of real exchanges, because

that, suppose for some machine the size of the effective

the data block is 256Kb, and you want to carry out exchanges by

128Kb, and you make two requests to read your

128Kb logical blocks. It is very likely that instead of

to read a block of 256Kb in one exchange, you contact two

times to one block and read first one half, and then

another. There are elements of inefficiency here, although they may

smoothed out by a “smart” operating system, and if it doesn’t

smooths it out, then it’s your fault.

3. File pointer management. With almost every open

The concept of a file pointer is associated with a file. This pointer

similar to the program counter register, at each moment of time

points to the next relative address in the file with which

exchange can be made. After exchange with this block, the pointer

is transferred to the position through the block. To organize work with

the file needs to be able to manage this pointer. Available

file pointer management function that allows

Move the pointer arbitrarily (within the available range)

file. A pointer is some variable accessible to the program,

which is associated with the file open function (which creates this

variable).

4. Closing the file. This operation can be carried out by two

file contents. 2) Destroy the file.

After closing the file, all connections with it are terminated, and it comes

into some canonical state.

4. Data protection. Many strategic decisions are repeated both on

hardware level and at the operating system level. If we remember

multiprogram mode, then one of necessary conditions his existence

is to provide protection (memory and data). If we consider the file

system, then it is the same as the operating system, maybe

single-user. In this case, there is no data protection problem,

because the person who works with this operating system is

the owner of all files. Examples of single-user systems - MS-DOS or

Windows 95. You can boot the machine and destroy all the files of others

users who are located on the disk, because on these systems

there is no protection. The multi-user system ensures correct

work for many users. MS-DOS can also run in

multiprogramming, but it is not correct enough because the error is in

one process can lead to overwriting the operating system and the neighboring

process. Also in the Windows 95 operating system it can work a lot

users, but this work is incorrect, because this operating system

the system does not provide all protection rights. So, multi-user

the system must ensure information protection from unauthorized

access. In fact, the security problem is not only related to file

system. In reality, the operating system provides data protection in all

areas: these are files, processes, and resources belonging to processes,

running as one user. Here I draw your attention to

this fact because for files this is the most critical point.

Basic properties of file systems.

The file system naturally includes all those properties that

were listed for the files, but adds some more. These properties

associated with the structural organization file system.

Let's look at some VZU space and see how we

We can organize the placement of files within this space.

1. Single-level organization of files in continuous segments. Term

“single-level” means that the system provides work with files

uniquely named. Within the space of the VZU, some

an area for storing data called a directory. The catalog has

following structure:

|name |start block |end block |

"Start block" refers to some relative address

space of the VRAM from which the file with the given name begins. "Finite

block" defines the last block this file. File open function

comes down to finding the file name in the directory and determining its beginning and

end (in reality, the data may take up slightly less space, more on this later

said later). This action is very simple, and the directory can be stored

in the operating system memory, and thereby reduce the number of exchanges.

If a new file is created, it is written to free space.

Similar to a name directory, there can be a table of free spaces

(fragments).

Reading/writing occurs almost without additional exchanges, since when

opening we get a range of data placement. Reading takes place in

according to this block structure and no additional information

is not required, so the exchange occurs very quickly.

What happens when you need to write additional

information, but there is no free space behind this file? In this case

The system can do two things. First, she will say that there is no room and you

must do something themselves, for example, launch a certain process that

will move this file to another location and add the necessary information. This

transfer is a rather expensive function. The second possibility is in exchange

will be refused. This means that when opening a file you had to

make a reservation extra bed; at the same time the file system checks

the size of the free buffer, and if it is not enough, it looks for free space where

this file will be located.

So, we see that this organization is simple, effective in exchanges, but

if there is not enough space for the file, inefficiency begins. Besides

However, during long-term operation of such a file system on the disk, something happens:

The same thing that happened to us with RAM is fragmentation. That is

a situation when there are free fragments, but among them there is no one where

it would be possible to post the file. Combating fragmentation for such an organization

file system - this is periodic compression when a long,

a process that is heavy and dangerous for the contents of the file system,

presses all files tightly together.

Such an organization may be suitable for a single-user

file system, because when large quantities users are very

Fragmentation will quickly occur, and the constant start of compression is death for

systems. On the other hand, the system is simple and requires almost no

overhead costs.

2. File system with block file organization. VZU space

divided into blocks (the same blocks that are effective for exchange). IN

In a file system of this type, the distribution of information occurs similarly

distribution of process information in RAM from page

organization. In general, each filename has a set of numbers associated with it.

device blocks in which the data of this file is located. Moreover, the numbers

these blocks have a random order, that is, the blocks can be scattered

throughout the device in random order. With such an organization there is no

fragmentation, although there may be losses that are multiples of a block (if the file took at least

one byte in a block, the entire block is considered occupied). Therefore no

compression problems, and this system can be used when

multi-user organization.

In this case, each file is associated with a set of attributes: file name, name

user by whom the file is accessed. Such an organization

allows you to get away from the uniqueness of names, which was required in the previous

case. In such a system, unique names are required only among files

one user.

The organization of such files can be through a directory. Directory structure

maybe next. The directory contains the strings; every i-th line

corresponds to the i-th block of the file system. This line contains

information about whether this block is free or busy. If he

busy, then this line indicates the file name (or a link to it), the name

user, and there may be some additional information.

When exchanging, the system can act in different ways. Or when opening

file, the system runs through the entire directory and builds a correspondence table

logical blocks of the file, their placement on the disk. Or with every exchange

a search for this correspondence is carried out.

This organization of the file system is single-level within

one user, that is, all files are linked into groups according to their membership

to some user.

3. Hierarchical file system. All files in the file system

built into a structure called a tree. At the root of the tree

there is the so-called root of the file system. If a tree node

is a sheet, then it is a file that can contain user data,

or be a file directory. Tree nodes other than a leaf are

directory files. Naming in such a hierarchical file system can

take place different ways. The first type is file naming relative

nearest directory, i.e. if we look at the files that are

closest to directory F0 is file F1, which is also

directory, and file F2. For successful naming in such a system on one

names cannot be repeated at a level. On the other hand, since all files

connected by a tree, we can talk about the so-called full name

file, which is made up of all the file names that make up the path from

file system root to a specific file. The full name of the F3 file will be

denoted as follows: /F0/F1/F3. The good thing about this kind of organization is that it

allows you to work with both a short file name (if the system

it is assumed that we work in this directory) and with the full name

file. Full file names are paths, and in any tree from its root to

For any node there is only one path, therefore this solves

problem of unification of names. The first time this approach was used was in

Multix operating system, which was developed at the University of Berkeley

in the late 60s. This beautiful solution began to appear later in

many operating systems. According to this hierarchy, each of the files

you can bind some attributes related to access rights. Rights

Both user files and directories can have access.

The structure of this system is good for organizing multi-user work,

due to the absence of a naming problem, and such a system can very well

build up.

4. Personalization and protection of data in the operating system. This nuance

which we will now consider, both simple and complex. Simple - because we

Let's talk about it in just a few sentences, but it's complex because there are

problems that can be discussed at length.

Personification is the ability of the operating system to identify

specific user and, in accordance with this, accept certain

actions, in particular regarding data protection.

If you and I look at our favorite operating system MS-DOS,

then there was no concept of a user with all the ensuing consequences -

it is single-user.

The second level of operating systems are operating systems that

allow users to register, but all users are introduced

in the form of a single set of certain subjects and are not connected with each other in any way.

An example of such operating systems are some operating systems.

IBM systems for mainframe computers. For example, the lecturer does not know who

of his listeners to which group belongs, but everyone sitting in front of him

users of his course. This is both good and bad. From a listening perspective

a course of lectures is good, but for this lecturer to conduct some kind of survey

this is bad, because in one day he will not have time to interview everyone. He needs

will somehow divide all the listeners, but it is not known how.

Accordingly, with such one-dimensional personification, all

those functions that we talked about (in particular protection), but such

user organization does not imply the formation of user groups.

And it’s convenient for me that, let’s say, on our faculty server my

laboratory was allocated, and within this laboratory it would be possible

grant each other access rights to files, etc.

Accordingly, similar to the file system, a hierarchical

user organization. That is, we have the concept of “all users”

and the concept of “user group”. There are real users in the group.

This hierarchical organization of personification entails the following

moments. When registering a user, you must first

tie it to some group - it could be a laboratory, department or

study group. Since users are grouped, it appears

the ability to separate access rights to user resources. That is

the user can, for example, declare that all his resources are available to

all users of the group. Such a scheme can be multi-level (groups

divided into subgroups, etc.) with a corresponding distribution of rights and

opportunities. Nowadays there are operating systems in which the rights

access can be determined not only by such a hierarchical structure, but also

can be more complex, i.e. access rights can be added, violating this

hierarchy.

Lecture No. 7

3. UNIX operating system.

We move on to studying the UNIX operating system, since many

decisions that are made in operating systems, we will

consider the example of this operating system.

In the mid-60s, AT&T Bell Laboratories conducted

research and development of one of the first operating systems in modern

its understanding - the Multix operating system. This operating system

had the properties of a time-sharing operating system,

multi-user system, as well as in this system were proposed

the main decisions on organizing file systems, in particular, were

A hierarchical tree file system is proposed. From this development

After some time, the UNIX operating system was launched. One of

the history of the development of this system suggests that the company had unnecessary

a PDP-7 computer with very underdeveloped software was required

a machine that would allow organizing comfortable work for the user,

in particular, processing of text information. A famous group of people is

Ken Thompson and Dennis Ritchie began developing a new operating room

systems. Another version of this story says that they were allegedly engaged in

implementation of a certain game and the means that were available to them,

turned out to be inconvenient - then they decided to play with this machine. As a result

The UNIX operating system appeared.

The peculiarity of this system was that it was the first system

program that was written using a language other than

machine language (assembler). For the purpose of writing this system

software, in particular the UNIX operating system, also

work was carried out that started from the BCPL language. From it was formed

language B, which operated with machine words. Further abstraction of machine

words - BN, and finally the C language. Since 1983, the UNIX operating system (its

original version) was rewritten into C language, and it turned out that about

90% of the operating system was written in a high-level language, not

depending on the machine architecture, and 10% of this system was written in

assembler. These ten percent included the most time-critical

parts of the operating system.

So, the first important and revolutionary result was the use

high level language. This fact caused discussion because no one

believed that this could be long-term, since the language is always high

level was associated with greater inefficiency. The C language was

designed in such a way that it allowed, on the one hand, to write

quite effective programs, on the other hand, broadcast it in

efficient code.

The first feature of the C language that made it more efficient was

working with pointers. The second property is that when

In assembly language programming we often use side effects.

For example, the effect when the result of evaluating some expression is

not only the recorded value, but also some intermediate values,

which can be written down along the way for later use. These

capabilities have become available in the C language, because the concept of expression in

C language is much broader than in those languages ​​​​that were available at that time

time. In particular, the assignment operation appeared instead of the operator

assignment, which made it possible to program side effects. These

properties and determined the “survivability” of the language, suitability for programming

system components and the ability to optimally translate the code of various

From a professional (canonical) point of view, the C language is terrible

language. The main requirement for languages

programming, is to ensure programming security.

Language tools should minimize the likelihood of introducing errors into

program, and obviously such means of modern languages ​​include

the following: strict type checking (i.e. you cannot, for example, fold

an integer variable with a real one without first converting the type

one of them to the type of the other). The C language has the ability to transform

default types. Another criminal thing is ensuring control over

access to program memory (i.e. if a memory cell stores

real number, then we cannot interpret it in any other way).

The possibility of uncontrolled use of these values ​​is provided by

pointers. Moreover, through a pointer you can “cheat” functions into

compliance and non-compliance actual parameters formal parameters

etc. The third property is control over the interaction of modules. A lot of

errors appear if one set is declared in the function

formal parameters, and access to it occurs according to a different set

(and the differences can be both in the number of parameters and in types). IN

in C language you can always trick the program - instead of a formal parameter

of one type give a parameter of another type, and instead of ten parameters pass

one. This leads to errors.

Here are three areas where the C language does not meet the requirements

security. However, experience shows that the most tenacious are

bad (from this point of view) languages.

So, 1973 is the year of the appearance of an operating system written in C language

UNIX systems. What main properties did this system have? First

property is a concept for files. The main object with which it operates

operating system, is a file. File, from an operating point of view

UNIX systems is an external device. A file is a directory that

contains information about the files it contains. And so on, on

which can work.

The second property is the special structure of the operating system. In contrast

from previous operating systems in which every command was "hardwired"

inside the operating system, i.e. it could not be modified in any way,

UNIX solves command problems very elegantly. First, UNIX

declares a standard interface for passing parameters from outside to inside

process. Secondly, all commands are implemented as files. It means,

that you can freely add new commands to the system, as well as remove and

modify them. That is, the UNIX system is open and can be easily developed.

Let's start looking at the specific properties of the operating system.

File system. File organization. Working with files.

The UNIX file system is a multi-user hierarchical

file system. We drew its structure in the last lecture. She

can be represented by a tree whose root is the so-called root

catalog. The nodes other than the leaves of the tree are directories. Leaves

can be either files (in the traditional sense) or empty directories.

The system defines the concept of a file name - this is the name that is associated with

a set of data within the directory to which this file belongs. Except

In addition, there is the concept of a full name - this is a unique path from the root of the file

system to a specific file. Allowed to match the names of files located

in different directories.

In fact, the file system is not entirely tree-like. Available

the possibility of breaking the hierarchy through means that allow association

several names (full) with the same file contents - this is so

hierarchical and tree-like.

The UNIX operating system uses a three-level hierarchy

users (all users are divided into groups), the structure of which is

the general case was discussed in the previous lecture. In this regard, everyone

A file system file has two attributes. The first attribute is, so

called the owner of the file. This attribute is associated with one specific

the user who is the owner of the file. The owner of the file can

become the default if you create this file, and there is also a command that

allows you to change the owner of a file. The second attribute is the attribute associated with

file access protection (more on this will be discussed later).

Access to each file is regulated according to three categories. First

can definitely do whatever he wants with this file. Second category -

the rights of the group to which the file owner belongs (different from the rights

excluding the relevant group. For these three categories

three actions are regulated - reading from a file, writing to a file and execution

file. Each file determines whether a user of a given category can

process.

Working with files

Let's look at the structure of the file system on the disk. For anyone

computing system, the concept of system external storage is defined

devices (SVZU). SVZU is a device that is accessed

the machine's hardware bootloader for the purpose of starting the operating system. Almost

any computer has a range of memory address space,

located in the so-called read-only memory (ROM). IN

The ROM contains a small program (hardware bootloader) that, when

turning on or hard rebooting the machine, accesses the fixed

block SVZU, places it in RAM and transfers control to

fixed address belonging to the read data. It is believed that this

The read data block is the so-called software loader.

It should be noted that the hardware bootloader does not depend on the operating system.

system, and the boot loader is a component of the operating system.

He already knows where the data needed to run the operating system is located.

In any system, it is customary to partition the VZU space into some

areas of data called blocks. Logical block size

is a fixed attribute of the operating system. In the operating room

On a UNIX system, the block size is determined by some parameter that can

vary depending on the system version. To be specific, we will

say that the logical block of the VRAM is 512 bytes.

Let's imagine the address space of the SVZU as a sequence

blocks. Zero block SVZU is a block bootstrap, or block, in

where the boot loader is located. Placing this block at zero

the SVZU block is determined by hardware, because the hardware bootloader

always addresses the zero block. This is the last component of the file

system, which depends on the equipment.

The next block is the superblock of the file system. He contains

operational information about the current state of the operating system, as well as

information about file system settings. In particular, the superblock

contains information about the number of so-called index descriptors in

file system. The superblock also contains information about the number of blocks,

components of the file system, as well as information about free blocks

files, free inodes, and other data,

characterizing time, date of modification and other special parameters.

|Block |Superblock|Area |Blocks |Area |

| initial | to | index | files | saving |

|download |file|descriptor| | |

| |system |s | | |

Following the superblock is an area (space) of inodes.

An inode is a special file system data structure that

which is put into one-to-one correspondence with each file.

The size of the inode space is determined by the parameter

generating a file system based on the number of inodes that

are indicated in the superblock. Each inode contains the following

information:

2. Security code field.

4. File length in bytes.

The next file system space is file blocks. This

space on the system device in which all information is located,

stored in files and about files, which did not fit into previous blocks

file system.

The last data area is implemented differently in different systems, but

behind the file system blocks is the save area.

This is the conceptual structure of a file system. Now let's consider

Superblock. The last two are of greatest interest in the superblock.

fields: fields for information about free file blocks and free index blocks

descriptors. In the UNIX file system, the influence of two factors is noticeable.

The first factor is that the file system was developed in those days,

when a hard drive capacity of 5-10MB was considered very large. Inside the structure

external device space. The second factor is the property of the file system

to optimize access. The criterion for optimal access is the number of exchanges

file system with an external device that it produces for

meeting needs.

The list (array) of free file blocks consists of fifty

elements and takes 100 bytes. In a buffer of fifty

elements, the numbers of free blocks of memory block space are recorded. These

the numbers are written from the second element to the forty-ninth. First element

array contains number last entry in this array. Zero element

this list continues, etc.

If some process needs to expand its file size

additional free block, then the system according to the Block Number (NB) index

selects an array element (a copy of the superblock is always present in

RAM, so in almost all such actions the system does not

needs to contact the SVZU) and this block is provided to the appropriate

file for expansion (in this case the NB pointer is adjusted). If

If the file size is reduced or the entire file is deleted, then

the released numbers are written to an array of free blocks, while

the NB indicator is also corrected.

Since the size of the array is fifty elements, there are two possible

critical situations. The first is when, when releasing new blocks, it is not

manages to place their numbers in this array, since it is already full. In that

In this case, one free block is selected from the file system (and it

is removed from the list of free blocks) and the filled array of free blocks

copied to this block. After this, the value of the NB pointer is reset to zero, and in

the zero element of the array is the number of the block that we have chosen for

copying our array into it. As a result, with constant release

blocks, a list is formed in which the numbers of absolutely all

free blocks of the file system.

The second critical situation is when you need to get a free block, but

The array's contents are exhausted. In this case, the system operates as follows: if

the null element of the list is zero, then this means that everything has been exhausted

file system space, and a message about this is displayed. If he doesn't

is zero, then its contents are equal to the address of the continuation of the array, and

the operating system reads the corresponding block and places it

continuation to the place of the array in the superblock.

The second array, which is located in the superblock, is an array consisting

of one hundred elements and containing the numbers of free inodes.

Working with this array is simple. As long as there's room in this

array, then when the index descriptors are released, the free index descriptors

descriptors are written to free places array. If the array is full

completely, then writing to this array stops. If, on the contrary, the content

the array is exhausted, then a process is launched that

scans the inode area and fills in accordingly

array with new values. There may be a situation when you need to create a file, i.e.

a new inode is needed and there are no elements in the array, and

The running process also did not find any free inodes. This

the second situation is when the system is forced to declare that the resource has been exhausted

(the first is when the file system runs out of free blocks).

Lecture No. 8

Indices. Inodes occupy several consecutive

running blocks on the disk. The size of the inode area is determined by

parameter (which was defined during system installation) that determines

the number of inodes for that particular file system.

The size of the area is equal to the product of this quantity and the size of the index

descriptor.

An inode is a UNIX object that is placed in mutual

unambiguous correspondence with the contents of the file, except when

a file is a special file associated with an external device. IN

The inode has the following fields:

1. A field defining the file type (directory or not).

2. Security code field.

3. The number of links to a given index descriptor out of all possible

directories of the file system (in the situation of violation of the file tree

systems). If the value of this field is zero, then it is considered that

this inode is free.

4. File length in bytes.

5. Statistics: fields characterizing the date and time of creation, etc.

6. File block addressing field.

Note that there is no file name in the inode,

although this object characterizes the contents of the file. Let's see how

Addressing of blocks in which the contents of the file is located is organized.

The addressing field contains the numbers of the first ten file blocks. If

the file is small, then all information about the placement of its blocks is in

index handle. If the file exceeds ten blocks, it starts

work some kind of list structure. Eleventh element of the addressing field

contains the block number from the file block space in which 128 are located

links to blocks of this file.

If the file is even larger, then the twelfth one is used

element of the addressing field. It contains the block number, which contains 128

records about block numbers containing 128 file block numbers

systems, i.e., double indirection is used here. If the file is still

is greater, then the thirteenth element is used and the triple is used

indirection (similar to double, but adds another level).

The file size limit (with a block size of 512) will be equal to (128 + 1282 +

1283) * 512 bytes = 1GB + 8MB + 64KB > 1GB.

We agreed that during our course we will pay

attention to speed discrepancies and smoothing them out. First

problem - if the file system did not have an array of free ones in the superblock

blocks, then we would have to somehow look for free ones each time

blocks, and this work would be crazy, and the file system would crash to

ideological level. Similarly with the list of free inodes,

although the search here would be simpler than for free blocks, but nevertheless,

there are also optimization elements here. Indirectness in block addressing

files allows the overhead of reading blocks of files to increase

proportional to the size of this file. That is, if the file is small, then overhead

there are no expenses, because when a file is opened, a

a copy of the file inode, and without additional calls to the VCU

you can access any of the ten blocks of the file immediately. If it is needed

work with blocks located at the first level of indirect addressing, then

one additional exchange appears, but access can still be made

already to 128 blocks. Similar reasoning for blocks two and three

order. It would seem that the bad thing is that when exchanging with a large file you have to

carry out many additional exchanges, but the UNIX system is tricky -

it uses deep in-echelon buffering of exchanges with the VCU. That is

if we do get some overhead at one level, then they

are compensated at another level of optimization of system interaction with

external memory.

File blocks. The size of the file block space is defined unambiguously

way due to the information in the superblock.

Process saving area. Although this area is shown behind blocks

files, but it can also be located in some file of the file system

or at any location of other VZU. It depends on the specific implementation

systems. Essentially, this area is a useful area to

processes are being pumped out, and this area is also used for

optimizing the launch of the most frequently used processes using,

the so-called t-bit of the file (more on this will be discussed later).

So, we have looked at the structure of the file system and its

organization on a system device. Like any system design,

The structure of the file system and the operating algorithms associated with it are simple

so that when working with them the overhead costs do not go beyond

reasonable. UNIX file system when real work obviously more optimal

Windows NT file system (compare development dates!!!), due to its simplicity

and optimization, which occurs at every step.

Catalogs

We told you that one of the properties of the UNIX operating system

is that all information is placed in files, i.e. no any

special tables used by the operating system, for

with the exception of those tables that it creates while already functioning in

RAM space. Directory, from a file system point of view,

This is a file that contains data about those files that belong to

catalogue.

Directory A contains files B, C and D, although

that files B and C can be either files or directories, and

file D is a directory.

The directory consists of items that contain two fields. First field -

inode number, the second field is the file name, which

associated with this inode. Index numbers

descriptors (in inode space) start at one.

The first inode is the directory inode. In general

there may be entries in the directory that refer to the same index

handle, but there cannot be entries in the directory that have the same name.

The name is unique within the directory, but the contents of the file may

associate an arbitrary number of names. Therefore there is some

ambiguity in the definition of a file in the UNIX operating system.

The file turns out to be more than just a named set of data: it has

inode and there can be multiple names (i.e. name is secondary

component).

When a directory is created, two entries are always created in it: an entry for

special file named "." (dot) with which the index is associated

handle to the directory itself, and the file ".." (two dots) with which

associated with the inode (ID) of the parent directory. For our

example, directory A has, for example, ID number 7, and directory D has ID number

number 5. File F has ID No. 10, file G has ID No. 101. In this case, the file is

directory D will have the following contents:

|Name |ID |

|“.” |5 | The first entry is an entry for yourself. |

|“..” |7 | The second entry is for the parent (directory A). |

| | |catalogue. |

|"G" |101 | This is what the contents of directory D will be. |

The difference between a directory file and regular user files is

the contents of the file type field in the ID. For the root directory, the parent field will be

refer to himself.

Now let's look schematically at how full names can be used

and directory structure. In the system, at every moment of operation

user is defined by the current directory, that is, the directory and the entire path from

root associated with this directory, which by default is substituted for

all file names that do not begin with the "/" character. If the current directory is D,

then we can simply talk about files F and G, and if we need to get to file B,

then you must use the full name or a special file “..”, i.e., in

in this case, the construction “../B”. We refer to the file ".." - this is

means that you need to read the parent ID and use it to get to the content

directory A. Then in the directory file A you need to select a line named B and

determine the ID of file B, and then open the file. This whole operation

quite labor-intensive, but given that files are not opened often, this

will not affect the speed of the system.

We said that the same content can be associated

several names, i.e. files with the same file can be opened at the same time

ID. A problem arises - how to synchronize work with the contents of the file in

if it is opened by different processes or with different names. In UNIX this is

can be solved quite correctly (we will look at this a little later).

Device special files

We already know two types of files: directory files and working files, in

which data is stored. There is a third type - device files. This

the variety is characterized by the type specified in the ID. Contents of files

There are no devices, but only ID and name. The ID contains information about

what type of device is associated with this file: byte-oriented

device or block-oriented device. Byte-oriented

device is the device with which exchange is carried out one at a time

byte (for example, keyboard). A block-oriented device is

a device with which exchange can be carried out in blocks.

There is also a field identifying the driver number associated with this

device (one device can have several drivers, but not

vice versa). This field is actually a number in the driver table

corresponding class of devices. The system has two tables: for block

and for byte-oriented devices. The ID also defines some

a digital parameter that can be passed to the driver as

clarifying information about the work.

Organization of data exchange with files

Let's first define what is low-level I/O in

system. The UNIX file system defines some special

functions called system calls. System calls

directly access the operating system, that is, it

functions that perform some operating system actions. Implementation

system and library functions (for example, mathematical) at the root

is different. If the library function is loaded into the process body,

who uses this library, then all actions in most cases

will be executed within this process, and the system call will immediately

transfers control to the operating system and it performs what is ordered

action. In UNIX, to provide low-level I/O, i.e.

I/O, which is implemented through system calls, is available

set of functions. Here are the main ones:

1. open - Open an existing file. One of the parameters of this function

is a string with the file name, and it returns a number,

which is called a file descriptor. In the body of the user process,

and also in the data associated with this process is located

(except for code and data, of course) some service information, in

specifically, the file descriptor table. She, like all the tables in

UNIX system, positional, i.e. descriptor number corresponds to

the entry number in this table. With file descriptor (FD)

the file name and all the necessary attributes for working with it are associated.

FD numbers are unique within one process. There is a similar

create function - function to open a new file.

2. read/write - read/write system calls, the parameters of which

is the FD number and some attributes that are not so important for

our consideration.

3. close - system call to complete work with a file, parameter

which is the FD number. After accessing this FD function

becomes free, and the work of this process with the file ends.

Here are some system calls that provide I/O (by the way, they are

almost no code is added to your program). See details

on one's own. I drew your attention to the fact that these are system calls, because

that I/O can also be done through I/O libraries. For

This is why there is the so-called file exchange and the functions fopen, fread, and

etc. (prefixed with f). These are library functions. These functions call themselves

to low-level functions within itself.

Let's consider the organization of exchange from a systemic point of view in the operating room

UNIX system. When organizing an exchange, the operating system divides

and data associated with the operating system.

Inode table open files. The first data table,

associated with the operating system - table of inodes

open files (TIDOF). This table contains records, each of which

contains a copy of the inode for each one open on the system

file. File blocks are accessed through this copy. Each

table records also contains a field characterizing the number of open

file system using this descriptor (counter). That is, if

the same file is opened on behalf of two processes, then an entry in TIDOF

one is created, but each additional opening of this file increases

counter per unit.

File table. The file table (TF) contains information about the name

Lecture No. 9

We said that the system can work with the contents of the file in that and

only if the process has registered its desire to work with

this file. The fact of such registration is called opening a file. At

opening a file within a process for each file name being opened

(may open already existing file, or new) is placed in

matches a unique integer called file

descriptor (FD). Within the process, PDs are numbered from 0 to k-1.

The k value is an operating system tuning parameter that determines whether

how many simultaneously open files a process can have. Here

It should be noted that we are talking about the number of simultaneously open files

(the same is written in any book on UNIX), however, in fact, k is

the maximum number of FDs that can be associated with one

file, because the same file can be opened two times within a process

times, and two FDs are formed. What this will lead to, we will look at a few

later, but this is quite correct. After opening the file, all exchange operations

are carried out through file descriptor instructions (i.e. the name is nowhere else

not specified). Each file descriptor has a number of parameters associated with it

(more on them a little later).

Let's see how input/output, or rather processing, is organized

low-level exchange, from the operating system's point of view. Will now be

told about logical circuit organization of input/output, because the real circuit

is arranged somewhat differently, but this is not so important for us.

All data that the system operates with is divided into two

class. The first type of data is data associated with the operational

system, that is, system-wide data. This data includes TIDOF.

The table size is fixed and is determined by the number of simultaneously open

FD. Each entry in this table contains some information, including

which we will be interested in is the following:

1) Copy of the open file ID. For any open file, the ID that

characterizes the contents of this file, is copied and placed in

TIDOPH. After this, all manipulations with the file (for example, changing

file addressing) occur with a copy of the ID, and not with the ID itself on disk.

TIDOF is located in RAM, i.e. access to information in

it is carried out quickly.

2) Counter of currently open files associated with this ID. This

means that for any number of times the file associated with

given an ID, the system works with a single copy of this ID.

Now let's move on to the so-called file table (TF). File table

consists of a fixed number of records. Each TF entry

corresponds to a file open in the system ((or more precisely FD)). At the same time, in

in the vast majority of cases this is a one-to-one correspondence.

In the case where this is not a one-to-one correspondence, we

Let's look at it below. Each TF record contains read/write pointers for

file. This means that if the same file is open in two processes

or twice in the same process, then each opening has its own pointer associated with it, and

they do not depend on each other (almost always, with the exception of some

cases). Each TF record contains a so-called index

heredity - this is some integer.

This is operating system level data, i.e. data that describes

the state of the problem in the system as a whole.

Each process is associated with a so-called open file table

(TOF). The entry number in this table is the FD number. Every line of this

information about indexes associated with FD seems to be torn apart. With one

On the other hand, file descriptors are data that is an attribute of the process,

on the other hand, a pointer is data that is an attribute of the operating

systems. It would seem illogical, and now we will look at what this

illogicality appears. To do this, let us briefly consider the conceptual

issues related to the formation of the process. UNIX operating system

has a fork() function. This is a system call. When accessing this system

call, some action occurs in the system, which for most of the

may seem pointless to you - the process is copied, in

which this function was encountered, i.e. A twin process is created. For what

this is necessary, I will say a little later.

The formation of a twin process has the following properties. First

property: child process that will be formed after calling the function

fork() has all those files that were opened in the father process. Second -

the system allows, by some of its own means, to identify where

the father process, and where is the son process, although in the general case they are absolutely

are the same.

Suppose there is process No. 1, and a table of open

files No. 1. In this process, a file named Name is open, and this file

file descriptor I is assigned. This means that in

the corresponding line of the TOF will be a record with a link to the TF. In TF

some attributes associated with opening a file are defined, and there is also

read/write pointer, i.e. the pointer by which we work,

exchanging information with the file. Entries in the TF have a link to TIDOF, in

which contains a copy of the ID corresponding to the file named Name.

Let's assume that this process once again opens a file named Name.

The system assigned it the file descriptor J. That is. this

the opening corresponds to the J-th line of the Pacific Fleet of the first process. In this entry

opening the file Name. And so far the heredity indices for both cases

will be equal to one. This entry will have its own related to this discovery,

read/write pointers. File descriptor pointers I and J are independent

from each other, i.e. when reading/writing through file descriptor I,

The file descriptor pointer J will not change. This post will link

to the same inode from TIDOF, and the counter value will be

equals two.

Let's assume that process #1 made a call to the fork() function,

a copy of the process has been formed, and both copies begin to work at the output

from fork(), and TOF No. 2 will be associated with the second process. It will be the same

the Name file is opened by ID I and by ID J. But in this case, when the process received

open files are inherited from the parent, then links from the corresponding lines

TOF will occur not on new TF records, but on the same ones to which

the corresponding FDs from the parent were referenced. These processes have read pointers

the entries will be the same, i.e. if you move the pointer in one process,

then it will automatically move to another process. This case is like

times when there is no one-to-one correspondence between the TF strings and

lines of the Pacific Fleet. When these links are spawned, the counter is increased by two. AND,

accordingly, from the ID, due to the addressing of blocks, access is provided to

blocks of files. Such information organization exchange means that exchange

with the contents of each file is carried out centrally, i.e. ultimately

As a result, all orders for exchange go through one single entry, no matter how many

no files associated with this ID were open on the system. There are no

collisions, when confusion begins in time in what is completed, or

outstanding exchanges associated with one handle.

Whenever a new process is formed, the system a priori establishes

zero, first and second file descriptors from TOF, linking them with

predefined files. Zero FD is associated with the system input file, with

An external device, a keyboard, is usually associated with it. The first FD is

standard output file, usually associated with a monitor screen. Second

FD is a standard file for outputting diagnostic messages, with it also

usually associated with a monitor screen.

Let us consider, as an example, typical actions when accessing certain

system calls.

Calling the fork() function. As you know, when calling this function

the system creates a copy of the original process. In this case, the system duplicates the Pacific Fleet

one process in the TOF of the successor process, and also increases by one

heredity index in TF lines associated with open files

the original process, and also increases the counter of open files associated with

according to ID, in TIDOF.

Calling the open() function. When calling this function, it happens

following:

1. The full name determines the directory in which the

2. The ID number is determined. The ID number is searched in

table TIDOF.

3. If a record with a given number is found, record the number

corresponding line TIDOF and go to step 5.

4. If the line is not detected, the

a new line corresponding to the new ID and fixes it

5. Adjust the link counter (arrow) to the TIDOF entry. Number

records in TIDOF are recorded in the TF record, as well as in the TOF

this results in the program returning the number of terms of the Pacific Fleet, in which

During I/O operations, the system's actions are obvious.

Interaction with devices. We have already said that all devices

that are served by the UNIX operating system may be

classified into two types - byte-oriented devices and block-oriented

oriented devices. It should be noted that the same device in

system can be considered both byte-oriented and block-oriented

oriented (example - RAM). Accordingly, there is

drivers are block-oriented and byte-oriented. At the last lecture we

considered special files, associated with external devices, and

They said that there is a table of drivers for block-oriented devices

and a table of byte-oriented device drivers. Accordingly, these

The main feature of organizing work with block-oriented

devices is the ability to buffer exchange. The point is

next. A pool of buffers is organized in the system's RAM, where

each buffer is one block in size. Each of these blocks can be

associated with the driver of one of the physical block-oriented

devices.

Let's look at how the sequence of actions is performed when executing

block from device number M.

1. Among the buffers of the buffer pool, a search is carried out for the specified

block, i.e. if a buffer containing the Nth block of the Mth is detected

device, then we record the number of this buffer. In this case,

appeal to the real physical device doesn't happen, but

the operation of reading information is presenting information

from the found buffer. Let's move on to step 4.

2. If the search for a given buffer is unsuccessful, then in the buffer pool

a buffer is searched for reading and placing this

block. If there is a free buffer (in reality, this situation

is possible only at system startup), then we record its number and

go to step 3. If a free buffer is not found, then we

select the buffer that has not been accessed for the longest time

time. If the buffer has a set sign

information has been written to the buffer, then

real record of the block allocated in the buffer on the physical

device. Then we fix its number and also go to

3. The Nth block of device M is read into the found one

4. The time counter in this buffer is reset and

incrementing counters in other buffers by one.

5. We transmit the contents of this data as a reading result

You see there is an optimization here related to minimization

real calls to the physical device. This is quite useful when

operation of the system. Blocks are written according to a similar scheme. So

This is how buffering is organized for low-level I/O.

The benefits are obvious. The disadvantage is that the system in this case

is critical to unauthorized power outages, i.e.

a situation when the system buffers are not unloaded, but an abnormal situation occurs

stopping the execution of operating system programs, which can lead to

loss of information.

The second disadvantage is that due to buffering, the

in time, the fact of turning to the system for exchange and the actual exchange. This

the disadvantage manifests itself if, during real physical exchange

a crash occurs. Those. it is necessary, suppose, to write down a block, it

is written to the buffer, and a response is received from the system that the exchange has ended

successfully, but when the system will actually write this block to the VSD is unknown. At

In this case, an emergency situation may arise due to the fact that the recording may

fail, suppose, due to defects in the media. This turns out to be a situation where

which the call to the system for the exchange function for the process was successful

(the process received the answer that everything was recorded), but, in fact, the exchange was not

Thus, this system is designed for reliable hardware and

correct professional operating conditions. To fight the odds

loss of information when emergency situations occur, the system is sufficiently

“smart” and acts correctly. Namely, the system has a certain parameter,

which can change quickly, which defines periods of time,

through which system data is reset. Second - there is

The command that may be available to the user is the SYNC command. By this

The command flushes data to disk. And thirdly, the system has

some redundancy, allowing in case of information loss, to produce

a set of actions that will restore information or controversial blocks that

could not be identified by file affiliation, will be written to

specific location in the file system. This is where you can try them

analyze and restore manually, or lose something. Our

the university was one of the first in the country to operate an operating room

UNIX system, and now we can already say that the problems of system unreliability,

in terms of fatal loss of information, there was none.

Today we started talking about the fact that we have system calls and

I/O libraries. Another tool that allows

optimize system performance, is a standard input/output library,

associated with the stdio.h include file. The essence of the conceptual exchange is the same

the same as when organizing low-level input/output. The difference is

what if open() returns the file descriptor number, fopen() returns

a pointer to some structure of a special type FILE. Second and main

This is a library of functions. Many of the service features this

library are implemented within your address space. IN

In particular, this service function is another level of buffering

input/output. Its essence is that on process resources you can

allocate a buffer that will work similarly to a buffer pool

operating system and, which minimizes your process's access to

I/O system calls. It is clear that this I/O library

implemented through a program using system calls

input/output. This means that there is a double buffering factor, although

this increases insecurity.

Double buffering is obviously a useful thing. It allows you to contact

to read or write through library functions with data volumes of half a block

or a third of the block, and if these parts are in a row, then the system itself, due to

buffering, collects these parts and, instead of several calls to the system

a call performs only one call. It's profitable. The disadvantage is that this

buffering is organized within the address space of the process with

all the ensuing consequences (synchronization of exchanges is lost, including

if other processes work with this file through this library,

because the body of each process has its own buffer, which can

accumulate this data and any uniformity that exists in

the scheme we considered does not work). However, standard

the I/O library is a handy tool; she also has the means

blocking this buffering.

Lecture No. 10

In the last lecture we discussed the following points related to

organizing the functioning of the file system. This is a systemic organization

low-level exchange. We found that by organizing the data,

UNIX operating system using fairly simple and transparent means

solves problems of possible conflicts in case of several openings of one and

the same file. We saw that all openings of the same file (under

by file we understand not the name, but the contents) ultimately come down to work

with a single copy of the ID. We have found out that almost all discoveries

files associated with the same ID give rise to the ability for processes to work

with their own read/write file pointers, unless

when a file in a process was obtained through inheritance, i.e. the file was received

from the father process through the fork() function to the son process.

We have found out that the system divides the devices it supports

into two classes: block-oriented and byte-oriented. Same

a device can be both byte-oriented and block-oriented at the same time

oriented. This depends both on the device itself and on the availability

drivers - programs that control this device. An example of this

device is RAM.

We have reviewed the principles of organizing low-level exchange for

block-oriented devices, and in the context of this we became acquainted with

buffering tools that are used in UNIX OS, the essence of which

is that, by analogy with read/write buffers from the operational

memory (hardware), the operating system creates software

tools that allow you to minimize the number of calls to

physical device. This mechanism distinguished and distinguishes the UNIX OS.

It should be noted here that exchange buffering can be multi-level.

The first additional level may appear due to the fact that the device

may have its own hardware buffers, implemented similarly to buffers

random access memory.

We also talked about the fact that in addition to low-level I/O, with

which are associated with functions that provide system calls (open, read, write

etc.), there are high-level access means - this is the standard

stdio.h input/output library, the connection of which allows you to use

to organize exchanges, another level of buffering (this is optimization

calls to system calls), which is associated with the process, i.e.

buffering occurs at the expense of process resources. We assessed what was good

what is wrong. Obviously, buffering reduces the number of exchanges with

slow external device, and the more such levels, the less

exchanges take place. However, the bad thing is that due to buffering it reduces

system reliability. For example, if the system unexpectedly turns off

power supply, all buffers lose information. The moment of turning to exchange is far from

real exchange, and therefore unpleasant situations are possible. But despite

these shortcomings, experience shows that fatal losses of information occur

rarely.

I would like to draw your attention to how much UNIX saves access to the VCU.

The superblock is located in RAM, and real actions with information

superblocks do not come from the disk, but from RAM, although here

The same problem occurs with unauthorized power off.

When opening a file, we work with ID. We found out that working with ID

carried out through working with its copy located in software

tables in RAM. This means there is almost no overhead

costs associated with small files, and this overhead is small when

working with huge files. It turns out that almost the entire infrastructure,

supporting the operation of the file system, works due to deep

layered buffering.

File attributes

We talked about organizing system users; she has

hierarchical three-level structure.

Any user belongs to a group. According to hierarchy

users, a hierarchy of file protection and user rights is defined.

The concept of a file owner is defined. The initial owner of the file is

the user (more precisely, the user process) who created this file. Attribute

The "file owner" can be changed with the changeown command. Each file has

security attributes associated with the hierarchy. There are access rights to some

actions of the file on the part of the file owner. These are read permissions

recording, for execution. Each file, except for the rights associated with the level

user has rights associated with the group level. These are rights for everyone

users of the group to which the file owner belongs, with the exception of

himself (i.e. the rights of the owner and his group are different). Third category

protection - everyone else. These are the rights that all users have

systems, with the exception of the owner and his group. The system has a command

change access rights changemode.

In addition to access attributes, each file can have characteristics such as

in particular, the so-called t-bit and s-bit, which are also set by some

team. We, already knowing the structure of the file system, understand that, in principle,

the file may be very fragmented. Besides,

the file may be large, and when opening large file, overheads arise

costs associated with accessing distant blocks of a file. Therefore the opening

file is a long process. To optimize this action,

The system has the ability to mark executable files with a t-bit. After that

the following happens: if called executable file,

marked with a t-bit, then during the first call during a system session,

copying the file body to the saving area. Each time you call again

file, first the directory of the saving area is viewed, and in that

If the file you are looking for is there, then the file is not loaded from the OSD,

but from this area. That is, this is another way to minimize calls to the VZU.

Usually the ability to set the t-bit is the prerogative of the system

administrator, and the system administrator himself selects those processes (and

respectively, files) that must be marked with a t-bit. Usually they are marked with it

those processes that are used most frequently (if, for example, there is

workshop, then it makes sense to mark the compiler file with a t-bit).

We will look at the S-bit somewhat superficially, but will return to it later.

There is the following problem. All funds in the system belong to someone, because... All

means, all commands (except some built-ins) in the final

account are files that have an owner. Some of

these commands can address one or another system files. Arises

problem related to the fact that, on the one hand, there must be protection from

unauthorized access to the file. On the other hand, all teams have

potential rights for all categories. What should I do? It is possible to mark

some files are s-bit. The owner of the s-bit file remains unchanged, but

when this file is launched, the owner of the process that launched this file,

rights to access data are granted from the owner of the source file.

Let's say there is an executable named file and it runs like this:

then the image with the file file2, which contains confidential information.

Let's say file updates file2, which contains information about

all registered users and, in particular, file can change

user password in the system. If I run file on my behalf, then they can

two situations will arise: either I will not be able to work with file2, which contains

user account information because it is closed to everyone

the rest; or it is open to everyone, then there is no protection. In this case

s-bit works. The essence of his work is as follows. Owner

the source file is ROOT user. Let's assume this file is wanted

run user named MASH. If MASH runs this file and there is no s-

bit, it turns out that the owner of the file is ROOT, and the owner

process became MASH. In this case, files that are not accessible to the user

MASH will be inaccessible to its process, and MASH will not be able to change its

password in the system. S-bit allows you to extend the rights of the owner (ROOT) of the file for

owner (MASH) of the process (launched from this file), and for the duration of the session

operation of the process, it will have access to all those files that were accessible

the owner of the file (ROOT).

Next question: how are directory permissions interpreted?

(since directories are also files)? Permission to read from

directory means that entering the directory and opening files from it is allowed

catalogue. Write permission provides the ability to create and

destroy files in this directory. Permission to execute is

the ability to search in a given directory (for example, using the ls command).

The file system from the user's point of view.

Let's look at the file system structure from the point of view

user. This structure will be considered for a generalized

operating system, since its actual structure may vary.

There is a file in the root directory called unix. This is the same file

which is launched by the boot loader, and which forms the kernel

ETC Catalog. This directory contains standard files data

systems and commands that provide some level of control

functioning of the system. 1. File passwd. All users in

system are registered through this file. This means that if

the user can work, then in the passwd file there is a line marked

username, which contains a set of some data separated

delimiter character. In particular, the passwd file line contains the number

the group to which the user belongs can sometimes contain

encrypted password for user login into the system. Coded -

means that the system uses a mutually ambiguous possibility

mapping a sequence of characters into some code, and in the system

A display of this password is stored. Modern UNIXes store passwords in

a separate secure database (although the passwd file is also present),

because the passwd file is usually open for reading, the conversion algorithm

is also usually known and it is possible to guess the password.

characterizing the last name, first name and patronymic of the user; field in which

the user status is indicated; field indicating the “home” directory.

The same line indicates (or can indicate) with which interpreter

commands this user will work. There may be some more

options.

2. File rc. This file contains in text form a set

commands that will be executed when the operating system boots.

For example, when booting, the operating system may start a process

checking the integrity of the file system.

Please note that the UNIX operating system, with the exception of

several cases, contains all its system information in ordinary

text files. This information is easy to view and easy to

is being adjusted. At one time, this was a revolutionary step.

3. In the same directory there are commands that allow

change user passwords (passwd executable file), allow

“mount” local file systems to the file system and

base the same local systems, allow you to start the process

testing and correction of the file system. This process checks the file

system according to a certain set of characteristics, for example, a set of free

files should, when combined with many busy files, give all

BIN catalogue. This catalog contains the overwhelming number of standard

system commands available to the user.

MNT Catalog. This is the directory to which you can “mount” local

file systems. Until today, we believed that the file system

located on one device, but in reality this is not the case. There is a main

file system on the system device, and there is an arbitrary (in

within reasonable limits) the number of local file systems that

mounted to the system using some command. The root of the local

file system will be the MNT directory.

DER Catalog. This directory contains files associated with

specific external device drivers, such as console drivers,

line printing, etc. You remember that files associated with drivers

external devices, in the ID that is associated with their name, have the attribute

that this is a file device, and also have links in the ID to the corresponding

driver tables. These files have no content.

USR Catalog. This directory has a LIB subdirectory, which usually contains

there are libraries that implement some group functions,

provided to the user, incl. C compiler with appropriate

support libraries.

Also, there is a subdirectory BIN (/USR/BIN), which contains

system administrator additional “homespun” commands, because they

placement in the /BIN directory is considered incorrect.

INCLUDE subdirectory. Do you remember what the include line looks like? .

This line tells the C preprocessor to take a file from the directory

/USR/INCLUDE. This directory has its own subdirectories, and is interesting for us

SYS subdirectory (/USR/INCLUDE/SYS). It contains include files,

associated with system capabilities, in particular signal.h is

a list of the signals that can be exchanged between two processes.

So, we have finished describing the file system, and we can conclude that

The UNIX file system is hierarchical, multi-user. File

The UNIX system has deep, multi-tiered buffering for exchanges with

real devices. The UNIX file system is informational

basis for the functioning of the operating system. This is an extensible file

system, while maintaining its integrity, i.e. and always

there is only one path from its root to any node (or leaf).

The UNIX file system, in terms of logical organization of files, has

its clear and transparent structure. This imposes certain conditions

on the system administration, because there are problems coordinating access rights to

various components of the file system, there are problems placing a new

information within the file system.

-----------------------

Heredity Index