е
считываниЯ каждого блока Ядро уменьшает размер канала в соответствии с коли-
чеством  считанных  данных  и устанавливает значение смещениЯ в пространстве
процесса так, чтобы при достижении конца канала оно указывало на его начало.
Љогда выполнение системной функции read завершаетсЯ, Ядро  возобновлЯет  вы-
полнение  всех приостановленных процессов записи и запоминает текущее значе-
ние указателЯ чтениЯ в индексе (а не в записи таблицы файлов).
    …сли процесс пытаетсЯ считать больше информации, чем фактически  есть  в
канале, функциЯ read завершитсЯ успешно, возвратив все данные, находЯщиесЯ в
данный  момент в канале, пусть даже не полностью выполнив запрос пользовате-
лЯ. …сли канал пуст, процесс обычно приостанавливаетсЯ до тех пор, пока  ка-
кой-нибудь другой процесс не запишет данные в канал, после чего все приоста-
новленные  процессы,  ожидающие  ввода  данных, возобновЯт свое выполнение и
начнут конкурировать за чтение из канала. …сли,  однако,  процесс  открывает
поименованный  канал  с  параметром  "no delay" (без задержки), функциЯ read
возвратит управление немедленно, если в канале отсутствуют данные.  Ћперации
чтениЯ  и  записи  в канал имеют ту же семантику, что и аналогичные операции
длЯ терминальных устройств (глава 10), она позволЯет процессам  игнорировать
тип тех файлов, с которыми эти программы имеют дело.
    …сли  процесс ведет запись в канал и в канале нет места длЯ всех данных,
Ядро помечает индекс и приостанавливает выполнение процесса до тех пор, пока
канал не начнет очищатьсЯ от данных. Љогда впоследствии другой процесс будет
считывать данные из канала, Ядро заметит существование  процессов,  приоста-
новленных  в ожидании очистки канала, и возобновит их выполнение подобно то-
му, как это было объЯснено выше. €сключением из этого  утверждениЯ  ЯвлЯетсЯ

                                    107

ситуациЯ,  когда  процесс записывает в канал данные, объем которых превышает
емкость канала (то есть, объем данных, которые могут хранитьсЯ в блоках прЯ-
мой адресации); в этом случае Ядро записывает в канал столько данных, сколь-
ко он может вместить в себЯ, и приостанавливает процесс до тех пор, пока  не
освободитсЯ дополнительное место. ’аким образом, возможно положение, при ко-
тором записываемые данные не будут занимать непрерывное место в канале, если
другие  процессы  ведут запись в канал в то времЯ, на которое первый процесс
прервал свою работу.
    ЂнализируЯ реализацию каналов, можно заметить, что  интерфейс  процессов
согласуетсЯ  с интерфейсом обычных файлов, но его воплощение отличаетсЯ, так
как Ядро запоминает смещениЯ длЯ чтениЯ и записи в индексе вместо того, что-
бы делать это в таблице файлов. џдро вынуждено хранить значениЯ смещений длЯ
поименованных каналов в индексе длЯ того, чтобы процессы могли совместно ис-
пользовать эти значениЯ: они не могли бы  совместно  использовать  значениЯ,
хранЯщиесЯ в таблице файлов, так как процесс получает новую запись в таблице
файлов  по каждому вызову функции open. ’ем не менее, совместное использова-
ние смещений чтениЯ и записи в индексе наблюдалось и до реализации  поимено-
ванных  каналов. Џроцессы, обращающиесЯ к непоименованным каналам, разделЯют
доступ к каналу через общие точки входа в таблицу файлов, поэтому они  могли
бы  по  умолчанию хранить смещениЯ записи и чтениЯ в таблице файлов, как это
принЯто длЯ обычных файлов. ќто не было сделано, так как  процедуры  низкого
уровнЯ,  работающие в Ядре, больше не имеют доступа к записЯм в таблице фай-
лов: программа упростилась за счет того, что процессы  совместно  используют
значениЯ смещений, хранЯщиесЯ в индексе.


.te1        5.12.4 ‡акрытие каналов

    Џри  закрытии  канала процесс выполнЯет ту же самую процедуру, что и при
закрытии обычного файла, за исключением того, что Ядро, прежде  чем  освобо-
дить индекс канала, выполнЯет специальную обработку. Ћно уменьшает количест-
во  процессов чтениЯ из канала или записи в канал в зависимости от типа фай-
лового дескриптора. …сли значение счетчика числа записывающих в  канал  про-
цессов  становитсЯ  равным 0 и имеютсЯ процессы, приостановленные в ожидании
чтениЯ данных из канала, Ядро возобновлЯет выполнение последних и они завер-
шают свои операции чтениЯ без возврата каких-либо  данных.  …сли  становитсЯ
равным  0  значение счетчика числа считывающих из канала процессов и имеютсЯ
процессы, приостановленные в ожидании возможности записи данных в канал, Яд-
ро возобновлЯет выполнение последних и посылает им сигнал (глава 7) об ошиб-
ке. ‚ обоих случаЯх не имеет смысла продолжать держать процессы  приостанов-
ленными,  если нет надежды на то, что состоЯние канала когда-нибудь изменит-
сЯ. Ќапример, если процесс ожидает возможности производить чтение из  непои-
менованного канала и в системе больше нет процессов, записывающих в этот ка-
нал,  значит,  записывающий процесс никогда не поЯвитсЯ. ЌесмотрЯ на то, что
если канал поименованный, в принципе возможно поЯвление нового  считывающего
или  записывающего  процесса, Ядро трактует эту ситуацию точно так же, как и
длЯ непоименованных каналов. …сли к каналу не обращаетсЯ ни один  записываю-
щий или считывающий процесс, Ядро освобождает все информационные блоки кана-
ла  и  переустанавливает  индекс таким образом, чтобы он указывал на то, что
канал пуст. Љогда Ядро освобождает индекс обычного канала,  оно  освобождает
длЯ переназначениЯ и дисковую копию этого индекса.


        5.12.5 Џримеры

    Џрограмма на ђисунке 5.18 иллюстрирует искусственное использование кана-
лов.  Џроцесс  создает  канал и входит в бесконечный цикл, записываЯ в канал


                                    108

               +---------------------------------+
               | char string[] = "hello";        |
               | main()                          |
               | {                               |
               |    char buf[1024];              |
               |    char *cp1,*cp2;              |
               |    int fds[2];                  |
               |                                 |
               |    cp1 = string;                |
               |    cp2 = buf;                   |
               |    while(*cp1)                  |
               |          *cp2++ = *cp1++;       |
               |    pipe(fds);                   |
               |    for (;;)                     |
               |    {                            |
               |        write(fds[1],buf,6);     |
               |        read(fds[0],buf,6);      |
               |    }                            |
               | }                               |
               +---------------------------------+

         ђисунок 5.18. —тение из канала и запись в канал


строку символов "hello" и считываЯ ее из канала. џдру не нужно  ни  знать  о
том,  что процесс, ведущий запись в канал, ЯвлЯетсЯ и процессом, считывающим
из канала, ни проЯвлЯть по этому поводу какое-либо беспокойство.
    Џроцесс, выполнЯющий программу, котораЯ приведена на ђисунке 5.19,  соз-
дает поименованный канал с именем "fifo". …сли этот процесс запущен с указа-
нием второго (формального) аргумента, он пос-

    +------------------------------------------------------------+
    | #include <fcntl.h>                                         |
    | char string[] = "hello";                                   |
    | main(argc,argv)                                            |
    |     int argc;                                              |
    |     char *argv[];                                          |
    | {                                                          |
    |     int fd;                                                |
    |     char buf[256];                                         |
    |                                                            |
    | /* создание поименованного канала с разрешением чтениЯ и   |
    |    записи длЯ всех пользователей */                        |
    |     mknod("fifo",010777,0);                                |
    |     if(argc == 2)                                          |
    |          fd = open("fifo",O_WRONLY);                       |
    |     else                                                   |
    |          fd = open("fifo",O_RDONLY);                       |
    |     for (;;)                                               |
    |          if(argc == 2)                                     |
    |               write(fd,string,6);                          |
    |          else                                              |
    |               read(fd,buf,6);                              |
    | }                                                          |
    +------------------------------------------------------------+

         ђисунок 5.19. —тение и запись в поименованный канал


                                    109

тоЯнно записывает в канал строку символов "hello"; будучи запущен без второ-
го  аргумента, он ведет чтение из поименованного канала. „ва процесса запус-
каютсЯ по одной и той же программе,  тайно  договорившись  взаимодействовать
между  собой  через поименованный канал "fifo", но им нет необходимости быть
родственными процессами. „ругие пользователи  могут  выполнЯть  программу  и
участвовать в диалоге (или мешать ему).


        5.13 DUђ

    ‘истемнаЯ функциЯ dup копирует дескриптор файла в первое свободное место
в  таблице  пользовательских  дескрипторов файла, возвращаЯ новый дескриптор
пользователю. Ћна действует длЯ всех типов файла. ‘интаксис вызова функции:

    newfd = dup(fd);

где fd - дескриптор файла, копируемый функцией, а newfd - новый  дескриптор,
ссылающийсЯ  на  файл. Џоскольку функциЯ dup дублирует дескриптор файла, она
увеличивает значение счетчика в соответствующей записи таблицы файлов -  за-

    таблица пользова-
    тельских дескрип-
       торов файла        таблица файлов        таблица индексов
       +---------+        +------------+        +--------------+
      0|     ----+----+   |            |        |       -      |
       +---------+    |   |            |        |       -      |
      1|     ----+---++-->|            |        |       -      |
       +---------+   |    +------------+        |       -      |
      2|     ----+--++--->|      -     |        |       -      |
       +---------+  +---->|      -     |        |       -      |
      3|     ----+----+   |      -     |        |       -      |
       +---------+    |   |      -     |        +--------------+
      4|     ----+---+|   |      -     |  +---->| счет-        |
       +---------+   ||   |      -     |  |     | чик  (/etc/  |
      5|     ----+--+||   +------------+  | +-->|  2    passwd)|
       +---------+  |||   | счет-      |  | |   +--------------+
      6|     ----++ ||+-->| чик        +--+ |   |       -      |
       +---------++-||--->|  2         |    |   |       -      |
      7|         |  ||    +------------+    |   |       -      |
       +---------+  ||    |      -     |    |   |       -      |
       |    -    |  ||    +------------+    |   |       -      |
       +---------+  ||    | счетчик    |    |   |       -      |
                    |+--->|      1     +----|+  |       -      |
                    |     +------------+    ||  |       -      |
                    |     |      -     |    ||  +--------------+
                    |     |      -     |    ||  | счет-        |
                    |     |      -     |    |+->| чик   (local)|
                    |     |      -     |    |   |  1           |
                    |     |      -     |    |   +--------------+
                    |     +------------+    |   |       -      |
                    |     | счетчик    |    |   |       -      |
                    +---->|      1     +----+   |       -      |
                          +------------+        |       -      |
                          |      -     |        +--------------+
                          |      -     |
                          +------------+

    ђисунок 5.20. ‘труктуры данных после выполнениЯ функции dup


                                    110


писи,  на  которую  указывают свЯзанные с ней точки входа в таблице файловых
дескрипторов, которых теперь стало на одну больше. Ќапример, обзор  структур
данных,  изображенных на ђисунке 5.20, показывает, что процесс вызывает сле-
дующую  последовательность  функций:  он  открывает  (open)  файл  с  именем
"/etc/passwd" (файловый дескриптор 3), затем открывает файл с именем "local"
(файловый  дескриптор  4), снова файл с именем "/etc/passwd" (файловый деск-
риптор 5) и, наконец, дублирует (dup) файловый дескриптор 3, возвращаЯ деск-
риптор 6.
    ‚озможно, dup - функциЯ, не отличающаЯсЯ изЯществом, поскольку она пред-
полагает, что пользователь знает о том, что система возвратит свободную точ-
ку входа в таблице пользовательских дескрипторов, имеющую наименьший  номер.
Ћднако,  она  служит важной задаче конструированиЯ сложных программ из более
простых конструкционных блоков, что, в частности, имеет место  при  создании
конвейеров, составленных из командных процессоров.
    ђассмотрим  программу,  приведенную на ђисунке 5.21. ‚ переменной i хра-
нитсЯ  дескриптор  файла,   возвращаемый   в   результате   открытиЯ   файла
"/etc/passwd",  а в переменной j - дескриптор файла, возвращаемый системой в
результате дублированиЯ дескриптора i с  помощью  функции  dup.  ‚  адресном
пространстве процесса оба пользовательских дескриптора, представленные пере-
менными  i  и j, ссылаютсЯ на одну и ту же запись в таблице файлов и поэтому
используют одно и то же значение смещениЯ внутри файла. ’аким образом,  пер-
вые  два вызова процессом функции read реализуют последовательное считывание
данных, и в буферах buf1 и buf2 будут располагатьсЯ  разные  данные.  ‘овсем
другой результат получаетсЯ, когда процесс

    +--------------------------------------------------------+
    | #include <fcntl.h>                                     |
    | main()                                                 |
    | {                                                      |
    |     int i,j;                                           |
    |     char buf1[512],buf2[512];                          |
    |                                                        |
    |     i = open("/etc/passwd",O_RDONLY);                  |
    |     j = dup(i);                                        |
    |     read(i,buf1,sizeof(buf1));                         |
    |     read(j,buf2,sizeof(buf2));                         |
    |     close(i);                                          |
    |     read(j,buf2,sizeof(buf2));                         |
    | }                                                      |
    +--------------------------------------------------------+

    ђисунок 5.21. Џрограмма на Языке ‘и, иллюстрирующаЯ использо-
                  вание функции dup


открывает  один  и  тот  же  файл дважды и читает дважды одни и те же данные
(раздел 5.2). Џроцесс может освободить с помощью функции close любой из фай-
ловых дескрипторов по своему желанию, и ввод-вывод получит  нормальное  про-
должение  по другому дескриптору, как показано на примере. ‚ частности, про-
цесс может "закрыть" дескриптор файла стандартного вывода (файловый дескрип-
тор 1), снЯть с него копию, имеющую то же значение,  и  затем  рассматривать
новый файл в качестве файла стандартного вывода. ‚ главе 7 будет представлен
более  реалистический  пример  использованиЯ функций pipe и dup при описании
особенностей реализации командного процессора.


                                    111

        5.14 ЊЋЌ’€ђЋ‚ЂЌ€… € „…ЊЋЌ’€ђЋ‚ЂЌ€… ”Ђ‰‹Ћ‚›• ‘€‘’…Њ

    ”изический диск состоит из нескольких логических разделов, на которые он
разбит дисковым драйвером, причем каждому разделу соответствует файл устрой-
ства, имеющий определенное имЯ. Џроцессы обращаютсЯ к данным раздела, откры-
ваЯ соответствующий файл устройства и затем ведЯ запись и  чтение  из  этого
"файла", представлЯЯ его себе в виде последовательности дисковых блоков. ќто
взаимодействие  во всех деталЯх рассматриваетсЯ в главе 10. ђаздел диска мо-
жет содержать логическую файловую систему, состоЯщую из блока начальной заг-
рузки, суперблока, списка индексов и информационных блоков  (см.  главу  2).
‘истемнаЯ  функциЯ mount (монтировать) свЯзывает файловую систему из указан-
ного раздела на диске с существующей иерархией файловых  систем,  а  функциЯ
umount  (демонтировать)  выключает  файловую  систему  из  иерархии. ”ункциЯ
mount, таким образом, дает пользователЯм возможность обращатьсЯ к  данным  в
дисковом  разделе как к файловой системе, а не как к последовательности дис-
ковых блоков.
    ‘интаксис вызова функции mount:
    mount(special pathname,directory pathname,options);

где special pathname - имЯ специального файла  устройства,  соответствующего
дисковому  разделу с монтируемой файловой системой, directory pathname - ка-
талог в существующей иерархии,  где  будет  монтироватьсЯ  файловаЯ  система
(другими словами, точка или место монтированиЯ), а options указывает, следу-
ет  ли  монтировать  файловую систему "только длЯ чтениЯ" (при этом не будут
выполнЯтьсЯ

 + - - - - - - - - - - - - - - - - - - - - - - - - +
                               /
 |                             |                   |
           +----------------+--+-------------+        ЉорневаЯ
 |         |                |                |     |  файловаЯ
          bin              etc              usr       система
 |         |                |                -     |
     +-----+-----+     +----+----+           -
 |   |     |     |     |         |           -     |
    cc    date   sh   getty   passwd         -
 + - - - - - - - - - - - - - - - - - - - - - - - - +
                                             -
               + - - - - - - - - - - - - - - - - - - - - - - - - +
                                             /
               |                             |                   |
   ”айловаЯ              +----------------+--+-------------+
   система из  |         |                |                |     |
   раздела с            bin            include            src
   именем      |         |                |                |     |
   /dev/dsk1       +-----+-----+          |                |
               |   |     |     |          |                |     |
                  awk  banner  yacc    stdio.h            uts
               + - - - - - - - - - - - - - - - - - - - - - - - - +

    ђисунок 5.22. „ерево файловых систем до и после выполнениЯ функции mount

такие функции, как write и creat, которые производЯт запись в файловую  сис-
тему). Ќапример, если процесс вызывает функцию mount следующим образом:

    mount("/dev/dsk1","/usr",0);

Ядро  присоединЯет файловую систему, находЯщуюсЯ в дисковом разделе с именем
"/dev/dsk1", к каталогу "/usr" в существующем дереве  файловых  систем  (см.

                                    112

ђисунок 5.22). ”айл "/dev/dsk1" ЯвлЯетсЯ блочным специальным файлом, т.е. он
носит  имЯ устройства блочного типа, обычно имЯ раздела на диске. џдро пред-
полагает, что раздел на диске с указанным именем содержит файловую систему с
суперблоком, списком индексов и корневым индексом. Џосле выполнениЯ  функции
mount  к  корню  смонтированной  файловой  системы можно обращатьсЯ по имени
"/usr". Џроцессы могут обращатьсЯ к файлам в монтированной файловой  системе
и  игнорировать  тот факт, что система может отсоединЯтьсЯ. ’олько системнаЯ
функциЯ link контролирует файловую систему, так как в версии V не разрешают-
сЯ свЯзи между файлами, принадлежащими разным файловым системам (см.  раздел
5.15).
    џдро поддерживает таблицу монтированиЯ с записЯми о каждой монтированной
файловой системе. ‚ каждой записи таблицы монтированиЯ содержатсЯ:
  * номер устройства, идентифицирующий монтированную файловую систему (упо-
    мЯнутый выше логический номер файловой системы);
  * указатель на буфер, где находитсЯ суперблок файловой системы;
  * указатель на корневой индекс монтированной  файловой  системы  ("/"  длЯ
    файловой системы с именем "/dev/dsk1" на ђисунке 5.22);
  * указатель  на индекс каталога, ставшего точкой монтированиЯ (на ђисунке
    5.22 это каталог "usr", принадлежащий корневой файловой системе).
    ‘вЯзь индекса точки монтированиЯ с корневым индексом монтированной  фай-
ловой  системы,  возникшаЯ  в результате выполнениЯ системной функции mount,
дает Ядру возможность легко двигатьсЯ по иерархии файловых систем без  полу-
чениЯ от пользователей дополнительных сведений.

    +------------------------------------------------------------+
    | алгоритм mount                                             |
    | входнаЯ информациЯ:  имЯ блочного специального файла       |
    |                      имЯ каталога точки монтированиЯ       |
    |                      опции ("только длЯ чтениЯ")           |
    | выходнаЯ информациЯ: отсутствует                           |
    | {                                                          |
    |     если (пользователь не ЯвлЯетсЯ суперпользователем)     |
    |          возвратить (ошибку);                              |
    |     получить индекс длЯ блочного специального файла (алго- |
    |      ритм namei);                                          |
    |     проверить допустимость значений параметров;            |
    |     получить индекс длЯ имени каталога, где производитсЯ   |
    |      монтирование (алгоритм namei);                        |
    |     если (индекс не ЯвлЯетсЯ индексом каталога или счетчик |
    |      ссылок имеет значение > 1)                            |
    |     {                                                      |
    |          освободить индексы (алгоритм iput);               |
    |          возвратить (ошибку);                              |
    |     }                                                      |
    |     найти свободное место в таблице монтированиЯ;          |
    |     запустить процедуру открытиЯ блочного устройства длЯ   |
    |      данного драйвера;                                     |
    |     получить свободный буфер из буферного кеша;            |
    |     считать суперблок в свободный буфер;                   |
    |     проинициализировать полЯ суперблока;                   |
    |     получить корневой индекс монтируемой системы (алгоритм |
    |      iget), сохранить его в таблице монтированиЯ;          |
    |     сделать пометку в индексе каталога о том, что каталог  |
    |      ЯвлЯетсЯ точкой монтированиЯ;                         |
    |     освободить индекс специального файла (алгоритм iput);  |
    |     снЯть блокировку с индекса каталога точки монтированиЯ;|
    | }                                                          |
    +------------------------------------------------------------+
        ђисунок 5.23. Ђлгоритм монтированиЯ файловой системы

                                    113


    Ќа  ђисунке  5.23  показан  алгоритм монтированиЯ файловой системы. џдро
позволЯет монтировать и демонтировать файловые системы только тем процессам,
владельцем которых ЯвлЯетсЯ  суперпользователь.  Џредоставление  возможности
выполнЯть  функции mount и umount всем пользователЯм привело бы к внесению с
их стороны хаоса в работу файловой системы, как умышленному, так и Явившему-
сЯ результатом неосторожности.  ‘уперпользователи  могут  разрушить  систему
только случайно.
    џдро  находит индекс специального файла, представлЯющего файловую систе-
му, подлежащую монтированию, извлекает старший  и  младший  номера,  которые
идентифицируют  соответствующий дисковый раздел, и выбирает индекс каталога,
в котором файловаЯ система будет смонтирована. ‘четчик ссылок в индексе  ка-
талога должен иметь значение, не превышающее 1 (и меньше 1 он не должен быть
-  почему?),  в свЯзи с наличием потенциально опасных побочных эффектов (см.
упражнение 5.27). ‡атем Ядро назначает свободное место в таблице  монтирова-
ниЯ,  помечает его длЯ использованиЯ и присваивает значение полю номера уст-
ройства в таблице. ‚ышеуказанные назначениЯ  производЯтсЯ  немедленно,  пос-
кольку  вызывающий  процесс может приостановитьсЯ, следуЯ процедуре открытиЯ
устройства или считываЯ суперблок файловой системы,  а  другой  процесс  тем
временем попыталсЯ бы смонтировать файловую систему. Џометив длЯ использова-
ниЯ  запись  в  таблице монтированиЯ, Ядро не допускает использованиЯ в двух
вызовах функции mount одной и той же записи таблицы. ‡апоминаЯ номер устрой-
ства с монтируемой системой, Ядро может воспрепЯтствовать повторному  монти-
рованию одной и той же системы другими процессами, которое, будь оно допуще-
но, могло бы привести к непредсказуемым последствиЯм (см. упражнение 5.26).
    џдро  вызывает  процедуру  открытиЯ длЯ блочного устройства, содержащего
файловую систему, точно так же, как оно делает это при непосредственном отк-
рытии блочного устройства (глава 10). Џроцедура открытиЯ  устройства  обычно
проверЯет  существование  такого  устройства, иногда производЯ инициализацию
структур данных драйвера и посылаЯ команды инициализации  аппаратуре.  ‡атем
Ядро  выделЯет  из буферного пула свободный буфер (вариант алгоритма getblk)
длЯ хранениЯ суперблока монтируемой файловой системы и считывает  суперблок,
используЯ  один из вариантов алгоритма read. џдро сохранЯет указатель на ин-
декс каталога, в котором монтируетсЯ система,  даваЯ  возможность  маршрутам
поиска  файловых  имен,  содержащих имЯ "..", пересекать точку монтированиЯ,
как мы увидим дальше. Ћно находит корневой индекс монтируемой файловой  сис-
темы и запоминает указатель на индекс в таблице монтированиЯ. ‘ точки зрениЯ
пользователЯ, место (точка) монтированиЯ и корень файловой системы логически
эквивалентны, и Ядро упрочивает эту эквивалентность благодарЯ их сосущество-
ванию  в  одной  записи таблицы монтированиЯ. Џроцессы больше не могут обра-
щатьсЯ к индексу каталога - точки монтированиЯ.
    џдро инициализирует полЯ в суперблоке файловой системы, очищаЯ полЯ  длЯ
списка  свободных  блоков  и  списка свободных индексов и устанавливаЯ число
свободных индексов в суперблоке равным 0. –елью инициализации  (заданиЯ  на-
чальных  значений  полей)  ЯвлЯетсЯ  сведение к минимуму опасности разрушить
файловую систему, если монтирование осуществлЯетсЯ после аварийного заверше-
ниЯ работы системы. …сли Ядро заставить думать, что в суперблоке отсутствуют
свободные индексы, то это приведет к запуску алгоритма ialloc, ведущего  по-
иск на диске свободных индексов. Љ сожалению, если список свободных дисковых
блоков  испорчен,  Ядро не исправлЯет этот список изнутри (см. раздел 5.17 о
сопровождении файловой системы). …сли пользователь монтирует файловую систе-
му только длЯ чтениЯ, запрещаЯ проведение всех операций  записи  в  системе,
Ядро устанавливает в суперблоке соответствующий флаг. Ќаконец, Ядро помечает
индекс каталога как "точку монтированиЯ", чтобы другие процессы позднее мог-
ли ссылатьсЯ на нее. Ќа ђисунке 5.24 представлен вид различных структур дан-
ных по завершении выполнениЯ функции mount.


                                    114

        5.14.1 Џересечение точек монтированиЯ в  маршрутах поиска имен файлов

    „авайте повторно рассмотрим поведение алгоритмов namei и iget в случаЯх,
когда  маршрут поиска файлов проходит через точку монтированиЯ. ’очку монти-
рованиЯ можно пересечь двумЯ способами: из файловой системы, где производит-
сЯ монтирование, в файловую систему, котораЯ монтируетсЯ (в  направлении  от
глобального  корнЯ к листу), и в обратном направлении. ќти способы иллюстри-
рует следующаЯ последовательность команд shell'а.

    ’аблица индексов           ’аблица монтированиЯ
  +------------------+        +--------------------+
  +------------------+        |                    |
  | €ндекс каталога, + - - +  |                    |
  | где производитсЯ |        |                    |
  |   монтирование   |     |  |                    |   +-------+
  | Џомечен как "точ-|<---+   |                    |+->| Ѓуфер |
  | ка монтированиЯ" |    ||  |                    ||  +-------+
  | ‘четчик ссылок =1|    |   |                    ||
  +------------------+    |+ >+--------------------+|
  |                  |    |   |      ‘уперблок  ---++
  +------------------+    +---+ €ндекс точки монти-|
  | €ндекс устройства|        |       рованиЯ      |
  |  Ќе используетсЯ |    +---+-  Љорневой индекс  |
  | ‘четчик ссылок =0|    |   +--------------------+
  +------------------+    |   |                    |
  +------------------+<---+   |                    |
  | €ндекс корнЯ мон-|        |                    |
  | тируемой файловой|        |                    |
  |      системы     |        |                    |
  | ‘четчик ссылок =1|        +--------------------+
  +------------------+
  +------------------+

       ђисунок 5.24. ‘труктуры данных после монтированиЯ


    mount /dev/dsk1 /usr
    cd /usr/src/uts
    cd ../../..
    Џо команде mount после выполнениЯ некоторых логических проверок запуска-
етсЯ системнаЯ функциЯ mount, котораЯ монтирует файловую систему в  дисковом
разделе  с именем "/dev/dsk1" под управлением каталога "/usr". ЏерваЯ из ко-
манд cd (сменить каталог) побуждает командный процессор shell  вызвать  сис-
темную  функцию  chdir,  выполнЯЯ которую, Ядро анализирует имЯ пути поиска,
пересекающего точку монтированиЯ в "/usr". ‚тораЯ из команд  cd  приводит  к
тому, что Ядро анализирует имЯ пути поиска и пересекает точку монтированиЯ в
третьей компоненте ".." имени.
    „лЯ случаЯ пересечениЯ точки монтированиЯ в направлении из файловой сис-
темы,  где производитсЯ монтирование, в файловую систему, котораЯ монтирует-
сЯ, рассмотрим модификацию алгоритма iget (ђисунок 5.25), котораЯ  идентична
версии  алгоритма, приведенной на ђисунке 4.3, почти во всем, за исключением
того, что в данной модификации производитсЯ проверка, ЯвлЯетсЯ ли индекс ин-
дексом точки монтированиЯ. …сли индекс имеет соответствующую  пометку,  Ядро
соглашаетсЯ,  что  это индекс точки монтированиЯ. Ћно обнаруживает в таблице
монтированиЯ запись с указанным индексом точки монтированиЯ и запоминает но-
мер устройства монтируемой файловой системы. ‡атем, используЯ номер устройс-
тва и номер индекса корнЯ, общего длЯ всех файловых систем, Ядро  обращаетсЯ
к индексу корнЯ


                                    115

    +------------------------------------------------------------+
    | алгоритм iget                                              |
    | входнаЯ информациЯ:  номер индекса в файловой системе      |
    | выходнаЯ информациЯ: заблокированный индекс                |
    | {                                                          |
    |   выполнить                                                |
    |   {                                                        |
    |     если (индекс в индексном кеше)                         |
    |     {                                                      |
    |       если (индекс заблокирован)                           |
    |       {                                                    |
    |         приостановитьсЯ (до освобождениЯ индекса);         |
    |         продолжить;    /* цикл с условием продолжениЯ */   |
    |       }                                                    |
    |       /* специальнаЯ обработка длЯ точек монтированиЯ */   |
    |       если (индекс ЯвлЯетсЯ индексом точки монтированиЯ)   |
    |       {                                                    |
    |         найти запись в таблице монтированиЯ длЯ точки мон- |
    |          тированиЯ;                                        |
    |         получить новый номер файловой системы из таблицы   |
    |          монтированиЯ;                                     |
    |         использовать номер индекса корнЯ длЯ просмотра;    |
    |         продолжить;      /* продолжение цикла */           |
    |       }                                                    |
    |       если (индекс в списке свободных индексов)            |
    |         убрать из списка свободных индексов;               |
    |       увеличить счетчик ссылок длЯ индекса;                |
    |       возвратить (индекс);                                 |
    |     }                                                      |
    |                                                            |
    |     /* индекс отсутствует в индексном кеше */              |
    |     убрать новый индекс из списка свободных индексов;      |
    |     сбросить номер индекса и файловой системы;             |
    |     убрать индекс из старой хеш-очереди, поместить в новую;|
    |     считать индекс с диска (алгоритм bread);               |
    |     инициализировать индекс (например, установив счетчик   |
    |      ссылок в 1);                                          |
    |     возвратить (индекс);                                   |
    |   }                                                        |
    | }                                                          |
    +------------------------------------------------------------+

    ђисунок 5.25.  ЊодификациЯ алгоритма получениЯ доступа к  ин-
                   дексу


монтируемого  устройства  и  возвращает при выходе из функции этот индекс. ‚
первом примере смены каталога Ядро обращаетсЯ к индексу каталога  "/usr"  из
файловой  системы,  в  которой  производитсЯ монтирование, обнаруживает, что
этот индекс имеет пометку "точка монтированиЯ", находит в таблице монтирова-
ниЯ индекс корнЯ монтируемой файловой системы и обращаетсЯ к этому индексу.
    „лЯ второго случаЯ пересечениЯ точки монтированиЯ в направлении из  фай-
ловой системы, котораЯ монтируетсЯ, в файловую систему, где выполнЯетсЯ мон-
тирование, рассмотрим модификацию алгоритма namei (ђисунок 5.26). Ћна похожа
на  версию алгоритма, приведенную на ђисунке 4.11. Ћднако, после обнаружениЯ
в каталоге номера индекса длЯ данной компоненты пути поиска Ядро  проверЯет,
не указывает ли номер индекса на то, что это корневой индекс файловой систе-
мы.  …сли  это так и если текущий рабочий индекс так же ЯвлЯетсЯ корневым, а


                                    116

    +------------------------------------------------------------+
    | алгоритм namei /* превращение имени пути поиска в индекс */|
    | входнаЯ информациЯ:  имЯ пути поиска                       |
    | выходнаЯ информациЯ: заблокированный индекс                |
    | {                                                          |
    |    если (путь поиска берет начало с корнЯ)                 |
    |         рабочий индекс = индексу корнЯ (алгоритм iget);    |
    |    в противном случае                                      |
    |         рабочий индекс = индексу текущего каталога         |
    |          (алгоритм iget);                                  |
    |                                                            |
    |    выполнить (пока путь поиска не кончилсЯ)                |
    |    {                                                       |
    |         считать следующую компоненту имени пути поиска;    |
    |         проверить соответствие рабочего индекса каталогу   |
    |          и права доступа;                                  |
    |         если (рабочий индекс соответствует корню и компо-  |
    |          нента имени "..")                                 |
    |              продолжить;  /* цикл с условием продолжениЯ */|
    |  поиск компоненты:                                         |
    |         считать каталог (рабочий индекс), повторЯЯ алго-   |
    |          ритмы bmap, bread и brelse;                       |
    |         если (компонента соответствует записи в каталоге   |
    |          (рабочем индексе))                                |
    |         {                                                  |
    |              получить номер индекса длЯ совпавшей компонен-|
    |               ты;                                          |
    |              если (найденный индекс ЯвлЯетсЯ индексом кор- |
    |               нЯ и рабочий индекс ЯвлЯетсЯ индексом корнЯ  |
    |               и имЯ компоненты "..")                       |
    |              {                                             |
    |                /* пересечение точки монтированиЯ */        |
    |                получить запись в таблице монтированиЯ длЯ  |
    |                 рабочего индекса;                          |
    |                освободить рабочий индекс (алгоритм iput);  |
    |                рабочий индекс = индексу точки монтированиЯ;|
    |                заблокировать индекс точки монтированиЯ;    |
    |                увеличить значение счетчика ссылок на рабо- |
    |                 чий индекс;                                |
    |                перейти к поиску компоненты (длЯ "..");     |
    |              }                                             |
    |              освободить рабочий индекс (алгоритм iput);    |
    |              рабочий индекс = индексу с новым номером      |
    |               (алгоритм iget);                             |
    |         }                                                  |
    |         в противном случае  /* компонента отсутствует в    |
    |                                каталоге */                 |
    |              возвратить (нет индекса);                     |
    |    }                                                       |
    |    возвратить (рабочий индекс);                            |
    | }                                                          |
    +------------------------------------------------------------+

    ђисунок 5.26.  ЊодификациЯ  алгоритма синтаксического анализа
                   имени файла


компонента пути поиска, в свою очередь, имеет имЯ "..", Ядро  идентифицирует
индекс  как  точку  монтированиЯ. Ћно находит в таблице монтированиЯ запись,

                                    117

номер устройства в которой совпадает с номером устройства длЯ последнего  из
найденных  индексов,  получает  индекс  длЯ каталога, в котором производитсЯ
монтирование, и продолжает поиск компоненты с именем "..", используЯ  только
что  полученный индекс в качестве рабочего. ‚ корне файловой системы, тем не
менее, корневым каталогом ЯвлЯетсЯ "..".
    ‚ вышеприведенном примере (cd "../../..") предполагаетсЯ, что  в  начале
процесс имеет текущий каталог с именем "/usr/src/uts". Љогда имЯ пути поиска
подвергаетсЯ  анализу в алгоритме namei, начальным рабочим индексом ЯвлЯетсЯ
индекс текущего каталога. џдро менЯет текущий рабочий индекс на индекс ката-
лога с именем "/usr/src" в результате расшифровки первой компоненты  ".."  в
имени пути поиска. ‡атем Ядро анализирует вторую компоненту ".." в имени пу-
ти поиска, находит корневой индекс смонтированной (перед этим) файловой сис-
темы  -  индекс  каталога  "usr" - и делает его рабочим индексом при анализе
имени с помощью алгоритма namei. Ќаконец, оно расшифровывает  третью  компо-
ненту  ".."  в  имени  пути поиска. џдро обнаруживает, что номер индекса длЯ
".." совпадает с номером корневого индекса, рабочим индексом ЯвлЯетсЯ корне-
вой индекс, а ".." ЯвлЯетсЯ текущей компонентой имени пути поиска. џдро  на-
ходит  запись  в  таблице  монтированиЯ,  соответствующую точке монтированиЯ
"usr", освобождает текущий рабочий индекс (корень файловой системы,  смонти-
рованной  в  каталоге "usr") и назначает индекс точки монтированиЯ (каталога
"usr" в корневой файловой системе) в качестве нового рабочего индекса. ‡атем
оно просматривает записи в каталоге точки монтированиЯ "/usr" в поисках име-
ни ".." и находит номер индекса длЯ корнЯ файловой системы ("/"). Џосле это-
го системнаЯ функциЯ chdir завершаетсЯ как обычно, вызывающий процесс не об-
ращает вниманиЯ на тот факт, что он пересек точку монтированиЯ.


        5.14.2 „емонтирование файловой системы

    ‘интаксис вызова системной функции umount:
    umount(special filename);

где special filename указывает демонтируемую файловую систему. Џри  демонти-
ровании файловой системы (ђисунок 5.27) Ядро обращаетсЯ к индексу демонтиру-
емого  устройства,  восстанавливает номер устройства длЯ специального файла,
освобождает индекс (алгоритм iput) и находит в таблице монтированиЯ запись с
номером устройства, равным номеру устройства длЯ специального файла.  Џрежде
чем  Ядро  действительно  демонтирует файловую систему, оно должно удостове-
ритьсЯ в том, что в системе не осталось используемых файлов, длЯ этого  Ядро
просматривает  таблицу  индексов в поисках всех файлов, чей номер устройства
совпадает с номером демонтируемой системы. Ђктивным файлам соответствует по-
ложительное значение счетчика ссылок и в их  число  входЯт  текущий  каталог
процесса,  файлы с разделЯемым текстом, которые исполнЯютсЯ в текущий момент
(глава 7), и открытые когда-то файлы, которые потом не  были  закрыты.  …сли
какие-нибудь  файлы  из файловой системы активны, функциЯ umount завершаетсЯ
неудачно: если бы она прошла успешно, активные файлы сделались бы