libprotobinder/binder_manager.h

// Copyright 2015 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef LIBPROTOBINDER_BINDER_MANAGER_H_
#define LIBPROTOBINDER_BINDER_MANAGER_H_

#include <cstdint>
#include <map>
#include <memory>
#include <set>

#include <base/macros.h>
#include <base/memory/scoped_ptr.h>
#include <base/memory/weak_ptr.h>

// binder.h requires types.h to be included first.
#include <sys/types.h>
#include <linux/android/binder.h>  // NOLINT(build/include_alpha)

#include "binder_driver.h"  // NOLINT(build/include)
#include "binder_export.h"  // NOLINT(build/include)
#include "parcel.h"         // NOLINT(build/include)
#include "status.h"         // NOLINT(build/include)

namespace protobinder {

class BinderHost;
class BinderProxy;
class IInterface;

// Interface for a singleton class for communicating using the binder protocol.
class BINDER_EXPORT BinderManagerInterface {
 public:
  // Returns the singleton instance of BinderManagerInterface, creating it if
  // necessary.
  static BinderManagerInterface* Get();

  // Overrides the automatically-created instance returned by Get(). Can be
  // called by tests to install their own BinderManagerStub.
  static void SetForTesting(scoped_ptr<BinderManagerInterface> manager);

  virtual ~BinderManagerInterface() = default;

  virtual Status Transact(uint32_t handle,
                          uint32_t code,
                          const Parcel& data,
                          Parcel* reply,
                          bool one_way) = 0;
  virtual bool GetFdForPolling(int* fd) = 0;
  virtual void HandleEvent() = 0;

  // Returns the cookie that should be used to identify a new BinderHost().
  virtual binder_uintptr_t GetNextBinderHostCookie() = 0;

  // Registers or unregisters a mapping from a cookie to a host. Called by
  // BinderHost's constructor and destructor, respectively.
  virtual void RegisterBinderHost(BinderHost* host) = 0;
  virtual void UnregisterBinderHost(BinderHost* host) = 0;

  // Registers or unregisters a proxy. Called by BinderProxy's constructor and
  // destructor, respectively.
  virtual void RegisterBinderProxy(BinderProxy* proxy) = 0;
  virtual void UnregisterBinderProxy(BinderProxy* proxy) = 0;

  // If a test IInterface has been registered for |proxy|, returns it.
  // Otherwise, returns null.
  virtual std::unique_ptr<IInterface> CreateTestInterface(
      const BinderProxy* proxy) = 0;
};

// Real implementation of BinderManagerInterface that communicates with the
// kernel via /dev/binder.
class BINDER_EXPORT BinderManager : public BinderManagerInterface {
 public:
  explicit BinderManager(std::unique_ptr<BinderDriverInterface> driver);
  ~BinderManager() override;

  // BinderManagerInterface:
  Status Transact(uint32_t handle,
                  uint32_t code,
                  const Parcel& data,
                  Parcel* reply,
                  bool one_way) override;
  bool GetFdForPolling(int* fd) override;
  void HandleEvent() override;
  binder_uintptr_t GetNextBinderHostCookie() override;
  void RegisterBinderHost(BinderHost* host) override;
  void UnregisterBinderHost(BinderHost* host) override;
  void RegisterBinderProxy(BinderProxy* proxy) override;
  void UnregisterBinderProxy(BinderProxy* proxy) override;
  std::unique_ptr<IInterface> CreateTestInterface(
      const BinderProxy* proxy) override;

 private:
  struct HostInfo;

  // Adds or removes a remote process's reference from the HostInfo struct
  // identified by |cookie| in |hosts_|. If the reference count reaches zero and
  // the underlying BinderHost object has already been destroyed,
  // RemoveHostReference() removes the struct from |hosts_|.
  void AddHostReference(binder_uintptr_t cookie);
  void RemoveHostReference(binder_uintptr_t cookie);

  Status WaitAndActionReply(Parcel* reply);

  // Writes a command freeing |data|.
  void ReleaseBinderBuffer(const uint8_t* data);

  // Passes |parcel|'s data to ReleaseBinderBuffer().
  void ReleaseParcel(Parcel* parcel);

  void DoBinderReadWriteIoctl(bool do_read);
  void SetUpTransaction(bool is_reply,
                        uint32_t handle,
                        uint32_t code,
                        const Parcel& data,
                        uint32_t flags);
  // Process a single command from binder.
  void ProcessCommand(uint32_t cmd);
  void GetNextCommandAndProcess();
  Status SendReply(const Parcel& reply, const Status& status);
  Status HandleReply(const binder_transaction_data& tr, Parcel* reply);

  // Increments or decrements the kernel's reference count for the binder
  // identified by |handle|.
  void IncWeakHandle(uint32_t handle);
  void DecWeakHandle(uint32_t handle);

  // Registers or unregisters a request for death notifications for the binder
  // identified by |handle|.
  void RequestDeathNotification(uint32_t handle);
  void ClearDeathNotification(uint32_t handle);

  // Notifies all of the BinderProxy objects keyed by |handle| in |proxies_|
  // that the host side of their binder has died.
  void NotifyProxiesAboutBinderDeath(uint32_t handle);

  std::unique_ptr<BinderDriverInterface> driver_;

  // These parcels are used to pass binder ioctl commands to binder.
  // They carry binder command buffers, not to be confused with Parcels
  // used in Transactions which carry user data.
  Parcel out_commands_;
  Parcel in_commands_;

  // Value to be returned for next call to GetNextBinderHostCookie().
  binder_uintptr_t next_host_cookie_;

  // Associates cookies with hosts.
  std::map<binder_uintptr_t, HostInfo> hosts_;

  // Associates handles with BinderProxy objects. Note that multiple proxies may
  // be created for a single binder handle.
  std::multimap<uint32_t, BinderProxy*> proxies_;

  // BinderProxy objects that NotifyProxiesAboutBinderDeath() is in the process
  // of notifying. Stored in a member so that UnregisterBinderProxy() can update
  // it if one of the death callbacks happens to destroy a still-scheduled
  // proxy.
  std::set<BinderProxy*> proxies_to_notify_about_death_;

  // Keep this member last.
  base::WeakPtrFactory<BinderManager> weak_ptr_factory_;

  DISALLOW_COPY_AND_ASSIGN(BinderManager);
};

}  // namespace protobinder

#endif  // LIBPROTOBINDER_BINDER_MANAGER_H_