1 /* 2 ** 3 ** Copyright 2015, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #include <assert.h> 19 #include <stdio.h> 20 #include <stdlib.h> 21 22 #include <algorithm> 23 #include <cstring> 24 #include <sstream> 25 26 #include <android-base/file.h> 27 #include <android-base/logging.h> 28 29 #include "configreader.h" 30 31 // 32 // Config file path 33 // 34 static const char *config_file_path = 35 "/data/data/com.google.android.gms/files/perfprofd.conf"; 36 37 ConfigReader::ConfigReader() 38 : trace_config_read(false) 39 { 40 addDefaultEntries(); 41 } 42 43 ConfigReader::~ConfigReader() 44 { 45 } 46 47 const char *ConfigReader::getConfigFilePath() 48 { 49 return config_file_path; 50 } 51 52 void ConfigReader::setConfigFilePath(const char *path) 53 { 54 config_file_path = strdup(path); 55 LOG(INFO) << "config file path set to " << config_file_path; 56 } 57 58 // 59 // Populate the reader with the set of allowable entries 60 // 61 void ConfigReader::addDefaultEntries() 62 { 63 struct DummyConfig : public Config { 64 void Sleep(size_t seconds) override {} 65 bool IsProfilingEnabled() const override { return false; } 66 }; 67 DummyConfig config; 68 69 // Average number of seconds between perf profile collections (if 70 // set to 100, then over time we want to see a perf profile 71 // collected every 100 seconds). The actual time within the interval 72 // for the collection is chosen randomly. 73 addUnsignedEntry("collection_interval", config.collection_interval_in_s, 0, UINT32_MAX); 74 75 // Use the specified fixed seed for random number generation (unit 76 // testing) 77 addUnsignedEntry("use_fixed_seed", config.use_fixed_seed, 0, UINT32_MAX); 78 79 // For testing purposes, number of times to iterate through main 80 // loop. Value of zero indicates that we should loop forever. 81 addUnsignedEntry("main_loop_iterations", config.main_loop_iterations, 0, UINT32_MAX); 82 83 // Destination directory (where to write profiles). This location 84 // chosen since it is accessible to the uploader service. 85 addStringEntry("destination_directory", config.destination_directory.c_str()); 86 87 // Config directory (where to read configs). 88 addStringEntry("config_directory", config.config_directory.c_str()); 89 90 // Full path to 'perf' executable. 91 addStringEntry("perf_path", config.perf_path.c_str()); 92 93 // Desired sampling period (passed to perf -c option). 94 addUnsignedEntry("sampling_period", config.sampling_period, 0, UINT32_MAX); 95 // Desired sampling frequency (passed to perf -f option). 96 addUnsignedEntry("sampling_frequency", config.sampling_frequency, 0, UINT32_MAX); 97 98 // Length of time to collect samples (number of seconds for 'perf 99 // record -a' run). 100 addUnsignedEntry("sample_duration", config.sample_duration_in_s, 1, 600); 101 102 // If this parameter is non-zero it will cause perfprofd to 103 // exit immediately if the build type is not userdebug or eng. 104 // Currently defaults to 1 (true). 105 addUnsignedEntry("only_debug_build", config.only_debug_build ? 1 : 0, 0, 1); 106 107 // If the "mpdecision" service is running at the point we are ready 108 // to kick off a profiling run, then temporarily disable the service 109 // and hard-wire all cores on prior to the collection run, provided 110 // that the duration of the recording is less than or equal to the value of 111 // 'hardwire_cpus_max_duration'. 112 addUnsignedEntry("hardwire_cpus", config.hardwire_cpus, 0, 1); 113 addUnsignedEntry("hardwire_cpus_max_duration", 114 config.hardwire_cpus_max_duration_in_s, 115 1, 116 UINT32_MAX); 117 118 // Maximum number of unprocessed profiles we can accumulate in the 119 // destination directory. Once we reach this limit, we continue 120 // to collect, but we just overwrite the most recent profile. 121 addUnsignedEntry("max_unprocessed_profiles", config.max_unprocessed_profiles, 1, UINT32_MAX); 122 123 // If set to 1, pass the -g option when invoking 'perf' (requests 124 // stack traces as opposed to flat profile). 125 addUnsignedEntry("stack_profile", config.stack_profile ? 1 : 0, 0, 1); 126 127 // For unit testing only: if set to 1, emit info messages on config 128 // file parsing. 129 addUnsignedEntry("trace_config_read", config.trace_config_read ? 1 : 0, 0, 1); 130 131 // Control collection of various additional profile tags 132 addUnsignedEntry("collect_cpu_utilization", config.collect_cpu_utilization ? 1 : 0, 0, 1); 133 addUnsignedEntry("collect_charging_state", config.collect_charging_state ? 1 : 0, 0, 1); 134 addUnsignedEntry("collect_booting", config.collect_booting ? 1 : 0, 0, 1); 135 addUnsignedEntry("collect_camera_active", config.collect_camera_active ? 1 : 0, 0, 1); 136 137 // If true, use an ELF symbolizer to on-device symbolize. 138 addUnsignedEntry("use_elf_symbolizer", config.use_elf_symbolizer ? 1 : 0, 0, 1); 139 140 // If true, use libz to compress the output proto. 141 addUnsignedEntry("compress", config.compress ? 1 : 0, 0, 1); 142 143 // If true, send the proto to dropbox instead of to a file. 144 addUnsignedEntry("dropbox", config.send_to_dropbox ? 1 : 0, 0, 1); 145 146 // The pid of the process to profile. May be negative, in which case 147 // the whole system will be profiled. 148 addUnsignedEntry("process", static_cast<uint32_t>(-1), 0, UINT32_MAX); 149 } 150 151 void ConfigReader::addUnsignedEntry(const char *key, 152 unsigned default_value, 153 unsigned min_value, 154 unsigned max_value) 155 { 156 std::string ks(key); 157 CHECK(u_entries.find(ks) == u_entries.end() && 158 s_entries.find(ks) == s_entries.end()) 159 << "internal error -- duplicate entry for key " << key; 160 values vals; 161 vals.minv = min_value; 162 vals.maxv = max_value; 163 u_info[ks] = vals; 164 u_entries[ks] = default_value; 165 } 166 167 void ConfigReader::addStringEntry(const char *key, const char *default_value) 168 { 169 std::string ks(key); 170 CHECK(u_entries.find(ks) == u_entries.end() && 171 s_entries.find(ks) == s_entries.end()) 172 << "internal error -- duplicate entry for key " << key; 173 CHECK(default_value != nullptr) << "internal error -- bad default value for key " << key; 174 s_entries[ks] = std::string(default_value); 175 } 176 177 unsigned ConfigReader::getUnsignedValue(const char *key) const 178 { 179 std::string ks(key); 180 auto it = u_entries.find(ks); 181 CHECK(it != u_entries.end()); 182 return it->second; 183 } 184 185 bool ConfigReader::getBoolValue(const char *key) const 186 { 187 std::string ks(key); 188 auto it = u_entries.find(ks); 189 CHECK(it != u_entries.end()); 190 return it->second != 0; 191 } 192 193 std::string ConfigReader::getStringValue(const char *key) const 194 { 195 std::string ks(key); 196 auto it = s_entries.find(ks); 197 CHECK(it != s_entries.end()); 198 return it->second; 199 } 200 201 void ConfigReader::overrideUnsignedEntry(const char *key, unsigned new_value) 202 { 203 std::string ks(key); 204 auto it = u_entries.find(ks); 205 CHECK(it != u_entries.end()); 206 values vals; 207 auto iit = u_info.find(key); 208 CHECK(iit != u_info.end()); 209 vals = iit->second; 210 CHECK(new_value >= vals.minv && new_value <= vals.maxv); 211 it->second = new_value; 212 LOG(INFO) << "option " << key << " overridden to " << new_value; 213 } 214 215 216 // 217 // Parse a key=value pair read from the config file. This will issue 218 // warnings or errors to the system logs if the line can't be 219 // interpreted properly. 220 // 221 bool ConfigReader::parseLine(const char *key, 222 const char *value, 223 unsigned linecount) 224 { 225 assert(key); 226 assert(value); 227 228 auto uit = u_entries.find(key); 229 if (uit != u_entries.end()) { 230 unsigned uvalue = 0; 231 if (isdigit(value[0]) == 0 || sscanf(value, "%u", &uvalue) != 1) { 232 LOG(WARNING) << "line " << linecount << ": malformed unsigned value (ignored)"; 233 return false; 234 } else { 235 values vals; 236 auto iit = u_info.find(key); 237 assert(iit != u_info.end()); 238 vals = iit->second; 239 if (uvalue < vals.minv || uvalue > vals.maxv) { 240 LOG(WARNING) << "line " << linecount << ": " 241 << "specified value " << uvalue << " for '" << key << "' " 242 << "outside permitted range [" << vals.minv << " " << vals.maxv 243 << "] (ignored)"; 244 return false; 245 } else { 246 if (trace_config_read) { 247 LOG(INFO) << "option " << key << " set to " << uvalue; 248 } 249 uit->second = uvalue; 250 } 251 } 252 trace_config_read = (getUnsignedValue("trace_config_read") != 0); 253 return true; 254 } 255 256 auto sit = s_entries.find(key); 257 if (sit != s_entries.end()) { 258 if (trace_config_read) { 259 LOG(INFO) << "option " << key << " set to " << value; 260 } 261 sit->second = std::string(value); 262 return true; 263 } 264 265 LOG(WARNING) << "line " << linecount << ": unknown option '" << key << "' ignored"; 266 return false; 267 } 268 269 static bool isblank(const std::string &line) 270 { 271 auto non_space = [](char c) { return isspace(c) == 0; }; 272 return std::find_if(line.begin(), line.end(), non_space) == line.end(); 273 } 274 275 276 277 bool ConfigReader::readFile() 278 { 279 std::string contents; 280 if (! android::base::ReadFileToString(config_file_path, &contents)) { 281 return false; 282 } 283 return Read(contents, /* fail_on_error */ false); 284 } 285 286 bool ConfigReader::Read(const std::string& content, bool fail_on_error) { 287 std::stringstream ss(content); 288 std::string line; 289 for (unsigned linecount = 1; 290 std::getline(ss,line,'\n'); 291 linecount += 1) 292 { 293 294 // comment line? 295 if (line[0] == '#') { 296 continue; 297 } 298 299 // blank line? 300 if (isblank(line.c_str())) { 301 continue; 302 } 303 304 // look for X=Y assignment 305 auto efound = line.find('='); 306 if (efound == std::string::npos) { 307 LOG(WARNING) << "line " << linecount << ": line malformed (no '=' found)"; 308 if (fail_on_error) { 309 return false; 310 } 311 continue; 312 } 313 314 std::string key(line.substr(0, efound)); 315 std::string value(line.substr(efound+1, std::string::npos)); 316 317 bool parse_success = parseLine(key.c_str(), value.c_str(), linecount); 318 if (fail_on_error && !parse_success) { 319 return false; 320 } 321 } 322 323 return true; 324 } 325 326 void ConfigReader::FillConfig(Config* config) { 327 config->collection_interval_in_s = getUnsignedValue("collection_interval"); 328 329 config->use_fixed_seed = getUnsignedValue("use_fixed_seed"); 330 331 config->main_loop_iterations = getUnsignedValue("main_loop_iterations"); 332 333 config->destination_directory = getStringValue("destination_directory"); 334 335 config->config_directory = getStringValue("config_directory"); 336 337 config->perf_path = getStringValue("perf_path"); 338 339 config->sampling_period = getUnsignedValue("sampling_period"); 340 config->sampling_frequency = getUnsignedValue("sampling_frequency"); 341 342 config->sample_duration_in_s = getUnsignedValue("sample_duration"); 343 344 config->only_debug_build = getBoolValue("only_debug_build"); 345 346 config->hardwire_cpus = getBoolValue("hardwire_cpus"); 347 config->hardwire_cpus_max_duration_in_s = getUnsignedValue("hardwire_cpus_max_duration"); 348 349 config->max_unprocessed_profiles = getUnsignedValue("max_unprocessed_profiles"); 350 351 config->stack_profile = getBoolValue("stack_profile"); 352 353 config->trace_config_read = getBoolValue("trace_config_read"); 354 355 config->collect_cpu_utilization = getBoolValue("collect_cpu_utilization"); 356 config->collect_charging_state = getBoolValue("collect_charging_state"); 357 config->collect_booting = getBoolValue("collect_booting"); 358 config->collect_camera_active = getBoolValue("collect_camera_active"); 359 360 config->process = static_cast<int32_t>(getUnsignedValue("process")); 361 config->use_elf_symbolizer = getBoolValue("use_elf_symbolizer"); 362 config->compress = getBoolValue("compress"); 363 config->send_to_dropbox = getBoolValue("dropbox"); 364 } 365