[DO NOT COMMIT] Refactor systrace to support new clock sync design

systrace/systrace/agents/ftrace_agent.py

-# Copyright (c) 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 os
-import sys
-import time
-
-from systrace import systrace_agent
-
-
-class FtraceAgentIo(object):
-
-  @staticmethod
-  def writeFile(path, data):
-    with open(path, 'w') as f:
-      f.write(data)
-
-  @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/", "power/clock_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(options, categories):
-  if options.target != 'linux':
-    return False
-  return FtraceAgent(options, categories, FtraceAgentIo)
-
-
-class FtraceAgent(systrace_agent.SystraceAgent):
-
-  def __init__(self, options, categories, fio=FtraceAgentIo):
-    """Initialize a systrace agent.
-
-    Args:
-      options: The command-line options.
-      categories: The trace categories to capture.
-    """
-    super(FtraceAgent, self).__init__(options, categories)
-    if not self._categories:
-      self._categories = ["sched"]
-    self._fio = fio
-    self._categories = [x for x in self._categories
-                        if self._is_category_available(x)]
-    self._expect_trace = False
-
-  def _get_trace_buffer_size(self):
-    buffer_size = 4096
-    if ((self._options.trace_buf_size is not None)
-        and (self._options.trace_buf_size > 0)):
-      buffer_size = self._options.trace_buf_size
-    return buffer_size
-
-  def _get_trace_time(self):
-    wait_time = 5
-    if ((self._options.trace_time is not None)
-        and (self._options.trace_time > 0)):
-      wait_time = self._options.trace_time
-    return wait_time
-
-  def start(self):
-    """Start tracing.
-    """
-    if self._options.list_categories or len(self._categories) == 0:
-      self._expect_trace = False
-    else:
-      self._expect_trace = True
-
-      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 self._categories:
-        self._category_enable(category)
-
-      self._fio.writeFile(FT_TRACE, '')
-
-      print "starting tracing."
-      sys.stdout.flush()
-
-      self._fio.writeFile(FT_TRACE_ON, '1')
-
-  def collect_result(self):
-    """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.
-    """
-    if self._options.list_categories or len(self._categories) == 0:
-      self._print_avail_categories()
-    else:
-      try:
-        time.sleep(self._get_trace_time())
-      except KeyboardInterrupt:
-        pass
-      self._fio.writeFile(FT_TRACE_ON, '0')
-      for category in self._categories:
-        self._category_disable(category)
-      if self._options.fix_threads:
-        print "WARN: thread name fixing is not yet supported."
-      if self._options.fix_tgids:
-        print "WARN: tgid fixing is not yet supported."
-      if self._options.fix_circular:
-        print "WARN: circular buffer fixups are not yet supported."
-
-  def expect_trace(self):
-    """Check if the agent is returning a trace or not.
-
-    This will be determined in collect_result().
-    Returns:
-      Whether the agent is expecting a trace or not.
-    """
-    return self._expect_trace
-
-  def get_trace_data(self):
-    """Get the trace data.
-
-    Returns:
-      The trace data.
-    """
-    d = self._fio.readFile(FT_TRACE)
-    self._fio.writeFile(FT_BUFFER_SIZE, "1")
-    return d
-
-  def get_class_name(self):
-    return 'trace-data'
-
-  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 options:"
-      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")