1 /* 2 * Copyright (C) 2009 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 #include <algorithm> 18 #include <chrono> 19 #include <iomanip> 20 #include <thread> 21 22 #include <android-base/file.h> 23 #include <android-base/stringprintf.h> 24 #include <android-base/unique_fd.h> 25 #include <binder/Parcel.h> 26 #include <binder/ProcessState.h> 27 #include <binder/TextOutput.h> 28 #include <serviceutils/PriorityDumper.h> 29 #include <utils/Log.h> 30 #include <utils/Vector.h> 31 32 #include <fcntl.h> 33 #include <getopt.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <sys/poll.h> 38 #include <sys/socket.h> 39 #include <sys/time.h> 40 #include <sys/types.h> 41 #include <unistd.h> 42 43 #include "dumpsys.h" 44 45 using namespace android; 46 using ::android::base::StringAppendF; 47 using ::android::base::StringPrintf; 48 using ::android::base::unique_fd; 49 using ::android::base::WriteFully; 50 using ::android::base::WriteStringToFd; 51 52 static int sort_func(const String16* lhs, const String16* rhs) 53 { 54 return lhs->compare(*rhs); 55 } 56 57 static void usage() { 58 fprintf(stderr, 59 "usage: dumpsys\n" 60 " To dump all services.\n" 61 "or:\n" 62 " dumpsys [-t TIMEOUT] [--priority LEVEL] [--help | -l | --skip SERVICES | " 63 "SERVICE [ARGS]]\n" 64 " --help: shows this help\n" 65 " -l: only list services, do not dump them\n" 66 " -t TIMEOUT_SEC: TIMEOUT to use in seconds instead of default 10 seconds\n" 67 " -T TIMEOUT_MS: TIMEOUT to use in milliseconds instead of default 10 seconds\n" 68 " --proto: filter services that support dumping data in proto format. Dumps\n" 69 " will be in proto format.\n" 70 " --priority LEVEL: filter services based on specified priority\n" 71 " LEVEL must be one of CRITICAL | HIGH | NORMAL\n" 72 " --skip SERVICES: dumps all services but SERVICES (comma-separated list)\n" 73 " SERVICE [ARGS]: dumps only service SERVICE, optionally passing ARGS to it\n"); 74 } 75 76 static bool IsSkipped(const Vector<String16>& skipped, const String16& service) { 77 for (const auto& candidate : skipped) { 78 if (candidate == service) { 79 return true; 80 } 81 } 82 return false; 83 } 84 85 static bool ConvertPriorityTypeToBitmask(const String16& type, int& bitmask) { 86 if (type == PriorityDumper::PRIORITY_ARG_CRITICAL) { 87 bitmask = IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL; 88 return true; 89 } 90 if (type == PriorityDumper::PRIORITY_ARG_HIGH) { 91 bitmask = IServiceManager::DUMP_FLAG_PRIORITY_HIGH; 92 return true; 93 } 94 if (type == PriorityDumper::PRIORITY_ARG_NORMAL) { 95 bitmask = IServiceManager::DUMP_FLAG_PRIORITY_NORMAL; 96 return true; 97 } 98 return false; 99 } 100 101 String16 ConvertBitmaskToPriorityType(int bitmask) { 102 if (bitmask == IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL) { 103 return String16(PriorityDumper::PRIORITY_ARG_CRITICAL); 104 } 105 if (bitmask == IServiceManager::DUMP_FLAG_PRIORITY_HIGH) { 106 return String16(PriorityDumper::PRIORITY_ARG_HIGH); 107 } 108 if (bitmask == IServiceManager::DUMP_FLAG_PRIORITY_NORMAL) { 109 return String16(PriorityDumper::PRIORITY_ARG_NORMAL); 110 } 111 return String16(""); 112 } 113 114 int Dumpsys::main(int argc, char* const argv[]) { 115 Vector<String16> services; 116 Vector<String16> args; 117 String16 priorityType; 118 Vector<String16> skippedServices; 119 Vector<String16> protoServices; 120 bool showListOnly = false; 121 bool skipServices = false; 122 bool asProto = false; 123 int timeoutArgMs = 10000; 124 int priorityFlags = IServiceManager::DUMP_FLAG_PRIORITY_ALL; 125 static struct option longOptions[] = {{"priority", required_argument, 0, 0}, 126 {"proto", no_argument, 0, 0}, 127 {"skip", no_argument, 0, 0}, 128 {"help", no_argument, 0, 0}, 129 {0, 0, 0, 0}}; 130 131 // Must reset optind, otherwise subsequent calls will fail (wouldn't happen on main.cpp, but 132 // happens on test cases). 133 optind = 1; 134 while (1) { 135 int c; 136 int optionIndex = 0; 137 138 c = getopt_long(argc, argv, "+t:T:l", longOptions, &optionIndex); 139 140 if (c == -1) { 141 break; 142 } 143 144 switch (c) { 145 case 0: 146 if (!strcmp(longOptions[optionIndex].name, "skip")) { 147 skipServices = true; 148 } else if (!strcmp(longOptions[optionIndex].name, "proto")) { 149 asProto = true; 150 } else if (!strcmp(longOptions[optionIndex].name, "help")) { 151 usage(); 152 return 0; 153 } else if (!strcmp(longOptions[optionIndex].name, "priority")) { 154 priorityType = String16(String8(optarg)); 155 if (!ConvertPriorityTypeToBitmask(priorityType, priorityFlags)) { 156 fprintf(stderr, "\n"); 157 usage(); 158 return -1; 159 } 160 } 161 break; 162 163 case 't': 164 { 165 char* endptr; 166 timeoutArgMs = strtol(optarg, &endptr, 10); 167 timeoutArgMs = timeoutArgMs * 1000; 168 if (*endptr != '\0' || timeoutArgMs <= 0) { 169 fprintf(stderr, "Error: invalid timeout(seconds) number: '%s'\n", optarg); 170 return -1; 171 } 172 } 173 break; 174 175 case 'T': 176 { 177 char* endptr; 178 timeoutArgMs = strtol(optarg, &endptr, 10); 179 if (*endptr != '\0' || timeoutArgMs <= 0) { 180 fprintf(stderr, "Error: invalid timeout(milliseconds) number: '%s'\n", optarg); 181 return -1; 182 } 183 } 184 break; 185 186 case 'l': 187 showListOnly = true; 188 break; 189 190 default: 191 fprintf(stderr, "\n"); 192 usage(); 193 return -1; 194 } 195 } 196 197 for (int i = optind; i < argc; i++) { 198 if (skipServices) { 199 skippedServices.add(String16(argv[i])); 200 } else { 201 if (i == optind) { 202 services.add(String16(argv[i])); 203 } else { 204 args.add(String16(argv[i])); 205 } 206 } 207 } 208 209 if ((skipServices && skippedServices.empty()) || 210 (showListOnly && (!services.empty() || !skippedServices.empty()))) { 211 usage(); 212 return -1; 213 } 214 215 if (services.empty() || showListOnly) { 216 services = listServices(priorityFlags, asProto); 217 setServiceArgs(args, asProto, priorityFlags); 218 } 219 220 const size_t N = services.size(); 221 if (N > 1) { 222 // first print a list of the current services 223 aout << "Currently running services:" << endl; 224 225 for (size_t i=0; i<N; i++) { 226 sp<IBinder> service = sm_->checkService(services[i]); 227 228 if (service != nullptr) { 229 bool skipped = IsSkipped(skippedServices, services[i]); 230 aout << " " << services[i] << (skipped ? " (skipped)" : "") << endl; 231 } 232 } 233 } 234 235 if (showListOnly) { 236 return 0; 237 } 238 239 for (size_t i = 0; i < N; i++) { 240 const String16& serviceName = services[i]; 241 if (IsSkipped(skippedServices, serviceName)) continue; 242 243 if (startDumpThread(serviceName, args) == OK) { 244 bool addSeparator = (N > 1); 245 if (addSeparator) { 246 writeDumpHeader(STDOUT_FILENO, serviceName, priorityFlags); 247 } 248 std::chrono::duration<double> elapsedDuration; 249 size_t bytesWritten = 0; 250 status_t status = 251 writeDump(STDOUT_FILENO, serviceName, std::chrono::milliseconds(timeoutArgMs), 252 asProto, elapsedDuration, bytesWritten); 253 254 if (status == TIMED_OUT) { 255 aout << endl 256 << "*** SERVICE '" << serviceName << "' DUMP TIMEOUT (" << timeoutArgMs 257 << "ms) EXPIRED ***" << endl 258 << endl; 259 } 260 261 if (addSeparator) { 262 writeDumpFooter(STDOUT_FILENO, serviceName, elapsedDuration); 263 } 264 bool dumpComplete = (status == OK); 265 stopDumpThread(dumpComplete); 266 } 267 } 268 269 return 0; 270 } 271 272 Vector<String16> Dumpsys::listServices(int priorityFilterFlags, bool filterByProto) const { 273 Vector<String16> services = sm_->listServices(priorityFilterFlags); 274 services.sort(sort_func); 275 if (filterByProto) { 276 Vector<String16> protoServices = sm_->listServices(IServiceManager::DUMP_FLAG_PROTO); 277 protoServices.sort(sort_func); 278 Vector<String16> intersection; 279 std::set_intersection(services.begin(), services.end(), protoServices.begin(), 280 protoServices.end(), std::back_inserter(intersection)); 281 services = std::move(intersection); 282 } 283 return services; 284 } 285 286 void Dumpsys::setServiceArgs(Vector<String16>& args, bool asProto, int priorityFlags) { 287 // Add proto flag if dumping service as proto. 288 if (asProto) { 289 args.insertAt(String16(PriorityDumper::PROTO_ARG), 0); 290 } 291 292 // Add -a (dump all) flag if dumping all services, dumping normal services or 293 // services not explicitly registered to a priority bucket (default services). 294 if ((priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_ALL) || 295 (priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_NORMAL) || 296 (priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT)) { 297 args.insertAt(String16("-a"), 0); 298 } 299 300 // Add priority flags when dumping services registered to a specific priority bucket. 301 if ((priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL) || 302 (priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_HIGH) || 303 (priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_NORMAL)) { 304 String16 priorityType = ConvertBitmaskToPriorityType(priorityFlags); 305 args.insertAt(String16(PriorityDumper::PRIORITY_ARG), 0); 306 args.insertAt(priorityType, 1); 307 } 308 } 309 310 status_t Dumpsys::startDumpThread(const String16& serviceName, const Vector<String16>& args) { 311 sp<IBinder> service = sm_->checkService(serviceName); 312 if (service == nullptr) { 313 aerr << "Can't find service: " << serviceName << endl; 314 return NAME_NOT_FOUND; 315 } 316 317 int sfd[2]; 318 if (pipe(sfd) != 0) { 319 aerr << "Failed to create pipe to dump service info for " << serviceName << ": " 320 << strerror(errno) << endl; 321 return -errno; 322 } 323 324 redirectFd_ = unique_fd(sfd[0]); 325 unique_fd remote_end(sfd[1]); 326 sfd[0] = sfd[1] = -1; 327 328 // dump blocks until completion, so spawn a thread.. 329 activeThread_ = std::thread([=, remote_end{std::move(remote_end)}]() mutable { 330 int err = service->dump(remote_end.get(), args); 331 332 // It'd be nice to be able to close the remote end of the socketpair before the dump 333 // call returns, to terminate our reads if the other end closes their copy of the 334 // file descriptor, but then hangs for some reason. There doesn't seem to be a good 335 // way to do this, though. 336 remote_end.reset(); 337 338 if (err != 0) { 339 aerr << "Error dumping service info: (" << strerror(err) << ") " 340 << serviceName << endl; 341 } 342 }); 343 return OK; 344 } 345 346 void Dumpsys::stopDumpThread(bool dumpComplete) { 347 if (dumpComplete) { 348 activeThread_.join(); 349 } else { 350 activeThread_.detach(); 351 } 352 /* close read end of the dump output redirection pipe */ 353 redirectFd_.reset(); 354 } 355 356 void Dumpsys::writeDumpHeader(int fd, const String16& serviceName, int priorityFlags) const { 357 std::string msg( 358 "----------------------------------------" 359 "---------------------------------------\n"); 360 if (priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_ALL || 361 priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_NORMAL || 362 priorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT) { 363 StringAppendF(&msg, "DUMP OF SERVICE %s:\n", String8(serviceName).c_str()); 364 } else { 365 String16 priorityType = ConvertBitmaskToPriorityType(priorityFlags); 366 StringAppendF(&msg, "DUMP OF SERVICE %s %s:\n", String8(priorityType).c_str(), 367 String8(serviceName).c_str()); 368 } 369 WriteStringToFd(msg, fd); 370 } 371 372 status_t Dumpsys::writeDump(int fd, const String16& serviceName, std::chrono::milliseconds timeout, 373 bool asProto, std::chrono::duration<double>& elapsedDuration, 374 size_t& bytesWritten) const { 375 status_t status = OK; 376 size_t totalBytes = 0; 377 auto start = std::chrono::steady_clock::now(); 378 auto end = start + timeout; 379 380 int serviceDumpFd = redirectFd_.get(); 381 if (serviceDumpFd == -1) { 382 return INVALID_OPERATION; 383 } 384 385 struct pollfd pfd = {.fd = serviceDumpFd, .events = POLLIN}; 386 387 while (true) { 388 // Wrap this in a lambda so that TEMP_FAILURE_RETRY recalculates the timeout. 389 auto time_left_ms = [end]() { 390 auto now = std::chrono::steady_clock::now(); 391 auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - now); 392 return std::max(diff.count(), 0LL); 393 }; 394 395 int rc = TEMP_FAILURE_RETRY(poll(&pfd, 1, time_left_ms())); 396 if (rc < 0) { 397 aerr << "Error in poll while dumping service " << serviceName << " : " 398 << strerror(errno) << endl; 399 status = -errno; 400 break; 401 } else if (rc == 0) { 402 status = TIMED_OUT; 403 break; 404 } 405 406 char buf[4096]; 407 rc = TEMP_FAILURE_RETRY(read(redirectFd_.get(), buf, sizeof(buf))); 408 if (rc < 0) { 409 aerr << "Failed to read while dumping service " << serviceName << ": " 410 << strerror(errno) << endl; 411 status = -errno; 412 break; 413 } else if (rc == 0) { 414 // EOF. 415 break; 416 } 417 418 if (!WriteFully(fd, buf, rc)) { 419 aerr << "Failed to write while dumping service " << serviceName << ": " 420 << strerror(errno) << endl; 421 status = -errno; 422 break; 423 } 424 totalBytes += rc; 425 } 426 427 if ((status == TIMED_OUT) && (!asProto)) { 428 std::string msg = StringPrintf("\n*** SERVICE '%s' DUMP TIMEOUT (%llums) EXPIRED ***\n\n", 429 String8(serviceName).string(), timeout.count()); 430 WriteStringToFd(msg, fd); 431 } 432 433 elapsedDuration = std::chrono::steady_clock::now() - start; 434 bytesWritten = totalBytes; 435 return status; 436 } 437 438 void Dumpsys::writeDumpFooter(int fd, const String16& serviceName, 439 const std::chrono::duration<double>& elapsedDuration) const { 440 using std::chrono::system_clock; 441 const auto finish = system_clock::to_time_t(system_clock::now()); 442 std::tm finish_tm; 443 localtime_r(&finish, &finish_tm); 444 std::stringstream oss; 445 oss << std::put_time(&finish_tm, "%Y-%m-%d %H:%M:%S"); 446 std::string msg = 447 StringPrintf("--------- %.3fs was the duration of dumpsys %s, ending at: %s\n", 448 elapsedDuration.count(), String8(serviceName).string(), oss.str().c_str()); 449 WriteStringToFd(msg, fd); 450 } 451