1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chromeos/dbus/debug_daemon_client.h" 6 7 #include <fcntl.h> 8 #include <unistd.h> 9 #include <string> 10 #include <vector> 11 12 #include "base/bind.h" 13 #include "base/bind_helpers.h" 14 #include "base/callback.h" 15 #include "base/files/file_path.h" 16 #include "base/location.h" 17 #include "base/memory/ref_counted_memory.h" 18 #include "base/message_loop/message_loop.h" 19 #include "base/posix/eintr_wrapper.h" 20 #include "base/strings/string_util.h" 21 #include "base/task_runner_util.h" 22 #include "chromeos/dbus/pipe_reader.h" 23 #include "dbus/bus.h" 24 #include "dbus/message.h" 25 #include "dbus/object_path.h" 26 #include "dbus/object_proxy.h" 27 #include "third_party/cros_system_api/dbus/service_constants.h" 28 29 namespace { 30 31 // Used in DebugDaemonClient::EmptySystemStopTracingCallback(). 32 void EmptyStopSystemTracingCallbackBody( 33 const scoped_refptr<base::RefCountedString>& unused_result) { 34 } 35 36 } // namespace 37 38 namespace chromeos { 39 40 // The DebugDaemonClient implementation used in production. 41 class DebugDaemonClientImpl : public DebugDaemonClient { 42 public: 43 DebugDaemonClientImpl() : debugdaemon_proxy_(NULL), weak_ptr_factory_(this) {} 44 45 virtual ~DebugDaemonClientImpl() {} 46 47 // DebugDaemonClient override. 48 virtual void DumpDebugLogs(bool is_compressed, 49 base::File file, 50 scoped_refptr<base::TaskRunner> task_runner, 51 const GetDebugLogsCallback& callback) OVERRIDE { 52 dbus::FileDescriptor* file_descriptor = new dbus::FileDescriptor; 53 file_descriptor->PutValue(file.TakePlatformFile()); 54 // Punt descriptor validity check to a worker thread; on return we'll 55 // issue the D-Bus request to stop tracing and collect results. 56 task_runner->PostTaskAndReply( 57 FROM_HERE, 58 base::Bind(&dbus::FileDescriptor::CheckValidity, 59 base::Unretained(file_descriptor)), 60 base::Bind(&DebugDaemonClientImpl::OnCheckValidityGetDebugLogs, 61 weak_ptr_factory_.GetWeakPtr(), 62 is_compressed, 63 base::Owned(file_descriptor), 64 callback)); 65 } 66 67 virtual void SetDebugMode(const std::string& subsystem, 68 const SetDebugModeCallback& callback) OVERRIDE { 69 dbus::MethodCall method_call(debugd::kDebugdInterface, 70 debugd::kSetDebugMode); 71 dbus::MessageWriter writer(&method_call); 72 writer.AppendString(subsystem); 73 debugdaemon_proxy_->CallMethod( 74 &method_call, 75 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 76 base::Bind(&DebugDaemonClientImpl::OnSetDebugMode, 77 weak_ptr_factory_.GetWeakPtr(), 78 callback)); 79 } 80 81 virtual void GetRoutes(bool numeric, bool ipv6, 82 const GetRoutesCallback& callback) OVERRIDE { 83 dbus::MethodCall method_call(debugd::kDebugdInterface, 84 debugd::kGetRoutes); 85 dbus::MessageWriter writer(&method_call); 86 dbus::MessageWriter sub_writer(NULL); 87 writer.OpenArray("{sv}", &sub_writer); 88 dbus::MessageWriter elem_writer(NULL); 89 sub_writer.OpenDictEntry(&elem_writer); 90 elem_writer.AppendString("numeric"); 91 elem_writer.AppendVariantOfBool(numeric); 92 sub_writer.CloseContainer(&elem_writer); 93 sub_writer.OpenDictEntry(&elem_writer); 94 elem_writer.AppendString("v6"); 95 elem_writer.AppendVariantOfBool(ipv6); 96 sub_writer.CloseContainer(&elem_writer); 97 writer.CloseContainer(&sub_writer); 98 debugdaemon_proxy_->CallMethod( 99 &method_call, 100 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 101 base::Bind(&DebugDaemonClientImpl::OnGetRoutes, 102 weak_ptr_factory_.GetWeakPtr(), 103 callback)); 104 } 105 106 virtual void GetNetworkStatus(const GetNetworkStatusCallback& callback) 107 OVERRIDE { 108 dbus::MethodCall method_call(debugd::kDebugdInterface, 109 debugd::kGetNetworkStatus); 110 debugdaemon_proxy_->CallMethod( 111 &method_call, 112 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 113 base::Bind(&DebugDaemonClientImpl::OnGetNetworkStatus, 114 weak_ptr_factory_.GetWeakPtr(), 115 callback)); 116 } 117 118 virtual void GetModemStatus(const GetModemStatusCallback& callback) 119 OVERRIDE { 120 dbus::MethodCall method_call(debugd::kDebugdInterface, 121 debugd::kGetModemStatus); 122 debugdaemon_proxy_->CallMethod( 123 &method_call, 124 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 125 base::Bind(&DebugDaemonClientImpl::OnGetModemStatus, 126 weak_ptr_factory_.GetWeakPtr(), 127 callback)); 128 } 129 130 virtual void GetWiMaxStatus(const GetWiMaxStatusCallback& callback) 131 OVERRIDE { 132 dbus::MethodCall method_call(debugd::kDebugdInterface, 133 debugd::kGetWiMaxStatus); 134 debugdaemon_proxy_->CallMethod( 135 &method_call, 136 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 137 base::Bind(&DebugDaemonClientImpl::OnGetWiMaxStatus, 138 weak_ptr_factory_.GetWeakPtr(), 139 callback)); 140 } 141 142 virtual void GetNetworkInterfaces( 143 const GetNetworkInterfacesCallback& callback) OVERRIDE { 144 dbus::MethodCall method_call(debugd::kDebugdInterface, 145 debugd::kGetInterfaces); 146 debugdaemon_proxy_->CallMethod( 147 &method_call, 148 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 149 base::Bind(&DebugDaemonClientImpl::OnGetNetworkInterfaces, 150 weak_ptr_factory_.GetWeakPtr(), 151 callback)); 152 } 153 154 virtual void GetPerfData(uint32_t duration, 155 const GetPerfDataCallback& callback) OVERRIDE { 156 dbus::MethodCall method_call(debugd::kDebugdInterface, 157 debugd::kGetRichPerfData); 158 dbus::MessageWriter writer(&method_call); 159 writer.AppendUint32(duration); 160 161 debugdaemon_proxy_->CallMethod( 162 &method_call, 163 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 164 base::Bind(&DebugDaemonClientImpl::OnGetPerfData, 165 weak_ptr_factory_.GetWeakPtr(), 166 callback)); 167 } 168 169 virtual void GetScrubbedLogs(const GetLogsCallback& callback) OVERRIDE { 170 dbus::MethodCall method_call(debugd::kDebugdInterface, 171 debugd::kGetFeedbackLogs); 172 debugdaemon_proxy_->CallMethod( 173 &method_call, 174 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 175 base::Bind(&DebugDaemonClientImpl::OnGetAllLogs, 176 weak_ptr_factory_.GetWeakPtr(), 177 callback)); 178 } 179 180 virtual void GetAllLogs(const GetLogsCallback& callback) 181 OVERRIDE { 182 dbus::MethodCall method_call(debugd::kDebugdInterface, 183 debugd::kGetAllLogs); 184 debugdaemon_proxy_->CallMethod( 185 &method_call, 186 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 187 base::Bind(&DebugDaemonClientImpl::OnGetAllLogs, 188 weak_ptr_factory_.GetWeakPtr(), 189 callback)); 190 } 191 192 virtual void GetUserLogFiles( 193 const GetLogsCallback& callback) OVERRIDE { 194 dbus::MethodCall method_call(debugd::kDebugdInterface, 195 debugd::kGetUserLogFiles); 196 debugdaemon_proxy_->CallMethod( 197 &method_call, 198 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 199 base::Bind(&DebugDaemonClientImpl::OnGetUserLogFiles, 200 weak_ptr_factory_.GetWeakPtr(), 201 callback)); 202 } 203 204 virtual void StartSystemTracing() OVERRIDE { 205 dbus::MethodCall method_call( 206 debugd::kDebugdInterface, 207 debugd::kSystraceStart); 208 dbus::MessageWriter writer(&method_call); 209 writer.AppendString("all"); // TODO(sleffler) parameterize category list 210 211 DVLOG(1) << "Requesting a systrace start"; 212 debugdaemon_proxy_->CallMethod( 213 &method_call, 214 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 215 base::Bind(&DebugDaemonClientImpl::OnStartMethod, 216 weak_ptr_factory_.GetWeakPtr())); 217 } 218 219 virtual bool RequestStopSystemTracing( 220 scoped_refptr<base::TaskRunner> task_runner, 221 const StopSystemTracingCallback& callback) OVERRIDE { 222 if (pipe_reader_ != NULL) { 223 LOG(ERROR) << "Busy doing StopSystemTracing"; 224 return false; 225 } 226 227 pipe_reader_.reset(new PipeReaderForString( 228 task_runner, 229 base::Bind(&DebugDaemonClientImpl::OnIOComplete, 230 weak_ptr_factory_.GetWeakPtr()))); 231 232 base::File pipe_write_end = pipe_reader_->StartIO(); 233 // Create dbus::FileDescriptor on the worker thread; on return we'll 234 // issue the D-Bus request to stop tracing and collect results. 235 base::PostTaskAndReplyWithResult( 236 task_runner.get(), 237 FROM_HERE, 238 base::Bind( 239 &DebugDaemonClientImpl::CreateFileDescriptorToStopSystemTracing, 240 base::Passed(&pipe_write_end)), 241 base::Bind( 242 &DebugDaemonClientImpl::OnCreateFileDescriptorRequestStopSystem, 243 weak_ptr_factory_.GetWeakPtr(), 244 callback)); 245 return true; 246 } 247 248 virtual void TestICMP(const std::string& ip_address, 249 const TestICMPCallback& callback) OVERRIDE { 250 dbus::MethodCall method_call(debugd::kDebugdInterface, 251 debugd::kTestICMP); 252 dbus::MessageWriter writer(&method_call); 253 writer.AppendString(ip_address); 254 debugdaemon_proxy_->CallMethod( 255 &method_call, 256 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 257 base::Bind(&DebugDaemonClientImpl::OnTestICMP, 258 weak_ptr_factory_.GetWeakPtr(), 259 callback)); 260 } 261 262 virtual void TestICMPWithOptions( 263 const std::string& ip_address, 264 const std::map<std::string, std::string>& options, 265 const TestICMPCallback& callback) OVERRIDE { 266 dbus::MethodCall method_call(debugd::kDebugdInterface, 267 debugd::kTestICMPWithOptions); 268 dbus::MessageWriter writer(&method_call); 269 dbus::MessageWriter sub_writer(NULL); 270 dbus::MessageWriter elem_writer(NULL); 271 272 // Write the host. 273 writer.AppendString(ip_address); 274 275 // Write the options. 276 writer.OpenArray("{ss}", &sub_writer); 277 std::map<std::string, std::string>::const_iterator it; 278 for (it = options.begin(); it != options.end(); ++it) { 279 sub_writer.OpenDictEntry(&elem_writer); 280 elem_writer.AppendString(it->first); 281 elem_writer.AppendString(it->second); 282 sub_writer.CloseContainer(&elem_writer); 283 } 284 writer.CloseContainer(&sub_writer); 285 286 // Call the function. 287 debugdaemon_proxy_->CallMethod( 288 &method_call, 289 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 290 base::Bind(&DebugDaemonClientImpl::OnTestICMP, 291 weak_ptr_factory_.GetWeakPtr(), 292 callback)); 293 } 294 295 virtual void UploadCrashes() OVERRIDE { 296 dbus::MethodCall method_call(debugd::kDebugdInterface, 297 debugd::kUploadCrashes); 298 debugdaemon_proxy_->CallMethod( 299 &method_call, 300 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 301 base::Bind(&DebugDaemonClientImpl::OnStartMethod, 302 weak_ptr_factory_.GetWeakPtr())); 303 } 304 305 protected: 306 virtual void Init(dbus::Bus* bus) OVERRIDE { 307 debugdaemon_proxy_ = 308 bus->GetObjectProxy(debugd::kDebugdServiceName, 309 dbus::ObjectPath(debugd::kDebugdServicePath)); 310 } 311 312 private: 313 // Called when a CheckValidity response is received. 314 void OnCheckValidityGetDebugLogs(bool is_compressed, 315 dbus::FileDescriptor* file_descriptor, 316 const GetDebugLogsCallback& callback) { 317 // Issue the dbus request to get debug logs. 318 dbus::MethodCall method_call(debugd::kDebugdInterface, 319 debugd::kDumpDebugLogs); 320 dbus::MessageWriter writer(&method_call); 321 writer.AppendBool(is_compressed); 322 writer.AppendFileDescriptor(*file_descriptor); 323 324 debugdaemon_proxy_->CallMethod( 325 &method_call, 326 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 327 base::Bind(&DebugDaemonClientImpl::OnGetDebugLogs, 328 weak_ptr_factory_.GetWeakPtr(), 329 callback)); 330 } 331 332 // Called when a response for GetDebugLogs() is received. 333 void OnGetDebugLogs(const GetDebugLogsCallback& callback, 334 dbus::Response* response) { 335 if (!response) { 336 LOG(ERROR) << "Failed to get debug logs"; 337 callback.Run(false); 338 return; 339 } 340 callback.Run(true); 341 } 342 343 // Called when a response for SetDebugMode() is received. 344 void OnSetDebugMode(const SetDebugModeCallback& callback, 345 dbus::Response* response) { 346 if (!response) { 347 LOG(ERROR) << "Failed to change debug mode"; 348 callback.Run(false); 349 } else { 350 callback.Run(true); 351 } 352 } 353 354 void OnGetRoutes(const GetRoutesCallback& callback, 355 dbus::Response* response) { 356 std::vector<std::string> routes; 357 if (response) { 358 dbus::MessageReader reader(response); 359 if (reader.PopArrayOfStrings(&routes)) { 360 callback.Run(true, routes); 361 } else { 362 LOG(ERROR) << "Got non-array response from GetRoutes"; 363 callback.Run(false, routes); 364 } 365 } else { 366 callback.Run(false, routes); 367 } 368 } 369 370 void OnGetNetworkStatus(const GetNetworkStatusCallback& callback, 371 dbus::Response* response) { 372 std::string status; 373 if (response && dbus::MessageReader(response).PopString(&status)) 374 callback.Run(true, status); 375 else 376 callback.Run(false, ""); 377 } 378 379 void OnGetModemStatus(const GetModemStatusCallback& callback, 380 dbus::Response* response) { 381 std::string status; 382 if (response && dbus::MessageReader(response).PopString(&status)) 383 callback.Run(true, status); 384 else 385 callback.Run(false, ""); 386 } 387 388 void OnGetWiMaxStatus(const GetWiMaxStatusCallback& callback, 389 dbus::Response* response) { 390 std::string status; 391 if (response && dbus::MessageReader(response).PopString(&status)) 392 callback.Run(true, status); 393 else 394 callback.Run(false, ""); 395 } 396 397 void OnGetNetworkInterfaces(const GetNetworkInterfacesCallback& callback, 398 dbus::Response* response) { 399 std::string status; 400 if (response && dbus::MessageReader(response).PopString(&status)) 401 callback.Run(true, status); 402 else 403 callback.Run(false, ""); 404 } 405 406 void OnGetPerfData(const GetPerfDataCallback& callback, 407 dbus::Response* response) { 408 std::vector<uint8> data; 409 410 if (!response) { 411 return; 412 } 413 414 dbus::MessageReader reader(response); 415 const uint8* buffer = NULL; 416 size_t buf_size = 0; 417 if (!reader.PopArrayOfBytes(&buffer, &buf_size)) 418 return; 419 420 // TODO(asharif): Figure out a way to avoid this copy. 421 data.insert(data.end(), buffer, buffer + buf_size); 422 423 callback.Run(data); 424 } 425 426 void OnGetAllLogs(const GetLogsCallback& callback, 427 dbus::Response* response) { 428 std::map<std::string, std::string> logs; 429 bool broken = false; // did we see a broken (k,v) pair? 430 dbus::MessageReader sub_reader(NULL); 431 if (!response || !dbus::MessageReader(response).PopArray(&sub_reader)) { 432 callback.Run(false, logs); 433 return; 434 } 435 while (sub_reader.HasMoreData()) { 436 dbus::MessageReader sub_sub_reader(NULL); 437 std::string key, value; 438 if (!sub_reader.PopDictEntry(&sub_sub_reader) 439 || !sub_sub_reader.PopString(&key) 440 || !sub_sub_reader.PopString(&value)) { 441 broken = true; 442 break; 443 } 444 logs[key] = value; 445 } 446 callback.Run(!sub_reader.HasMoreData() && !broken, logs); 447 } 448 449 void OnGetUserLogFiles(const GetLogsCallback& callback, 450 dbus::Response* response) { 451 return OnGetAllLogs(callback, response); 452 } 453 454 // Called when a response for a simple start is received. 455 void OnStartMethod(dbus::Response* response) { 456 if (!response) { 457 LOG(ERROR) << "Failed to request start"; 458 return; 459 } 460 } 461 462 // Creates dbus::FileDescriptor from base::File. 463 static scoped_ptr<dbus::FileDescriptor> 464 CreateFileDescriptorToStopSystemTracing(base::File pipe_write_end) { 465 if (!pipe_write_end.IsValid()) { 466 LOG(ERROR) << "Cannot create pipe reader"; 467 // NB: continue anyway to shutdown tracing; toss trace data 468 pipe_write_end.Initialize(base::FilePath(FILE_PATH_LITERAL("/dev/null")), 469 base::File::FLAG_OPEN | base::File::FLAG_WRITE); 470 // TODO(sleffler) if this fails AppendFileDescriptor will abort 471 } 472 scoped_ptr<dbus::FileDescriptor> file_descriptor(new dbus::FileDescriptor); 473 file_descriptor->PutValue(pipe_write_end.TakePlatformFile()); 474 file_descriptor->CheckValidity(); 475 return file_descriptor.Pass(); 476 } 477 478 // Called when a CheckValidity response is received. 479 void OnCreateFileDescriptorRequestStopSystem( 480 const StopSystemTracingCallback& callback, 481 scoped_ptr<dbus::FileDescriptor> file_descriptor) { 482 DCHECK(file_descriptor); 483 484 // Issue the dbus request to stop system tracing 485 dbus::MethodCall method_call( 486 debugd::kDebugdInterface, 487 debugd::kSystraceStop); 488 dbus::MessageWriter writer(&method_call); 489 writer.AppendFileDescriptor(*file_descriptor); 490 491 callback_ = callback; 492 493 DVLOG(1) << "Requesting a systrace stop"; 494 debugdaemon_proxy_->CallMethod( 495 &method_call, 496 dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, 497 base::Bind(&DebugDaemonClientImpl::OnRequestStopSystemTracing, 498 weak_ptr_factory_.GetWeakPtr())); 499 } 500 501 // Called when a response for RequestStopSystemTracing() is received. 502 void OnRequestStopSystemTracing(dbus::Response* response) { 503 if (!response) { 504 LOG(ERROR) << "Failed to request systrace stop"; 505 // If debugd crashes or completes I/O before this message is processed 506 // then pipe_reader_ can be NULL, see OnIOComplete(). 507 if (pipe_reader_.get()) 508 pipe_reader_->OnDataReady(-1); // terminate data stream 509 } 510 // NB: requester is signaled when i/o completes 511 } 512 513 void OnTestICMP(const TestICMPCallback& callback, dbus::Response* response) { 514 std::string status; 515 if (response && dbus::MessageReader(response).PopString(&status)) 516 callback.Run(true, status); 517 else 518 callback.Run(false, ""); 519 } 520 521 // Called when pipe i/o completes; pass data on and delete the instance. 522 void OnIOComplete() { 523 std::string pipe_data; 524 pipe_reader_->GetData(&pipe_data); 525 callback_.Run(base::RefCountedString::TakeString(&pipe_data)); 526 pipe_reader_.reset(); 527 } 528 529 dbus::ObjectProxy* debugdaemon_proxy_; 530 scoped_ptr<PipeReaderForString> pipe_reader_; 531 StopSystemTracingCallback callback_; 532 base::WeakPtrFactory<DebugDaemonClientImpl> weak_ptr_factory_; 533 534 DISALLOW_COPY_AND_ASSIGN(DebugDaemonClientImpl); 535 }; 536 537 DebugDaemonClient::DebugDaemonClient() { 538 } 539 540 DebugDaemonClient::~DebugDaemonClient() { 541 } 542 543 // static 544 DebugDaemonClient::StopSystemTracingCallback 545 DebugDaemonClient::EmptyStopSystemTracingCallback() { 546 return base::Bind(&EmptyStopSystemTracingCallbackBody); 547 } 548 549 // static 550 DebugDaemonClient* DebugDaemonClient::Create() { 551 return new DebugDaemonClientImpl(); 552 } 553 554 } // namespace chromeos 555
