blob: 19549666c06b40c4a81ad13d70babaff812f35b9 [file] [log] [blame]
James Hawkinsabd73e62016-01-19 15:10:38 -08001/*
2 * Copyright (C) 2016 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// The bootstat command provides options to persist boot events with the current
18// timestamp, dump the persisted events, and log all events to EventLog to be
19// uploaded to Android log storage via Tron.
20
James Hawkinsa4a1a4a2016-02-09 15:32:38 -080021#include <getopt.h>
Mark Salyzynb304f6d2017-08-04 13:35:51 -070022#include <sys/klog.h>
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -070023#include <unistd.h>
Mark Salyzynff2dcd92016-09-28 15:54:45 -070024
James Hawkinse78ea772017-03-24 11:43:02 -070025#include <chrono>
James Hawkins0660b302016-03-08 16:18:15 -080026#include <cmath>
James Hawkinsabd73e62016-01-19 15:10:38 -080027#include <cstddef>
28#include <cstdio>
James Hawkins500d7152016-02-16 15:05:54 -080029#include <ctime>
James Hawkinsa4a1a4a2016-02-09 15:32:38 -080030#include <map>
James Hawkinsabd73e62016-01-19 15:10:38 -080031#include <memory>
32#include <string>
James Hawkinsbe46fd12017-02-02 16:21:25 -080033#include <vector>
Mark Salyzynff2dcd92016-09-28 15:54:45 -070034
James Hawkinse78ea772017-03-24 11:43:02 -070035#include <android-base/chrono_utils.h>
Mark Salyzynb304f6d2017-08-04 13:35:51 -070036#include <android-base/file.h>
James Hawkinseabe08b2016-01-19 16:54:35 -080037#include <android-base/logging.h>
James Hawkins4dded612016-07-28 11:50:23 -070038#include <android-base/parseint.h>
James Hawkinsbe46fd12017-02-02 16:21:25 -080039#include <android-base/strings.h>
James Hawkinse78ea772017-03-24 11:43:02 -070040#include <android/log.h>
Mark Salyzynb304f6d2017-08-04 13:35:51 -070041#include <cutils/android_reboot.h>
James Hawkinsa4a1a4a2016-02-09 15:32:38 -080042#include <cutils/properties.h>
Mark Salyzynb304f6d2017-08-04 13:35:51 -070043#include <log/logcat.h>
James Hawkins9aec9262017-01-31 11:42:24 -080044#include <metricslogger/metrics_logger.h>
Mark Salyzynff2dcd92016-09-28 15:54:45 -070045
James Hawkinsabd73e62016-01-19 15:10:38 -080046#include "boot_event_record_store.h"
James Hawkinsabd73e62016-01-19 15:10:38 -080047
48namespace {
49
James Hawkinsabd73e62016-01-19 15:10:38 -080050// Scans the boot event record store for record files and logs each boot event
51// via EventLog.
52void LogBootEvents() {
53 BootEventRecordStore boot_event_store;
54
55 auto events = boot_event_store.GetAllBootEvents();
56 for (auto i = events.cbegin(); i != events.cend(); ++i) {
James Hawkins9aec9262017-01-31 11:42:24 -080057 android::metricslogger::LogHistogram(i->first, i->second);
James Hawkinsabd73e62016-01-19 15:10:38 -080058 }
59}
60
James Hawkinsc6275582016-03-22 10:47:44 -070061// Records the named boot |event| to the record store. If |value| is non-empty
62// and is a proper string representation of an integer value, the converted
63// integer value is associated with the boot event.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -070064void RecordBootEventFromCommandLine(const std::string& event, const std::string& value_str) {
James Hawkinsc6275582016-03-22 10:47:44 -070065 BootEventRecordStore boot_event_store;
66 if (!value_str.empty()) {
67 int32_t value = 0;
Elliott Hughesda46b392016-10-11 17:09:00 -070068 if (android::base::ParseInt(value_str, &value)) {
James Hawkins4dded612016-07-28 11:50:23 -070069 boot_event_store.AddBootEventWithValue(event, value);
70 }
James Hawkinsc6275582016-03-22 10:47:44 -070071 } else {
72 boot_event_store.AddBootEvent(event);
73 }
74}
75
James Hawkinsabd73e62016-01-19 15:10:38 -080076void PrintBootEvents() {
77 printf("Boot events:\n");
78 printf("------------\n");
79
80 BootEventRecordStore boot_event_store;
81 auto events = boot_event_store.GetAllBootEvents();
82 for (auto i = events.cbegin(); i != events.cend(); ++i) {
83 printf("%s\t%d\n", i->first.c_str(), i->second);
84 }
85}
86
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -070087void ShowHelp(const char* cmd) {
James Hawkinsabd73e62016-01-19 15:10:38 -080088 fprintf(stderr, "Usage: %s [options]\n", cmd);
89 fprintf(stderr,
90 "options include:\n"
Yongqin Liu78b2b942017-07-07 13:26:49 +080091 " -h, --help Show this help\n"
92 " -l, --log Log all metrics to logstorage\n"
93 " -p, --print Dump the boot event records to the console\n"
94 " -r, --record Record the timestamp of a named boot event\n"
95 " --value Optional value to associate with the boot event\n"
96 " --record_boot_complete Record metrics related to the time for the device boot\n"
97 " --record_boot_reason Record the reason why the device booted\n"
James Hawkins53684ea2016-02-23 16:18:19 -080098 " --record_time_since_factory_reset Record the time since the device was reset\n");
James Hawkinsabd73e62016-01-19 15:10:38 -080099}
100
101// Constructs a readable, printable string from the givencommand line
102// arguments.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700103std::string GetCommandLine(int argc, char** argv) {
James Hawkinsabd73e62016-01-19 15:10:38 -0800104 std::string cmd;
105 for (int i = 0; i < argc; ++i) {
106 cmd += argv[i];
107 cmd += " ";
108 }
109
110 return cmd;
111}
112
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800113// Convenience wrapper over the property API that returns an
114// std::string.
115std::string GetProperty(const char* key) {
116 std::vector<char> temp(PROPERTY_VALUE_MAX);
117 const int len = property_get(key, &temp[0], nullptr);
118 if (len < 0) {
119 return "";
120 }
121 return std::string(&temp[0], len);
122}
123
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700124void SetProperty(const char* key, const std::string& val) {
125 property_set(key, val.c_str());
126}
127
128void SetProperty(const char* key, const char* val) {
129 property_set(key, val);
130}
131
James Hawkins6f74c0b2016-02-12 15:49:16 -0800132constexpr int32_t kUnknownBootReason = 1;
133
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800134// A mapping from boot reason string, as read from the ro.boot.bootreason
135// system property, to a unique integer ID. Viewers of log data dashboards for
136// the boot_reason metric may refer to this mapping to discern the histogram
137// values.
James Hawkins6f74c0b2016-02-12 15:49:16 -0800138const std::map<std::string, int32_t> kBootReasonMap = {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700139 {"unknown", kUnknownBootReason},
140 {"normal", 2},
141 {"recovery", 3},
142 {"reboot", 4},
143 {"PowerKey", 5},
144 {"hard_reset", 6},
145 {"kernel_panic", 7},
146 {"rpm_err", 8},
147 {"hw_reset", 9},
148 {"tz_err", 10},
149 {"adsp_err", 11},
150 {"modem_err", 12},
151 {"mba_err", 13},
152 {"Watchdog", 14},
153 {"Panic", 15},
154 {"power_key", 16},
155 {"power_on", 17},
156 {"Reboot", 18},
157 {"rtc", 19},
158 {"edl", 20},
159 {"oem_pon1", 21},
160 {"oem_powerkey", 22},
161 {"oem_unknown_reset", 23},
162 {"srto: HWWDT reset SC", 24},
163 {"srto: HWWDT reset platform", 25},
164 {"srto: bootloader", 26},
165 {"srto: kernel panic", 27},
166 {"srto: kernel watchdog reset", 28},
167 {"srto: normal", 29},
168 {"srto: reboot", 30},
169 {"srto: reboot-bootloader", 31},
170 {"srto: security watchdog reset", 32},
171 {"srto: wakesrc", 33},
172 {"srto: watchdog", 34},
173 {"srto:1-1", 35},
174 {"srto:omap_hsmm", 36},
175 {"srto:phy0", 37},
176 {"srto:rtc0", 38},
177 {"srto:touchpad", 39},
178 {"watchdog", 40},
179 {"watchdogr", 41},
180 {"wdog_bark", 42},
181 {"wdog_bite", 43},
182 {"wdog_reset", 44},
183 {"shutdown,", 45}, // Trailing comma is intentional.
184 {"shutdown,userrequested", 46},
185 {"reboot,bootloader", 47},
186 {"reboot,cold", 48},
187 {"reboot,recovery", 49},
188 {"thermal_shutdown", 50},
189 {"s3_wakeup", 51},
190 {"kernel_panic,sysrq", 52},
191 {"kernel_panic,NULL", 53},
192 {"kernel_panic,BUG", 54},
193 {"bootloader", 55},
194 {"cold", 56},
195 {"hard", 57},
196 {"warm", 58},
197 {"recovery", 59},
198 {"thermal-shutdown", 60},
199 {"shutdown,thermal", 61},
200 {"shutdown,battery", 62},
201 {"reboot,ota", 63},
202 {"reboot,factory_reset", 64},
203 {"reboot,", 65},
204 {"reboot,shell", 66},
205 {"reboot,adb", 67},
Mark Salyzyn9033bf52017-09-21 11:30:29 -0700206 {"reboot,userrequested", 68},
Mark Salyzyn161b8622017-09-26 08:26:12 -0700207 {"shutdown,container", 69}, // Host OS asking Android Container to shutdown
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800208};
209
210// Converts a string value representing the reason the system booted to an
211// integer representation. This is necessary for logging the boot_reason metric
212// via Tron, which does not accept non-integer buckets in histograms.
213int32_t BootReasonStrToEnum(const std::string& boot_reason) {
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800214 auto mapping = kBootReasonMap.find(boot_reason);
215 if (mapping != kBootReasonMap.end()) {
216 return mapping->second;
217 }
218
219 LOG(INFO) << "Unknown boot reason: " << boot_reason;
220 return kUnknownBootReason;
221}
222
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700223// Canonical list of supported primary reboot reasons.
224const std::vector<const std::string> knownReasons = {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700225 // clang-format off
226 // kernel
227 "watchdog",
228 "kernel_panic",
229 // strong
230 "recovery", // Should not happen from ro.boot.bootreason
231 "bootloader", // Should not happen from ro.boot.bootreason
232 // blunt
233 "cold",
234 "hard",
235 "warm",
Mark Salyzyn62909822017-10-09 09:27:16 -0700236 // super blunt
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700237 "shutdown", // Can not happen from ro.boot.bootreason
238 "reboot", // Default catch-all for anything unknown
239 // clang-format on
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700240};
241
242// Returns true if the supplied reason prefix is considered detailed enough.
243bool isStrongRebootReason(const std::string& r) {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700244 for (auto& s : knownReasons) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700245 if (s == "cold") break;
246 // Prefix defined as terminated by a nul or comma (,).
247 if (android::base::StartsWith(r, s.c_str()) &&
248 ((r.length() == s.length()) || (r[s.length()] == ','))) {
249 return true;
250 }
251 }
252 return false;
253}
254
255// Returns true if the supplied reason prefix is associated with the kernel.
256bool isKernelRebootReason(const std::string& r) {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700257 for (auto& s : knownReasons) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700258 if (s == "recovery") break;
259 // Prefix defined as terminated by a nul or comma (,).
260 if (android::base::StartsWith(r, s.c_str()) &&
261 ((r.length() == s.length()) || (r[s.length()] == ','))) {
262 return true;
263 }
264 }
265 return false;
266}
267
268// Returns true if the supplied reason prefix is considered known.
269bool isKnownRebootReason(const std::string& r) {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700270 for (auto& s : knownReasons) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700271 // Prefix defined as terminated by a nul or comma (,).
272 if (android::base::StartsWith(r, s.c_str()) &&
273 ((r.length() == s.length()) || (r[s.length()] == ','))) {
274 return true;
275 }
276 }
277 return false;
278}
279
280// If the reboot reason should be improved, report true if is too blunt.
281bool isBluntRebootReason(const std::string& r) {
282 if (isStrongRebootReason(r)) return false;
283
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700284 if (!isKnownRebootReason(r)) return true; // Can not support unknown as detail
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700285
286 size_t pos = 0;
287 while ((pos = r.find(',', pos)) != std::string::npos) {
288 ++pos;
289 std::string next(r.substr(pos));
290 if (next.length() == 0) break;
291 if (next[0] == ',') continue;
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700292 if (!isKnownRebootReason(next)) return false; // Unknown subreason is good.
293 if (isStrongRebootReason(next)) return false; // eg: reboot,reboot
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700294 }
295 return true;
296}
297
Mark Salyzyn64610892017-09-18 10:41:14 -0700298bool readPstoreConsole(std::string& console) {
299 if (android::base::ReadFileToString("/sys/fs/pstore/console-ramoops-0", &console)) {
300 return true;
301 }
302 return android::base::ReadFileToString("/sys/fs/pstore/console-ramoops", &console);
303}
304
305bool addKernelPanicSubReason(const std::string& console, std::string& ret) {
306 // Check for kernel panic types to refine information
307 if (console.rfind("SysRq : Trigger a crash") != std::string::npos) {
308 // Can not happen, except on userdebug, during testing/debugging.
309 ret = "kernel_panic,sysrq";
310 return true;
311 }
312 if (console.rfind("Unable to handle kernel NULL pointer dereference at virtual address") !=
313 std::string::npos) {
314 ret = "kernel_panic,NULL";
315 return true;
316 }
317 if (console.rfind("Kernel BUG at ") != std::string::npos) {
318 ret = "kernel_panic,BUG";
319 return true;
320 }
321 return false;
322}
323
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700324// std::transform Helper callback functions:
325// Converts a string value representing the reason the system booted to a
326// string complying with Android system standard reason.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700327char tounderline(char c) {
328 return ::isblank(c) ? '_' : c;
329}
330char toprintable(char c) {
331 return ::isprint(c) ? c : '?';
332}
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700333
334const char system_reboot_reason_property[] = "sys.boot.reason";
335const char last_reboot_reason_property[] = LAST_REBOOT_REASON_PROPERTY;
336const char bootloader_reboot_reason_property[] = "ro.boot.bootreason";
337
338// Scrub, Sanitize, Standardize and Enhance the boot reason string supplied.
339std::string BootReasonStrToReason(const std::string& boot_reason) {
Mark Salyzyna16e4372017-09-20 08:36:12 -0700340 static const size_t max_reason_length = 256;
341
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700342 std::string ret(GetProperty(system_reboot_reason_property));
343 std::string reason(boot_reason);
344 // If sys.boot.reason == ro.boot.bootreason, let's re-evaluate
345 if (reason == ret) ret = "";
346
347 // Cleanup boot_reason regarding acceptable character set
348 std::transform(reason.begin(), reason.end(), reason.begin(), ::tolower);
349 std::transform(reason.begin(), reason.end(), reason.begin(), tounderline);
350 std::transform(reason.begin(), reason.end(), reason.begin(), toprintable);
351
352 // Is the current system boot reason sys.boot.reason valid?
353 if (!isKnownRebootReason(ret)) ret = "";
354
355 if (ret == "") {
356 // Is the bootloader boot reason ro.boot.bootreason known?
357 std::vector<std::string> words(android::base::Split(reason, ",_-"));
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700358 for (auto& s : knownReasons) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700359 std::string blunt;
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700360 for (auto& r : words) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700361 if (r == s) {
362 if (isBluntRebootReason(s)) {
363 blunt = s;
364 } else {
365 ret = s;
366 break;
367 }
368 }
369 }
370 if (ret == "") ret = blunt;
371 if (ret != "") break;
372 }
373 }
374
375 if (ret == "") {
376 // A series of checks to take some officially unsupported reasons
377 // reported by the bootloader and find some logical and canonical
378 // sense. In an ideal world, we would require those bootloaders
379 // to behave and follow our standards.
380 static const std::vector<std::pair<const std::string, const std::string>> aliasReasons = {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700381 {"watchdog", "wdog"},
382 {"cold,powerkey", "powerkey"},
383 {"kernel_panic", "panic"},
384 {"shutdown,thermal", "thermal"},
385 {"warm,s3_wakeup", "s3_wakeup"},
386 {"hard,hw_reset", "hw_reset"},
387 {"bootloader", ""},
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700388 };
389
390 // Either the primary or alias is found _somewhere_ in the reason string.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700391 for (auto& s : aliasReasons) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700392 if (reason.find(s.first) != std::string::npos) {
393 ret = s.first;
394 break;
395 }
396 if (s.second.size() && (reason.find(s.second) != std::string::npos)) {
397 ret = s.first;
398 break;
399 }
400 }
401 }
402
403 // If watchdog is the reason, see if there is a security angle?
404 if (ret == "watchdog") {
405 if (reason.find("sec") != std::string::npos) {
406 ret += ",security";
407 }
408 }
409
Mark Salyzyn64610892017-09-18 10:41:14 -0700410 if (ret == "kernel_panic") {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700411 // Check to see if last klog has some refinement hints.
412 std::string content;
Mark Salyzyn64610892017-09-18 10:41:14 -0700413 if (readPstoreConsole(content)) {
414 addKernelPanicSubReason(content, ret);
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700415 }
Mark Salyzyn64610892017-09-18 10:41:14 -0700416 } else if (isBluntRebootReason(ret)) {
417 // Check the other available reason resources if the reason is still blunt.
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700418
Mark Salyzyn64610892017-09-18 10:41:14 -0700419 // Check to see if last klog has some refinement hints.
420 std::string content;
421 if (readPstoreConsole(content)) {
422 // The toybox reboot command used directly (unlikely)? But also
423 // catches init's response to Android's more controlled reboot command.
424 if (content.rfind("reboot: Power down") != std::string::npos) {
425 ret = "shutdown"; // Still too blunt, but more accurate.
426 // ToDo: init should record the shutdown reason to kernel messages ala:
427 // init: shutdown system with command 'last_reboot_reason'
428 // so that if pstore has persistence we can get some details
429 // that could be missing in last_reboot_reason_property.
430 }
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700431
Mark Salyzyn64610892017-09-18 10:41:14 -0700432 static const char cmd[] = "reboot: Restarting system with command '";
433 size_t pos = content.rfind(cmd);
434 if (pos != std::string::npos) {
435 pos += strlen(cmd);
Mark Salyzyna16e4372017-09-20 08:36:12 -0700436 std::string subReason(content.substr(pos, max_reason_length));
437 for (pos = 0; pos < subReason.length(); ++pos) {
438 char c = tounderline(subReason[pos]);
439 if (!::isprint(c) || (c == '\'')) {
440 subReason.erase(pos);
441 break;
442 }
443 subReason[pos] = ::tolower(c);
444 }
Mark Salyzyn64610892017-09-18 10:41:14 -0700445 if (subReason != "") { // Will not land "reboot" as that is too blunt.
446 if (isKernelRebootReason(subReason)) {
447 ret = "reboot," + subReason; // User space can't talk kernel reasons.
448 } else {
449 ret = subReason;
450 }
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700451 }
452 }
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700453
Mark Salyzyn64610892017-09-18 10:41:14 -0700454 // Check for kernel panics, allowed to override reboot command.
455 if (!addKernelPanicSubReason(content, ret) &&
456 // check for long-press power down
457 ((content.rfind("Power held for ") != std::string::npos) ||
458 (content.rfind("charger: [") != std::string::npos))) {
459 ret = "cold";
460 }
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700461 }
462
463 // The following battery test should migrate to a default system health HAL
464
465 // Let us not worry if the reboot command was issued, for the cases of
466 // reboot -p, reboot <no reason>, reboot cold, reboot warm and reboot hard.
467 // Same for bootloader and ro.boot.bootreasons of this set, but a dead
468 // battery could conceivably lead to these, so worthy of override.
469 if (isBluntRebootReason(ret)) {
470 // Heuristic to determine if shutdown possibly because of a dead battery?
471 // Really a hail-mary pass to find it in last klog content ...
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700472 static const int battery_dead_threshold = 2; // percent
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700473 static const char battery[] = "healthd: battery l=";
Mark Salyzyn64610892017-09-18 10:41:14 -0700474 size_t pos = content.rfind(battery); // last one
Mark Salyzyna16e4372017-09-20 08:36:12 -0700475 std::string digits;
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700476 if (pos != std::string::npos) {
Mark Salyzyna16e4372017-09-20 08:36:12 -0700477 digits = content.substr(pos + strlen(battery));
478 }
479 char* endptr = NULL;
480 unsigned long long level = strtoull(digits.c_str(), &endptr, 10);
481 if ((level <= 100) && (endptr != digits.c_str()) && (*endptr == ' ')) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700482 LOG(INFO) << "Battery level at shutdown " << level << "%";
483 if (level <= battery_dead_threshold) {
484 ret = "shutdown,battery";
485 }
Mark Salyzyna16e4372017-09-20 08:36:12 -0700486 } else { // Most likely
487 digits = ""; // reset digits
488
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700489 // Content buffer no longer will have console data. Beware if more
490 // checks added below, that depend on parsing console content.
491 content = "";
492
493 LOG(DEBUG) << "Can not find last low battery in last console messages";
494 android_logcat_context ctx = create_android_logcat();
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700495 FILE* fp = android_logcat_popen(&ctx, "logcat -b kernel -v brief -d");
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700496 if (fp != nullptr) {
497 android::base::ReadFdToString(fileno(fp), &content);
498 }
499 android_logcat_pclose(&ctx, fp);
500 android_logcat_destroy(&ctx);
501 static const char logcat_battery[] = "W/healthd ( 0): battery l=";
502 const char* match = logcat_battery;
503
504 if (content == "") {
505 // Service logd.klog not running, go to smaller buffer in the kernel.
506 int rc = klogctl(KLOG_SIZE_BUFFER, nullptr, 0);
507 if (rc > 0) {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700508 ssize_t len = rc + 1024; // 1K Margin should it grow between calls.
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700509 std::unique_ptr<char[]> buf(new char[len]);
510 rc = klogctl(KLOG_READ_ALL, buf.get(), len);
511 if (rc < len) {
512 len = rc + 1;
513 }
514 buf[--len] = '\0';
515 content = buf.get();
516 }
517 match = battery;
518 }
519
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700520 pos = content.find(match); // The first one it finds.
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700521 if (pos != std::string::npos) {
Mark Salyzyna16e4372017-09-20 08:36:12 -0700522 digits = content.substr(pos + strlen(match));
523 }
524 endptr = NULL;
525 level = strtoull(digits.c_str(), &endptr, 10);
526 if ((level <= 100) && (endptr != digits.c_str()) && (*endptr == ' ')) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700527 LOG(INFO) << "Battery level at startup " << level << "%";
528 if (level <= battery_dead_threshold) {
529 ret = "shutdown,battery";
530 }
531 } else {
532 LOG(DEBUG) << "Can not find first battery level in dmesg or logcat";
533 }
534 }
535 }
536
537 // Is there a controlled shutdown hint in last_reboot_reason_property?
538 if (isBluntRebootReason(ret)) {
539 // Content buffer no longer will have console data. Beware if more
540 // checks added below, that depend on parsing console content.
541 content = GetProperty(last_reboot_reason_property);
Mark Salyzyna16e4372017-09-20 08:36:12 -0700542 // Cleanup last_boot_reason regarding acceptable character set
543 std::transform(content.begin(), content.end(), content.begin(), ::tolower);
544 std::transform(content.begin(), content.end(), content.begin(), tounderline);
545 std::transform(content.begin(), content.end(), content.begin(), toprintable);
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700546
Mark Salyzyn62909822017-10-09 09:27:16 -0700547 // Anything in last is better than 'super-blunt' reboot or shutdown.
548 if ((ret == "") || (ret == "reboot") || (ret == "shutdown") || !isBluntRebootReason(content)) {
549 ret = content;
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700550 }
551 }
552
553 // Other System Health HAL reasons?
554
555 // ToDo: /proc/sys/kernel/boot_reason needs a HAL interface to
556 // possibly offer hardware-specific clues from the PMIC.
557 }
558
559 // If unknown left over from above, make it "reboot,<boot_reason>"
560 if (ret == "") {
561 ret = "reboot";
562 if (android::base::StartsWith(reason, "reboot")) {
563 reason = reason.substr(strlen("reboot"));
Mark Salyzyn0af71a52017-10-05 13:58:04 -0700564 while ((reason[0] == ',') || (reason[0] == '_')) {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700565 reason = reason.substr(1);
566 }
567 }
568 if (reason != "") {
569 ret += ",";
570 ret += reason;
571 }
572 }
573
574 LOG(INFO) << "Canonical boot reason: " << ret;
575 if (isKernelRebootReason(ret) && (GetProperty(last_reboot_reason_property) != "")) {
576 // Rewrite as it must be old news, kernel reasons trump user space.
577 SetProperty(last_reboot_reason_property, ret);
578 }
579 return ret;
580}
581
James Hawkinsb9cf7712016-04-08 15:32:19 -0700582// Returns the appropriate metric key prefix for the boot_complete metric such
583// that boot metrics after a system update are labeled as ota_boot_complete;
584// otherwise, they are labeled as boot_complete. This method encapsulates the
585// bookkeeping required to track when a system update has occurred by storing
586// the UTC timestamp of the system build date and comparing against the current
587// system build date.
588std::string CalculateBootCompletePrefix() {
589 static const std::string kBuildDateKey = "build_date";
590 std::string boot_complete_prefix = "boot_complete";
591
592 std::string build_date_str = GetProperty("ro.build.date.utc");
James Hawkins4dded612016-07-28 11:50:23 -0700593 int32_t build_date;
Elliott Hughesda46b392016-10-11 17:09:00 -0700594 if (!android::base::ParseInt(build_date_str, &build_date)) {
James Hawkins4dded612016-07-28 11:50:23 -0700595 return std::string();
596 }
James Hawkinsb9cf7712016-04-08 15:32:19 -0700597
598 BootEventRecordStore boot_event_store;
599 BootEventRecordStore::BootEventRecord record;
James Hawkins0bc4ad42017-05-30 15:03:15 -0700600 if (!boot_event_store.GetBootEvent(kBuildDateKey, &record)) {
601 boot_complete_prefix = "factory_reset_" + boot_complete_prefix;
602 boot_event_store.AddBootEventWithValue(kBuildDateKey, build_date);
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700603 LOG(INFO) << "Canonical boot reason: reboot,factory_reset";
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700604 SetProperty(system_reboot_reason_property, "reboot,factory_reset");
James Hawkins0bc4ad42017-05-30 15:03:15 -0700605 } else if (build_date != record.second) {
James Hawkinsb9cf7712016-04-08 15:32:19 -0700606 boot_complete_prefix = "ota_" + boot_complete_prefix;
607 boot_event_store.AddBootEventWithValue(kBuildDateKey, build_date);
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700608 LOG(INFO) << "Canonical boot reason: reboot,ota";
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700609 SetProperty(system_reboot_reason_property, "reboot,ota");
James Hawkinsb9cf7712016-04-08 15:32:19 -0700610 }
611
612 return boot_complete_prefix;
613}
614
James Hawkinsef0a0902017-01-06 14:38:23 -0800615// Records the value of a given ro.boottime.init property in milliseconds.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700616void RecordInitBootTimeProp(BootEventRecordStore* boot_event_store, const char* property) {
James Hawkinsef0a0902017-01-06 14:38:23 -0800617 std::string value = GetProperty(property);
618
James Hawkins27c05222017-01-26 11:55:44 -0800619 int32_t time_in_ms;
620 if (android::base::ParseInt(value, &time_in_ms)) {
James Hawkinsef0a0902017-01-06 14:38:23 -0800621 boot_event_store->AddBootEventWithValue(property, time_in_ms);
622 }
623}
624
James Hawkins1bfcaec2017-05-19 14:27:27 -0700625// A map from bootloader timing stage to the time that stage took during boot.
626typedef std::map<std::string, int32_t> BootloaderTimingMap;
627
628// Returns a mapping from bootloader stage names to the time those stages
629// took to boot.
630const BootloaderTimingMap GetBootLoaderTimings() {
631 BootloaderTimingMap timings;
632
633 // |ro.boot.boottime| is of the form 'stage1:time1,...,stageN:timeN',
634 // where timeN is in milliseconds.
James Hawkinsbe46fd12017-02-02 16:21:25 -0800635 std::string value = GetProperty("ro.boot.boottime");
James Hawkins6b5c5aa2017-02-16 11:53:03 -0800636 if (value.empty()) {
637 // ro.boot.boottime is not reported on all devices.
James Hawkins1bfcaec2017-05-19 14:27:27 -0700638 return BootloaderTimingMap();
James Hawkins6b5c5aa2017-02-16 11:53:03 -0800639 }
James Hawkinsbe46fd12017-02-02 16:21:25 -0800640
641 auto stages = android::base::Split(value, ",");
James Hawkins1bfcaec2017-05-19 14:27:27 -0700642 for (const auto& stageTiming : stages) {
James Hawkinsbe46fd12017-02-02 16:21:25 -0800643 // |stageTiming| is of the form 'stage:time'.
644 auto stageTimingValues = android::base::Split(stageTiming, ":");
James Hawkins0bc4ad42017-05-30 15:03:15 -0700645 DCHECK_EQ(2U, stageTimingValues.size());
James Hawkinsbe46fd12017-02-02 16:21:25 -0800646
647 std::string stageName = stageTimingValues[0];
648 int32_t time_ms;
649 if (android::base::ParseInt(stageTimingValues[1], &time_ms)) {
James Hawkins1bfcaec2017-05-19 14:27:27 -0700650 timings[stageName] = time_ms;
James Hawkinsbe46fd12017-02-02 16:21:25 -0800651 }
652 }
James Hawkins6b5c5aa2017-02-16 11:53:03 -0800653
James Hawkins1bfcaec2017-05-19 14:27:27 -0700654 return timings;
655}
656
657// Parses and records the set of bootloader stages and associated boot times
658// from the ro.boot.boottime system property.
659void RecordBootloaderTimings(BootEventRecordStore* boot_event_store,
660 const BootloaderTimingMap& bootloader_timings) {
661 int32_t total_time = 0;
662 for (const auto& timing : bootloader_timings) {
663 total_time += timing.second;
664 boot_event_store->AddBootEventWithValue("boottime.bootloader." + timing.first, timing.second);
665 }
666
James Hawkins6b5c5aa2017-02-16 11:53:03 -0800667 boot_event_store->AddBootEventWithValue("boottime.bootloader.total", total_time);
James Hawkinsbe46fd12017-02-02 16:21:25 -0800668}
669
James Hawkins1bfcaec2017-05-19 14:27:27 -0700670// Records the closest estimation to the absolute device boot time, i.e.,
671// from power on to boot_complete, including bootloader times.
672void RecordAbsoluteBootTime(BootEventRecordStore* boot_event_store,
673 const BootloaderTimingMap& bootloader_timings,
674 std::chrono::milliseconds uptime) {
675 int32_t bootloader_time_ms = 0;
676
677 for (const auto& timing : bootloader_timings) {
678 if (timing.first.compare("SW") != 0) {
679 bootloader_time_ms += timing.second;
680 }
681 }
682
683 auto bootloader_duration = std::chrono::milliseconds(bootloader_time_ms);
684 auto absolute_total =
685 std::chrono::duration_cast<std::chrono::seconds>(bootloader_duration + uptime);
686 boot_event_store->AddBootEventWithValue("absolute_boot_time", absolute_total.count());
687}
688
James Hawkinsc08e9962016-03-11 14:59:50 -0800689// Records several metrics related to the time it takes to boot the device,
690// including disambiguating boot time on encrypted or non-encrypted devices.
691void RecordBootComplete() {
692 BootEventRecordStore boot_event_store;
James Hawkinsb9cf7712016-04-08 15:32:19 -0700693 BootEventRecordStore::BootEventRecord record;
James Hawkins2d8b3e62016-04-14 14:13:20 -0700694
James Hawkins1bfcaec2017-05-19 14:27:27 -0700695 auto time_since_epoch = android::base::boot_clock::now().time_since_epoch();
696 auto uptime = std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch);
James Hawkins2d8b3e62016-04-14 14:13:20 -0700697 time_t current_time_utc = time(nullptr);
698
699 if (boot_event_store.GetBootEvent("last_boot_time_utc", &record)) {
700 time_t last_boot_time_utc = record.second;
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700701 time_t time_since_last_boot = difftime(current_time_utc, last_boot_time_utc);
702 boot_event_store.AddBootEventWithValue("time_since_last_boot", time_since_last_boot);
James Hawkins2d8b3e62016-04-14 14:13:20 -0700703 }
704
705 boot_event_store.AddBootEventWithValue("last_boot_time_utc", current_time_utc);
James Hawkinsc08e9962016-03-11 14:59:50 -0800706
James Hawkinsb9cf7712016-04-08 15:32:19 -0700707 // The boot_complete metric has two variants: boot_complete and
708 // ota_boot_complete. The latter signifies that the device is booting after
709 // a system update.
710 std::string boot_complete_prefix = CalculateBootCompletePrefix();
James Hawkins4dded612016-07-28 11:50:23 -0700711 if (boot_complete_prefix.empty()) {
712 // The system is hosed because the build date property could not be read.
713 return;
714 }
James Hawkinsc08e9962016-03-11 14:59:50 -0800715
716 // post_decrypt_time_elapsed is only logged on encrypted devices.
717 if (boot_event_store.GetBootEvent("post_decrypt_time_elapsed", &record)) {
718 // Log the amount of time elapsed until the device is decrypted, which
719 // includes the variable amount of time the user takes to enter the
720 // decryption password.
James Hawkinse78ea772017-03-24 11:43:02 -0700721 boot_event_store.AddBootEventWithValue("boot_decryption_complete", uptime.count());
James Hawkinsc08e9962016-03-11 14:59:50 -0800722
723 // Subtract the decryption time to normalize the boot cycle timing.
James Hawkinse78ea772017-03-24 11:43:02 -0700724 std::chrono::seconds boot_complete = std::chrono::seconds(uptime.count() - record.second);
James Hawkinsb9cf7712016-04-08 15:32:19 -0700725 boot_event_store.AddBootEventWithValue(boot_complete_prefix + "_post_decrypt",
James Hawkinse78ea772017-03-24 11:43:02 -0700726 boot_complete.count());
James Hawkinsc08e9962016-03-11 14:59:50 -0800727 } else {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700728 boot_event_store.AddBootEventWithValue(boot_complete_prefix + "_no_encryption", uptime.count());
James Hawkinsc08e9962016-03-11 14:59:50 -0800729 }
730
731 // Record the total time from device startup to boot complete, regardless of
732 // encryption state.
James Hawkinse78ea772017-03-24 11:43:02 -0700733 boot_event_store.AddBootEventWithValue(boot_complete_prefix, uptime.count());
James Hawkinsef0a0902017-01-06 14:38:23 -0800734
735 RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init");
736 RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init.selinux");
737 RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init.cold_boot_wait");
James Hawkinsbe46fd12017-02-02 16:21:25 -0800738
James Hawkins1bfcaec2017-05-19 14:27:27 -0700739 const BootloaderTimingMap bootloader_timings = GetBootLoaderTimings();
740 RecordBootloaderTimings(&boot_event_store, bootloader_timings);
741
742 auto uptime_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_since_epoch);
743 RecordAbsoluteBootTime(&boot_event_store, bootloader_timings, uptime_ms);
James Hawkinsc08e9962016-03-11 14:59:50 -0800744}
745
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800746// Records the boot_reason metric by querying the ro.boot.bootreason system
747// property.
748void RecordBootReason() {
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700749 const std::string reason(GetProperty(bootloader_reboot_reason_property));
James Hawkins5240f202017-09-15 16:01:57 -0700750 android::metricslogger::LogMultiAction(android::metricslogger::ACTION_BOOT,
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700751 android::metricslogger::FIELD_PLATFORM_REASON, reason);
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700752
753 // Log the raw bootloader_boot_reason property value.
754 int32_t boot_reason = BootReasonStrToEnum(reason);
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800755 BootEventRecordStore boot_event_store;
756 boot_event_store.AddBootEventWithValue("boot_reason", boot_reason);
Mark Salyzynb304f6d2017-08-04 13:35:51 -0700757
758 // Log the scrubbed system_boot_reason.
759 const std::string system_reason(BootReasonStrToReason(reason));
760 int32_t system_boot_reason = BootReasonStrToEnum(system_reason);
761 boot_event_store.AddBootEventWithValue("system_boot_reason", system_boot_reason);
762
763 // Record the scrubbed system_boot_reason to the property
764 SetProperty(system_reboot_reason_property, system_reason);
765 if (reason == "") {
766 SetProperty(bootloader_reboot_reason_property, system_reason);
767 }
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800768}
769
James Hawkins500d7152016-02-16 15:05:54 -0800770// Records two metrics related to the user resetting a device: the time at
771// which the device is reset, and the time since the user last reset the
772// device. The former is only set once per-factory reset.
773void RecordFactoryReset() {
774 BootEventRecordStore boot_event_store;
775 BootEventRecordStore::BootEventRecord record;
776
777 time_t current_time_utc = time(nullptr);
778
James Hawkins0660b302016-03-08 16:18:15 -0800779 if (current_time_utc < 0) {
780 // UMA does not display negative values in buckets, so convert to positive.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700781 android::metricslogger::LogHistogram("factory_reset_current_time_failure",
782 std::abs(current_time_utc));
James Hawkinsfff95ba2016-03-29 16:13:49 -0700783
James Hawkins9aec9262017-01-31 11:42:24 -0800784 // Logging via BootEventRecordStore to see if using android::metricslogger::LogHistogram
James Hawkinsfff95ba2016-03-29 16:13:49 -0700785 // is losing records somehow.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700786 boot_event_store.AddBootEventWithValue("factory_reset_current_time_failure",
787 std::abs(current_time_utc));
James Hawkins0660b302016-03-08 16:18:15 -0800788 return;
789 } else {
James Hawkins9aec9262017-01-31 11:42:24 -0800790 android::metricslogger::LogHistogram("factory_reset_current_time", current_time_utc);
James Hawkinsfff95ba2016-03-29 16:13:49 -0700791
James Hawkins9aec9262017-01-31 11:42:24 -0800792 // Logging via BootEventRecordStore to see if using android::metricslogger::LogHistogram
James Hawkinsfff95ba2016-03-29 16:13:49 -0700793 // is losing records somehow.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700794 boot_event_store.AddBootEventWithValue("factory_reset_current_time", current_time_utc);
James Hawkins0660b302016-03-08 16:18:15 -0800795 }
796
James Hawkins500d7152016-02-16 15:05:54 -0800797 // The factory_reset boot event does not exist after the device is reset, so
798 // use this signal to mark the time of the factory reset.
799 if (!boot_event_store.GetBootEvent("factory_reset", &record)) {
800 boot_event_store.AddBootEventWithValue("factory_reset", current_time_utc);
James Hawkins3bf9b142016-03-03 14:50:24 -0800801
802 // Don't log the time_since_factory_reset until some time has elapsed.
803 // The data is not meaningful yet and skews the histogram buckets.
James Hawkins500d7152016-02-16 15:05:54 -0800804 return;
805 }
806
807 // Calculate and record the difference in time between now and the
808 // factory_reset time.
809 time_t factory_reset_utc = record.second;
James Hawkins9aec9262017-01-31 11:42:24 -0800810 android::metricslogger::LogHistogram("factory_reset_record_value", factory_reset_utc);
James Hawkinsfff95ba2016-03-29 16:13:49 -0700811
James Hawkins9aec9262017-01-31 11:42:24 -0800812 // Logging via BootEventRecordStore to see if using android::metricslogger::LogHistogram
James Hawkinsfff95ba2016-03-29 16:13:49 -0700813 // is losing records somehow.
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700814 boot_event_store.AddBootEventWithValue("factory_reset_record_value", factory_reset_utc);
James Hawkinsfff95ba2016-03-29 16:13:49 -0700815
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700816 time_t time_since_factory_reset = difftime(current_time_utc, factory_reset_utc);
817 boot_event_store.AddBootEventWithValue("time_since_factory_reset", time_since_factory_reset);
James Hawkins500d7152016-02-16 15:05:54 -0800818}
819
James Hawkinsabd73e62016-01-19 15:10:38 -0800820} // namespace
821
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700822int main(int argc, char** argv) {
James Hawkinsabd73e62016-01-19 15:10:38 -0800823 android::base::InitLogging(argv);
824
825 const std::string cmd_line = GetCommandLine(argc, argv);
826 LOG(INFO) << "Service started: " << cmd_line;
827
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800828 int option_index = 0;
James Hawkinsc6275582016-03-22 10:47:44 -0700829 static const char value_str[] = "value";
James Hawkinsc08e9962016-03-11 14:59:50 -0800830 static const char boot_complete_str[] = "record_boot_complete";
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800831 static const char boot_reason_str[] = "record_boot_reason";
James Hawkins53684ea2016-02-23 16:18:19 -0800832 static const char factory_reset_str[] = "record_time_since_factory_reset";
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800833 static const struct option long_options[] = {
Mark Salyzyn14b1e6d2017-09-18 10:41:14 -0700834 // clang-format off
835 { "help", no_argument, NULL, 'h' },
836 { "log", no_argument, NULL, 'l' },
837 { "print", no_argument, NULL, 'p' },
838 { "record", required_argument, NULL, 'r' },
839 { value_str, required_argument, NULL, 0 },
840 { boot_complete_str, no_argument, NULL, 0 },
841 { boot_reason_str, no_argument, NULL, 0 },
842 { factory_reset_str, no_argument, NULL, 0 },
843 { NULL, 0, NULL, 0 }
844 // clang-format on
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800845 };
846
James Hawkinsc6275582016-03-22 10:47:44 -0700847 std::string boot_event;
848 std::string value;
James Hawkinsabd73e62016-01-19 15:10:38 -0800849 int opt = 0;
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800850 while ((opt = getopt_long(argc, argv, "hlpr:", long_options, &option_index)) != -1) {
James Hawkinsabd73e62016-01-19 15:10:38 -0800851 switch (opt) {
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800852 // This case handles long options which have no single-character mapping.
853 case 0: {
854 const std::string option_name = long_options[option_index].name;
James Hawkinsc6275582016-03-22 10:47:44 -0700855 if (option_name == value_str) {
856 // |optarg| is an external variable set by getopt representing
857 // the option argument.
858 value = optarg;
859 } else if (option_name == boot_complete_str) {
James Hawkinsc08e9962016-03-11 14:59:50 -0800860 RecordBootComplete();
861 } else if (option_name == boot_reason_str) {
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800862 RecordBootReason();
James Hawkins500d7152016-02-16 15:05:54 -0800863 } else if (option_name == factory_reset_str) {
864 RecordFactoryReset();
James Hawkinsa4a1a4a2016-02-09 15:32:38 -0800865 } else {
866 LOG(ERROR) << "Invalid option: " << option_name;
867 }
868 break;
869 }
870
James Hawkinsabd73e62016-01-19 15:10:38 -0800871 case 'h': {
872 ShowHelp(argv[0]);
873 break;
874 }
875
876 case 'l': {
877 LogBootEvents();
878 break;
879 }
880
881 case 'p': {
882 PrintBootEvents();
883 break;
884 }
885
886 case 'r': {
887 // |optarg| is an external variable set by getopt representing
888 // the option argument.
James Hawkinsc6275582016-03-22 10:47:44 -0700889 boot_event = optarg;
James Hawkinsabd73e62016-01-19 15:10:38 -0800890 break;
891 }
892
893 default: {
894 DCHECK_EQ(opt, '?');
895
896 // |optopt| is an external variable set by getopt representing
897 // the value of the invalid option.
898 LOG(ERROR) << "Invalid option: " << optopt;
899 ShowHelp(argv[0]);
900 return EXIT_FAILURE;
901 }
902 }
903 }
904
James Hawkinsc6275582016-03-22 10:47:44 -0700905 if (!boot_event.empty()) {
906 RecordBootEventFromCommandLine(boot_event, value);
907 }
908
James Hawkinsabd73e62016-01-19 15:10:38 -0800909 return 0;
910}