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 <stdio.h>
19#include <stdlib.h>
20#include <sstream>
21
22#include <android-base/file.h>
23
24#include "configreader.h"
25#include "perfprofdutils.h"
26
27//
28// Config file path
29//
30static const char *config_file_path =
31    "/data/data/com.google.android.gms/files/perfprofd.conf";
32
33ConfigReader::ConfigReader()
34    : trace_config_read(false)
35{
36  addDefaultEntries();
37}
38
39ConfigReader::~ConfigReader()
40{
41}
42
43const char *ConfigReader::getConfigFilePath()
44{
45  return config_file_path;
46}
47
48void ConfigReader::setConfigFilePath(const char *path)
49{
50  config_file_path = strdup(path);
51  W_ALOGI("config file path set to %s", config_file_path);
52}
53
54//
55// Populate the reader with the set of allowable entries
56//
57void ConfigReader::addDefaultEntries()
58{
59  // Average number of seconds between perf profile collections (if
60  // set to 100, then over time we want to see a perf profile
61  // collected every 100 seconds). The actual time within the interval
62  // for the collection is chosen randomly.
63  addUnsignedEntry("collection_interval", 14400, 100, UINT32_MAX);
64
65  // Use the specified fixed seed for random number generation (unit
66  // testing)
67  addUnsignedEntry("use_fixed_seed", 0, 0, UINT32_MAX);
68
69  // For testing purposes, number of times to iterate through main
70  // loop.  Value of zero indicates that we should loop forever.
71  addUnsignedEntry("main_loop_iterations", 0, 0, UINT32_MAX);
72
73  // Destination directory (where to write profiles). This location
74  // chosen since it is accessible to the uploader service.
75  addStringEntry("destination_directory", "/data/misc/perfprofd");
76
77  // Config directory (where to read configs).
78  addStringEntry("config_directory", "/data/data/com.google.android.gms/files");
79
80  // Full path to 'perf' executable.
81  addStringEntry("perf_path", "/system/xbin/simpleperf");
82
83  // Desired sampling period (passed to perf -c option). Small
84  // sampling periods can perturb the collected profiles, so enforce
85  // min/max.
86  addUnsignedEntry("sampling_period", 500000, 5000, UINT32_MAX);
87
88  // Length of time to collect samples (number of seconds for 'perf
89  // record -a' run).
90  addUnsignedEntry("sample_duration", 3, 2, 600);
91
92  // If this parameter is non-zero it will cause perfprofd to
93  // exit immediately if the build type is not userdebug or eng.
94  // Currently defaults to 1 (true).
95  addUnsignedEntry("only_debug_build", 1, 0, 1);
96
97  // If the "mpdecision" service is running at the point we are ready
98  // to kick off a profiling run, then temporarily disable the service
99  // and hard-wire all cores on prior to the collection run, provided
100  // that the duration of the recording is less than or equal to the value of
101  // 'hardwire_cpus_max_duration'.
102  addUnsignedEntry("hardwire_cpus", 1, 0, 1);
103  addUnsignedEntry("hardwire_cpus_max_duration", 5, 1, UINT32_MAX);
104
105  // Maximum number of unprocessed profiles we can accumulate in the
106  // destination directory. Once we reach this limit, we continue
107  // to collect, but we just overwrite the most recent profile.
108  addUnsignedEntry("max_unprocessed_profiles", 10, 1, UINT32_MAX);
109
110  // If set to 1, pass the -g option when invoking 'perf' (requests
111  // stack traces as opposed to flat profile).
112  addUnsignedEntry("stack_profile", 0, 0, 1);
113
114  // For unit testing only: if set to 1, emit info messages on config
115  // file parsing.
116  addUnsignedEntry("trace_config_read", 0, 0, 1);
117
118  // Control collection of various additional profile tags
119  addUnsignedEntry("collect_cpu_utilization", 1, 0, 1);
120  addUnsignedEntry("collect_charging_state", 1, 0, 1);
121  addUnsignedEntry("collect_booting", 1, 0, 1);
122  addUnsignedEntry("collect_camera_active", 0, 0, 1);
123}
124
125void ConfigReader::addUnsignedEntry(const char *key,
126                                    unsigned default_value,
127                                    unsigned min_value,
128                                    unsigned max_value)
129{
130  std::string ks(key);
131  if (u_entries.find(ks) != u_entries.end() ||
132      s_entries.find(ks) != s_entries.end()) {
133    W_ALOGE("internal error -- duplicate entry for key %s", key);
134    exit(9);
135  }
136  values vals;
137  vals.minv = min_value;
138  vals.maxv = max_value;
139  u_info[ks] = vals;
140  u_entries[ks] = default_value;
141}
142
143void ConfigReader::addStringEntry(const char *key, const char *default_value)
144{
145  std::string ks(key);
146  if (u_entries.find(ks) != u_entries.end() ||
147      s_entries.find(ks) != s_entries.end()) {
148    W_ALOGE("internal error -- duplicate entry for key %s", key);
149    exit(9);
150  }
151  if (default_value == nullptr) {
152    W_ALOGE("internal error -- bad default value for key %s", key);
153    exit(9);
154  }
155  s_entries[ks] = std::string(default_value);
156}
157
158unsigned ConfigReader::getUnsignedValue(const char *key) const
159{
160  std::string ks(key);
161  auto it = u_entries.find(ks);
162  assert(it != u_entries.end());
163  return it->second;
164}
165
166std::string ConfigReader::getStringValue(const char *key) const
167{
168  std::string ks(key);
169  auto it = s_entries.find(ks);
170  assert(it != s_entries.end());
171  return it->second;
172}
173
174void ConfigReader::overrideUnsignedEntry(const char *key, unsigned new_value)
175{
176  std::string ks(key);
177  auto it = u_entries.find(ks);
178  assert(it != u_entries.end());
179  values vals;
180  auto iit = u_info.find(key);
181  assert(iit != u_info.end());
182  vals = iit->second;
183  assert(new_value >= vals.minv && new_value <= vals.maxv);
184  it->second = new_value;
185  W_ALOGI("option %s overridden to %u", key, new_value);
186}
187
188
189//
190// Parse a key=value pair read from the config file. This will issue
191// warnings or errors to the system logs if the line can't be
192// interpreted properly.
193//
194void ConfigReader::parseLine(const char *key,
195                             const char *value,
196                             unsigned linecount)
197{
198  assert(key);
199  assert(value);
200
201  auto uit = u_entries.find(key);
202  if (uit != u_entries.end()) {
203    unsigned uvalue = 0;
204    if (isdigit(value[0]) == 0 || sscanf(value, "%u", &uvalue) != 1) {
205      W_ALOGW("line %d: malformed unsigned value (ignored)", linecount);
206    } else {
207      values vals;
208      auto iit = u_info.find(key);
209      assert(iit != u_info.end());
210      vals = iit->second;
211      if (uvalue < vals.minv || uvalue > vals.maxv) {
212        W_ALOGW("line %d: specified value %u for '%s' "
213                "outside permitted range [%u %u] (ignored)",
214                linecount, uvalue, key, vals.minv, vals.maxv);
215      } else {
216        if (trace_config_read) {
217          W_ALOGI("option %s set to %u", key, uvalue);
218        }
219        uit->second = uvalue;
220      }
221    }
222    trace_config_read = (getUnsignedValue("trace_config_read") != 0);
223    return;
224  }
225
226  auto sit = s_entries.find(key);
227  if (sit != s_entries.end()) {
228    if (trace_config_read) {
229      W_ALOGI("option %s set to %s", key, value);
230    }
231    sit->second = std::string(value);
232    return;
233  }
234
235  W_ALOGW("line %d: unknown option '%s' ignored", linecount, key);
236}
237
238static bool isblank(const std::string &line)
239{
240  for (std::string::const_iterator it = line.begin(); it != line.end(); ++it)
241  {
242    if (isspace(*it) == 0) {
243      return false;
244    }
245  }
246  return true;
247}
248
249bool ConfigReader::readFile()
250{
251  std::string contents;
252  if (! android::base::ReadFileToString(config_file_path, &contents)) {
253    return false;
254  }
255
256  std::stringstream ss(contents);
257  std::string line;
258  for (unsigned linecount = 1;
259       std::getline(ss,line,'\n');
260       linecount += 1)
261  {
262
263    // comment line?
264    if (line[0] == '#') {
265      continue;
266    }
267
268    // blank line?
269    if (isblank(line.c_str())) {
270      continue;
271    }
272
273    // look for X=Y assignment
274    auto efound = line.find('=');
275    if (efound == std::string::npos) {
276      W_ALOGW("line %d: line malformed (no '=' found)", linecount);
277      continue;
278    }
279
280    std::string key(line.substr(0, efound));
281    std::string value(line.substr(efound+1, std::string::npos));
282
283    parseLine(key.c_str(), value.c_str(), linecount);
284  }
285
286  return true;
287}
288