Ошибка сегментирования ubuntu

Умение обращаться

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

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

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

Попытка чтения за концом массива

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

Если вы читаете за концом массива, вы можете оказаться в памяти, которая не инициализирована или принадлежит чему-то другому. Это технически неопределенное поведение. Segfault — это только один из многих возможных неопределенных вариантов поведения.

Или часто встречающийся с вместо (слишком много читает 1 байт):

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

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

У меня есть segfaults!

Состояния процесса в Linux

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

Рассмотрим основные состояния процесса:

   Выполнение — процесс либо запущен (текущий процесс в системе), либо готов к запуску (ожидает передачи на выполнение процессору).

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

   прерываемые ожидающие процессы — могут быть прерваны сигналами;

   непрерываемые ожидающие процессы — процессы ожидают непосредственно на аппаратном уровне и не могут быть прерваны каким-либо событием/сигналом.

   Завершен — процесс был остановлен, как правило, путем получения сигнала штатного завершения работы exit().

   Зомби — иногда, когда родительский процесс убивается до завершения дочернего процесса, дочерние процессы становятся «осиротевшими», при этом в качестве нового родителя (с соответствующим изменением PPID) им назначается процесс init. Убитые процессы, но при этом все еще отображающиеся в таблице процессов, называются процессами зомби (они мертвы и не используются).

Ответ 5

Чтобы активировать дамп ядра, сделайте следующее:

  1. В /etc/profile закомментируйте строку:

# ulimit -S -c 0 > /dev/null 2>&1

  1. В /etc/security/limits.conf закомментируйте строку: 

* soft core 0

  1. Выполните команду limit coredumpsize unlimited и проверьте ее с помощью cmd limit:

# limit coredumpsize unlimited

# limit

cputime           unlimited

filesize            unlimited

datasize           unlimited

stacksize         10240 kbytes

coredumpsize  unlimited

memoryuse     unlimited

vmemoryuse   unlimited

descriptors      1024

memorylocked 32 kbytes

maxproc          528383

  1. Для проверки записи файла ядра можно завершить соответствующий процесс командой kill -s SEGV <PID> (необязательно, просто в случае, если файл ядра не записывается, это можно использовать как проверку):

# kill -s SEGV <PID>

  1. После записи corefile убедитесь, что настройки coredump снова отключены в соответствующих файлах.

Основные сигналы

Следующие сигналы являются частью стандарта POSIX. Каждый сигнал макрос, определенный в <signals.h> Файл заголовка системы. Они, как правило, сокращенны, без их SIG- префикса; например SIGHUP часто называют просто как HUP.

SIGTERM –  Этот сигнал запрашивает остановку процесса который работает. Этот сигнал может быть проигнорирован.Процессу дается время, чтобы хорошо выключился. Когда программа хорошо выключается, это означает, что ей дано время, чтобы спасти его прогресс и освободить ресурсы. Другими словами, он не «forced» прекращение работы процесса.

SIGKILL –  сигнал SIGKILL заставляет процесс прекратить выполнение своей работы немедленно. Программа не может игнорировать этот сигнал. Несохраненный прогресс будет потерян.

Синтаксис для  «kill».

Синтаксис команды такой:

# kill  PID(s)

или

# kill   %pid

Сигнал по умолчанию (если он не указан) является SIGTERM. Когда данный сигнал не помогает и не работает, вы можете использовать следующие опции для «kill» чтобы завершить процесс принудительно:

# kill SIGKILL PID

Или

# kill -9 PID

где «-9» — это флаг относится к сигналу SIGKILL.

Если вы не знаете какой нужно использовать PID приложения которого следует избавиться, то запустите команду:

$ ps -aux

А если знаете конкретное приложение (например apache), то можно отсеять ненужное и вывести все процессы по данной службе:

$ ps -aux | grep apache

И это отобразит все запущенные приложения вместе с его PID-ом(ами).

Например, чтобы убить приложение, я выполните следующую команду:

# kill -9 3629

Стоит также отметить, что вы можете использовать несколько процессов одновременно чтобы их можно было » убить»:

# kill -9 PID1 PID2 PID 3

Перезагурзить конфигурационные файлы или перезапуск утилит:

# kill -1 number_of_PID

Особенно полезными сигналы включают HUP, INT, kill, STOP, CONT, и 0.

Варианты таковы:

-s signal_name
Символическое имя сигнала, задающее сигнал для отправки сигнала не по умолчанию.

-l
Если операнд не указан,  то показать имена сигналов; В противном случае, написать название сигнала, соответствующего exit_status.

-signal_name
Символическое имя сигнала, задающее сигнал для отправки в TERM по умолчанию.

-signal_number
Неотрицательное десятичное целое, задающее сигнал для отправки в TERM по умолчанию.

Следующие PID-ы, имеют особое значение:-1 Если суперпользователь, то транслирует сигнал всем процессам;  в противном случае вещает на все процессыbelong-
ing для пользователя.

Некоторые из наиболее часто используемых сигналов:

  • 1 HUP (hang up) — повесить.
  • 2 INT (interrupt) — прерывание.
  • 3 QUIT (quit) — выход.
  • 6 ABRT (abort) — прерывания.
  • 9 KILL (non-catchable, non-ignorable kill)
  • 14 ALRM (alarm clock) — будильник.
  • 15 TERM (software termination signal) — Программное обеспечение для прекращения сигнала.

PKill

Команда «pkill» позволяет использовать расширенные шаблоны регулярных выражений и других критериев соответствия. Вместо того чтобы использовать PID, теперь вы можете убить приложение, введя имя процесса. Например, чтобы убитьбраузер Firefox , просто запустите команду:

# pkill Firefox

Так как он соответствует шаблону регулярного выражения, вы также можете ввести часть имени процесса, например:

# pkill fire

Чтобы избежать «убийства» неправильных процессов, вы можете сделать «pgrep -l » в список подходящих процессов.

Pkill команда имеет гораздо больше вариантов, например если указать опцию «-u», то она позволит вам указать имя пользователя или ID. В этом примере мы посылаем сигнал TERM всем процессам, принадлежащие пользователю ‘nobody’:

# pkill -u nobody

Killall

Killall использует имя процесса, а вместо PID, и он «убивает» все экземпляры процесса с тем же именем. Например, если вы используете несколько экземпляров браузера Firefox, вы можете убить их всех с помощью команды:

# killall firefox

В Gnome, вы можете перезапустить Nautilus с помощью команды:

# killall nautilus

xkill

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

Почему возникает ошибка сегментации?

И зачем бы это порядочной программе лезть, куда ей не положено? Да в принципе, незачем. Это происходит из-за ошибки при написании программ или несовместимых версиях библиотек и ПО. Часто эта ошибка встречается в программах на Си или C++. В этом языке программисты могут вручную работать с памятью, а язык со своей стороны не контролирует, чтобы они это делали правильно, поэтому одно неверное обращение к памяти может обрушить программу.

Почему может возникать эта ошибка при несовместимости библиотек? По той же причине — неверному обращению к памяти. Представим, что у нас есть библиотека linux (набор функций), в которой есть функция, которая выполняет определенную задачу. Для работы нашей функции нужны данные, поэтому при вызове ей нужно передать строку. Наша старая версия библиотеки ожидает, что длина строки будет до 256 символов. Но программа была обновлена формат записи поменялся, и теперь она передает библиотеке строку размером 512 символов. Если обновить программу, но оставить старую версию библиотеки, то при передаче такой строки 256 символов запишутся нормально в подготовленное место, а вот вторые 256 перезапишут данные программы, и возможно, попытаются выйти за пределы сегмента, тогда и будет ошибка сегментирования linux.

DEBUGGING

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

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

Некоторые отладчики памяти

  • ГБД | Mac, Linux
  • Вальгринд (мемчек) | Linux
  • Доктор Память | Windows

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

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

высокоуровневый

  1. Обычно — пакеты программного обеспечения, которые реализуют промежуточный слой между системной платформой и приложением. Эти пакеты предназначены для переноса уже испытанных протоколов коммуникации приложения на более новую архитектуру. Примером можно привести: DIPC, MPI и др. (мне не знакомы, честно говоря)

Итак. Подведем маленький итог:

  • В Linux есть процессы,
  • каждый процесс может запускать подпроцессы (нити),
  • создание нового процесса создается клонированием исходного,
  • прородителем всех процессов в системе является процесс init, запускаемый ядром системы при загрузке.
  • процессы взаимодействуют между собой по средствам можпроцессного взаимодействия:
    • каналы
    • сигналы
    • сокеты
    • разделяемая память
  • каждый процесс обладает свойствами (читай: обладает следующим контекстом):
    • PID — идентификатор процесса
    • PPID — идентификатор процесса, породившего данный
    • UID и GID — идентификаторы прав процесса (соответствует UID и GID  пользователя, от которого запущен процесс)
    • приоритет процесса
    • состояние процесса (выполнение, сон и т.п.)
    • так же у процесса есть таблица открытых (используемых) файлов

Далее поговорим о том, как посмотреть состояние процессов в Linux и о том, как же ими управлять.

Общие понятия

Сегментная адресация памяти  — схема логической адресации памяти компьютера в архитектуре x86. Линейный адрес конкретной ячейки памяти, который в некоторых режимах работы процессора будет совпадать с физическим адресом, делится на две части: сегмент и смещение. Сегментом называется условно выделенная область адресного пространства определённого размера, а смещением — адрес ячейки памяти относительно начала сегмента. Базой сегмента называется линейный адрес (адрес относительно всего объёма памяти), который указывает на начало сегмента в адресном пространстве. В результате получается сегментный (логический) адрес, который соответствует линейному адресу база сегмента+смещение и который выставляется процессором на шину адреса.

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

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

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

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

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

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

На уровне операционной системы эта ошибка ловится и сигнал передается в блок «offending process», где эта ошибка обрабатывается:

  • В UNIX-подобных операционных системах процесс, обращающийся к недействительным участкам памяти, получает сигнал «SIGSEGV».
  • В Microsoft Windows, процесс, получающий доступ к недействительным участкам памяти, создаёт исключение «STATUS_ACCESS_VIOLATION», и, как правило, предлагает запустить отладчик приложения Dr. Watson, которая показывает пользователю окно с предложением отправить отчет об ошибке Microsoft.

Суммирую можно сказать, когда пользовательский процесс хочет обратиться к памяти, то он просит MMU переадресовать его. Но если полученный адрес ошибочен, — находится вне пределов физического сегмента, или если сегмент не имеет нужных прав (попытка записи в read only-сегмент), — то ОС по умолчанию отправляет сигнал SIGSEGV, что приводит к прерыванию выполнения процесса и выдаче сообщения “segmentation fault”.

Что такое ошибка сегментации?

Ошибка сегментации, Segmentation fault, или Segfault, или SIGSEGV в Ubuntu и других Unix подобных дистрибутивах, означает ошибку работы с памятью. Когда вы получаете эту ошибку, это значит, что срабатывает системный механизм защиты памяти, потому что программа попыталась получить доступ или записать данные в ту часть памяти, к которой у нее нет прав обращаться.

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

Допустим, в вашей системе есть 6 Гигабайт оперативной памяти, каждой программе нужно выделить определенную область, куда будет записана она сама, ее данные и новые данные, которые она будет создавать. Чтобы дать возможность каждой из запущенных программ использовать все шесть гигабайт памяти был придуман механизм виртуального адресного пространства. Создается виртуальное пространство очень большого размера, а из него уже выделяется по 6 Гб для каждой программы. Если интересно, это адресное пространство можно найти в файле /proc/kcore, только не вздумайте никуда его копировать.

Выделенное адресное пространство для программы называется сегментом. Как только программа попытается записать или прочитать данные не из своего сегмента, ядро отправит ей сигнал SIGSEGV и программа завершится с нашей ошибкой. Более того, каждый сегмент поделен на секции, в некоторые из них запись невозможна, другие нельзя выполнять, если программа и тут попытается сделать что-то запрещенное, мы опять получим ошибку сегментации Ubuntu.

Причины

Ниже приведены некоторые типичные причины ошибки сегментации:

  • Попытка доступа к несуществующему адресу памяти (вне адресного пространства процесса)
  • Попытка доступа к памяти, на которую программа не имеет прав (например, к структурам ядра в контексте процесса)
  • Попытка записи в постоянную память (например, сегмент кода)

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

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

В коде C, ошибка сегментации чаще всего возникает из — за ошибки в использовании указателей, в частности , в выделении динамической памяти C . Разыменование нулевого указателя всегда приводит к сбою сегментации, но дикие указатели и висячие указатели указывают на память, которая может существовать, а может и не существовать, и может быть, а может и не быть доступной для чтения или записи, и, таким образом, может привести к временным ошибкам. Например:

char *p1 = NULL;           // Null pointer
char *p2;                  // Wild pointer: not initialized at all.
char *p3  = malloc(10 * sizeof(char));  // Initialized pointer to allocated memory
                                        // (assuming malloc did not fail)
free(p3);                  // p3 is now a dangling pointer, as memory has been freed

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

Пример Segmentation Fault

Рассмотрим пример кода на ANSI C, который приводит к ошибке сегментации вследствие присутствия квалификатора Сonst — type:

 const char *s = "hello world";
 *(char *)s = 'H';

Когда программа, содержащая этот код, скомпилирована, строка «hello world» размещена в секции программы с бинарной пометкой «только для чтения». При запуске операционная система помещает её с другими строками и константами в сегмент памяти, предназначенный только для чтения. После запуска переменная s указывает на адрес строки, а попытка присвоить значение символьной константы H через переменную в памяти приводит к ошибке сегментации.

Компиляция и запуск таких программ на OpenBSD 4.0 вызывает следующую ошибку выполнения:

 
$ gcc segfault.c -g -o segfault
$ ./segfault
 Segmentation fault

Вывод отладчика gdb:

 Program received signal SIGSEGV, Segmentation fault.
 0x1c0005c2 in main () at segfault.c:6
 6               *s = 'H';

В отличие от этого, gcc 4.1.1 на GNU/Linux возвращает ошибку ещё во время компиляции:

 $ gcc segfault.c -g -o segfault
 segfault.c: In function ‘main’:
 segfault.c:4: error: assignment of read-only location

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

 int* ptr = (int*);
 *ptr = 1;

Ещё один способ вызвать ошибку сегментации заключается в том, чтобы вызвать функцию main рекурсивно, что приведёт к переполнению стека:

int main()
 {
    main();
 }

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

 char* p1 = NULL;  /* инициализирован как нулевой, в чем нет ничего плохого, но на многих системах он не может быть разыменован */
 char* p2;  /* вообще не инициализирован */
 char* p3  = (char *)malloc(20);  /* хорошо, участок памяти выделен */
 free(p3);  /* но теперь его больше нет */

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

 int main()
 { 
     int const nmax=10;
     int i,n,an];
 }

Такая ошибка не прослеживается G++ при компоновке, но при запуске приложения вызовет ошибку сегментации.

Видеопример Segmentation Fault на примере C:

Ответ 3

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

sysctl kernel.core_pattern

 или:

cat /proc/sys/kernel/core_pattern

 где %e — имя процесса, а %t — системное время. Вы можете изменить его в /etc/sysctl.conf и перезагрузить с помощью sysctl -p. Если файлы ядра не генерируются и далее (проверить это можно с помощью: sleep 10 & и killall -SIGSEGV sleep), проверьте ограничения с помощью команды:

 ulimit -a.

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

ulimit -c unlimited

чтобы сделать его неограниченным.

Затем снова проверьте, что дамп ядра выполнен успешно — вы увидите «(core dumped)» после индикации ошибки сегментации, как показано ниже:

Segmentation fault: 11 (core dumped)

В Ubuntu дампы ядра обрабатываются Apport и могут быть расположены в /var/crash/. Однако в стабильных релизах он отключен по умолчанию.

Отслеживание активных процессов

Существует несколько различных инструментов для просмотра/перечисления запущенных в системе процессов. Двумя традиционными и хорошо известными из них являются команды ps и top:

Команда ps

Отображает информацию об активных процессах в системе, как показано на следующем скриншоте:

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

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

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

   PID — идентификатор процесса.

   PPID — идентификатор родительского процесса.

   C — загрузка CPU процессом.

   STIME — время начала выполнения процесса.

   TTY — тип терминала, связанного с процессом.

   TIME — количество процессорного времени, потраченного на выполнение процесса.

   CMD — команда, запустившая этот процесс.

Также можно отобразить информацию по конкретному процессу, используя команду , например:

Есть и другие опции, которые можно использовать вместе с командой :

    — показывает информацию о процессах по всем пользователям;

    — показывает информацию о процессах без терминалов;

    — показывает дополнительную информацию о процессе по заданному UID или имени пользователя;

    — отображение расширенной информации.

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

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

Например, чтобы отсортировать список процессов по потреблению ресурсов процессора (в порядке возрастания), введите команду:

Результат:

Если вы ходите выполнить сортировку по потреблению памяти (в порядке убывания), то добавьте к имени интересующего столбца знак минуса:

Результат:

Еще один очень популярный пример использования команды — это объединение её и для поиска заданного процесса по его имени:

Результат:

Команда top

Команда top отображает информацию о запущенных процессах в режиме реального времени:

Рассмотрим детально:

   PID — идентификатор процесса.

   USER — пользователь, которому принадлежит процесс.

   PR — приоритет процесса на уровне ядра.

   NI — приоритет выполнения процесса от до .

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

   RES — текущий объем (в килобайтах) физической памяти процесса.

   SHR — объем совместно используемой с другими процессами памяти.

   S (сокр. от «STATUS») — состояние процесса:

   S (сокр. от «Sleeping») — прерываемое ожидание. Процесс ждет наступления события.

   I (сокр. от «Idle») — процесс бездействует.

   R (сокр. от «Running») — процесс выполняется (или поставлен в очередь на выполнение).

   Z (сокр. от «Zombie») — зомби-процесс.

   %CPU — процент используемых ресурсов процессора.

   %MEM — процент используемой памяти.

   TIME+ — количество процессорного времени, потраченного на выполнение процесса.

   COMMAND — имя процесса (команды).

Также в сочетании с основными символами состояния процесса (S от «STATUS») вы можете встретить и дополнительные:

    — процесс с высоким приоритетом;

    — процесс с низким приоритетом;

    — многопоточный процесс;

    — фоновый процесс;

    — лидер сессии.

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

Команда glances

Команда glances — это относительно новый инструмент мониторинга системы с расширенными функциями:

Примечание: Если в вашей системе отсутствует данная утилита, то установить её можно с помощью следующих команд:

RHEL/CentOS/Fedora

Debian/Ubuntu/Linux Mint

Ответ 6

Стоит упомянуть, что если у вас установлен systemd, то ситуация немного меняется. Обычно файлы ядра передаются через systemd-coredump(8) посредством значения core_pattern sysctl. Размер rlimit файла ядра, как правило, уже настроен как неограниченный.

Затем можно получить дампы ядра с помощью coredumpctl(1).

Хранение дампов ядра и т. д. настраивается coredump.conf(5). Примеры получения файлов ядра есть на man-странице coredumpctl, но вкратце это выглядит следующим образом:

~$ coredumpctl list test_me | tail -1

Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

 Получите файл ядра:

~$ coredumpctl -o test_me.core dump 16163

Рейтинг
( Пока оценок нет )
Понравилась статья? Поделиться с друзьями:
Все про сервера
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!:

Adblock
detector