Купить книги Пять элементов благополучия Чек-лист. Как избежать глупых ошибок, ведущих к фатальным последствиям Телефоны Бизбук - c 10 до 18 по будним дням
 
Наши проекты:
Вход для зарегистрированных пользователей
Регистрация нового пользователя
Главная Новинки Анонсы Мои заказы Рассылка Оплата и Доставка Контакты
АУДИОКНИГИ ПО БИЗНЕСУ ЭКОНОМИЧЕСКАЯ ЛИТЕРАТУРА КОМПЬЮТЕРНАЯ ЛИТЕРАТУРА ДЕТСКАЯ ЛИТЕРАТУРА
ДОМ, БЫТ, ДОСУГ ЕСТЕСТВЕННЫЕ НАУКИ ИНОСТРАННЫЕ ЯЗЫКИ ИСКУССТВО, ЖИВОПИСЬ
ОБЩЕСТВЕННЫЕ И ГУМАНИТАРНЫЕ НАУКИ ПОДАРОЧНАЯ ЛИТЕРАТУРА ПСИХОЛОГИЯ ТЕХНИЧЕСКАЯ ЛИТЕРАТУРА
ХУДОЖЕСТВЕННАЯ и ПОПУЛЯРНАЯ ЛИТЕРАТУРА ЭЛЕКТРОНИКА РАСПРОДАЖА. СУПЕРСКИДКИ !!!  
Вы находитесь в разделе каталога:
• Linux API. Исчерпывающее руководство, Майкл Керриск

Linux API. Исчерпывающее руководство
Книга Linux API. Исчерпывающее руководство
Майкл Керриск
Год выпуска: 2018
Изд-во: Питер
ISBN: 978-5-496-02689-5
Переплёт: твердый
1248 страниц
Цена: 1525.00 грн.
Есть в наличии
в корзину

Instant Purshare Только 1 книга
Доставка: по Киеву - в течение суток*
                по Украине - от 2 до 10 суток*
"Linux API. Исчерпывающее руководство" - масштабное издание по программированию приложений для Linux и UNIX. Описанный здесь интерфейс применяется практически с любыми приложениями, работающими в операционных системах Linux или UNIX.

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



Оглавление книги Майкл Керриск "Linux API. Исчерпывающее руководство"



Предисловие..................................................................................................................26
Цель книги...........................................................................................................................................................26
Для кого эта книга.............................................................................................................................................26
Linux и UNIX.......................................................................................................................................................27
Структура книги................................................................................................................................................27
Примеры программ...........................................................................................................................................28
Упражнения................................................................................................................................................29
Стандарты и портируемость..................................................................................................................29
Ядро Linux и версии библиотеки C....................................................................................................29
Использование программного интерфейса других языков программирования.................30
Об авторе..............................................................................................................................................................30
Благодарности.....................................................................................................................................................31
Разрешения..........................................................................................................................................................36
Обратная связь...................................................................................................................................................36
Глава 1. История и стандарты..........................................................................................37
1.1. Краткая история UNIX и языка C.......................................................................................................37
1.2. Краткая история Linux.............................................................................................................................41
1.2.1. Проект GNU.....................................................................................................................................41
1.2.2. Ядро Linux........................................................................................................................................42
1.3. Стандартизация..........................................................................................................................................46
1.3.1. Язык программирования C.........................................................................................................46
1.3.2. Первые стандарты POSIX...........................................................................................................47
1.3.3. X/Open Company и Open Group...............................................................................................49
1.3.4. SUSv3 и POSIX.1-2001................................................................................................................49
1.3.5. SUSv4 и POSIX.1-2008................................................................................................................51
1.3.6. Этапы развития стандартов UNIX...........................................................................................52
1.3.7. Стандарты реализаций.................................................................................................................53
1.3.8. Linux, стандарты и нормативная база Linux.........................................................................54
1.4. Резюме............................................................................................................................................................55
Глава 2. Основные понятия.............................................................................................57
2.1. Основа операционной системы: ядро..................................................................................................57
2.2. Оболочка.......................................................................................................................................................60
2.3. Пользователи и группы............................................................................................................................61
2.4. Иерархия одного каталога. Что такое каталоги, ссылки и файлы............................................62
2.5. Модель файлового ввода-вывода.........................................................................................................65
2.6. Программы...................................................................................................................................................66
2.7. Процессы.......................................................................................................................................................67
2.8. Отображение в памяти.............................................................................................................................71
2.9. Статические и совместно используемые библиотеки...................................................................71
2.10. Межпроцессное взаимодействие и синхронизация.....................................................................72
2.11. Сигналы.......................................................................................................................................................73
2.12. Потоки.........................................................................................................................................................74
2.13. Группы процессов и управление заданиями в оболочке............................................................74
2.14. Сессии, управляющие терминалы и управляющие процессы.................................................75
2.15. Псевдотерминалы....................................................................................................................................75
2.16. Дата и время...............................................................................................................................................76
2.17. Клиент-серверная архитектура...........................................................................................................76
2.18. Выполнение действий в реальном масштабе времени................................................................77
2.19. Файловая система /proc........................................................................................................................78
2.20. Резюме.........................................................................................................................................................78
Глава 3. Общее представление о системном программировании.........................................79
3.1. Системные вызовы....................................................................................................................................79
3.2. Библиотечные функции..........................................................................................................................82
3.3. Стандартная библиотека языка C; GNU-библиотека C (glibc).................................................82
3.4. Обработка ошибок, возникающих при системных вызовах и вызовах библиотечных функций...................................................................................................................................84
3.5. Пояснения по поводу примеров программ, приводимых в книге.............................................86
3.5.1. Ключи и аргументы командной строки..................................................................................87
3.5.2. Типовые функции и заголовочные файлы............................................................................87
3.6. Вопросы переносимости..........................................................................................................................96
3.6.1. Макросы проверки возможностей...........................................................................................96
3.6.2. Типы системных данных.............................................................................................................98
3.6.3. Прочие вопросы, связанные с портированием..................................................................102
3.7. Резюме..........................................................................................................................................................104
3.8. Упражнение................................................................................................................................................104
Глава 4. Файловый ввод-вывод: универсальная модель ввода-вывода...............................105
4.1. Общее представление.............................................................................................................................105
4.2. Универсальность ввода-вывода..........................................................................................................107
4.3. Открытие файла: open()........................................................................................................................108
4.3.1. Аргумент flags системного вызова open()............................................................................109
4.3.2. Ошибки, возвращаемые из системного вызова open()...................................................113
4.3.3. Системный вызов creat()...........................................................................................................114
4.4. Чтение из файла: read().........................................................................................................................114
4.5. Запись в файл: write()............................................................................................................................115
4.6. Закрытие файла: close().........................................................................................................................116
4.7. Изменение файлового смещения: lseek()........................................................................................117
4.8. Операции, не вписывающиеся в модель универсального ввода-вывода: ioctl()...............121
4.9. Резюме..........................................................................................................................................................122
4.10. Упражнения.............................................................................................................................................122
Глава 5. Файловый ввод-вывод: дополнительные сведения..............................................123
5.1. Атомарность и состояние гонки..........................................................................................................123
5.2. Операции управления файлом: fcntl().............................................................................................126
5.3. Флаги состояния открытого файла...................................................................................................127
5.4. Связь файловых дескрипторов с открытыми файлами..............................................................128
5.5. Дублирование дескрипторов файлов................................................................................................129
5.6. Файловый ввод-вывод по указанному смещению: pread() и pwrite()...................................133
5.7. Ввод-вывод по принципу фрагментации-дефрагментации: readv() и writev().................134
5.8. Усечение файла: truncate() и ftruncate().........................................................................................137
5.9. Неблокирующий ввод-вывод...............................................................................................................138
5.10. Ввод-вывод, осуществляемый в отношении больших файлов..............................................138
5.11. Каталог /dev/fd.......................................................................................................................................142
5.12. Создание временных файлов.............................................................................................................143
5.13. Резюме.......................................................................................................................................................144
5.14. Упражнения.............................................................................................................................................145
Глава 6. Процессы.........................................................................................................147
6.1. Процессы и программы..........................................................................................................................147
6.2. Идентификатор процесса и идентификатор родительского процесса..................................148
6.3. Структура памяти процесса.................................................................................................................149
6.4. Управление виртуальной памятью....................................................................................................153
6.5. Стек и стековые фреймы.......................................................................................................................155
6.6. Аргументы командной строки (argc, argv)......................................................................................156
6.7. Список переменных среды....................................................................................................................158
6.8. Выполнение нелокального перехода: setjmp() и longjmp().......................................................165
6.9. Резюме..........................................................................................................................................................170
6.10. Упражнения.............................................................................................................................................171
Глава 7. Выделение памяти............................................................................................172
7.1. Выделение памяти в куче......................................................................................................................172
7.1.1. Установка крайней точки программы: brk() и sbrk()......................................................172
7.1.2. Выделение памяти в куче: malloc() и free().........................................................................173
7.1.3. Реализация функций malloc() и free()..................................................................................177
7.1.4. Другие методы выделения памяти в куче............................................................................180
7.2. Выделение памяти в стеке: alloca()....................................................................................................183
7.3. Резюме..........................................................................................................................................................184
7.4. Упражнения...............................................................................................................................................185
Глава 8. Пользователи и группы......................................................................................186
8.1. Файл паролей: /etc/passwd...................................................................................................................186
8.2. Теневой файл паролей: /etc/shadow.................................................................................................187
8.3. Файл групп: /etc/group..........................................................................................................................188
8.4. Извлечение информации о пользователях и группах.................................................................189
8.5. Шифрование пароля и аутентификация пользователя..............................................................195
8.6. Резюме..........................................................................................................................................................198
8.7. Упражнения...............................................................................................................................................199
Глава 9. Идентификаторы процессов..............................................................................200
9.1. Реальный идентификатор пользователя и реальный идентификатор группы..................200
9.2. Действующий идентификатор пользователя
и действующий идентификатор группы..................................................................................................200
9.3. Программы с установленным идентификатором пользователя
и установленным идентификатором группы.........................................................................................201
9.4. Сохраненный set-user-ID и сохраненный set-group-ID..............................................................203
9.5. Пользовательские и групповые ID файловой системы..............................................................204
9.6. Дополнительные групповые идентификаторы..............................................................................205
9.7. Извлечение и модификация идентификаторов процессов.......................................................205
9.7.1. Извлечение и изменение реальных, действующих
и сохраненных установленных идентификаторов.......................................................................206
9.7.2. Извлечение и изменение идентификаторов файловой системы.................................212
9.7.3. Извлечение и изменение дополнительных
групповых идентификаторов..............................................................................................................213
9.7.4. Сводный обзор вызовов, предназначенных
для изменения идентификаторов процесса...................................................................................214
9.7.5. Пример: вывод на экран идентификаторов процесса......................................................216
9.8. Резюме..........................................................................................................................................................218
9.9. Упражнения...............................................................................................................................................218
Глава 10. Время.............................................................................................................220
10.1. Календарное время................................................................................................................................220
10.2. Функции преобразования представлений времени..................................................................222
10.2.1. Преобразование значений типа time_t к виду, подходящему
для устройств вывода информации..................................................................................................223
10.2.2. Преобразования между time_t и разделенным календарным временем................223
10.2.3. Преобразования между разделенным календарным временем
и временем в печатном виде................................................................................................................225
10.3. Часовые пояса.........................................................................................................................................232
10.4. Локали.......................................................................................................................................................235
10.5. Обновление системных часов............................................................................................................239
10.6. Программные часы (мгновения)......................................................................................................240
10.7. Время процесса.......................................................................................................................................241
10.8. Резюме.......................................................................................................................................................244
10.9. Упражнение.............................................................................................................................................245
Глава 11. Системные ограничения и возможности............................................................246
11.1. Системные ограничения......................................................................................................................247
11.2. Извлечение в ходе выполнения программы значений ограничений
(и возможностей) системы...........................................................................................................................251
11.3. Извлечение в ходе выполнения программы значений ограничений
(и возможностей), связанных с файлами................................................................................................253
11.4. Неопределенные ограничения..........................................................................................................254
11.5. Системные возможности.....................................................................................................................255
11.6. Резюме.......................................................................................................................................................257
11.7. Упражнения.............................................................................................................................................258
Глава 12. Информация о системе и процессе...................................................................259
12.1. Файловая система /proc......................................................................................................................259
12.1.1. Получение информации о процессе: /proc/PID.............................................................259
12.1.2. Системная информация, находящаяся в /proc................................................................262
12.1.3 Доступ к файлам, находящимся в /proc..............................................................................263
12.2. Идентификация системы: uname()..................................................................................................264
12.3. Резюме.......................................................................................................................................................266
12.4. Упражнения.............................................................................................................................................267
Глава 13. Буферизация файлового ввода-вывода.............................................................268
13.1. Буферизация файлового ввода-вывода при работе в режиме ядра:
буферная кэш-память.....................................................................................................................................268
13.2. Буферизация в библиотеке stdio......................................................................................................272
13.3. Управление буферизацией файлового ввода-вывода, осуществляемой в ядре...............274
13.4. Обзор буферизации ввода-вывода...................................................................................................278
13.5. Уведомление ядра о схемах ввода-вывода....................................................................................279
13.6. Обход буферной кэш-памяти: непосредственный ввод/вывод.............................................281
13.7. Смешивание библиотечных функций и системных вызовов
для файлового ввода-вывода.......................................................................................................................284
13.8. Резюме.......................................................................................................................................................285
13.9. Упражнения.............................................................................................................................................285
Глава 14. Файловые системы..........................................................................................287
14.1. Специальные файлы устройств........................................................................................................287
14.2. Диски и разделы.....................................................................................................................................289
14.3. Файловые системы................................................................................................................................290
14.4. Индексные дескрипторы.....................................................................................................................292
14.5. Виртуальная файловая система........................................................................................................294
14.6. Журналируемые файловые системы..............................................................................................295
14.7. Иерархия одиночного каталога и точки монтирования...........................................................297
14.8. Монтирование и размонтирование файловых систем..............................................................298
14.8.1. Монтирование файловой системы: mount()....................................................................299
14.8.2. Размонтирование файловой системы: системные вызовы umount()
и umount2()...............................................................................................................................................305
14.9. Дополнительные функции монтирования....................................................................................306
14.9.1. Монтирование файловой системы в нескольких точках монтирования...............306
14.9.2. Создание стека монтирования в одной точке..................................................................307
14.9.3. Флаги монтирования, которые являются параметрами конкретной
точки монтирования...............................................................................................................................307
14.9.4. Связанные (синонимичные) точки монтирования........................................................308
14.9.5. Рекурсивное связанное монтирование...............................................................................309
14.10. Файловая система виртуальной памяти: tmpfs.........................................................................310
14.11. Получение информации о файловой системе: statvfs().........................................................311
14.12. Резюме.....................................................................................................................................................313
14.13. Упражнение...........................................................................................................................................314
Глава 15. Атрибуты файла..............................................................................................315
15.1. Извлечение информации о файле: stat().......................................................................................315
15.2. Файловые метки времени...................................................................................................................320
15.2.1. Изменение меток времени файла с помощью системных вызовов
utime() и utimes()....................................................................................................................................323
15.2.2. Изменение меток времени файла с помощью системного вызова
utimensat() и функции futimens().....................................................................................................325
15.3. Принадлежность файла.......................................................................................................................326
15.3.1. Принадлежность новых файлов...........................................................................................327
15.3.2. Изменение принадлежности файла: системные вызовы chown(),
fchown() и lchown()................................................................................................................................327
15.4. Права доступа к файлу.........................................................................................................................330
15.4.1. Права доступа к обычным файлам.......................................................................................330
15.4.2. Права доступа к каталогам.....................................................................................................332
15.4.3. Алгоритм проверки прав доступа.........................................................................................333
15.4.4. Проверка доступности файла: системный вызов access()...........................................335
15.4.5. Биты set-user-ID, set-group-ID и закрепляющий............................................................336
15.4.6. Маска режима создания файла процесса: umask().........................................................337
15.4.7. Изменение прав доступа к файлу: системные вызовы chmod()
и fchmod()..................................................................................................................................................339
15.5. Флаги индексного дескриптора (расширенные атрибуты файла
в файловой системе ext2)..............................................................................................................................340
15.6. Резюме.......................................................................................................................................................344
15.7. Упражнения.............................................................................................................................................344
Глава 16. Расширенные атрибуты...................................................................................346
16.1. Обзор..........................................................................................................................................................346
16.2. Подробности реализации расширенных атрибутов..................................................................348
16.3. Системные вызовы для манипуляции расширенными атрибутами....................................349
16.4. Резюме.......................................................................................................................................................353
16.5. Упражнение.............................................................................................................................................353
Глава 17. Списки контроля доступа.................................................................................354
17.1. Обзор..........................................................................................................................................................354
17.2. Алгоритм проверки прав доступа с помощью списков контроля доступа........................356
17.3. Длинная и краткая текстовые формы списков контроля доступа.......................................357
17.4. Запись ACL_MASK и класс группы для ACL-списка..............................................................358
17.5. Команды getfacl и setfacl......................................................................................................................359
17.6. ACL-списки по умолчанию и создание файла.............................................................................361
17.7. Границы реализации списка контроля доступа..........................................................................362
17.8. API для ACL-списков...........................................................................................................................363
17.9. Резюме.......................................................................................................................................................370
17.10. Упражнение...........................................................................................................................................370
Глава 18. Каталоги и ссылки...........................................................................................371
18.1. Каталоги и (жесткие) ссылки............................................................................................................371
18.2. Символические (мягкие) ссылки.....................................................................................................374
18.3. Создание и удаление (жестких) ссылок: системные вызовы link() и unlink()................377
18.4. Изменение имени файла: системный вызов rename()..............................................................380
18.5. Работа с символическими ссылками: системные вызовы symlink() и readlink()............381
18.6. Создание и удаление каталогов: системные вызовы mkdir() и rmdir()..............................382
18.7. Удаление файла или каталога: функция remove().....................................................................384
18.8. Чтение каталогов: функции opendir() и readdir()......................................................................384
18.9. Обход дерева файлов: функция nftw()...........................................................................................390
18.10. Текущий рабочий каталог процесса..............................................................................................394
18.11. Работа с использованием файлового дескриптора каталога................................................396
18.12. Изменение корневого каталога процесса: системный вызов chroot()..............................398
18.13. Анализ имени пути: функция realpath().....................................................................................400
18.14. Синтаксический разбор строк с именем пути: функции dirname() и basename()........402
18.15. Резюме.....................................................................................................................................................404
18.16. Упражнения...........................................................................................................................................404
Глава 19. Мониторинг событий файлов...........................................................................406
19.1. Обзор..........................................................................................................................................................406
19.2. Интерфейс inotify..................................................................................................................................407
19.3. События inotify.......................................................................................................................................409
19.4. Чтение событий inotify........................................................................................................................410
19.5. Ограничения очереди и файлы /proc.............................................................................................416
19.6. Старая система мониторинга событий файлов: dnotify...........................................................416
19.7. Резюме.......................................................................................................................................................417
19.8. Упражнение.............................................................................................................................................417
Глава 20. Сигналы: фундаментальные концепции.............................................................418
20.1. Концепции и общие сведения...........................................................................................................418
20.2. Типы сигналов и действия по умолчанию....................................................................................420
20.3. Изменение диспозиций сигналов: signal()....................................................................................426
20.4. Введение в обработчики сигналов...................................................................................................427
20.5. Отправка сигналов: kill()....................................................................................................................430
20.6. Проверка существования процесса.................................................................................................432
20.7. Другие способы отправки сигналов: raise() и killpg()...............................................................433
20.8. Отображение описаний сигналов....................................................................................................434
20.9. Наборы сигналов....................................................................................................................................435
20.10. Сигнальная маска (блокирование доставки сигналов)..........................................................438
20.11. Ожидающие сигналы.........................................................................................................................439
20.12. Сигналы не ставятся в очередь.......................................................................................................440
20.13. Изменение диспозиций сигналов: sigaction()...........................................................................443
20.14. Ожидание сигнала: pause()..............................................................................................................445
20.15. Резюме.....................................................................................................................................................445
20.16. Упражнения...........................................................................................................................................446
Глава 21. Сигналы: обработчики сигналов.......................................................................447
21.1. Проектирование обработчиков сигналов......................................................................................447
21.1.1. Сигналы не ставятся в очередь (еще раз о...)....................................................................447
21.1.2. Реентерабельные функции и функции, безопасные
для асинхронных сигналов..................................................................................................................448
21.1.3. Глобальные переменные и тип данных sig_atomic_t.....................................................453
21.2. Другие методы завершения работы обработчика сигнала......................................................454
21.2.1. Выполнение нелокального перехода из обработчика сигнала...................................454
21.2.2. Аварийное завершение процесса: abort()..........................................................................458
21.3. Обработка сигнала на альтернативном стеке: signalstack()....................................................459
21.4. Флаг SA_SIGINFO...............................................................................................................................462
21.5. Прерывание и повторный запуск системных вызовов.............................................................467
21.6. Резюме.......................................................................................................................................................470
21.7. Упражнение.............................................................................................................................................471
Глава 22. Сигналы: дополнительные возможности...........................................................472
22.1. Файлы дампа ядра.................................................................................................................................472
22.2. Частные случаи доставки, диспозиции и обработки.................................................................474
22.3. Прерываемые и непрерываемые состояния сна процесса.......................................................475
22.4. Аппаратно генерируемые сигналы..................................................................................................476
22.5. Синхронная и асинхронная генерация сигнала..........................................................................477
22.6. Тайминг и порядок доставки сигнала.............................................................................................478
22.7. Реализация и переносимость функции signal()..........................................................................479
22.8. Сигналы реального времени..............................................................................................................481
22.8.1. Отправка сигналов реального времени..............................................................................483
22.8.2. Обработка сигналов реального времени............................................................................485
22.9. Ожидание сигнала с использованием маски: sigsuspend()......................................................488
22.10. Синхронное ожидание сигнала.......................................................................................................492
22.11. Получение сигналов через файловый дескриптор..................................................................496
22.12. Межпроцессное взаимодействие посредством сигналов......................................................498
22.13. Ранние API сигналов..........................................................................................................................499
22.14. Резюме.....................................................................................................................................................500
22.15. Упражнения...........................................................................................................................................501
Глава 23. Таймеры и переход в режим сна.......................................................................502
23.1. Интервальные таймеры.......................................................................................................................502
23.2. Планирование и точность таймеров................................................................................................507
23.3. Установка времени ожидания для блокирующих операций..................................................508
23.4. Приостановка выполнения на определенный отрезок времени
(переход в режим сна)....................................................................................................................................509
23.4.1. Переход в режим сна (низкая точность): вызов sleep()................................................509
23.4.2. Переход в режим сна (высокая точность): вызов nanosleep()....................................510
23.5. Часы стандарта POSIX........................................................................................................................512
23.5.1. Получение текущего значения часов: вызов clock_gettime().....................................513
23.5.2. Изменение значения часов: вызов clock_settime()........................................................514
23.5.3. Получение идентификатора часов для определенного процесса
или потока..................................................................................................................................................514
23.5.4. Улучшенный переход в режим сна (высокая точность):
вызов clock_nanosleep()........................................................................................................................515
23.6. Интервальные таймеры POSIX........................................................................................................516
23.6.1. Создание таймера: вызов timer_create()............................................................................517
23.6.2. Запуск и остановка таймера: вызов timer_settime()......................................................519
23.6.3. Получение текущего значения таймера: вызов timer_gettime()...............................520
23.6.4. Удаление таймера: вызов timer_delete()............................................................................520
23.6.5. Уведомление с помощью сигнала........................................................................................521
23.6.6. Дополнительные срабатывания таймера...........................................................................524
23.6.7. Уведомление с помощью потока..........................................................................................525
23.7. Таймеры, которые уведомляют с помощью файловых дескрипторов:
интерфейс timerfd............................................................................................................................................528
23.8. Резюме.......................................................................................................................................................532
23.9. Упражнения.............................................................................................................................................532
Глава 24. Создание процессов........................................................................................533
24.1. Обзор вызовов fork(), exit(), wait() и execve()............................................................................533
24.2. Создание нового процесса: fork().....................................................................................................534
24.2.1. Совместный доступ к файлу родителя и потомка..........................................................537
24.2.2. Семантика памяти вызова fork()..........................................................................................540
24.3. Системный вызов vfork()....................................................................................................................542
24.4. Состояние гонки после вызова fork().............................................................................................544
24.5. Синхронизация с помощью сигналов как способ
избежать состояния гонки............................................................................................................................546
24.6. Резюме.......................................................................................................................................................548
24.7. Упражнения.............................................................................................................................................548
Глава 25. Завершение работы процесса...........................................................................549
25.1. Завершение процесса: вызовы _exit() и exit().............................................................................549
25.2. Завершение процесса в подробностях............................................................................................550
25.3. Обработчики выхода............................................................................................................................551
25.4. Взаимодействие между буферами stdio и вызовами fork() и _exit()..................................554
25.5. Резюме.......................................................................................................................................................556
25.6. Упражнение.............................................................................................................................................556
Глава 26. Мониторинг дочерних процессов......................................................................557
26.1. Ожидание дочернего процесса..........................................................................................................557
26.1.1. Системный вызов wait()..........................................................................................................557
26.1.2. Системный вызов waitpid()....................................................................................................559
26.1.3. Статус ожидания........................................................................................................................560
26.1.4. Завершение процесса из обработчика сигнала................................................................564
26.1.5. Системный вызов waitid()......................................................................................................565
26.1.6. Системные вызовы wait3() и wait4()..................................................................................567
26.2. Процессы-"сироты" и процессы-"зомби"....................................................................................567
26.3. Сигнал SIGCHLD..................................................................................................................................569
26.3.1. Установка обработчика сигнала SIGCHLD.....................................................................570
26.3.2. Доставка сигнала SIGCHLD для остановленных потомков......................................573
26.3.3. Игнорирование завершенных дочерних процессов.......................................................573
26.4. Резюме.......................................................................................................................................................574
26.5. Упражнения.............................................................................................................................................575
Глава 27. Выполнение программы...................................................................................576
27.1. Выполнение новой программы: execve().......................................................................................576
27.2. Библиотечные функции семейства exec()....................................................................................579
27.2.1. Переменная среды PATH........................................................................................................580
27.2.2. Задание аргументов программы в виде списка...............................................................582
27.2.3. Передача переменных среды вызывающего процесса новой программе...............582
27.2.4. Выполнение файла через ссылку на его дескриптор: fexecve().................................583
27.3. Интерпретируемые скрипты..............................................................................................................583
27.4. Дескрипторы файлов и вызовы exec()...........................................................................................587
27.5. Сигналы и вызов exec().......................................................................................................................589
27.6. Выполнение консольных команд: system()..................................................................................590
27.7. Реализация функции system()..........................................................................................................593
27.8. Резюме.......................................................................................................................................................599
27.9. Упражнения.............................................................................................................................................599
Глава 28. Подробнее о создании процесса и выполнении программы.................................601
28.1. Учет ресурсов, используемых процессом......................................................................................601
28.2. Системный вызов clone()....................................................................................................................607
28.2.1. Аргумент flags вызова clone()................................................................................................612
28.2.2. Расширения к вызову waitpid() для клонированных потомков................................619
28.3. Скорость создания процессов...........................................................................................................619
28.4. Влияние вызовов exec() и fork() на атрибуты процесса..........................................................621
28.5. Резюме.......................................................................................................................................................625
28.6. Упражнение.............................................................................................................................................626
Глава 29. Потоки выполнения: введение..........................................................................627
29.1. Краткий обзор.........................................................................................................................................627
29.2. Общие сведения о программном интерфейсе Pthreads............................................................630
29.3. Создание потоков...................................................................................................................................631
29.4. Завершение потоков.............................................................................................................................633
29.5. Идентификаторы потоков..................................................................................................................633
29.6. Присоединение к завершенному потоку.......................................................................................635
29.7. Отсоединение потока...........................................................................................................................637
29.8. Атрибуты потоков..................................................................................................................................637
29.9. Сравнение потоков и процессов.......................................................................................................638
29.10. Резюме.....................................................................................................................................................639
29.11. Упражнения...........................................................................................................................................640
Глава 30. Потоки выполнения: синхронизация.................................................................641
30.1. Защита доступа к разделяемым переменным: мьютексы........................................................641
30.1.1. Статически выделяемые мьютексы.....................................................................................645
30.1.2. Закрытие и открытие мьютекса............................................................................................645
30.1.3. Производительность мьютексов...........................................................................................647
30.1.4. Взаимное блокирование мьютексов....................................................................................648
30.1.5. Динамическая инициализация мьютексов.......................................................................649
30.1.6. Атрибуты мьютексов................................................................................................................650
30.1.7. Типы мьютексов.........................................................................................................................650
30.2. Оповещение об изменении состояния: условные переменные..............................................651
30.2.1. Статически выделяемые условные переменные.............................................................652
30.2.2. Оповещение и ожидание условных переменных............................................................652
30.2.3. Проверка предиката условной переменной......................................................................656
30.2.4. Пример программы: подсоединение любого завершенного потока.........................657
30.2.5. Динамически выделяемые условные переменные.........................................................660
30.3. Резюме.......................................................................................................................................................661
30.4. Упражнения.............................................................................................................................................661
Глава 31. Потоки выполнения: потоковая безопасность и локальное хранилище................662
31.1. Потоковая безопасность (и новый взгляд на реентерабельность).......................................662
31.2. Единовременная инициализация.....................................................................................................665
31.3. Данные уровня потока.........................................................................................................................666
31.3.1. Данные уровня потока с точки зрения библиотечной функции...............................666
31.3.2. Обзор программного интерфейса для работы с данными уровня потока..............667
31.3.3. Подробности о программном интерфейсе для работы
с данными уровня потока.....................................................................................................................667
31.3.4. Использование программного интерфейса для работы
с данными уровня потока.....................................................................................................................670
31.3.5. Ограничения реализации данных уровня потока..........................................................674
31.4. Локальное хранилище потока...........................................................................................................674
31.5. Резюме.......................................................................................................................................................676
31.6. Упражнения.............................................................................................................................................676
Глава 32. Потоки выполнения: отмена потока..................................................................677
32.1. Отмена потока.........................................................................................................................................677
32.2. Состояние и тип отмены.....................................................................................................................677
32.3. Точки отмены..........................................................................................................................................678
32.4. Проверка возможности отмены потока.........................................................................................681
32.5. Обработчики, освобождающие ресурсы........................................................................................681
32.6. Асинхронная отмена.............................................................................................................................685
32.7. Резюме.......................................................................................................................................................685
Глава 33. Потоки выполнения: дальнейшие подробности..................................................686
33.1. Стеки потоков.........................................................................................................................................686
33.2. Потоки и сигналы..................................................................................................................................687
33.2.1. Как модель сигналов в UNIX соотносится с потоками................................................687
33.2.2. Изменение масок сигналов потока......................................................................................688
33.2.3. Отправка сигнала потоку.

С этой книгой чаще всего покупают:
Ядро Linux: описание процесса разработки

Ядро Linux: описание процесса разработки

рекомендуем
Роберт Лав
Год выпуска: 2016
Изд-во: Диалектика-Вильямс
в корзину
Только 1 книга
 
Искусство программирования для Unix

Искусство программирования для Unix

Реймонд Эрик C.
Год выпуска: 2016
Изд-во: Диалектика-Вильямс
Временно отсутствует Оставить заявку
Цена: 765.00 грн. 
 
 
UNIX. Профессиональное программирование. 3-е изд.

UNIX. Профессиональное программирование. 3-е изд.

Стивенс У., Раго С.
Год выпуска: 2018
Изд-во: Питер

в корзину

Instant Purshare Только 1 книга
 
   
Цена: 1263.00 грн. 
   

Хотите оставить отзыв? У Вас возникли вопросы о книге "Linux API. Исчерпывающее руководство, Майкл Керриск" ? Пишите:

* Текст сообщения:
 
  Отправить
Сайт по косметолгии
Поиск по каталогу
 поиск в аннотациях
Искать

* Подробнее об условиях доставки смотрите в разделе "Оплата и Доставка" нашего магазина.
Если у Вас возникли вопросы как подобрать и купить книги в нашем интернет-магазине звоните с 9 до 18 по будним дням: Киев 331-04-53, МТС (050) 809-56-66, Киевстар (067) 408-26-36, Лайф (063) 227-24-47, Интертелеком (094) 831-04-53 или пишите нам