1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /******************************************************************************* 18 * AUTOGENERATED - DO NOT EDIT 19 ******************************************************************************* 20 * This file has been generated from the protobuf message 21 * perfetto/config/trace_config.proto 22 * by 23 * ../../tools/proto_to_cpp/proto_to_cpp.cc. 24 * If you need to make changes here, change the .proto file and then run 25 * ./tools/gen_tracing_cpp_headers_from_protos.py 26 */ 27 28 #ifndef INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_ 29 #define INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_ 30 31 #include <stdint.h> 32 #include <string> 33 #include <type_traits> 34 #include <vector> 35 36 #include "perfetto/base/export.h" 37 38 #include "perfetto/tracing/core/data_source_config.h" 39 40 // Forward declarations for protobuf types. 41 namespace perfetto { 42 namespace protos { 43 class TraceConfig; 44 class TraceConfig_BufferConfig; 45 class TraceConfig_DataSource; 46 class DataSourceConfig; 47 class FtraceConfig; 48 class ChromeConfig; 49 class InodeFileConfig; 50 class InodeFileConfig_MountPointMappingEntry; 51 class ProcessStatsConfig; 52 class TestConfig; 53 class TraceConfig_ProducerConfig; 54 class TraceConfig_StatsdMetadata; 55 class TraceConfig_GuardrailOverrides; 56 } // namespace protos 57 } // namespace perfetto 58 59 namespace perfetto { 60 61 class PERFETTO_EXPORT TraceConfig { 62 public: 63 class PERFETTO_EXPORT BufferConfig { 64 public: 65 enum FillPolicy { 66 UNSPECIFIED = 0, 67 RING_BUFFER = 1, 68 }; 69 BufferConfig(); 70 ~BufferConfig(); 71 BufferConfig(BufferConfig&&) noexcept; 72 BufferConfig& operator=(BufferConfig&&); 73 BufferConfig(const BufferConfig&); 74 BufferConfig& operator=(const BufferConfig&); 75 76 // Conversion methods from/to the corresponding protobuf types. 77 void FromProto(const perfetto::protos::TraceConfig_BufferConfig&); 78 void ToProto(perfetto::protos::TraceConfig_BufferConfig*) const; 79 80 uint32_t size_kb() const { return size_kb_; } 81 void set_size_kb(uint32_t value) { size_kb_ = value; } 82 83 FillPolicy fill_policy() const { return fill_policy_; } 84 void set_fill_policy(FillPolicy value) { fill_policy_ = value; } 85 86 private: 87 uint32_t size_kb_ = {}; 88 FillPolicy fill_policy_ = {}; 89 90 // Allows to preserve unknown protobuf fields for compatibility 91 // with future versions of .proto files. 92 std::string unknown_fields_; 93 }; 94 95 class PERFETTO_EXPORT DataSource { 96 public: 97 DataSource(); 98 ~DataSource(); 99 DataSource(DataSource&&) noexcept; 100 DataSource& operator=(DataSource&&); 101 DataSource(const DataSource&); 102 DataSource& operator=(const DataSource&); 103 104 // Conversion methods from/to the corresponding protobuf types. 105 void FromProto(const perfetto::protos::TraceConfig_DataSource&); 106 void ToProto(perfetto::protos::TraceConfig_DataSource*) const; 107 108 const DataSourceConfig& config() const { return config_; } 109 DataSourceConfig* mutable_config() { return &config_; } 110 111 int producer_name_filter_size() const { 112 return static_cast<int>(producer_name_filter_.size()); 113 } 114 const std::vector<std::string>& producer_name_filter() const { 115 return producer_name_filter_; 116 } 117 std::string* add_producer_name_filter() { 118 producer_name_filter_.emplace_back(); 119 return &producer_name_filter_.back(); 120 } 121 122 private: 123 DataSourceConfig config_ = {}; 124 std::vector<std::string> producer_name_filter_; 125 126 // Allows to preserve unknown protobuf fields for compatibility 127 // with future versions of .proto files. 128 std::string unknown_fields_; 129 }; 130 131 enum LockdownModeOperation { 132 LOCKDOWN_UNCHANGED = 0, 133 LOCKDOWN_CLEAR = 1, 134 LOCKDOWN_SET = 2, 135 }; 136 137 class PERFETTO_EXPORT ProducerConfig { 138 public: 139 ProducerConfig(); 140 ~ProducerConfig(); 141 ProducerConfig(ProducerConfig&&) noexcept; 142 ProducerConfig& operator=(ProducerConfig&&); 143 ProducerConfig(const ProducerConfig&); 144 ProducerConfig& operator=(const ProducerConfig&); 145 146 // Conversion methods from/to the corresponding protobuf types. 147 void FromProto(const perfetto::protos::TraceConfig_ProducerConfig&); 148 void ToProto(perfetto::protos::TraceConfig_ProducerConfig*) const; 149 150 const std::string& producer_name() const { return producer_name_; } 151 void set_producer_name(const std::string& value) { producer_name_ = value; } 152 153 uint32_t shm_size_kb() const { return shm_size_kb_; } 154 void set_shm_size_kb(uint32_t value) { shm_size_kb_ = value; } 155 156 uint32_t page_size_kb() const { return page_size_kb_; } 157 void set_page_size_kb(uint32_t value) { page_size_kb_ = value; } 158 159 private: 160 std::string producer_name_ = {}; 161 uint32_t shm_size_kb_ = {}; 162 uint32_t page_size_kb_ = {}; 163 164 // Allows to preserve unknown protobuf fields for compatibility 165 // with future versions of .proto files. 166 std::string unknown_fields_; 167 }; 168 169 class PERFETTO_EXPORT StatsdMetadata { 170 public: 171 StatsdMetadata(); 172 ~StatsdMetadata(); 173 StatsdMetadata(StatsdMetadata&&) noexcept; 174 StatsdMetadata& operator=(StatsdMetadata&&); 175 StatsdMetadata(const StatsdMetadata&); 176 StatsdMetadata& operator=(const StatsdMetadata&); 177 178 // Conversion methods from/to the corresponding protobuf types. 179 void FromProto(const perfetto::protos::TraceConfig_StatsdMetadata&); 180 void ToProto(perfetto::protos::TraceConfig_StatsdMetadata*) const; 181 182 int64_t triggering_alert_id() const { return triggering_alert_id_; } 183 void set_triggering_alert_id(int64_t value) { 184 triggering_alert_id_ = value; 185 } 186 187 int32_t triggering_config_uid() const { return triggering_config_uid_; } 188 void set_triggering_config_uid(int32_t value) { 189 triggering_config_uid_ = value; 190 } 191 192 int64_t triggering_config_id() const { return triggering_config_id_; } 193 void set_triggering_config_id(int64_t value) { 194 triggering_config_id_ = value; 195 } 196 197 private: 198 int64_t triggering_alert_id_ = {}; 199 int32_t triggering_config_uid_ = {}; 200 int64_t triggering_config_id_ = {}; 201 202 // Allows to preserve unknown protobuf fields for compatibility 203 // with future versions of .proto files. 204 std::string unknown_fields_; 205 }; 206 207 class PERFETTO_EXPORT GuardrailOverrides { 208 public: 209 GuardrailOverrides(); 210 ~GuardrailOverrides(); 211 GuardrailOverrides(GuardrailOverrides&&) noexcept; 212 GuardrailOverrides& operator=(GuardrailOverrides&&); 213 GuardrailOverrides(const GuardrailOverrides&); 214 GuardrailOverrides& operator=(const GuardrailOverrides&); 215 216 // Conversion methods from/to the corresponding protobuf types. 217 void FromProto(const perfetto::protos::TraceConfig_GuardrailOverrides&); 218 void ToProto(perfetto::protos::TraceConfig_GuardrailOverrides*) const; 219 220 uint64_t max_upload_per_day_bytes() const { 221 return max_upload_per_day_bytes_; 222 } 223 void set_max_upload_per_day_bytes(uint64_t value) { 224 max_upload_per_day_bytes_ = value; 225 } 226 227 private: 228 uint64_t max_upload_per_day_bytes_ = {}; 229 230 // Allows to preserve unknown protobuf fields for compatibility 231 // with future versions of .proto files. 232 std::string unknown_fields_; 233 }; 234 235 TraceConfig(); 236 ~TraceConfig(); 237 TraceConfig(TraceConfig&&) noexcept; 238 TraceConfig& operator=(TraceConfig&&); 239 TraceConfig(const TraceConfig&); 240 TraceConfig& operator=(const TraceConfig&); 241 242 // Conversion methods from/to the corresponding protobuf types. 243 void FromProto(const perfetto::protos::TraceConfig&); 244 void ToProto(perfetto::protos::TraceConfig*) const; 245 246 int buffers_size() const { return static_cast<int>(buffers_.size()); } 247 const std::vector<BufferConfig>& buffers() const { return buffers_; } 248 BufferConfig* add_buffers() { 249 buffers_.emplace_back(); 250 return &buffers_.back(); 251 } 252 253 int data_sources_size() const { 254 return static_cast<int>(data_sources_.size()); 255 } 256 const std::vector<DataSource>& data_sources() const { return data_sources_; } 257 DataSource* add_data_sources() { 258 data_sources_.emplace_back(); 259 return &data_sources_.back(); 260 } 261 262 uint32_t duration_ms() const { return duration_ms_; } 263 void set_duration_ms(uint32_t value) { duration_ms_ = value; } 264 265 bool enable_extra_guardrails() const { return enable_extra_guardrails_; } 266 void set_enable_extra_guardrails(bool value) { 267 enable_extra_guardrails_ = value; 268 } 269 270 LockdownModeOperation lockdown_mode() const { return lockdown_mode_; } 271 void set_lockdown_mode(LockdownModeOperation value) { 272 lockdown_mode_ = value; 273 } 274 275 int producers_size() const { return static_cast<int>(producers_.size()); } 276 const std::vector<ProducerConfig>& producers() const { return producers_; } 277 ProducerConfig* add_producers() { 278 producers_.emplace_back(); 279 return &producers_.back(); 280 } 281 282 const StatsdMetadata& statsd_metadata() const { return statsd_metadata_; } 283 StatsdMetadata* mutable_statsd_metadata() { return &statsd_metadata_; } 284 285 bool write_into_file() const { return write_into_file_; } 286 void set_write_into_file(bool value) { write_into_file_ = value; } 287 288 uint32_t file_write_period_ms() const { return file_write_period_ms_; } 289 void set_file_write_period_ms(uint32_t value) { 290 file_write_period_ms_ = value; 291 } 292 293 uint64_t max_file_size_bytes() const { return max_file_size_bytes_; } 294 void set_max_file_size_bytes(uint64_t value) { max_file_size_bytes_ = value; } 295 296 const GuardrailOverrides& guardrail_overrides() const { 297 return guardrail_overrides_; 298 } 299 GuardrailOverrides* mutable_guardrail_overrides() { 300 return &guardrail_overrides_; 301 } 302 303 private: 304 std::vector<BufferConfig> buffers_; 305 std::vector<DataSource> data_sources_; 306 uint32_t duration_ms_ = {}; 307 bool enable_extra_guardrails_ = {}; 308 LockdownModeOperation lockdown_mode_ = {}; 309 std::vector<ProducerConfig> producers_; 310 StatsdMetadata statsd_metadata_ = {}; 311 bool write_into_file_ = {}; 312 uint32_t file_write_period_ms_ = {}; 313 uint64_t max_file_size_bytes_ = {}; 314 GuardrailOverrides guardrail_overrides_ = {}; 315 316 // Allows to preserve unknown protobuf fields for compatibility 317 // with future versions of .proto files. 318 std::string unknown_fields_; 319 }; 320 321 } // namespace perfetto 322 #endif // INCLUDE_PERFETTO_TRACING_CORE_TRACE_CONFIG_H_ 323