| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 syntax = "proto2"; | |
| 6 | |
| 7 option optimize_for = LITE_RUNTIME; | |
| 8 | |
| 9 package metrics; | |
| 10 | |
| 11 // Stores information from a perf session generated via running: | |
| 12 // "perf record" | |
| 13 // | |
| 14 // See $kernel/tools/perf/design.txt for more details. | |
| 15 | |
| 16 // Please do not modify this protobuf directly, except to mirror the upstream | |
| 17 // version found here: | |
| 18 // https://chromium.googlesource.com/chromiumos/platform/chromiumos-wide-profili
ng/+/master/perf_data.proto | |
| 19 // with some fields omitted for privacy reasons. Because it is a read-only copy | |
| 20 // of the upstream protobuf, "Next tag:" comments are also absent. | |
| 21 | |
| 22 message PerfDataProto { | |
| 23 | |
| 24 // Perf event attribute. Stores the event description. | |
| 25 // This data structure is defined in the linux kernel: | |
| 26 // $kernel/tools/perf/util/event.h. | |
| 27 message PerfEventAttr { | |
| 28 // Type of the event. Type is an enumeration and can be: | |
| 29 // IP: an instruction-pointer was stored in the event. | |
| 30 // MMAP: a DLL was loaded. | |
| 31 // FORK: a process was forked. | |
| 32 // etc. | |
| 33 optional uint32 type = 1; | |
| 34 | |
| 35 // Size of the event data in bytes. | |
| 36 optional uint32 size = 2; | |
| 37 | |
| 38 // The config stores the CPU-specific counter information. | |
| 39 optional uint64 config = 3; | |
| 40 | |
| 41 // Sample period of the event. Indicates how often the event is | |
| 42 // triggered in terms of # of events. After |sample_period| events, an event | |
| 43 // will be recorded and stored. | |
| 44 optional uint64 sample_period = 4; | |
| 45 | |
| 46 // Sample frequency of the event. Indicates how often the event is | |
| 47 // triggered in terms of # per second. The kernel will try to record | |
| 48 // |sample_freq| events per second. | |
| 49 optional uint64 sample_freq = 5; | |
| 50 | |
| 51 // Sample type is a bitfield that records attributes of the sample. Example, | |
| 52 // whether an entire callchain was recorded, etc. | |
| 53 optional uint64 sample_type = 6; | |
| 54 | |
| 55 // Bitfield that indicates whether reads on the counter will return the | |
| 56 // total time enabled and total time running. | |
| 57 optional uint64 read_format = 7; | |
| 58 | |
| 59 // Indicates whether the counter starts off disabled. | |
| 60 optional bool disabled = 8; | |
| 61 | |
| 62 // Indicates whether child processes inherit the counter. | |
| 63 optional bool inherit = 9; | |
| 64 | |
| 65 // Indicates whether the counter is pinned to a particular CPU. | |
| 66 optional bool pinned = 10; | |
| 67 | |
| 68 // Indicates whether this counter's group has exclusive access to the CPU's | |
| 69 // counters. | |
| 70 optional bool exclusive = 11; | |
| 71 | |
| 72 // The following bits restrict events to be counted when the CPU is in user, | |
| 73 // kernel, hypervisor or idle modes. | |
| 74 optional bool exclude_user = 12; | |
| 75 optional bool exclude_kernel = 13; | |
| 76 optional bool exclude_hv = 14; | |
| 77 optional bool exclude_idle = 15; | |
| 78 | |
| 79 // Indicates whether mmap events should be recorded. | |
| 80 optional bool mmap = 16; | |
| 81 | |
| 82 // Indicates whether process comm information should be recorded upon | |
| 83 // process creation. | |
| 84 optional bool comm = 17; | |
| 85 | |
| 86 // Indicates that we are in frequency mode, not period mode. | |
| 87 optional bool freq = 18; | |
| 88 | |
| 89 // Indicates whether we have per-task counts. | |
| 90 optional bool inherit_stat = 19; | |
| 91 | |
| 92 // Indicates whether we enable perf events after an exec() function call. | |
| 93 optional bool enable_on_exec = 20; | |
| 94 | |
| 95 // Indicates whether we trace fork/exit. | |
| 96 optional bool task = 21; | |
| 97 | |
| 98 // Indicates whether we are using a watermark to wake up. | |
| 99 optional bool watermark = 22; | |
| 100 | |
| 101 // CPUs often "skid" when recording events. That means the instruction | |
| 102 // pointer may not be the same as the one that caused the counter overflow. | |
| 103 // Indicates the capabilities of the CPU in terms of recording precise | |
| 104 // instruction pointer. | |
| 105 optional uint32 precise_ip = 23; | |
| 106 | |
| 107 // Indicates whether we have non-exec mmap data. | |
| 108 optional bool mmap_data = 24; | |
| 109 | |
| 110 // If set, all the event types will have the same sample_type. | |
| 111 optional bool sample_id_all = 25; | |
| 112 | |
| 113 // Indicates whether we are counting events from the host (when running a | |
| 114 // VM). | |
| 115 optional bool exclude_host = 26; | |
| 116 | |
| 117 // Exclude events that happen on a guest OS. | |
| 118 optional bool exclude_guest = 27; | |
| 119 | |
| 120 // Contains the number of events after which we wake up. | |
| 121 optional uint32 wakeup_events = 28; | |
| 122 | |
| 123 // Contains the number of bytes after which we wake up. | |
| 124 optional uint32 wakeup_watermark = 29; | |
| 125 | |
| 126 // Information about the type of the breakpoint. | |
| 127 optional uint32 bp_type = 30; | |
| 128 | |
| 129 // Contains the breakpoint address. | |
| 130 optional uint64 bp_addr = 31; | |
| 131 | |
| 132 // This is an extension of config (see above). | |
| 133 optional uint64 config1 = 32; | |
| 134 | |
| 135 // The length of the breakpoint data in bytes. | |
| 136 optional uint64 bp_len = 33; | |
| 137 | |
| 138 // This is an extension of config (see above). | |
| 139 optional uint64 config2 = 34; | |
| 140 | |
| 141 // Contains the type of branch, example: user, kernel, call, return, etc. | |
| 142 optional uint64 branch_sample_type = 35; | |
| 143 } | |
| 144 | |
| 145 // Describes a perf.data file attribute. | |
| 146 message PerfFileAttr { | |
| 147 optional PerfEventAttr attr = 1; | |
| 148 | |
| 149 // List of perf file attribute ids. Each id describes an event. | |
| 150 repeated uint64 ids = 2; | |
| 151 } | |
| 152 | |
| 153 // This message contains information about a perf sample itself, as opposed to | |
| 154 // a perf event captured by a sample. | |
| 155 message SampleInfo { | |
| 156 // Process ID / thread ID from which this sample was taken. | |
| 157 optional uint32 pid = 1; | |
| 158 optional uint32 tid = 2; | |
| 159 | |
| 160 // Time this sample was taken (NOT the same as an event time). | |
| 161 // It is the number of nanoseconds since bootup. | |
| 162 optional uint64 sample_time_ns = 3; | |
| 163 | |
| 164 // The ID of the sample's event type (cycles, instructions, etc). | |
| 165 // The event type IDs are defined in PerfFileAttr. | |
| 166 optional uint64 id = 4; | |
| 167 | |
| 168 // The CPU on which this sample was taken. | |
| 169 optional uint32 cpu = 5; | |
| 170 } | |
| 171 | |
| 172 message CommEvent { | |
| 173 // Process id. | |
| 174 optional uint32 pid = 1; | |
| 175 | |
| 176 // Thread id. | |
| 177 optional uint32 tid = 2; | |
| 178 | |
| 179 // Comm string's md5 prefix. | |
| 180 // The comm string was field 3 and has been intentionally left out. | |
| 181 optional uint64 comm_md5_prefix = 4; | |
| 182 | |
| 183 // Time the sample was taken. | |
| 184 // Deprecated, use |sample_info| instead. | |
| 185 optional uint64 sample_time = 5 [deprecated=true]; | |
| 186 | |
| 187 // Info about the perf sample containing this event. | |
| 188 optional SampleInfo sample_info = 6; | |
| 189 } | |
| 190 | |
| 191 message MMapEvent { | |
| 192 // Process id. | |
| 193 optional uint32 pid = 1; | |
| 194 | |
| 195 // Thread id. | |
| 196 optional uint32 tid = 2; | |
| 197 | |
| 198 // Start address. | |
| 199 optional uint64 start = 3; | |
| 200 | |
| 201 // Length. | |
| 202 optional uint64 len = 4; | |
| 203 | |
| 204 // PG Offset. | |
| 205 optional uint64 pgoff = 5; | |
| 206 | |
| 207 // Filename's md5 prefix. | |
| 208 // The filename was field 6 and has been intentionally left out. | |
| 209 optional uint64 filename_md5_prefix = 7; | |
| 210 | |
| 211 // Info about the perf sample containing this event. | |
| 212 optional SampleInfo sample_info = 8; | |
| 213 } | |
| 214 | |
| 215 message BranchStackEntry { | |
| 216 // Branch source address. | |
| 217 optional uint64 from_ip = 1; | |
| 218 | |
| 219 // Branch destination address. | |
| 220 optional uint64 to_ip = 2; | |
| 221 | |
| 222 // Indicates a mispredicted branch. | |
| 223 optional bool mispredicted = 3; | |
| 224 } | |
| 225 | |
| 226 message SampleEvent { | |
| 227 // Instruction pointer. | |
| 228 optional uint64 ip = 1; | |
| 229 | |
| 230 // Process id. | |
| 231 optional uint32 pid = 2; | |
| 232 | |
| 233 // Thread id. | |
| 234 optional uint32 tid = 3; | |
| 235 | |
| 236 // The time after boot when the sample was recorded, in nanoseconds. | |
| 237 optional uint64 sample_time_ns = 4; | |
| 238 | |
| 239 // The address of the sample. | |
| 240 optional uint64 addr = 5; | |
| 241 | |
| 242 // The id of the sample. | |
| 243 optional uint64 id = 6; | |
| 244 | |
| 245 // The stream id of the sample. | |
| 246 optional uint64 stream_id = 7; | |
| 247 | |
| 248 // The period of the sample. | |
| 249 optional uint64 period = 8; | |
| 250 | |
| 251 // The CPU where the event was recorded. | |
| 252 optional uint32 cpu = 9; | |
| 253 | |
| 254 // The raw size of the event in bytes. | |
| 255 optional uint32 raw_size = 10; | |
| 256 | |
| 257 // Sample callchain info. | |
| 258 repeated uint64 callchain = 11; | |
| 259 | |
| 260 // Branch stack info. | |
| 261 repeated BranchStackEntry branch_stack = 12; | |
| 262 } | |
| 263 | |
| 264 // ForkEvent is used for both FORK and EXIT events, which have the same data | |
| 265 // format. We don't want to call this "ForkOrExitEvent", in case a separate | |
| 266 // exit event is introduced in the future. | |
| 267 message ForkEvent { | |
| 268 // Forked process ID. | |
| 269 optional uint32 pid = 1; | |
| 270 | |
| 271 // Parent process ID. | |
| 272 optional uint32 ppid = 2; | |
| 273 | |
| 274 // Forked process thread ID. | |
| 275 optional uint32 tid = 3; | |
| 276 | |
| 277 // Parent process thread ID. | |
| 278 optional uint32 ptid = 4; | |
| 279 | |
| 280 // Time of fork event in nanoseconds since bootup. | |
| 281 optional uint64 fork_time_ns = 5; | |
| 282 | |
| 283 // Info about the perf sample containing this event. | |
| 284 optional SampleInfo sample_info = 11; | |
| 285 } | |
| 286 | |
| 287 message EventHeader { | |
| 288 // Type of event. | |
| 289 optional uint32 type = 1; | |
| 290 optional uint32 misc = 2; | |
| 291 // Size of event. | |
| 292 optional uint32 size = 3; | |
| 293 } | |
| 294 | |
| 295 message PerfEvent { | |
| 296 optional EventHeader header = 1; | |
| 297 | |
| 298 optional MMapEvent mmap_event = 2; | |
| 299 optional SampleEvent sample_event = 3; | |
| 300 optional CommEvent comm_event = 4; | |
| 301 optional ForkEvent fork_event = 5; | |
| 302 } | |
| 303 | |
| 304 message PerfEventStats { | |
| 305 // Total number of events read from perf data. | |
| 306 optional uint32 num_events_read = 1; | |
| 307 | |
| 308 // Total number of various types of events. | |
| 309 optional uint32 num_sample_events = 2; | |
| 310 optional uint32 num_mmap_events = 3; | |
| 311 optional uint32 num_fork_events = 4; | |
| 312 optional uint32 num_exit_events = 5; | |
| 313 | |
| 314 // Number of sample events that were successfully mapped by the address | |
| 315 // mapper, a quipper module that is used to obscure addresses and convert | |
| 316 // them to DSO name + offset. Sometimes it fails to process sample events. | |
| 317 // This field allows us to track the success rate of the address mapper. | |
| 318 optional uint32 num_sample_events_mapped = 6; | |
| 319 | |
| 320 // Whether address remapping was enabled. | |
| 321 optional bool did_remap = 7; | |
| 322 } | |
| 323 | |
| 324 message PerfBuildID { | |
| 325 // Misc field in perf_event_header. | |
| 326 // Indicates whether the file is mapped in kernel mode or user mode. | |
| 327 optional uint32 misc = 1; | |
| 328 | |
| 329 // Process ID. | |
| 330 optional uint32 pid = 2; | |
| 331 | |
| 332 // Build id. Should always contain kBuildIDArraySize bytes of data. | |
| 333 // perf_reader.h in Chrome OS defines kBuildIDArraySize = 20. | |
| 334 optional bytes build_hash = 3; | |
| 335 | |
| 336 // Filename Md5sum prefix. | |
| 337 // The filename was field 4 and has been intentionally left out. | |
| 338 optional uint64 filename_md5_prefix = 5; | |
| 339 } | |
| 340 | |
| 341 repeated PerfFileAttr file_attrs = 1; | |
| 342 repeated PerfEvent events = 2; | |
| 343 | |
| 344 // Time when quipper generated this perf data / protobuf, given as seconds | |
| 345 // since the epoch. | |
| 346 optional uint64 timestamp_sec = 3; | |
| 347 | |
| 348 // Records some stats about the serialized perf events. | |
| 349 optional PerfEventStats stats = 4; | |
| 350 | |
| 351 // Not added from original: repeated uint64 metadata_mask = 5; | |
| 352 // Not added from original: repeated PerfStringMetadata string_metadata = 6; | |
| 353 | |
| 354 // Build ID metadata. | |
| 355 repeated PerfBuildID build_ids = 7; | |
| 356 } | |
| OLD | NEW |