В этой главе будут рассматриваться файлы и каталоги ОС Linux и способы работы с ними. Вы научитесь создавать файлы, открывать и читать их, писать в них и удалять их. Вы также узнаете, как программы могут обрабатывать каталоги (например, создавать, просматривать и удалять их). После сделанного в предыдущей главе отступления, посвященного командным оболочкам, теперь вы начнете программировать на языке С.

Прежде чем перейти к способам обработки файлового ввода/вывода в системе Linux, мы дадим краткий обзор понятий, связанных с файлами, каталогами и устройствами. Для управления файлами и каталогами вам придется выполнять системные вызовы (аналог Windows API в системах UNIX и Linux), но, кроме того, для обеспечения более эффективного управления файлами существует большой набор библиотечных функций стандартной библиотеки ввода/вывода (stdio).

Большую часть главы мы посвятим работе с различными вызовами, необходимыми для обработки файлов и каталогов. Таким образом, в данной главе будут обсуждаться разные темы, связанные с файлами:

□ файлы и устройства;

□ системные вызовы;

□ библиотечные функции;

□ низкоуровневый доступ к файлу;

□ управление файлами;

□ стандартная библиотека ввода/вывода;

□ форматированный ввод и вывод;

□ сопровождение файлов и каталогов;

□ просмотр каталогов;

□ ошибки;

□ файловая система /proc;

□ более сложные приемы —

fcntl

mmap

Вы можете спросить: "Зачем вы останавливаетесь на структуре файла? Я уже знаком с ней." Дело в том, что в среде Linux, как и UNIX, файлы особенно важны, поскольку они обеспечивают простую и согласованную взаимосвязь со службами операционной системы и устройствами. В ОС Linux файл — это все что угодно. Ну, или почти все!

Это означает, что в основном программы могут обрабатывать дисковые файлы, последовательные порты, принтеры и другие устройства точно так же, как они используют файлы. Мы расскажем о некоторых исключениях, таких как сетевые подключения, в главе 15, но в основном вы должны будете применять пять базовых функций:

open

close

read

write

ioctl

Каталоги — тоже специальный тип файлов. В современных версиях UNIX, включая Linux, даже суперпользователь не пишет непосредственно в них. Обычно все пользователи для чтения каталогов применяют интерфейс

opendir/readdir

Действительно, в ОС Linux почти все представлено в виде файлов или может быть доступно с помощью специальных файлов. И основная идея сохраняется даже, несмотря на то, что существуют в силу необходимости небольшие отличия от известных и любимых вами традиционных файлов. Давайте рассмотрим особые случаи, о которых мы уже упоминали.

Помимо содержимого у файла есть имя и набор свойств, или "административная информация", т.е. дата создания/модификации файла и права доступа к нему. Свойства хранятся в файловом индексе (inode), специальном блоке данных файловой системы, который также содержит сведения о длине файла и месте хранения файла на диске. Система использует номер файлового индекса; для нашего удобства структуру каталога также называют файлом.

Каталог — это файл, содержащий номера индексов и имена других файлов. Каждый элемент каталога — ссылка на файловый индекс; удаляя имя файла, вы удаляете ссылку. (Номер индекса файла можно увидеть с помощью команды

ln -i

ln

Когда вы удаляете файл, удаляется элемент каталога для этого файла, и количество ссылок на файл уменьшается на единицу. Данные файла могут быть все еще доступны благодаря другим ссылкам на этот же файл. Когда число ссылок на файл (число, идущее после прав доступа в команде

ls -l

Файлы помещаются в каталоги, которые могут содержать подкаталоги. Так формируется хорошо знакомая иерархия файловой системы. Пользователь, скажем neil, обычно хранит файлы в исходном (home) каталоге, возможно /home/neil, с подкаталогами для хранения электронной почты, деловых писем, служебных программ и т.д. Имейте в виду, что у многих командных оболочек систем UNIX и Linux есть отличное обозначение для указания начала пути в вашем исходном каталоге: символ "тильда" (~). Для другого пользователя наберите

~user

Примечание

К сожалению, функции стандартной библиотеки при указании имени файла как параметра не понимают сокращенного обозначения с помощью тильды, поэтому в ваших программах следует всегда явно задавать полное имя файла.

Каталог /home в свою очередь является подкаталогом корневого каталога /, расположенного на верхнем уровне иерархии и содержащего все системные файлы и подкаталоги. В корневой каталог обычно включен каталог /bin для хранения системных программ (бинарных файлов), каталог /etc, предназначенный для хранения системных файлов конфигурации, и каталог /lib для хранения системных библиотек. Файлы, представляющие физические устройства и предоставляющие интерфейс для этих устройств, принято помещать в каталог /dev. На рис. 3.1 показана в качестве примера часть типичной файловой системы Linux. Мы рассмотрим структуру файловой системы Linux более подробно в главе 18, когда будем обсуждать стандарт файловой системы Linux (Linux File System Standard).

Рис. 3.1 

Даже физические устройства очень часто представляют (отображают) с помощью файлов. Например, будучи суперпользователем, вы можете смонтировать дисковод IDE CD-ROM как файл:

# mount -t iso9660 /dev/hdc /mnt/cdrom

# cd /mnt/cdrom

который выбирает устройство CD-ROM (в данном случае вторичное ведущее (secondary master) устройство IDE, которое загружается как /dev/hdc во время начального запуска системы; у устройств других типов будут другие элементы каталога /dev) и монтирует его текущее содержимое как файловую структуру в каталоге /mnt/cdrom. Затем вы перемещаетесь по каталогам компакт-диска как обычно, конечно за исключением того, что их содержимое доступно только для чтения.

В системах UNIX и Linux есть три важных файла устройств: /dev/console, /dev/tty и /dev/null.

Это устройство представляет системную консоль. На него часто отправляются сообщения об ошибках и диагностическая информация. У всех систем UNIX есть выделенный терминал или экран для получения сообщений консоли. Иногда он может быть выделенным печатающим терминалом. На современных рабочих станциях и в ОС Linux обычно это активная виртуальная консоль, а под управлением графической среды X Window это устройство станет специальным окном консоли на экране.

Специальный файл /dev/tty — это псевдоним (логическое устройство) управляющего терминала (клавиатуры и экрана или окна) процесса, если таковой есть. (Например, у процессов и сценариев, автоматически запускаемых системой, не будет управляющего терминала, следовательно, они не смогут открыть файл /dev/tty.)

Там где этот файл, /dev/tty может применяться, он позволяет программе писать непосредственно пользователю независимо от того, какой псевдотерминал или аппаратный терминал он использует. Это полезно при перенаправлении стандартного вывода. Примером может служить отображение содержимого длинного каталога в виде группы страниц с помощью команды

ls -R | more

Учтите, что существует только одно устройство /dev/console, и в то же время может существовать много разных физических устройств, к которым можно обратиться с помощью файла dev/tty.

Файл /dev/null — это фиктивное устройство. Весь вывод, записанный на это устройство, отбрасывается. Когда устройство читается, немедленно возвращается конец файла, поэтому данное устройство можно применять с помощью команды cp как источник пустых файлов. Нежелательный вывод очень часто перенаправляется на dev/null.

$ echo do not want to see this >/dev/null

$ cp /dev/null empty_file

Примечание

Другой способ создания пустых файлов — применение команды

touch <имя файла>

, изменяющей время модификации файла или создающей новый файл при отсутствии файла с заданным именем. Хотя она и не очищает содержимое обрабатываемого файла.

В каталоге /dev можно найти и другие устройства, такие как дисководы жестких дисков и флоппи-дисководы, коммуникационные порты, ленточные накопители, дисководы CD-ROM, звуковые карты и некоторые устройства, представляющие внутреннюю структуру системы. Есть даже устройство /dev/zero, действующее как источник нулевых байтов для создания файлов, заполненных нулями. Для доступа к некоторым из этих устройств вам понадобятся права супер пользователя; обычные пользователи не могут писать программы, непосредственно обращающиеся к низкоуровневым устройствам, таким как накопители жестких дисков. Имена файлов устройств могут быть в разных системах различными. В дистрибутивах ОС Linux обычно есть приложения, выполняемые от имени суперпользователя и управляющие устройствами, которые иначе будут недоступны, например, mount для монтируемых пользователями файловых систем.

Устройства делятся на символьные и блочные. Отличие заключается в том, что к некоторым устройствам следует обращаться поблочно. Обычно только блочные устройства, такие как жесткие диски, поддерживают определенный тип файловой системы.

В этой главе мы сосредоточимся на дисковых файлах и каталогах. Другому устройству, пользовательскому терминалу, будет посвящена глава 5.

Вы можете обращаться к файлам и устройствам и управлять ими, применяя небольшой набор функций. Эти функции, известные как системные вызовы, непосредственно представляются системой UNIX (и Linux) и служат интерфейсом самой операционной системы.

В сердце операционной системы, ее ядре, есть ряд драйверов устройств. Они представляют собой коллекцию низкоуровневых интерфейсов для управления оборудованием системы. Например, в ней есть драйвер устройства для ленточного накопителя, который знает, как запустить ленту, перемотать ее вперед и назад, прочитать ее и записать на нее и т.д. Ему известно, что на ленту следует писать данные блоками определенного размера. Поскольку ленты — по природе своей устройства с последовательным доступом, драйвер не может обращаться непосредственно к блокам ленты, сначала он должен перемотать ленту до нужного места. Точно так же низкоуровневый драйвер накопителя жесткого диска будет записывать на диск в каждый момент времени только целое число дисковых секторов, но сможет прямо обратиться к любому нужному блоку диска, поскольку диск — это устройство с произвольным доступом.

Для формирования одинакового интерфейса драйверы устройств включают в себя все аппаратно-зависимые свойства. Уникальные аппаратные средства обычно доступны через системный вызов

ioctl

Файлы устройств из каталога /dev используются одинаково: они могут открываться, читаться, на них можно записывать и их можно закрывать. Например, один и тот вызов

open

К низкоуровневым функциям или системным вызовам, используемым для обращения к драйверам устройств, относятся следующие:

□

open

□

read

□ 

write

□

close

□

ioctl

Системный вызов

ioctl

ioctl

ioctl

ioctl

Этот системный вызов, как и другие, обычно описывается в разделе 2 интерактивного справочного руководства. Прототипы функций со списком параметров и типом возвращаемого функцией значения, используемые в системных вызовах, а также связанные с ними директивы

#define

include

Проблема использования низкоуровневых системных вызовов непосредственно для ввода и вывода заключается в том, что они могут быть очень неэффективны. Почему? Ответ может быть следующим.

□ При выполнении системных вызовов существуют эксплуатационные издержки. Поэтому системные вызовы требуют больше затрат по сравнению с библиотечными функциями, т.к. ОС Linux вынуждена переключаться с выполнения вашего программного кода на собственный код ядра и затем возвращаться к выполнению вашей программы. Было бы неплохо стараться свести к минимуму применение системных вызовов в программе и заставлять каждый такой вызов выполнять максимально возможный объем работы, например, считывать и записывать за один раз большие объемы данных, а не одиночные символы.

□ У оборудования есть ограничения, накладываемые на размер блока данных, которые могут быть считаны или записаны в любой конкретный момент времени. У ленточных накопителей, например, часто есть размер блока для записи, скажем 10 Кбайт, поэтому, если вы попытаетесь записать количество информации, не кратное 10 Кбайт, накопитель переместит ленту к следующему блоку в 10 Кбайт, оставив на ленте пустоты.

Для формирования высокоуровневого интерфейса для устройств и дисковых файлов дистрибутив Linux (и UNIX) предоставляет ряд стандартных библиотек. Они представляют собой коллекции функций, которые вы можете включать в свои программы для решения подобных проблем. Хорошим примером может послужить стандартная библиотека ввода/вывода, обеспечивающая буферизованный вывод. Вы сможете эффективно записывать блоки данных разных размеров, применяя библиотечные функции, которые будут выполнять низкоуровневые системные вызовы, снабжая их полными блоками, как только данные станут доступны. Это существенно снижает издержки системных вызовов.

Библиотечные функции, как правило, описываются в разделе 3 интерактивного справочного руководства и часто снабжаются стандартным файлом директивы

include

Для обобщения материала последних нескольких разделов на рис. 3.2 приведена схема системы Linux, на которой показано, где расположены различные функции работы с файлами относительно пользователя, драйверов устройств, ядра системы и оборудования.

Рис. 3.2

У каждой выполняющейся программы, называемой процессом, есть ряд связанных с ней дескрипторов файлов. Существуют короткие целые (small integer) числа, которые можно использовать для обращения к открытым файлам и устройствам. Количество дескрипторов зависит от конфигурации системы. Когда программа запускается, у нее обычно уже открыты три подобных дескриптора. К ним относятся следующие:

□ 0 — стандартный ввод;

□ 1 — стандартный вывод;

□ 2 — стандартный поток ошибок.

Вы можете связать с файлами и устройствами другие дескрипторы файлов, используя системный вызов open, который уже обсуждался вкратце. Дескрипторы файлов, открытые автоматически, уже позволяют вам создавать простые программы с помощью вызова

write

Системный вызов

write

buf

nbytes

fildes

nbytes

write

errno

Далее приведена синтаксическая запись.

#include <unistd.h>

size_t write(int fildes, const void *buf, size_t nbytes);

Благодаря полученным знаниям вы можете написать свою первую программу, simple_write.c:

#include <unistd.h>

#include <stdlib.h>

int main() {

 if ((write(1, "Here is some data\n", 18)) != 18)

  write(2, "A write error has occurred on file descriptor 1\n", 46);

 exit(0);

}

Эта программа просто помещает сообщение в стандартный вывод. Когда она завершается, все открытые дескрипторы файлов автоматически закрываются, и вам не нужно закрывать их явно. Но в случае буферизованного вывода это не так.

$ ./simple_write

Here is some data

$

И еще одно маленькое замечание: вызов

write

errno

write

Системный вызов

read

nbytes

fildes

buf

read

#include <unistd.h>

size_t read(int fildes, void *buf, size_t nbytes);

Программа simple_read.c копирует первые 128 байтов стандартного ввода в стандартный вывод. Она копирует все вводимые данные, если их меньше 128 байтов.

#include <unistd.h>

#include <stdlib.h>

int main() {

 char buffer[128];

 int nread;

 nread = read(0, buffer, 128);

 if (nread == -1)

  write(2, "A read error has occurred\n", 26);

 if ((write(1, buffer, nread)) != nread)

  write(2, "A write error has occurred\n", 27);

 exit(0);

}

Если вы выполните программу, то получите следующий результат:

$ echo hello there | ./simple_read

hello there

$ ./simple_read < draft1.txt

Files

In this chapter we will be looking at files and directories and how to

manipulate them. We will learn how to create files, $

Первое выполнение программы с помощью команды

echo

Примечание

Обратите внимание на то, что знак подсказки или приглашения командной оболочки появляется в конце последней строки вывода, поскольку в этом примере 128 байтов не формируют целое число строк.

Для создания дескриптора нового файла вы должны применить системный вызов

open

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

int open(const char *path, int oflags);

int open(const char *path, int oflags, mode_t mode);

Примечание

Строго говоря, для использования вызова

open

вы не должны включать файлы sys/types.h и sys/stat.h в системах, удовлетворяющих стандартам POSIX, но они могут понадобиться в некоторых системах UNIX.

Не вдаваясь в подробности, скажем, что вызов

open

read

write

Имя открываемого файла или устройства передается как параметр

path

oflags

Параметр

oflags

open

Таблица 3.1

Вызов может также включать в параметр

oflags

OR

□

O_APPEND

□

O_TRUNC

□

O_CREAT

mode

□

O_EXCL

O_CREAT

open

open

Другие возможные значения параметра

oflags

man 2 open

Вызов

open

errno

errno

Существует также системный вызов

creat

open

oflags

O_CREAT|О_WRONLY|O_TRUNC

Количество файлов, одновременно открытых в любой выполняющейся программе, ограничено. Предельное значение обычно определяется константой

OPEN_MAX

OPEN_MAX

Когда вы создаете файл, применяя флаг

O_CREAT

mode

OR

□

S_IRUSR

□

S_IWUSR

□

S_IXUSR

□

S_IRGRP

□

S_IWGRP

□

S_IXGRP

□

S_IROTH

□

S_IWOTH

□

S_IXOTH

Например, вызов

open("myfile", O_CREAT, S_IRUSR|S_IXOTH);

в результате приведет к созданию файла с именем myfile с правом на чтение для владельца и правом на выполнение для остальных и только с этими правами доступа.

$ ls -ls myfile

0 -r-------х 1 neil software 0 Sep 22 08:11 myfile*

Есть пара факторов, способных повлиять на права доступа к файлу. Во-первых, заданные права применяются, только если файл создается. Во-вторых, на права доступа к созданному файлу оказывает воздействие маска пользователя (заданная командой командной оболочки,

umask

mode

open

AND

mode

S_IXOTH

open

creat

umask

umask

umask

OR

Таблица 3.2

Например, для блокирования права "группы" на запись и выполнение и права "остальных" на запись переменная umask должна была бы быть следующей (табл. 3.3).

Таблица 3.3

Значения каждой цифры объединяются операциями

OR

2 | 1

3

umask

Когда вы создаете файл с помощью системного вызова open или creat, параметр mode сравнивается с текущим значением переменной

umask

mode

umask

chmod

chmod

Системный вызов

close

fildes

#include <unistd.h>

int close (int fildes);

Примечание

В некоторых случаях проверка возвращаемого значения вызова

close

бывает очень важна. Некоторые файловые системы, особенно с сетевой структурой, могут не сообщать об ошибке записи в файл до тех пор, пока файл не будет закрыт, потому что при выполнении записи могло отсутствовать подтверждение действительной записи данных.

Системный вызов

ioctl

ioctl

ioctl

#include <unistd.h>

int ioctl(int fildes, int cmd, ...)

Вызов

ioctl

cmd

fildes

Например, следующий вызов

ioctl

ioctl(tty_fd, KDSETLED, LED_NUM|LED_CAP|LED_SCR);

Выполните упражнения 3.1 и 3.2.

Теперь вы знаете достаточно о системных вызовах

open

read

write

В данной главе мы проделаем это несколькими способами для того, чтобы сравнить эффективность разных методов. Для краткости предположим, что входной файл существует, а выходной — нет, и что все операции чтения и записи завершаются успешно. Конечно, в реальных программах вам придется убедиться в том, что эти предположения верны!

1. Сначала вам нужно создать тестовый входной файл размером, скажем, 1 Мбайт и именем file.in.

2. Далее откомпилируйте программу copy_system.c.

#include <unistd.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

int main() {

 char c;

 int in, out;

 in = open("file.in", O_RDONLY);

 put = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);

 while(read(in, &c, 1) == 1) write(out, &c, 1);

 exit(0);

}

Примечание

Имейте в виду, что строка

#include <unistd.h>

должна быть первой, поскольку она определяет флаги, касающиеся соответствия стандарту POSIX и способные повлиять на другие включенные в

#include

файлы.

3. Выполнение программы даст результат, похожий на следующий:

$ TIMEPORMAT="" time ./copy_system

4.67user 146.90system 2:32.57elapsed 99%CPU

...

$ ls -ls file.in file.out

1029 -rw-r--r-- 1 neil users 1048576 Sep 17 10:46 file.in

1029 -rw------- 1 neil users 1048576 Sep 17 10:51 file.out

Как это работает

Вы используете команду

time

TIMEFORMAT

В последние годы ОС Linux продемонстрировала огромные успехи в повышении производительности системных вызовов и файловой системы. Для сравнения аналогичный тест с применением ядра 2.6 занял чуть менее 14 секунд:

$ TIMEFORMAT="" time ./copy_system

2.08user 10.59system 0:13.74elapsed 92%CPU

...

Вы можете добиться лучших результатов, копируя блоки большего размера. Взгляните на модифицированную программу copy_block.c, которая копирует файл блоками в 1 Кбайт и снова использует системные вызовы.

#include <unistd.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

int main() {

 char block[1024];

 int in, out;

 int nread;

 in = open("file.in", O_RDONLY);

 out = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);

 while((nread = read(in, block, sizeof(block))) > 0)

  write(out, block, nread);

 exit(0);

}

Теперь испытайте программу, но сначала удалите старый выходной файл.

$ rm file.out

$ TIMEFORMAT="" time ./copy_block

0.00user 0.02system 0:00.04elapsed 78%CPU

...

Как это работает

Теперь программа выполняется только сотые доли секунды, поскольку ей требуется около 2000 системных вызовов. Конечно, это время очень зависит от системы, но оно показывает, что системные вызовы сопряжены с поддающимися измерению издержками, поэтому их применение стоит оптимизировать.

Существует ряд других системных вызовов, оперирующих низкоуровневыми дескрипторами файлов. Они позволяют программе контролировать использование файла, возвращая информацию о его состоянии,

Системный вызов

lseek

#include <unistd.h>

#include <sys/types.h>

off_t lseek(int fildes, off_t offset, int whence);

Параметр

offset

whence

offset

□

SEEK_SET

offset

□

SEEK_CUR

offset

□

SEEK_END

offset

Вызов

lseek

offset

off_t

offset

integer

Системный вызов

fstat

buf

Далее приведена синтаксическая запись вызовов.

#include <unistd.h>

#include <sys/stat.h>

#include <sys/types.h>

int fstat(int fildes, struct stat *buf);

int stat(const char *path, struct stat *buf);

int lstat(const char *path, struct stat *buf);

Примечание

Учтите, что включение файла sys/types.h не обязательное, но мы рекомендуем включать его при использовании системных вызовов, поскольку некоторые из их определений применяют для стандартных типов псевдонимы, которые могут измениться когда-нибудь.

Родственные функции

stat

и

lstat

возвращают информацию о состоянии названного файла. Они возвращают те же результаты за исключением того, что файл является символической ссылкой. Вызов

lstat

возвращает данные о самой ссылке, а вызов

stat

— о файле, на который ссылка указывает.

Элементы вызываемой структуры stat могут меняться в разных UNIX-подобных системах, но обязательно включают перечисленные в табл. 3.4 элементы.

Таблица 3.4

У флагов

st_mode

stat

Флаги прав доступа такие же, как в системном вызове

open

□

S_IFBLK

□

S_IFDIR

□

S_IFCHR

□

S_IFIFO

□

S_IFREG

□

S_IFLNK

Для других флагов режима файла включены следующие имена:

□

S_ISUID

□

S_ISGUID

Для масок, интерпретирующих флаги

st_mode

□

S_IFMT

□

S_IRWXU

□

S_IRWXG

□

S_IRWXO

Существует ряд макросов, помогающих определить типы файлов. Они просто сравнивают надлежащим образом установленные флаги режима файла с подходящим флагом, типа устройства. К ним относятся следующие:

□

S_ISBLK

□

S_ISCHR

□

S_ISDIR

□

S_ISFIFO

□

S_ISREG

□

S_ISLNK

Например, для проверки того, что файл не является каталогом и у него есть права на выполнение только для владельца и больше никаких других прав, вы можете воспользоваться следующим тестом;

struct stat statbuf;

mode_t modes;

stat("filename", &statbuf);

modes = statbuf.st_mode;

if (!S_ISDIR(modes) && (modes & S_IRWXU) = S_IXUSR)

...

Системные вызовы

dup

dup

fildes

dup2

Далее приведена синтаксическая запись для вызовов.

#include <unistd.h>

int dup(int fildes);

int dup2(int fildes, int fildes2);

Эти вызовы могут оказаться полезными в случае нескольких процессов, взаимодействующих через именованные каналы. Более глубоко мы рассмотрим системные вызовы

dup

Стандартная библиотека ввода/вывода (stdio) и ее заголовочный файл stdio.h предоставляют универсальный интерфейс для системных вызовов ввода/вывода нижнего уровня. Библиотека, теперь часть языка С стандарта ANSI, в отличие от системных вызовов, с которыми вы встречались ранее, включает много сложных функций для форматирования вывода и просмотра ввода. Она также обеспечивает необходимые условия буферизации для устройств.

Во многих случаях эта библиотека используется так же, как низкоуровневые дескрипторы файлов. Вы должны открыть файл для установления пути доступа. Это действие возвращает значение, применяемое как параметр в других функциях библиотеки ввода/вывода. Эквивалент низкоуровневого дескриптора файла называется потоком и реализуется как указатель на структуру

FILE*

Примечание

Не путайте эти потоки файлов с потоками ввода/вывода в языке С++ и механизмом STREAMS, описывающим взаимодействие процессов и введенным в системе AT&T UNIX System V Release 3, который не рассматривается в данной книге. Для получения дополнительной информации о средствах STREAMS обратитесь к спецификации X/Open (по адресу http://www.opengroup.org) и руководству по программированию AT&T STREAMS Programming Guide, поставляемому с системой System V.

Три файловых потока открываются автоматически при старте программы. К ним относятся stdin, stdout и stderr. Эти потоки объявлены в файле stdio.h и представляют вывод, ввод и стандартный поток ошибок, которым соответствуют низкоуровневые файловые дескрипторы 0, 1 и 2.

В данном разделе мы рассмотрим следующие функции:

□

fopen

fclose

□

fread

fwrite

□

fflush

□

fseek

□

fgetc

getc

□

fputc

putc

putchar

□

fgets

gets

□

printf

fprintf

sprintf

□

scanf

fscanf

sscanf

□

fopen

Библиотечная функция f

o

open

Далее приведена синтаксическая запись функции:

#include <stdio.h>

FILE *fopen(const char *filename, const char *mode);

Функция

fopen

filename

mode

□ "

r

rb

□ "

w

wb

□ "

а

ab

□ "

r+

rb+

r+b

□ "

w+

wb+

w+b

□ "

a+

ab+

а+b

b

Примечание

В отличие от MS-DOS, системы UNIX и Linux не делают различий между текстовыми и бинарными файлами. UNIX и Linux обрабатывают их одинаково с эффективностью обработки бинарных файлов. Важно также учесть, что параметр

mode

должен быть строкой, а не символом. Всегда применяйте двойные кавычки, а не апострофы.

В случае успешного завершения функция

fopen

FILE*

NULL

Количество доступных потоков ограничено, как и число дескрипторов файлов. Реальное предельное значение содержится в определенной в файле stdio.h константе

FOPEN_MAX

Библиотечная функция

fread

stream

ptr

fread

fwrite

size

nitems

nitems

Далее приведена синтаксическая запись функции:

#include <stdio.h>

size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);

Как и в других функциях стандартного ввода/вывода, записывающих данные в буфер, выделять место для данных и проверять ошибки должен программист. См. также функции

ferror

feof

Интерфейс библиотечной функции

fwrite

fread

Далее приведена синтаксическая запись функции:

#include <stdio.h>

size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);

Примечание

Имейте в виду, что функции

fread

и

fwrite

не рекомендуется применять со структурированными данными. Частично проблема заключается в том, что файлы, записанные функцией fwrite, могут быть непереносимыми между машинами с разной архитектурой.

Библиотечная функция

fclose

fclose

fclose

fclose

fclose

Далее приведена синтаксическая запись функции:

#include <stdio.h>

int fclose(FILE* stream);

Библиотечная функция

fflush

fclose

fflush

fclose

fflush

Далее приведена синтаксическая запись функции:

#include <stdio.h>

int fflush(FILE *stream);

Функция

fseek

lseek

stream

offset

whence

lseek

lseek

off_t

fseek

errno

Далее приведена синтаксическая запись функции:

#include <stdio.h>

int fseek(FILE *stream, long int offset, int whence);

Функция

fgetc

EOF

ferror

feof

Далее приведена синтаксическая запись функций:

#include <stdio.h>

int fgetc(FILE *stream);

int getc(FILE *stream);

int getchar();

Функция

getc

fgetc

stream

getc

Функция

getchar

getc(stdin)

Функция

fputc

EOF

#include <stdio.h>

int fputc(int с, FILE *stream); int putc(int c, FILE *stream); int putchar(int c);

Как и в случае функций

fgetc/getc

putc

fputc

Функция

putchar

putc(с, stdout)

putchar

getchar

int

char

EOF

Функция

fgets

stream

#include <stdio.h>

char *fgets(char *s, int n, FILE *stream);

char *gets(char *s);

Функция

fgets

s

n-1

\0

n-1

При успешном завершении функция

fgets

s

EOF

fgets

errno

Функция

gets

fgets

Примечание

Учтите, что функция

gets

не ограничивает количество символов, которые могут передаваться, поэтому она может переполнить свой пересылочный буфер. По этой причине вам следует избегать применения этой функции и заменять ее функцией

fgets

. Многие проблемы безопасности порождены функциями в программах, сделанных для переполнения буфера тем или иным способом. Это одна из таких функций, поэтому будьте осторожны!

Для создания вывода управляемого вида существует ряд библиотечных функций, с которыми вы, возможно, знакомы, если программируете на языке С. К ним относятся функция

printf

scanf

Семейство функций

printf

format

#include <stdio.h>

int printf(const char *format, ...);

int sprintf(char *s, const char *format, ...);

int fprintf(FILE * stream, const char *format, ...);

Функция

printf

fprintf

stream

sprintf

s

У семейства

printf

Обычные символы передаются в вывод без изменений. Спецификаторы преобразований заставляют функцию

printf

%

printf("Some numbers: %d, %d, and &d\n", 1, 2, 3);

Он порождает в стандартном выводе следующую строку.

Some numbers: 1, 2, and 3

Для вывода символа

%

%%

Далее перечислены наиболее часто применяемые спецификаторы преобразований:

□

%d

%i

□

%о

%x

□

%с

□

%s

□

%f

□

%e

□

%g

Очень важно, чтобы число и тип аргументов, передаваемых функции

printf

format

Он может быть равен

h

%hd

short int

l

%ld

long int

printf

-Wformat

Далее приведен еще один пример:

char initial = 'А';

char *surname = "Matthew";

double age = 13.5;

printf("Hello Mr %c %s, aged %g\n", initial, surname, age);

Будет выводиться следующая информация:

Hello Mr A Matthew, aged 13.5

Вы можете добиться большего при выводе элементов с помощью спецификаторов полей. Они расширяют возможности спецификаторов преобразований, управляя расположением элементов при выводе. Обычно задается количество десятичных разрядов для числа с плавающей точкой или величина пробельных отступов, обрамляющих строку.

Спецификаторы полей задаются в виде чисел, следующих в спецификаторах преобразований непосредственно за знаком

%

Таблица 3.5

Все приведенные примеры выводятся в поле шириной 10 символов. Обратите внимание на то, что отрицательная ширина поля означает выравнивание элемента по левому краю в пределах поля. Переменная ширина поля обозначается символом "звездочка" (

*

printf

Таблица 3.6

Функции семейства

printf

sprintf

errno

Семейство функций

scanf

printf

printf

#include <stdio.h>

int scanf(const char *format, ...);

int fscanf(FILE *stream, const char *format, ...);

int sscanf(const char *s, const char *format, ...);

Очень важно, чтобы переменные, используемые для хранения значений, считываемых функциями

scanf

Строка

format

scanf

printf

Рассмотрим простой пример:

int num;

scanf("Hello %d", &num);

Вызов функции

scanf

Hello

num

scanf

num

Hello    1234

Hellol234

Пробельные символы обычно игнорируются во вводе, когда начинается преобразование. Это означает, что строка формата

%d

Примечание

Если не соблюдать осторожность, могут возникнуть проблемы. В вашей программе может появиться бесконечный цикл, если во вводе оставить нецифровой символ при считывании целых чисел.

К другим спецификаторам преобразований относятся следующие:

□

%d

□

%o

%x

□

%f

%e

%g

□

%c

□

%s

□

%[]

□

%%

%

Как и в случае

printf

scanf

h

l

%hd

short int

%ld

long int

%lg

Спецификатор, начинающийся со звездочки, указывает на то, что элемент игнорируется. Это значит, что информация не сохраняется, и, следовательно, для ее получения не нужна переменная.

Применяйте спецификатор

%c

Используйте спецификатор

%s

Лучше применять спецификатор ширины поля или комбинацию функций

fgets

sscanf

Применяйте спецификатор

%[]

%[A-Z]

^

%[^, ]

Если задана следующая строка ввода:

Hello, 1234, 5.678, X, string to the end of the line

приведенный далее вызов

scanf

char s[256];

int n;

float f;

char c;

scanf("Hello, %d, %g, %c, %[^\n]", &n, &f, &c, s);

Функции семейства

scanf

EOF

errno

Функция

scanf

□ традиционно их реализации полны ошибок;

□ в использовании эти функции не гибки;

□ они могут привести к созданию программного кода, в котором трудно решить, что подвергать синтаксическому анализу.

В качестве альтернативы попытайтесь применять другие функции, такие как

fread

fgets

В библиотеке stdio существует ряд других функций, использующих потоки как параметры или стандартные потоки

stdin

stdout

stderr

□

fgetpos

□

fsetpos

□

ftell

□

rewind

□

freopen

□

setvbuf

□

remove

unlink

path

rmdir

Эти библиотечные функции описаны на страницах интерактивного справочного руководства в разделе 3.

Вы можете использовать функции обработки файловых потоков для повторной реализации с их помощью программы копирования файлов. Взгляните на программу copy_stdio.c в упражнении 3.3.

Эта программа очень похожа на предыдущие версии, но посимвольное копирование выполняется с помощью вызовов функций, заданных в файле stdio.h:

#include <stdio.h>

#include <stdlib.h>

int main() {

 int c; 

 FILE *in, *out;

 in = fopen("file.in", "r");

 out = fopen("file.out", "w");

 while((c = fgetc(in)) != EOF) fputc(c, out);

 exit(0);

}

Выполнив эту программу, как прежде, вы получите:

$ TIMEFORMAT="" time ./copy_stdio

0.06user 0.02system 0:00.11elapsed 81%CPU

Как это работает

На этот раз программа выполняется 0,11 с, не так быстро, как низкоуровневая блочная версия, но значительно быстрее другой посимвольной версии. Это произошло потому, что библиотека stdio поддерживает внутренний буфер в структуре

FILE

Для обозначения ошибок многие функции библиотеки stdio применяют значения за пределами допустимых, например, пустые указатели или константу

EOF

errno

#include <errno.h>

extern int errno;

Примечание

Имейте в виду, что многие функции могут изменять значение

errno

. Оно достоверно, только когда функция закончилась неудачно. Вам следует проверять это значение сразу же, как функция сообщила о сбое. Прежде чем использовать его, скопируйте это значение в другую переменную, поскольку функции вывода, такие как

fprintf

, могут сами изменять

errno

.

Вы можете также запросить состояние файлового потока, чтобы выяснить, возникла ли ошибка или достигнут конец файла.

#include <stdio.h>

int ferror(FILE *stream);

int feof(FILE *stream);

void clearerr(FILE *stream);

Функция

ferror

Функция

feof

if (feof(some_stream))

 /* Мы в конце */

Функция

clearerr

stream

Каждый файловый поток ассоциирован с низкоуровневым дескриптором файла. Вы можете смешивать операции низкоуровневого ввода/вывода с высокоуровневыми потоковыми операциями, но это, как правило, неразумно, потому что трудно предсказать эффект от применения буферизации.

#include <stdio.h>

int fileno(FILE *stream);

FILE *fdopen(int fildes, const char *mode);

Вы можете определить, какой низкоуровневый дескриптор файла применяется для файлового потока, вызвав функцию

fileno

fstat

Можно создать новый поток файла на основе дескриптора файла, открытого только для чтения, применив функцию

fdopen

Функция

fdopen

fopen

fopen

fdopen

NULL

Стандартные библиотеки и системные вызовы обеспечивают полный контроль над созданием и ведением файлов и каталогов.

С помощью системного вызова

chmod

chmod

Далее приведена синтаксическая запись вызова:

#include <sys/stat.h>

int chmod(const char *path, mode_t mode);

Права доступа к файлу, заданному параметром

path

mode

mode

OR

Суперпользователь может изменить владельца файла с помощью системного вызова chown.

#include <sys/types.h> #include <unistd.h>

int chown(const char *path, uid_t owner, gid_t group);

В вызове применяются числовые значения идентификаторов (ID) нового пользователя и группы (взятые из системных вызовов

getuid

getgid

Примечание

Стандарт POSIX в действительности допускает существование систем, в которых несуперпользователи могут изменять права владения файлом. Все "правильные" с точки зрения POSIX системы не допускают этого, но строго говоря, это расширение стандарта (в FIPS 151-2). Все виды систем, с которыми мы имеем дело в этой книге, подчиняются спецификации XSI (X/Open System Interface) и соблюдают на деле правила владения.

С помощью вызова

unlink

Системный вызов

unlink

#include <unistd.h>

int unlink(const char *path);

int link(const char *path1, const char *path2);

int symlink(const char *path1, const char *path2);

Если счетчик становится равен нулю и файл не открыт ни в одном процессе, он удаляется. В действительности элемент каталога всегда удаляется немедленно, а место, занятое содержимым файла, не очищается до тех пор, пока последний процесс (если таковой существует) не закроет файл. Этот вызов использует программа

rm

ln

link

Примечание

Создание файла с помощью вызова

open

и последующее обращение к

unlink

для этого файла — трюк, применяемый некоторыми программистами для создания временных или транзитных файлов. Эти файлы доступны программе, только пока они открыты; и будут удалены автоматически, когда программа завершится, и файлы будут закрыты.

Системный вызов

link

path1

path2

symlink

Вы можете создавать и удалять каталоги, применяя системные вызовы

mkdir

rmdir

#include <sys/types.h>#include <sys/stat.h>

int mkdir(const char *path, mode_t mode);

Системный вызов

mkdir

mkdir

mkdir

path

O_CREAT

umask

#include <unistd.h>

int rmdir(const char *path);

Системный вызов

rmdir

rmdir

Программа может перемещаться по каталогам во многом так же, как пользователь перемещается по файловой системе. Как вы применяете в командной оболочке команду

cd

chdir

#include <unistd.h>

int chdir(const char *path);

Программа может определить свой текущий рабочий каталог, вызвав функцию

getcwd

#include <unistd.h>

char *getcwd(char *buf, size_t size);

Функция

getcwd

buf

NULL

ERANGE

size

buf

Функция

getcwd

NULL

EINVAL

EACCESS

Широко распространенная проблема систем Linux — просмотр каталогов, т.е. определение файлов, размещенных в конкретном каталоге. В программах командной оболочки она решается легко — просто скомандуйте оболочке выполнить подстановку в выражении с метасимволами. В прошлом в разных вариантах UNIX был разрешен программный доступ к низкоуровневой структуре файловой системы. Вы все еще можете открывать каталог как обычный файл и непосредственно считывать элементы каталога, но разные структуры файловых систем и реализации сделали такой подход непереносимым с машины на машину. Был разработан стандартный комплект библиотечных функций, существенно упрощающий просмотр каталогов.

Функции работы с каталогами объявлены в заголовочном файле dirent.h. В них используется структура

DIR

DIR*

FILE*

DIR

Мы рассмотрим следующие функции:

□

opendir

closedir

□

readdir

□

telldir

□

seekdir

□

closedir

Функция

opendir

DIR

#include <sys/types.h>

#include <dirent.h>

DIR *opendir(const char *name);

В случае неудачи функция opendir возвращает пустой указатель. Имейте в виду, что для доступа к самому каталогу поток каталога использует низкоуровневый дескриптор файла, поэтому opendir может дать сбой, если открыто слишком много файлов.

Функция

readdir

dirp

readdir

readdir

NULL

NULL

errno

#include <sys/types.h>

#include <dirent.h>

struct dirent *readdir(DIR *dirp);

Просмотр каталога с помощью функции

readdir

В состав структуры

dirent

□

ino_t d_ino

□

char d_name[]

Для выяснения других реквизитов файла в каталоге вам необходимо вызвать

stat

Функция

telldir

seekdir

#include <sys/types.h>

#include <dirent.h>

long int telldir(DIR *dirp);

Функция

seekdir

dirp

loc

telldir

#include <sys/types.h>

#include <dirent.h>

void seekdir (DIR *dirp, long int loc);

Функция

closedir

#include <sys/types.h>

#include <dirent.h>

int closedir(DIR *dirp);

В приведенной далее программе printdir.c (упражнение 3.4) вы соберете вместе множество функций обработки файлов для создания простого перечня содержимого каталога. Каждый файл представлен отдельной строкой. У каждого подкаталога есть имя, за которым следует слэш, и файлы, содержащиеся в подкаталоге, выводятся с отступом шириной в четыре пробела.

Программа превращает каталог в подкаталоги, чтобы у найденных файлов были пригодные для использования имена, т.е. они могут передаваться непосредственно в функцию opendir. Программа будет давать сбои при просмотре структур с большим числом уровней вложенности, поскольку есть ограничение на разрешенное число открытых потоков каталогов.

Мы могли бы сделать программу более универсальной, принимая в качестве аргумента командной строки начальную точку просмотра.

Для того чтобы познакомиться с методами повышения универсальности программ, посмотрите исходный код таких утилит Linux, как

ls

find

1. Начните с соответствующих заголовочных файлов и функции

printdir

depth

#include <unistd.h>

#include <stdio.h>

#include <dirent.h>

#include <string.h>

#include <sys/stat.h>

#include <stdlib.h>

void printdir(char *dir, int depth) {

 DIR *dp;

 struct dirent *entry;

 struct stat statbuf;

 if ((dp = opendir(dir)) == NULL) {

  fprintf(stderr, "cannot open directory: %s\n", dir);

  return;

 }

 chdir(dir);

 while((entry = readdir(dp)) != NULL) {

  lstat(entry->d_name, &statbuf);

  if (S_ISDIR(statbuf.st_mode)) {

   /* Находит каталог, но игнорирует . и .. */

   if (strcmp(".", entry->d_name) == 0 || strcmp("..", entry->d_name) == 0)

    continue;

   printf("%*s%s/\n", depth, "", entry->d_name);

   /* Рекурсивный вызов с новый отступом */

   printdir(entry->d_name, depth+4);

  } else printf("%*s%s\n", depth, " ", entry->d_name);

 }

 chdir("..");

 closedir(dp);

}

2. Теперь переходите к функции

main

int main() {

 /* Обзор каталога /home */

 printf("Directory scan of /home:\n");

 printdir("/home", 0);

 printf("done.\n");

 exit(0);

}

Программа просматривает исходные каталоги и формирует вывод, похожий на приведенный далее (отредактированный для краткости). Для того чтобы заглянуть в каталоги других пользователей, вам могут понадобиться права доступа суперпользователя.

$ ./printdir

Directory scan of /home:

neil/

    .Xdefaults

    .Xmodmap

    .Xresources

    .bash_history

    .bashrc

    .kde/

        share/

            apps/

                konqueror/

                    dirtree/

                        public_html.desktop

                    toolbar/

                        bookmarks.xml

                        konq_history

                    kdisplay/

                        color-schemes/

    BLP4e/

        Gnu_Public_License

        chapter04/

            argopt.с

            args.с

        chapter03/

            file.out

            mmap.с

            printdir

done.

Как это работает

Большинство операций сосредоточено в функции

printdir

opendir

printdir

chdir

readdir

depth

Если элемент — каталог, вы встречаетесь с рекурсией. После игнорирования элементов

.

..

printdir

while

chdir("..")

closedir(dp)

Для того чтобы составить представление об окружении в системе Linux, обсуждаемом в главе 4, познакомьтесь с одним из способов, повышающих универсальность программы. Рассматриваемая программа ограничена, потому что привязана каталогу /home. Следующие изменения в функции

main

int main(int argc, char* argv[]) {

 char *topdir = ".";

 if (argc >= 2) topdir = argv[1];

 printf("Directory scan of %s\n", topdir);

 printdir(topdir, 0);

 printf("done.\n");

 exit(0);

}

Три строки изменены и пять добавлено, но это уже универсальная утилита с необязательным параметром, содержащим имя каталога, по умолчанию равным текущему каталогу. Вы можете выполнять ее с помощью следующей командной строки:

$ ./printdir2 /usr/local | more

Вывод будет разбит на страницы, и пользователь сможет листать их. Таким образом, у него появится маленький удобный универсальный обозреватель дерева каталогов. Приложив минимум усилий, вы могли бы добавить статистический показатель использования пробелов, предельную глубину отображения и т.д.

Как вы видели, многие системные вызовы и функции, описанные в этой главе, могут завершиться аварийно по ряду причин. Когда это происходит, они указывают причину сбоя, задавая значение внешней переменной

errno

Имена констант и варианты ошибок перечислены в заголовочном файле errno.h. К ним относятся следующие:

□

EPERM

□

ENOENT

□

EINTR

□

EIO

□

EBUSY

□

EEXIST

□

EINVAL

□

EMFILE

□

ENODEV

□

EISDIR

□

ENOTDIR

Есть пара полезных функций, сообщающих об ошибках при их возникновении:

strerror

perror

Функция

strerror

Далее приведена ее синтаксическая запись:

#include <string.h>

char *strerror(int errnum);

Функция

perror

errno

s

NULL

Далее приведена синтаксическая запись функции:

#include <stdio.h>

void perror(const char *s);

Например, вызов

perror("program");

может дать следующий результат в стандартном потоке ошибок:

program: Too many open files

Ранее в этой главе мы уже писали о том, что ОС Linux обрабатывает многие вещи как файлы, и в файловой системе есть ряд элементов для аппаратных устройств. Эти файлы /dev применяются для доступа к оборудованию особыми методами с помощью низкоуровневых системных вызовов.

Программные драйверы, управляющие оборудованием, часто могут настраиваться определенными способами или сообщать информацию. Например, контроллер жесткого диска может настраиваться на применение определенного режима DMA. Сетевая карта может обладать функциональными возможностями для оповещения об установке высокоскоростного дуплексного соединения.

В прошлом для связи с драйверами устройств применялись утилиты общего назначения. Например, hdparm использовалась для настройки некоторых параметров диска, a ifconfig могла сообщить сетевую статистику. В недавнем прошлом появилась тенденция, направленная на обеспечение более подходящего способа доступа к информации драйвера и, как расширение, включающая взаимодействие с различными элементами ядра Linux.

ОС Linux предоставляет специальную файловую систему procfs, которая обычно доступна в виде каталога /proc. Она содержит много специальных файлов, обеспечивающих высокоуровневый доступ к информации драйвера и ядра. Приложения, выполняющиеся с корректными правами доступа, могут читать эти файлы для получения информации и записывать в них устанавливаемые параметры.

Набор файлов в каталоге /proc меняется от системы к системе, и с каждым новым выпуском Linux появляются новые файлы, дополнительные драйверы и средства поддержки файловой системы procfs. В этом разделе мы рассмотрим некоторые из самых широко распространенных файлов и кратко обсудим их применение.

В перечень каталога /proc на компьютере, использовавшемся для написания этой главы, включены следующие элементы:

1/     10514/ 20254/ 6/    9057/ 9623/     ide/       mtrr

10359/ 10524/ 29/    698/  9089/ 9638/     interrupts net/

10360/ 10530/ 983/   699/  9118/ acpi/     iomem      partitions

10381/ 10539/ 3/     710/  9119/ asound/   ioports    scsi/

10438/ 10541/ 30/    711/  9120/ buddyinfo irq/       self@

10441/ 10555/ 3069/  742/  9138/ bus/      kallsyms   slabinfo

10442/ 10688/ 3098/  7808/ 9151/ cmdline   kcore      splash

10478/ 10689/ 3099/  7813/ 92/   config.gz keys       stat

10479/ 10784/ 31/    8357/ 9288/ cpuinfo   key-users  swaps

10482/ 113/   3170/  8371/ 93/   crypto    kmsg       sys/

10484/ 115/   3171/  840/  9355/ devices   loadavg    sysrq-trigger

10486/ 116/   3177/  8505/ 9407/ diskstats locks      sysvipc/

10495/ 1167/  32288/ 8543/ 9457/ dma       mdstat     tty/

10497/ 1168/  3241/  8547/ 9479/ driver/   meminfo    uptime

Во многих случаях файлы могут только читаться и дают информацию о состоянии. Например, /proc/cpuinfo предоставляет сведения о доступных процессорах:

$ cat /proc/cpuinfo

processor    : 0

vendor_id     : GenuineIntel

cpu family    : 15

model         : 2

model name    : Intel(R) Pentium(R) 4 CPU 2.66GHz

stepping      : 8

cpu MHz       : 2665.923

cache size    : 512 KB

fdiv_bug      : no

hlt_bug       : no

f00f_bug      : no

coma_bug      : no

fpu           : yes

fpu_exception : yes

cpuid level   : 2

wp            : yes

flags         : fpu vme de pse tsc msr рае mce cx8 apic sep mtrr pge mca cmov

pat pse36 clflush dts acpi mmx fxsr sse sse2 ss up

bogomips      : 5413.47

clflush size  : 64

Файлы /proc/meminfo и /рroc/version предоставляют данные об использовании оперативной памяти и версии ядра соответственно:

$ cat /proc/meminfo

MemTotal:     776156 kB

MemFree:       28528 kB

Buffers:      191764 kB

Cached:       369520 kB

SwapCached:       20 kB

Active:       406912 kB

Inactive:     274320 kB

HighTotal:         0 kB

HighFree:          0 kB

LowTotal:     776156 kB

LowFree:       28528 kB

SwapTotal:   1164672 kB

SwapFree:    1164652 kB

Dirty:            68 kB

Writeback:         0 kB

AnonPages:     95348 kB

Mapped:        49044 kB

Slab:          57848 kB

SReclaimable:  48008 kB

SUnreclaim:     9840 kB

PageTables:     1500 kB

NFS_Unstable:      0 kB

Bounce:            0 kB

CommitLimit: 1552748 kB

Committed_AS: 189680 kB

VmallocTotal: 245752 kB

VmallocUsed:   10572 kB

VmallocChunk: 234556 kB

HugePages_Total:   0

HugePages_Free:    0

HugePages_Rsvd:    0

Hugepagesize:   4096 kB

$ cat /proc/version

Linux version 2.6.20.2-2-default (geeko@buildhost) (gcc version 4.1.3 20070218 (prerelease) (SUSE Linux)) #1 SMP Fri Mar 9 21:54:10 UTC 2007

Информация, выводимая этими файлами, генерируется при каждом чтении файла. Поэтому повторное чтение файла meminfo в более поздний момент времени даст результаты с точностью до секунд.

Получить дополнительную информацию от специальных функций ядра можно в подкаталогах каталога /proc. Например, статистику использования сетевых сокетов вы можете узнать из /proc/net/sockstat:

$ cat /proc/net/sockstat

sockets: used 285

TCP: inuse 4 orphan 0 tw 0 alloc 7 mem 1

UDP: inuse 3

UDPLITE: inuse 0

RAW: inuse 0

FRAG: inuse 0 memory 0

В некоторые элементы каталога /proc можно производить запись, а не только читать их. Например, общее количество файлов, которые могут быть открыты одновременно всеми выполняющимися программами, — это параметр ядра Linux. Текущее значение можно прочитать из /proc/sys/fs/file-max:

$ cat /proc/sys/fs/file-max

76593

В данном случае задана величина

76593

Примечание

Для записи в файлы /proc требуются права доступа суперпользователя. При записи в эти файлы нужно быть предельно внимательным; при записи неподходящих данных возможно возникновение серьезных проблем, включая крах системы и потерю данных.

Для увеличения предельного значения одновременно обрабатываемых в системе файлов до 80000 вы можете просто записать новое предельное значение в файл file-max.

# echo 80000 >/proc/sys/fs/file-max

Теперь, повторно прочитав файл, вы увидите новое значение:

$ cat /proc/sys/fs/file-max

80000

Подкаталоги каталога /proc с числовыми именами применяются для обеспечения доступа к информации о выполняющихся программах. В главе 11 вы узнаете больше о том, что программы выполняются как процессы.

Сейчас только отметьте, что у каждого процесса есть уникальный идентификатор: число в диапазоне от 1 до почти 32 000. Команда ps предоставляет список выполняющихся в данный момент процессов. Например, когда писалась эта глава:

neil@susel03:~/BLP4e/chapter03> ps -а

  PID TTY       TIME CMD

 9118 pts/1 00:00:00 ftp

 9230 pts/1 00:00:00 ps

10689 pts/1 00:00:01

bash neil@susel03:~/BLP4e/chapter03>

Вы видите несколько сеансов терминалов, запустивших командную оболочку bash и сеанс передачи файла, выполняющий программу

ftp

ftp

В данном случае для ftp задан идентификатор процесса

9118

$ ls -l /proc/9118

total 0

0 dr-xr-xr-x 2 neil users 0 2007-05-20 07:43 attr

0 -r-------- 1 neil users 0 2007-05-20 07:43 auxv

0 -r--r--r-- 1 neil users 0 2007-05-20 07:35 cmdline

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 cpuset

0 lrvxrwxrwx 1 neil users 0 2007-05-20 07:43 cwd -> /home/neil/BLP4e/chapter03

0 -r-------- 1 neil users 0 2007-05-20 07:43 environ

0 lrwxrwxrwx 1 neil users 0 2007-05-20 07:43 exe -> /usr/bin/pftp

0 dr-x------ 2 neil users 0 2007-05-20 07:19 fd

0 -rw-r--r-- 1 neil users 0 2007-05-20 07:43 loginuid

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 maps

0 -rw------- 1 neil users 0 2007-05-20 07:43 mem

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 mounts

0 -r-------- 1 neil users 0 2007-05-20 07:43 mountstats

0 -rw-r--r-- 1 neil users 0 2007-05-20 07:43 oom_adj

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 oom_score

0 lrwxrwxrwx 1 neil users 0 2007-05-20 07:43 root -> /

0 -rw------- 1 neil users 0 2007-05-20 07:43 seccomp

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 smaps

0 -r--r--r-- 1 neil users 0 2007-05-20 07:33 stat

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 statm

0 -r--r--r-- 1 neil users 0 2007-05-20 07:33 status

0 dr-xr-xr-x 3 neil users 0 2007-05-20 07:43 task

0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 wchan

В данном перечне вы видите разные специальные файлы, способные сообщить вам, что происходит с процессом.

Можно сказать, что выполняется программа /usr/bin/pftp, и ее текущий рабочий каталог — home/neil/BLP4e/chapter03. Есть возможность прочитать другие файлы из этого каталога, чтобы увидеть командную строку, применяемую для запуска программы, а также ее окружение. Файлы cmdline и environ предоставляют эту информацию в виде последовательности нуль-терминированных строк, поэтому вам следует соблюдать осторожность при их просмотре. Более подробно окружение ОС Linux мы обсудим в главе 4.

$ od -с /proc/9118/cmdline

0000000 f  t  p \0  1  9  2  .  1  6  8  .  0  .  1  2

0000020 \0

0000021

Из полученного вывода видно, что

ftp

ftp 192.163.0.12

Подкаталог fd предоставляет информацию об открытых дескрипторах файлов, используемых процессом. Эти данные могут быть полезны при определении количества файлов, одновременно открытых программой. На каждый открытый дескриптор приходится один элемент; имя его соответствует номеру дескриптора. В нашем случае, как мы и ожидали, у программы

ftp

$ ls /proc/9118/fd

0 1 2 3

Теперь мы коснемся приемов, которые вы можете пропустить, поскольку они редко используются. Признавая это, мы помещаем их в книгу просто для вашего сведения, потому что применение описываемых средств может предоставить простые решения для замысловатых проблем.

Системный вызов

fcntl

#include <fcntl.h>

int fcntl(int fildes, int cmd);

int fcntl(int fildes, int cmd, long arg);

С помощью системного вызова

fcntl

Различные операции выбираются разными значениями параметра команды

cmd

arg

□

fcntl(fildes, F_DUPFD, newfd)

newfd

fildes

newfd

dup(fildes)

□

fcntl(fildes, F_GETFD)

FD_CLOEXEC

□

fcntl(fildes, F_SETFD, flags)

FD_CLOEXEC

□

fcntl(fildes, F_GETFL)

fcntl(fildes, F_SETFL, flags)

O_ACCMODE

O_CREAT

Вызов

fcntl

Система UNIX предоставляет полезное средство, позволяющее программам совместно использовать память, и, к счастью, оно включено в версию 2.0 и более поздние версии ядра Linux. Функция

mmap

Вы можете применить то же самое средство для работы с файлами, заставив все содержимое файла на диске выглядеть как массив в памяти. Если файл состоит из записей, которые могут быть описаны структурами на языке С, вы сможете обновлять файл с помощью методов доступа к массиву структур.

Это становится возможным благодаря применению сегментов виртуальной памяти с набором особых прав доступа. Чтение из сегмента и запись в него заставляет операционную систему читать соответствующую часть файла на диске и писать данные в нее.

Функция mmap создает указатель на область памяти, ассоциированную с содержимым файла, доступ к которому осуществляется через открытый дескриптор файла.

#include <sys/mman.h>

void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);

Изменить начальную позицию порции данных файла, к которым выполняется обращение через совместно используемый сегмент, можно, передавая параметр

off

fildes

len

Параметр

addr

Параметр

prot

□

PROT_READ

□

PROT_WRITE

□

PROT_EXEC

□

PROT_NONE

Параметр

flags

Таблица 3.7

Функция

msync

#include <sys/mman.h>

int msync(void *addr, size_t len, int flags);

Корректируемая часть сегмента задается передачей начального адреса

addr

len

flags

Таблица 3.8

Функция

munmap

#include <sys/mman.h>

int munmap(void *addr, size_t len);

В программе mmap.с из упражнения 3.5 показан файл из структур, которые будут корректироваться с помощью функции

mmap

mmap

1. Начните с определения структуры

RECORD

NRECORDS

#include <unistd.h>

#include <stdio.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <stdlib.h>

typedef struct {

 int integer;

 char string[24];

} RECORD;

#define NRECORDS (100)

int main() {

 RECORD record, *mapped;

 int i, f;

 FILE *fp;

 fp = fopen("records.dat", "w+");

 for (i=0; i<NRECORDS; i++) {

  record.integer = i;

  sprintf(record.string, "RECORD-%d", i);

  fwrite(&record, sizeof(record), 1, fp);

 }

 fclose(fp);

2. Далее измените целое значение записи с 43 на 143 и запишите его в строку 43-й записи.

 fp = fopen("records.dat", "r+");

 fseek(fp, 43*sizeof(record), SEEK_SET);

 fread(&record, sizeof(record), 1, fp);

 record.integer =143;

 sprintf(record.string, "RECORD-%d", record.integer);

 fseek(fp, 43*sizeof(record), SEEK_SET);

 fwrite(&record, sizeof(record), 1, fp);

 fclose(fp);

3. Теперь отобразите записи в память и обратитесь к 43-й записи для того, чтобы изменить целое на 243 (и обновить строку записи), снова используя отображение в память.

 f = open("records.dat", O_RDWR);

 mapped = (RECORD *)mmap(0, NRECORDS*sizeof(record),

  PROT_READ|PROT_WRITE, MAP_SHARED, f, 0);

 mapped[43].integer = 243;

 sprintf(mapped[43].string, "RECORD-%d", mapped[43].integer);

 msync((void *)mapped, NRECORDS*sizeof(record), MS_ASYNC);

 munmap((void *)mapped, NRECORDS*sizeof(record));

 close(f);

 exit(0);

}

В главе 13 вы встретитесь с еще одним средством совместного использования памяти — разделяемой памятью System V.

В этой главе вы увидели, как ОС Linux обеспечивает прямой доступ к файлам и устройствам, как на этих низкоуровневых функциях строятся библиотечные функции, предоставляющие гибкие решения программных проблем. В результате вы смогли написать довольно мощную процедуру просмотра каталога с помощью нескольких строк программного кода.

Вы также узнали об обработке файлов и каталогов достаточно для того, чтобы превратить "сырое" приложение для работы с компакт-дисками, созданное в конце главы 2, в программу на языке С, применяющую более структурированное решение на базе файлов. Но на этом этапе вы не можете расширить функциональные возможности программы, поэтому мы отложим ее переработку до того времени, когда вы научитесь управлять экраном и клавиатурой, которые будут предметами обсуждения следующих двух глав.