Книга: Linux программирование в примерах

12.5.3. Важные предостережения

12.5.3. Важные предостережения

Есть несколько технических предостережений, о которых нужно знать.

Во-первых, поскольку сохранение и восстановление среды может быть беспорядочной машинно-зависимой задачей, setjmp() и longjmp() могут быть макросами

Во-вторых, стандарт С ограничивает использование setjmp() следующими ситуациями.

• В качестве единственного контролирующего выражения в операторе цикла или условном операторе (if, switch).

• В качестве одного операнда выражения сравнения (==, < и т.д.), с целой константой в качестве другого операнда. Выражение сравнения может быть единственный контролирующим выражением цикла или условного оператора.

• В качестве операнда унарного оператора '!', причем результирующее выражение является единственным контролирующим выражением цикла или условного оператора.

• В качестве всего выражения оператора-выражения, возможно, приведенного к типу void. Например:

(void)setjmp(buf);

В-третьих, если вы хотите изменить локальную переменную в функции, которая вызывает setjmp(), после вызова и хотите, чтобы эта переменная сохранила свое последнее присвоенное после longjmp() значение, нужно объявить эту переменную как volatile. В противном случае все локальные переменные, не являющиеся volatile и изменившиеся после того, как была первоначально вызвана setjmp(), имеют неопределенные значения. (Обратите внимание, что сама переменная jmp_buf не должна объявляться как volatile.) Например:

1  /* ch12-setjmp.с --- демонстрирует setjmp()/longjmp() и volatile. */
2
3  #include <stdio.h>
4  #include <setjmp.h>
5
6  jmp_buf env;
7
8  /* comeback --- выполнение longjmp */
9
10 void comeback(void)
11 {
12  longjmp(env, 1);
13  printf("This line is never printedn");
14 }
15
16 /* main - вызов setjmp, действия с переменными, вывод значений */
17
18 int main(void)
19 {
20  int i = 5;
21  volatile int j = 6;
22
23  if (setjmp(env) == 0) { /* первый раз */
24   i++;
25   j++;
26   printf("first time: i = %d, j = %dn", i, j);
27    comeback));
28  } else /* второй раз */
29   printf("second time: i = %d, j = %dn", i, j);
30
31  return 0;
32 }

В этом примере сохранение своего значения ко второму вызову printf() гарантируется лишь j (строка 21). Значение (строка 20) в соответствии со стандартом С 1999 г. не определено. Это может быть 6, может быть 5, а может даже какое-нибудь другое значение!

В-четвертых, как описано в разделе 12.5.2 «Обработка масок сигналов: sigsetjmp() и siglongjmp()», стандарт С 1999 г. не делает никаких утверждений о влиянии, если оно есть, setjmp() и longjmp() на состояние сигналов программы. Если это важно, вам придется вместо них использовать sigsetjmp() и siglongjmp().

В-пятых, эти процедуры содержат поразительные возможности для утечек памяти! Рассмотрим программу, в которой main() вызывает setjmp(), а затем вызывает несколько вложенных функций, каждая из которых выделяет с помощью malloc() динамическую память. Если наиболее глубоко вложенная функция делает longjmp() обратно в main(), указатели на динамическую память теряются. Взгляните на ch12-memleak.c:

1  /* ch12-memleak.с --- демонстрирует утечки памяти с помощью setjmp()/longjmp(). */
2
3  #include <stdio.h>
4  #include <malloc.h> /* для определения ptrdiff_t в GLIBC */
5  #include <setjmp.h>
6  #include <unistd.h>
7
8  jmp_buf env;
9
10 void f1(void), f2(void);
11
12 /* main --- утечка памяти с помощью setjmp() и longjmp() */
13
14 int main(void)
15 {
16  char *start_break;
17  char *current_break;
18  ptrdiff_t diff;
19
20  start_break = sbrk((ptrdiff_t)0);
21
22  if (setjmp(env) == 0) /* первый раз */
23   printf("setjmp calledn");
24
25  current_break = sbrk((ptrdiff_t) 0);
26
27  diff = current_break - start_break;
28  printf("memsize = %ldn", (long)diff);
29
30  f1();
31
32  return 0;
33 }
34
35 /* f1 --- выделяет память, осуществляет вложенный вызов */
36
37 void f1(void)
38 {
39  char *p = malloc(1024);
40
41  f2();
42 }
43
44 /* f2 --- выделяет память, выполняет longjmp */
45
46 void f2(void)
47 {
48  char *p = malloc(1024);
49
50  longjmp(env, 1);
51 }

Эта программа устанавливает бесконечный цикл, используя setjmp() и longjmp(). Строка 20 использует для нахождения текущего начала кучи sbrk() (см. раздел 3.2.3 «Системные вызовы: brk() и sbrk()»), а затем строка 22 вызывает setjmp(). Строка 25 получает текущее начало кучи; это место каждый раз изменяется, поскольку longjmp() повторно входит в код. Строки 27–28 вычисляют, сколько было выделено памяти, и выводят это количество. Вот что происходит при запуске:

$ ch12-memleak /* Запуск программы */
setjmp called
memsize = 0
memsize = 6372
memsize = 6372
memsize = 6372
memsize = 10468
memsize = 10468
memsize = 14564
memsize = 14564
memsize = 18660
memsize = 18660
...

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

Каждая из функций f1() и f2() выделяют память, a f2() выполняет longjmp() обратно в main() (строка 51). Когда это происходит, локальные указатели (строки 39 и 48) на выделенную память пропали! Такие утечки памяти может оказаться трудно отследить, поскольку часто выделяются небольшие размеры памяти, и как таковые, они могут оставаться незамеченными в течение ряда лет[128].

Этот код явно патологический, но он предназначен для иллюстрации нашей мысли: setjmp() и longjmp() могут вести к трудно обнаруживаемым утечкам памяти. Предположим, что f1() правильно вызвал free(). Было бы далеко неочевидно, что память никогда не будет освобождена. В более крупной и более реалистичной программе, в которой longjmp() мог быть вызван лишь посредством if, найти такую утечку становится даже еще труднее.

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

В-шестых, longjmp() и siglongjmp() не следует использовать из функций, зарегистрированных посредством atexit() (см. раздел 9.1.5.3 «Функции завершения»).

В-седьмых, setjmp() и longjmp() могут оказаться дорогими операциями на машинах с множеством регистров.

При наличии всех этих проблем вы должны строго рассмотреть дизайн своей программы. Если вам не нужно использовать setjmp() и longjmp(), то, может, стоит обойтись без их использования. Однако, если их использование является лучшим способом структурировать свою программу, продолжайте и используйте их, но делайте это осмотрительно.

Оглавление книги