dbus: revamp fd passing for i/o restrictions

chromeos/dbus/debug_daemon_client.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <fcntl.h>
 #include <unistd.h>
 
 #include "chromeos/dbus/debug_daemon_client.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/eintr_wrapper.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
+#include "base/threading/worker_pool.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
@@ skipping 118 matching lines @@
     debugdaemon_proxy_ = bus->GetObjectProxy(
         debugd::kDebugdServiceName,
         dbus::ObjectPath(debugd::kDebugdServicePath));
   }
 
   virtual ~DebugDaemonClientImpl() {}
 
   // DebugDaemonClient override.
   virtual void GetDebugLogs(base::PlatformFile file,
                             const GetDebugLogsCallback& callback) OVERRIDE {
-    dbus::MethodCall method_call(
-        debugd::kDebugdInterface,
-        debugd::kGetDebugLogs);
-    dbus::MessageWriter writer(&method_call);
-    dbus::FileDescriptor fd(file);  // explicit temp for C++ 98
-    writer.AppendFileDescriptor(fd);
 
-    debugdaemon_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&DebugDaemonClientImpl::OnGetDebugLogs,
+    dbus::FileDescriptor* file_descriptor = new dbus::FileDescriptor(file);
+    // Punt descriptor validity check to a worker thread; on return we'll
+    // issue the D-Bus request to stop tracing and collect results.
+    base::WorkerPool::PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&DebugDaemonClientImpl::CheckValidity,
+                   file_descriptor),
+        base::Bind(&DebugDaemonClientImpl::OnCheckValidityGetDebugLogs,
                    weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   base::Owned(file_descriptor),
+                   callback),
+        false);
   }
 
   virtual void SetDebugMode(const std::string& subsystem,
                             const SetDebugModeCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(debugd::kDebugdInterface,
                                  debugd::kSetDebugMode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(subsystem);
     debugdaemon_proxy_->CallMethod(
         &method_call,
@@ skipping 31 matching lines @@
     int write_fd = -1;
     if (!pipe_reader_->StartIO()) {
       LOG(ERROR) << "Cannot create pipe reader";
       // NB: continue anyway to shutdown tracing; toss trace data
       write_fd = HANDLE_EINTR(open("/dev/null", O_WRONLY));
       // TODO(sleffler) if this fails AppendFileDescriptor will abort
     } else {
       write_fd = pipe_reader_->GetWriteFD();
     }
 
-    callback_ = callback;
-
-    // Issue the dbus request to stop system tracing
-    dbus::MethodCall method_call(
-        debugd::kDebugdInterface,
-        debugd::kSystraceStop);
-    dbus::MessageWriter writer(&method_call);
-    dbus::FileDescriptor temp(write_fd);  // NB: explicit temp for C++98
-    writer.AppendFileDescriptor(temp);
-
-    DVLOG(1) << "Requesting a systrace stop";
-    debugdaemon_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&DebugDaemonClientImpl::OnRequestStopSystemTracing,
-                   weak_ptr_factory_.GetWeakPtr()));
-
-    pipe_reader_->CloseWriteFD();  // close our copy of fd after send
+    dbus::FileDescriptor* file_descriptor = new dbus::FileDescriptor(write_fd);
+    // Punt descriptor validity check to a worker thread; on return we'll
+    // issue the D-Bus request to stop tracing and collect results.
+    base::WorkerPool::PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&DebugDaemonClientImpl::CheckValidity,
+                   file_descriptor),
+        base::Bind(&DebugDaemonClientImpl::OnCheckValidityRequestStopSystem,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Owned(file_descriptor),
+                   callback),
+        false);
 
     return true;
   }
 
  private:
+  // Called to check descriptor validity on a thread where i/o is permitted.
+  static void CheckValidity(dbus::FileDescriptor* file_descriptor) {
+    file_descriptor->CheckValidity();
+  }
+
+  // Called when a CheckValidity response is received.
+  void OnCheckValidityGetDebugLogs(dbus::FileDescriptor* file_descriptor,
+                                   const GetDebugLogsCallback& callback) {
+    // Issue the dbus request to get debug logs.
+    dbus::MethodCall method_call(
+        debugd::kDebugdInterface,
+        debugd::kGetDebugLogs);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendFileDescriptor(*file_descriptor);
+
+    debugdaemon_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnGetDebugLogs,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback));
+  }
+
   // Called when a response for GetDebugLogs() is received.
   void OnGetDebugLogs(const GetDebugLogsCallback& callback,
                       dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to get debug logs";
       callback.Run(false);
       return;
     }
     callback.Run(true);
   }
@@ skipping 10 matching lines @@
   }
 
   // Called when a response for StartSystemTracing() is received.
   void OnStartSystemTracing(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to request systrace start";
       return;
     }
   }
 
+  // Called when a CheckValidity response is received.
+  void OnCheckValidityRequestStopSystem(
+      dbus::FileDescriptor* file_descriptor,
+      const StopSystemTracingCallback& callback) {
+    // Issue the dbus request to stop system tracing
+    dbus::MethodCall method_call(
+        debugd::kDebugdInterface,
+        debugd::kSystraceStop);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendFileDescriptor(*file_descriptor);
+
+    callback_ = callback;
+
+    DVLOG(1) << "Requesting a systrace stop";
+    debugdaemon_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnRequestStopSystemTracing,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    pipe_reader_->CloseWriteFD();  // close our copy of fd after send
+  }
+
   // Called when a response for RequestStopSystemTracing() is received.
   void OnRequestStopSystemTracing(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to request systrace stop";
       pipe_reader_->OnDataReady(-1); // terminate data stream
     }
     // NB: requester is signaled when i/o completes
   }
 
   // Called when pipe i/o completes; pass data on and delete the instance.
@@ skipping 46 matching lines @@
 // static
 DebugDaemonClient* DebugDaemonClient::Create(DBusClientImplementationType type,
                                    dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new DebugDaemonClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new DebugDaemonClientStubImpl();
 }
 
 }  // namespace chromeos