catapult/systrace/systrace/tracing_agents/ftrace_agent.py

# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import optparse
import os
import py_utils

from systrace import trace_result
from systrace import tracing_agents


class FtraceAgentIo(object):
  @staticmethod
  def writeFile(path, data):
    if FtraceAgentIo.haveWritePermissions(path):
      with open(path, 'w') as f:
        f.write(data)
    else:
      raise IOError('Cannot write to %s; did you forget sudo/root?' % path)

  @staticmethod
  def readFile(path):
    with open(path, 'r') as f:
      return f.read()

  @staticmethod
  def haveWritePermissions(path):
    return os.access(path, os.W_OK)


FT_DIR = "/sys/kernel/debug/tracing/"
FT_CLOCK = FT_DIR + "trace_clock"
FT_BUFFER_SIZE = FT_DIR + "buffer_size_kb"
FT_TRACER = FT_DIR + "current_tracer"
FT_PRINT_TGID = FT_DIR + "options/print-tgid"
FT_TRACE_ON = FT_DIR + "tracing_on"
FT_TRACE = FT_DIR + "trace"
FT_TRACE_MARKER = FT_DIR + "trace_marker"
FT_OVERWRITE = FT_DIR + "options/overwrite"

all_categories = {
    "sched": {
          "desc": "CPU Scheduling",
          "req": ["sched/sched_switch/", "sched/sched_wakeup/"]
    },
    "freq": {
          "desc": "CPU Frequency",
          "req": ["power/cpu_frequency/"],
          "opt": ["power/clock_set_rate/", "clk/clk_set_rate/"]
    },
    "irq": {
          "desc": "CPU IRQS and IPIS",
          "req": ["irq/"],
          "opt": ["ipi/"]
    },
    "workq": {
          "desc": "Kernel workqueues",
          "req": ["workqueue/"]
    },
    "memreclaim": {
          "desc": "Kernel Memory Reclaim",
          "req": ["vmscan/mm_vmscan_direct_reclaim_begin/",
                  "vmscan/mm_vmscan_direct_reclaim_end/",
                  "vmscan/mm_vmscan_kswapd_wake/",
                  "vmscan/mm_vmscan_kswapd_sleep/"]
    },
    "idle": {
          "desc": "CPU Idle",
          "req": ["power/cpu_idle/"]
    },
    "regulators": {
          "desc": "Voltage and Current Regulators",
          "req": ["regulator/"]
    },
    "disk": {
          "desc": "Disk I/O",
          "req": ["block/block_rq_issue/",
                  "block/block_rq_complete/"],
          "opt": ["f2fs/f2fs_sync_file_enter/",
                  "f2fs/f2fs_sync_file_exit/",
                  "f2fs/f2fs_write_begin/",
                  "f2fs/f2fs_write_end/",
                  "ext4/ext4_da_write_begin/",
                  "ext4/ext4_da_write_end/",
                  "ext4/ext4_sync_file_enter/",
                  "ext4/ext4_sync_file_exit/"]
    }
}


def try_create_agent(config):
  if config.target != 'linux':
    return None
  return FtraceAgent(FtraceAgentIo)


def list_categories(_):
  agent = FtraceAgent(FtraceAgentIo)
  agent._print_avail_categories()


class FtraceConfig(tracing_agents.TracingConfig):
  def __init__(self, ftrace_categories, target, trace_buf_size):
    tracing_agents.TracingConfig.__init__(self)
    self.ftrace_categories = ftrace_categories
    self.target = target
    self.trace_buf_size = trace_buf_size


def add_options(parser):
  options = optparse.OptionGroup(parser, 'Ftrace options')
  options.add_option('--ftrace-categories', dest='ftrace_categories',
                     help='Select ftrace categories with a comma-delimited '
                     'list, e.g. --ftrace-categories=cat1,cat2,cat3')
  return options


def get_config(options):
  return FtraceConfig(options.ftrace_categories, options.target,
                      options.trace_buf_size)


class FtraceAgent(tracing_agents.TracingAgent):

  def __init__(self, fio=FtraceAgentIo):
    """Initialize a systrace agent.

    Args:
      config: The command-line config.
      categories: The trace categories to capture.
    """
    super(FtraceAgent, self).__init__()
    self._fio = fio
    self._config = None
    self._categories = None

  def _get_trace_buffer_size(self):
    buffer_size = 4096
    if ((self._config.trace_buf_size is not None)
        and (self._config.trace_buf_size > 0)):
      buffer_size = self._config.trace_buf_size
    return buffer_size

  def _fix_categories(self, categories):
    """
    Applies the default category (sched) if there are no categories
    in the list and removes unavailable categories from the list.
    Args:
        categories: List of categories.
    """
    if not categories:
      categories = ["sched"]
    return [x for x in categories
            if self._is_category_available(x)]

  @py_utils.Timeout(tracing_agents.START_STOP_TIMEOUT)
  def StartAgentTracing(self, config, timeout=None):
    """Start tracing.
    """
    self._config = config
    categories = self._fix_categories(config.ftrace_categories)
    self._fio.writeFile(FT_BUFFER_SIZE,
                        str(self._get_trace_buffer_size()))
    self._fio.writeFile(FT_CLOCK, 'global')
    self._fio.writeFile(FT_TRACER, 'nop')
    self._fio.writeFile(FT_OVERWRITE, "0")

    # TODO: riandrews to push necessary patches for TGID option to upstream
    # linux kernel
    # self._fio.writeFile(FT_PRINT_TGID, '1')

    for category in categories:
      self._category_enable(category)

    self._categories = categories # need to store list of categories to disable
    print 'starting tracing.'

    self._fio.writeFile(FT_TRACE, '')
    self._fio.writeFile(FT_TRACE_ON, '1')
    return True

  @py_utils.Timeout(tracing_agents.START_STOP_TIMEOUT)
  def StopAgentTracing(self, timeout=None):
    """Collect the result of tracing.

    This function will block while collecting the result. For sync mode, it
    reads the data, e.g., from stdout, until it finishes. For async mode, it
    blocks until the agent is stopped and the data is ready.
    """
    self._fio.writeFile(FT_TRACE_ON, '0')
    for category in self._categories:
      self._category_disable(category)
    return True

  @py_utils.Timeout(tracing_agents.GET_RESULTS_TIMEOUT)
  def GetResults(self, timeout=None):
    # get the output
    d = self._fio.readFile(FT_TRACE)
    self._fio.writeFile(FT_BUFFER_SIZE, "1")
    return trace_result.TraceResult('trace-data', d)

  def SupportsExplicitClockSync(self):
    return False

  def RecordClockSyncMarker(self, sync_id, did_record_sync_marker_callback):
    # No implementation, but need to have this to support the API
    # pylint: disable=unused-argument
    return False

  def _is_category_available(self, category):
    if category not in all_categories:
      return False
    events_dir = FT_DIR + "events/"
    req_events = all_categories[category]["req"]
    for event in req_events:
      event_full_path = events_dir + event + "enable"
      if not self._fio.haveWritePermissions(event_full_path):
        return False
    return True

  def _avail_categories(self):
    ret = []
    for event in all_categories:
      if self._is_category_available(event):
        ret.append(event)
    return ret

  def _print_avail_categories(self):
    avail = self._avail_categories()
    if len(avail):
      print "tracing config:"
      for category in self._avail_categories():
        desc = all_categories[category]["desc"]
        print "{0: <16}".format(category), ": ", desc
    else:
      print "No tracing categories available - perhaps you need root?"

  def _category_enable_paths(self, category):
    events_dir = FT_DIR + "events/"
    req_events = all_categories[category]["req"]
    for event in req_events:
      event_full_path = events_dir + event + "enable"
      yield event_full_path
    if "opt" in all_categories[category]:
      opt_events = all_categories[category]["opt"]
      for event in opt_events:
        event_full_path = events_dir + event + "enable"
        if self._fio.haveWritePermissions(event_full_path):
          yield event_full_path

  def _category_enable(self, category):
    for path in self._category_enable_paths(category):
      self._fio.writeFile(path, "1")

  def _category_disable(self, category):
    for path in self._category_enable_paths(category):
      self._fio.writeFile(path, "0")