src/mojo/system/data_pipe.h

   1 // Copyright 2013 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 #ifndef MOJO_SYSTEM_DATA_PIPE_H_
   6 #define MOJO_SYSTEM_DATA_PIPE_H_
   7
   8 #include <stdint.h>
   9
  10 #include "base/macros.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/synchronization/lock.h"
  14 #include "mojo/public/c/system/data_pipe.h"
  15 #include "mojo/public/c/system/types.h"
  16 #include "mojo/system/handle_signals_state.h"
  17 #include "mojo/system/memory.h"
  18 #include "mojo/system/system_impl_export.h"
  19
  20 namespace mojo {
  21 namespace system {
  22
  23 class Waiter;
  24 class WaiterList;
  25
  26 // |DataPipe| is a base class for secondary objects implementing data pipes,
  27 // similar to |MessagePipe| (see the explanatory comment in core.cc). It is
  28 // typically owned by the dispatcher(s) corresponding to the local endpoints.
  29 // Its subclasses implement the three cases: local producer and consumer, local
  30 // producer and remote consumer, and remote producer and local consumer. This
  31 // class is thread-safe.
  32 class MOJO_SYSTEM_IMPL_EXPORT DataPipe
  33     : public base::RefCountedThreadSafe<DataPipe> {
  34  public:
  35   // The default options for |MojoCreateDataPipe()|. (Real uses should obtain
  36   // this via |ValidateCreateOptions()| with a null |in_options|; this is
  37   // exposed directly for testing convenience.)
  38   static const MojoCreateDataPipeOptions kDefaultCreateOptions;
  39
  40   // Validates and/or sets default options for |MojoCreateDataPipeOptions|. If
  41   // non-null, |in_options| must point to a struct of at least
  42   // |in_options->struct_size| bytes. |out_options| must point to a (current)
  43   // |MojoCreateDataPipeOptions| and will be entirely overwritten on success (it
  44   // may be partly overwritten on failure).
  45   static MojoResult ValidateCreateOptions(
  46       UserPointer<const MojoCreateDataPipeOptions> in_options,
  47       MojoCreateDataPipeOptions* out_options);
  48
  49   // These are called by the producer dispatcher to implement its methods of
  50   // corresponding names.
  51   void ProducerCancelAllWaiters();
  52   void ProducerClose();
  53   MojoResult ProducerWriteData(UserPointer<const void> elements,
  54                                UserPointer<uint32_t> num_bytes,
  55                                bool all_or_none);
  56   MojoResult ProducerBeginWriteData(UserPointer<void*> buffer,
  57                                     UserPointer<uint32_t> buffer_num_bytes,
  58                                     bool all_or_none);
  59   MojoResult ProducerEndWriteData(uint32_t num_bytes_written);
  60   HandleSignalsState ProducerGetHandleSignalsState();
  61   MojoResult ProducerAddWaiter(Waiter* waiter,
  62                                MojoHandleSignals signals,
  63                                uint32_t context,
  64                                HandleSignalsState* signals_state);
  65   void ProducerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
  66   bool ProducerIsBusy() const;
  67
  68   // These are called by the consumer dispatcher to implement its methods of
  69   // corresponding names.
  70   void ConsumerCancelAllWaiters();
  71   void ConsumerClose();
  72   // This does not validate its arguments, except to check that |*num_bytes| is
  73   // a multiple of |element_num_bytes_|.
  74   MojoResult ConsumerReadData(UserPointer<void> elements,
  75                               UserPointer<uint32_t> num_bytes,
  76                               bool all_or_none);
  77   MojoResult ConsumerDiscardData(UserPointer<uint32_t> num_bytes,
  78                                  bool all_or_none);
  79   MojoResult ConsumerQueryData(UserPointer<uint32_t> num_bytes);
  80   MojoResult ConsumerBeginReadData(UserPointer<const void*> buffer,
  81                                    UserPointer<uint32_t> buffer_num_bytes,
  82                                    bool all_or_none);
  83   MojoResult ConsumerEndReadData(uint32_t num_bytes_read);
  84   HandleSignalsState ConsumerGetHandleSignalsState();
  85   MojoResult ConsumerAddWaiter(Waiter* waiter,
  86                                MojoHandleSignals signals,
  87                                uint32_t context,
  88                                HandleSignalsState* signals_state);
  89   void ConsumerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
  90   bool ConsumerIsBusy() const;
  91
  92  protected:
  93   DataPipe(bool has_local_producer,
  94            bool has_local_consumer,
  95            const MojoCreateDataPipeOptions& validated_options);
  96
  97   friend class base::RefCountedThreadSafe<DataPipe>;
  98   virtual ~DataPipe();
  99
 100   virtual void ProducerCloseImplNoLock() = 0;
 101   // |num_bytes.Get()| will be a nonzero multiple of |element_num_bytes_|.
 102   virtual MojoResult ProducerWriteDataImplNoLock(
 103       UserPointer<const void> elements,
 104       UserPointer<uint32_t> num_bytes,
 105       uint32_t max_num_bytes_to_write,
 106       uint32_t min_num_bytes_to_write) = 0;
 107   virtual MojoResult ProducerBeginWriteDataImplNoLock(
 108       UserPointer<void*> buffer,
 109       UserPointer<uint32_t> buffer_num_bytes,
 110       uint32_t min_num_bytes_to_write) = 0;
 111   virtual MojoResult ProducerEndWriteDataImplNoLock(
 112       uint32_t num_bytes_written) = 0;
 113   // Note: A producer should not be writable during a two-phase write.
 114   virtual HandleSignalsState ProducerGetHandleSignalsStateImplNoLock()
 115       const = 0;
 116
 117   virtual void ConsumerCloseImplNoLock() = 0;
 118   // |*num_bytes| will be a nonzero multiple of |element_num_bytes_|.
 119   virtual MojoResult ConsumerReadDataImplNoLock(
 120       UserPointer<void> elements,
 121       UserPointer<uint32_t> num_bytes,
 122       uint32_t max_num_bytes_to_read,
 123       uint32_t min_num_bytes_to_read) = 0;
 124   virtual MojoResult ConsumerDiscardDataImplNoLock(
 125       UserPointer<uint32_t> num_bytes,
 126       uint32_t max_num_bytes_to_discard,
 127       uint32_t min_num_bytes_to_discard) = 0;
 128   // |*num_bytes| will be a nonzero multiple of |element_num_bytes_|.
 129   virtual MojoResult ConsumerQueryDataImplNoLock(
 130       UserPointer<uint32_t> num_bytes) = 0;
 131   virtual MojoResult ConsumerBeginReadDataImplNoLock(
 132       UserPointer<const void*> buffer,
 133       UserPointer<uint32_t> buffer_num_bytes,
 134       uint32_t min_num_bytes_to_read) = 0;
 135   virtual MojoResult ConsumerEndReadDataImplNoLock(uint32_t num_bytes_read) = 0;
 136   // Note: A consumer should not be writable during a two-phase read.
 137   virtual HandleSignalsState ConsumerGetHandleSignalsStateImplNoLock()
 138       const = 0;
 139
 140   // Thread-safe and fast (they don't take the lock):
 141   bool may_discard() const { return may_discard_; }
 142   size_t element_num_bytes() const { return element_num_bytes_; }
 143   size_t capacity_num_bytes() const { return capacity_num_bytes_; }
 144
 145   // Must be called under lock.
 146   bool producer_open_no_lock() const {
 147     lock_.AssertAcquired();
 148     return producer_open_;
 149   }
 150   bool consumer_open_no_lock() const {
 151     lock_.AssertAcquired();
 152     return consumer_open_;
 153   }
 154   uint32_t producer_two_phase_max_num_bytes_written_no_lock() const {
 155     lock_.AssertAcquired();
 156     return producer_two_phase_max_num_bytes_written_;
 157   }
 158   uint32_t consumer_two_phase_max_num_bytes_read_no_lock() const {
 159     lock_.AssertAcquired();
 160     return consumer_two_phase_max_num_bytes_read_;
 161   }
 162   void set_producer_two_phase_max_num_bytes_written_no_lock(
 163       uint32_t num_bytes) {
 164     lock_.AssertAcquired();
 165     producer_two_phase_max_num_bytes_written_ = num_bytes;
 166   }
 167   void set_consumer_two_phase_max_num_bytes_read_no_lock(uint32_t num_bytes) {
 168     lock_.AssertAcquired();
 169     consumer_two_phase_max_num_bytes_read_ = num_bytes;
 170   }
 171   bool producer_in_two_phase_write_no_lock() const {
 172     lock_.AssertAcquired();
 173     return producer_two_phase_max_num_bytes_written_ > 0;
 174   }
 175   bool consumer_in_two_phase_read_no_lock() const {
 176     lock_.AssertAcquired();
 177     return consumer_two_phase_max_num_bytes_read_ > 0;
 178   }
 179
 180  private:
 181   void AwakeProducerWaitersForStateChangeNoLock(
 182       const HandleSignalsState& new_producer_state);
 183   void AwakeConsumerWaitersForStateChangeNoLock(
 184       const HandleSignalsState& new_consumer_state);
 185
 186   bool has_local_producer_no_lock() const {
 187     lock_.AssertAcquired();
 188     return !!producer_waiter_list_;
 189   }
 190   bool has_local_consumer_no_lock() const {
 191     lock_.AssertAcquired();
 192     return !!consumer_waiter_list_;
 193   }
 194
 195   const bool may_discard_;
 196   const size_t element_num_bytes_;
 197   const size_t capacity_num_bytes_;
 198
 199   mutable base::Lock lock_;  // Protects the following members.
 200   // *Known* state of producer or consumer.
 201   bool producer_open_;
 202   bool consumer_open_;
 203   // Non-null only if the producer or consumer, respectively, is local.
 204   scoped_ptr<WaiterList> producer_waiter_list_;
 205   scoped_ptr<WaiterList> consumer_waiter_list_;
 206   // These are nonzero if and only if a two-phase write/read is in progress.
 207   uint32_t producer_two_phase_max_num_bytes_written_;
 208   uint32_t consumer_two_phase_max_num_bytes_read_;
 209
 210   DISALLOW_COPY_AND_ASSIGN(DataPipe);
 211 };
 212
 213 }  // namespace system
 214 }  // namespace mojo
 215
 216 #endif  // MOJO_SYSTEM_DATA_PIPE_H_