Наши партнеры

Библиотека сайта rus-linux.net

Руководство для начинающих пользователей SystemTap. Полезные сценарии SystemTap

Оригинал: SystemTap Beginners Guide
Авторы: Don Domingo, William Cohen
Дата публикации: 20 июля 2009 г.
Перевод: А.Панин
Дата перевода: 3 октября 2014 г.

Глава 5. Полезные сценарии SystemTap

5.2. Диск

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

5.2.1. Подсчет объема данных при чтении данных с диска/записи данных на диск

В данном разделе описывается способ идентификации процессов, наиболее интенсивно читающих данные с дисков/записывающих данные на диски в системе.

disktop.stp

#!/usr/bin/env stap 
#
# Авторские права (C) 2007 Oracle Corp.
#
# Получение информации о процессах, читающих данные с диска/записывающих данные
# на диск каждые 5 секунд с выводом десяти процессов, осуществляющих наиболее 
# интенсивные операции ввода/вывода
#
# Это свободное программное обеспечение, распространяемое в соответствии с условиями
# Универсальной общественной лицензии GNU; либо версии 2, либо (по вашему 
# усмотрению) любой более поздней версии.
#
# Использование:
#  ./disktop.stp
#

global io_stat,device
global read_bytes,write_bytes

probe vfs.read.return {
  if ($return>0) {
    if (devname!="N/A") {/*пропуск операций чтения из кэша*/
      io_stat[pid(),execname(),uid(),ppid(),"R"] += $return
      device[pid(),execname(),uid(),ppid(),"R"] = devname
      read_bytes += $return
    }
  }
}

probe vfs.write.return {
  if ($return>0) {
    if (devname!="N/A") { /*пропуск операций обновления кэша*/
      io_stat[pid(),execname(),uid(),ppid(),"W"] += $return
      device[pid(),execname(),uid(),ppid(),"W"] = devname
      write_bytes += $return
    }
  }
}

probe timer.ms(5000) {
  /* пропуск операций, не являющихся операциями чтения данных с диска/записи данных на диск */
  if (read_bytes+write_bytes) {

printf("\n%-25s, %-8s%4dКБ/с, %-7s%6dKБ, %-7s%6dКБ\n\n",
           ctime(gettimeofday_s()),
           "Среднее:", ((read_bytes+write_bytes)/1024)/5,
           "Чтение:",read_bytes/1024,
           "Запись:",write_bytes/1024)

/* вывод заголовка */
    printf("%8s %8s %8s %25s %12s %4s %12s\n",
           "UID","PID","PPID","КОМАНДА","УСТРОЙСТВО","Т","БАЙТЫ")
  }
  /* вывод информации о десяти процессах, наиболее интенсивно осуществляющих операции ввода/вывода */
  foreach ([process,cmd,userid,parent,action] in io_stat- limit 10)
    printf("%8d %8d %8d %25s %12s %4s %12d\n",
           userid,process,parent,cmd,
           device[process,cmd,userid,parent,action],
           action,io_stat[process,cmd,userid,parent,action])

/* очистка значений переменных */
  delete io_stat
  delete device
  read_bytes = 0
  write_bytes = 0  
}

probe end{
  delete io_stat
  delete device
  delete read_bytes
  delete write_bytes
}

Сценарий disktop.stp выводит информацию о десяти процессах, наиболее интенсивно выполняющих чтение данных с диска/запись данных на диск. В Примере 5.6, "Вариант вывода сценария disktop.stp" показан фрагмент вывода данного сценария, содержащий следующую информацию для каждого процесса из списка:

UID - идентификатор пользователя. Идентификатор пользователя 0 соответствует учетной записи пользователя с именем root.
PID - идентификатор процесса из списка.
PPID - идентификатор родительского процесса для процесса из списка.
КОМАНДА - имя процесса из списка.
УСТРОЙСТВО - имя файла устройства, с которого читает данные или на которое записывает данные процесс из списка.
T - тип операции, выполняемой процессом из списка; символ W соответствует операции записи, R - операции чтения.
БАЙТЫ - объем данных, прочитанных с диска или записанных на диск.

Строки времени и даты, выводимые сценарием disktop.stp, генерируются с помощью функций ctime() и gettimeofday_s(). Функция ctime() преобразует в строку значение календарного времени в секундах с начала эпохи Unix (1 января 1970). Функция gettimeofday_s подсчитывает действительное количество секунд с начала эпохи Unix, на основе которого может быть сгенерировано достаточно точное, читаемое строковое представление даты и времени.

В данном сценарии переменная $return является локальной переменной, хранящей действительное количество байт, которое каждый процесс читает из виртуальной файловой системы или записывает в нее. Переменная $return может использоваться исключительно в зондах для отслеживания событий выхода из функций (например, vfs.read.return и vfs.write.return).

Пример 5.6, "Вариант вывода сценария disktop.stp"

5.2.2. Отслеживание затрат времени на операции ввода/вывода для каждой операции чтения или записи

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

iotime.stp

#! /usr/bin/env stap

/*
 * Авторские права (C) 2006-2007 Red Hat Inc.
 * 
 * Данный защищенный авторскими правами материал доступен для любого желающего 
 * использовать, модифицировать, копировать или распространять его в соответствии с 
 * условиями Универсальной общественной лицензии версии 2.
 *
 * Вы должны были получить копию Универсальной общественной лицензии GNU вместе с
 * данной программой.  Если это не так, перейдите по адресу <http://www.gnu.org/licenses/>.
 *
 * Сценарий выводит время, затраченное на выполнение системных вызовов для чтения и 
 * записи в момент, когда каждый из открытых процессом файлов закрывается. Учтите, что 
 * сценарий systemtap должен быть запущен перед выполнением операций открытия файлов
 * для того, чтобы он имел возможность сохранить полученные данные.
 *
 * Данный сценарий может быть использован для установления того, какие файлы медленно
 * обрабатываются на используемой машине, следующим образом:
 *
 * stap iotime.stp -c 'firefox'
 *
 * Формат вывода:
 * метка_времени pid (исполняемый_файл) тип_информации путь к файлу ...
 *
 * 200283135 2573 (cupsd) доступ /etc/printcap прочитано: 0 записано: 7063
 * 200283143 2573 (cupsd) время доступа /etc/printcap время: 69
 *
 */

global start
global time_io

function timestamp:long() { return gettimeofday_us() - start }

function proc:string() { return sprintf("%d (%s)", pid(), execname()) }

probe begin { start = gettimeofday_us() }

global filehandles, fileread, filewrite

probe syscall.open.return {
  filename = user_string($filename)
  if ($return != -1) {
    filehandles[pid(), $return] = filename
  } else {
    printf("%d %s доступ к файлу %s завершился неудачей\n", timestamp(), proc(), filename)
  }
}

probe syscall.read.return {
  p = pid()
  fd = $fd
  bytes = $return
  time = gettimeofday_us() - @entry(gettimeofday_us())
  if (bytes > 0)
    fileread[p, fd] += bytes
  time_io[p, fd] <<< time
}

probe syscall.write.return {
  p = pid()
  fd = $fd
  bytes = $return
  time = gettimeofday_us() - @entry(gettimeofday_us())
  if (bytes > 0)
    filewrite[p, fd] += bytes
  time_io[p, fd] <<< time
}

probe syscall.close {
  if ([pid(), $fd] in filehandles) {
    printf("%d %s доступ к файлу %s прочитано: %d записано: %d\n",
           timestamp(), proc(), filehandles[pid(), $fd],
           fileread[pid(), $fd], filewrite[pid(), $fd])
    if (@count(time_io[pid(), $fd]))
      printf("%d %s время доступа к файлу %s время: %d\n",  timestamp(), proc(),
             filehandles[pid(), $fd], @sum(time_io[pid(), $fd]))
   }
  delete fileread[pid(), $fd]
  delete filewrite[pid(), $fd]
  delete filehandles[pid(), $fd]
  delete time_io[pid(),$fd]
}

Сценарий iotime.stp отслеживает каждый системный вызов, который используется для открытия файла, закрытия файла, чтения данных из файла и записи данных в файл. При каждом доступе к файлу посредством системного вызова сценарий iotime.stp подсчитывает количество микросекунд, которые требуются для завершения операций чтения данных из файла и записи данных в файл и отслеживает объем данных (в байтах), прочитанных из файла или записанных в файл.

Также сценарий iotime.stp использует локальную переменную $count для отслеживания объема данных (в байтах), который процесс пытается прочитать из файла или записать в файл с помощью системного вызова. Обратите внимание на то, что переменная $return (которая используется также и в сценарии disktop.stp из Раздела 5.2.1, "Подсчет объема данных при чтении данных с диска/записи данных на диск") хранит реальный объем прочитанных с диска/записанных на диск данных. Переменная $count может использоваться исключительно в рамках зондов, которые отслеживают операции чтения и записи данных (таких, как syscall.read и syscall.write).

Пример 5.7. Вариант вывода сценария iotime.stp

Вывод сценария из Примера 5.7, "Вариант вывода сценария iotime.stp", содержит следующую информацию:

Метку времени в микросекундах
Идентификатор процесса и имя процесса
Флаг операции доступа или времени доступа к данным
Имя файла, к которому осуществлялся доступ

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

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

5.2.3. Отслеживание совокупного объема данных, перемещенных с помощью операций ввода/вывода

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

traceio.stp

#! /usr/bin/env stap
# traceio.stp
# Авторские права (C) 2007 Red Hat, Inc., Eugene Teo <eteo@redhat.com>
# Авторские права (C) 2009 Kai Meyer <kai@unixlords.com>
#   Исправлена ошибка, в результате которой сценарий исполнялся дольше положенного времени 
#   Также добавлена функция для вывода информации в читаемой форме
#
# Данная программа является свободным программным обеспечением; вы можете 
# распространять и/или модифицировать ее в соответствии с условиями Универсальной
# общественной лицензии GNU версии 2, опубликованной Фондом свободного 
# программного обеспечения.
#

global reads, writes, total_io

probe vfs.read.return {
  if ($return > 0) {
    reads[pid(),execname()] += $return
    total_io[pid(),execname()] += $return
  }
}

probe vfs.write.return {
  if ($return > 0) {
    writes[pid(),execname()] += $return
    total_io[pid(),execname()] += $return
  }
}

function humanreadable(bytes) {
  if (bytes > 1024*1024*1024) {
    return sprintf("%d ГиБ", bytes/1024/1024/1024)
  } else if (bytes > 1024*1024) {
    return sprintf("%d МиБ", bytes/1024/1024)
  } else if (bytes > 1024) {
    return sprintf("%d КиБ", bytes/1024)
  } else {
    return sprintf("%d   Б", bytes)
  }
}

probe timer.s(1) {
  foreach([p,e] in total_io- limit 10)
    printf("%8d %15s ч: %12s з: %12s\n",
           p, e, humanreadable(reads[p,e]),
           humanreadable(writes[p,e]))
  printf("\n")
  # Обратите внимание на то, что нам не нужно обнулять количество операций чтения, записи
  # и общее количество операций ввода/вывода, поэтому переменные хранят совокупные
  # значения, вычисляемые с момента запуска сценария.
}

Сценарий traceio.stp выводит информацию о первых десяти процессах, наиболее интенсивно перемещающих данные с помощью операций ввода/вывода с течением времени. В дополнение он также позволяет отслеживать совокупный объем данных, прочитанных и записанных этими десятью процессами с помощью операций ввода/вывода. Вся эта информация обрабатывается и выводится с интервалом в 1 секунду, при этом информация о процессах сортируется в соответствии с убыванием объема перемещенных данных.

Обратите внимание на то, что в сценарии traceio.stp используется локальная переменная $return, которая также используется в сценарии disktop.stp из Раздела 5.2.1, "Подсчет объема данных при чтении данных с диска/записи данных на диск".

Пример 5.8. Вариант вывода сценария traceio.stp

5.2.4. Мониторинг операций ввода/вывода (для устройства)

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

traceio2.stp

Сценарий traceio2.stp принимает 1 аргумент: номер самого устройства. Для получения этого номера используйте команду stat -c "0x%D" директория, где вместо строки директория должен использоваться путь к директории, расположенной на устройстве для мониторинга операций ввода/вывода.

Функция usrdev2kerndev() преобразует номер устройства в формат, с которым работает ядро ОС. Возвращаемое функцией usrdev2kerndev() значение используется вместе с функциями MKDEV(), MINOR() и MAJOR() для получения основного и дополнительного номеров определенного устройства.

Вывод сценария traceio2.stp содержит имена и идентификаторы каждого из процессов, осуществляющих чтение/запись, имя функции, в рамках которой выполнялась операция (а именно, vfs_read или vfs_write), а также номер устройства в рамках ядра ОС.

В следующем примере приведен фрагмент вывода сценария, запущенного с помощью команды stap traceio2.stp 0x805, где число 0x805 является номером устройства, на котором расположена директория /home. Директория /home расположена на устройстве /dev/sda5, следовательно, мы будем осуществлять мониторинг именно этого устройства.

Пример 5.9. Вариант вывода сценария traceio2.stp

[...]
synergyc(3722) vfs_read 0x800005
synergyc(3722) vfs_read 0x800005
cupsd(2889) vfs_write 0x800005
cupsd(2889) vfs_write 0x800005
cupsd(2889) vfs_write 0x800005
[...]

5.2.5. Мониторинг операций чтения данных из файла и записи данных в файл

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

inodewatch.stp

#! /usr/bin/env stap

probe vfs.write, vfs.read
{
  # переменные dev и ino объявлены в рамках событий vfs.write и vfs.read
  if (dev == MKDEV($1,$2) # основной/дополнительный номер устройства
      && ino == $3)
    printf ("%s(%d) %s 0x%x/%u\n",
      execname(), pid(), ppfunc(), dev, ino)
}

Сценарий inodewatch.stp принимает следующую информацию о файле в качестве аргументов командной строки:

Основной номер устройства, на котором находится файл.
Дополнительный номер устройства, на котором находится файл.
Номер inode файла.

Для получения данной информации следует использовать команду stat -c '%D %i' имя_файла, где вместо строки имя_файла должен использоваться абсолютный путь к файлу.

Например, для мониторинга операций в отношении файла /etc/crontab в первую очередь следует выполнить команду stat -c '%D %i' /etc/crontab. В результате будет получен следующий вывод:

805 1078319

Число 805 является номером устройства (в шестнадцатеричном формате). Две цифры, соответствующие низшим разрядам, представляют дополнительный номер устройства, а цифры, соответствующие высшим разрядам - основной номер устройства. Значение 1078319 является номером inode файла. Для начала мониторинга операций в отношении файла /etc/crontab следует выполнить команду stap inodewatch.stp 0x8 0x05 1078319 (префикс 0x используется для указания на шестнадцатеричные значения).

Вывод данного сценария содержит имя и идентификатор любого процесса, который осуществляет операции чтения/записи заданного файла, имя функции, в рамках которой они осуществляются (а именно, vfs_read или vfs_write), номер устройства (в шестнадцатеричном формате), а также номер inode. Пример 5.10, "Вариант вывода сценария inodewatch.stp" содержит вывод сценария, запущенного с помощью команды stap inodewatch.stp 0x8 0x05 1078319 (при исполнении команды cat /etc/crontab в процессе работы сценария):

Пример 5.10. Вариант вывода сценария inodewatch.stp

cat(16437) vfs_read 0x800005/1078319
cat(16437) vfs_read 0x800005/1078319

5.2.6. Мониторинг изменений атрибутов файлов

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

inodewatch2.stp

Как и сценарий inodewatch.stp из Раздела 5.2.5, "Мониторинг операций чтения данных из файла и записи данных в файл", сценарий inodewatch2.stp принимает номер устройства, на котором расположен целевой файл (в целочисленном формате) и номер inode в качестве аргументов. Для ознакомления с дополнительной информацией о способе получения упомянутых данных, обратитесь к Разделу 5.2.5, "Мониторинг операций чтения данных из файла и записи данных в файл".

Вывод сценария inodewatch2.stp аналогичен выводу сценария inodewatch.stp за исключением того, что сценарий inodewatch2.stp также выводит информацию о изменении атрибутов целевого файла вместе с идентификатором осуществившего это изменение пользователя (uid()). В Примере 5.11, "Вариант вывода сценария inodewatch2.stp" показан вывод сценария inodewatch2.stp в момент, когда в процессе мониторинга изменений атрибутов файла /home/joe/bigfile пользователь joe выполняет команды chmod 777 /home/joe/bigfile и chmod 666 /home/joe/bigfile.

Пример 5.11. Вариант вывода сценария inodewatch2.stp

chmod(17448) inode_setattr 0x800005/6011835 100777 500
chmod(17449) inode_setattr 0x800005/6011835 100666 500

5.2.7. Периодический вывод времени блокировки ввода-вывода

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

ioblktime.stp

Сценарий ioblktime.stp рассчитывает среднее время ожидания операции ввода/вывода с блокировкой для устройства и выводит полученную информацию через каждые 10 секунд. Как обычно, вы можете изменить эту частоту вывода информации, отредактировав значение, заданное в строке probe timer.s(10), end {.

В некоторых случаях может осуществляться большое количество ресурсоемких операций ввода/вывода с блокировками, что в конце концов приведет к превышению стандартного для сценария значения MAXMAPENTRIES. Значение MAXMAPENTRIES устанавливает максимальное количество элементов массива, если размер массива явно не указывался при объявлении. В том случае, если превышается стандартное значение MAXMAPENTRIES, равное 2048, снова запустите сценарий, используя параметр -DMAXMAPENTRIES=10000 утилиты stap.

Пример 5.12. Вариант вывода сценария ioblktime.stp

устройство  rw всего (мс) количество среднее (мс)
       sda   W       9659          6         1609
      dm-0   W      20278          6         3379
      dm-0   R      20524          5         4104
       sda   R      19277          5         3855

В выводе из Примера 5.12, "Вариант вывода сценария ioblktime.stp" отражены имя устройства, выполненные операции (rw), общее время выполнения всех операций (всего (мс)), количество операций (количество), а также среднее время ожидания для всех этих операций (среднее (мс)). Значения времени, рассчитанные с помощью сценария, выводятся в микросекундах.

Следующий раздел : 5.3. Профилирование.