Home | History | Annotate | Download | only in service 
      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 "gpu/command_buffer/service/common_decoder.h"
      6 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
      7 
      8 namespace gpu {
      9 
     10 CommonDecoder::Bucket::Bucket() : size_(0) {}
     11 
     12 CommonDecoder::Bucket::~Bucket() {}
     13 
     14 void* CommonDecoder::Bucket::GetData(size_t offset, size_t size) const {
     15   if (OffsetSizeValid(offset, size)) {
     16     return data_.get() + offset;
     17   }
     18   return NULL;
     19 }
     20 
     21 void CommonDecoder::Bucket::SetSize(size_t size) {
     22   if (size != size_) {
     23     data_.reset(size ? new int8[size] : NULL);
     24     size_ = size;
     25     memset(data_.get(), 0, size);
     26   }
     27 }
     28 
     29 bool CommonDecoder::Bucket::SetData(
     30     const void* src, size_t offset, size_t size) {
     31   if (OffsetSizeValid(offset, size)) {
     32     memcpy(data_.get() + offset, src, size);
     33     return true;
     34   }
     35   return false;
     36 }
     37 
     38 void CommonDecoder::Bucket::SetFromString(const char* str) {
     39   // Strings are passed NULL terminated to distinguish between empty string
     40   // and no string.
     41   if (!str) {
     42     SetSize(0);
     43   } else {
     44     size_t size = strlen(str) + 1;
     45     SetSize(size);
     46     SetData(str, 0, size);
     47   }
     48 }
     49 
     50 bool CommonDecoder::Bucket::GetAsString(std::string* str) {
     51   DCHECK(str);
     52   if (size_ == 0) {
     53     return false;
     54   }
     55   str->assign(GetDataAs<const char*>(0, size_ - 1), size_ - 1);
     56   return true;
     57 }
     58 
     59 CommonDecoder::CommonDecoder() : engine_(NULL) {}
     60 
     61 CommonDecoder::~CommonDecoder() {}
     62 
     63 void* CommonDecoder::GetAddressAndCheckSize(unsigned int shm_id,
     64                                             unsigned int data_offset,
     65                                             unsigned int data_size) {
     66   CHECK(engine_);
     67   scoped_refptr<gpu::Buffer> buffer = engine_->GetSharedMemoryBuffer(shm_id);
     68   if (!buffer.get())
     69     return NULL;
     70   return buffer->GetDataAddress(data_offset, data_size);
     71 }
     72 
     73 scoped_refptr<gpu::Buffer> CommonDecoder::GetSharedMemoryBuffer(
     74     unsigned int shm_id) {
     75   return engine_->GetSharedMemoryBuffer(shm_id);
     76 }
     77 
     78 const char* CommonDecoder::GetCommonCommandName(
     79     cmd::CommandId command_id) const {
     80   return cmd::GetCommandName(command_id);
     81 }
     82 
     83 CommonDecoder::Bucket* CommonDecoder::GetBucket(uint32 bucket_id) const {
     84   BucketMap::const_iterator iter(buckets_.find(bucket_id));
     85   return iter != buckets_.end() ? &(*iter->second) : NULL;
     86 }
     87 
     88 CommonDecoder::Bucket* CommonDecoder::CreateBucket(uint32 bucket_id) {
     89   Bucket* bucket = GetBucket(bucket_id);
     90   if (!bucket) {
     91     bucket = new Bucket();
     92     buckets_[bucket_id] = linked_ptr<Bucket>(bucket);
     93   }
     94   return bucket;
     95 }
     96 
     97 namespace {
     98 
     99 // Returns the address of the first byte after a struct.
    100 template <typename T>
    101 const void* AddressAfterStruct(const T& pod) {
    102   return reinterpret_cast<const uint8*>(&pod) + sizeof(pod);
    103 }
    104 
    105 // Returns the address of the frst byte after the struct.
    106 template <typename RETURN_TYPE, typename COMMAND_TYPE>
    107 RETURN_TYPE GetImmediateDataAs(const COMMAND_TYPE& pod) {
    108   return static_cast<RETURN_TYPE>(const_cast<void*>(AddressAfterStruct(pod)));
    109 }
    110 
    111 // TODO(vmiura): Looks like this g_command_info is duplicated in
    112 // common_decoder.cc
    113 // and gles2_cmd_decoder.cc.  Fix it!
    114 
    115 // A struct to hold info about each command.
    116 struct CommandInfo {
    117   uint8 arg_flags;   // How to handle the arguments for this command
    118   uint8 cmd_flags;   // How to handle this command
    119   uint16 arg_count;  // How many arguments are expected for this command.
    120 };
    121 
    122 // A table of CommandInfo for all the commands.
    123 const CommandInfo g_command_info[] = {
    124   #define COMMON_COMMAND_BUFFER_CMD_OP(name) {                           \
    125     cmd::name::kArgFlags,                                                \
    126     cmd::name::cmd_flags,                                                \
    127     sizeof(cmd::name) / sizeof(CommandBufferEntry) - 1, },  /* NOLINT */
    128 
    129   COMMON_COMMAND_BUFFER_CMDS(COMMON_COMMAND_BUFFER_CMD_OP)
    130 
    131   #undef COMMON_COMMAND_BUFFER_CMD_OP
    132 };
    133 
    134 }  // anonymous namespace.
    135 
    136 // Decode command with its arguments, and call the corresponding method.
    137 // Note: args is a pointer to the command buffer. As such, it could be changed
    138 // by a (malicious) client at any time, so if validation has to happen, it
    139 // should operate on a copy of them.
    140 error::Error CommonDecoder::DoCommonCommand(
    141     unsigned int command,
    142     unsigned int arg_count,
    143     const void* cmd_data) {
    144   if (command < arraysize(g_command_info)) {
    145     const CommandInfo& info = g_command_info[command];
    146     unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
    147     if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
    148         (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) {
    149       uint32 immediate_data_size =
    150           (arg_count - info_arg_count) * sizeof(CommandBufferEntry);  // NOLINT
    151       switch (command) {
    152         #define COMMON_COMMAND_BUFFER_CMD_OP(name)                      \
    153           case cmd::name::kCmdId:                                       \
    154             return Handle ## name(                                      \
    155                 immediate_data_size,                                    \
    156                 *static_cast<const cmd::name*>(cmd_data));              \
    157 
    158         COMMON_COMMAND_BUFFER_CMDS(COMMON_COMMAND_BUFFER_CMD_OP)
    159 
    160         #undef COMMON_COMMAND_BUFFER_CMD_OP
    161       }
    162     } else {
    163       return error::kInvalidArguments;
    164     }
    165   }
    166   return error::kUnknownCommand;
    167 }
    168 
    169 error::Error CommonDecoder::HandleNoop(
    170     uint32 immediate_data_size,
    171     const cmd::Noop& args) {
    172   return error::kNoError;
    173 }
    174 
    175 error::Error CommonDecoder::HandleSetToken(
    176     uint32 immediate_data_size,
    177     const cmd::SetToken& args) {
    178   engine_->set_token(args.token);
    179   return error::kNoError;
    180 }
    181 
    182 error::Error CommonDecoder::HandleSetBucketSize(
    183     uint32 immediate_data_size,
    184     const cmd::SetBucketSize& args) {
    185   uint32 bucket_id = args.bucket_id;
    186   uint32 size = args.size;
    187 
    188   Bucket* bucket = CreateBucket(bucket_id);
    189   bucket->SetSize(size);
    190   return error::kNoError;
    191 }
    192 
    193 error::Error CommonDecoder::HandleSetBucketData(
    194     uint32 immediate_data_size,
    195     const cmd::SetBucketData& args) {
    196   uint32 bucket_id = args.bucket_id;
    197   uint32 offset = args.offset;
    198   uint32 size = args.size;
    199   const void* data = GetSharedMemoryAs<const void*>(
    200       args.shared_memory_id, args.shared_memory_offset, size);
    201   if (!data) {
    202     return error::kInvalidArguments;
    203   }
    204   Bucket* bucket = GetBucket(bucket_id);
    205   if (!bucket) {
    206     return error::kInvalidArguments;
    207   }
    208   if (!bucket->SetData(data, offset, size)) {
    209     return error::kInvalidArguments;
    210   }
    211 
    212   return error::kNoError;
    213 }
    214 
    215 error::Error CommonDecoder::HandleSetBucketDataImmediate(
    216     uint32 immediate_data_size,
    217     const cmd::SetBucketDataImmediate& args) {
    218   const void* data = GetImmediateDataAs<const void*>(args);
    219   uint32 bucket_id = args.bucket_id;
    220   uint32 offset = args.offset;
    221   uint32 size = args.size;
    222   if (size > immediate_data_size) {
    223     return error::kInvalidArguments;
    224   }
    225   Bucket* bucket = GetBucket(bucket_id);
    226   if (!bucket) {
    227     return error::kInvalidArguments;
    228   }
    229   if (!bucket->SetData(data, offset, size)) {
    230     return error::kInvalidArguments;
    231   }
    232   return error::kNoError;
    233 }
    234 
    235 error::Error CommonDecoder::HandleGetBucketStart(
    236     uint32 immediate_data_size,
    237     const cmd::GetBucketStart& args) {
    238   uint32 bucket_id = args.bucket_id;
    239   uint32* result = GetSharedMemoryAs<uint32*>(
    240       args.result_memory_id, args.result_memory_offset, sizeof(*result));
    241   int32 data_memory_id = args.data_memory_id;
    242   uint32 data_memory_offset = args.data_memory_offset;
    243   uint32 data_memory_size = args.data_memory_size;
    244   uint8* data = NULL;
    245   if (data_memory_size != 0 || data_memory_id != 0 || data_memory_offset != 0) {
    246     data = GetSharedMemoryAs<uint8*>(
    247         args.data_memory_id, args.data_memory_offset, args.data_memory_size);
    248     if (!data) {
    249       return error::kInvalidArguments;
    250     }
    251   }
    252   if (!result) {
    253     return error::kInvalidArguments;
    254   }
    255   // Check that the client initialized the result.
    256   if (*result != 0) {
    257     return error::kInvalidArguments;
    258   }
    259   Bucket* bucket = GetBucket(bucket_id);
    260   if (!bucket) {
    261     return error::kInvalidArguments;
    262   }
    263   uint32 bucket_size = bucket->size();
    264   *result = bucket_size;
    265   if (data) {
    266     uint32 size = std::min(data_memory_size, bucket_size);
    267     memcpy(data, bucket->GetData(0, size), size);
    268   }
    269   return error::kNoError;
    270 }
    271 
    272 error::Error CommonDecoder::HandleGetBucketData(
    273     uint32 immediate_data_size,
    274     const cmd::GetBucketData& args) {
    275   uint32 bucket_id = args.bucket_id;
    276   uint32 offset = args.offset;
    277   uint32 size = args.size;
    278   void* data = GetSharedMemoryAs<void*>(
    279       args.shared_memory_id, args.shared_memory_offset, size);
    280   if (!data) {
    281     return error::kInvalidArguments;
    282   }
    283   Bucket* bucket = GetBucket(bucket_id);
    284   if (!bucket) {
    285     return error::kInvalidArguments;
    286   }
    287   const void* src = bucket->GetData(offset, size);
    288   if (!src) {
    289       return error::kInvalidArguments;
    290   }
    291   memcpy(data, src, size);
    292   return error::kNoError;
    293 }
    294 
    295 }  // namespace gpu
    296