blob: fab4770b7f64c7541085e2447d14b461d58b57c1 [file] [log] [blame]
#define LOG_TAG "ServiceFramework"
#include "pdx/service.h"
#include <fcntl.h>
#include <log/log.h>
#include <utils/misc.h>
#include <algorithm>
#include <cstdint>
#include <pdx/trace.h>
#define TRACE 0
namespace android {
namespace pdx {
std::shared_ptr<Channel> Channel::GetFromMessageInfo(const MessageInfo& info) {
return info.channel ? info.channel->shared_from_this()
: std::shared_ptr<Channel>();
}
Message::Message() : replied_(true) {}
Message::Message(const MessageInfo& info)
: service_{Service::GetFromMessageInfo(info)},
channel_{Channel::GetFromMessageInfo(info)},
info_{info},
replied_{IsImpulse()} {
auto svc = service_.lock();
if (svc)
state_ = svc->endpoint()->AllocateMessageState();
}
// C++11 specifies the move semantics for shared_ptr but not weak_ptr. This
// means we have to manually implement the desired move semantics for Message.
Message::Message(Message&& other) { *this = std::move(other); }
Message& Message::operator=(Message&& other) {
Destroy();
auto base = reinterpret_cast<std::uint8_t*>(&info_);
std::fill(&base[0], &base[sizeof(info_)], 0);
replied_ = true;
std::swap(service_, other.service_);
std::swap(channel_, other.channel_);
std::swap(info_, other.info_);
std::swap(state_, other.state_);
std::swap(replied_, other.replied_);
return *this;
}
Message::~Message() { Destroy(); }
void Message::Destroy() {
auto svc = service_.lock();
if (svc) {
if (!replied_) {
ALOGE(
"ERROR: Service \"%s\" failed to reply to message: op=%d pid=%d "
"cid=%d\n",
svc->name_.c_str(), info_.op, info_.pid, info_.cid);
svc->DefaultHandleMessage(*this);
}
svc->endpoint()->FreeMessageState(state_);
}
state_ = nullptr;
service_.reset();
channel_.reset();
}
const std::uint8_t* Message::ImpulseBegin() const {
return reinterpret_cast<const std::uint8_t*>(info_.impulse);
}
const std::uint8_t* Message::ImpulseEnd() const {
return ImpulseBegin() + (IsImpulse() ? GetSendLength() : 0);
}
Status<size_t> Message::ReadVector(const struct iovec* vector,
size_t vector_length) {
PDX_TRACE_NAME("Message::ReadVector");
if (auto svc = service_.lock()) {
return svc->endpoint()->ReadMessageData(this, vector, vector_length);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<void> Message::ReadVectorAll(const struct iovec* vector,
size_t vector_length) {
PDX_TRACE_NAME("Message::ReadVectorAll");
if (auto svc = service_.lock()) {
const auto status =
svc->endpoint()->ReadMessageData(this, vector, vector_length);
if (!status)
return status.error_status();
size_t size_to_read = 0;
for (size_t i = 0; i < vector_length; i++)
size_to_read += vector[i].iov_len;
if (status.get() < size_to_read)
return ErrorStatus{EIO};
return {};
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<size_t> Message::Read(void* buffer, size_t length) {
PDX_TRACE_NAME("Message::Read");
if (auto svc = service_.lock()) {
const struct iovec vector = {buffer, length};
return svc->endpoint()->ReadMessageData(this, &vector, 1);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<size_t> Message::WriteVector(const struct iovec* vector,
size_t vector_length) {
PDX_TRACE_NAME("Message::WriteVector");
if (auto svc = service_.lock()) {
return svc->endpoint()->WriteMessageData(this, vector, vector_length);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<void> Message::WriteVectorAll(const struct iovec* vector,
size_t vector_length) {
PDX_TRACE_NAME("Message::WriteVector");
if (auto svc = service_.lock()) {
const auto status =
svc->endpoint()->WriteMessageData(this, vector, vector_length);
if (!status)
return status.error_status();
size_t size_to_write = 0;
for (size_t i = 0; i < vector_length; i++)
size_to_write += vector[i].iov_len;
if (status.get() < size_to_write)
return ErrorStatus{EIO};
return {};
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<size_t> Message::Write(const void* buffer, size_t length) {
PDX_TRACE_NAME("Message::Write");
if (auto svc = service_.lock()) {
const struct iovec vector = {const_cast<void*>(buffer), length};
return svc->endpoint()->WriteMessageData(this, &vector, 1);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<FileReference> Message::PushFileHandle(const LocalHandle& handle) {
PDX_TRACE_NAME("Message::PushFileHandle");
if (auto svc = service_.lock()) {
return svc->endpoint()->PushFileHandle(this, handle);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<FileReference> Message::PushFileHandle(const BorrowedHandle& handle) {
PDX_TRACE_NAME("Message::PushFileHandle");
if (auto svc = service_.lock()) {
return svc->endpoint()->PushFileHandle(this, handle);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<FileReference> Message::PushFileHandle(const RemoteHandle& handle) {
PDX_TRACE_NAME("Message::PushFileHandle");
if (auto svc = service_.lock()) {
return svc->endpoint()->PushFileHandle(this, handle);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<ChannelReference> Message::PushChannelHandle(
const LocalChannelHandle& handle) {
PDX_TRACE_NAME("Message::PushChannelHandle");
if (auto svc = service_.lock()) {
return svc->endpoint()->PushChannelHandle(this, handle);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<ChannelReference> Message::PushChannelHandle(
const BorrowedChannelHandle& handle) {
PDX_TRACE_NAME("Message::PushChannelHandle");
if (auto svc = service_.lock()) {
return svc->endpoint()->PushChannelHandle(this, handle);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<ChannelReference> Message::PushChannelHandle(
const RemoteChannelHandle& handle) {
PDX_TRACE_NAME("Message::PushChannelHandle");
if (auto svc = service_.lock()) {
return svc->endpoint()->PushChannelHandle(this, handle);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
bool Message::GetFileHandle(FileReference ref, LocalHandle* handle) {
PDX_TRACE_NAME("Message::GetFileHandle");
auto svc = service_.lock();
if (!svc)
return false;
if (ref >= 0) {
*handle = svc->endpoint()->GetFileHandle(this, ref);
if (!handle->IsValid())
return false;
} else {
*handle = LocalHandle{ref};
}
return true;
}
bool Message::GetChannelHandle(ChannelReference ref,
LocalChannelHandle* handle) {
PDX_TRACE_NAME("Message::GetChannelHandle");
auto svc = service_.lock();
if (!svc)
return false;
if (ref >= 0) {
*handle = svc->endpoint()->GetChannelHandle(this, ref);
if (!handle->valid())
return false;
} else {
*handle = LocalChannelHandle{nullptr, ref};
}
return true;
}
Status<void> Message::Reply(int return_code) {
PDX_TRACE_NAME("Message::Reply");
auto svc = service_.lock();
if (!replied_ && svc) {
const auto ret = svc->endpoint()->MessageReply(this, return_code);
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::ReplyFileDescriptor(unsigned int fd) {
PDX_TRACE_NAME("Message::ReplyFileDescriptor");
auto svc = service_.lock();
if (!replied_ && svc) {
const auto ret = svc->endpoint()->MessageReplyFd(this, fd);
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::ReplyError(unsigned int error) {
PDX_TRACE_NAME("Message::ReplyError");
auto svc = service_.lock();
if (!replied_ && svc) {
const auto ret =
svc->endpoint()->MessageReply(this, -static_cast<int>(error));
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::Reply(const LocalHandle& handle) {
PDX_TRACE_NAME("Message::ReplyFileHandle");
auto svc = service_.lock();
if (!replied_ && svc) {
Status<void> ret;
if (handle)
ret = svc->endpoint()->MessageReplyFd(this, handle.Get());
else
ret = svc->endpoint()->MessageReply(this, handle.Get());
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::Reply(const BorrowedHandle& handle) {
PDX_TRACE_NAME("Message::ReplyFileHandle");
auto svc = service_.lock();
if (!replied_ && svc) {
Status<void> ret;
if (handle)
ret = svc->endpoint()->MessageReplyFd(this, handle.Get());
else
ret = svc->endpoint()->MessageReply(this, handle.Get());
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::Reply(const RemoteHandle& handle) {
PDX_TRACE_NAME("Message::ReplyFileHandle");
auto svc = service_.lock();
if (!replied_ && svc) {
Status<void> ret;
if (handle)
ret = svc->endpoint()->MessageReply(this, handle.Get());
else
ret = svc->endpoint()->MessageReply(this, handle.Get());
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::Reply(const LocalChannelHandle& handle) {
auto svc = service_.lock();
if (!replied_ && svc) {
const auto ret = svc->endpoint()->MessageReplyChannelHandle(this, handle);
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::Reply(const BorrowedChannelHandle& handle) {
auto svc = service_.lock();
if (!replied_ && svc) {
const auto ret = svc->endpoint()->MessageReplyChannelHandle(this, handle);
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::Reply(const RemoteChannelHandle& handle) {
auto svc = service_.lock();
if (!replied_ && svc) {
const auto ret = svc->endpoint()->MessageReplyChannelHandle(this, handle);
replied_ = ret.ok();
return ret;
} else {
return ErrorStatus{EINVAL};
}
}
Status<void> Message::ModifyChannelEvents(int clear_mask, int set_mask) {
PDX_TRACE_NAME("Message::ModifyChannelEvents");
if (auto svc = service_.lock()) {
return svc->endpoint()->ModifyChannelEvents(info_.cid, clear_mask,
set_mask);
} else {
return ErrorStatus{ESHUTDOWN};
}
}
Status<RemoteChannelHandle> Message::PushChannel(
int flags, const std::shared_ptr<Channel>& channel, int* channel_id) {
PDX_TRACE_NAME("Message::PushChannel");
if (auto svc = service_.lock()) {
return svc->PushChannel(this, flags, channel, channel_id);
} else {
return ErrorStatus(ESHUTDOWN);
}
}
Status<RemoteChannelHandle> Message::PushChannel(
Service* service, int flags, const std::shared_ptr<Channel>& channel,
int* channel_id) {
PDX_TRACE_NAME("Message::PushChannel");
return service->PushChannel(this, flags, channel, channel_id);
}
Status<int> Message::CheckChannel(ChannelReference ref,
std::shared_ptr<Channel>* channel) const {
PDX_TRACE_NAME("Message::CheckChannel");
if (auto svc = service_.lock()) {
return svc->CheckChannel(this, ref, channel);
} else {
return ErrorStatus(ESHUTDOWN);
}
}
Status<int> Message::CheckChannel(const Service* service, ChannelReference ref,
std::shared_ptr<Channel>* channel) const {
PDX_TRACE_NAME("Message::CheckChannel");
return service->CheckChannel(this, ref, channel);
}
pid_t Message::GetProcessId() const { return info_.pid; }
pid_t Message::GetThreadId() const { return info_.tid; }
uid_t Message::GetEffectiveUserId() const { return info_.euid; }
gid_t Message::GetEffectiveGroupId() const { return info_.egid; }
int Message::GetChannelId() const { return info_.cid; }
int Message::GetMessageId() const { return info_.mid; }
int Message::GetOp() const { return info_.op; }
int Message::GetFlags() const { return info_.flags; }
size_t Message::GetSendLength() const { return info_.send_len; }
size_t Message::GetReceiveLength() const { return info_.recv_len; }
size_t Message::GetFileDescriptorCount() const { return info_.fd_count; }
std::shared_ptr<Channel> Message::GetChannel() const { return channel_.lock(); }
Status<void> Message::SetChannel(const std::shared_ptr<Channel>& chan) {
channel_ = chan;
Status<void> status;
if (auto svc = service_.lock())
status = svc->SetChannel(info_.cid, chan);
return status;
}
std::shared_ptr<Service> Message::GetService() const { return service_.lock(); }
const MessageInfo& Message::GetInfo() const { return info_; }
Service::Service(const std::string& name, std::unique_ptr<Endpoint> endpoint)
: name_(name), endpoint_{std::move(endpoint)} {
if (!endpoint_)
return;
const auto status = endpoint_->SetService(this);
ALOGE_IF(!status, "Failed to set service context because: %s",
status.GetErrorMessage().c_str());
}
Service::~Service() {
if (endpoint_) {
const auto status = endpoint_->SetService(nullptr);
ALOGE_IF(!status, "Failed to clear service context because: %s",
status.GetErrorMessage().c_str());
}
}
std::shared_ptr<Service> Service::GetFromMessageInfo(const MessageInfo& info) {
return info.service ? info.service->shared_from_this()
: std::shared_ptr<Service>();
}
bool Service::IsInitialized() const { return endpoint_.get() != nullptr; }
std::shared_ptr<Channel> Service::OnChannelOpen(Message& /*message*/) {
return nullptr;
}
void Service::OnChannelClose(Message& /*message*/,
const std::shared_ptr<Channel>& /*channel*/) {}
Status<void> Service::SetChannel(int channel_id,
const std::shared_ptr<Channel>& channel) {
PDX_TRACE_NAME("Service::SetChannel");
std::lock_guard<std::mutex> autolock(channels_mutex_);
const auto status = endpoint_->SetChannel(channel_id, channel.get());
if (!status) {
ALOGE("%s::SetChannel: Failed to set channel context: %s\n", name_.c_str(),
status.GetErrorMessage().c_str());
// It's possible someone mucked with things behind our back by calling the C
// API directly. Since we know the channel id isn't valid, make sure we
// don't have it in the channels map.
if (status.error() == ENOENT)
channels_.erase(channel_id);
} else {
if (channel != nullptr)
channels_[channel_id] = channel;
else
channels_.erase(channel_id);
}
return status;
}
std::shared_ptr<Channel> Service::GetChannel(int channel_id) const {
PDX_TRACE_NAME("Service::GetChannel");
std::lock_guard<std::mutex> autolock(channels_mutex_);
auto search = channels_.find(channel_id);
if (search != channels_.end())
return search->second;
else
return nullptr;
}
Status<void> Service::CloseChannel(int channel_id) {
PDX_TRACE_NAME("Service::CloseChannel");
std::lock_guard<std::mutex> autolock(channels_mutex_);
const auto status = endpoint_->CloseChannel(channel_id);
// Always erase the map entry, in case someone mucked with things behind our
// back using the C API directly.
channels_.erase(channel_id);
return status;
}
Status<void> Service::ModifyChannelEvents(int channel_id, int clear_mask,
int set_mask) {
PDX_TRACE_NAME("Service::ModifyChannelEvents");
return endpoint_->ModifyChannelEvents(channel_id, clear_mask, set_mask);
}
Status<RemoteChannelHandle> Service::PushChannel(
Message* message, int flags, const std::shared_ptr<Channel>& channel,
int* channel_id) {
PDX_TRACE_NAME("Service::PushChannel");
std::lock_guard<std::mutex> autolock(channels_mutex_);
int channel_id_temp = -1;
Status<RemoteChannelHandle> ret =
endpoint_->PushChannel(message, flags, channel.get(), &channel_id_temp);
ALOGE_IF(!ret.ok(), "%s::PushChannel: Failed to push channel: %s",
name_.c_str(), strerror(ret.error()));
if (channel && channel_id_temp != -1)
channels_[channel_id_temp] = channel;
if (channel_id)
*channel_id = channel_id_temp;
return ret;
}
Status<int> Service::CheckChannel(const Message* message, ChannelReference ref,
std::shared_ptr<Channel>* channel) const {
PDX_TRACE_NAME("Service::CheckChannel");
// Synchronization to maintain consistency between the kernel's channel
// context pointer and the userspace channels_ map. Other threads may attempt
// to modify the map at the same time, which could cause the channel context
// pointer returned by the kernel to be invalid.
std::lock_guard<std::mutex> autolock(channels_mutex_);
Channel* channel_context = nullptr;
Status<int> ret = endpoint_->CheckChannel(
message, ref, channel ? &channel_context : nullptr);
if (ret && channel) {
if (channel_context)
*channel = channel_context->shared_from_this();
else
*channel = nullptr;
}
return ret;
}
std::string Service::DumpState(size_t /*max_length*/) { return ""; }
Status<void> Service::HandleMessage(Message& message) {
return DefaultHandleMessage(message);
}
void Service::HandleImpulse(Message& /*impulse*/) {}
Status<void> Service::HandleSystemMessage(Message& message) {
const MessageInfo& info = message.GetInfo();
switch (info.op) {
case opcodes::CHANNEL_OPEN: {
ALOGD("%s::OnChannelOpen: pid=%d cid=%d\n", name_.c_str(), info.pid,
info.cid);
message.SetChannel(OnChannelOpen(message));
return message.Reply(0);
}
case opcodes::CHANNEL_CLOSE: {
ALOGD("%s::OnChannelClose: pid=%d cid=%d\n", name_.c_str(), info.pid,
info.cid);
OnChannelClose(message, Channel::GetFromMessageInfo(info));
message.SetChannel(nullptr);
return message.Reply(0);
}
case opcodes::REPORT_SYSPROP_CHANGE:
ALOGD("%s:REPORT_SYSPROP_CHANGE: pid=%d cid=%d\n", name_.c_str(),
info.pid, info.cid);
OnSysPropChange();
android::report_sysprop_change();
return message.Reply(0);
case opcodes::DUMP_STATE: {
ALOGD("%s:DUMP_STATE: pid=%d cid=%d\n", name_.c_str(), info.pid,
info.cid);
auto response = DumpState(message.GetReceiveLength());
const size_t response_size = response.size() < message.GetReceiveLength()
? response.size()
: message.GetReceiveLength();
const Status<size_t> status =
message.Write(response.data(), response_size);
if (status && status.get() < response_size)
return message.ReplyError(EIO);
else
return message.Reply(status);
}
default:
return ErrorStatus{EOPNOTSUPP};
}
}
Status<void> Service::DefaultHandleMessage(Message& message) {
const MessageInfo& info = message.GetInfo();
ALOGD_IF(TRACE, "Service::DefaultHandleMessage: pid=%d cid=%d op=%d\n",
info.pid, info.cid, info.op);
switch (info.op) {
case opcodes::CHANNEL_OPEN:
case opcodes::CHANNEL_CLOSE:
case opcodes::REPORT_SYSPROP_CHANGE:
case opcodes::DUMP_STATE:
return HandleSystemMessage(message);
default:
return message.ReplyError(EOPNOTSUPP);
}
}
void Service::OnSysPropChange() {}
Status<void> Service::ReceiveAndDispatch() {
Message message;
const auto status = endpoint_->MessageReceive(&message);
if (!status) {
ALOGE("Failed to receive message: %s\n", status.GetErrorMessage().c_str());
return status;
}
std::shared_ptr<Service> service = message.GetService();
if (!service) {
ALOGE("Service::ReceiveAndDispatch: service context is NULL!!!\n");
// Don't block the sender indefinitely in this error case.
endpoint_->MessageReply(&message, -EINVAL);
return ErrorStatus{EINVAL};
}
if (message.IsImpulse()) {
service->HandleImpulse(message);
return {};
} else if (service->HandleSystemMessage(message)) {
return {};
} else {
return service->HandleMessage(message);
}
}
Status<void> Service::Cancel() { return endpoint_->Cancel(); }
} // namespace pdx
} // namespace android