atrace.cpp revision e61e3618ee6fde5f2de0469628c3aed86becb7f9
1/* 2 * Copyright (C) 2012 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#define LOG_TAG "atrace" 18 19#include <errno.h> 20#include <fcntl.h> 21#include <getopt.h> 22#include <inttypes.h> 23#include <signal.h> 24#include <stdarg.h> 25#include <stdbool.h> 26#include <stdio.h> 27#include <stdlib.h> 28#include <string.h> 29#include <sys/sendfile.h> 30#include <time.h> 31#include <unistd.h> 32#include <zlib.h> 33 34#include <memory> 35 36#include <binder/IBinder.h> 37#include <binder/IServiceManager.h> 38#include <binder/Parcel.h> 39 40#include <android/hidl/manager/1.0/IServiceManager.h> 41#include <hidl/ServiceManagement.h> 42#include <cutils/properties.h> 43 44#include <utils/String8.h> 45#include <utils/Timers.h> 46#include <utils/Tokenizer.h> 47#include <utils/Trace.h> 48#include <android-base/file.h> 49 50using namespace android; 51 52using std::string; 53#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0]))) 54 55#define MAX_SYS_FILES 10 56#define MAX_PACKAGES 16 57 58const char* k_traceTagsProperty = "debug.atrace.tags.enableflags"; 59 60const char* k_traceAppsNumberProperty = "debug.atrace.app_number"; 61const char* k_traceAppsPropertyTemplate = "debug.atrace.app_%d"; 62const char* k_coreServiceCategory = "core_services"; 63const char* k_coreServicesProp = "ro.atrace.core.services"; 64 65typedef enum { OPT, REQ } requiredness ; 66 67struct TracingCategory { 68 // The name identifying the category. 69 const char* name; 70 71 // A longer description of the category. 72 const char* longname; 73 74 // The userland tracing tags that the category enables. 75 uint64_t tags; 76 77 // The fname==NULL terminated list of /sys/ files that the category 78 // enables. 79 struct { 80 // Whether the file must be writable in order to enable the tracing 81 // category. 82 requiredness required; 83 84 // The path to the enable file. 85 const char* path; 86 } sysfiles[MAX_SYS_FILES]; 87}; 88 89/* Tracing categories */ 90static const TracingCategory k_categories[] = { 91 { "gfx", "Graphics", ATRACE_TAG_GRAPHICS, { } }, 92 { "input", "Input", ATRACE_TAG_INPUT, { } }, 93 { "view", "View System", ATRACE_TAG_VIEW, { } }, 94 { "webview", "WebView", ATRACE_TAG_WEBVIEW, { } }, 95 { "wm", "Window Manager", ATRACE_TAG_WINDOW_MANAGER, { } }, 96 { "am", "Activity Manager", ATRACE_TAG_ACTIVITY_MANAGER, { } }, 97 { "sm", "Sync Manager", ATRACE_TAG_SYNC_MANAGER, { } }, 98 { "audio", "Audio", ATRACE_TAG_AUDIO, { } }, 99 { "video", "Video", ATRACE_TAG_VIDEO, { } }, 100 { "camera", "Camera", ATRACE_TAG_CAMERA, { } }, 101 { "hal", "Hardware Modules", ATRACE_TAG_HAL, { } }, 102 { "app", "Application", ATRACE_TAG_APP, { } }, 103 { "res", "Resource Loading", ATRACE_TAG_RESOURCES, { } }, 104 { "dalvik", "Dalvik VM", ATRACE_TAG_DALVIK, { } }, 105 { "rs", "RenderScript", ATRACE_TAG_RS, { } }, 106 { "bionic", "Bionic C Library", ATRACE_TAG_BIONIC, { } }, 107 { "power", "Power Management", ATRACE_TAG_POWER, { } }, 108 { "pm", "Package Manager", ATRACE_TAG_PACKAGE_MANAGER, { } }, 109 { "ss", "System Server", ATRACE_TAG_SYSTEM_SERVER, { } }, 110 { "database", "Database", ATRACE_TAG_DATABASE, { } }, 111 { "network", "Network", ATRACE_TAG_NETWORK, { } }, 112 { "adb", "ADB", ATRACE_TAG_ADB, { } }, 113 { k_coreServiceCategory, "Core services", 0, { } }, 114 { "sched", "CPU Scheduling", 0, { 115 { REQ, "events/sched/sched_switch/enable" }, 116 { REQ, "events/sched/sched_wakeup/enable" }, 117 { OPT, "events/sched/sched_blocked_reason/enable" }, 118 { OPT, "events/sched/sched_cpu_hotplug/enable" }, 119 } }, 120 { "irq", "IRQ Events", 0, { 121 { REQ, "events/irq/enable" }, 122 { OPT, "events/ipi/enable" }, 123 } }, 124 { "i2c", "I2C Events", 0, { 125 { REQ, "events/i2c/enable" }, 126 { REQ, "events/i2c/i2c_read/enable" }, 127 { REQ, "events/i2c/i2c_write/enable" }, 128 { REQ, "events/i2c/i2c_result/enable" }, 129 { REQ, "events/i2c/i2c_reply/enable" }, 130 { OPT, "events/i2c/smbus_read/enable" }, 131 { OPT, "events/i2c/smbus_write/enable" }, 132 { OPT, "events/i2c/smbus_result/enable" }, 133 { OPT, "events/i2c/smbus_reply/enable" }, 134 } }, 135 { "freq", "CPU Frequency", 0, { 136 { REQ, "events/power/cpu_frequency/enable" }, 137 { OPT, "events/power/clock_set_rate/enable" }, 138 { OPT, "events/power/cpu_frequency_limits/enable" }, 139 } }, 140 { "membus", "Memory Bus Utilization", 0, { 141 { REQ, "events/memory_bus/enable" }, 142 } }, 143 { "idle", "CPU Idle", 0, { 144 { REQ, "events/power/cpu_idle/enable" }, 145 } }, 146 { "disk", "Disk I/O", 0, { 147 { OPT, "events/f2fs/f2fs_sync_file_enter/enable" }, 148 { OPT, "events/f2fs/f2fs_sync_file_exit/enable" }, 149 { OPT, "events/f2fs/f2fs_write_begin/enable" }, 150 { OPT, "events/f2fs/f2fs_write_end/enable" }, 151 { OPT, "events/ext4/ext4_da_write_begin/enable" }, 152 { OPT, "events/ext4/ext4_da_write_end/enable" }, 153 { OPT, "events/ext4/ext4_sync_file_enter/enable" }, 154 { OPT, "events/ext4/ext4_sync_file_exit/enable" }, 155 { REQ, "events/block/block_rq_issue/enable" }, 156 { REQ, "events/block/block_rq_complete/enable" }, 157 } }, 158 { "mmc", "eMMC commands", 0, { 159 { REQ, "events/mmc/enable" }, 160 } }, 161 { "load", "CPU Load", 0, { 162 { REQ, "events/cpufreq_interactive/enable" }, 163 } }, 164 { "sync", "Synchronization", 0, { 165 { REQ, "events/sync/enable" }, 166 } }, 167 { "workq", "Kernel Workqueues", 0, { 168 { REQ, "events/workqueue/enable" }, 169 } }, 170 { "memreclaim", "Kernel Memory Reclaim", 0, { 171 { REQ, "events/vmscan/mm_vmscan_direct_reclaim_begin/enable" }, 172 { REQ, "events/vmscan/mm_vmscan_direct_reclaim_end/enable" }, 173 { REQ, "events/vmscan/mm_vmscan_kswapd_wake/enable" }, 174 { REQ, "events/vmscan/mm_vmscan_kswapd_sleep/enable" }, 175 } }, 176 { "regulators", "Voltage and Current Regulators", 0, { 177 { REQ, "events/regulator/enable" }, 178 } }, 179 { "binder_driver", "Binder Kernel driver", 0, { 180 { REQ, "events/binder/binder_transaction/enable" }, 181 { REQ, "events/binder/binder_transaction_received/enable" }, 182 } }, 183 { "binder_lock", "Binder global lock trace", 0, { 184 { REQ, "events/binder/binder_lock/enable" }, 185 { REQ, "events/binder/binder_locked/enable" }, 186 { REQ, "events/binder/binder_unlock/enable" }, 187 } }, 188 { "pagecache", "Page cache", 0, { 189 { REQ, "events/filemap/enable" }, 190 } }, 191}; 192 193/* Command line options */ 194static int g_traceDurationSeconds = 5; 195static bool g_traceOverwrite = false; 196static int g_traceBufferSizeKB = 2048; 197static bool g_compress = false; 198static bool g_nohup = false; 199static int g_initialSleepSecs = 0; 200static const char* g_categoriesFile = NULL; 201static const char* g_kernelTraceFuncs = NULL; 202static const char* g_debugAppCmdLine = ""; 203static const char* g_outputFile = nullptr; 204 205/* Global state */ 206static bool g_traceAborted = false; 207static bool g_categoryEnables[NELEM(k_categories)] = {}; 208static std::string g_traceFolder; 209 210/* Sys file paths */ 211static const char* k_traceClockPath = 212 "trace_clock"; 213 214static const char* k_traceBufferSizePath = 215 "buffer_size_kb"; 216 217static const char* k_tracingOverwriteEnablePath = 218 "options/overwrite"; 219 220static const char* k_currentTracerPath = 221 "current_tracer"; 222 223static const char* k_printTgidPath = 224 "options/print-tgid"; 225 226static const char* k_funcgraphAbsTimePath = 227 "options/funcgraph-abstime"; 228 229static const char* k_funcgraphCpuPath = 230 "options/funcgraph-cpu"; 231 232static const char* k_funcgraphProcPath = 233 "options/funcgraph-proc"; 234 235static const char* k_funcgraphFlatPath = 236 "options/funcgraph-flat"; 237 238static const char* k_funcgraphDurationPath = 239 "options/funcgraph-duration"; 240 241static const char* k_ftraceFilterPath = 242 "set_ftrace_filter"; 243 244static const char* k_tracingOnPath = 245 "tracing_on"; 246 247static const char* k_tracePath = 248 "trace"; 249 250static const char* k_traceStreamPath = 251 "trace_pipe"; 252 253static const char* k_traceMarkerPath = 254 "trace_marker"; 255 256// Check whether a file exists. 257static bool fileExists(const char* filename) { 258 return access((g_traceFolder + filename).c_str(), F_OK) != -1; 259} 260 261// Check whether a file is writable. 262static bool fileIsWritable(const char* filename) { 263 return access((g_traceFolder + filename).c_str(), W_OK) != -1; 264} 265 266// Truncate a file. 267static bool truncateFile(const char* path) 268{ 269 // This uses creat rather than truncate because some of the debug kernel 270 // device nodes (e.g. k_ftraceFilterPath) currently aren't changed by 271 // calls to truncate, but they are cleared by calls to creat. 272 int traceFD = creat((g_traceFolder + path).c_str(), 0); 273 if (traceFD == -1) { 274 fprintf(stderr, "error truncating %s: %s (%d)\n", (g_traceFolder + path).c_str(), 275 strerror(errno), errno); 276 return false; 277 } 278 279 close(traceFD); 280 281 return true; 282} 283 284static bool _writeStr(const char* filename, const char* str, int flags) 285{ 286 std::string fullFilename = g_traceFolder + filename; 287 int fd = open(fullFilename.c_str(), flags); 288 if (fd == -1) { 289 fprintf(stderr, "error opening %s: %s (%d)\n", fullFilename.c_str(), 290 strerror(errno), errno); 291 return false; 292 } 293 294 bool ok = true; 295 ssize_t len = strlen(str); 296 if (write(fd, str, len) != len) { 297 fprintf(stderr, "error writing to %s: %s (%d)\n", fullFilename.c_str(), 298 strerror(errno), errno); 299 ok = false; 300 } 301 302 close(fd); 303 304 return ok; 305} 306 307// Write a string to a file, returning true if the write was successful. 308static bool writeStr(const char* filename, const char* str) 309{ 310 return _writeStr(filename, str, O_WRONLY); 311} 312 313// Append a string to a file, returning true if the write was successful. 314static bool appendStr(const char* filename, const char* str) 315{ 316 return _writeStr(filename, str, O_APPEND|O_WRONLY); 317} 318 319static void writeClockSyncMarker() 320{ 321 char buffer[128]; 322 int len = 0; 323 int fd = open((g_traceFolder + k_traceMarkerPath).c_str(), O_WRONLY); 324 if (fd == -1) { 325 fprintf(stderr, "error opening %s: %s (%d)\n", k_traceMarkerPath, 326 strerror(errno), errno); 327 return; 328 } 329 float now_in_seconds = systemTime(CLOCK_MONOTONIC) / 1000000000.0f; 330 331 len = snprintf(buffer, 128, "trace_event_clock_sync: parent_ts=%f\n", now_in_seconds); 332 if (write(fd, buffer, len) != len) { 333 fprintf(stderr, "error writing clock sync marker %s (%d)\n", strerror(errno), errno); 334 } 335 336 int64_t realtime_in_ms = systemTime(CLOCK_REALTIME) / 1000000; 337 len = snprintf(buffer, 128, "trace_event_clock_sync: realtime_ts=%" PRId64 "\n", realtime_in_ms); 338 if (write(fd, buffer, len) != len) { 339 fprintf(stderr, "error writing clock sync marker %s (%d)\n", strerror(errno), errno); 340 } 341 342 close(fd); 343} 344 345// Enable or disable a kernel option by writing a "1" or a "0" into a /sys 346// file. 347static bool setKernelOptionEnable(const char* filename, bool enable) 348{ 349 return writeStr(filename, enable ? "1" : "0"); 350} 351 352// Check whether the category is supported on the device with the current 353// rootness. A category is supported only if all its required /sys/ files are 354// writable and if enabling the category will enable one or more tracing tags 355// or /sys/ files. 356static bool isCategorySupported(const TracingCategory& category) 357{ 358 if (strcmp(category.name, k_coreServiceCategory) == 0) { 359 char value[PROPERTY_VALUE_MAX]; 360 property_get(k_coreServicesProp, value, ""); 361 return strlen(value) != 0; 362 } 363 364 bool ok = category.tags != 0; 365 for (int i = 0; i < MAX_SYS_FILES; i++) { 366 const char* path = category.sysfiles[i].path; 367 bool req = category.sysfiles[i].required == REQ; 368 if (path != NULL) { 369 if (req) { 370 if (!fileIsWritable(path)) { 371 return false; 372 } else { 373 ok = true; 374 } 375 } else { 376 ok |= fileIsWritable(path); 377 } 378 } 379 } 380 return ok; 381} 382 383// Check whether the category would be supported on the device if the user 384// were root. This function assumes that root is able to write to any file 385// that exists. It performs the same logic as isCategorySupported, but it 386// uses file existence rather than writability in the /sys/ file checks. 387static bool isCategorySupportedForRoot(const TracingCategory& category) 388{ 389 bool ok = category.tags != 0; 390 for (int i = 0; i < MAX_SYS_FILES; i++) { 391 const char* path = category.sysfiles[i].path; 392 bool req = category.sysfiles[i].required == REQ; 393 if (path != NULL) { 394 if (req) { 395 if (!fileExists(path)) { 396 return false; 397 } else { 398 ok = true; 399 } 400 } else { 401 ok |= fileExists(path); 402 } 403 } 404 } 405 return ok; 406} 407 408// Enable or disable overwriting of the kernel trace buffers. Disabling this 409// will cause tracing to stop once the trace buffers have filled up. 410static bool setTraceOverwriteEnable(bool enable) 411{ 412 return setKernelOptionEnable(k_tracingOverwriteEnablePath, enable); 413} 414 415// Enable or disable kernel tracing. 416static bool setTracingEnabled(bool enable) 417{ 418 return setKernelOptionEnable(k_tracingOnPath, enable); 419} 420 421// Clear the contents of the kernel trace. 422static bool clearTrace() 423{ 424 return truncateFile(k_tracePath); 425} 426 427// Set the size of the kernel's trace buffer in kilobytes. 428static bool setTraceBufferSizeKB(int size) 429{ 430 char str[32] = "1"; 431 int len; 432 if (size < 1) { 433 size = 1; 434 } 435 snprintf(str, 32, "%d", size); 436 return writeStr(k_traceBufferSizePath, str); 437} 438 439// Read the trace_clock sysfs file and return true if it matches the requested 440// value. The trace_clock file format is: 441// local [global] counter uptime perf 442static bool isTraceClock(const char *mode) 443{ 444 int fd = open((g_traceFolder + k_traceClockPath).c_str(), O_RDONLY); 445 if (fd == -1) { 446 fprintf(stderr, "error opening %s: %s (%d)\n", k_traceClockPath, 447 strerror(errno), errno); 448 return false; 449 } 450 451 char buf[4097]; 452 ssize_t n = read(fd, buf, 4096); 453 close(fd); 454 if (n == -1) { 455 fprintf(stderr, "error reading %s: %s (%d)\n", k_traceClockPath, 456 strerror(errno), errno); 457 return false; 458 } 459 buf[n] = '\0'; 460 461 char *start = strchr(buf, '['); 462 if (start == NULL) { 463 return false; 464 } 465 start++; 466 467 char *end = strchr(start, ']'); 468 if (end == NULL) { 469 return false; 470 } 471 *end = '\0'; 472 473 return strcmp(mode, start) == 0; 474} 475 476// Enable or disable the kernel's use of the global clock. Disabling the global 477// clock will result in the kernel using a per-CPU local clock. 478// Any write to the trace_clock sysfs file will reset the buffer, so only 479// update it if the requested value is not the current value. 480static bool setGlobalClockEnable(bool enable) 481{ 482 const char *clock = enable ? "global" : "local"; 483 484 if (isTraceClock(clock)) { 485 return true; 486 } 487 488 return writeStr(k_traceClockPath, clock); 489} 490 491static bool setPrintTgidEnableIfPresent(bool enable) 492{ 493 if (fileExists(k_printTgidPath)) { 494 return setKernelOptionEnable(k_printTgidPath, enable); 495 } 496 return true; 497} 498 499// Poke all the binder-enabled processes in the system to get them to re-read 500// their system properties. 501static bool pokeBinderServices() 502{ 503 sp<IServiceManager> sm = defaultServiceManager(); 504 Vector<String16> services = sm->listServices(); 505 for (size_t i = 0; i < services.size(); i++) { 506 sp<IBinder> obj = sm->checkService(services[i]); 507 if (obj != NULL) { 508 Parcel data; 509 if (obj->transact(IBinder::SYSPROPS_TRANSACTION, data, 510 NULL, 0) != OK) { 511 if (false) { 512 // XXX: For some reason this fails on tablets trying to 513 // poke the "phone" service. It's not clear whether some 514 // are expected to fail. 515 String8 svc(services[i]); 516 fprintf(stderr, "error poking binder service %s\n", 517 svc.string()); 518 return false; 519 } 520 } 521 } 522 } 523 return true; 524} 525 526// Poke all the HAL processes in the system to get them to re-read 527// their system properties. 528static void pokeHalServices() 529{ 530 using ::android::hidl::base::V1_0::IBase; 531 using ::android::hidl::manager::V1_0::IServiceManager; 532 using ::android::hardware::hidl_string; 533 using ::android::hardware::Return; 534 535 sp<IServiceManager> sm = ::android::hardware::defaultServiceManager(); 536 537 if (sm == nullptr) { 538 fprintf(stderr, "failed to get IServiceManager to poke hal services\n"); 539 return; 540 } 541 542 auto listRet = sm->list([&](const auto &interfaces) { 543 for (size_t i = 0; i < interfaces.size(); i++) { 544 string fqInstanceName = interfaces[i]; 545 string::size_type n = fqInstanceName.find("/"); 546 if (n == std::string::npos || interfaces[i].size() == n+1) 547 continue; 548 hidl_string fqInterfaceName = fqInstanceName.substr(0, n); 549 hidl_string instanceName = fqInstanceName.substr(n+1, std::string::npos); 550 Return<sp<IBase>> interfaceRet = sm->get(fqInterfaceName, instanceName); 551 if (!interfaceRet.isOk()) { 552 // ignore 553 continue; 554 } 555 556 sp<IBase> interface = interfaceRet; 557 if (interface == nullptr) { 558 // ignore 559 continue; 560 } 561 562 auto notifyRet = interface->notifySyspropsChanged(); 563 if (!notifyRet.isOk()) { 564 // ignore 565 } 566 } 567 }); 568 if (!listRet.isOk()) { 569 // TODO(b/34242478) fix this when we determine the correct ACL 570 //fprintf(stderr, "failed to list services: %s\n", listRet.description().c_str()); 571 } 572} 573 574// Set the trace tags that userland tracing uses, and poke the running 575// processes to pick up the new value. 576static bool setTagsProperty(uint64_t tags) 577{ 578 char buf[PROPERTY_VALUE_MAX]; 579 snprintf(buf, sizeof(buf), "%#" PRIx64, tags); 580 if (property_set(k_traceTagsProperty, buf) < 0) { 581 fprintf(stderr, "error setting trace tags system property\n"); 582 return false; 583 } 584 return true; 585} 586 587static void clearAppProperties() 588{ 589 char buf[PROPERTY_KEY_MAX]; 590 for (int i = 0; i < MAX_PACKAGES; i++) { 591 snprintf(buf, sizeof(buf), k_traceAppsPropertyTemplate, i); 592 if (property_set(buf, "") < 0) { 593 fprintf(stderr, "failed to clear system property: %s\n", buf); 594 } 595 } 596 if (property_set(k_traceAppsNumberProperty, "") < 0) { 597 fprintf(stderr, "failed to clear system property: %s", 598 k_traceAppsNumberProperty); 599 } 600} 601 602// Set the system property that indicates which apps should perform 603// application-level tracing. 604static bool setAppCmdlineProperty(char* cmdline) 605{ 606 char buf[PROPERTY_KEY_MAX]; 607 int i = 0; 608 char* start = cmdline; 609 while (start != NULL) { 610 if (i == MAX_PACKAGES) { 611 fprintf(stderr, "error: only 16 packages could be traced at once\n"); 612 clearAppProperties(); 613 return false; 614 } 615 char* end = strchr(start, ','); 616 if (end != NULL) { 617 *end = '\0'; 618 end++; 619 } 620 snprintf(buf, sizeof(buf), k_traceAppsPropertyTemplate, i); 621 if (property_set(buf, start) < 0) { 622 fprintf(stderr, "error setting trace app %d property to %s\n", i, buf); 623 clearAppProperties(); 624 return false; 625 } 626 start = end; 627 i++; 628 } 629 630 snprintf(buf, sizeof(buf), "%d", i); 631 if (property_set(k_traceAppsNumberProperty, buf) < 0) { 632 fprintf(stderr, "error setting trace app number property to %s\n", buf); 633 clearAppProperties(); 634 return false; 635 } 636 return true; 637} 638 639// Disable all /sys/ enable files. 640static bool disableKernelTraceEvents() { 641 bool ok = true; 642 for (int i = 0; i < NELEM(k_categories); i++) { 643 const TracingCategory &c = k_categories[i]; 644 for (int j = 0; j < MAX_SYS_FILES; j++) { 645 const char* path = c.sysfiles[j].path; 646 if (path != NULL && fileIsWritable(path)) { 647 ok &= setKernelOptionEnable(path, false); 648 } 649 } 650 } 651 return ok; 652} 653 654// Verify that the comma separated list of functions are being traced by the 655// kernel. 656static bool verifyKernelTraceFuncs(const char* funcs) 657{ 658 std::string buf; 659 if (!android::base::ReadFileToString(g_traceFolder + k_ftraceFilterPath, &buf)) { 660 fprintf(stderr, "error opening %s: %s (%d)\n", k_ftraceFilterPath, 661 strerror(errno), errno); 662 return false; 663 } 664 665 String8 funcList = String8::format("\n%s",buf.c_str()); 666 667 // Make sure that every function listed in funcs is in the list we just 668 // read from the kernel, except for wildcard inputs. 669 bool ok = true; 670 char* myFuncs = strdup(funcs); 671 char* func = strtok(myFuncs, ","); 672 while (func) { 673 if (!strchr(func, '*')) { 674 String8 fancyFunc = String8::format("\n%s\n", func); 675 bool found = funcList.find(fancyFunc.string(), 0) >= 0; 676 if (!found || func[0] == '\0') { 677 fprintf(stderr, "error: \"%s\" is not a valid kernel function " 678 "to trace.\n", func); 679 ok = false; 680 } 681 } 682 func = strtok(NULL, ","); 683 } 684 free(myFuncs); 685 return ok; 686} 687 688// Set the comma separated list of functions that the kernel is to trace. 689static bool setKernelTraceFuncs(const char* funcs) 690{ 691 bool ok = true; 692 693 if (funcs == NULL || funcs[0] == '\0') { 694 // Disable kernel function tracing. 695 if (fileIsWritable(k_currentTracerPath)) { 696 ok &= writeStr(k_currentTracerPath, "nop"); 697 } 698 if (fileIsWritable(k_ftraceFilterPath)) { 699 ok &= truncateFile(k_ftraceFilterPath); 700 } 701 } else { 702 // Enable kernel function tracing. 703 ok &= writeStr(k_currentTracerPath, "function_graph"); 704 ok &= setKernelOptionEnable(k_funcgraphAbsTimePath, true); 705 ok &= setKernelOptionEnable(k_funcgraphCpuPath, true); 706 ok &= setKernelOptionEnable(k_funcgraphProcPath, true); 707 ok &= setKernelOptionEnable(k_funcgraphFlatPath, true); 708 709 // Set the requested filter functions. 710 ok &= truncateFile(k_ftraceFilterPath); 711 char* myFuncs = strdup(funcs); 712 char* func = strtok(myFuncs, ","); 713 while (func) { 714 ok &= appendStr(k_ftraceFilterPath, func); 715 func = strtok(NULL, ","); 716 } 717 free(myFuncs); 718 719 // Verify that the set functions are being traced. 720 if (ok) { 721 ok &= verifyKernelTraceFuncs(funcs); 722 } 723 } 724 725 return ok; 726} 727 728static bool setCategoryEnable(const char* name, bool enable) 729{ 730 for (int i = 0; i < NELEM(k_categories); i++) { 731 const TracingCategory& c = k_categories[i]; 732 if (strcmp(name, c.name) == 0) { 733 if (isCategorySupported(c)) { 734 g_categoryEnables[i] = enable; 735 return true; 736 } else { 737 if (isCategorySupportedForRoot(c)) { 738 fprintf(stderr, "error: category \"%s\" requires root " 739 "privileges.\n", name); 740 } else { 741 fprintf(stderr, "error: category \"%s\" is not supported " 742 "on this device.\n", name); 743 } 744 return false; 745 } 746 } 747 } 748 fprintf(stderr, "error: unknown tracing category \"%s\"\n", name); 749 return false; 750} 751 752static bool setCategoriesEnableFromFile(const char* categories_file) 753{ 754 if (!categories_file) { 755 return true; 756 } 757 Tokenizer* tokenizer = NULL; 758 if (Tokenizer::open(String8(categories_file), &tokenizer) != NO_ERROR) { 759 return false; 760 } 761 bool ok = true; 762 while (!tokenizer->isEol()) { 763 String8 token = tokenizer->nextToken(" "); 764 if (token.isEmpty()) { 765 tokenizer->skipDelimiters(" "); 766 continue; 767 } 768 ok &= setCategoryEnable(token.string(), true); 769 } 770 delete tokenizer; 771 return ok; 772} 773 774// Set all the kernel tracing settings to the desired state for this trace 775// capture. 776static bool setUpTrace() 777{ 778 bool ok = true; 779 780 // Set up the tracing options. 781 ok &= setCategoriesEnableFromFile(g_categoriesFile); 782 ok &= setTraceOverwriteEnable(g_traceOverwrite); 783 ok &= setTraceBufferSizeKB(g_traceBufferSizeKB); 784 ok &= setGlobalClockEnable(true); 785 ok &= setPrintTgidEnableIfPresent(true); 786 ok &= setKernelTraceFuncs(g_kernelTraceFuncs); 787 788 // Set up the tags property. 789 uint64_t tags = 0; 790 for (int i = 0; i < NELEM(k_categories); i++) { 791 if (g_categoryEnables[i]) { 792 const TracingCategory &c = k_categories[i]; 793 tags |= c.tags; 794 } 795 } 796 ok &= setTagsProperty(tags); 797 798 bool coreServicesTagEnabled = false; 799 for (int i = 0; i < NELEM(k_categories); i++) { 800 if (strcmp(k_categories[i].name, k_coreServiceCategory) == 0) { 801 coreServicesTagEnabled = g_categoryEnables[i]; 802 } 803 } 804 805 std::string packageList(g_debugAppCmdLine); 806 if (coreServicesTagEnabled) { 807 char value[PROPERTY_VALUE_MAX]; 808 property_get(k_coreServicesProp, value, ""); 809 if (!packageList.empty()) { 810 packageList += ","; 811 } 812 packageList += value; 813 } 814 ok &= setAppCmdlineProperty(&packageList[0]); 815 ok &= pokeBinderServices(); 816 pokeHalServices(); 817 818 // Disable all the sysfs enables. This is done as a separate loop from 819 // the enables to allow the same enable to exist in multiple categories. 820 ok &= disableKernelTraceEvents(); 821 822 // Enable all the sysfs enables that are in an enabled category. 823 for (int i = 0; i < NELEM(k_categories); i++) { 824 if (g_categoryEnables[i]) { 825 const TracingCategory &c = k_categories[i]; 826 for (int j = 0; j < MAX_SYS_FILES; j++) { 827 const char* path = c.sysfiles[j].path; 828 bool required = c.sysfiles[j].required == REQ; 829 if (path != NULL) { 830 if (fileIsWritable(path)) { 831 ok &= setKernelOptionEnable(path, true); 832 } else if (required) { 833 fprintf(stderr, "error writing file %s\n", path); 834 ok = false; 835 } 836 } 837 } 838 } 839 } 840 841 return ok; 842} 843 844// Reset all the kernel tracing settings to their default state. 845static void cleanUpTrace() 846{ 847 // Disable all tracing that we're able to. 848 disableKernelTraceEvents(); 849 850 // Reset the system properties. 851 setTagsProperty(0); 852 clearAppProperties(); 853 pokeBinderServices(); 854 855 // Set the options back to their defaults. 856 setTraceOverwriteEnable(true); 857 setTraceBufferSizeKB(1); 858 setGlobalClockEnable(false); 859 setPrintTgidEnableIfPresent(false); 860 setKernelTraceFuncs(NULL); 861} 862 863 864// Enable tracing in the kernel. 865static bool startTrace() 866{ 867 return setTracingEnabled(true); 868} 869 870// Disable tracing in the kernel. 871static void stopTrace() 872{ 873 setTracingEnabled(false); 874} 875 876// Read data from the tracing pipe and forward to stdout 877static void streamTrace() 878{ 879 char trace_data[4096]; 880 int traceFD = open((g_traceFolder + k_traceStreamPath).c_str(), O_RDWR); 881 if (traceFD == -1) { 882 fprintf(stderr, "error opening %s: %s (%d)\n", k_traceStreamPath, 883 strerror(errno), errno); 884 return; 885 } 886 while (!g_traceAborted) { 887 ssize_t bytes_read = read(traceFD, trace_data, 4096); 888 if (bytes_read > 0) { 889 write(STDOUT_FILENO, trace_data, bytes_read); 890 fflush(stdout); 891 } else { 892 if (!g_traceAborted) { 893 fprintf(stderr, "read returned %zd bytes err %d (%s)\n", 894 bytes_read, errno, strerror(errno)); 895 } 896 break; 897 } 898 } 899} 900 901// Read the current kernel trace and write it to stdout. 902static void dumpTrace(int outFd) 903{ 904 ALOGI("Dumping trace"); 905 int traceFD = open((g_traceFolder + k_tracePath).c_str(), O_RDWR); 906 if (traceFD == -1) { 907 fprintf(stderr, "error opening %s: %s (%d)\n", k_tracePath, 908 strerror(errno), errno); 909 return; 910 } 911 912 if (g_compress) { 913 z_stream zs; 914 memset(&zs, 0, sizeof(zs)); 915 916 int result = deflateInit(&zs, Z_DEFAULT_COMPRESSION); 917 if (result != Z_OK) { 918 fprintf(stderr, "error initializing zlib: %d\n", result); 919 close(traceFD); 920 return; 921 } 922 923 constexpr size_t bufSize = 64*1024; 924 std::unique_ptr<uint8_t> in(new uint8_t[bufSize]); 925 std::unique_ptr<uint8_t> out(new uint8_t[bufSize]); 926 if (!in || !out) { 927 fprintf(stderr, "couldn't allocate buffers\n"); 928 close(traceFD); 929 return; 930 } 931 932 int flush = Z_NO_FLUSH; 933 934 zs.next_out = reinterpret_cast<Bytef*>(out.get()); 935 zs.avail_out = bufSize; 936 937 do { 938 939 if (zs.avail_in == 0) { 940 // More input is needed. 941 result = read(traceFD, in.get(), bufSize); 942 if (result < 0) { 943 fprintf(stderr, "error reading trace: %s (%d)\n", 944 strerror(errno), errno); 945 result = Z_STREAM_END; 946 break; 947 } else if (result == 0) { 948 flush = Z_FINISH; 949 } else { 950 zs.next_in = reinterpret_cast<Bytef*>(in.get()); 951 zs.avail_in = result; 952 } 953 } 954 955 if (zs.avail_out == 0) { 956 // Need to write the output. 957 result = write(outFd, out.get(), bufSize); 958 if ((size_t)result < bufSize) { 959 fprintf(stderr, "error writing deflated trace: %s (%d)\n", 960 strerror(errno), errno); 961 result = Z_STREAM_END; // skip deflate error message 962 zs.avail_out = bufSize; // skip the final write 963 break; 964 } 965 zs.next_out = reinterpret_cast<Bytef*>(out.get()); 966 zs.avail_out = bufSize; 967 } 968 969 } while ((result = deflate(&zs, flush)) == Z_OK); 970 971 if (result != Z_STREAM_END) { 972 fprintf(stderr, "error deflating trace: %s\n", zs.msg); 973 } 974 975 if (zs.avail_out < bufSize) { 976 size_t bytes = bufSize - zs.avail_out; 977 result = write(outFd, out.get(), bytes); 978 if ((size_t)result < bytes) { 979 fprintf(stderr, "error writing deflated trace: %s (%d)\n", 980 strerror(errno), errno); 981 } 982 } 983 984 result = deflateEnd(&zs); 985 if (result != Z_OK) { 986 fprintf(stderr, "error cleaning up zlib: %d\n", result); 987 } 988 } else { 989 ssize_t sent = 0; 990 while ((sent = sendfile(outFd, traceFD, NULL, 64*1024*1024)) > 0); 991 if (sent == -1) { 992 fprintf(stderr, "error dumping trace: %s (%d)\n", strerror(errno), 993 errno); 994 } 995 } 996 997 close(traceFD); 998} 999 1000static void handleSignal(int /*signo*/) 1001{ 1002 if (!g_nohup) { 1003 g_traceAborted = true; 1004 } 1005} 1006 1007static void registerSigHandler() 1008{ 1009 struct sigaction sa; 1010 sigemptyset(&sa.sa_mask); 1011 sa.sa_flags = 0; 1012 sa.sa_handler = handleSignal; 1013 sigaction(SIGHUP, &sa, NULL); 1014 sigaction(SIGINT, &sa, NULL); 1015 sigaction(SIGQUIT, &sa, NULL); 1016 sigaction(SIGTERM, &sa, NULL); 1017} 1018 1019static void listSupportedCategories() 1020{ 1021 for (int i = 0; i < NELEM(k_categories); i++) { 1022 const TracingCategory& c = k_categories[i]; 1023 if (isCategorySupported(c)) { 1024 printf(" %10s - %s\n", c.name, c.longname); 1025 } 1026 } 1027} 1028 1029// Print the command usage help to stderr. 1030static void showHelp(const char *cmd) 1031{ 1032 fprintf(stderr, "usage: %s [options] [categories...]\n", cmd); 1033 fprintf(stderr, "options include:\n" 1034 " -a appname enable app-level tracing for a comma " 1035 "separated list of cmdlines\n" 1036 " -b N use a trace buffer size of N KB\n" 1037 " -c trace into a circular buffer\n" 1038 " -f filename use the categories written in a file as space-separated\n" 1039 " values in a line\n" 1040 " -k fname,... trace the listed kernel functions\n" 1041 " -n ignore signals\n" 1042 " -s N sleep for N seconds before tracing [default 0]\n" 1043 " -t N trace for N seconds [default 5]\n" 1044 " -z compress the trace dump\n" 1045 " --async_start start circular trace and return immediately\n" 1046 " --async_dump dump the current contents of circular trace buffer\n" 1047 " --async_stop stop tracing and dump the current contents of circular\n" 1048 " trace buffer\n" 1049 " --stream stream trace to stdout as it enters the trace buffer\n" 1050 " Note: this can take significant CPU time, and is best\n" 1051 " used for measuring things that are not affected by\n" 1052 " CPU performance, like pagecache usage.\n" 1053 " --list_categories\n" 1054 " list the available tracing categories\n" 1055 " -o filename write the trace to the specified file instead\n" 1056 " of stdout.\n" 1057 ); 1058} 1059 1060bool findTraceFiles() 1061{ 1062 static const std::string debugfs_path = "/sys/kernel/debug/tracing/"; 1063 static const std::string tracefs_path = "/sys/kernel/tracing/"; 1064 static const std::string trace_file = "trace_marker"; 1065 1066 bool tracefs = access((tracefs_path + trace_file).c_str(), F_OK) != -1; 1067 bool debugfs = access((debugfs_path + trace_file).c_str(), F_OK) != -1; 1068 1069 if (!tracefs && !debugfs) { 1070 fprintf(stderr, "Error: Did not find trace folder\n"); 1071 return false; 1072 } 1073 1074 if (tracefs) { 1075 g_traceFolder = tracefs_path; 1076 } else { 1077 g_traceFolder = debugfs_path; 1078 } 1079 1080 return true; 1081} 1082 1083int main(int argc, char **argv) 1084{ 1085 bool async = false; 1086 bool traceStart = true; 1087 bool traceStop = true; 1088 bool traceDump = true; 1089 bool traceStream = false; 1090 1091 if (argc == 2 && 0 == strcmp(argv[1], "--help")) { 1092 showHelp(argv[0]); 1093 exit(0); 1094 } 1095 1096 if (!findTraceFiles()) { 1097 fprintf(stderr, "No trace folder found\n"); 1098 exit(-1); 1099 } 1100 1101 for (;;) { 1102 int ret; 1103 int option_index = 0; 1104 static struct option long_options[] = { 1105 {"async_start", no_argument, 0, 0 }, 1106 {"async_stop", no_argument, 0, 0 }, 1107 {"async_dump", no_argument, 0, 0 }, 1108 {"list_categories", no_argument, 0, 0 }, 1109 {"stream", no_argument, 0, 0 }, 1110 { 0, 0, 0, 0 } 1111 }; 1112 1113 ret = getopt_long(argc, argv, "a:b:cf:k:ns:t:zo:", 1114 long_options, &option_index); 1115 1116 if (ret < 0) { 1117 for (int i = optind; i < argc; i++) { 1118 if (!setCategoryEnable(argv[i], true)) { 1119 fprintf(stderr, "error enabling tracing category \"%s\"\n", argv[i]); 1120 exit(1); 1121 } 1122 } 1123 break; 1124 } 1125 1126 switch(ret) { 1127 case 'a': 1128 g_debugAppCmdLine = optarg; 1129 break; 1130 1131 case 'b': 1132 g_traceBufferSizeKB = atoi(optarg); 1133 break; 1134 1135 case 'c': 1136 g_traceOverwrite = true; 1137 break; 1138 1139 case 'f': 1140 g_categoriesFile = optarg; 1141 break; 1142 1143 case 'k': 1144 g_kernelTraceFuncs = optarg; 1145 break; 1146 1147 case 'n': 1148 g_nohup = true; 1149 break; 1150 1151 case 's': 1152 g_initialSleepSecs = atoi(optarg); 1153 break; 1154 1155 case 't': 1156 g_traceDurationSeconds = atoi(optarg); 1157 break; 1158 1159 case 'z': 1160 g_compress = true; 1161 break; 1162 1163 case 'o': 1164 g_outputFile = optarg; 1165 break; 1166 1167 case 0: 1168 if (!strcmp(long_options[option_index].name, "async_start")) { 1169 async = true; 1170 traceStop = false; 1171 traceDump = false; 1172 g_traceOverwrite = true; 1173 } else if (!strcmp(long_options[option_index].name, "async_stop")) { 1174 async = true; 1175 traceStart = false; 1176 } else if (!strcmp(long_options[option_index].name, "async_dump")) { 1177 async = true; 1178 traceStart = false; 1179 traceStop = false; 1180 } else if (!strcmp(long_options[option_index].name, "stream")) { 1181 traceStream = true; 1182 traceDump = false; 1183 } else if (!strcmp(long_options[option_index].name, "list_categories")) { 1184 listSupportedCategories(); 1185 exit(0); 1186 } 1187 break; 1188 1189 default: 1190 fprintf(stderr, "\n"); 1191 showHelp(argv[0]); 1192 exit(-1); 1193 break; 1194 } 1195 } 1196 1197 registerSigHandler(); 1198 1199 if (g_initialSleepSecs > 0) { 1200 sleep(g_initialSleepSecs); 1201 } 1202 1203 bool ok = true; 1204 ok &= setUpTrace(); 1205 ok &= startTrace(); 1206 1207 if (ok && traceStart) { 1208 if (!traceStream) { 1209 printf("capturing trace..."); 1210 fflush(stdout); 1211 } 1212 1213 // We clear the trace after starting it because tracing gets enabled for 1214 // each CPU individually in the kernel. Having the beginning of the trace 1215 // contain entries from only one CPU can cause "begin" entries without a 1216 // matching "end" entry to show up if a task gets migrated from one CPU to 1217 // another. 1218 ok = clearTrace(); 1219 1220 writeClockSyncMarker(); 1221 if (ok && !async && !traceStream) { 1222 // Sleep to allow the trace to be captured. 1223 struct timespec timeLeft; 1224 timeLeft.tv_sec = g_traceDurationSeconds; 1225 timeLeft.tv_nsec = 0; 1226 do { 1227 if (g_traceAborted) { 1228 break; 1229 } 1230 } while (nanosleep(&timeLeft, &timeLeft) == -1 && errno == EINTR); 1231 } 1232 1233 if (traceStream) { 1234 streamTrace(); 1235 } 1236 } 1237 1238 // Stop the trace and restore the default settings. 1239 if (traceStop) 1240 stopTrace(); 1241 1242 if (ok && traceDump) { 1243 if (!g_traceAborted) { 1244 printf(" done\n"); 1245 fflush(stdout); 1246 int outFd = STDOUT_FILENO; 1247 if (g_outputFile) { 1248 outFd = open(g_outputFile, O_WRONLY | O_CREAT | O_TRUNC, 0644); 1249 } 1250 if (outFd == -1) { 1251 printf("Failed to open '%s', err=%d", g_outputFile, errno); 1252 } else { 1253 dprintf(outFd, "TRACE:\n"); 1254 dumpTrace(outFd); 1255 if (g_outputFile) { 1256 close(outFd); 1257 } 1258 } 1259 } else { 1260 printf("\ntrace aborted.\n"); 1261 fflush(stdout); 1262 } 1263 clearTrace(); 1264 } else if (!ok) { 1265 fprintf(stderr, "unable to start tracing\n"); 1266 } 1267 1268 // Reset the trace buffer size to 1. 1269 if (traceStop) 1270 cleanUpTrace(); 1271 1272 return g_traceAborted ? 1 : 0; 1273} 1274