chromeos/dbus/debug_daemon_client.cc

   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 "base/threading/worker_pool.h"
  23 #include "chromeos/dbus/pipe_reader.h"
  24 #include "dbus/bus.h"
  25 #include "dbus/message.h"
  26 #include "dbus/object_path.h"
  27 #include "dbus/object_proxy.h"
  28 #include "third_party/cros_system_api/dbus/service_constants.h"
  29
  30 namespace {
  31
  32 // Used in DebugDaemonClient::EmptySystemStopTracingCallback().
  33 void EmptyStopSystemTracingCallbackBody(
  34   const scoped_refptr<base::RefCountedString>& unused_result) {
  35 }
  36
  37 }  // namespace
  38
  39 namespace chromeos {
  40
  41 // The DebugDaemonClient implementation used in production.
  42 class DebugDaemonClientImpl : public DebugDaemonClient {
  43  public:
  44   DebugDaemonClientImpl() : debugdaemon_proxy_(NULL), weak_ptr_factory_(this) {}
  45
  46   virtual ~DebugDaemonClientImpl() {}
  47
  48   // DebugDaemonClient override.
  49   virtual void GetDebugLogs(base::File file,
  50                             const GetDebugLogsCallback& callback) OVERRIDE {
  51
  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     base::WorkerPool::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                    base::Owned(file_descriptor),
  63                    callback),
  64         false);
  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(const StopSystemTracingCallback&
 220       callback) OVERRIDE {
 221     if (pipe_reader_ != NULL) {
 222       LOG(ERROR) << "Busy doing StopSystemTracing";
 223       return false;
 224     }
 225
 226     scoped_refptr<base::TaskRunner> task_runner =
 227         base::WorkerPool::GetTaskRunner(true /* task_is_slow */);
 228
 229     pipe_reader_.reset(new PipeReaderForString(
 230         task_runner,
 231         base::Bind(&DebugDaemonClientImpl::OnIOComplete,
 232                    weak_ptr_factory_.GetWeakPtr())));
 233
 234     base::File pipe_write_end = pipe_reader_->StartIO();
 235     // Create dbus::FileDescriptor on the worker thread; on return we'll
 236     // issue the D-Bus request to stop tracing and collect results.
 237     base::PostTaskAndReplyWithResult(
 238         task_runner,
 239         FROM_HERE,
 240         base::Bind(
 241             &DebugDaemonClientImpl::CreateFileDescriptorToStopSystemTracing,
 242             base::Passed(&pipe_write_end)),
 243         base::Bind(
 244             &DebugDaemonClientImpl::OnCreateFileDescriptorRequestStopSystem,
 245             weak_ptr_factory_.GetWeakPtr(),
 246             callback));
 247     return true;
 248   }
 249
 250   virtual void TestICMP(const std::string& ip_address,
 251                         const TestICMPCallback& callback) OVERRIDE {
 252     dbus::MethodCall method_call(debugd::kDebugdInterface,
 253                                  debugd::kTestICMP);
 254     dbus::MessageWriter writer(&method_call);
 255     writer.AppendString(ip_address);
 256     debugdaemon_proxy_->CallMethod(
 257         &method_call,
 258         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 259         base::Bind(&DebugDaemonClientImpl::OnTestICMP,
 260                    weak_ptr_factory_.GetWeakPtr(),
 261                    callback));
 262   }
 263
 264   virtual void TestICMPWithOptions(
 265       const std::string& ip_address,
 266       const std::map<std::string, std::string>& options,
 267       const TestICMPCallback& callback) OVERRIDE {
 268     dbus::MethodCall method_call(debugd::kDebugdInterface,
 269                                  debugd::kTestICMPWithOptions);
 270     dbus::MessageWriter writer(&method_call);
 271     dbus::MessageWriter sub_writer(NULL);
 272     dbus::MessageWriter elem_writer(NULL);
 273
 274     // Write the host.
 275     writer.AppendString(ip_address);
 276
 277     // Write the options.
 278     writer.OpenArray("{ss}", &sub_writer);
 279     std::map<std::string, std::string>::const_iterator it;
 280     for (it = options.begin(); it != options.end(); ++it) {
 281       sub_writer.OpenDictEntry(&elem_writer);
 282       elem_writer.AppendString(it->first);
 283       elem_writer.AppendString(it->second);
 284       sub_writer.CloseContainer(&elem_writer);
 285     }
 286     writer.CloseContainer(&sub_writer);
 287
 288     // Call the function.
 289     debugdaemon_proxy_->CallMethod(
 290         &method_call,
 291         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 292         base::Bind(&DebugDaemonClientImpl::OnTestICMP,
 293                    weak_ptr_factory_.GetWeakPtr(),
 294                    callback));
 295   }
 296
 297   virtual void UploadCrashes() OVERRIDE {
 298     dbus::MethodCall method_call(debugd::kDebugdInterface,
 299                                  debugd::kUploadCrashes);
 300     debugdaemon_proxy_->CallMethod(
 301         &method_call,
 302         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 303         base::Bind(&DebugDaemonClientImpl::OnStartMethod,
 304                    weak_ptr_factory_.GetWeakPtr()));
 305   }
 306
 307  protected:
 308   virtual void Init(dbus::Bus* bus) OVERRIDE {
 309     debugdaemon_proxy_ =
 310         bus->GetObjectProxy(debugd::kDebugdServiceName,
 311                             dbus::ObjectPath(debugd::kDebugdServicePath));
 312   }
 313
 314  private:
 315   // Called when a CheckValidity response is received.
 316   void OnCheckValidityGetDebugLogs(dbus::FileDescriptor* file_descriptor,
 317                                    const GetDebugLogsCallback& callback) {
 318     // Issue the dbus request to get debug logs.
 319     dbus::MethodCall method_call(
 320         debugd::kDebugdInterface,
 321         debugd::kGetDebugLogs);
 322     dbus::MessageWriter writer(&method_call);
 323     writer.AppendFileDescriptor(*file_descriptor);
 324
 325     debugdaemon_proxy_->CallMethod(
 326         &method_call,
 327         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 328         base::Bind(&DebugDaemonClientImpl::OnGetDebugLogs,
 329                    weak_ptr_factory_.GetWeakPtr(),
 330                    callback));
 331   }
 332
 333   // Called when a response for GetDebugLogs() is received.
 334   void OnGetDebugLogs(const GetDebugLogsCallback& callback,
 335                       dbus::Response* response) {
 336     if (!response) {
 337       LOG(ERROR) << "Failed to get debug logs";
 338       callback.Run(false);
 339       return;
 340     }
 341     callback.Run(true);
 342   }
 343
 344   // Called when a response for SetDebugMode() is received.
 345   void OnSetDebugMode(const SetDebugModeCallback& callback,
 346                       dbus::Response* response) {
 347     if (!response) {
 348       LOG(ERROR) << "Failed to change debug mode";
 349       callback.Run(false);
 350     } else {
 351       callback.Run(true);
 352     }
 353   }
 354
 355   void OnGetRoutes(const GetRoutesCallback& callback,
 356                    dbus::Response* response) {
 357     std::vector<std::string> routes;
 358     if (response) {
 359       dbus::MessageReader reader(response);
 360       if (reader.PopArrayOfStrings(&routes)) {
 361         callback.Run(true, routes);
 362       } else {
 363         LOG(ERROR) << "Got non-array response from GetRoutes";
 364         callback.Run(false, routes);
 365       }
 366     } else {
 367       callback.Run(false, routes);
 368     }
 369   }
 370
 371   void OnGetNetworkStatus(const GetNetworkStatusCallback& callback,
 372                           dbus::Response* response) {
 373     std::string status;
 374     if (response && dbus::MessageReader(response).PopString(&status))
 375       callback.Run(true, status);
 376     else
 377       callback.Run(false, "");
 378   }
 379
 380   void OnGetModemStatus(const GetModemStatusCallback& callback,
 381                         dbus::Response* response) {
 382     std::string status;
 383     if (response && dbus::MessageReader(response).PopString(&status))
 384       callback.Run(true, status);
 385     else
 386       callback.Run(false, "");
 387   }
 388
 389   void OnGetWiMaxStatus(const GetWiMaxStatusCallback& callback,
 390                         dbus::Response* response) {
 391     std::string status;
 392     if (response && dbus::MessageReader(response).PopString(&status))
 393       callback.Run(true, status);
 394     else
 395       callback.Run(false, "");
 396   }
 397
 398   void OnGetNetworkInterfaces(const GetNetworkInterfacesCallback& callback,
 399                               dbus::Response* response) {
 400     std::string status;
 401     if (response && dbus::MessageReader(response).PopString(&status))
 402       callback.Run(true, status);
 403     else
 404       callback.Run(false, "");
 405   }
 406
 407   void OnGetPerfData(const GetPerfDataCallback& callback,
 408                      dbus::Response* response) {
 409     std::vector<uint8> data;
 410
 411     if (!response) {
 412       return;
 413     }
 414
 415     dbus::MessageReader reader(response);
 416     const uint8* buffer = NULL;
 417     size_t buf_size = 0;
 418     if (!reader.PopArrayOfBytes(&buffer, &buf_size))
 419       return;
 420
 421     // TODO(asharif): Figure out a way to avoid this copy.
 422     data.insert(data.end(), buffer, buffer + buf_size);
 423
 424     callback.Run(data);
 425   }
 426
 427   void OnGetAllLogs(const GetLogsCallback& callback,
 428                     dbus::Response* response) {
 429     std::map<std::string, std::string> logs;
 430     bool broken = false; // did we see a broken (k,v) pair?
 431     dbus::MessageReader sub_reader(NULL);
 432     if (!response || !dbus::MessageReader(response).PopArray(&sub_reader)) {
 433       callback.Run(false, logs);
 434       return;
 435     }
 436     while (sub_reader.HasMoreData()) {
 437       dbus::MessageReader sub_sub_reader(NULL);
 438       std::string key, value;
 439       if (!sub_reader.PopDictEntry(&sub_sub_reader)
 440           || !sub_sub_reader.PopString(&key)
 441           || !sub_sub_reader.PopString(&value)) {
 442         broken = true;
 443         break;
 444       }
 445       logs[key] = value;
 446     }
 447     callback.Run(!sub_reader.HasMoreData() && !broken, logs);
 448   }
 449
 450   void OnGetUserLogFiles(const GetLogsCallback& callback,
 451                          dbus::Response* response) {
 452     return OnGetAllLogs(callback, response);
 453   }
 454
 455   // Called when a response for a simple start is received.
 456   void OnStartMethod(dbus::Response* response) {
 457     if (!response) {
 458       LOG(ERROR) << "Failed to request start";
 459       return;
 460     }
 461   }
 462
 463   // Creates dbus::FileDescriptor from base::File.
 464   static scoped_ptr<dbus::FileDescriptor>
 465   CreateFileDescriptorToStopSystemTracing(base::File pipe_write_end) {
 466     if (!pipe_write_end.IsValid()) {
 467       LOG(ERROR) << "Cannot create pipe reader";
 468       // NB: continue anyway to shutdown tracing; toss trace data
 469       pipe_write_end.Initialize(base::FilePath(FILE_PATH_LITERAL("/dev/null")),
 470                                 base::File::FLAG_OPEN | base::File::FLAG_WRITE);
 471       // TODO(sleffler) if this fails AppendFileDescriptor will abort
 472     }
 473     scoped_ptr<dbus::FileDescriptor> file_descriptor(new dbus::FileDescriptor);
 474     file_descriptor->PutValue(pipe_write_end.TakePlatformFile());
 475     file_descriptor->CheckValidity();
 476     return file_descriptor.Pass();
 477   }
 478
 479   // Called when a CheckValidity response is received.
 480   void OnCreateFileDescriptorRequestStopSystem(
 481       const StopSystemTracingCallback& callback,
 482       scoped_ptr<dbus::FileDescriptor> file_descriptor) {
 483     DCHECK(file_descriptor);
 484
 485     // Issue the dbus request to stop system tracing
 486     dbus::MethodCall method_call(
 487         debugd::kDebugdInterface,
 488         debugd::kSystraceStop);
 489     dbus::MessageWriter writer(&method_call);
 490     writer.AppendFileDescriptor(*file_descriptor);
 491
 492     callback_ = callback;
 493
 494     DVLOG(1) << "Requesting a systrace stop";
 495     debugdaemon_proxy_->CallMethod(
 496         &method_call,
 497         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 498         base::Bind(&DebugDaemonClientImpl::OnRequestStopSystemTracing,
 499                    weak_ptr_factory_.GetWeakPtr()));
 500   }
 501
 502   // Called when a response for RequestStopSystemTracing() is received.
 503   void OnRequestStopSystemTracing(dbus::Response* response) {
 504     if (!response) {
 505       LOG(ERROR) << "Failed to request systrace stop";
 506       // If debugd crashes or completes I/O before this message is processed
 507       // then pipe_reader_ can be NULL, see OnIOComplete().
 508       if (pipe_reader_.get())
 509         pipe_reader_->OnDataReady(-1); // terminate data stream
 510     }
 511     // NB: requester is signaled when i/o completes
 512   }
 513
 514   void OnTestICMP(const TestICMPCallback& callback, dbus::Response* response) {
 515     std::string status;
 516     if (response && dbus::MessageReader(response).PopString(&status))
 517       callback.Run(true, status);
 518     else
 519       callback.Run(false, "");
 520   }
 521
 522   // Called when pipe i/o completes; pass data on and delete the instance.
 523   void OnIOComplete() {
 524     std::string pipe_data;
 525     pipe_reader_->GetData(&pipe_data);
 526     callback_.Run(base::RefCountedString::TakeString(&pipe_data));
 527     pipe_reader_.reset();
 528   }
 529
 530   dbus::ObjectProxy* debugdaemon_proxy_;
 531   scoped_ptr<PipeReaderForString> pipe_reader_;
 532   StopSystemTracingCallback callback_;
 533   base::WeakPtrFactory<DebugDaemonClientImpl> weak_ptr_factory_;
 534
 535   DISALLOW_COPY_AND_ASSIGN(DebugDaemonClientImpl);
 536 };
 537
 538 DebugDaemonClient::DebugDaemonClient() {
 539 }
 540
 541 DebugDaemonClient::~DebugDaemonClient() {
 542 }
 543
 544 // static
 545 DebugDaemonClient::StopSystemTracingCallback
 546 DebugDaemonClient::EmptyStopSystemTracingCallback() {
 547   return base::Bind(&EmptyStopSystemTracingCallbackBody);
 548 }
 549
 550 // static
 551 DebugDaemonClient* DebugDaemonClient::Create() {
 552   return new DebugDaemonClientImpl();
 553 }
 554
 555 }  // namespace chromeos