src/third_party/trace-viewer/trace_viewer/tracing/importer/linux_perf/disk_parser.html

   1 <!DOCTYPE html>
   2 <!--
   3 Copyright (c) 2013 The Chromium Authors. All rights reserved.
   4 Use of this source code is governed by a BSD-style license that can be
   5 found in the LICENSE file.
   6 -->
   7
   8 <link rel="import" href="/tracing/importer/linux_perf/parser.html">
   9
  10 <script>
  11 'use strict';
  12
  13 /**
  14  * @fileoverview Parses filesystem and block device events in the Linux event
  15  * trace format.
  16  */
  17 tvcm.exportTo('tracing.importer.linux_perf', function() {
  18
  19   var Parser = tracing.importer.linux_perf.Parser;
  20
  21   /**
  22    * Parses linux filesystem and block device trace events.
  23    * @constructor
  24    */
  25   function DiskParser(importer) {
  26     Parser.call(this, importer);
  27
  28     importer.registerEventHandler('ext4_sync_file_enter',
  29         DiskParser.prototype.ext4SyncFileEnterEvent.bind(this));
  30     importer.registerEventHandler('ext4_sync_file_exit',
  31         DiskParser.prototype.ext4SyncFileExitEvent.bind(this));
  32     importer.registerEventHandler('block_rq_issue',
  33         DiskParser.prototype.blockRqIssueEvent.bind(this));
  34     importer.registerEventHandler('block_rq_complete',
  35         DiskParser.prototype.blockRqCompleteEvent.bind(this));
  36   }
  37
  38   DiskParser.prototype = {
  39     __proto__: Parser.prototype,
  40
  41     openAsyncSlice: function(ts, category, threadName, pid, key, name) {
  42       var kthread = this.importer.getOrCreateKernelThread(
  43           category + ':' + threadName, pid);
  44       var slice = new tracing.trace_model.AsyncSlice(
  45           category, name, tvcm.ui.getStringColorId(name), ts);
  46       slice.startThread = kthread.thread;
  47
  48       if (!kthread.openAsyncSlices) {
  49         kthread.openAsyncSlices = { };
  50       }
  51       kthread.openAsyncSlices[key] = slice;
  52     },
  53
  54     closeAsyncSlice: function(ts, category, threadName, pid, key, args) {
  55       var kthread = this.importer.getOrCreateKernelThread(
  56           category + ':' + threadName, pid);
  57       if (kthread.openAsyncSlices) {
  58         var slice = kthread.openAsyncSlices[key];
  59         if (slice) {
  60           slice.duration = ts - slice.start;
  61           slice.args = args;
  62           slice.endThread = kthread.thread;
  63           slice.subSlices = [
  64             new tracing.trace_model.Slice(category, slice.title,
  65                 slice.colorId, slice.start, slice.args, slice.duration)
  66           ];
  67           kthread.thread.asyncSliceGroup.push(slice);
  68           delete kthread.openAsyncSlices[key];
  69         }
  70       }
  71     },
  72
  73     /**
  74      * Parses events and sets up state in the importer.
  75      */
  76     ext4SyncFileEnterEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
  77       var event = /dev (\d+,\d+) ino (\d+) parent (\d+) datasync (\d+)/.
  78           exec(eventBase.details);
  79       if (!event)
  80         return false;
  81
  82       var device = event[1];
  83       var inode = parseInt(event[2]);
  84       var datasync = event[4] == 1;
  85       var key = device + '-' + inode;
  86       var action = datasync ? 'fdatasync' : 'fsync';
  87       this.openAsyncSlice(ts, 'ext4', eventBase.threadName, eventBase.pid,
  88           key, action);
  89       return true;
  90     },
  91
  92     ext4SyncFileExitEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
  93       var event = /dev (\d+,\d+) ino (\d+) ret (\d+)/.exec(eventBase.details);
  94       if (!event)
  95         return false;
  96
  97       var device = event[1];
  98       var inode = parseInt(event[2]);
  99       var error = parseInt(event[3]);
 100       var key = device + '-' + inode;
 101       this.closeAsyncSlice(ts, 'ext4', eventBase.threadName, eventBase.pid,
 102           key, {
 103             device: device,
 104             inode: inode,
 105             error: error
 106           });
 107       return true;
 108     },
 109
 110     blockRqIssueEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 111       var event = new RegExp('(\\d+,\\d+) (F)?([DWRN])(F)?(A)?(S)?(M)? ' +
 112           '\\d+ \\(.*\\) (\\d+) \\+ (\\d+) \\[.*\\]').exec(eventBase.details);
 113       if (!event)
 114         return false;
 115
 116       var action;
 117       switch (event[3]) {
 118         case 'D':
 119           action = 'discard';
 120           break;
 121         case 'W':
 122           action = 'write';
 123           break;
 124         case 'R':
 125           action = 'read';
 126           break;
 127         case 'N':
 128           action = 'none';
 129           break;
 130         default:
 131           action = 'unknown';
 132           break;
 133       }
 134
 135       if (event[2]) {
 136         action += ' flush';
 137       }
 138       if (event[4] == 'F') {
 139         action += ' fua';
 140       }
 141       if (event[5] == 'A') {
 142         action += ' ahead';
 143       }
 144       if (event[6] == 'S') {
 145         action += ' sync';
 146       }
 147       if (event[7] == 'M') {
 148         action += ' meta';
 149       }
 150       var device = event[1];
 151       var sector = parseInt(event[8]);
 152       var numSectors = parseInt(event[9]);
 153       var key = device + '-' + sector + '-' + numSectors;
 154       this.openAsyncSlice(ts, 'block', eventBase.threadName, eventBase.pid,
 155           key, action);
 156       return true;
 157     },
 158
 159     blockRqCompleteEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 160       var event = new RegExp('(\\d+,\\d+) (F)?([DWRN])(F)?(A)?(S)?(M)? ' +
 161           '\\(.*\\) (\\d+) \\+ (\\d+) \\[(.*)\\]').exec(eventBase.details);
 162       if (!event)
 163         return false;
 164
 165       var device = event[1];
 166       var sector = parseInt(event[8]);
 167       var numSectors = parseInt(event[9]);
 168       var error = parseInt(event[10]);
 169       var key = device + '-' + sector + '-' + numSectors;
 170       this.closeAsyncSlice(ts, 'block', eventBase.threadName, eventBase.pid,
 171           key, {
 172             device: device,
 173             sector: sector,
 174             numSectors: numSectors,
 175             error: error
 176           });
 177       return true;
 178     }
 179   };
 180
 181   Parser.registerSubtype(DiskParser);
 182
 183   return {
 184     DiskParser: DiskParser
 185   };
 186 });
 187 </script>
 188