Lines Matching refs:event
445 const SchedBlockedReasonFtraceEvent& event
448 event.pid(), event.io_wait(), event.caller());
469 std::string FormatCpuFrequency(const CpuFrequencyFtraceEvent& event) {
472 event.state(), event.cpu_id());
477 const CpuFrequencyLimitsFtraceEvent& event) {
482 event.min_freq(), event.max_freq(), event.cpu_id());
486 std::string FormatCpuIdle(const CpuIdleFtraceEvent& event) {
488 sprintf(line, "cpu_idle: state=%" PRIu32 " cpu_id=%" PRIu32, event.state(),
489 event.cpu_id());
493 std::string FormatClockSetRate(const ClockSetRateFtraceEvent& event) {
496 event.name().empty() ? "todo" : event.name().c_str(), event.state(),
497 event.cpu_id());
501 std::string FormatClockEnable(const ClockEnableFtraceEvent& event) {
504 event.name().empty() ? "todo" : event.name().c_str(), event.state(),
505 event.cpu_id());
509 std::string FormatClockDisable(const ClockDisableFtraceEvent& event) {
512 event.name().empty() ? "todo" : event.name().c_str(), event.state(),
513 event.cpu_id());
517 std::string FormatTracingMarkWrite(const TracingMarkWriteFtraceEvent& event) {
519 sprintf(line, "tracing_mark_write: %s|%d|%s", event.trace_begin() ? "B" : "E",
520 event.pid(), event.trace_name().c_str());
524 std::string FormatBinderLocked(const BinderLockedFtraceEvent& event) {
526 sprintf(line, "binder_locked: tag=%s", event.tag().c_str());
530 std::string FormatBinderUnlock(const BinderUnlockFtraceEvent& event) {
532 sprintf(line, "binder_unlock: tag=%s", event.tag().c_str());
536 std::string FormatBinderLock(const BinderLockFtraceEvent& event) {
538 sprintf(line, "binder_lock: tag=%s", event.tag().c_str());
542 std::string FormatBinderTransaction(const BinderTransactionFtraceEvent& event) {
547 event.debug_id(), event.target_node(), event.to_proc(),
548 event.to_thread(), event.reply(), event.flags(), event.code());
553 const BinderTransactionReceivedFtraceEvent& event) {
556 event.debug_id());
560 std::string FormatExt4SyncFileEnter(const Ext4SyncFileEnterFtraceEvent& event) {
564 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.parent(),
565 event.datasync());
569 std::string FormatExt4SyncFileExit(const Ext4SyncFileExitFtraceEvent& event) {
572 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.ret());
576 std::string FormatExt4DaWriteBegin(const Ext4DaWriteBeginFtraceEvent& event) {
580 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pos(),
581 event.len(), event.flags());
585 std::string FormatExt4DaWriteEnd(const Ext4DaWriteEndFtraceEvent& event) {
589 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pos(),
590 event.len(), event.copied());
594 std::string FormatBlockRqIssue(const BlockRqIssueFtraceEvent& event) {
597 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
598 event.bytes(), event.cmd().c_str(),
599 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
600 event.comm().c_str());
604 std::string FormatI2cRead(const I2cReadFtraceEvent& event) {
606 sprintf(line, "i2c_read: i2c-%d #%u a=%03x f=%04x l=%u", event.adapter_nr(),
607 event.msg_nr(), event.addr(), event.flags(), event.len());
611 std::string FormatI2cResult(const I2cResultFtraceEvent& event) {
613 sprintf(line, "i2c_result: i2c-%d n=%u ret=%d", event.adapter_nr(),
614 event.nr_msgs(), event.ret());
618 std::string FormatIrqHandlerEntry(const IrqHandlerEntryFtraceEvent& event) {
620 sprintf(line, "irq_handler_entry: irq=%d name=%s", event.irq(),
621 event.name().c_str());
625 std::string FormatIrqHandlerExit(const IrqHandlerExitFtraceEvent& event) {
627 sprintf(line, "irq_handler_exit: irq=%d ret=%s", event.irq(),
628 event.ret() ? "handled" : "unhandled");
633 const MmVmscanKswapdWakeFtraceEvent& event) {
635 sprintf(line, "mm_vmscan_kswapd_wake: nid=%d order=%d", event.nid(),
636 event.order());
641 const MmVmscanKswapdSleepFtraceEvent& event) {
643 sprintf(line, "mm_vmscan_kswapd_sleep: nid=%d", event.nid());
647 std::string FormatRegulatorEnable(const RegulatorEnableFtraceEvent& event) {
649 sprintf(line, "regulator_enable: name=%s", event.name().c_str());
654 const RegulatorEnableDelayFtraceEvent& event) {
656 sprintf(line, "regulator_enable_delay: name=%s", event.name().c_str());
661 const RegulatorEnableCompleteFtraceEvent& event) {
663 sprintf(line, "regulator_enable_complete: name=%s", event.name().c_str());
667 std::string FormatRegulatorDisable(const RegulatorDisableFtraceEvent& event) {
669 sprintf(line, "regulator_disable: name=%s", event.name().c_str());
674 const RegulatorDisableCompleteFtraceEvent& event) {
676 sprintf(line, "regulator_disable_complete: name=%s", event.name().c_str());
681 const RegulatorSetVoltageFtraceEvent& event) {
683 sprintf(line, "regulator_set_voltage: name=%s (%d-%d)", event.name().c_str(),
684 event.min(), event.max());
689 const RegulatorSetVoltageCompleteFtraceEvent& event) {
692 event.name().c_str(), event.val());
696 std::string FormatSchedCpuHotplug(const SchedCpuHotplugFtraceEvent& event) {
698 sprintf(line, "sched_cpu_hotplug: cpu %d %s error=%d", event.affected_cpu(),
699 event.status() ? "online" : "offline", event.error());
703 std::string FormatSyncTimeline(const SyncTimelineFtraceEvent& event) {
705 sprintf(line, "sync_timeline: name=%s value=%s", event.name().c_str(),
706 event.value().c_str());
710 std::string FormatSyncWait(const SyncWaitFtraceEvent& event) {
713 event.begin() ? "begin" : "end", event.name().c_str(),
714 event.status());
718 std::string FormatSyncPt(const SyncPtFtraceEvent& event) {
720 sprintf(line, "sync_pt: name=%s value=%s", event.timeline().c_str(),
721 event.value().c_str());
725 std::string FormatSoftirqRaise(const SoftirqRaiseFtraceEvent& event) {
727 sprintf(line, "softirq_raise: vec=%u [action=%s]", event.vec(),
728 SoftirqArray[event.vec()]);
732 std::string FormatSoftirqEntry(const SoftirqEntryFtraceEvent& event) {
734 sprintf(line, "softirq_entry: vec=%u [action=%s]", event.vec(),
735 SoftirqArray[event.vec()]);
739 std::string FormatSoftirqExit(const SoftirqExitFtraceEvent& event) {
741 sprintf(line, "softirq_exit: vec=%u [action=%s]", event.vec(),
742 SoftirqArray[event.vec()]);
746 std::string FormatI2cWrite(const I2cWriteFtraceEvent& event) {
748 // TODO(hjd): Check event.buf().
749 sprintf(line, "i2c_write: i2c-%d #%u a=%03x f=%04x l=%u", event.adapter_nr(),
750 event.msg_nr(), event.addr(), event.flags(), event.len());
754 std::string FormatI2cReply(const I2cReplyFtraceEvent& event) {
756 // TODO(hjd): Check event.buf().
757 sprintf(line, "i2c_reply: i2c-%d #%u a=%03x f=%04x l=%u", event.adapter_nr(),
758 event.msg_nr(), event.addr(), event.flags(), event.len());
764 const MmVmscanDirectReclaimBeginFtraceEvent& event) {
767 event.order(), event.may_writepage());
772 const MmVmscanDirectReclaimEndFtraceEvent& event) {
775 event.nr_reclaimed());
779 std::string FormatLowmemoryKill(const LowmemoryKillFtraceEvent& event) {
784 event.comm().c_str(), event.pid(), event.pagecache_size(),
785 event.pagecache_limit(), event.free());
790 const WorkqueueExecuteStartFtraceEvent& event) {
793 event.work(), event.function());
798 const WorkqueueExecuteEndFtraceEvent& event) {
800 sprintf(line, "workqueue_execute_end: work struct %llx", event.work());
805 const WorkqueueQueueWorkFtraceEvent& event) {
811 event.work(), event.function(), event.workqueue(), event.req_cpu(),
812 event.cpu());
817 const WorkqueueActivateWorkFtraceEvent& event) {
819 sprintf(line, "workqueue_activate_work: work struct %llx", event.work());
823 std::string FormatMmCompactionBegin(const MmCompactionBeginFtraceEvent& event) {
828 event.zone_start(), event.migrate_pfn(), event.free_pfn(),
829 event.zone_end(), event.sync() ? "sync" : "async");
834 const MmCompactionDeferCompactionFtraceEvent& event) {
839 event.nid(), MmCompactionSuitableArray[event.idx()], event.order(),
840 event.order_failed(), event.considered(), 1UL << event.defer_shift());
845 const MmCompactionDeferredFtraceEvent& event) {
850 event.nid(), MmCompactionSuitableArray[event.idx()], event.order(),
851 event.order_failed(), event.considered(), 1UL << event.defer_shift());
856 const MmCompactionDeferResetFtraceEvent& event) {
861 event.nid(), MmCompactionSuitableArray[event.idx()], event.order(),
862 event.order_failed(), event.considered(), 1UL << event.defer_shift());
866 std::string FormatMmCompactionEnd(const MmCompactionEndFtraceEvent& event) {
871 event.zone_start(), event.migrate_pfn(), event.free_pfn(),
872 event.zone_end(), event.sync() ? "sync" : "aysnc",
873 MmCompactionRetArray[event.status()]);
878 const MmCompactionFinishedFtraceEvent& event) {
881 event.nid(), MmCompactionSuitableArray[event.idx()], event.order(),
882 MmCompactionRetArray[event.ret()]);
887 const MmCompactionIsolateFreepagesFtraceEvent& event) {
892 event.start_pfn(), event.end_pfn(), event.nr_scanned(),
893 event.nr_taken());
898 const MmCompactionIsolateMigratepagesFtraceEvent& event) {
903 event.start_pfn(), event.end_pfn(), event.nr_scanned(),
904 event.nr_taken());
909 const MmCompactionKcompactdSleepFtraceEvent& event) {
911 sprintf(line, "mm_compaction_kcompactd_sleep: nid=%d", event.nid());
916 const MmCompactionKcompactdWakeFtraceEvent& event) {
920 event.nid(), event.order(),
921 MmCompactionSuitableArray[event.classzone_idx()]);
926 const MmCompactionMigratepagesFtraceEvent& event) {
929 event.nr_migrated(), event.nr_failed());
934 const MmCompactionSuitableFtraceEvent& event) {
937 event.nid(), MmCompactionSuitableArray[event.idx()], event.order(),
938 MmCompactionRetArray[event.ret()]);
943 const MmCompactionTryToCompactPagesFtraceEvent& event) {
947 event.order(), event.gfp_mask(),
948 event.mode()); // convert to int?
953 const MmCompactionWakeupKcompactdFtraceEvent& event) {
957 event.nid(), event.order(),
958 MmCompactionSuitableArray[event.classzone_idx()]);
962 std::string FormatSuspendResume(const SuspendResumeFtraceEvent& event) {
964 sprintf(line, "suspend_resume: %s[%u] %s", event.action().c_str(),
965 event.val(), event.start() ? "begin" : "end");
969 std::string FormatSchedWakeupNew(const SchedWakeupNewFtraceEvent& event) {
972 event.comm().c_str(), event.pid(), event.prio(), event.target_cpu());
976 std::string FormatSchedProcessExec(const SchedProcessExecFtraceEvent& event) {
979 event.filename().c_str(), event.pid(), event.old_pid());
982 std::string FormatSchedProcessExit(const SchedProcessExitFtraceEvent& event) {
985 event.comm().c_str(), event.pid(), event.tgid(), event.prio());
988 std::string FormatSchedProcessFork(const SchedProcessForkFtraceEvent& event) {
993 event.parent_comm().c_str(), event.parent_pid(),
994 event.child_comm().c_str(), event.child_pid());
997 std::string FormatSchedProcessFree(const SchedProcessFreeFtraceEvent& event) {
1000 event.comm().c_str(), event.pid(), event.prio());
1003 std::string FormatSchedProcessHang(const SchedProcessHangFtraceEvent& event) {
1005 sprintf(line, "sched_process_hang: comm=%s pid=%d", event.comm().c_str(),
1006 event.pid());
1010 std::string FormatSchedProcessWait(const SchedProcessWaitFtraceEvent& event) {
1012 sprintf(line, "sched_process_wait: comm=%s pid=%d", event.comm().c_str(),
1013 event.pid());
1017 std::string FormatTaskNewtask(const TaskNewtaskFtraceEvent& event) {
1021 event.comm().c_str(), event.pid(), event.clone_flags(),
1022 event.oom_score_adj());
1026 std::string FormatTaskRename(const TaskRenameFtraceEvent& event) {
1029 event.pid(), event.newcomm().c_str(), event.oldcomm().c_str(),
1030 event.oom_score_adj());
1034 std::string FormatBlockBioBackmerge(const BlockBioBackmergeFtraceEvent& event) {
1037 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1038 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1039 event.comm().c_str());
1043 std::string FormatBlockBioBounce(const BlockBioBounceFtraceEvent& event) {
1048 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1049 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1050 event.comm().c_str());
1054 std::string FormatBlockBioComplete(const BlockBioCompleteFtraceEvent& event) {
1057 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1058 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1059 event.error());
1064 const BlockBioFrontmergeFtraceEvent& event) {
1067 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1068 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1069 event.comm().c_str());
1073 std::string FormatBlockBioQueue(const BlockBioQueueFtraceEvent& event) {
1075 sprintf(line, "block_bio_queue: %d,%d %s %llu + %u [%s]", BlkMaj(event.dev()),
1076 BlkMin(event.dev()), event.rwbs().c_str(),
1077 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1078 event.comm().c_str());
1082 std::string FormatBlockBioRemap(const BlockBioRemapFtraceEvent& event) {
1085 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1086 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1087 BlkMaj(event.dev()), BlkMin(event.dev()), event.old_sector());
1091 std::string FormatBlockDirtyBuffer(const BlockDirtyBufferFtraceEvent& event) {
1094 BlkMaj(event.dev()), BlkMin(event.dev()),
1095 static_cast<unsigned long long>(event.sector()),
1096 static_cast<size_t>(event.size()));
1100 std::string FormatBlockGetrq(const BlockGetrqFtraceEvent& event) {
1102 sprintf(line, "block_getrq: %d,%d %s %llu + %u [%s]", BlkMaj(event.dev()),
1103 BlkMin(event.dev()), event.rwbs().c_str(),
1104 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1105 event.comm().c_str());
1109 std::string FormatBlockPlug(const BlockPlugFtraceEvent& event) {
1111 sprintf(line, "block_plug: comm=[%s]", event.comm().c_str());
1115 std::string FormatBlockRqAbort(const BlockRqAbortFtraceEvent& event) {
1118 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1119 event.cmd().c_str(), static_cast<unsigned long long>(event.sector()),
1120 event.nr_sector(), event.errors());
1124 std::string FormatBlockRqComplete(const BlockRqCompleteFtraceEvent& event) {
1127 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1128 event.cmd().c_str(), static_cast<unsigned long long>(event.sector()),
1129 event.nr_sector(), event.errors());
1133 std::string FormatBlockRqInsert(const BlockRqInsertFtraceEvent& event) {
1136 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1137 event.bytes(), event.cmd().c_str(),
1138 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1139 event.comm().c_str());
1143 std::string FormatBlockRqRemap(const BlockRqRemapFtraceEvent& event) {
1146 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1147 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1148 BlkMaj(event.dev()), BlkMin(event.dev()), event.old_sector(),
1149 event.nr_bios());
1153 std::string FormatBlockRqRequeue(const BlockRqRequeueFtraceEvent& event) {
1156 BlkMaj(event.dev()), BlkMin(event.dev()), event.rwbs().c_str(),
1157 event.cmd().c_str(), static_cast<unsigned long long>(event.sector()),
1158 event.nr_sector(), event.errors());
1162 std::string FormatBlockSleeprq(const BlockSleeprqFtraceEvent& event) {
1164 sprintf(line, "block_sleeprq: %d,%d %s %llu + %u [%s]", BlkMaj(event.dev()),
1165 BlkMin(event.dev()), event.rwbs().c_str(),
1166 static_cast<unsigned long long>(event.sector()), event.nr_sector(),
1167 event.comm().c_str());
1171 std::string FormatBlockSplit(const BlockSplitFtraceEvent& event) {
1173 sprintf(line, "block_split: %d,%d %s %llu / %llu [%s]", BlkMaj(event.dev()),
1174 BlkMin(event.dev()), event.rwbs().c_str(),
1175 static_cast<unsigned long long>(event.sector()), event.new_sector(),
1176 event.comm().c_str());
1180 std::string FormatBlockTouchBuffer(const BlockTouchBufferFtraceEvent& event) {
1183 BlkMaj(event.dev()), BlkMin(event.dev()),
1184 static_cast<unsigned long long>(event.sector()),
1185 static_cast<size_t>(event.size()));
1189 std::string FormatBlockUnplug(const BlockUnplugFtraceEvent& event) {
1191 sprintf(line, "block_unplug: [%s] %d", event.comm().c_str(), event.nr_rq());
1195 std::string FormatExt4AllocDaBlocks(const Ext4AllocDaBlocksFtraceEvent& event) {
1200 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1201 event.data_blocks(), event.meta_blocks());
1206 const Ext4AllocateBlocksFtraceEvent& event) {
1211 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1212 GetExt4HintFlag(event.flags()), event.len(), event.block(),
1213 event.logical(), event.goal(), event.lleft(), event.lright(),
1214 event.pleft(), event.pright());
1218 std::string FormatExt4AllocateInode(const Ext4AllocateInodeFtraceEvent& event) {
1221 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.dir(),
1222 event.mode());
1227 const Ext4BeginOrderedTruncateFtraceEvent& event) {
1230 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1231 event.new_size());
1235 std::string FormatExt4CollapseRange(const Ext4CollapseRangeFtraceEvent& event) {
1238 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.offset(),
1239 event.len());
1244 const Ext4DaReleaseSpaceFtraceEvent& event) {
1250 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.mode(),
1251 event.i_blocks(), event.freed_blocks(), event.reserved_data_blocks(),
1252 event.reserved_meta_blocks(), event.allocated_meta_blocks());
1257 const Ext4DaReserveSpaceFtraceEvent& event) {
1262 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.mode(),
1263 event.i_blocks(), event.reserved_data_blocks(),
1264 event.reserved_meta_blocks());
1269 const Ext4DaUpdateReserveSpaceFtraceEvent& event) {
1275 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.mode(),
1276 event.i_blocks(), event.used_blocks(), event.reserved_data_blocks(),
1277 event.reserved_meta_blocks(), event.allocated_meta_blocks(),
1278 event.quota_claim());
1282 std::string FormatExt4DaWritePages(const Ext4DaWritePagesFtraceEvent& event) {
1287 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1288 event.first_page(), event.nr_to_write(), event.sync_mode());
1294 const Ext4DaWritePagesExtentFtraceEvent& event) {
1298 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1299 event.len());
1303 std::string FormatExt4DiscardBlocks(const Ext4DiscardBlocksFtraceEvent& event) {
1306 BlkMaj(event.dev()), BlkMin(event.dev()), event.blk(), event.count());
1311 const Ext4DiscardPreallocationsFtraceEvent& event) {
1314 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino());
1318 std::string FormatExt4DropInode(const Ext4DropInodeFtraceEvent& event) {
1321 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.drop());
1326 std::string FormatExt4EsCacheExtent(const Ext4EsCacheExtentFtraceEvent& event) {
1330 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1331 event.len(), event.pblk());
1336 const Ext4EsFindDelayedExtentRangeEnterFtraceEvent& event) {
1340 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk());
1346 const Ext4EsFindDelayedExtentRangeExitFtraceEvent& event) {
1351 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1352 event.len(), event.pblk());
1358 const Ext4EsInsertExtentFtraceEvent& event) {
1362 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1363 event.len(), event.pblk());
1368 const Ext4EsLookupExtentEnterFtraceEvent& event) {
1371 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk());
1377 const Ext4EsLookupExtentExitFtraceEvent& event) {
1381 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.found(),
1382 event.lblk(), event.len(), event.found() ? event.pblk() : 0);
1387 const Ext4EsRemoveExtentFtraceEvent& event) {
1390 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1391 event.len());
1395 std::string FormatExt4EsShrink(const Ext4EsShrinkFtraceEvent& event) {
1400 BlkMaj(event.dev()), BlkMin(event.dev()), event.nr_shrunk(),
1401 event.scan_time(), event.nr_skipped(), event.retried());
1405 std::string FormatExt4EsShrinkCount(const Ext4EsShrinkCountFtraceEvent& event) {
1408 BlkMaj(event.dev()), BlkMin(event.dev()), event.nr_to_scan(),
1409 event.cache_cnt());
1414 const Ext4EsShrinkScanEnterFtraceEvent& event) {
1418 BlkMaj(event.dev()), BlkMin(event.dev()), event.nr_to_scan(),
1419 event.cache_cnt());
1424 const Ext4EsShrinkScanExitFtraceEvent& event) {
1427 BlkMaj(event.dev()), BlkMin(event.dev()), event.nr_shrunk(),
1428 event.cache_cnt());
1432 std::string FormatExt4EvictInode(const Ext4EvictInodeFtraceEvent& event) {
1435 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.nlink());
1440 const Ext4ExtConvertToInitializedEnterFtraceEvent& event) {
1445 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.m_lblk(),
1446 event.m_len(), event.u_lblk(), event.u_len(), event.u_pblk());
1451 const Ext4ExtConvertToInitializedFastpathFtraceEvent& event) {
1457 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.m_lblk(),
1458 event.m_len(), event.u_lblk(), event.u_len(), event.u_pblk(),
1459 event.i_lblk(), event.i_len(), event.i_pblk());
1464 const Ext4ExtHandleUnwrittenExtentsFtraceEvent& event) {
1469 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1470 event.pblk(), event.len(), GetExt4ExtFlag(event.flags()),
1471 event.allocated(), event.newblk());
1475 std::string FormatExt4ExtInCache(const Ext4ExtInCacheFtraceEvent& event) {
1478 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1479 event.ret());
1483 std::string FormatExt4ExtLoadExtent(const Ext4ExtLoadExtentFtraceEvent& event) {
1486 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1487 event.pblk());
1492 const Ext4ExtMapBlocksEnterFtraceEvent& event) {
1497 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1498 static_cast<unsigned>(event.lblk()), event.len(),
1499 GetExt4ExtFlag(event.flags()));
1504 const Ext4ExtMapBlocksExitFtraceEvent& event) {
1509 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1510 event.pblk(), event.len(), event.flags(), event.ret());
1514 std::string FormatExt4ExtPutInCache(const Ext4ExtPutInCacheFtraceEvent& event) {
1518 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1519 event.len(), event.start());
1524 const Ext4ExtRemoveSpaceFtraceEvent& event) {
1528 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.start(),
1529 event.end(), event.depth());
1534 const Ext4ExtRemoveSpaceDoneFtraceEvent& event) {
1539 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.start(),
1540 event.end(), event.depth(), event.partial(), event.eh_entries());
1544 std::string FormatExt4ExtRmIdx(const Ext4ExtRmIdxFtraceEvent& event) {
1547 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pblk());
1551 std::string FormatExt4ExtRmLeaf(const Ext4ExtRmLeafFtraceEvent& event) {
1556 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.start(),
1557 event.ee_lblk(), event.ee_pblk(), event.ee_len(), event.partial());
1561 std::string FormatExt4ExtShowExtent(const Ext4ExtShowExtentFtraceEvent& event) {
1565 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1566 event.pblk(), event.len());
1571 const Ext4FallocateEnterFtraceEvent& event) {
1576 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.offset(),
1577 event.len(), GetExt4ModeFlag(event.mode()));
1581 std::string FormatExt4FallocateExit(const Ext4FallocateExitFtraceEvent& event) {
1585 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pos(),
1586 event.blocks(), event.ret());
1591 const Ext4FindDelallocRangeFtraceEvent& event) {
1596 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.from(),
1597 event.to(), event.reverse(), event.found(), event.found_blk());
1601 std::string FormatExt4Forget(const Ext4ForgetFtraceEvent& event) {
1605 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.mode(),
1606 event.is_metadata(), event.block());
1610 std::string FormatExt4FreeBlocks(const Ext4FreeBlocksFtraceEvent& event) {
1615 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.mode(),
1616 event.block(), event.count(), GetExt4FreeBlocksFlag(event.flags()));
1620 std::string FormatExt4FreeInode(const Ext4FreeInodeFtraceEvent& event) {
1625 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.mode(),
1626 event.uid(), event.gid(), event.blocks());
1631 const Ext4GetImpliedClusterAllocExitFtraceEvent& event) {
1636 BlkMaj(event.dev()), BlkMin(event.dev()), event.lblk(), event.pblk(),
1637 event.len(), event.flags(), event.ret());
1642 const Ext4GetReservedClusterAllocFtraceEvent& event) {
1646 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1647 event.len());
1652 const Ext4IndMapBlocksEnterFtraceEvent& event) {
1657 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1658 event.len(), event.flags());
1663 const Ext4IndMapBlocksExitFtraceEvent& event) {
1668 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.lblk(),
1669 event.pblk(), event.len(), event.flags(), event.ret());
1673 std::string FormatExt4InsertRange(const Ext4InsertRangeFtraceEvent& event) {
1676 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.offset(),
1677 event.len());
1682 const Ext4InvalidatepageFtraceEvent& event) {
1687 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.index(),
1688 event.offset(), event.length());
1692 std::string FormatExt4JournalStart(const Ext4JournalStartFtraceEvent& event) {
1696 BlkMaj(event.dev()), BlkMin(event.dev()), event.blocks(),
1697 event.rsv_blocks(), event.ip());
1702 const Ext4JournalStartReservedFtraceEvent& event) {
1705 BlkMaj(event.dev()), BlkMin(event.dev()), event.blocks(), event.ip());
1710 const Ext4JournalledInvalidatepageFtraceEvent& event) {
1715 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.index(),
1716 event.offset(), event.length());
1721 const Ext4JournalledWriteEndFtraceEvent& event) {
1726 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pos(),
1727 event.len(), event.copied());
1731 std::string FormatExt4LoadInode(const Ext4LoadInodeFtraceEvent& event) {
1733 sprintf(line, "ext4_load_inode: dev %d,%d ino %ld", BlkMaj(event.dev()),
1734 BlkMin(event.dev()), event.ino());
1739 const Ext4LoadInodeBitmapFtraceEvent& event) {
1742 BlkMaj(event.dev()), BlkMin(event.dev()), event.group());
1747 const Ext4MarkInodeDirtyFtraceEvent& event) {
1750 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.ip());
1754 std::string FormatExt4MbBitmapLoad(const Ext4MbBitmapLoadFtraceEvent& event) {
1756 sprintf(line, "ext4_mb_bitmap_load: dev %d,%d group %u", BlkMaj(event.dev()),
1757 BlkMin(event.dev()), event.group());
1762 const Ext4MbBuddyBitmapLoadFtraceEvent& event) {
1765 BlkMaj(event.dev()), BlkMin(event.dev()), event.group());
1770 const Ext4MbDiscardPreallocationsFtraceEvent& event) {
1773 BlkMaj(event.dev()), BlkMin(eventevent.needed());
1777 std::string FormatExt4MbNewGroupPa(const Ext4MbNewGroupPaFtraceEvent& event) {
1782 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1783 event.pa_pstart(), event.pa_len(), event.pa_lstart());
1787 std::string FormatExt4MbNewInodePa(const Ext4MbNewInodePaFtraceEvent& event) {
1792 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1793 event.pa_pstart(), event.pa_len(), event.pa_lstart());
1798 const Ext4MbReleaseGroupPaFtraceEvent& event) {
1801 BlkMaj(event.dev()), BlkMin(event.dev()), event.pa_pstart(),
1802 event.pa_len());
1807 const Ext4MbReleaseInodePaFtraceEvent& event) {
1811 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.block(),
1812 event.count());
1816 std::string FormatExt4MballocAlloc(const Ext4MballocAllocFtraceEvent& event) {
1822 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1823 event.orig_group(), event.orig_start(), event.orig_len(),
1824 event.orig_logical(), event.goal_group(), event.goal_start(),
1825 event.goal_len(), event.goal_logical(), event.result_group(),
1826 event.result_start(), event.result_len(), event.result_logical(),
1827 event.found(), event.groups(), event.cr(),
1828 GetExt4HintFlag(event.flags()), event.tail(),
1829 event.buddy() ? 1 << event.buddy() : 0);
1834 const Ext4MballocDiscardFtraceEvent& event) {
1837 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1838 event.result_group(), event.result_start(), event.result_len());
1842 std::string FormatExt4MballocFree(const Ext4MballocFreeFtraceEvent& event) {
1845 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1846 event.result_group(), event.result_start(), event.result_len());
1851 const Ext4MballocPreallocFtraceEvent& event) {
1856 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1857 event.orig_group(), event.orig_start(), event.orig_len(),
1858 event.orig_logical(), event.result_group(), event.result_start(),
1859 event.result_len(), event.result_logical());
1864 const Ext4OtherInodeUpdateTimeFtraceEvent& event) {
1869 BlkMaj(event.dev()), BlkMin(event.dev()), event.orig_ino(),
1870 event.ino(), event.mode(), event.uid(), event.gid());
1874 std::string FormatExt4PunchHole(const Ext4PunchHoleFtraceEvent& event) {
1878 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.offset(),
1879 event.len(), GetExt4ModeFlag(event.mode()));
1884 const Ext4ReadBlockBitmapLoadFtraceEvent& event) {
1887 BlkMaj(event.dev()), BlkMin(event.dev()), event.group());
1891 std::string FormatExt4Readpage(const Ext4ReadpageFtraceEvent& event) {
1894 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.index());
1898 std::string FormatExt4Releasepage(const Ext4ReleasepageFtraceEvent& event) {
1901 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.index());
1905 std::string FormatExt4RemoveBlocks(const Ext4RemoveBlocksFtraceEvent& event) {
1910 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1911 event.ee_lblk(), event.ee_pblk(), event.ee_len(), event.from(),
1912 event.to(), event.partial());
1916 std::string FormatExt4RequestBlocks(const Ext4RequestBlocksFtraceEvent& event) {
1921 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1922 GetExt4HintFlag(event.flags()), event.len(), event.logical(),
1923 event.goal(), event.lleft(), event.lright(), event.pleft(),
1924 event.pright());
1928 std::string FormatExt4RequestInode(const Ext4RequestInodeFtraceEvent& event) {
1931 BlkMaj(event.dev()), BlkMin(event.dev()), event.dir(), event.mode());
1935 std::string FormatExt4SyncFs(const Ext4SyncFsFtraceEvent& event) {
1937 sprintf(line, "ext4_sync_fs: dev %d,%d wait %d", BlkMaj(event.dev()),
1938 BlkMin(event.dev()), event.wait());
1942 std::string FormatExt4TrimAllFree(const Ext4TrimAllFreeFtraceEvent& event) {
1945 event.dev_major(), event.dev_minor(), event.group(), event.start(),
1946 event.len());
1950 std::string FormatExt4TrimExtent(const Ext4TrimExtentFtraceEvent& event) {
1953 event.dev_major(), event.dev_minor(), event.group(), event.start(),
1954 event.len());
1958 std::string FormatExt4TruncateEnter(const Ext4TruncateEnterFtraceEvent& event) {
1961 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1962 event.blocks());
1966 std::string FormatExt4TruncateExit(const Ext4TruncateExitFtraceEvent& event) {
1969 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
1970 event.blocks());
1974 std::string FormatExt4UnlinkEnter(const Ext4UnlinkEnterFtraceEvent& event) {
1977 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.size(),
1978 event.parent());
1982 std::string FormatExt4UnlinkExit(const Ext4UnlinkExitFtraceEvent& event) {
1985 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.ret());
1989 std::string FormatExt4WriteBegin(const Ext4WriteBeginFtraceEvent& event) {
1992 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pos(),
1993 event.len(), event.flags());
1997 std::string FormatExt4WriteEnd(const Ext4WriteEndFtraceEvent& event) {
2000 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.pos(),
2001 event.len(), event.copied());
2005 std::string FormatExt4Writepage(const Ext4WritepageFtraceEvent& event) {
2008 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.index());
2012 std::string FormatExt4Writepages(const Ext4WritepagesFtraceEvent& event) {
2018 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(),
2019 event.nr_to_write(), event.pages_skipped(), event.range_start(),
2020 event.range_end(), event.sync_mode(), event.for_kupdate(),
2021 event.range_cyclic(), event.writeback_index());
2026 const Ext4WritepagesResultFtraceEvent& event) {
2031 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.ret(),
2032 event.pages_written(), event.pages_skipped(), event.sync_mode(),
2033 event.writeback_index());
2037 std::string FormatExt4ZeroRange(const Ext4ZeroRangeFtraceEvent& event) {
2041 BlkMaj(event.dev()), BlkMin(event.dev()), event.ino(), event.offset(),
2042 event.len(), GetExt4ModeFlag(event.mode()));
2046 std::string FormatF2fsDoSubmitBio(const F2fsDoSubmitBioFtraceEvent& event) {
2051 std::string FormatF2fsEvictInode(const F2fsEvictInodeFtraceEvent& event) {
2056 std::string FormatF2fsFallocate(const F2fsFallocateFtraceEvent& event) {
2061 std::string FormatF2fsGetDataBlock(const F2fsGetDataBlockFtraceEvent& event) {
2066 std::string FormatF2fsGetVictim(const F2fsGetVictimFtraceEvent& event) {
2071 std::string FormatF2fsIget(const F2fsIgetFtraceEvent& event) {
2076 std::string FormatF2fsIgetExit(const F2fsIgetExitFtraceEvent& event) {
2081 std::string FormatF2fsNewInode(const F2fsNewInodeFtraceEvent& event) {
2086 std::string FormatF2fsReadpage(const F2fsReadpageFtraceEvent& event) {
2092 const F2fsReserveNewBlockFtraceEvent& event) {
2097 std::string FormatF2fsSetPageDirty(const F2fsSetPageDirtyFtraceEvent& event) {
2103 const F2fsSubmitWritePageFtraceEvent& event) {
2108 std::string FormatF2fsSyncFileEnter(const F2fsSyncFileEnterFtraceEvent& event) {
2113 std::string FormatF2fsSyncFileExit(const F2fsSyncFileExitFtraceEvent& event) {
2118 std::string FormatF2fsSyncFs(const F2fsSyncFsFtraceEvent& event) {
2123 std::string FormatF2fsTruncate(const F2fsTruncateFtraceEvent& event) {
2129 const F2fsTruncateBlocksEnterFtraceEvent& event) {
2135 const F2fsTruncateBlocksExitFtraceEvent& event) {
2141 const F2fsTruncateDataBlocksRangeFtraceEvent& event) {
2147 const F2fsTruncateInodeBlocksEnterFtraceEvent& event) {
2153 const F2fsTruncateInodeBlocksExitFtraceEvent& event) {
2158 std::string FormatF2fsTruncateNode(const F2fsTruncateNodeFtraceEvent& event) {
2164 const F2fsTruncateNodesEnterFtraceEvent& event) {
2170 const F2fsTruncateNodesExitFtraceEvent& event) {
2176 const F2fsTruncatePartialNodesFtraceEvent& event) {
2181 std::string FormatF2fsUnlinkEnter(const F2fsUnlinkEnterFtraceEvent& event) {
2186 std::string FormatF2fsUnlinkExit(const F2fsUnlinkExitFtraceEvent& event) {
2191 std::string FormatF2fsVmPageMkwrite(const F2fsVmPageMkwriteFtraceEvent& event) {
2196 std::string FormatF2fsWriteBegin(const F2fsWriteBeginFtraceEvent& event) {
2202 const F2fsWriteCheckpointFtraceEvent& event) {
2207 std::string FormatF2fsWriteEnd(const F2fsWriteEndFtraceEvent& event) {
2213 std::string FormatEventText(const protos::FtraceEvent& event) {
2214 if (event.has_binder_lock()) {
2215 const auto& inner = event.binder_lock();
2217 } else if (event.has_binder_locked()) {
2218 const auto& inner = event.binder_locked();
2220 } else if (event.has_binder_transaction()) {
2221 const auto& inner = event.binder_transaction();
2223 } else if (event.has_binder_transaction_received()) {
2224 const auto& inner = event.binder_transaction_received();
2226 } else if (event.has_binder_unlock()) {
2227 const auto& inner = event.binder_unlock();
2229 } else if (event.has_block_bio_backmerge()) {
2230 const auto& inner = event.block_bio_backmerge();
2232 } else if (event.has_block_bio_bounce()) {
2233 const auto& inner = event.block_bio_bounce();
2235 } else if (event.has_block_bio_complete()) {
2236 const auto& inner = event.block_bio_complete();
2238 } else if (event.has_block_bio_frontmerge()) {
2239 const auto& inner = event.block_bio_frontmerge();
2241 } else if (event.has_block_bio_queue()) {
2242 const auto& inner = event.block_bio_queue();
2244 } else if (event.has_block_bio_remap()) {
2245 const auto& inner = event.block_bio_remap();
2247 } else if (event.has_block_dirty_buffer()) {
2248 const auto& inner = event.block_dirty_buffer();
2250 } else if (event.has_block_getrq()) {
2251 const auto& inner = event.block_getrq();
2253 } else if (event.has_block_plug()) {
2254 const auto& inner = event.block_plug();
2256 } else if (event.has_block_rq_abort()) {
2257 const auto& inner = event.block_rq_abort();
2259 } else if (event.has_block_rq_complete()) {
2260 const auto& inner = event.block_rq_complete();
2262 } else if (event.has_block_rq_insert()) {
2263 const auto& inner = event.block_rq_insert();
2265 } else if (event.has_block_rq_issue()) {
2266 const auto& inner = event.block_rq_issue();
2268 } else if (event.has_block_rq_remap()) {
2269 const auto& inner = event.block_rq_remap();
2271 } else if (event.has_block_rq_requeue()) {
2272 const auto& inner = event.block_rq_requeue();
2274 } else if (event.has_block_sleeprq()) {
2275 const auto& inner = event.block_sleeprq();
2277 } else if (event.has_block_split()) {
2278 const auto& inner = event.block_split();
2280 } else if (event.has_block_touch_buffer()) {
2281 const auto& inner = event.block_touch_buffer();
2283 } else if (event.has_block_unplug()) {
2284 const auto& inner = event.block_unplug();
2286 } else if (event.has_mm_compaction_begin()) {
2287 const auto& inner = event.mm_compaction_begin();
2289 } else if (event.has_mm_compaction_defer_compaction()) {
2290 const auto& inner = event.mm_compaction_defer_compaction();
2292 } else if (event.has_mm_compaction_defer_reset()) {
2293 const auto& inner = event.mm_compaction_defer_reset();
2295 } else if (event.has_mm_compaction_deferred()) {
2296 const auto& inner = event.mm_compaction_deferred();
2298 } else if (event.has_mm_compaction_end()) {
2299 const auto& inner = event.mm_compaction_end();
2301 } else if (event.has_mm_compaction_finished()) {
2302 const auto& inner = event.mm_compaction_finished();
2304 } else if (event.has_mm_compaction_isolate_freepages()) {
2305 const auto& inner = event.mm_compaction_isolate_freepages();
2307 } else if (event.has_mm_compaction_isolate_migratepages()) {
2308 const auto& inner = event.mm_compaction_isolate_migratepages();
2310 } else if (event.has_mm_compaction_kcompactd_sleep()) {
2311 const auto& inner = event.mm_compaction_kcompactd_sleep();
2313 } else if (event.has_mm_compaction_kcompactd_wake()) {
2314 const auto& inner = event.mm_compaction_kcompactd_wake();
2316 } else if (event.has_mm_compaction_migratepages()) {
2317 const auto& inner = event.mm_compaction_migratepages();
2319 } else if (event.has_mm_compaction_suitable()) {
2320 const auto& inner = event.mm_compaction_suitable();
2322 } else if (event.has_mm_compaction_try_to_compact_pages()) {
2323 const auto& inner = event.mm_compaction_try_to_compact_pages();
2325 } else if (event.has_mm_compaction_wakeup_kcompactd()) {
2326 const auto& inner = event.mm_compaction_wakeup_kcompactd();
2328 } else if (event.has_ext4_alloc_da_blocks()) {
2329 const auto& inner = event.ext4_alloc_da_blocks();
2331 } else if (event.has_ext4_allocate_blocks()) {
2332 const auto& inner = event.ext4_allocate_blocks();
2334 } else if (event.has_ext4_allocate_inode()) {
2335 const auto& inner = event.ext4_allocate_inode();
2337 } else if (event.has_ext4_begin_ordered_truncate()) {
2338 const auto& inner = event.ext4_begin_ordered_truncate();
2340 } else if (event.has_ext4_collapse_range()) {
2341 const auto& inner = event.ext4_collapse_range();
2343 } else if (event.has_ext4_da_release_space()) {
2344 const auto& inner = event.ext4_da_release_space();
2346 } else if (event.has_ext4_da_reserve_space()) {
2347 const auto& inner = event.ext4_da_reserve_space();
2349 } else if (event.has_ext4_da_update_reserve_space()) {
2350 const auto& inner = event.ext4_da_update_reserve_space();
2352 } else if (event.has_ext4_da_write_begin()) {
2353 const auto& inner = event.ext4_da_write_begin();
2355 } else if (event.has_ext4_da_write_end()) {
2356 const auto& inner = event.ext4_da_write_end();
2358 } else if (event.has_ext4_da_write_pages()) {
2359 const auto& inner = event.ext4_da_write_pages();
2361 } else if (event.has_ext4_da_write_pages_extent()) {
2362 const auto& inner = event.ext4_da_write_pages_extent();
2364 } else if (event.has_ext4_discard_blocks()) {
2365 const auto& inner = event.ext4_discard_blocks();
2367 } else if (event.has_ext4_discard_preallocations()) {
2368 const auto& inner = event.ext4_discard_preallocations();
2370 } else if (event.has_ext4_drop_inode()) {
2371 const auto& inner = event.ext4_drop_inode();
2373 } else if (event.has_ext4_es_cache_extent()) {
2374 const auto& inner = event.ext4_es_cache_extent();
2376 } else if (event.has_ext4_es_find_delayed_extent_range_enter()) {
2377 const auto& inner = event.ext4_es_find_delayed_extent_range_enter();
2379 } else if (event.has_ext4_es_find_delayed_extent_range_exit()) {
2380 const auto& inner = event.ext4_es_find_delayed_extent_range_exit();
2382 } else if (event.has_ext4_es_insert_extent()) {
2383 const auto& inner = event.ext4_es_insert_extent();
2385 } else if (event.has_ext4_es_lookup_extent_enter()) {
2386 const auto& inner = event.ext4_es_lookup_extent_enter();
2388 } else if (event.has_ext4_es_lookup_extent_exit()) {
2389 const auto& inner = event.ext4_es_lookup_extent_exit();
2391 } else if (event.has_ext4_es_remove_extent()) {
2392 const auto& inner = event.ext4_es_remove_extent();
2394 } else if (event.has_ext4_es_shrink()) {
2395 const auto& inner = event.ext4_es_shrink();
2397 } else if (event.has_ext4_es_shrink_count()) {
2398 const auto& inner = event.ext4_es_shrink_count();
2400 } else if (event.has_ext4_es_shrink_scan_enter()) {
2401 const auto& inner = event.ext4_es_shrink_scan_enter();
2403 } else if (event.has_ext4_es_shrink_scan_exit()) {
2404 const auto& inner = event.ext4_es_shrink_scan_exit();
2406 } else if (event.has_ext4_evict_inode()) {
2407 const auto& inner = event.ext4_evict_inode();
2409 } else if (event.has_ext4_ext_convert_to_initialized_enter()) {
2410 const auto& inner = event.ext4_ext_convert_to_initialized_enter();
2412 } else if (event.has_ext4_ext_convert_to_initialized_fastpath()) {
2413 const auto& inner = event.ext4_ext_convert_to_initialized_fastpath();
2415 } else if (event.has_ext4_ext_handle_unwritten_extents()) {
2416 const auto& inner = event.ext4_ext_handle_unwritten_extents();
2418 } else if (event.has_ext4_ext_in_cache()) {
2419 const auto& inner = event.ext4_ext_in_cache();
2421 } else if (event.has_ext4_ext_load_extent()) {
2422 const auto& inner = event.ext4_ext_load_extent();
2424 } else if (event.has_ext4_ext_map_blocks_enter()) {
2425 const auto& inner = event.ext4_ext_map_blocks_enter();
2427 } else if (event.has_ext4_ext_map_blocks_exit()) {
2428 const auto& inner = event.ext4_ext_map_blocks_exit();
2430 } else if (event.has_ext4_ext_put_in_cache()) {
2431 const auto& inner = event.ext4_ext_put_in_cache();
2433 } else if (event.has_ext4_ext_remove_space()) {
2434 const auto& inner = event.ext4_ext_remove_space();
2436 } else if (event.has_ext4_ext_remove_space_done()) {
2437 const auto& inner = event.ext4_ext_remove_space_done();
2439 } else if (event.has_ext4_ext_rm_idx()) {
2440 const auto& inner = event.ext4_ext_rm_idx();
2442 } else if (event.has_ext4_ext_rm_leaf()) {
2443 const auto& inner = event.ext4_ext_rm_leaf();
2445 } else if (event.has_ext4_ext_show_extent()) {
2446 const auto& inner = event.ext4_ext_show_extent();
2448 } else if (event.has_ext4_fallocate_enter()) {
2449 const auto& inner = event.ext4_fallocate_enter();
2451 } else if (event.has_ext4_fallocate_exit()) {
2452 const auto& inner = event.ext4_fallocate_exit();
2454 } else if (event.has_ext4_find_delalloc_range()) {
2455 const auto& inner = event.ext4_find_delalloc_range();
2457 } else if (event.has_ext4_forget()) {
2458 const auto& inner = event.ext4_forget();
2460 } else if (event.has_ext4_free_blocks()) {
2461 const auto& inner = event.ext4_free_blocks();
2463 } else if (event.has_ext4_free_inode()) {
2464 const auto& inner = event.ext4_free_inode();
2466 } else if (event.has_ext4_get_implied_cluster_alloc_exit()) {
2467 const auto& inner = event.ext4_get_implied_cluster_alloc_exit();
2469 } else if (event.has_ext4_get_reserved_cluster_alloc()) {
2470 const auto& inner = event.ext4_get_reserved_cluster_alloc();
2472 } else if (event.has_ext4_ind_map_blocks_enter()) {
2473 const auto& inner = event.ext4_ind_map_blocks_enter();
2475 } else if (event.has_ext4_ind_map_blocks_exit()) {
2476 const auto& inner = event.ext4_ind_map_blocks_exit();
2478 } else if (event.has_ext4_insert_range()) {
2479 const auto& inner = event.ext4_insert_range();
2481 } else if (event.has_ext4_invalidatepage()) {
2482 const auto& inner = event.ext4_invalidatepage();
2484 } else if (event.has_ext4_journal_start()) {
2485 const auto& inner = event.ext4_journal_start();
2487 } else if (event.has_ext4_journal_start_reserved()) {
2488 const auto& inner = event.ext4_journal_start_reserved();
2490 } else if (event.has_ext4_journalled_invalidatepage()) {
2491 const auto& inner = event.ext4_journalled_invalidatepage();
2493 } else if (event.has_ext4_journalled_write_end()) {
2494 const auto& inner = event.ext4_journalled_write_end();
2496 } else if (event.has_ext4_load_inode()) {
2497 const auto& inner = event.ext4_load_inode();
2499 } else if (event.has_ext4_load_inode_bitmap()) {
2500 const auto& inner = event.ext4_load_inode_bitmap();
2502 } else if (event.has_ext4_mark_inode_dirty()) {
2503 const auto& inner = event.ext4_mark_inode_dirty();
2505 } else if (event.has_ext4_mb_bitmap_load()) {
2506 const auto& inner = event.ext4_mb_bitmap_load();
2508 } else if (event.has_ext4_mb_buddy_bitmap_load()) {
2509 const auto& inner = event.ext4_mb_buddy_bitmap_load();
2511 } else if (event.has_ext4_mb_discard_preallocations()) {
2512 const auto& inner = event.ext4_mb_discard_preallocations();
2514 } else if (event.has_ext4_mb_new_group_pa()) {
2515 const auto& inner = event.ext4_mb_new_group_pa();
2517 } else if (event.has_ext4_mb_new_inode_pa()) {
2518 const auto& inner = event.ext4_mb_new_inode_pa();
2520 } else if (event.has_ext4_mb_release_group_pa()) {
2521 const auto& inner = event.ext4_mb_release_group_pa();
2523 } else if (event.has_ext4_mb_release_inode_pa()) {
2524 const auto& inner = event.ext4_mb_release_inode_pa();
2526 } else if (event.has_ext4_mballoc_alloc()) {
2527 const auto& inner = event.ext4_mballoc_alloc();
2529 } else if (event
2530 const auto& inner = event.ext4_mballoc_discard();
2532 } else if (event.has_ext4_mballoc_free()) {
2533 const auto& inner = event.ext4_mballoc_free();
2535 } else if (event.has_ext4_mballoc_prealloc()) {
2536 const auto& inner = event.ext4_mballoc_prealloc();
2538 } else if (event.has_ext4_other_inode_update_time()) {
2539 const auto& inner = event.ext4_other_inode_update_time();
2541 } else if (event.has_ext4_punch_hole()) {
2542 const auto& inner = event.ext4_punch_hole();
2544 } else if (event.has_ext4_read_block_bitmap_load()) {
2545 const auto& inner = event.ext4_read_block_bitmap_load();
2547 } else if (event.has_ext4_readpage()) {
2548 const auto& inner = event.ext4_readpage();
2550 } else if (event.has_ext4_releasepage()) {
2551 const auto& inner = event.ext4_releasepage();
2553 } else if (event.has_ext4_remove_blocks()) {
2554 const auto& inner = event.ext4_remove_blocks();
2556 } else if (event.has_ext4_request_blocks()) {
2557 const auto& inner = event.ext4_request_blocks();
2559 } else if (event.has_ext4_request_inode()) {
2560 const auto& inner = event.ext4_request_inode();
2562 } else if (event.has_ext4_sync_file_enter()) {
2563 const auto& inner = event.ext4_sync_file_enter();
2565 } else if (event.has_ext4_sync_file_exit()) {
2566 const auto& inner = event.ext4_sync_file_exit();
2568 } else if (event.has_ext4_sync_fs()) {
2569 const auto& inner = event.ext4_sync_fs();
2571 } else if (event.has_ext4_trim_all_free()) {
2572 const auto& inner = event.ext4_trim_all_free();
2574 } else if (event.has_ext4_trim_extent()) {
2575 const auto& inner = event.ext4_trim_extent();
2577 } else if (event.has_ext4_truncate_enter()) {
2578 const auto& inner = event.ext4_truncate_enter();
2580 } else if (event.has_ext4_truncate_exit()) {
2581 const auto& inner = event.ext4_truncate_exit();
2583 } else if (event.has_ext4_unlink_enter()) {
2584 const auto& inner = event.ext4_unlink_enter();
2586 } else if (event.has_ext4_unlink_exit()) {
2587 const auto& inner = event.ext4_unlink_exit();
2589 } else if (event.has_ext4_write_begin()) {
2590 const auto& inner = event.ext4_write_begin();
2592 } else if (event.has_ext4_write_end()) {
2593 const auto& inner = event.ext4_write_end();
2595 } else if (event.has_ext4_writepage()) {
2596 const auto& inner = event.ext4_writepage();
2598 } else if (event.has_ext4_writepages()) {
2599 const auto& inner = event.ext4_writepages();
2601 } else if (event.has_ext4_writepages_result()) {
2602 const auto& inner = event.ext4_writepages_result();
2604 } else if (event.has_ext4_zero_range()) {
2605 const auto& inner = event.ext4_zero_range();
2607 } else if (event.has_print()) {
2608 const auto& inner = event.print();
2610 } else if (event.has_i2c_read()) {
2611 const auto& inner = event.i2c_read();
2613 } else if (event.has_i2c_reply()) {
2614 const auto& inner = event.i2c_reply();
2616 } else if (event.has_i2c_result()) {
2617 const auto& inner = event.i2c_result();
2619 } else if (event.has_i2c_write()) {
2620 const auto& inner = event.i2c_write();
2622 } else if (event.has_irq_handler_entry()) {
2623 const auto& inner = event.irq_handler_entry();
2625 } else if (event.has_irq_handler_exit()) {
2626 const auto& inner = event.irq_handler_exit();
2628 } else if (event.has_softirq_entry()) {
2629 const auto& inner = event.softirq_entry();
2631 } else if (event.has_softirq_exit()) {
2632 const auto& inner = event.softirq_exit();
2634 } else if (event.has_softirq_raise()) {
2635 const auto& inner = event.softirq_raise();
2637 } else if (event.has_lowmemory_kill()) {
2638 const auto& inner = event.lowmemory_kill();
2640 } else if (event.has_tracing_mark_write()) {
2641 const auto& inner = event.tracing_mark_write();
2643 } else if (event.has_clock_disable()) {
2644 const auto& inner = event.clock_disable();
2646 } else if (event.has_clock_enable()) {
2647 const auto& inner = event.clock_enable();
2649 } else if (event.has_clock_set_rate()) {
2650 const auto& inner = event.clock_set_rate();
2652 } else if (event.has_cpu_frequency()) {
2653 const auto& inner = event.cpu_frequency();
2655 } else if (event.has_cpu_frequency_limits()) {
2656 const auto& inner = event.cpu_frequency_limits();
2658 } else if (event.has_cpu_idle()) {
2659 const auto& inner = event.cpu_idle();
2661 } else if (event.has_suspend_resume()) {
2662 const auto& inner = event.suspend_resume();
2664 } else if (event.has_regulator_disable()) {
2665 const auto& inner = event.regulator_disable();
2667 } else if (event.has_regulator_disable_complete()) {
2668 const auto& inner = event.regulator_disable_complete();
2670 } else if (event.has_regulator_enable()) {
2671 const auto& inner = event.regulator_enable();
2673 } else if (event.has_regulator_enable_complete()) {
2674 const auto& inner = event.regulator_enable_complete();
2676 } else if (event.has_regulator_enable_delay()) {
2677 const auto& inner = event.regulator_enable_delay();
2679 } else if (event.has_regulator_set_voltage()) {
2680 const auto& inner = event.regulator_set_voltage();
2682 } else if (event.has_regulator_set_voltage_complete()) {
2683 const auto& inner = event.regulator_set_voltage_complete();
2685 } else if (event.has_sched_blocked_reason()) {
2686 const auto& inner = event.sched_blocked_reason();
2688 } else if (event.has_sched_cpu_hotplug()) {
2689 const auto& inner = event.sched_cpu_hotplug();
2691 } else if (event.has_sched_switch()) {
2692 const auto& inner = event.sched_switch();
2694 } else if (event.has_sched_wakeup()) {
2695 const auto& inner = event.sched_wakeup();
2697 } else if (event.has_sched_wakeup_new()) {
2698 const auto& inner = event.sched_wakeup_new();
2700 } else if (event.has_sync_pt()) {
2701 const auto& inner = event.sync_pt();
2703 } else if (event.has_sync_timeline()) {
2704 const auto& inner = event.sync_timeline();
2706 } else if (event.has_sync_wait()) {
2707 const auto& inner = event.sync_wait();
2709 } else if (event.has_mm_vmscan_direct_reclaim_begin()) {
2710 const auto& inner = event.mm_vmscan_direct_reclaim_begin();
2712 } else if (event.has_mm_vmscan_direct_reclaim_end()) {
2713 const auto& inner = event.mm_vmscan_direct_reclaim_end();
2715 } else if (event.has_mm_vmscan_kswapd_sleep()) {
2716 const auto& inner = event.mm_vmscan_kswapd_sleep();
2718 } else if (event.has_mm_vmscan_kswapd_wake()) {
2719 const auto& inner = event.mm_vmscan_kswapd_wake();
2721 } else if (event.has_workqueue_activate_work()) {
2722 const auto& inner = event.workqueue_activate_work();
2724 } else if (event.has_workqueue_execute_end()) {
2725 const auto& inner = event.workqueue_execute_end();
2727 } else if (event.has_workqueue_execute_start()) {
2728 const auto& inner = event.workqueue_execute_start();
2730 } else if (event.has_workqueue_queue_work()) {
2731 const auto& inner = event.workqueue_queue_work();
2733 } else if (event.has_sched_process_fork()) {
2734 const auto& inner = event.sched_process_fork();
2736 } else if (event.has_sched_process_hang()) {
2737 const auto& inner = event.sched_process_hang();
2739 } else if (event.has_sched_process_free()) {
2740 const auto& inner = event.sched_process_free();
2742 } else if (event.has_sched_process_exec()) {
2743 const auto& inner = event.sched_process_exec();
2745 } else if (event.has_sched_process_exit()) {
2746 const auto& inner = event.sched_process_exit();
2748 } else if (event.has_sched_process_wait()) {
2749 const auto& inner = event.sched_process_wait();
2751 } else if (event.has_task_rename()) {
2752 const auto& inner = event.task_rename();
2754 } else if (event.has_task_newtask()) {
2755 const auto& inner = event.task_newtask();
2757 } else if (event.has_f2fs_do_submit_bio()) {
2758 const auto& inner = event.f2fs_do_submit_bio();
2760 } else if (event.has_f2fs_evict_inode()) {
2761 const auto& inner = event.f2fs_evict_inode();
2763 } else if (event.has_f2fs_fallocate()) {
2764 const auto& inner = event.f2fs_fallocate();
2766 } else if (event.has_f2fs_get_data_block()) {
2767 const auto& inner = event.f2fs_get_data_block();
2769 } else if (event.has_f2fs_get_victim()) {
2770 const auto& inner = event.f2fs_get_victim();
2772 } else if (event.has_f2fs_iget()) {
2773 const auto& inner = event.f2fs_iget();
2775 } else if (event.has_f2fs_iget_exit()) {
2776 const auto& inner = event.f2fs_iget_exit();
2778 } else if (event.has_f2fs_new_inode()) {
2779 const auto& inner = event.f2fs_new_inode();
2781 } else if (event.has_f2fs_readpage()) {
2782 const auto& inner = event.f2fs_readpage();
2784 } else if (event.has_f2fs_reserve_new_block()) {
2785 const auto& inner = event.f2fs_reserve_new_block();
2787 } else if (event.has_f2fs_set_page_dirty()) {
2788 const auto& inner = event.f2fs_set_page_dirty();
2790 } else if (event.has_f2fs_submit_write_page()) {
2791 const auto& inner = event.f2fs_submit_write_page();
2793 } else if (event.has_f2fs_sync_file_enter()) {
2794 const auto& inner = event.f2fs_sync_file_enter();
2796 } else if (event.has_f2fs_sync_file_exit()) {
2797 const auto& inner = event.f2fs_sync_file_exit();
2799 } else if (event.has_f2fs_sync_fs()) {
2800 const auto& inner = event.f2fs_sync_fs();
2802 } else if (event.has_f2fs_truncate()) {
2803 const auto& inner = event.f2fs_truncate();
2805 } else if (event.has_f2fs_truncate_blocks_enter()) {
2806 const auto& inner = event.f2fs_truncate_blocks_enter();
2808 } else if (event.has_f2fs_truncate_blocks_exit()) {
2809 const auto& inner = event.f2fs_truncate_blocks_exit();
2811 } else if (event.has_f2fs_truncate_data_blocks_range()) {
2812 const auto& inner = event.f2fs_truncate_data_blocks_range();
2814 } else if (event.has_f2fs_truncate_inode_blocks_enter()) {
2815 const auto& inner = event.f2fs_truncate_inode_blocks_enter();
2817 } else if (event.has_f2fs_truncate_inode_blocks_exit()) {
2818 const auto& inner = event.f2fs_truncate_inode_blocks_exit();
2820 } else if (event.has_f2fs_truncate_node()) {
2821 const auto& inner = event.f2fs_truncate_node();
2823 } else if (event.has_f2fs_truncate_nodes_enter()) {
2824 const auto& inner = event.f2fs_truncate_nodes_enter();
2826 } else if (event.has_f2fs_truncate_nodes_exit()) {
2827 const auto& inner = event.f2fs_truncate_nodes_exit();
2829 } else if (event.has_f2fs_truncate_partial_nodes()) {
2830 const auto& inner = event.f2fs_truncate_partial_nodes();
2832 } else if (event.has_f2fs_unlink_enter()) {
2833 const auto& inner = event.f2fs_unlink_enter();
2835 } else if (event.has_f2fs_unlink_exit()) {
2836 const auto& inner = event.f2fs_unlink_exit();
2838 } else if (event.has_f2fs_vm_page_mkwrite()) {
2839 const auto& inner = event.f2fs_vm_page_mkwrite();
2841 } else if (event.has_f2fs_write_begin()) {
2842 const auto& inner = event.f2fs_write_begin();
2844 } else if (event.has_f2fs_write_checkpoint()) {
2845 const auto& inner = event.f2fs_write_checkpoint();
2847 } else if (event.has_f2fs_write_end()) {
2848 const auto& inner = event.f2fs_write_end();
2877 const protos::FtraceEvent& event) {
2878 std::string line = FormatEventText(event);
