title: malloc_hook(3)

summary: переменные отладки malloc

text:
# malloc_hook(3)

## ИМЯ
__malloc_hook, __malloc_initialize_hook, __memalign_hook, __free_hook, __realloc_hook, __after_morecore_hook - переменные отладки malloc

## ОБЗОР

```
#include <malloc.h>
```

```
void *(*__malloc_hook)(size_t size, const void *caller);
```

```
void *(*__realloc_hook)(void *ptr, size_t size, const void *caller);
```

```
void *(*__memalign_hook)(size_t alignment, size_t size,
                         const void *caller);
```

```
void (*__free_hook)(void *ptr, const void *caller);
```

```
void (*__malloc_initialize_hook)(void);
```

```
void (*__after_morecore_hook)(void);
```

## ОПИСАНИЕ
Библиотека GNU C позволяет изменить поведение malloc(3), realoc(3) и free(3), указав соответствующие «обрабатывающие» (hook) функции. Вы можете использовать эти функции-обработчики для отладки программ, использующих динамическое выделение памяти.

Переменная __ malloc_initialize_hook указывает на функцию, которая однократно вызывается при инициализации реализации malloc. Это — слабая переменная, поэтому она может быть переопределена в приложении как показано далее:

```
void (*__malloc_initialize_hook)(void) = my_init_hook;
```

Теперь функция my_init_hook() может проинициализировать все функции-обработчики.

У четырёх функций, на которые указывают переменные __malloc_hook, __realloc_hook, __memalign_hook, __free_hook, имеются прототипы, подобные функциям malloc(3), realloc(3), memalign(3), free(3), соответственно, однако у них есть дополнительный последний параметр caller, в который передаётся адрес вызывающего malloc(3) и т.д.

Переменная __ after_morecore_hook указывает на функцию, которая вызывается каждый раз после того, как sbrk(2) просят увеличить память.

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эти функции являются расширениями GNU.

## ЗАМЕЧАНИЯ
Использование этих обрабатывающих функций не безопасно в многонитевых программах, и теперь они считаются устаревшими. Начиная с glibc версии 2.24, переменная __ malloc_initialize_hook была удалена из программного интерфейса. Теперь вместо неё программисты должны подменять вызовы соответствующих функций, определяя и экспортируя такие функции как «malloc» и «free».

## ПРИМЕР
Вот короткий пример того, как использовать эти переменные.

```
#include <stdio.h>
#include <malloc.h>
/* прототипы наших функций */
static void my_init_hook(void);
static void *my_malloc_hook(size_t, const void *);
/* переменные для сохранения имеющихся обрабатывающих функций */
static void *(*old_malloc_hook)(size_t, const void *);
/* переопределяем первоначальные функции библиотеки C */
void (*__malloc_initialize_hook) (void) = my_init_hook;
static void
my_init_hook(void)
{

    old_malloc_hook = __malloc_hook;

    __malloc_hook = my_malloc_hook;
}
static void *
my_malloc_hook(size_t size, const void *caller)
{

    void *result;

    /* Восстанавливаем старые функции */

    __malloc_hook = old_malloc_hook;

    /* вызываем рекурсивно */

    result = malloc(size);

    /* сохраняем нижележащие функции */

    old_malloc_hook = __malloc_hook;

    /* printf() тоже может вызвать malloc(), поэтому его тоже надо защитить */

    printf("malloc(%u) called from %p returns %p\n",

            (unsigned int) size, caller, result);

    /* восстанавливаем наши функции */

    __malloc_hook = my_malloc_hook;

    return result;
}
```

## СМОТРИТЕ ТАКЖЕ
mallinfo(3), malloc(3), mcheck(3), mtrace(3)


package: man-pages-ru

title: malloc_info(3)

summary: экспортирует состояние malloc в поток

text:
# malloc_info(3)

## ИМЯ
malloc_info - экспортирует состояние malloc в поток

## ОБЗОР

```
#include <malloc.h>
```

```
int malloc_info(int options, FILE *stream);
```

## ОПИСАНИЕ
Функция malloc_info() экспортирует строку XML, описывающую текущее состояние реализации выделения памяти вызывающего. Строка печатается в файловый поток stream. В экспортируемой строке содержится информация о всех областях (arenas) (смотрите malloc(3)).

В текущей реализации значение options должно быть равно нулю.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
При успешном выполнении malloc_info() возвращается 0; при ошибке возвращается -1, а в errno помещается код ошибки.

## ОШИБКИ
EINVAL

Значение options не равно.

## ВЕРСИИ
Функция malloc_info() впервые появилась в glibc 2.10.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

malloc_info()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эта функция является расширением GNU.

## ЗАМЕЧАНИЯ
Информация о выделении памяти предоставляется в виде строки XML (а не в структуре C), так как структура со временем может меняться (при изменении в реализации). Возвращаемая строка XML содержит поле версии.

Для отправки вывода malloc_info() в буфер памяти, а не в файл можно использовать функцию open_memstream(3).

Функция malloc_info() разработана для компенсации нехватки данных из malloc_stats(3) и mallinfo(3).

## ПРИМЕР
Программа, представленная ниже, принимает до четырёх параметров командной строки, три из которых обязательны. В первом параметре задаётся количество нитей, которые должна создать программа. Все нити, включая главную нить, выделяют количество блоков памяти, заданное в втором параметре. В третьем параметре задаётся размер выделяемых блоков. Главная нить создает блоки этого размера, вторая нить создаваемая программой, выделяет блоки двукратного размера, третья нить выделяет блоки трёхкратного размера и так далее.

Чтобы показать состояние выделения памяти программа дважды вызывает malloc_info(). Первый раз вызов делается до создания нитей и выделения памяти. Второй вызов выполняется после того, как все нити выделят память.

В следующем примере аргументами командной строки задаётся создание одной дополнительной нити и что главная и дополнительная нить выделяют 10000 блоков памяти. После того, как блоки памяти выделены, malloc_info() показывает состояние двух областей выделения.

```
$ getconf GNU_LIBC_VERSION
glibc 2.13
$ ./a.out 1 10000 100
============ до выделения блоков ============
<malloc version="1">
<heap nr="0">
<sizes>
</sizes>
<total type="fast" count="0" size="0"/>
<total type="rest" count="0" size="0"/>
<system type="current" size="135168"/>
<system type="max" size="135168"/>
<aspace type="total" size="135168"/>
<aspace type="mprotect" size="135168"/>
</heap>
<total type="fast" count="0" size="0"/>
<total type="rest" count="0" size="0"/>
<system type="current" size="135168"/>
<system type="max" size="135168"/>
<aspace type="total" size="135168"/>
<aspace type="mprotect" size="135168"/>
</malloc>
============ после выделения блоков ============
<malloc version="1">
<heap nr="0">
<sizes>
</sizes>
<total type="fast" count="0" size="0"/>
<total type="rest" count="0" size="0"/>
<system type="current" size="1081344"/>
<system type="max" size="1081344"/>
<aspace type="total" size="1081344"/>
<aspace type="mprotect" size="1081344"/>
</heap>
<heap nr="1">
<sizes>
</sizes>
<total type="fast" count="0" size="0"/>
<total type="rest" count="0" size="0"/>
<system type="current" size="1032192"/>
<system type="max" size="1032192"/>
<aspace type="total" size="1032192"/>
<aspace type="mprotect" size="1032192"/>
</heap>
<total type="fast" count="0" size="0"/>
<total type="rest" count="0" size="0"/>
<system type="current" size="2113536"/>
<system type="max" size="2113536"/>
<aspace type="total" size="2113536"/>
<aspace type="mprotect" size="2113536"/>
</malloc>
```

### Исходный код программы

```
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <malloc.h>
#include <errno.h>
static size_t blockSize;
static int numThreads, numBlocks;
#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \

                        } while (0)
static void *
thread_func(void *arg)
{

    int j;

    int tn = (int) arg;

    /* Множитель '(2 + tn)' для обеспечения того, что каждая

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

    for (j = 0; j < numBlocks; j++)

        if (malloc(blockSize * (2 + tn)) == NULL)

            errExit("malloc-thread");

    sleep(100);         /* Спим, пока главная нить не завершит работу */

    return NULL;
}
int
main(int argc, char *argv[])
{

    int j, tn, sleepTime;

    pthread_t *thr;

    if (argc < 4) {

        fprintf(stderr,

                "%s num-threads num-blocks block-size [sleep-time]\n",

                argv[0]);

        exit(EXIT_FAILURE);

    }

    numThreads = atoi(argv[1]);

    numBlocks = atoi(argv[2]);

    blockSize = atoi(argv[3]);

    sleepTime = (argc > 4) ? atoi(argv[4]) : 0;

    thr = calloc(numThreads, sizeof(pthread_t));

    if (thr == NULL)

        errExit("calloc");

    printf("============ до выделения блоков ============\n");

    malloc_info(0, stdout);

    /* Создаём нити, которые выделяют разное количество памяти  */

    for (tn = 0; tn < numThreads; tn++) {

        errno = pthread_create(&thr[tn], NULL, thread_func,

                               (void *) tn);

        if (errno != 0)

            errExit("pthread_create");

        /* если мы добавим задержку после запуска каждой нити,

           то нити, вероятно,  не будут бороться за мьютекс malloc,

           и поэтому дополнительные области выделены

           не будут (смотрите malloc(3)) */

        if (sleepTime > 0)

            sleep(sleepTime);

    }

    /* главная нить также выделяет память */

    for (j = 0; j < numBlocks; j++)

        if (malloc(blockSize) == NULL)

            errExit("malloc");

    sleep(2);           /* ждём, чтобы потоки успели

                           выделить память */

    printf("\n============ после выделения блоков ============\n");

    malloc_info(0, stdout);

    exit(EXIT_SUCCESS);
}
```

## СМОТРИТЕ ТАКЖЕ
mallinfo(3), malloc(3), malloc_stats(3), mallopt(3), open_memstream(3)


title: malloc_stats(3)

text:
# malloc_stats(3)

## ИМЯ
malloc_stats — вывести статистику для выделенной памяти

## ОБЗОР
\#include <malloc.h>

void malloc_stats(void);

## ОПИСАНИЕ
Функция malloc_stats() печатает (через стандартный вывод ошибок) статистику о выделенной, при помощи malloc(3) или других функций, памяти. Для каждой области выделяемой памяти (арене), эта функция печатает общее количество выделенной памяти и общее число затраченных на это байт. (Эти два значения соответствуют полям arena и uordblks возвращаемым mallinfo(3)). В дополнение, функция печатает сумму этих двух статистик для всех арен и максимальное число блоков и байт, которые когда-либо были одновременно выделены при использовании mmap(2).

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

malloc_stats()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эта функция является расширением GNU.

## ЗАМЕЧАНИЯ
Для более детальной информации о выделении памяти в главной арене используйте mallinfo(3).

## СМОТРИТЕ ТАКЖЕ
mmap(2), mallinfo(3), malloc(3), malloc_info(3), mallopt(3)


title: malloc_trim(3)

text:
# malloc_trim(3)

## ИМЯ
malloc_trim — освобождает свободную память из кучи

## ОБЗОР
\#include <malloc.h>

int malloc_trim(size_t pad);

## ОПИСАНИЕ
Функция malloc_trim() освобождает свободную память из кучи (используя sbrk(2) или madvise(2) с подходящими аргументами).

Аргумент pad определяет размер свободного пространства, оставляемого на верху кучи. Если он 0, то поддерживается минимум памяти (одна страница или меньше). Если значение отлично от нуля, то освобождается пространство для будущего распределения без необходимости использовать sbrk(2).

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
malloc_trim() возвращает 1 если память была освобождена, 0 если это не возможно.

## ОШИБКИ
Ошибки не установлены.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

malloc_trim()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эта функция является расширением GNU.

## ЗАМЕЧАНИЯ
Эта функция автоматически вызывается функцией free(3) в определённых обстоятельствах. Смотрите обсуждение M_TOP_PAD и M_TRIM_THRESHOLD в mallopt(3).

В аргументе pad учитывается только главная куча (использующаяся в sbrk(2)); с кучами нитей не работает.

Начиная с glibc 2.8 эта функция освобождает память во всех областях (arenas) и во всех кусках (chunks) со свободными страницами целиком.

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

## СМОТРИТЕ ТАКЖЕ
sbrk(2), malloc(3), mallopt(3)


title: malloc_usable_size(3)

summary: размер блока отданного из кучи

text:
# malloc_usable_size(3)

## ИМЯ
malloc_usable_size - размер блока отданного из кучи

## ОБЗОР
\#include <malloc.h>

size_t malloc_usable_size (void *ptr);

## ОПИСАНИЕ
Функция malloc_usable_size() возвращает число байт в блоке. Вычисляет размер блока на который указывает ptr. В качестве параметра следует использовать указатель полученный от функции malloc(3) или от функции связанной с ней.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция malloc_usable_size() возвращает число байт в блоке выделенном malloc(). Размер вычисляется для блока на который указывает ptr. Если ptr содержит NULL, то функция вернёт 0.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

malloc_usable_size()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эта функция является расширением GNU.

## ЗАМЕЧАНИЯ
Значение, возвращенное malloc_usable_size(), может быть больше, чем то значение которое вы указали в malloc(). Это происходит из-за выравнивания и ограничений на минимальный размер блока. Хотя изменение лишних байт не может привести к ошибкам, это не хорошая практика программирования: так как наличие и число лишних байт зависит от реализации malloc.

В основном эта функция применяется для отладки и самоанализа.

## СМОТРИТЕ ТАКЖЕ
malloc(3)


mallopt

title: mallopt(3)

summary: задаёт параметры выделения памяти

text:
# mallopt(3)

## ИМЯ
mallopt - задаёт параметры выделения памяти

## ОБЗОР
\#include <malloc.h>

int mallopt(int param, int value);

## ОПИСАНИЕ
Функция mallopt() подстраивает параметры, которые управляют поведением функций выделения памяти (смотрите malloc(3)). В аргументе param указывается изменяемый параметр, а в value — новое значение этого параметра.

В param можно указать следующие значения:

M_ARENA_MAX

Если этот параметр не равен нулю, то он определяет жёсткое ограничение на максимальное количество площадок (arenas), которое можно создать. Площадка представляет собой общий набор буферов (pool) памяти, который может использовать вызов malloc(3) (и подобные) для обслуживания запросов выделения. Площадки безопасны в нитях и поэтому могут использоваться при одновременных запросах выделения. Нужно соблюдать соотношение между количеством нитей и количеством площадок. Чем больше площадок, тем меньше состязаний между нитями, но большее потребление памяти.

Значение по умолчанию данного параметра равно 0, то есть ограничение на количество площадок будет определяться по M_ARENA_TEST.

Этот параметр доступен начиная с glibc 2.10 при указании --enable-experimental-malloc, и начиная с glibc 2.15 — по умолчанию. В некоторых версиях механизм выделения не имел ограничения на количество создаваемых площадок (например, в CentOS 5, RHEL 5).

При использовании более новых версий glibc приложения могут, в некоторых случаях, встретить высокую состязательность при доступе к площадкам. В этих случаях может быть выгодно увеличить M_ARENA_MAX для соответствия количеству нитей. Такое поведение подобно стратегиям, используемым tcmalloc и jemalloc (например, общие наборы буферов выделения для каждой нити).

M_ARENA_TEST

Этим параметром определяется значение на количество создаваемых площадок; в соответствии с ним будут исследоваться системные настройки для оценки жёсткого ограничения на количество создаваемых площадок (определение площадки смотрите в описании M_ARENA_MAX).

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

Значение по умолчанию для параметра M_ARENA_TEST равно 2 в системах, где sizeof(long) равно 4; в противном случае значение по умолчанию равно 8.

Этот параметр доступен начиная с glibc 2.10 при указании --enable-experimental-malloc, и начиная с glibc 2.15 — по умолчанию.

Значение M_ARENA_TEST не используется, если M_ARENA_MAX не равно нулю.

M_CHECK_ACTION

Значение данного параметра управляет тем, как glibc действует при обнаружении различных программных ошибок (например, освобождение одного указателя дважды). Поведение glibc задаётся тремя битами (2, 1 и 0) указанного значения:

Бит 0

Если этот бит установлен, то печатается сообщение в stderr с подробностями ошибки. Сообщение начинается со строки «*** glibc detected ***», далее идёт имя программы, имя функции выделения памяти, в которой возникла ошибка, краткое описание ошибки и адрес памяти, где обнаружена ошибка.

Бит 1

Если этот бит установлен, то после печати сообщения об ошибке, если указано битом 0, программа завершается вызовом abort(3). В glibc с версии 2.4, если также установлен бит 0, то между печатью сообщения об ошибке и завершением программа также печатает трассировку стека подобную backtrace(3), и печатает отображение памяти процесса в стиле /proc/[pid]/maps (смотрите proc(5)).

Бит 2 (начиная с glibc 2.4)

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

Оставшиеся биты в value игнорируются.

Объединяя выше описанное, получаются следующие числовые значения, влияющие на M_CHECK_ACTION:

0

Игнорировать условия ошибки; продолжить выполнение (с неопределенными результатами).

1

Вывести подробное сообщение об ошибке и продолжить выполнение.

2

Прервать программу.

3

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

5

Вывести простое сообщение об ошибке и продолжить выполнение.

7

Вывести простое сообщение об ошибке, трассировку стека и отображения памяти, и прервать программу.

Начиная с glibc 2.3.4, значение параметра M_CHECK_ACTION по умолчанию равно 3. В glibc версии 2.3.3 и старее значением по умолчанию было 1.

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

M_MMAP_MAX

Данным параметром задаётся максимальное количество запросов выделения, которые может одновременно выполнить mmap(2). Этот параметр существует, так как в некоторых системах ограничено количество внутренних таблиц, используемых mmap(2), и использование больше определённого количество снижает производительность.

По умолчанию значение равно 65536; оно не имеет какого-то специального обоснования и служит только как предохранитель. Присвоение этому параметру 0 отключает использование mmap(2) для обслуживания запросов больших выделений.

M_MMAP_THRESHOLD

Для выделений, которые больше или равны M_MMAP_THRESHOLD (в байтах) и не могут быть получены из списка свободных, то функции выделения памяти вместо mmap(2) используют sbrk(2) для увеличения пространства данных программы.

Выделяемая с помощью mmap(2) память имеет значительное преимущество в том, что выделенные блоки памяти можно всегда независимо освободить и вернуть системе (по сравнению с кучей, которую можно обрезать только, если память свободна в конце). С другой стороны, есть несколько отрицательных моментов при использовании mmap(2): освобождённое пространство не возвращается в список свободного для повторного выделения позже; память может траться впустую, так как выделения mmap(2) должны быть кратны размеру страницы; ядро должно выполнять ресурсоёмкую задачу по обнулению памяти, выделяемой через mmap(2). Баланс этих факторов учтён в значении по умолчанию для параметра M_MMAP_THRESHOLD — 128*1024.

Нижний предел данного параметра равен 0. Верхний предел DEFAULT_MMAP_THRESHOLD_MAX: 512*1024 в 32-битных системах и 4*1024*1024*sizeof(long) в 64-битных системах.

Замечание: В настоящее время по умолчанию в glibc используется динамический порог mmap. Начальное значение порога — 128*1024, но когда освобождаются блоки больше текущего порога и меньше или равны DEFAULT_MMAP_THRESHOLD_MAX, то порог увеличивается до размера свободного блока. Когда срабатывает динамический порог mmap, порог обрезки кучи также динамически корректируется на двукратное значение динамического порога mmap.Динамическая корректировка порога mmap отключается, если задан параметр M_TRIM_THRESHOLD, M_TOP_PAD, M_MMAP_THRESHOLD или M_MMAP_MAX.

M_MXFAST (начиная с glibc 2.3)

Задаёт верхний порог запросов выделения памяти, которые обрабатываются с помощью «fastbins» (значение параметра измеряется в байтах). Fastbins — это области хранилища, которые содержат освобождённые блоки памяти одного размера и не объединяют смежные свободные блоки. Последующее перераспределение блоков одного размера при выделении из fastbin может обрабатываться очень быстро, хотя из-за этого может увеличиться фрагментация памяти и общее количество памяти программы.

По умолчанию значение параметра равно 64*sizeof(size_t)/4 (т. е., 64 на 32-битных архитектурах). Диапазон значений параметра: 0 - 80*sizeof(size_t)/4. Присваивание M_MXFAST значения 0 отключает использование fastbins.

M_PERTURB (начиная с glibc 2.4)

Если этому параметру присвоено ненулевое значение, то байты выделенной памяти (кроме выделенных через calloc(3)) инициализируются дополнением значения в наименее значимом байте value, и при освобождении памяти с помощью free(3) освобождённым байтам присваивается значение наименее значимого байта value. Это может быть полезно для обнаружения ошибок, когда программа некорректно полагается на то, что выделенная памяти инициализируется нулями или повторно использует значения уже освобождённой памяти.

Значение по умолчанию для этого параметра равно 0.

M_TOP_PAD

Данным параметром определяется количество заполнения при вызове sbrk(2) для изменения пространства данных программы (измеряется в байтах). Данный параметр полезен в следующих случаях:

- Когда пространство данных программы увеличивается, то M_TOP_PAD байт добавляется к запросу sbrk(2).

- Когда обрезается куча в следствии вызова free(3) (смотрите описание M_TRIM_THRESHOLD), то это количество пространства предохраняется вверху кучи.

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

Изменение M_TOP_PAD — компромисс между увеличением количества системных вызовов (если значение параметра занижено) и тратой неиспользуемой памяти сверху кучи (если значение параметра завышено).

Значение по умолчанию этого параметра равно 128*1024.

M_TRIM_THRESHOLD

Когда количество непрерывной свободной памяти сверху кучи вырастает до значительных размеров функция free(3) вызывает sbrk(2) для освобождения этой памяти обратно в систему (это может быть полезно в программах, которые работают длительное время после освобождения значительного количества памяти). Параметром M_TRIM_THRESHOLD задаётся минимальный размер (в байтах), которого должен достигнуть блок памяти, чтобы вызвался sbrk(2) для обрезания кучи.

Значение по умолчанию этого параметра равно 128*1024. Установка M_TRIM_THRESHOLD равным -1 отключает обрезку.

Изменение M_TRIM_THRESHOLD — компромисс между увеличением количества системных вызовов (если значение параметра занижено) и тратой неиспользуемой памяти сверху кучи (если значение параметра завышено).

### Переменные окружения
Параметры, управляющие mallopt(), можно изменить и через переменные окружения. Использование этих переменных позволяет изменять работу программы без пересборки из исходного кода. В целях эффективной работы эти переменные должны быть определены до первого вызова функции выделения памяти (если этот же параметр изменяется через mallopt(), то вызов mallopt() имеет приоритет). В целях безопасности, эти переменные игнорируются для программ с установленными битами set-user-ID и set-group-ID.

Используются следующие переменные окружения (обратите внимание на подчёркивание в конце некоторых переменных):

MALLOC_ARENA_MAX

Управляет параметром M_ARENA_MAX, аналогично вызову mallopt().

MALLOC_ARENA_TEST

Управляет параметром M_ARENA_TEST, аналогично вызову mallopt().

MALLOC_CHECK_

Эта переменная окружения управляет тем же параметром что и mallopt() M_CHECK_ACTION. Если эта переменная установлена в ненулевое значение, то будет использоваться особенная реализация функций выделения памяти (это достигается использованием функции malloc_hook(3)). Эта реализация выполняет дополнительные проверки ошибок, но она медленнее чем стандартный набор функций выделения памяти (эта реализация не способна обнаружить все возможные ошибки; утечки памяти всё ещё возможны).

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

В целях безопасности по умолчанию переменная MALLOC_CHECK_ игнорируется для программ с установленными битами set-user-ID и set-group-ID. Однако, если существует файл /etc/suid-debug (содержимое файла не важно), то MALLOC_CHECK_ учитывается и для программ с установленными битами set-user-ID и set-group-ID.

MALLOC_MMAP_MAX_

Управляет параметром M_MMAP_MAX, аналогично вызову mallopt().

MALLOC_MMAP_THRESHOLD_

Управляет параметром M_MMAP_THRESHOLD, аналогично вызову mallopt().

MALLOC_PERTURB_

Управляет параметром M_PERTURB, аналогично вызову mallopt().

MALLOC_TRIM_THRESHOLD_

Управляет параметром M_TRIM_THRESHOLD, аналогично вызову mallopt().

MALLOC_TOP_PAD_

Управляет параметром M_TOP_PAD, аналогично вызову mallopt().

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
При успешном выполнении mallopt() возвращается 1. При ошибке возвращается 0.

## ОШИБКИ
При ошибке значение errno не изменяется.

## СООТВЕТСТВИЕ СТАНДАРТАМ
Данная функция не описана в POSIX или C. Подобная функция существует во многих ответвлениях System V, но значения param не совпадают. В SVID определены параметры M_MXFAST, M_NLBLKS, M_GRAIN и M_KEEP, но только первый из них реализован в glibc.

## ДЕФЕКТЫ
Неправильное значение param не вызывает ошибки.

Ошибка вычисления внутри реализации glibc означает, что вызов:

```
mallopt(M_MXFAST, n)
```

не приведёт к тому, что из fastbins будет выделяться память до размера n. Чтобы это сработало, n должно быть округлено до следующего множителя большего или равного (2k+1)*sizeof(size_t), где k — целое число.

Если mallopt() используется для установки M_PERTURB, то, как и ожидалось, байты свободной памяти инициализируются дополнением байта из value, и когда эта память освобождается, байты области инициализируются байтом, указанным в value. Однако, в реализации есть ошибка выхода за sizeof(size_t): вместо инициализации точного блока памяти освобождаемом вызовом free(p), блок начинает инициализироваться с p+sizeof(size_t).

## ПРИМЕР
Представленная далее программа показывает использование M_CHECK_ACTION. Если программе передаётся аргумент командной строки (целое число), то этот аргумент используется для установки значения параметра M_CHECK_ACTION. При этом программа выделяет блок памяти и освобождает его дважды (ошибка).

Следующий сеанс в оболочке показывает работу программы с glibc и значением по умолчанию для M_CHECK_ACTION:

```
$ ./a.out
main(): возвращение из первого вызова free()
*** glibc detected *** ./a.out: double free or corruption (top): 0x09d30008 ***
======= Backtrace: =========
/lib/libc.so.6(+0x6c501)[0x523501]
/lib/libc.so.6(+0x6dd70)[0x524d70]
/lib/libc.so.6(cfree+0x6d)[0x527e5d]
./a.out[0x80485db]
/lib/libc.so.6(__libc_start_main+0xe7)[0x4cdce7]
./a.out[0x8048471]
======= Memory map: ========
001e4000-001fe000 r-xp 00000000 08:06 1083555    /lib/libgcc_s.so.1
001fe000-001ff000 r--p 00019000 08:06 1083555    /lib/libgcc_s.so.1
[some lines omitted]
b7814000-b7817000 rw-p 00000000 00:00 0
bff53000-bff74000 rw-p 00000000 00:00 0          [stack]
Aborted (core dumped)
```

В этом запуске показаны результаты при других значениях M_CHECK_ACTION:

```
$ ./a.out 1             # показ ошибки и продолжение
main(): возвращение из первого вызова free()
*** glibc detected *** ./a.out: double free or corruption (top): 0x09cbe008 ***
main(): возвращение из второго вызова free()
$ ./a.out 2             # прерывание без показа ошибки
main(): возвращение из первого вызова free()
Aborted (core dumped)
$ ./a.out 0             # игнорирование ошибки и продолжение
main(): возвращение из первого вызова free()
main(): возвращение из второго вызова free()
```

При этом запуске показано как изменить тот же параметр с помощью переменной окружения MALLOC_CHECK_:

```
$ MALLOC_CHECK_=1 ./a.out
main(): возвращение из первого вызова free()
*** glibc detected *** ./a.out: free(): invalid pointer: 0x092c2008 ***
main(): возвращение из второго вызова free()
```

### Исходный код программы

```
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
int
main(int argc, char *argv[])
{

    char *p;

    if (argc > 1) {

        if (mallopt(M_CHECK_ACTION, atoi(argv[1])) != 1) {

            fprintf(stderr, "mallopt() завершилась с ошибкой");

            exit(EXIT_FAILURE);

        }

    }

    p = malloc(1000);

    if (p == NULL) {

        fprintf(stderr, "malloc() завершилась с ошибкой");

        exit(EXIT_FAILURE);

    }

    free(p);

    printf("main(): возвращение из первого вызова free()\n");

    free(p);

    printf("main(): возвращение из второго вызова free()\n");

    exit(EXIT_SUCCESS);
}
```

## СМОТРИТЕ ТАКЖЕ
mmap(2), sbrk(2), mallinfo(3), malloc(3), malloc_hook(3), malloc_info(3), malloc_stats(3), malloc_trim(3), mcheck(3), mtrace(3), posix_memalign(3)


matherr

title: matherr(3)

text:
# matherr(3)

## ИМЯ
matherr - библиотека SVID для обработки математических исключений

## ОБЗОР

```
#include <math.h>
```

```
int matherr(struct exception *exc);
```

```
extern _LIB_VERSION_TYPE _LIB_VERSION;
```

Компонуется при указании параметра -lm.

## ОПИСАНИЕ
Замечание: механизм, описанный на этой странице, больше не поддерживается glibc. До glibc 2.27 он был помечен как устаревший. Начиная с glibc 2.27, механизм был полностью удалён. В новых приложениях нужно использовать методы, описанные в math_error(7) и fenv(3). На этой странице описан механизм matherr() с целью сопровождения и переноса старых приложений.

В System V Interface Definition (SVID) определено какие математические функции должны вызывать функцию matherr(), если обнаруживается математическое исключение. Эта функция вызывает до возврата из самой математической функции; после возврата из matherr() система возвращается в математическую функцию, которая, в свою очередь, возвращает управление вызывающему.

Чтобы задействовать matherr(), программист должен определить макрос тестирования свойств _SVID_SOURCE (до включения каких-либо заголовочных файлов) и присвоить значение _SVID_ внешней переменной _LIB_VERSION.

Система предоставляет matherr() как версию по умолчанию. Эта версия ничего не делает возвращает ноль (назначение этого смотрите далее). Версия по умолчанию matherr() может быть перезаписана версией программиста, которая будет вызываться при возникновении исключений. Функция вызывается с одним аргументом, указателем на структуру exception, определённую следующим образом:

```
struct exception {

    int    type;      /* тип исключения */

    char  *name;      /* имя функции, вызвавшей исключение */

    double arg1;      /* 1-й аргумент функции */

    double arg2;      /* 2-й аргумент функции */

    double retval;    /* значение, возвращаемое функцией */
}
```

В поле type может быть одно из следующих значений:

DOMAIN

Произошла ошибка области (аргумент функции вне диапазона, для которого определена функция). Возвращаемое значение зависит от функции; errno присваивается EDOM.

SING

Произошла ошибка особой точки (результат функции равен бесконечности). Возвращаемое значение, в большинстве случаев, равно HUGE (самое большое число с плавающей запятой одинарной точности) с соответствующим знаком. В большинстве случаев, errno присваивается EDOM.

OVERFLOW

Возникло переполнение. В большинстве случаев, возвращается значение HUGE и errno присваивается ERANGE.

UNDERFLOW

Произошла потеря значимости. Возвращается 0.0 и errno присваивается ERANGE.

TLOSS

Полная потеря значимости. Возвращается 0.0 и errno присваивается ERANGE.

PLOSS

Частичная потеря значимости. Это значение не используется в glibc (и многих других системах).

Поля arg1 и arg2 это значения аргументов, переданных функции (arg2 не определено для функций, у которых только один аргумент).

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

Если функция matherr() возвращает ноль, то система изменяет errno как описано выше и может вывести сообщение об ошибке в стандартный поток ошибок (смотрите далее).

Если функция matherr() возвращает ненулевое значение, то система не изменяет errno и не печатает сообщение об ошибке.

### Математические функции, которые используют matherr()
В таблице далее перечислены функции и обстоятельства вызова matherr(). В столбце «тип» показано значение, назначаемое exc->type, когда вызывается matherr(). В столбце «результат» содержится возвращаемое значение по умолчанию. назначаемое exc->retval.

В столбцах «сообщение?» и «errno» описано поведение по умолчанию, если matherr() возвращает ноль. Если в «сообщение?» указано «y», то система выводит сообщение об ошибке в стандартный поток ошибок.

В таблице используются следующие обозначения и сокращения:

```
x        первый аргумент функции
y        второй аргумент функции
fin      конечное значение аргумента
neg      отрицательное значение аргумента
int      целочисленное значение аргумента
o/f      переполнение результата
u/f      потеря значимости результата
|x|      абсолютное значение x
X_TLOSS  константа, определённая в <math.h>
```

функция

тип

результат

Сообщение?

errno

acos(|x|>1)

DOMAIN

HUGE

y

EDOM

asin(|x|>1)

DOMAIN

HUGE

y

EDOM

atan2(0,0)

DOMAIN

HUGE

y

EDOM

acosh(x<1)

DOMAIN

NAN

y

EDOM

atanh(|x|>1)

DOMAIN

NAN

y

EDOM

atanh(|x|==1)

SING

(x>0.0)?

y

EDOM

HUGE_VAL :

-HUGE_VAL

cosh(fin) o/f

OVERFLOW

HUGE

n

ERANGE

sinh(fin) o/f

OVERFLOW

(x>0.0) ?

n

ERANGE

HUGE : -HUGE

sqrt(x<0)

DOMAIN

0.0

y

EDOM

hypot(fin,fin) o/f

OVERFLOW

HUGE

n

ERANGE

exp(fin) o/f

OVERFLOW

HUGE

n

ERANGE

exp(fin) u/f

UNDERFLOW

0.0

n

ERANGE

exp2(fin) o/f

OVERFLOW

HUGE

n

ERANGE

exp2(fin) u/f

UNDERFLOW

0.0

n

ERANGE

exp10(fin) o/f

OVERFLOW

HUGE

n

ERANGE

exp10(fin) u/f

UNDERFLOW

0.0

n

ERANGE

j0(|x|>X_TLOSS)

TLOSS

0.0

y

ERANGE

j1(|x|>X_TLOSS)

TLOSS

0.0

y

ERANGE

jn(|x|>X_TLOSS)

TLOSS

0.0

y

ERANGE

y0(x>X_TLOSS)

TLOSS

0.0

y

ERANGE

y1(x>X_TLOSS)

TLOSS

0.0

y

ERANGE

yn(x>X_TLOSS)

TLOSS

0.0

y

ERANGE

y0(0)

DOMAIN

-HUGE

y

EDOM

y0(x<0)

DOMAIN

-HUGE

y

EDOM

y1(0)

DOMAIN

-HUGE

y

EDOM

y1(x<0)

DOMAIN

-HUGE

y

EDOM

yn(n,0)

DOMAIN

-HUGE

y

EDOM

yn(x<0)

DOMAIN

-HUGE

y

EDOM

lgamma(fin) o/f

OVERFLOW

HUGE

n

ERANGE

lgamma(-int) или

SING

HUGE

y

EDOM

lgamma(0)

tgamma(fin) o/f

OVERFLOW

HUGE_VAL

n

ERANGE

tgamma(-int)

SING

NAN

y

EDOM

tgamma(0)

SING

copysign(

y

ERANGE

HUGE_VAL,x)

log(0)

SING

-HUGE

y

EDOM

log(x<0)

DOMAIN

-HUGE

y

EDOM

log2(0)

SING

-HUGE

n

EDOM

log2(x<0)

DOMAIN

-HUGE

n

EDOM

log10(0)

SING

-HUGE

y

EDOM

log10(x<0)

DOMAIN

-HUGE

y

EDOM

pow(0.0,0.0)

DOMAIN

0.0

y

EDOM

pow(x,y) o/f

OVERFLOW

HUGE

n

ERANGE

pow(x,y) u/f

UNDERFLOW

0.0

n

ERANGE

pow(NaN,0.0)

DOMAIN

x

n

EDOM

0**neg

DOMAIN

0.0

y

EDOM

neg**non-int

DOMAIN

0.0

y

EDOM

scalb() o/f

OVERFLOW

(x>0.0) ?

n

ERANGE

HUGE_VAL :

-HUGE_VAL

scalb() u/f

UNDERFLOW

copysign(

n

ERANGE

0.0,x)

fmod(x,0)

DOMAIN

x

y

EDOM

remainder(x,0)

DOMAIN

NAN

y

EDOM

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

matherr()

Безвредность в нитях

MT-Safe

## ПРИМЕР
В примере программы показано использование matherr() при вызове log(3). Программа имеет три аргумента командной строки. Первый аргумент — число с плавающей запятой, передаваемое в log(3). Если указан необязательный второй аргумент, то _LIB_VERSION присваивается значение _SVID_ для того, чтобы вызывалась matherr(), и указанное в командной строке целое число используется как возвращаемое значение matherr(). Если указан необязательный третий аргумент, то им определяется альтернативное возвращаемое значение, которое matherr() должна вернуть как результат математической функции.

Пример запуска, где в log(3) передаётся аргумент 0.0 и не используется matherr():

```
$ ./a.out 0.0
errno: Числовой результат вне представимого диапазона
x=-inf
```

В следующем примере вызывается функция matherr() и возвращает 0:

```
$ ./a.out 0.0 0
исключение matherr SING в функции log()

        арг:   0.000000, 0.000000

        возвр.знач.: -340282346638528859811704183484516925440.000000
log: SING error
errno: Числовой аргумент вне области функции
x=-340282346638528859811704183484516925440.000000
```

Сообщение «log: SING error» выдаётся библиотекой Си.

В следующем примере вызывается функция matherr() и возвращается не нулевое значение:

```
$ ./a.out 0.0 1
исключение matherr SING в функции log()

        арг:   0.000000, 0.000000

        возвр.знач.: -340282346638528859811704183484516925440.000000
x=-340282346638528859811704183484516925440.000000
```

В этом случае библиотека Си не печатает сообщение, и значение errno не изменяется.

В следующем примере вызывается функция matherr(), изменяется возвращаемое значение математической функции и возвращается ненулевое значение:

```
$ ./a.out 0.0 1 12345.0
исключение matherr SING в функции log()

        арг:   0.000000, 0.000000

        возвр.знач.: -340282346638528859811704183484516925440.000000
x=12345.000000
```

### Исходный код программы

```
#define _SVID_SOURCE
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
static int matherr_ret = 0;     /* значение, которое должна

                                    вернуть matherr() */
static int change_retval = 0;   /* должна ли matherr() изменять

                                   возвращаемое функцией значение? */
static double new_retval;       /* новое значение, возвращаемое

                                   функцией */
int
matherr(struct exception *exc)
{

    fprintf(stderr, "исключение matherr %s в функции %s()\n",

           (exc->type == DOMAIN) ?    "DOMAIN" :

           (exc->type == OVERFLOW) ?  "OVERFLOW" :

           (exc->type == UNDERFLOW) ? "UNDERFLOW" :

           (exc->type == SING) ?      "SING" :

           (exc->type == TLOSS) ?     "TLOSS" :

           (exc->type == PLOSS) ?     "PLOSS" : "???",

            exc->name);

    fprintf(stderr, "        арг:   %f, %f\n",

            exc->arg1, exc->arg2);

    fprintf(stderr, "        возвр.знач.: %f\n", exc->retval);

    if (change_retval)

        exc->retval = new_retval;

    return matherr_ret;
}
int
main(int argc, char *argv[])
{

    double x;

    if (argc < 2) {

        fprintf(stderr, "Использование: %s <арг>"

                " [<рез-matherr> [<рез-нов-функ>]]\n", argv[0]);

        exit(EXIT_FAILURE);

    }

    if (argc > 2) {

        _LIB_VERSION = _SVID_;

        matherr_ret = atoi(argv[2]);

    }

    if (argc > 3) {

        change_retval = 1;

        new_retval = atof(argv[3]);

    }

    x = log(atof(argv[1]));

    if (errno != 0)

        perror("errno");

    printf("x=%f\n", x);

    exit(EXIT_SUCCESS);
}
```

## СМОТРИТЕ ТАКЖЕ
fenv(3), math_error(7), standards(7)


mblen

title: mblen(3)

text:
# mblen(3)

## ИМЯ
mblen - вычисляет количество байтов в следующем многобайтовом символе

## ОБЗОР

```
#include <stdlib.h>
```

```
int mblen(const char *s, size_t n);
```

## ОПИСАНИЕ
Если s не равно NULL, то функция mblen() просматривает не более n байт в многобайтовой строке, начинающейся с s и извлекает следующий полный многобайтовый символ. Изменяется анонимное состояние сдвига, известное только функции mblen(). Если многобайтовый символ не является широким символом null, то возвращается количество байт, которые использовались из s. Если многобайтовый символ является широким символом null, то возвращается 0.

Если в n байтах, начиная с s, не содержится полного многобайтового символа, то mblen() возвращает -1. Это может произойти даже, если n больше или равно MB_CUR_MAX, если в многобайтовой строке содержится лишние сдвиговые последовательности.

Если многобайтовая строка, начинающаяся с s, содержит некорректную многобайтовую последовательность до следующего полного символа, то mblen() также возвращает -1.

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

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mblen() возвращает количество байт, просмотренных в многобайтовой последовательности, начинающейся с s, если при этом был распознан широкий символ не равный null. Она возвращает 0, если был получен широкий символ null. Она возвращает -1, если встречена некорректная многобайтовая последовательность или если невозможно найти полный многобайтовый символ.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mblen()

Безвредность в нитях

MT-Unsafe race

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mblen() зависит от категории LC_CTYPE текущей локали.

Функция mbrlen(3) предоставляет лучший интерфейс с теми же возможностями.

## СМОТРИТЕ ТАКЖЕ
mbrlen(3)


mbrlen

title: mbrlen(3)

text:
# mbrlen(3)

## ИМЯ
mbrlen - вычисляет количество байт в следующем многобайтовом символе

## ОБЗОР

```
#include <wchar.h>
```

```
size_t mbrlen(const char *s, size_t n, mbstate_t *ps);
```

## ОПИСАНИЕ
Функция mbrlen() просматривает не более n байт в многобайтовой строке, начинающейся с s и извлекает следующий полный многобайтовый символ. Она изменяет состояние сдвига *ps. Если многобайтовый символ не является широким символом null, то возвращается количество байт, которые использовались из s. Если многобайтовый символ является широким символом null, состояние сдвига *ps сбрасывается в начальное и возвращается 0.

Если в n байтах, начиная с s, не содержится полного многобайтового символа, то mbrlen() возвращает (size_t) -2. Это может произойти даже, если n >= MB_CUR_MAX, если в многобайтовой строке содержится лишние сдвиговые последовательности.

Если многобайтовая строка, начинающаяся с s, содержит некорректную многобайтовую последовательность до следующего полного символа, то mbrlen() возвращает (size_t) -1 и присваивает errno значение EILSEQ. В этом случае влияние на *ps не определено.

Если ps равно NULL, то используется статическое анонимное состояние, известное только функции mbrlen().

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mbrlen() возвращает количество байт, просмотренных в многобайтовой последовательности, начинающейся с s, если при этом был получен широкий символ не равный null. Она возвращает 0, если был получен широкий символ null. Она возвращает (size_t) -1 и присваивает errno значение EILSEQ, если встречена некорректная многобайтовая последовательность. Она возвращает (size_t) -2, если не удалось найти полную многобайтовую последовательность, что означает, что n должно быть увеличено.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbrlen()

Безвредность в нитях

MT-Unsafe race:mbrlen/!ps

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mbrlen() зависит от категории LC_CTYPE текущей локали.

## СМОТРИТЕ ТАКЖЕ
mbrtowc(3)


mbrtowc

title: mbrtowc(3)

text:
# mbrtowc(3)

## ИМЯ
mbrtowc - преобразовывает мультибайтовую последовательность в широкий символ

## ОБЗОР

```
#include <wchar.h>
```

```
size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps);
```

## ОПИСАНИЕ
В основном, функция предназначена для работы, когда s и pwc не равны NULL. В этом случае функция mbrtowc() просматривает не более n байт многобайтовой строки, начинающейся с s, извлекает следующий полный многобайтовый символ, преобразует его в широкий символ и сохраняет его в *pwc. При этом обновляется состояние сдвига *ps. Если преобразованный широкий символ не равен L'\0' (широкий символ null), то возвращается количество байт, которое было выбрано из s. Если преобразованный широкий символ равен L'\0', то состояние сдвига *ps сбрасывается в начальное состояние и возвращается 0.

Если в n байтах, начиная с s, не содержится полного многобайтового символа, то mbrtowc() возвращает (size_t) -2. Это может произойти даже, если n >= MB_CUR_MAX, если в многобайтовой строке содержится лишние сдвиговые последовательности.

Если многобайтовая строка, начинающаяся с s, содержит некорректную многобайтовую последовательность до следующего полного символа, то mbrtowc() возвращает (size_t) -1 и присваивает errno значение EILSEQ. В этом случае влияние на *ps не определено.

Ещё случай, когда s не равно NULL, а pwc равно NULL. В этом случае функция mbrtowc() действует как описано выше, но не сохраняет преобразованный широкий символ в памяти.

И третий случай, когда s равно NULL. В этом случае pwc и n игнорируются. Если состояние преобразования, представляемое *ps означает неполный многобайтовый символ, то функция mbrtowc() возвращает (size_t) -1, присваивает errno значение EILSEQ и оставляет *ps в неопределённом состоянии. Иначе функция mbrtowc() изменяет *ps в начальное состояние и возвращает 0.

Во всех вышеперечисленных случаях, если ps равно NULL, то используется статическое анонимное состояние, известное только функции mbrtowc(). Иначе *ps должен быть корректным объектом mbstate_t. Объект mbstate_t a может быть переведён в начальное состояние, если его обнулить, например с помощью

```
memset(&a, 0, sizeof(a));
```

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mbrtowc() возвращает количество байт, просмотренных в многобайтовой последовательности, начинающейся с s, если при этом был получен широкий символ не равный L'\0'. Она возвращает 0, если был получен широкий символ L'\0'. Она возвращает (size_t) -1 и присваивает errno значение EILSEQ, если встречена некорректная многобайтовая последовательность. Она возвращает (size_t) -2, если не удалось найти полную многобайтовую последовательность, что означает, что n должно быть увеличено.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbrtowc()

Безвредность в нитях

MT-Unsafe race:mbrtowc/!ps

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mbrtowc() зависит от категории LC_CTYPE текущей локали.

## СМОТРИТЕ ТАКЖЕ
mbsinit(3), mbsrtowcs(3)


mbsinit

title: mbsinit(3)

summary: проверяет начальное состояние сдвига

text:
# mbsinit(3)

## ИМЯ
mbsinit - проверяет начальное состояние сдвига

## ОБЗОР

```
#include <wchar.h>
```

```
int mbsinit(const mbstate_t *ps);
```

## ОПИСАНИЕ
Преобразование многобайтового представления символов в представление в виде широких символов (и наоборот) происходит с помощью состояния преобразования (тип mbstate_t). Преобразование строк происходит с помощью конечного автомата; если преобразование прерывается после некоторого количества символов, то может потребоваться сохранить состояние для обработки остальных символов. Это состояние преобразования необходимо, к примеру, для кодировок ISO-2022 и UTF-7.

Начальное состояние — это состояние в начале преобразования строки. Есть два типа состояния: первое используется функциями преобразования многобайтовых символов в широкие (mbsrtowcs(3)); второе используется функциями преобразования широких символов в многобайтовые (wcsrtombs(3)). Для начального состояния обоих типов используется тип mbstate_t.

Все состояния 8-битных кодировок соответствуют начальному состоянию. Для многобайтовых кодировок (UTF-8, EUC-*, BIG5 или SJIS) функции преобразования широкого символа в многобайтовый никогда не создают не исходные состояния, а функции преобразования многобайтового символа в широкий (например, mbrtowc(3)) создают не исходные состояния, если прерываются на середине символа.

Одним из способов создания mbstate_t в начальном состоянии является присвоение нулевого значения:

```
mbstate_t state;
memset(&state,0,sizeof(mbstate_t));
```

В Linux также работает и следующее, но может привести к появлению предупреждения компилятора:

```
mbstate_t state = { 0 };
```

Функция mbsinit() проверяет *ps на соответствие начальному состоянию.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mbsinit() возвращает ненулевое значение, если *ps находится в начальном состоянии, или если ps равно NULL. В противном случае возвращается 0.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbsinit()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mbsinit() зависит от категории LC_CTYPE текущей локали.

## СМОТРИТЕ ТАКЖЕ
mbrlen(3), mbrtowc(3), mbsrtowcs(3), wcrtomb(3), wcsrtombs(3)


mbsnrtowcs

title: mbsnrtowcs(3)

text:
# mbsnrtowcs(3)

## ИМЯ
mbsnrtowcs - преобразует многобайтовую строку в строку широких символов

## ОБЗОР

```
#include <wchar.h>
```

```
size_t mbsnrtowcs(wchar_t *dest, const char **src,
                  size_t nms, size_t len, mbstate_t *ps);
```

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

mbsnrtowcs():

Начиная с glibc 2.10:

_POSIX_C_SOURCE >= 200809L

До glibc 2.10:

_GNU_SOURCE

## ОПИСАНИЕ
Функция mbsnrtowcs() похожа на функцию mbsrtowcs(3), исключая то, что количество преобразуемых байт, начиная с *src, ограничено nms байтами.

Если dest не равно NULL, то функция mbsnrtowcs() преобразует не более nms байт многобайтовой строки *src в строку широких символов, начинающуюся с dest. В dest будет записано не более len символов. Обновляется состояние сдвига *ps. Эффективное выполнение преобразования осуществляется повторяющимися вызовами mbrtowc(dest, *src, n, ps), где n — некое положительное число, и пока вызов завершается успешно, увеличивая dest на единицу и *src на количество использованных байт. Преобразование может остановиться по трём причинам:

1.

Во входных данных обнаружена неправильная многобайтовая последовательность. В этом случае *src по-прежнему указывает на неправильную многобайтовую последовательность, возвращается (size_t) -1 и errno присваивается EILSEQ.

2.

Остановка происходит, если достигнуто ограничение nms или в dest было сохранено len не равных L'\0' широких символов. В этом случае *src продолжит указывать на следующую непреобразованную многобайтовую последовательность и будет возвращено количество широких символов, записанных в dest.

3.

Многобайтовая строка была полностью преобразована, включая завершающий широкий символ null ('\0') (побочный эффект: *ps возвращается в начальное состояние). В этом случае *src устанавливается равным NULL и возвращается количество широких символов, записанных в dest, не считая завершающего широкого символа null.

Если входной буфер заканчивается неполным символом, в POSIX.1 не указано где остановится преобразование — в конце предыдущего символа (если есть) или в конце входного буфера. В реализации glibc принят первый вариант.

Если значение dest равно NULL, то len игнорируется и преобразование выполняется как описано выше, исключая то, что преобразованные широкие символы не записываются в память и нет ограничения на длину строки назначения.

В обоих перечисленных случаях, если ps равно NULL, то используется статическое анонимное состояние, известное только функции mbsnrtowcs().

Программист должен проверить, что в dest есть место по крайней мере для len широких символов.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mbsnrtowcs() возвращает количество широких символов, которые составили преобразованную часть широкосимвольной строки, не включая конечный широкий символ null. Если обнаружена некорректная многобайтовая последовательность, то возвращается (size_t) -1, а errno присваивается EILSEQ.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbsnrtowcs()

Безвредность в нитях

MT-Unsafe race:mbsnrtowcs/!ps

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2008.

## ЗАМЕЧАНИЯ
Поведение mbsnrtowcs() зависит от категории LC_CTYPE текущей локали.

Передавать NULL в качестве ps небезопасно при работе с нитями.

## СМОТРИТЕ ТАКЖЕ
iconv(3), mbrtowc(3) mbsinit(3), mbsrtowcs(3)


mbsrtowcs

title: mbsrtowcs(3)

text:
# mbsrtowcs(3)

## ИМЯ
mbsrtowcs - преобразует многобайтовую строку в строку широких символов

## ОБЗОР

```
#include <wchar.h>
```

```
size_t mbsrtowcs(wchar_t *dest, const char **src,
                  size_t len, mbstate_t *ps);
```

## ОПИСАНИЕ
Если dest не равно NULL, то функция mbsrtowcs() преобразует многобайтовую строку *src в строку широких символов, начинающуюся с dest. В dest будет записано не более len символов. Обновляется состояние сдвига *ps. Эффективное выполнение преобразования осуществляется повторяющимися вызовами mbrtowc(dest, *src, n, ps), где n — некое положительное число, и пока вызов завершается успешно, увеличивая dest на единицу и *src на количество использованных байт. Преобразование может остановиться по трём причинам:

1.

Во входных данных обнаружена неправильная многобайтовая последовательность. В этом случае *src по-прежнему указывает на неправильную многобайтовую последовательность, возвращается (size_t) -1 и errno присваивается EILSEQ.

2.

В dest было сохранено len не равных L'\0' широких символов. В этом случае *src продолжит указывать на следующую непреобразованную многобайтовую последовательность и будет возвращено количество широких символов, записанных в dest.

3.

Многобайтовая строка была полностью преобразована, включая завершающий широкий символ null ('\0') (побочный эффект: *ps возвращается в начальное состояние). В этом случае *src устанавливается равным NULL и возвращается количество широких символов, записанных в dest, не считая завершающего широкого символа null.

Если значение dest равно NULL, то len игнорируется и преобразование выполняется как описано выше, исключая то, что преобразованные широкие символы не записываются в память и нет ограничения по длине.

В обоих перечисленных случаях, если ps равно NULL, то используется статическое анонимное состояние, известное только функции mbsrtowcs().

Программист должен проверить, что в dest есть место по крайней мере для len широких символов.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mbsrtowcs() возвращает количество широких символов, которые составили преобразованную часть широкосимвольной строки, не включая конечный широкий символ null. Если обнаружена некорректная многобайтовая последовательность, то возвращается (size_t) -1, а errno присваивается EILSEQ.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbsrtowcs()

Безвредность в нитях

MT-Unsafe race:mbsrtowcs/!ps

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mbsrtowcs() зависит от категории LC_CTYPE текущей локали.

Передавать NULL в качестве ps небезопасно при работе с нитями.

## СМОТРИТЕ ТАКЖЕ
iconv(3), mbrtowc(3), mbsinit(3), mbsnrtowcs(3), mbstowcs(3)


mbstowcs

title: mbstowcs(3)

text:
# mbstowcs(3)

## ИМЯ
mbstowcs - преобразует многобайтовую строку в строку широких символов

## ОБЗОР

```
#include <stdlib.h>
```

```
size_t mbstowcs(wchar_t *dest, const char *src, size_t n);
```

## ОПИСАНИЕ
Если значение dest не равно NULL, то функция mbstowcs() преобразует многобайтовую строку src в широкосимвольную строку начиная с dest. В dest будет записано не более n широких символов. Последовательность символов в строке src должна начинаться с начального состояния. Преобразование может прекратиться по трём причинам:

1.

Во входных данных находится неправильная многобайтовая последовательность. В этом случае возвращается (size_t) -1.

2.

В dest было сохранено n не равных L'\0' широких символов. В этом случае будет возвращено количество широких символов, записанных в dest, но состояние сдвига в этой точке теряется.

3.

Многобайтовая строка была полностью преобразована, включая завершающий символ null ('\0'). В этом случае возвращается количество записанных в dest широких символов, не считая завершающий широкий символ null.

Программист должен проверить, что в dest есть место по крайней мере для n широких символов.

Если значение dest равно NULL, то n игнорируется и преобразование выполняется как описано выше, исключая то, что преобразованные широкие символы не записываются в память и нет ограничения по длине.

Для того, чтобы избежать ограничения пункта 2, программист должен удостовериться, что значение n больше или равно mbstowcs(NULL,src,0)+1.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mbstowcs() возвращает количество широких символов, которые составили преобразованную часть широкосимвольной строки, не включая конечный широкий символ null Если обнаружена некорректная многобайтовая последовательность, то возвращается (size_t) -1.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbstowcs()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mbstowcs() зависит от категории LC_CTYPE текущей локали.

Функция mbsrtowcs(3) предоставляет лучший интерфейс с теми же возможностями.

## ПРИМЕР
В программе, представленной ниже, показано использование mbstowcs(), а также некоторые функции классификации широких символов. Пример запуска:

```
$ ./t_mbstowcs de_DE.UTF-8 Grüße!
Длина исходной строки (без конечного символа):

    8 байт

    6 многобайтовых символов
Строка широких символов: Grüße! (6 символов)

    G буква заглавная

    r буква строчная

    ü буква строчная

    ß буква строчная

    e буква строчная

    ! !буква
```

### Исходный код программы

```
#include <wctype.h>
#include <locale.h>
#include <wchar.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int
main(int argc, char *argv[])
{

    size_t mbslen;      /* количество многобайтовых символов в источнике */

    wchar_t *wcs;       /* указатель на преобразованную строку

                           широких символов */

    wchar_t *wp;

    if (argc < 3) {

        fprintf(stderr, "Использование: %s <локаль> <строка>\n", argv[0]);

        exit(EXIT_FAILURE);

    }

    /* применяем указанную локаль */

    if (setlocale(LC_ALL, argv[1]) == NULL) {

        perror("setlocale");

        exit(EXIT_FAILURE);

    }

    /* вычисляем длину, которая требуется для хранения argv[2],

       преобразованной в строку широких символов */

    mbslen = mbstowcs(NULL, argv[2], 0);

    if (mbslen == (size_t) -1) {

        perror("mbstowcs");

        exit(EXIT_FAILURE);

    }

    /* опишем исходную строку пользователю */

    printf("Длина исходной строки (без конечного символа):\n");

    printf("    %zu байт\n", strlen(argv[2]));

    printf("    %zu многобайтовых символов\n\n", mbslen);

    /* выделим место под строку широких символов желаемого размера.

       Добавим 1 для конечного широкого символа null (L'\0'). */

    wcs = calloc(mbslen + 1, sizeof(wchar_t));

    if (wcs == NULL) {

        perror("calloc");

        exit(EXIT_FAILURE);

    }

    /* преобразуем многобайтовую строку из argv[2] в

       строку широких символов */

    if (mbstowcs(wcs, argv[2], mbslen + 1) == (size_t) -1) {

        perror("mbstowcs");

        exit(EXIT_FAILURE);

    }

    printf("Строка широких символов: %ls (%zu символов)\n",

            wcs, mbslen);

    /* теперь посмотрим на классы символов в

       строке широких символов */

    for (wp = wcs; *wp != 0; wp++) {

        printf("    %lc ", (wint_t) *wp);

        if (!iswalpha(*wp))

            printf("!");

        printf("буква ");

        if (iswalpha(*wp)) {

            if (iswupper(*wp))

                printf("заглавная ");

            if (iswlower(*wp))

                printf("строчная ");

        }

        putchar('\n');

    }

    exit(EXIT_SUCCESS);
}
```

## СМОТРИТЕ ТАКЖЕ
mblen(3), mbsrtowcs(3), mbtowc(3), wcstombs(3), wctomb(3)


mbtowc

title: mbtowc(3)

text:
# mbtowc(3)

## ИМЯ
mbtowc - преобразовывает мультибайтовую последовательность в широкий символ

## ОБЗОР

```
#include <stdlib.h>
```

```
int mbtowc(wchar_t *pwc, const char *s, size_t n);
```

## ОПИСАНИЕ
Обычно в эту функцию передают s и pwc не равные NULL. В этом случае функция mbtowc() просматривает не более n байт многобайтовой строки, начиная с s, извлекает следующий полный многобайтовый символ, преобразует его в широкий символ и сохраняет его в *pwc. Она обновляет внутренне состояние сдвига, доступное только функции mbtowc(). Если s не указывает на байт null ('\0'), то она возвращает количество байт, которые были потрачены из s, в противном случае возвращается 0.

Если в n байтах, начиная с s, не содержится полного многобайтового символа или если в них содержится некорректный многобайтовый символ, то mbtowc() возвращает -1. Это может произойти даже если n >= MB_CUR_MAX, если в многобайтовой строке содержится лишние сдвиговые последовательности.

Ещё случай, когда s не равно NULL, а pwc равно NULL. В этом случае функция mbtowc() действует как описано выше, но не сохраняет преобразованный широкий символ в памяти.

И третий вариант, когда s равно NULL. В этом случае pwc и n игнорируются. Функция mbtowc() сбрасывает состояние сдвига, известное только ей, в начальное состояние и возвращает не ноль, если кодировка имеет непростое состояние сдвига, или ноль, если кодировка не имеет состояний.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Если s не равно NULL, то функция mbtowc() возвращает количество потраченных байт, начиная с s, или 0, если s указывает на байт null, или -1 — при ошибке.

Если значение s равно NULL, то функция mbtowc() возвращает не ноль, если кодировка имеет необычное смещение, или ноль, если кодировка не имеет смещения.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mbtowc()

Безвредность в нитях

MT-Unsafe race

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C99.

## ЗАМЕЧАНИЯ
Поведение mbtowc() зависит от категории LC_CTYPE текущей локали.

Данную функцию небезопасно использовать в нитях. Для этого лучше подходит функция mbrtowc(3) с тем же интерфейсом.

## СМОТРИТЕ ТАКЖЕ
MB_CUR_MAX(3), mblen(3), mbrtowc(3), mbstowcs(3), wcstombs(3), wctomb(3)


mcheck

title: mcheck(3)

summary: проверяет целостность

text:
# mcheck(3)

## ИМЯ
mcheck, mcheck_check_all, mcheck_pedantic, mprobe - проверяет целостность кучи

## ОБЗОР

```
#include <mcheck.h>
```

```
int mcheck(void (*abortfunc)(enum mcheck_status mstatus));
```

```
int mcheck_pedantic(void (*abortfunc)(enum mcheck_status mstatus));
```

```
void mcheck_check_all(void);
```

```
enum mcheck_status mprobe(void *ptr);
```

## ОПИСАНИЕ
Функция mcheck() устанавливает набор отладочных ловушек (hooks) на семейство функций выделения памяти malloc(3). Эти ловушки выполняют определённые проверки целостности состояния кучи. Проверками обнаруживаются следующие ошибки приложения: многократное освобождение одного блока памяти, повреждение структур данных служебной информации, расположенных непосредственно перед блоком выделенной памяти.

Для эффективной работы функция mcheck() должна вызываться перед первым вызовом malloc(3) или подобной функции. В случаях, когда это трудно проверить, компоновка программы с параметром -lmcheck вставляет неявный вызов mcheck() (с аргументом NULL) перед первым вызовом функции выделения памяти.

Функция mcheck_pedantic() похожа на mcheck(), но выполняет проверку всех выделенных блоков каждый раз, когда вызывается функция выделения памяти. Она может работать очень медленно!

Функция mcheck_check_all() выполняет немедленную проверку всех выделенных блоков. Этот вызов эффективно работает только, если перед этим была вызвана mcheck().

Если система обнаруживает целостность кучи, то вызывается функция, которую указал вызывающий в abortfunc с единственным аргументом mstatus, который показывает, какой тип рассогласованности обнаружен. Если abortfunc равно NULL, то функция по умолчанию печатает сообщение об ошибке в stderr и вызывает abort(3).

Функция mprobe() выполняет проверку целостности блока выделенной памяти, на который указывает ptr. Перед этим должна вызываться функция mcheck() (в противном случае mprobe() возвращает MCHECK_DISABLED).

Далее перечислены значения, возвращаемые mprobe() или передаваемые в аргументе mstatus при вызове abortfunc:

MCHECK_DISABLED (только mprobe())

Не вызвана функция mcheck() до первого вызова функции выделения памяти. Проверка несоответствий невозможна.

MCHECK_OK (только mprobe())

Никаких несоответствий не обнаружено.

MCHECK_HEAD

Память, предшествующая выделенному блоку, была затёрта.

MCHECK_TAIL

Память после выделенного блока была затёрта.

MCHECK_FREE

Блок памяти был освобожден дважды.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
При успешном выполнении mcheck() и mcheck_pedantic() возвращают 0, а в случае ошибки возвращают -1.

## ВЕРСИИ
Функции mcheck_pedantic() и mcheck_check_all() доступны начиная с glibc 2.2. Функции mcheck() и mprobe() появились, как минимум, начиная с glibc 2.0.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mcheck(), mcheck_pedantic(), mcheck_check_all(), mprobe()

Безвредность в нитях

MT-Unsafe race:mcheck const:malloc_hooks

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эти функции являются расширениями GNU.

## ЗАМЕЧАНИЯ
Компоновка программы с -lmcheck и использование переменной окружения MALLOC_CHECK_ (описана в mallopt(3)) обнаруживают ошибки схожим образом. Но при использовании MALLOC_CHECK_ не требуется перекомпоновывать приложение.

## ПРИМЕР
Программа, представленная ниже, вызывает mcheck() с аргументом NULL и затем освобождает один и тот же блок дважды. В следующем сеансе оболочки показано что случается при запуске программы:

```
$ ./a.out
Освобождаем
Освобождаем второй раз
блок освобождён дважды
Aborted (core dumped)
```

### Исходный код программы

```
#include <stdlib.h>
#include <stdio.h>
#include <mcheck.h>
int
main(int argc, char *argv[])
{

    char *p;

    if (mcheck(NULL) != 0) {

        fprintf(stderr, "ошибка mcheck()\n");

        exit(EXIT_FAILURE);

    }

    p = malloc(1000);

    fprintf(stderr, "Освобождаем\n");

    free(p);

    fprintf(stderr, "\nОсвобождаем второй раз\n");

    free(p);

    exit(EXIT_SUCCESS);
}
```

## СМОТРИТЕ ТАКЖЕ
malloc(3), mallopt(3), mtrace(3)


memccpy

title: memccpy(3)

summary: копирование участка памяти

text:
# memccpy(3)

## ИМЯ
memccpy - копирование участка памяти

## ОБЗОР

```
#include <string.h>
```

```
void *memccpy(void *dest, const void *src, int c, size_t n);
```

## ОПИСАНИЕ
Функция memccpy() копирует не более n байт из участка памяти src в участок памяти dest, останавливаясь, если найдётся символ c.

Если области памяти перекрываются, то результаты не определены.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memccpy() возвращает указатель на следующий символ в dest после c, или NULL, если c не найден в первых n символах src.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memccpy()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD.

## СМОТРИТЕ ТАКЖЕ
bcopy(3), bstring(3), memcpy(3), memmove(3), strcpy(3), strncpy(3)


memchr

title: memchr(3)

summary: выполняют поиск символа в памяти

text:
# memchr(3)

## ИМЯ
memchr, memrchr, rawmemchr - выполняют поиск символа в памяти

## ОБЗОР

```
#include <string.h>
```

```
void *memchr(const void *s, int c, size_t n);
```

```
void *memrchr(const void *s, int c, size_t n);
```

```
void *rawmemchr(const void *s, int c);
```

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

memrchr(), rawmemchr(): _GNU_SOURCE

## ОПИСАНИЕ
Функция memchr() сканирует первые n байт участка памяти, указанного в s, в поисках экземпляра c. Считается, что байты в памяти, указанной s, и значение c имеют тип unsigned char.

Функция memrchr() похожа на memchr(), за исключением того, что она ищет в участке n байт, указанных в s, не сначала, а с конца.

Функция rawmemchr() похожа на memchr(): она подразумевает (то есть программист в этом уверен), что экземпляр c точно находится где-то в памяти начало которой указано s, и при это производит оптимизированный поиск символа c (то есть, не используется счётчик для ограничения диапазона поиска). Если экземпляр c не найден, то результат непредсказуем. Следующий вызов является примером быстрого поиска завершающего строку байта null:

```
char *p = rawmemchr(s, '\0');
```

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функции memchr() и memrchr() возвращают указатель на совпавший байт, либо NULL, если в указанном участке памяти искомого байта нет.

Функция rawmemchr() возвращает указатель на совпавший байт (если он был обнаружен). Если совпадений не найдено, результат не определён.

## ВЕРСИИ
Функция rawmemchr() впервые появилась в glibc 2.1.

Функция memrchr() впервые появилась в glibc 2.2.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memchr(), memrchr(), rawmemchr()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
memchr(): POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD.

Функция memrchr() является расширением GNU, доступным в glibc начиная с версии 2.1.91.

Функция rawmemchr() является расширением GNU, доступным в glibc начиная с версии 2.1.

## СМОТРИТЕ ТАКЖЕ
bstring(3), ffs(3), index(3), memmem(3), rindex(3), strchr(3), strpbrk(3), strrchr(3), strsep(3), strspn(3), strstr(3), wmemchr(3)


memcmp

title: memcmp(3)

text:
# memcmp(3)

## ИМЯ
memcmp — сравнить области памяти

## ОБЗОР

```
#include <string.h>
```

```
int memcmp(const void *s1, const void *s2, size_t n);
```

## ОПИСАНИЕ
Функция memcmp() сравнивает первые n байт (каждый как unsigned char) из областей памяти s1 и s2.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memcmp() возвращает целое число меньше, равное, или выше нуля если первые n байт из s1 соответственно меньше, равны, или больше чем первые n байт из s2.

Для возвращаемого значения, отличного от нуля, его знак определяется знаком разности первой пары байтов (которые unsigned char) в s1 и s2.

Если n равно нулю, возвращаемое значение тоже ноль.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memcmp()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD.

## ЗАМЕЧАНИЯ
Не используйте memcmp() для сравнения важных с точки зрения безопасности данных, как например криптографические секреты, потому что для этой функции требуемое время CPU зависит от числа одинаковых байтов. Используйте функции, производящие сравнение за constant time. (Например в NetBSD функция consttime_memequal()). В POSIX подобная функция не предусмотрена.

## СМОТРИТЕ ТАКЖЕ
bcmp(3), bstring(3), strcasecmp(3), strcmp(3), strcoll(3), strncasecmp(3), strncmp(3), wmemcmp(3)


memcpy

title: memcpy(3)

summary: копирует участок памяти

text:
# memcpy(3)

## ИМЯ
memcpy - копирует участок памяти

## ОБЗОР

```
#include <string.h>
```

```
void *memcpy(void *dest, const void *src, size_t n);
```

## ОПИСАНИЕ
Функция memcpy() копирует n байт из участка памяти src в участок памяти dest. Адреса участков памяти не должны перекрываться друг другом. Если это неизбежно, используйте memmove(3).

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memcpy() возвращает указатель на dest.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memcpy()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD.

## ЗАМЕЧАНИЯ
Несоблюдение требования не перекрытия областей памяти является источником серьёзных ошибок (в стандартах POSIX и C явно указано, что выполнение memcpy() над перекрывающимися областями приводит к непредсказуемому поведению). Что особенно важно, в glibc 2.13 для оптимизации производительности memcpy() на некоторых платформах (включая x86-64) изменён порядок копирования байт из src в dest.

Это изменение привело к поломкам многих приложений, которые выполняли копирование перекрывающихся областей. В предыдущей реализации порядок, в котором копировались байты, случайно скрывал ошибку, который выявилась при изменении порядка копирования. В glibc 2.14 был добавлен символ версии для того, чтобы старые двоичные файлы (т.е., скомпонованные с версиями glibc до 2.14) вызывали реализацию memcpy(), которая безопасно обрабатывает случай перекрывающихся буферов (предоставляя «старую» реализацию memcpy(), которая была просто ещё одним именем memmove(3)).

## СМОТРИТЕ ТАКЖЕ
bcopy(3), bstring(3), memccpy(3), memmove(3), mempcpy(3), strcpy(3), strncpy(3), wmemcpy(3)


memfrob

title: memfrob(3)

summary: изменяет (зашифровывает) участок памяти

text:
# memfrob(3)

## ИМЯ
memfrob - изменяет (зашифровывает) участок памяти

## ОБЗОР

```
#define _GNU_SOURCE             /* смотрите feature_test_macros(7) */
#include <string.h>
```

```
void *memfrob(void *s, size_t n);
```

## ОПИСАНИЕ
Функция memfrob() шифрует первые n байт участка памяти s используя исключающее ИЛИ и число 42 для каждого символа. Этот же участок памяти можно привести в изначальное состояние повторно использовав memfrob().

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

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memfrob() возвращает указатель на зашифрованный участок памяти.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memfrob()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
memfrob() есть только в библиотеке GNU C.

## СМОТРИТЕ ТАКЖЕ
bstring(3), strfry(3)


memmem

title: memmem(3)

summary: ищет подстроку

text:
# memmem(3)

## ИМЯ
memmem - ищет подстроку

## ОБЗОР

```
#define _GNU_SOURCE         /* смотрите feature_test_macros(7) */
#include <string.h>
```

```
void *memmem(const void *haystack, size_t haystacklen,
             const void *needle, size_t needlelen);
```

## ОПИСАНИЕ
Функция memmem() ищет начало первого появления подстроки needle длинной needlelen в области памяти haystack размером haystacklen.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memmem() возвращает указатель на начало подстроки или NULL, если подстрока не найдена.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memmem()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эта функция не определена в POSIX.1, однако доступна в некоторых других системах.

## ДЕФЕКТЫ
В glibc 2.0, если needle пусто, то memmem() возвращает указатель на последний байт haystack. Это исправлено в glibc 2.1.

## СМОТРИТЕ ТАКЖЕ
bstring(3), strstr(3)


memmove

title: memmove(3)

summary: копирует область памяти

text:
# memmove(3)

## ИМЯ
memmove - копирует область памяти

## ОБЗОР

```
#include <string.h>
```

```
void *memmove(void *dest, const void *src, size_t n);
```

## ОПИСАНИЕ
Функция memmove() копирует n байт из участка памяти src в dest. Адреса участков могут перекрываться — в этом случае из src байты копируются во временный массив, который не пересекается с src или dest, после чего они копируются из него в dest.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memmove() возвращает указатель на dest.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memmove()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD.

## СМОТРИТЕ ТАКЖЕ
bcopy(3), bstring(3), memccpy(3), memcpy(3), strcpy(3), strncpy(3), wmemmove(3)


mempcpy

title: mempcpy(3)

text:
# mempcpy(3)

## ИМЯ
mempcpy, wmempcpy — копирует участок памяти

## ОБЗОР

```
#define _GNU_SOURCE         /* смотрите feature_test_macros(7) */
#include <string.h>
```

```
void *mempcpy(void *dest, const void *src, size_t n);
#define _GNU_SOURCE         /* смотрите feature_test_macros(7) */
#include <wchar.h>
```

```
wchar_t *wmempcpy(wchar_t *dest, const wchar_t *src, size_t n);
```

## ОПИСАНИЕ
Функция mempcpy() почти идентична memcpy(3). Она копирует n байт из src в dest, но вместо возвращения значения dest, она возвращает указатель на байт, следующий за последним записанным байтом.

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

wmempcpy() делает тоже самое, но принимает wchar_t тип аргументов и копирует n широких символов.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
dest + n.

## ВЕРСИИ
Впервые mempcpy() появилась в glibc версии 2.1.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mempcpy(), wmempcpy()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
Эта функция является расширением GNU.

## ПРИМЕР

```
void *
combine(void *o1, size_t s1, void *o2, size_t s2)
{

    void *result = malloc(s1 + s2);

    if (result != NULL)

        mempcpy(mempcpy(result, o1, s1), o2, s2);

    return result;
}
```

## СМОТРИТЕ ТАКЖЕ
memccpy(3), memcpy(3), memmove(3), wmemcpy(3)


memset

title: memset(3)

text:
# memset(3)

## ИМЯ
memset - заполнение памяти значением определённого байта

## ОБЗОР

```
#include <string.h>
```

```
void *memset(void *s, int c, size_t n);
```

## ОПИСАНИЕ
Функция memset() заполняет n байт участка памяти, адрес начала которого находится в указателе s, значением байта c.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция memset() возвращает указатель на участок памяти s.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

memset()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008, C89, C99, SVr4, 4.3BSD.

## СМОТРИТЕ ТАКЖЕ
bstring(3), bzero(3), swab(3), wmemset(3)


mkdtemp

title: mkdtemp(3)

text:
# mkdtemp(3)

## ИМЯ
mkdtemp - создание временного каталога с уникальным именем

## ОБЗОР

```
#include <stdlib.h>
```

```
char *mkdtemp(char *template);
```

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

mkdtemp():

/* Начиная с glibc 2.19: */ _DEFAULT_SOURCE

|| /* glibc 2.19 и старше: */ _BSD_SOURCE

|| /* начиная с glibc 2.10: */ _POSIX_C_SOURCE >= 200809L

## ОПИСАНИЕ
Функция mkdtemp() создаёт временный каталог с уникальным именем на основе template. Последние шесть символов template должны быть равны XXXXXX; они будут заменены на строку, которая и сделает имя каталога уникальным. После этого будет создан каталог с правами 0700. Так как template меняется, он не должен быть строковой константой, а должен быть объявлен как массив символов.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
В случае успеха mkdtemp() возвращает указатель на изменённую строку шаблона (template), в случае неудачи — NULL, при этом errno устанавливается в соответствующее значение.

## ОШИБКИ
EINVAL

Последние шесть символов template не равны XXXXXX. template не изменён.

См. также в mkdir(2) другие возможные значения errno.

## ВЕРСИИ
Доступна в glibc с версии 2.1.91.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mkdtemp()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2008. Данная функция есть в реализациях BSD.

## СМОТРИТЕ ТАКЖЕ
mktemp(1), mkdir(2), mkstemp(3), mktemp(3), tempnam(3), tmpfile(3), tmpnam(3)


mkfifo

title: mkfifo(3)

text:
# mkfifo(3)

## ИМЯ
mkfifo, mkfifoat - создают специальный файл очереди FIFO (именованный канал)

## ОБЗОР

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

```
int mkfifo(const char *pathname, mode_t mode);
#include <fcntl.h>           /* определения констант AT_* */
#include <sys/stat.h>
```

```
int mkfifoat(int dirfd, const char *pathname, mode_t mode);
```

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

mkfifoat():

Начиная с glibc 2.10:

_POSIX_C_SOURCE >= 200809L

До glibc 2.10:

_ATFILE_SOURCE

## ОПИСАНИЕ
Функция mkfifo() создаёт специальный файл FIFO с именем pathname и правами доступа mode. Как обычно, в правах учитывается значение umask процесса: права на создаваемый файл вычисляются как (mode & ~umask).

Специальный файл FIFO подобен каналу, за исключением того, что он создаётся другим способом. Вызов mkfifo() вместо безымянного канала взаимодействия создаёт специальный файл FIFO, расположенный в файловой системе.

После создания специального файла FIFO, любой процесс может открывать его для чтения или записи, как если бы он открывал обычный файл. Однако прежде чем вы сможете что-либо сделать, его необходимо открыть с обоих концов, притом одновременно. Открытие FIFO для чтения обычно блокируется, пока какой-нибудь другой процесс не откроет его для записи, и наоборот. Описание работы со специальными файлами FIFO в неблокирующем режиме смотрите в fifo(7).

### mkfifoat()
Функция mkfifoat() работает также как как mkfifo(), за исключением случаев, описанных здесь.

Если в pathname задан относительный путь, то он считается относительно каталога, на который ссылается файловый дескриптор dirfd (а не относительно текущего рабочего каталога вызывающего процесса, как это делается в mkfifo(3)).

Если в pathname задан относительный путь и dirfd равно специальному значению AT_FDCWD, то pathname рассматривается относительно текущего рабочего каталога вызывающего процесса (как mkfifo(3)).

Если в pathname задан абсолютный путь, то dirfd игнорируется.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
При успешном выполнении вызовы mkfifo() и mkfifoat() возвращают 0. В случае ошибки возвращают -1, а errno устанавливается в соответствующее значение.

## ОШИБКИ
EACCES

Один из каталогов содержащихся в pathname не позволяет выполнить поиск, так как правами запрещено исполнение.

EDQUOT

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

EEXIST

pathname уже существует. В этом случае pathname может быть символьной ссылкой, повисшей или нет.

ENAMETOOLONG

Если длина полного имени файла (включая путь) pathname больше чем PATH_MAX или длина имени файла больше чем NAME_MAX. В общем случае в системах, соответствующих стандарту GNU, отсутствует ограничение на длину полного имени файла, однако некоторые файловые системы могут устанавливать ограничение на длину отдельного компонента.

ENOENT

Один из каталогов в pathname не существует или является повисшей символьной ссылкой.

ENOSPC

В каталоге или файловой системе закончились места для новых файлов.

ENOTDIR

Компонент пути, использованный как каталог в pathname, в действительности таковым не является.

EROFS

pathname указывает на файловую систему, доступную только для чтения.

Следующие дополнительные ошибки могут быть характерны для mkfifoat():

EBADF

dirfd не является правильным файловым дескриптором.

ENOTDIR

pathname является относительным путем, а dirfd является файловым дескриптором, указывающим на файл, отличный от каталога.

## ВЕРСИИ
Функция mkfifoat() была добавлена в glibc 2.4. Она реализована с помощью системного вызова mknodat(2), доступного в ядре Linux начиная с версии 2.6.16.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mkfifo(), mkfifoat()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
mkfifo(): POSIX.1-2001, POSIX.1-2008.

mkfifoat(): POSIX.1-2008.

## СМОТРИТЕ ТАКЖЕ
mkfifo(1), close(2), open(2), read(2), stat(2), umask(2), write(2), fifo(7)


mkstemp

title: mkstemp(3)

summary: создаёт временный файл с уникальным

text:
# mkstemp(3)

## ИМЯ
mkstemp, mkostemp, mkstemps, mkostemps - создаёт временный файл с уникальным именем

## ОБЗОР

```
#include <stdlib.h>
```

```
int mkstemp(char *template);
```

```
int mkostemp(char *template, int flags);
```

```
int mkstemps(char *template, int suffixlen);
```

```
int mkostemps(char *template, int suffixlen, int flags);
```

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

mkstemp():

_XOPEN_SOURCE >= 500

|| /* начиная с glibc 2.12: */ _POSIX_C_SOURCE >= 200809L

|| /* версии glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE

mkostemp(): _GNU_SOURCE

mkstemps():

/* glibc начиная с 2.19: */ _DEFAULT_SOURCE

|| /* версии glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE

mkostemps(): _GNU_SOURCE

## ОПИСАНИЕ
Функция mktemp() генерирует на основе шаблона template уникальное имя для временного файла, создаёт и открывает файл, после чего возвращает дескриптор открытого файла.

Последние шесть символов template должны быть равны "XXXXXX", они будут заменены на строку, которая сделает имя файла уникальным. Так как template будет меняться, он должна быть объявлен не строковой константой, а массивом символов.

Файл создается с правами 0600, то есть читать и записывать в него может только владелец. Возвращаемый дескриптор файла предоставляет доступ к файлу как на чтение, так и на запись. Файл открывается с помощью open(2) с флагом O_EXCL, что гарантирует, что вызывающий является процессом, создавшим файл.

Функция mkostemp() подобна mkstemp(), но отличие в том, что следующие биты (с теми же значениями что и для open(2)) могут быть указаны в flags: O_APPEND, O_CLOEXEC и O_SYNC. Заметим, что при создании файла mkostemp() включает значения O_RDWR, O_CREAT и O_EXCL в аргумент flags при вызове open(2); добавлять эти значения в аргумент flags при вызове mkostemp() необязательно и это приводит к ошибках в некоторых системах.

Функция mkstemps() похожа на mkstemp(), за исключением строки в template, которая содержит символы суффикса suffixlen. Таким образом, template будет приобретать вид prefixXXXXXXsuffix, а строка XXXXXX будет меняться так же, как и для mkstemp().

Функция mkostemps() является аналогом mkstemps(), подобно как mkostemp() является аналогом mkstemp().

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
При успешном выполнении данные функции возвращают дескриптор временного файла. В случае ошибки возвращается -1, а errno устанавливается в соответствующее значение.

## ОШИБКИ
EEXIST

Невозможно создать уникальное имя временного файла. Содержимое template теперь не определено.

EINVAL

Для mkstemp() и mkostemp(): последние шесть символов template не равны XXXXXX. template не изменён.

Для mkstemps() и mkostemps(): количество символов template меньше, чем (6 + suffixlen) или последние 6 символов до суффикса в template не равны XXXXXX.

Данные функции также могут завершиться ошибками, описанными в open(2).

## ВЕРСИИ
mkostemp() впервые появилась в glibc 2.7. mkstemps() и mkostemps() доступны в glibc с версии 2.11.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mkstemp(), mkostemp(), mkstemps(), mkostemps()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
mkstemp(): 4.3BSD, POSIX.1-2001.

mkstemps() не стандартизована, однако может присутствовать на некоторых системах.

mkostemp() и mkstemp(): являются расширениями glibc.

## ЗАМЕЧАНИЯ
В версиях glibc 2.06 и ниже файл создавался с правами 0666, то есть читать и записывать в него могли все пользователи. Это старое поведение может быть небезопасным, особенно когда в других UNIX используются права 0600, и кто-то может не заметить это отличие при переносе программы. В POSIX.1-2008 добавлено требование, что файл должен создаваться с правами 0600.

В более общем смысле, в спецификации POSIX для mkstemp() ничего не сказано о правах на файл, поэтому программа должна сама проверить до вызова mkstemp() (и mkostemp()), что маска создания файла (смотрите umask(2)) уставлена в правильное значение.

## СМОТРИТЕ ТАКЖЕ
mkdtemp(3), mktemp(3), tempnam(3), tmpfile(3), tmpnam(3)


mktemp

title: mktemp(3)

text:
# mktemp(3)

## ИМЯ
mktemp - создаёт уникальное имя для временного файла

## ОБЗОР

```
#include <stdlib.h>
```

```
char *mktemp(char *template);
```

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

mktemp():

Начиная с glibc 2.12:

(_XOPEN_SOURCE >= 500) && ! (_POSIX_C_SOURCE >= 200112L)

|| /* Glibc начиная с 2.19: */ _DEFAULT_SOURCE

|| /* Glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE

До glibc 2.12:

_BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE >= 500

## ОПИСАНИЕ
Никогда не используйте эту функцию; см. ДЕФЕКТЫ

Функция mktemp() генерирует на основе шаблона template уникальное имя для временного файла. Последние шесть символов template должны быть равны XXXXXX, они будут заменены на строку, которая сделает имя файла уникальным. Так как template будет меняться, он должен быть объявлен не строковой константой, а массивом символов.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Функция mktemp() всегда возвращает template. При создании уникального имени последние шесть байтов template заменяются так, что имя становится уникальным (то есть, такого имени ещё нет). Если уникальное имя невозможно создать, template будет равно пустой строке, а errno будет назначен код ошибки.

## ОШИБКИ
EINVAL

Последние шесть символов template не равны XXXXXX.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mktemp()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
4.3BSD, POSIX.1-2001. В POSIX.1-2008 спецификация mktemp() удалена.

## ДЕФЕКТЫ
Никогда не используйте mktemp(). Некоторые реализации следуют 4.3BSD и заменяют XXXXXX текущим ID процесса и одним символом, поэтому может быть возвращено только 26 уникальных имен. С одной стороны такие имена легко подобрать, а с другой есть вероятность возникновения состязательности при проверке существования имени и открытия файла, поэтому каждое использование mktemp() является угрозой безопасности. Состязательность не может возникнуть, если использовать функции mkstemp(3) и mkdtemp(3).

## СМОТРИТЕ ТАКЖЕ
mktemp(1), mkdtemp(3), mkstemp(3), tempnam(3), tmpfile(3), tmpnam(3)


modf

title: modf(3)

text:
# modf(3)

## ИМЯ
modf, modff, modfl - извлекает целое и дробное значение со знаком из числа с плавающей запятой

## ОБЗОР

```
#include <math.h>
```

```
double modf(double x, double *iptr);
float modff(float x, float *iptr);
long double modfl(long double x, long double *iptr);
```

Компонуется при указании параметра -lm.

Требования макроса тестирования свойств для glibc (смотрите feature_test_macros(7)):

modf(), modfl():

_ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L

|| /* начиная с glibc 2.19: */ _DEFAULT_SOURCE

|| /* версии glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE

## ОПИСАНИЕ
Эти функции разбивают аргумент x на целую и дробную части, каждая из которых имеет такой же знак, как и x. Целая часть сохраняется месте, на которое указывает iptr.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
Данные функции возвращают дробную часть от x.

Если x имеет значение NaN, будет возвращено NaN и *iptr установится в NaN.

Если x стремится к плюс или минус бесконечности, будет возвращено значение +0 (-0) и *iptr установится в плюс или минус бесконечность.

## ОШИБКИ
Ошибки не возникают.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

modf(), modff(), modfl()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
C99, POSIX.1-2001, POSIX.1-2008.

Вариант, возвращающий значение типа double, также соответствует SVr4, 4.3BSD, C89.

## СМОТРИТЕ ТАКЖЕ
frexp(3), ldexp(3)


mpool

title: mpool(3)

summary: общий массив буферов памяти

text:
# mpool(3)

## ИМЯ
mpool - общий массив буферов памяти

## ОБЗОР

```
#include <db.h>
#include <mpool.h>
```

```
MPOOL *mpool_open(DBT *key, int fd, pgno_t pagesize, pgno_t maxcache);
```

```
void mpool_filter(MPOOL *mp, void (*pgin)(void *, pgno_t, void *),
                  void (*pgout)(void *, pgno_t, void *),
                  void *pgcookie);
```

```
void *mpool_new(MPOOL *mp, pgno_t *pgnoaddr);
```

```
void *mpool_get(MPOOL *mp, pgno_t pgno, unsigned int flags);
```

```
int mpool_put(MPOOL *mp, void *pgaddr, unsigned int flags);
```

```
int mpool_sync(MPOOL *mp);
```

```
int mpool_close(MPOOL *mp);
```

## ОПИСАНИЕ
Примечание: В этой странице описаны интерфейсы, предоставляемые glibc до версии 2.1. Начиная с версии 2.2, glibc больше не поддерживает эти интерфейсы. Вероятно, вы ищите API, предоставляемое библиотекой libdb.

Целью библиотечного интерфейса mpool является обеспечение управления буферными страницами файлов. Буферы могут использоваться несколькими процессами.

Функция mpool_open() инициализирует массив памяти. Параметр key является строкой байтов для согласования процессов, желающих совместно использовать буферы. Если файловые буферы отображены в общей памяти, то все процессы, использующие данный одинаковый параметр, будут совместно использовать буферы. Если параметр key равен NULL, то буферы отображаются в локальной (private) памяти. Параметр fd является файловым дескриптором связанного файла, который должен быть доступен для поиска. Если значение key не равно NULL и совпадает с уже отображённым файлом, то параметр fd игнорируется.

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

Функция mpool_filter() предназначена для создания прозрачной обработки операций ввода и вывода доступных страниц. Если задана функция pgin, то она вызывается каждый раз, когда данные буфера считываются в память массива из внешнего файла. Если задана функция pgout, то она вызывается каждый раз, когда данные буфера записываются во внешний файл. Обе функции вызываются с указателем pgcookie, номером страницы и указателем на страницу, используемую для чтения или записи.

Параметрами функции mpool_new() являются указатель MPOOL и адрес. Если может быть выделена новая страница, то возвращается указатель на страницу и номер страницы сохраняется по адресу pgnoaddr. В противном случае возвращается NULL и изменяется errno.

Параметрами функции mpool_get() являются указатель и номер страницы. Если страница существует, то возвращается указатель на страницу. Иначе возвращается NULL и меняется значение переменной errno. Параметр flags пока не используется.

Функция mpool_put() открепляет страницу, на которую указывает pgaddr. В pgaddr должен быть указан адрес, который был возвращён mpool_get() или mpool_new() ранее. Значением флага являются любые объединённые следующие значения:

MPOOL_DIRTY

Страница была изменена и должна быть записана обратно в файл.

При успешном выполнении функция mpool_put() возвращает 0, а при ошибках возвращает -1.

Функция mpool_sync() записывает все изменённые страницы, связанные с указателем MPOOL, обратно в файл. При успешном выполнении mpool_sync() возвращает 0 и -1 при ошибке.

Функция mpool_close() освобождает любую выделенную память, связанную с идентификатором массива памяти. Изменённые страницы не записываются обратно в файл. При успешном выполнении mpool_close() возвращает 0 и -1 при ошибке.

## ОШИБКИ
При ошибках функция mpool_open() устанавливает значение errno равным какому-либо значению из определённых в malloc(3).

При ошибках функция mpool_get() устанавливает значение errno по следующим причинам:

EINVAL

Запрошенная запись не существует.

При ошибках функции mpool_new() и mpool_get присваивают переменной errno любое значение из определённых в библиотечных функциях read(2), write(2) и malloc(3).

При ошибках функция mpool_sync() устанавливает значение errno равным значению ошибки из определённых в библиотеке для write(2).

При ошибках функция mpool_close() устанавливает значение errno равным значению ошибки из определённых в библиотеке для free(3).

## СООТВЕТСТВИЕ СТАНДАРТАМ
Не является частью POSIX.1. Присутствует в BSD.

## СМОТРИТЕ ТАКЖЕ
btree(3), dbopen(3), hash(3), recno(3)


title: mq_close(3)

summary: закрывает дескриптор очереди сообщений

text:
# mq_close(3)

## ИМЯ
mq_close - закрывает дескриптор очереди сообщений

## ОБЗОР

```
#include <mqueue.h>
```

```
int mq_close(mqd_t mqdes);
```

Компонуется при указании параметра -lrt.

## ОПИСАНИЕ
mq_close() закрывает дескриптор очереди сообщений mqdes.

Если к вызывающему процессу присоединён запрос уведомления (смотрите (mq_notify(3)) от этой очереди сообщений через mqdes, то этот запрос удаляется, и теперь другой процесс может присоединить запрос уведомлений.

## ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
При успешном выполнении mq_close() возвращается 0; при ошибке возвращается -1, а в errno помещается код ошибки.

## ОШИБКИ
EBADF

В mqdes размещён некорректный дескриптор очереди сообщений.

## АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).

Интерфейс

Атрибут

Значение

mq_close()

Безвредность в нитях

MT-Safe

## СООТВЕТСТВИЕ СТАНДАРТАМ
POSIX.1-2001, POSIX.1-2008.

## ЗАМЕЧАНИЯ
Все открытые очереди сообщений автоматически закрываются при завершении процесса или после execve(2).

## СМОТРИТЕ ТАКЖЕ
mq_getattr(3), mq_notify(3), mq_open(3), mq_receive(3), mq_send(3), mq_unlink(3), mq_overview(7)