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 tv.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('f2fs_write_begin',
  29         DiskParser.prototype.f2fsWriteBeginEvent.bind(this));
  30     importer.registerEventHandler('f2fs_write_end',
  31         DiskParser.prototype.f2fsWriteEndEvent.bind(this));
  32     importer.registerEventHandler('f2fs_sync_file_enter',
  33         DiskParser.prototype.f2fsSyncFileEnterEvent.bind(this));
  34     importer.registerEventHandler('f2fs_sync_file_exit',
  35         DiskParser.prototype.f2fsSyncFileExitEvent.bind(this));
  36     importer.registerEventHandler('ext4_sync_file_enter',
  37         DiskParser.prototype.ext4SyncFileEnterEvent.bind(this));
  38     importer.registerEventHandler('ext4_sync_file_exit',
  39         DiskParser.prototype.ext4SyncFileExitEvent.bind(this));
  40     importer.registerEventHandler('ext4_da_write_begin',
  41         DiskParser.prototype.ext4WriteBeginEvent.bind(this));
  42     importer.registerEventHandler('ext4_da_write_end',
  43         DiskParser.prototype.ext4WriteEndEvent.bind(this));
  44     importer.registerEventHandler('block_rq_issue',
  45         DiskParser.prototype.blockRqIssueEvent.bind(this));
  46     importer.registerEventHandler('block_rq_complete',
  47         DiskParser.prototype.blockRqCompleteEvent.bind(this));
  48   }
  49
  50   DiskParser.prototype = {
  51     __proto__: Parser.prototype,
  52
  53     openAsyncSlice: function(ts, category, threadName, pid, key, name) {
  54       var kthread = this.importer.getOrCreateKernelThread(
  55           category + ':' + threadName, pid);
  56       var asyncSliceConstructor =
  57          tracing.trace_model.AsyncSlice.getConstructor(
  58             category, name);
  59       var slice = new asyncSliceConstructor(
  60           category, name, tv.ui.getStringColorId(name), ts);
  61       slice.startThread = kthread.thread;
  62
  63       if (!kthread.openAsyncSlices) {
  64         kthread.openAsyncSlices = { };
  65       }
  66       kthread.openAsyncSlices[key] = slice;
  67     },
  68
  69     closeAsyncSlice: function(ts, category, threadName, pid, key, args) {
  70       var kthread = this.importer.getOrCreateKernelThread(
  71           category + ':' + threadName, pid);
  72       if (kthread.openAsyncSlices) {
  73         var slice = kthread.openAsyncSlices[key];
  74         if (slice) {
  75           slice.duration = ts - slice.start;
  76           slice.args = args;
  77           slice.endThread = kthread.thread;
  78           slice.subSlices = [
  79             new tracing.trace_model.Slice(category, slice.title,
  80                 slice.colorId, slice.start, slice.args, slice.duration)
  81           ];
  82           kthread.thread.asyncSliceGroup.push(slice);
  83           delete kthread.openAsyncSlices[key];
  84         }
  85       }
  86     },
  87
  88     /**
  89      * Parses events and sets up state in the importer.
  90      */
  91     f2fsWriteBeginEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
  92       var event = /dev = \((\d+,\d+)\), ino (\d+), pos (\d+), len (\d+), flags (\d+)/.
  93           exec(eventBase.details);
  94       if (!event)
  95         return false;
  96       var device = event[1];
  97       var inode = parseInt(event[2]);
  98       var pos = parseInt(event[3]);
  99       var len = parseInt(event[4]);
 100       var key = device + '-' + inode + '-' + pos + '-' + len;
 101       this.openAsyncSlice(ts, "f2fs", eventBase.threadName, eventBase.pid,
 102           key, "f2fs_write");
 103       return true;
 104     },
 105
 106     f2fsWriteEndEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 107       var event = /dev = \((\d+,\d+)\), ino (\d+), pos (\d+), len (\d+), copied (\d+)/.
 108           exec(eventBase.details);
 109       if (!event)
 110         return false;
 111
 112       var device = event[1];
 113       var inode = parseInt(event[2]);
 114       var pos = parseInt(event[3]);
 115       var len = parseInt(event[4]);
 116       var error = parseInt(event[5]) !== len;
 117       var key = device + '-' + inode + '-' + pos + '-' + len;
 118       this.closeAsyncSlice(ts, 'f2fs', eventBase.threadName, eventBase.pid,
 119           key, {
 120             device: device,
 121             inode: inode,
 122             error: error
 123           });
 124       return true;
 125     },
 126
 127     ext4WriteBeginEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 128       var event = /dev (\d+,\d+) ino (\d+) pos (\d+) len (\d+) flags (\d+)/.
 129           exec(eventBase.details);
 130       if (!event)
 131         return false;
 132       var device = event[1];
 133       var inode = parseInt(event[2]);
 134       var pos = parseInt(event[3]);
 135       var len = parseInt(event[4]);
 136       var key = device + '-' + inode + '-' + pos + '-' + len;
 137       this.openAsyncSlice(ts, "ext4", eventBase.threadName, eventBase.pid,
 138           key, "ext4_write");
 139       return true;
 140     },
 141
 142     ext4WriteEndEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 143       var event = /dev (\d+,\d+) ino (\d+) pos (\d+) len (\d+) copied (\d+)/.
 144           exec(eventBase.details);
 145       if (!event)
 146         return false;
 147
 148       var device = event[1];
 149       var inode = parseInt(event[2]);
 150       var pos = parseInt(event[3]);
 151       var len = parseInt(event[4]);
 152       var error = parseInt(event[5]) !== len;
 153       var key = device + '-' + inode + '-' + pos + '-' + len;
 154       this.closeAsyncSlice(ts, 'ext4', eventBase.threadName, eventBase.pid,
 155           key, {
 156             device: device,
 157             inode: inode,
 158             error: error
 159           });
 160       return true;
 161     },
 162
 163     f2fsSyncFileEnterEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 164       var event = new RegExp(
 165           'dev = \\((\\d+,\\d+)\\), ino = (\\d+), pino = (\\d+), i_mode = (\\S+), ' +
 166           'i_size = (\\d+), i_nlink = (\\d+), i_blocks = (\\d+), i_advise = (\\d+)').
 167           exec(eventBase.details);
 168       if (!event)
 169         return false;
 170
 171       var device = event[1];
 172       var inode = parseInt(event[2]);
 173       var key = device + '-' + inode;
 174       this.openAsyncSlice(ts, 'f2fs', eventBase.threadName, eventBase.pid,
 175           key, 'fsync');
 176       return true;
 177     },
 178
 179     f2fsSyncFileExitEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 180       var event = new RegExp('dev = \\((\\d+,\\d+)\\), ino = (\\d+), checkpoint is (\\S+), ' +
 181           'datasync = (\\d+), ret = (\\d+)').
 182           exec(eventBase.details.replace("not needed", "not_needed"));
 183       if (!event)
 184         return false;
 185
 186       var device = event[1];
 187       var inode = parseInt(event[2]);
 188       var error = parseInt(event[5]);
 189       var key = device + '-' + inode;
 190       this.closeAsyncSlice(ts, 'f2fs', eventBase.threadName, eventBase.pid,
 191           key, {
 192             device: device,
 193             inode: inode,
 194             error: error
 195           });
 196       return true;
 197     },
 198
 199     ext4SyncFileEnterEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 200       var event = /dev (\d+,\d+) ino (\d+) parent (\d+) datasync (\d+)/.
 201           exec(eventBase.details);
 202       if (!event)
 203         return false;
 204
 205       var device = event[1];
 206       var inode = parseInt(event[2]);
 207       var datasync = event[4] == 1;
 208       var key = device + '-' + inode;
 209       var action = datasync ? 'fdatasync' : 'fsync';
 210       this.openAsyncSlice(ts, 'ext4', eventBase.threadName, eventBase.pid,
 211           key, action);
 212       return true;
 213     },
 214
 215     ext4SyncFileExitEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 216       var event = /dev (\d+,\d+) ino (\d+) ret (\d+)/.exec(eventBase.details);
 217       if (!event)
 218         return false;
 219
 220       var device = event[1];
 221       var inode = parseInt(event[2]);
 222       var error = parseInt(event[3]);
 223       var key = device + '-' + inode;
 224       this.closeAsyncSlice(ts, 'ext4', eventBase.threadName, eventBase.pid,
 225           key, {
 226             device: device,
 227             inode: inode,
 228             error: error
 229           });
 230       return true;
 231     },
 232
 233     blockRqIssueEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 234       var event = new RegExp('(\\d+,\\d+) (F)?([DWRN])(F)?(A)?(S)?(M)? ' +
 235           '\\d+ \\(.*\\) (\\d+) \\+ (\\d+) \\[.*\\]').exec(eventBase.details);
 236       if (!event)
 237         return false;
 238
 239       var action;
 240       switch (event[3]) {
 241         case 'D':
 242           action = 'discard';
 243           break;
 244         case 'W':
 245           action = 'write';
 246           break;
 247         case 'R':
 248           action = 'read';
 249           break;
 250         case 'N':
 251           action = 'none';
 252           break;
 253         default:
 254           action = 'unknown';
 255           break;
 256       }
 257
 258       if (event[2]) {
 259         action += ' flush';
 260       }
 261       if (event[4] == 'F') {
 262         action += ' fua';
 263       }
 264       if (event[5] == 'A') {
 265         action += ' ahead';
 266       }
 267       if (event[6] == 'S') {
 268         action += ' sync';
 269       }
 270       if (event[7] == 'M') {
 271         action += ' meta';
 272       }
 273       var device = event[1];
 274       var sector = parseInt(event[8]);
 275       var numSectors = parseInt(event[9]);
 276       var key = device + '-' + sector + '-' + numSectors;
 277       this.openAsyncSlice(ts, 'block', eventBase.threadName, eventBase.pid,
 278           key, action);
 279       return true;
 280     },
 281
 282     blockRqCompleteEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 283       var event = new RegExp('(\\d+,\\d+) (F)?([DWRN])(F)?(A)?(S)?(M)? ' +
 284           '\\(.*\\) (\\d+) \\+ (\\d+) \\[(.*)\\]').exec(eventBase.details);
 285       if (!event)
 286         return false;
 287
 288       var device = event[1];
 289       var sector = parseInt(event[8]);
 290       var numSectors = parseInt(event[9]);
 291       var error = parseInt(event[10]);
 292       var key = device + '-' + sector + '-' + numSectors;
 293       this.closeAsyncSlice(ts, 'block', eventBase.threadName, eventBase.pid,
 294           key, {
 295             device: device,
 296             sector: sector,
 297             numSectors: numSectors,
 298             error: error
 299           });
 300       return true;
 301     }
 302   };
 303
 304   Parser.registerSubtype(DiskParser);
 305
 306   return {
 307     DiskParser: DiskParser
 308   };
 309 });
 310 </script>
 311