Текст книги "Linux программирование в примерах"

Автор книги: Арнольд Роббинс

сообщить о нарушении

Текущая страница: 11 (всего у книги 55 страниц)

4.7. Форсирование записи данных на диск

Ранее мы описали флаги O_DSYNC, O_RSYNC и O_SYNC для open(). Мы отметили, что использование этих флагов может замедлить программу, поскольку write() не возвращается до тех пор, пока все данные не будут записаны на физический носитель.

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

#include

int fsync(int fd); /* POSIX FSC */

int fdatasync(int fd); /* POSIX SIO */

Системный вызов fdatasync() подобен O_DSYNC: он форсирует запись данных на конечное физическое устройство. Системный вызов fsync() подобен O_SYNC, форсируя запись на физическое устройство не только данных файла, но и вспомогательных данных. Вызов fsync() более переносим; он существовал в мире Unix в течение более продолжительного времени, и вероятность его наличия среди широкого ряда систем больше.

Можно использовать эти вызовы с указателями файлов , вызвав сначала fflush(), а затем fileno() для получения дескриптора нижележащего файла. Вот функция fpsync(), которая может использоваться для заключения обеих операций в один вызов. Она возвращает в случае успеха 0:

/* fpsync – синхронизация переменной stdio FILE* */

int fpsync(FILE *fp) {

 if (fp == NULL || fflush(fp) == EOF || fsync(fileno(fp)) < 0)

  return -1;

 return 0;

}

Технически оба этих вызова являются расширениями базового стандарта POSIX: fsync() в расширении «Синхронизация файлов» (FSC), a fdatasync() в расширении «Синхронизированный ввод и вывод». Тем не менее, можно без проблем использовать их в системе GNU/Linux

4.8. Установка длины файла

Два системных вызова позволяют настраивать размер файла:

#include

#include

int truncate(const char *path, off_t length); /* XSI */

int ftruncate(int fd, off_t length); /* POSIX */

Как должно быть очевидно из параметров, truncate() принимает аргумент имени файла, тогда как ftruncate() работает с дескриптором открытого файла. (Обычным является соглашение по именованию пар системных вызовов xxx() и fxxxx(), работающих с именами файлов и дескрипторами файлов. Мы увидим несколько примеров в данной и последующих главах.) В обоих случаях аргумент length является новым размером файла.

Этот системный вызов происходит от 4.2 BSD Unix, и на ранних системах мог использоваться лишь для сокращения длины файла, отсюда и название. (Он был создан, чтобы облегчить реализацию операции урезания в Фортране.) На современных системах, включая Linux, имя является неправильным, поскольку с помощью этих вызовов можно также увеличить, а не только сократить длину файла. (Однако, POSIX указывает, что возможность увеличения размера файла относится к расширению XSI.)

Для этих вызовов сокращаемый файл должен иметь разрешение на запись (для truncate()), или должен быть открыт для записи (для ftruncate()). Если файл сокращается, все данные после нового конца файла теряются. (Поэтому вы не можете сократить файл, снова удлинить его и найти там первоначальные данные.) Если файл-расширен, как в случае записи данных после lseek(), данные между старым концом файла и новым концом файла читаются как нули.

Эти вызовы сильно отличаются от 'open(file, ... | O_TRUNC, mode)', который полностью урезает файл, отбрасывая все его данные. Эти же вызовы просто устанавливают абсолютную длину файла в данное значение.

Эти функции довольно специализированы; они используются лишь четыре раза во всем коде GNU Coreutils. Мы представляем пример использования ftruncate() в разделе 5.5.3 «Изменение отметок времени: utime()».

4.9. Резюме

• Когда системный вызов завершается неудачей, он обычно возвращает -1, а в глобальной переменной errno устанавливается предопределенное значение, указывающее на проблему. Для сообщений об ошибках могут использоваться функции perror() и strerror().

• Доступ к файлам осуществляется через небольшие целые, которые называются дескрипторами. Дескрипторы файлов для стандартного ввода, стандартного вывода и стандартной ошибки наследуются от родительского процесса программы. Другие получаются через open() или creat(). Для их закрытия используется close(), a getdtablesize() возвращает разрешенное максимальное число открытых файлов. Значение umask (устанавливаемое с помощью umask()) влияет на права доступа, получаемые новыми файлами при создании с помощью creat() или с флагом O_CREAT для open().

• Системные вызовы read() и write() соответственно читают и записывают данные. Их интерфейс прост. В частности, они не интерпретируют данные, файлы представлены линейными потоками байтов. Системный вызов lseek() осуществляет ввод/выводе произвольным доступом: возможность перемещаться внутри файла.

• Для синхронного ввода/вывода предусмотрены дополнительные флаги для open(), при этом данные записываются на физический носитель данных до возвращения write() или read(). Можно также форсировать запись данных на диск на управляемой основе с помощью fsync() или fdatasync().

• Системные вызовы truncate() и ftruncate() устанавливают абсолютную длину файла. (На более старых системах они могут использоваться лишь для сокращения длины файла; на современных системах они могут также увеличивать файл.)

Упражнения

1. Используя лишь open(), read(), write() и close(), напишите простую программу copy, которая копирует файл, имя которого дается в первом аргументе, в файл с именем во втором аргументе.

2. Усовершенствуйте программу copy так, чтобы она принимала "-" в значении «стандартный ввод» при использовании в качестве первого аргумента и в значении «стандартный вывод» в качестве второго аргумента. Правильно ли работает 'copy – -'?

3. Просмотрите страничку справки для proc(5) на системе GNU/Linux. В частности, посмотрите подраздел fd. Выполните 'ls -l /dev/fd' и непосредственно проверьте файлы в /proc/self/fd. Если бы /dev/stdin и дружественные устройства были бы в ранних версиях Unix, как это упростило бы код для программы V7 cat? (Во многих других современных системах Unix есть каталог или файловая система /dev/fd. Если вы не используете GNU/Linux, посмотрите, что вы можете обнаружить в своей версии Unix.)

4. Даже если вы пока этого не понимаете, постарайтесь скопировать сегмент кода из V7 cat.c, который использует struct stat и функцию fstat(), в ch04-cat.c, чтобы она также сообщала об ошибке для 'cat file >> file'.

5. (Простое) Предположив наличие strerror(), напишите свою версию perror().

6. Каков результат выполнения 'ulimit -n' на вашей системе?

7. Напишите простую версию программы umask, назвав ее myumask, которая принимает в командной строке восьмеричную маску. Используйте strtol() с основанием 8 для преобразования строки символов аргумента командной строки в целое значение. Измените umask с помощью системного вызова umask().

Откомпилируйте и запустите myumask, затем проверьте значение umask с помощью стандартной команды umask. Объясните результаты. (Подсказка: в оболочке Bash введите 'type umask'.)

8. Измените простую программу copy, которую вы написали ранее, для использования open() с флагом O_SYNC. Используя команду time, сравните характеристики первоначальной и новой версии большого файла.

9. Мы сказали, что для ftruncate() файл должен быть открыт для записи. Как можно открыть файл для записи, когда у самого файла нет доступа записи?

10. Напишите программу truncate, которая используется следующим образом: 'truncate длина_файла'.

Глава 5
Каталоги и служебные данные файлов

Данная глава продолжает подъем по кривой обучения до следующего плато: понимания каталогов и информации о файлах.

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

5.1. Просмотр содержимого каталога

Все Unix-системы, включая Linux, используют для хранения файловой информации на диске один и тот же концептуальный дизайн. Хотя в реализации дизайна есть значительные вариации, интерфейс на уровне С остается постоянным, давая возможность писать переносимые программы, которые компилируются и запускаются на многих различных системах.

5.1.1. Определения

Рис. Copyright 1997-2004 © J.D. «Illiad» Frazer. Использовано по разрешению, http://www.userfriendly.org

Мы начнем обсуждение с определения нескольких терминов.

Раздел (partition)

Единица физического хранилища. Физические разделы обычно являются либо частями диска, либо целым диском. Современные системы дают возможность создавать из нескольких физических логические разделы.

Файловая система (filesystem)

Раздел (физический или логический), содержащий данные файла и служебные данные (metadata), информацию о файлах (в противоположность содержимому файла, которое является информацией в файле). Такие служебные данные включают владельца файла, права доступа, размер и т.д., а также информацию, использующуюся операционной системой при поиске содержимого файла. Файловые системы размещаются «в» разделах (соотношение одни к одному) посредством записи в них стандартной информации. Это осуществляется программой уровня пользователя, такой, как mke2fs в GNU/Linux или newfs в Unix. (Команда Unix mkfs создает разделы, но ее трудно использовать, непосредственно, newfs вызывает ее с нужными параметрами. Если ваша система является системой Unix, подробности см. в справочных страницах для newfs(8) и mkfs(8).)

Большей частью GNU/Linux и Unix скрывают наличие файловых систем и разделов. (Дополнительные подробности приведены в разделе 8.1 «Монтирование и демонтирование файловых систем».) Доступ ко всему осуществляется через пути, безотносительно к тому, на каком диске расположен файл. (Сравните это с почти любой коммерческой операционной системой, такой, как OpenVMS, или с поведением по умолчанию любой системы Microsoft.)

Индекс (inode)

Сокращение от 'index node' (индексный узел), первоначально сокращалось 'i-node', а теперь пишется 'inode'. Небольшой блок информации, содержащий все сведения о файле, за исключением имени файла. Число индексов и, следовательно, число уникальных файлов в файловой системе, устанавливается и делается постоянным при создании файловой системы. Команда 'df -i' может показать, сколько имеется индексов и сколько из них используется.

Устройство (device)

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

Каталог (directory)

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

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

Рис. 5.1. Концептуальное представление индексов и блоков данных

На рисунке показаны все блоки индексов перед разделом и блоки данных после них. Ранние файловые системы Unix были организованы именно таким способом. Однако, хотя все современные системы до сих пор содержат индексы и блоки данных, их организация для повышения эффективности и устойчивости была изменена. Детали меняются от системы к системе, и даже в рамках систем GNU/Linux имеется множество разновидностей файловых систем, но концепция остается той же самой.

5.1.2. Содержимое каталога

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

Рис. 5.2. Концептуальное содержание каталога

На ранних Unix-системах были двухбайтные номера индексов, а имена файлов – до 14 байтов. Вот полное содержание файла V7 /usr/include/sys/dir.h:

#ifndef DIRSIZ

#define DIRSIZ 14

#endif

struct direct {

 ino_t d_ino;

 char d_name[DIRSIZ];

};

ino_t определен в V7 как 'typedef unsigned int into_t;'. Поскольку на PDP-11 int является 16-разрядным, таким же является и ino_t. Такая организация упрощала непосредственное чтение каталогов; поскольку размер элемента был фиксирован, код был простым. (Единственно, за чем нужно было следить, это то, что полное 14-символьное d_name не завершалось символом NUL.)

Управление содержанием каталога для системы также было простым. Когда файл удалялся из каталога, система заменяла номер индекса двоичным нулем, указывая, что элемент каталога не используется. Новые файлы могли потом использовать пустой элемент повторно. Это помогало поддерживать размер самих файлов каталогов в приемлемых рамках. (По соглашению, номер индекса 1 не используется; первым используемым индексом всегда является 2. Дополнительные сведения приведены в разделе 8.1 «Монтирование и демонтирование файловых систем».)

Современные системы предоставляют длинные имена файлов. Каждый элемент каталога имеет различную длину, с обычным ограничением для компонента имени файла каталога в 255 байтов. Далее мы увидим, как читать на современных системах содержимое каталога. Также в современных системах номера индексов 32 (или даже 64!) разрядные.

5.1.3. Прямые ссылки

Когда файл создается с помощью open() или creat(), система находит не использующийся индекс и присваивает его новому файлу. Она создает для файла элемент каталога с именем файла и номером индекса. Опция -i команды ls отображает номер индекса.

$ echo hello, world > message /* Создать новый файл */

$ ls -il message /* Показать также номер индекса */

228786 -rw-r–r– 1 arnold devel 13 May 4 15:43 message

Поскольку элементы каталога связывают имена файлов с индексами, у одного файла может быть несколько имен. Каждый элемент каталога, ссылающийся на один и тот же индекс, называется ссылкой (link) или прямой ссылкой (hard link) на файл. Ссылки создаются с помощью команды ln. Она используется следующим образом: 'ln старый_файл новый_файл'.

$ ln message msg /* Создать ссылку */

$ cat msg /* Показать содержание нового имени */

hello, world

$ ls -il msg message /* Показать номера индексов */

228786 -rw-r–r– 2 arnold devel 13 May 4 15:43 message

228786 -rw-r–r– 2 arnold devel 13 May 4 15:43 msg

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

Нельзя не подчеркнуть: прямые ссылки все относятся к одному и тому же файлу. Если вы измените один файл, изменятся и все остальные:

$ echo "Hi, how ya doin' ?" > msg /* Изменить файл через новое имя */

$ cat message /* Показать содержание через старое имя */

Hi, how ya doin' ?

$ ls -il message msg /* Отобразить сведения. Размер изменился */

228786 -rw-r–r– 2 arnold devel 19 May 4 15:51 message

228786 -rw-r–r– 2 arnold devel 19 May 4 15:51 msg

Хотя мы создали две ссылки на один файл в одном каталоге, прямые ссылки не обязательно должны находиться в одном и том же каталоге; они могут находиться в любом каталоге в той же самой файловой системе. (Несколько подробнее это обсуждается в разделе 5.1.6 «Символические ссылки».)

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

После удаления ссылки создание еще одного файла с прежним именем создает новый файл:

$ rm message /* Удалить старое имя */

$ echo "What's happenin?" > message /* Повторно использовать имя */

$ ls -il msg message /* Отобразить сведения */

228794 -rw-r–r– 1 arnold devel 17 May 4 15:58 message

228786 -rw-r–r– 1 arnold devel 19 May 4 15:51 msg

Обратите внимание, что теперь счетчик ссылок каждого из файлов равен 1. На уровне С ссылки создаются с помощью системного вызова link():

#include /* POSIX */

int link(const char *oldpath, const char *newpath);

При успешном создании ссылки возвращается 0, в противном случае (-1), при этом errno отражает ошибку. Важным-случаем ошибки является тот, когда newpath уже существует. Система не удалит его для вас, поскольку попытка сделать это может вызвать несовместимости в файловой системе.

5.1.3.1. Программа GNU link

Программа ln сложная и большая. Однако, GNU Coreutils содержит несложную программу link, которая просто вызывает link() со своими двумя аргументами. Следующий пример показывает код из файла link.с, не относящиеся к делу части удалены. Номера строк относятся к действительному файлу.

20  /* Обзор реализации:

21

22     Просто вызывает системную функцию 'link' */

23

    /* ...Операторы #include для краткости опущены... */

34

35  /* Официальное имя этой программы (например, нет префикса 'g'). */

36  #define PROGRAM_NAME "link"

37

38  #define AUTHORS "Michael Stone"

39

40  /* Имя, под которым была запущена данная программа. */

41  char *program_name;

42

43  void

44  usage(int status)

45  {

     /*  ... для краткости опущено... */

62  }

63

64  int

65  main(int argc, char **argv)

66  {

67   program_name = argv[0];

68   setlocale(LC_ALL, "");

69   bindtextdomain(PACKAGE, LOCALEDIR);

70   textdomain(PACKAGE);

71

72   atexit(close_stdout);

73

74   parse_long_options(argc, argv, PROGRAM_NAME, GNU_PACKAGE,

75    VERSION, AUTHORS, usage);

76

77   /* Вышеприведенное обрабатывает –help и –version.

78      Поскольку других вызовов getopt нет, обработать здесь '–'. */

79   if (1 < argc && STREQ(argv[1], "–"))

80   {

81    –argc;

82    ++argv;

83   }

84

85   if (argc < 3)

86   {

87    error(0, 0, _("too few arguments"));

88    usage(EXIT_FAILURE);

89   }

90

91   if (3 < argc)

92   {

93    error(0, 0, _("too many arguments"));

94    usage(EXIT_FAILURE);

95   }

96

97   if (link(argv[1], argv[2]) != 0)

98    error(EXIT_FAILURE, errno, _("cannot create link %s to %s"),

99     quote_n(0, argv[2]), quote_n(1, argv[1]));

100

101  exit(EXIT_SUCCESS);

102 }

Строки 67–75 являются типичным шаблоном Coreutils, устанавливающими интернациональные настройки, выход по завершении и анализ аргументов. Строки 79–95 гарантируют, что link вызывается лишь с двумя аргументами. Сам системный вызов link() осуществляется в строке 97 (Функция quote_n() обеспечивает отображение аргументов в стиле, подходящем для текущей локали; подробности сейчас несущественны.)

5.1.3.2. Точка и точка-точка

Завершая обсуждение ссылок, давайте взглянем на то, как обрабатываются специальные имена '.' и '..'. На самом деле они просто являются прямыми ссылками. В первом случае '.' является прямой ссылкой на каталог, содержащий ее, а '..' – прямой ссылкой на родительский каталог. Операционная система создает для вас эти ссылки; как упоминалось ранее, код уровня пользователя не может создать прямую ссылку на каталог. Этот пример иллюстрирует ссылки:

$ pwd /* Отобразить текущий каталог */

/tmp

$ ls -ldi /tmp /* Показать номер его индекса */

225345 drwxrwxrwt 14 root root 4096 May 4 16:15 /tmp

$ mkdir x /* Создать новый каталог */

$ ls -ldi x /* И показать номер его индекса */

52794 drwxr-xr-x 2 arnold devel 4096 May 4 16:27 x

$ ls -ldi x/. x/.. /* Показать номера индексов . И .. */

52794 drwxr-xr-x 2 arnold devel 4096 May 4 16:27 x/.

225345 drwxrwxrwt 15 root root 4096 May 4 16:27 x/..

Родительский каталог корневого каталога (/..) является особым случаем; мы отложим его обсуждение до главы 8 «Файловые системы и обход каталогов».

5.1.4. Переименование файлов

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

1. Если новое имя файла обозначает существующий файл, сначала удалить этот файл.

2. Создать новую ссылку на файл через новое имя.

3. Удалить старое имя (ссылку) для файла. (Удаление имен обсуждается в следующем разделе.)

Ранние версии команды mv работали таким способом. Однако, при таком способе переименование файла не является атомарным; т.е. оно не осуществляется посредством одной непрерываемой операции. И на сильно загруженной системе злонамеренный пользователь мог бы воспользоваться условиями состояния гонки[51]51
  Состояние .гонки (race condition) является ситуацией, при которой детали временных соотношений могут вызывать непреднамеренные побочные эффекты или ошибки. В данном случае, каталог в течение короткого периода времени находится в противоречивом состоянии, и именно эта противоречивость и создаёт уязвимость – Примеч. автора.


[Закрыть], разрушая операцию переименования и подменяя оригинальный файл другим.

По этой причине 4.2 BSD ввело системный вызов rename():

#include /* ISO С */

int rename(const char *oldpath, const char *newpath);

На системах Linux операция переименования является атомарной; справочная страница утверждает:

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

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

Как и в случае с другими системными вызовами, возвращенный 0 означает успех, а (-1) означает ошибку.