| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #define LOG_TAG "VehicleNetwork" |
| |
| #include <binder/PermissionCache.h> |
| #include <utils/Errors.h> |
| #include <utils/SystemClock.h> |
| |
| #include <private/android_filesystem_config.h> |
| |
| #include <vehicle-internal.h> |
| |
| #include "VehicleHalPropertyUtil.h" |
| #include "VehicleNetworkService.h" |
| |
| //#define DBG_EVENT |
| //#define DBG_VERBOSE |
| #ifdef DBG_EVENT |
| #define EVENT_LOG(x...) ALOGD(x) |
| #else |
| #define EVENT_LOG(x...) |
| #endif |
| #ifdef DBG_VERBOSE |
| #define LOG_VERBOSE(x...) ALOGD(x) |
| #else |
| #define LOG_VERBOSE(x...) |
| #endif |
| |
| namespace android { |
| |
| VehicleHalMessageHandler::VehicleHalMessageHandler(const sp<Looper>& looper, |
| VehicleNetworkService& service) |
| : mLooper(looper), |
| mService(service), |
| mFreeListIndex(0), |
| mLastDispatchTime(0) { |
| } |
| |
| VehicleHalMessageHandler::~VehicleHalMessageHandler() { |
| Mutex::Autolock autoLock(mLock); |
| for (int i = 0; i < NUM_PROPERTY_EVENT_LISTS; i++) { |
| for (auto& e : mHalPropertyList[i]) { |
| VehiclePropValueUtil::deleteMembers(e); |
| delete e; |
| } |
| } |
| for (VehicleHalError* e : mHalErrors) { |
| delete e; |
| } |
| } |
| |
| static const int MS_TO_NS = 1000000; |
| |
| void VehicleHalMessageHandler::handleHalEvent(vehicle_prop_value_t *eventData) { |
| EVENT_LOG("handleHalEvent 0x%x", eventData->prop); |
| Mutex::Autolock autoLock(mLock); |
| List<vehicle_prop_value_t*>& propList = mHalPropertyList[mFreeListIndex]; |
| propList.push_back(eventData); |
| int64_t deltaFromLast = elapsedRealtime() - mLastDispatchTime; |
| if (deltaFromLast > DISPATCH_INTERVAL_MS) { |
| mLooper->sendMessage(this, Message(HAL_EVENT)); |
| } else { |
| mLooper->sendMessageDelayed((DISPATCH_INTERVAL_MS - deltaFromLast) * MS_TO_NS, |
| this, Message(HAL_EVENT)); |
| } |
| } |
| |
| void VehicleHalMessageHandler::handleHalError(VehicleHalError* error) { |
| Mutex::Autolock autoLock(mLock); |
| mHalErrors.push_back(error); |
| mLooper->sendMessage(this, Message(HAL_ERROR)); |
| } |
| |
| void VehicleHalMessageHandler::handleMockStart() { |
| Mutex::Autolock autoLock(mLock); |
| mHalPropertyList[0].clear(); |
| mHalPropertyList[1].clear(); |
| sp<MessageHandler> self(this); |
| mLooper->removeMessages(self); |
| } |
| |
| void VehicleHalMessageHandler::doHandleHalEvent() { |
| // event dispatching can take time, so do it outside lock and that requires double buffering. |
| // inside lock, free buffer is swapped with non-free buffer. |
| List<vehicle_prop_value_t*>* events = NULL; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| mLastDispatchTime = elapsedRealtime(); |
| int nonFreeListIndex = mFreeListIndex ^ 0x1; |
| List<vehicle_prop_value_t*>* nonFreeList = &(mHalPropertyList[nonFreeListIndex]); |
| List<vehicle_prop_value_t*>* freeList = &(mHalPropertyList[mFreeListIndex]); |
| if (nonFreeList->size() > 0) { |
| for (auto& e : *freeList) { |
| nonFreeList->push_back(e); |
| } |
| freeList->clear(); |
| events = nonFreeList; |
| } else if (freeList->size() > 0) { |
| events = freeList; |
| mFreeListIndex = nonFreeListIndex; |
| } |
| } while (false); |
| if (events != NULL) { |
| EVENT_LOG("doHandleHalEvent, num events:%d", events->size()); |
| mService.dispatchHalEvents(*events); |
| //TODO implement return to memory pool |
| for (auto& e : *events) { |
| VehiclePropValueUtil::deleteMembers(e); |
| delete e; |
| } |
| events->clear(); |
| } |
| } |
| |
| void VehicleHalMessageHandler::doHandleHalError() { |
| VehicleHalError* error = NULL; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (mHalErrors.size() > 0) { |
| auto itr = mHalErrors.begin(); |
| error = *itr; |
| mHalErrors.erase(itr); |
| } |
| } while (false); |
| if (error != NULL) { |
| mService.dispatchHalError(error); |
| } |
| } |
| |
| void VehicleHalMessageHandler::handleMessage(const Message& message) { |
| switch (message.what) { |
| case HAL_EVENT: |
| doHandleHalEvent(); |
| break; |
| case HAL_ERROR: |
| doHandleHalError(); |
| break; |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| void MockDeathHandler::binderDied(const wp<IBinder>& who) { |
| mService.handleHalMockDeath(who); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| PropertyValueCache::PropertyValueCache() { |
| |
| } |
| |
| PropertyValueCache::~PropertyValueCache() { |
| for (size_t i = 0; i < mCache.size(); i++) { |
| vehicle_prop_value_t* v = mCache.editValueAt(i); |
| VehiclePropValueUtil::deleteMembers(v); |
| delete v; |
| } |
| mCache.clear(); |
| } |
| |
| void PropertyValueCache::writeToCache(const vehicle_prop_value_t& value) { |
| vehicle_prop_value_t* v; |
| ssize_t index = mCache.indexOfKey(value.prop); |
| if (index < 0) { |
| v = VehiclePropValueUtil::allocVehicleProp(value); |
| ASSERT_OR_HANDLE_NO_MEMORY(v, return); |
| mCache.add(value.prop, v); |
| } else { |
| v = mCache.editValueAt(index); |
| VehiclePropValueUtil::copyVehicleProp(v, value, true /* deleteOldData */); |
| } |
| } |
| |
| bool PropertyValueCache::readFromCache(vehicle_prop_value_t* value) { |
| ssize_t index = mCache.indexOfKey(value->prop); |
| if (index < 0) { |
| ALOGE("readFromCache 0x%x, not found", value->prop); |
| return false; |
| } |
| const vehicle_prop_value_t* cached = mCache.valueAt(index); |
| //TODO this can be improved by just passing pointer and not deleting members. |
| status_t r = VehiclePropValueUtil::copyVehicleProp(value, *cached); |
| if (r != NO_ERROR) { |
| ALOGD("readFromCache 0x%x, copy failed %d", value->prop, r); |
| return false; |
| } |
| return true; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| |
| VehicleNetworkService* VehicleNetworkService::sInstance = NULL; |
| |
| status_t VehicleNetworkService::dump(int fd, const Vector<String16>& /*args*/) { |
| static const String16 sDump("android.permission.DUMP"); |
| String8 msg; |
| if (!PermissionCache::checkCallingPermission(sDump)) { |
| msg.appendFormat("Permission Denial: " |
| "can't dump VNS from pid=%d, uid=%d\n", |
| IPCThreadState::self()->getCallingPid(), |
| IPCThreadState::self()->getCallingUid()); |
| write(fd, msg.string(), msg.size()); |
| return NO_ERROR; |
| } |
| msg.append("MockingEnabled=%d\n", mMockingEnabled ? 1 : 0); |
| msg.append("*Properties\n"); |
| for (auto& prop : mProperties->getList()) { |
| VechilePropertyUtil::dumpProperty(msg, *prop); |
| } |
| if (mMockingEnabled) { |
| msg.append("*Mocked Properties\n"); |
| for (auto& prop : mPropertiesForMocking->getList()) { |
| //TODO dump more info |
| msg.appendFormat("property 0x%x\n", prop->prop); |
| } |
| } |
| msg.append("*Active clients*\n"); |
| for (size_t i = 0; i < mBinderToClientMap.size(); i++) { |
| msg.appendFormat("pid %d uid %d\n", mBinderToClientMap.valueAt(i)->getPid(), |
| mBinderToClientMap.valueAt(i)->getUid()); |
| } |
| msg.append("*Active clients per property*\n"); |
| for (size_t i = 0; i < mPropertyToClientsMap.size(); i++) { |
| msg.appendFormat("prop 0x%x, pids:", mPropertyToClientsMap.keyAt(i)); |
| sp<HalClientSpVector> clients = mPropertyToClientsMap.valueAt(i); |
| for (size_t j = 0; j < clients->size(); j++) { |
| msg.appendFormat("%d,", clients->itemAt(j)->getPid()); |
| } |
| msg.append("\n"); |
| } |
| msg.append("*Subscription info per property*\n"); |
| for (size_t i = 0; i < mSubscriptionInfos.size(); i++) { |
| const SubscriptionInfo& info = mSubscriptionInfos.valueAt(i); |
| msg.appendFormat("prop 0x%x, sample rate %f Hz, zones 0x%x\n", mSubscriptionInfos.keyAt(i), |
| info.sampleRate, info.zones); |
| } |
| msg.append("*Event counts per property*\n"); |
| for (size_t i = 0; i < mEventsCount.size(); i++) { |
| msg.appendFormat("prop 0x%x: %d\n", mEventsCount.keyAt(i), |
| mEventsCount.valueAt(i)); |
| } |
| msg.append("*Vehicle Network Service Permissions*\n"); |
| mVehiclePropertyAccessControl.dump(msg); |
| |
| write(fd, msg.string(), msg.size()); |
| return NO_ERROR; |
| } |
| |
| bool VehicleNetworkService::isOperationAllowed(int32_t property, bool isWrite) { |
| const uid_t uid = IPCThreadState::self()->getCallingUid(); |
| |
| bool allowed = mVehiclePropertyAccessControl.testAccess(property, uid, isWrite); |
| if (!allowed) { |
| ALOGW("Property 0x%x: access not allowed for uid %d, isWrite %d", property, uid, isWrite); |
| } |
| return allowed; |
| } |
| |
| VehicleNetworkService::VehicleNetworkService() |
| : mModule(NULL), |
| mMockingEnabled(false) { |
| sInstance = this; |
| |
| // Load vehicle network services policy file |
| if(!mVehiclePropertyAccessControl.init()) { |
| LOG_ALWAYS_FATAL("Vehicle property access policy could not be initialized."); |
| } |
| } |
| |
| VehicleNetworkService::~VehicleNetworkService() { |
| sInstance = NULL; |
| for (size_t i = 0; i < mPropertyToClientsMap.size(); i++) { |
| sp<HalClientSpVector> clients = mPropertyToClientsMap.editValueAt(i); |
| clients->clear(); |
| } |
| mBinderToClientMap.clear(); |
| mPropertyToClientsMap.clear(); |
| mSubscriptionInfos.clear(); |
| } |
| |
| void VehicleNetworkService::binderDied(const wp<IBinder>& who) { |
| List<int32_t> propertiesToUnsubscribe; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| sp<IBinder> ibinder = who.promote(); |
| ibinder->unlinkToDeath(this); |
| ssize_t index = mBinderToClientMap.indexOfKey(ibinder); |
| if (index < 0) { |
| // already removed. ignore |
| return; |
| } |
| sp<HalClient> currentClient = mBinderToClientMap.editValueAt(index); |
| ALOGW("client binder death, pid: %d, uid:%d", currentClient->getPid(), |
| currentClient->getUid()); |
| mBinderToClientMap.removeItemsAt(index); |
| |
| for (size_t i = 0; i < mPropertyToClientsMap.size(); i++) { |
| sp<HalClientSpVector>& clients = mPropertyToClientsMap.editValueAt(i); |
| clients->remove(currentClient); |
| // TODO update frame rate |
| if (clients->size() == 0) { |
| int32_t property = mPropertyToClientsMap.keyAt(i); |
| propertiesToUnsubscribe.push_back(property); |
| mSubscriptionInfos.removeItem(property); |
| } |
| } |
| for (int32_t property : propertiesToUnsubscribe) { |
| mPropertyToClientsMap.removeItem(property); |
| } |
| } while (false); |
| for (int32_t property : propertiesToUnsubscribe) { |
| mDevice->unsubscribe(mDevice, property); |
| } |
| } |
| |
| void VehicleNetworkService::handleHalMockDeath(const wp<IBinder>& who) { |
| ALOGE("Hal mock binder died"); |
| sp<IBinder> ibinder = who.promote(); |
| stopMocking(IVehicleNetworkHalMock::asInterface(ibinder)); |
| } |
| |
| int VehicleNetworkService::eventCallback(const vehicle_prop_value_t *eventData) { |
| EVENT_LOG("eventCallback 0x%x"); |
| sInstance->onHalEvent(eventData); |
| return NO_ERROR; |
| } |
| |
| int VehicleNetworkService::errorCallback(int32_t errorCode, int32_t property, int32_t operation) { |
| status_t r = sInstance->onHalError(errorCode, property, operation); |
| if (r != NO_ERROR) { |
| ALOGE("VehicleNetworkService::errorCallback onHalError failed with %d", r); |
| } |
| return NO_ERROR; |
| } |
| |
| extern "C" { |
| vehicle_prop_config_t const * getInternalProperties(); |
| int getNumInternalProperties(); |
| }; |
| |
| void VehicleNetworkService::onFirstRef() { |
| Mutex::Autolock autoLock(mLock); |
| status_t r = loadHal(); |
| if (r!= NO_ERROR) { |
| ALOGE("cannot load HAL, error:%d", r); |
| return; |
| } |
| mHandlerThread = new HandlerThread(); |
| r = mHandlerThread->start("HAL.NATIVE_LOOP"); |
| if (r != NO_ERROR) { |
| ALOGE("cannot start handler thread, error:%d", r); |
| return; |
| } |
| sp<VehicleHalMessageHandler> handler(new VehicleHalMessageHandler(mHandlerThread->getLooper(), |
| *this)); |
| ASSERT_ALWAYS_ON_NO_MEMORY(handler.get()); |
| mHandler = handler; |
| r = mDevice->init(mDevice, eventCallback, errorCallback); |
| if (r != NO_ERROR) { |
| ALOGE("HAL init failed:%d", r); |
| return; |
| } |
| int numConfigs = 0; |
| vehicle_prop_config_t const* configs = mDevice->list_properties(mDevice, &numConfigs); |
| mProperties = new VehiclePropertiesHolder(false /* deleteConfigsInDestructor */); |
| ASSERT_ALWAYS_ON_NO_MEMORY(mProperties); |
| for (int i = 0; i < numConfigs; i++) { |
| mProperties->getList().push_back(&configs[i]); |
| } |
| configs = getInternalProperties(); |
| for (int i = 0; i < getNumInternalProperties(); i++) { |
| mProperties->getList().push_back(&configs[i]); |
| } |
| } |
| |
| void VehicleNetworkService::release() { |
| do { |
| Mutex::Autolock autoLock(mLock); |
| mHandlerThread->quit(); |
| } while (false); |
| mDevice->release(mDevice); |
| } |
| |
| vehicle_prop_config_t const * VehicleNetworkService::findConfigLocked(int32_t property) { |
| for (auto& config : (mMockingEnabled ? |
| mPropertiesForMocking->getList() : mProperties->getList())) { |
| if (config->prop == property) { |
| return config; |
| } |
| } |
| ALOGW("property not found 0x%x", property); |
| return NULL; |
| } |
| |
| bool VehicleNetworkService::isGettableLocked(int32_t property) { |
| vehicle_prop_config_t const * config = findConfigLocked(property); |
| if (config == NULL) { |
| return false; |
| } |
| if ((config->access & VEHICLE_PROP_ACCESS_READ) == 0) { |
| ALOGI("cannot get, property 0x%x is write only", property); |
| return false; |
| } |
| return true; |
| } |
| |
| bool VehicleNetworkService::isSettableLocked(int32_t property, int32_t valueType) { |
| vehicle_prop_config_t const * config = findConfigLocked(property); |
| if (config == NULL) { |
| return false; |
| } |
| if ((config->access & VEHICLE_PROP_ACCESS_WRITE) == 0) { |
| ALOGI("cannot set, property 0x%x is read only", property); |
| return false; |
| } |
| if (config->value_type != valueType) { |
| ALOGW("cannot set, property 0x%x expects type 0x%x while got 0x%x", property, |
| config->value_type, valueType); |
| return false; |
| } |
| return true; |
| } |
| |
| bool VehicleNetworkService::isSubscribableLocked(int32_t property) { |
| vehicle_prop_config_t const * config = findConfigLocked(property); |
| if (config == NULL) { |
| return false; |
| } |
| if ((config->access & VEHICLE_PROP_ACCESS_READ) == 0) { |
| ALOGI("cannot subscribe, property 0x%x is write only", property); |
| return false; |
| } |
| if (config->change_mode == VEHICLE_PROP_CHANGE_MODE_STATIC) { |
| ALOGI("cannot subscribe, property 0x%x is static", property); |
| return false; |
| } |
| return true; |
| } |
| |
| bool VehicleNetworkService::isZonedProperty(vehicle_prop_config_t const * config) { |
| if (config == NULL) { |
| return false; |
| } |
| switch (config->value_type) { |
| case VEHICLE_VALUE_TYPE_ZONED_INT32: |
| case VEHICLE_VALUE_TYPE_ZONED_FLOAT: |
| case VEHICLE_VALUE_TYPE_ZONED_BOOLEAN: |
| case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC2: |
| case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC3: |
| case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC2: |
| case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC3: |
| return true; |
| } |
| return false; |
| } |
| |
| sp<VehiclePropertiesHolder> VehicleNetworkService::listProperties(int32_t property) { |
| Mutex::Autolock autoLock(mLock); |
| if (property == 0) { |
| if (!mMockingEnabled) { |
| return mProperties; |
| } else { |
| return mPropertiesForMocking; |
| } |
| } else { |
| sp<VehiclePropertiesHolder> p; |
| const vehicle_prop_config_t* config = findConfigLocked(property); |
| if (config != NULL) { |
| p = new VehiclePropertiesHolder(false /* deleteConfigsInDestructor */); |
| p->getList().push_back(config); |
| ASSERT_OR_HANDLE_NO_MEMORY(p.get(), return p); |
| } |
| return p; |
| } |
| } |
| |
| status_t VehicleNetworkService::getProperty(vehicle_prop_value_t *data) { |
| bool inMocking = false; |
| do { // for lock scoping |
| Mutex::Autolock autoLock(mLock); |
| if (!isGettableLocked(data->prop)) { |
| ALOGW("getProperty, cannot get 0x%x", data->prop); |
| return BAD_VALUE; |
| } |
| if ((data->prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) && |
| (data->prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) { |
| if (!mCache.readFromCache(data)) { |
| return BAD_VALUE; |
| } |
| return NO_ERROR; |
| } |
| //TODO caching for static, on-change type? |
| if (mMockingEnabled) { |
| inMocking = true; |
| } |
| } while (false); |
| // set done outside lock to allow concurrent access |
| if (inMocking) { |
| status_t r = mHalMock->onPropertyGet(data); |
| if (r != NO_ERROR) { |
| ALOGW("getProperty 0x%x failed, mock returned %d", data->prop, r); |
| } |
| return r; |
| } |
| /* |
| * get call can return -EAGAIN error when hal has not fetched all data. In that case, |
| * keep retrying for certain time with some sleep. This will happen only at initial stage. |
| */ |
| status_t r = -EAGAIN; |
| int retryCount = 0; |
| while (true) { |
| r = mDevice->get(mDevice, data); |
| if (r == NO_ERROR) { |
| break; |
| } |
| if (r != -EAGAIN) { |
| break; |
| } |
| retryCount++; |
| if (retryCount > MAX_GET_RETRY_FOR_NOT_READY) { |
| ALOGE("Vehicle hal keep retrying not ready after multiple retries"); |
| break; |
| } |
| usleep(GET_WAIT_US); |
| } |
| if (r != NO_ERROR) { |
| ALOGW("getProperty 0x%x failed, HAL returned %d", data->prop, r); |
| } |
| return r; |
| } |
| |
| void VehicleNetworkService::releaseMemoryFromGet(vehicle_prop_value_t* value) { |
| switch (value->prop) { |
| case VEHICLE_VALUE_TYPE_STRING: |
| case VEHICLE_VALUE_TYPE_BYTES: { |
| Mutex::Autolock autoLock(mLock); |
| mDevice->release_memory_from_get(mDevice, value); |
| } break; |
| } |
| } |
| |
| status_t VehicleNetworkService::setProperty(const vehicle_prop_value_t& data) { |
| bool isInternalProperty = false; |
| bool inMocking = false; |
| do { // for lock scoping |
| Mutex::Autolock autoLock(mLock); |
| if (!isSettableLocked(data.prop, data.value_type)) { |
| ALOGW("setProperty, cannot set 0x%x", data.prop); |
| return BAD_VALUE; |
| } |
| if ((data.prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) && |
| (data.prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) { |
| isInternalProperty = true; |
| mCache.writeToCache(data); |
| } |
| if (mMockingEnabled) { |
| inMocking = true; |
| } |
| } while (false); |
| if (inMocking) { |
| status_t r = mHalMock->onPropertySet(data); |
| if (r != NO_ERROR) { |
| ALOGW("setProperty 0x%x failed, mock returned %d", data.prop, r); |
| return r; |
| } |
| } |
| if (isInternalProperty) { |
| // for internal property, just publish it. |
| onHalEvent(&data, inMocking); |
| return NO_ERROR; |
| } |
| if (inMocking) { |
| return NO_ERROR; |
| } |
| //TODO add value check requires auto generated code to return value range for enum types |
| // set done outside lock to allow concurrent access |
| status_t r = mDevice->set(mDevice, &data); |
| if (r != NO_ERROR) { |
| ALOGW("setProperty 0x%x failed, HAL returned %d", data.prop, r); |
| } |
| return r; |
| } |
| |
| status_t VehicleNetworkService::subscribe(const sp<IVehicleNetworkListener> &listener, int32_t prop, |
| float sampleRate, int32_t zones) { |
| bool shouldSubscribe = false; |
| bool inMock = false; |
| int32_t newZones = zones; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (!isSubscribableLocked(prop)) { |
| return BAD_VALUE; |
| } |
| vehicle_prop_config_t const * config = findConfigLocked(prop); |
| if (config->change_mode == VEHICLE_PROP_CHANGE_MODE_ON_CHANGE) { |
| if (sampleRate != 0) { |
| ALOGW("Sample rate set to non-zeo for on change type. Ignore it"); |
| sampleRate = 0; |
| } |
| } else { |
| if (sampleRate > config->max_sample_rate) { |
| ALOGW("sample rate %f higher than max %f. limit to max", sampleRate, |
| config->max_sample_rate); |
| sampleRate = config->max_sample_rate; |
| } |
| if (sampleRate < config->min_sample_rate) { |
| ALOGW("sample rate %f lower than min %f. limit to min", sampleRate, |
| config->min_sample_rate); |
| sampleRate = config->min_sample_rate; |
| } |
| } |
| if (isZonedProperty(config)) { |
| if ((zones != 0) && ((zones & config->vehicle_zone_flags) != zones)) { |
| ALOGE("subscribe requested zones 0x%x out of range, supported:0x%x", zones, |
| config->vehicle_zone_flags); |
| return BAD_VALUE; |
| } |
| } else { // ignore zone |
| zones = 0; |
| } |
| sp<IBinder> ibinder = IInterface::asBinder(listener); |
| LOG_VERBOSE("subscribe, binder 0x%x prop 0x%x", ibinder.get(), prop); |
| sp<HalClient> client = findOrCreateClientLocked(ibinder, listener); |
| if (client.get() == NULL) { |
| ALOGE("subscribe, no memory, cannot create HalClient"); |
| return NO_MEMORY; |
| } |
| sp<HalClientSpVector> clientsForProperty = findOrCreateClientsVectorForPropertyLocked(prop); |
| if (clientsForProperty.get() == NULL) { |
| ALOGE("subscribe, no memory, cannot create HalClientSpVector"); |
| return NO_MEMORY; |
| } |
| clientsForProperty->add(client); |
| ssize_t index = mSubscriptionInfos.indexOfKey(prop); |
| if (index < 0) { |
| // first time subscription for this property |
| shouldSubscribe = true; |
| } else { |
| const SubscriptionInfo& info = mSubscriptionInfos.valueAt(index); |
| if (info.sampleRate < sampleRate) { |
| shouldSubscribe = true; |
| } |
| newZones = (info.zones == 0) ? 0 : ((zones == 0) ? 0 : (info.zones | zones)); |
| if (info.zones != newZones) { |
| shouldSubscribe = true; |
| } |
| } |
| client->setSubscriptionInfo(prop, sampleRate, zones); |
| if (shouldSubscribe) { |
| inMock = mMockingEnabled; |
| SubscriptionInfo info(sampleRate, newZones); |
| mSubscriptionInfos.add(prop, info); |
| if ((prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) && |
| (prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) { |
| LOG_VERBOSE("subscribe to internal property, prop 0x%x", prop); |
| return NO_ERROR; |
| } |
| } |
| } while (false); |
| if (shouldSubscribe) { |
| status_t r; |
| if (inMock) { |
| r = mHalMock->onPropertySubscribe(prop, sampleRate, newZones); |
| if (r != NO_ERROR) { |
| ALOGW("subscribe 0x%x failed, mock returned %d", prop, r); |
| } |
| } else { |
| LOG_VERBOSE("subscribe to HAL, prop 0x%x sample rate:%f zones:0x%x", prop, sampleRate, |
| newZones); |
| r = mDevice->subscribe(mDevice, prop, sampleRate, newZones); |
| if (r != NO_ERROR) { |
| ALOGW("subscribe 0x%x failed, HAL returned %d", prop, r); |
| } |
| } |
| return r; |
| } |
| return NO_ERROR; |
| } |
| |
| void VehicleNetworkService::unsubscribe(const sp<IVehicleNetworkListener> &listener, int32_t prop) { |
| bool shouldUnsubscribe = false; |
| bool inMocking = false; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (!isSubscribableLocked(prop)) { |
| return; |
| } |
| sp<IBinder> ibinder = IInterface::asBinder(listener); |
| LOG_VERBOSE("unsubscribe, binder 0x%x, prop 0x%x", ibinder.get(), prop); |
| sp<HalClient> client = findClientLocked(ibinder); |
| if (client.get() == NULL) { |
| ALOGD("unsubscribe client not found in binder map"); |
| return; |
| } |
| shouldUnsubscribe = removePropertyFromClientLocked(ibinder, client, prop); |
| if ((prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) && |
| (prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) { |
| LOG_VERBOSE("unsubscribe to internal property, prop 0x%x", prop); |
| return; |
| } |
| if (mMockingEnabled) { |
| inMocking = true; |
| } |
| } while (false); |
| if (shouldUnsubscribe) { |
| if (inMocking) { |
| mHalMock->onPropertyUnsubscribe(prop); |
| } else { |
| mDevice->unsubscribe(mDevice, prop); |
| } |
| } |
| } |
| |
| sp<HalClient> VehicleNetworkService::findClientLocked(sp<IBinder>& ibinder) { |
| sp<HalClient> client; |
| ssize_t index = mBinderToClientMap.indexOfKey(ibinder); |
| if (index < 0) { |
| return client; |
| } |
| return mBinderToClientMap.editValueAt(index); |
| } |
| |
| sp<HalClient> VehicleNetworkService::findOrCreateClientLocked(sp<IBinder>& ibinder, |
| const sp<IVehicleNetworkListener> &listener) { |
| sp<HalClient> client; |
| ssize_t index = mBinderToClientMap.indexOfKey(ibinder); |
| if (index < 0) { |
| IPCThreadState* self = IPCThreadState::self(); |
| pid_t pid = self->getCallingPid(); |
| uid_t uid = self->getCallingUid(); |
| client = new HalClient(listener, pid, uid); |
| ASSERT_OR_HANDLE_NO_MEMORY(client.get(), return client); |
| ibinder->linkToDeath(this); |
| LOG_VERBOSE("add binder 0x%x to map", ibinder.get()); |
| mBinderToClientMap.add(ibinder, client); |
| } else { |
| client = mBinderToClientMap.editValueAt(index); |
| } |
| return client; |
| } |
| |
| sp<HalClientSpVector> VehicleNetworkService::findClientsVectorForPropertyLocked(int32_t property) { |
| sp<HalClientSpVector> clientsForProperty; |
| ssize_t index = mPropertyToClientsMap.indexOfKey(property); |
| if (index >= 0) { |
| clientsForProperty = mPropertyToClientsMap.editValueAt(index); |
| } |
| return clientsForProperty; |
| } |
| |
| sp<HalClientSpVector> VehicleNetworkService::findOrCreateClientsVectorForPropertyLocked( |
| int32_t property) { |
| sp<HalClientSpVector> clientsForProperty; |
| ssize_t index = mPropertyToClientsMap.indexOfKey(property); |
| if (index >= 0) { |
| clientsForProperty = mPropertyToClientsMap.editValueAt(index); |
| } else { |
| clientsForProperty = new HalClientSpVector(); |
| ASSERT_OR_HANDLE_NO_MEMORY(clientsForProperty.get(), return clientsForProperty); |
| mPropertyToClientsMap.add(property, clientsForProperty); |
| } |
| return clientsForProperty; |
| } |
| |
| /** |
| * remove given property from client and remove HalCLient if necessary. |
| * @return true if the property should be unsubscribed from HAL (=no more clients). |
| */ |
| bool VehicleNetworkService::removePropertyFromClientLocked(sp<IBinder>& ibinder, |
| sp<HalClient>& client, int32_t property) { |
| if(!client->removePropertyAndCheckIfActive(property)) { |
| // client is no longer necessary |
| mBinderToClientMap.removeItem(ibinder); |
| ibinder->unlinkToDeath(this); |
| } |
| sp<HalClientSpVector> clientsForProperty = findClientsVectorForPropertyLocked(property); |
| if (clientsForProperty.get() == NULL) { |
| // no subscription |
| return false; |
| } |
| clientsForProperty->remove(client); |
| //TODO reset sample rate. do not care for now. |
| if (clientsForProperty->size() == 0) { |
| mPropertyToClientsMap.removeItem(property); |
| mSubscriptionInfos.removeItem(property); |
| return true; |
| } |
| return false; |
| } |
| |
| status_t VehicleNetworkService::injectEvent(const vehicle_prop_value_t& value) { |
| ALOGI("injectEvent property:0x%x", value.prop); |
| return onHalEvent(&value, true); |
| } |
| |
| status_t VehicleNetworkService::startMocking(const sp<IVehicleNetworkHalMock>& mock) { |
| sp<VehicleHalMessageHandler> handler; |
| List<sp<HalClient> > clientsToDispatch; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (mMockingEnabled) { |
| ALOGW("startMocking while already enabled"); |
| // allow it as test can fail without clearing |
| if (mHalMock != NULL) { |
| IInterface::asBinder(mHalMock)->unlinkToDeath(mHalMockDeathHandler.get()); |
| } |
| } |
| ALOGW("starting vehicle HAL mocking"); |
| sp<IBinder> ibinder = IInterface::asBinder(mock); |
| if (mHalMockDeathHandler.get() == NULL) { |
| mHalMockDeathHandler = new MockDeathHandler(*this); |
| } |
| ibinder->linkToDeath(mHalMockDeathHandler); |
| mHalMock = mock; |
| mMockingEnabled = true; |
| // Mock implementation should make sure that its startMocking call is not blocking its |
| // onlistProperties call. Otherwise, this will lead into dead-lock. |
| mPropertiesForMocking = mock->onListProperties(); |
| handleHalRestartAndGetClientsToDispatchLocked(clientsToDispatch); |
| //TODO handle binder death |
| handler = mHandler; |
| } while (false); |
| handler->handleMockStart(); |
| for (auto& client : clientsToDispatch) { |
| client->dispatchHalRestart(true); |
| } |
| clientsToDispatch.clear(); |
| return NO_ERROR; |
| } |
| |
| void VehicleNetworkService::stopMocking(const sp<IVehicleNetworkHalMock>& mock) { |
| List<sp<HalClient> > clientsToDispatch; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (mHalMock.get() == NULL) { |
| return; |
| } |
| sp<IBinder> ibinder = IInterface::asBinder(mock); |
| if (ibinder != IInterface::asBinder(mHalMock)) { |
| ALOGE("stopMocking, not the one started"); |
| return; |
| } |
| ALOGW("stopping vehicle HAL mocking"); |
| ibinder->unlinkToDeath(mHalMockDeathHandler.get()); |
| mHalMock = NULL; |
| mMockingEnabled = false; |
| handleHalRestartAndGetClientsToDispatchLocked(clientsToDispatch); |
| } while (false); |
| for (auto& client : clientsToDispatch) { |
| client->dispatchHalRestart(false); |
| } |
| clientsToDispatch.clear(); |
| } |
| |
| void VehicleNetworkService::handleHalRestartAndGetClientsToDispatchLocked( |
| List<sp<HalClient> >& clientsToDispatch) { |
| // all subscriptions are invalid |
| mPropertyToClientsMap.clear(); |
| mSubscriptionInfos.clear(); |
| mEventsCount.clear(); |
| List<sp<HalClient> > clientsToRemove; |
| for (size_t i = 0; i < mBinderToClientMap.size(); i++) { |
| sp<HalClient> client = mBinderToClientMap.valueAt(i); |
| client->removeAllProperties(); |
| if (client->isMonitoringHalRestart()) { |
| clientsToDispatch.push_back(client); |
| } |
| if (!client->isActive()) { |
| clientsToRemove.push_back(client); |
| } |
| } |
| for (auto& client : clientsToRemove) { |
| // client is no longer necessary |
| sp<IBinder> ibinder = IInterface::asBinder(client->getListener()); |
| mBinderToClientMap.removeItem(ibinder); |
| ibinder->unlinkToDeath(this); |
| } |
| clientsToRemove.clear(); |
| } |
| |
| status_t VehicleNetworkService::injectHalError(int32_t errorCode, int32_t property, |
| int32_t operation) { |
| return onHalError(errorCode, property, operation, true /*isInjection*/); |
| } |
| |
| status_t VehicleNetworkService::startErrorListening(const sp<IVehicleNetworkListener> &listener) { |
| sp<IBinder> ibinder = IInterface::asBinder(listener); |
| sp<HalClient> client; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| client = findOrCreateClientLocked(ibinder, listener); |
| } while (false); |
| if (client.get() == NULL) { |
| ALOGW("startErrorListening failed, no memory"); |
| return NO_MEMORY; |
| } |
| client->setHalErrorMonitoringState(true); |
| return NO_ERROR; |
| } |
| |
| void VehicleNetworkService::stopErrorListening(const sp<IVehicleNetworkListener> &listener) { |
| sp<IBinder> ibinder = IInterface::asBinder(listener); |
| sp<HalClient> client; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| client = findClientLocked(ibinder); |
| } while (false); |
| if (client.get() != NULL) { |
| client->setHalErrorMonitoringState(false); |
| } |
| } |
| |
| status_t VehicleNetworkService::startHalRestartMonitoring( |
| const sp<IVehicleNetworkListener> &listener) { |
| sp<IBinder> ibinder = IInterface::asBinder(listener); |
| sp<HalClient> client; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| client = findOrCreateClientLocked(ibinder, listener); |
| } while (false); |
| if (client.get() == NULL) { |
| ALOGW("startHalRestartMonitoring failed, no memory"); |
| return NO_MEMORY; |
| } |
| client->setHalRestartMonitoringState(true); |
| return NO_ERROR; |
| } |
| |
| void VehicleNetworkService::stopHalRestartMonitoring(const sp<IVehicleNetworkListener> &listener) { |
| sp<IBinder> ibinder = IInterface::asBinder(listener); |
| sp<HalClient> client; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| client = findClientLocked(ibinder); |
| } while (false); |
| if (client.get() != NULL) { |
| client->setHalRestartMonitoringState(false); |
| } |
| } |
| |
| status_t VehicleNetworkService::onHalEvent(const vehicle_prop_value_t* eventData, bool isInjection) |
| { |
| sp<VehicleHalMessageHandler> handler; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (!isInjection) { |
| if (mMockingEnabled) { |
| // drop real HAL event if mocking is enabled |
| return NO_ERROR; |
| } |
| } |
| ssize_t index = mEventsCount.indexOfKey(eventData->prop); |
| if (index < 0) { |
| mEventsCount.add(eventData->prop, 1); |
| } else { |
| int count = mEventsCount.valueAt(index); |
| count++; |
| mEventsCount.add(eventData->prop, count); |
| } |
| handler = mHandler; |
| } while (false); |
| //TODO add memory pool |
| vehicle_prop_value_t* copy = VehiclePropValueUtil::allocVehicleProp(*eventData); |
| ASSERT_OR_HANDLE_NO_MEMORY(copy, return NO_MEMORY); |
| handler->handleHalEvent(copy); |
| return NO_ERROR; |
| } |
| |
| status_t VehicleNetworkService::onHalError(int32_t errorCode, int32_t property, int32_t operation, |
| bool isInjection) { |
| sp<VehicleHalMessageHandler> handler; |
| VehicleHalError* error = NULL; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (!isInjection) { |
| if (mMockingEnabled) { |
| // drop real HAL error if mocking is enabled |
| return NO_ERROR; |
| } |
| } |
| |
| error = new VehicleHalError(errorCode, property, operation); |
| if (error == NULL) { |
| return NO_MEMORY; |
| } |
| handler = mHandler; |
| } while (false); |
| ALOGI("HAL error, error code:%d, property:0x%x, operation:%d, isInjection:%d", |
| errorCode, property, operation, isInjection? 1 : 0); |
| handler->handleHalError(error); |
| return NO_ERROR; |
| } |
| |
| void VehicleNetworkService::dispatchHalEvents(List<vehicle_prop_value_t*>& events) { |
| HalClientSpVector activeClients; |
| do { // for lock scoping |
| Mutex::Autolock autoLock(mLock); |
| for (vehicle_prop_value_t* e : events) { |
| ssize_t index = mPropertyToClientsMap.indexOfKey(e->prop); |
| if (index < 0) { |
| EVENT_LOG("HAL event for not subscribed property 0x%x", e->prop); |
| continue; |
| } |
| sp<HalClientSpVector>& clients = mPropertyToClientsMap.editValueAt(index); |
| EVENT_LOG("dispatchHalEvents, prop 0x%x, active clients %d", e->prop, clients->size()); |
| for (size_t i = 0; i < clients->size(); i++) { |
| sp<HalClient>& client = clients->editItemAt(i); |
| activeClients.add(client); |
| client->addEvent(e); |
| } |
| } |
| } while (false); |
| EVENT_LOG("dispatchHalEvents num events %d, active clients:%d", events.size(), |
| activeClients.size()); |
| for (size_t i = 0; i < activeClients.size(); i++) { |
| sp<HalClient> client = activeClients.editItemAt(i); |
| client->dispatchEvents(); |
| } |
| activeClients.clear(); |
| } |
| |
| void VehicleNetworkService::dispatchHalError(VehicleHalError* error) { |
| List<sp<HalClient> > clientsToDispatch; |
| do { |
| Mutex::Autolock autoLock(mLock); |
| if (error->property != 0) { |
| sp<HalClientSpVector> clientsForProperty = findClientsVectorForPropertyLocked( |
| error->property); |
| if (clientsForProperty.get() != NULL) { |
| for (size_t i = 0; i < clientsForProperty->size(); i++) { |
| sp<HalClient> client = clientsForProperty->itemAt(i); |
| clientsToDispatch.push_back(client); |
| } |
| } |
| } |
| // Send to global error handler if property is 0 or if no client subscribing. |
| if (error->property == 0 || clientsToDispatch.size() == 0) { |
| for (size_t i = 0; i < mBinderToClientMap.size(); i++) { |
| sp<HalClient> client = mBinderToClientMap.valueAt(i); |
| if (client->isMonitoringHalError()) { |
| clientsToDispatch.push_back(client); |
| } |
| } |
| } |
| } while (false); |
| ALOGI("dispatchHalError error:%d, property:0x%x, operation:%d, num clients to dispatch:%d", |
| error->errorCode, error->property, error->operation, clientsToDispatch.size()); |
| for (auto& client : clientsToDispatch) { |
| client->dispatchHalError(error->errorCode, error->property, error->operation); |
| } |
| clientsToDispatch.clear(); |
| } |
| |
| status_t VehicleNetworkService::loadHal() { |
| int r = hw_get_module(VEHICLE_HARDWARE_MODULE_ID, (hw_module_t const**)&mModule); |
| if (r != NO_ERROR) { |
| ALOGE("cannot load HAL module, error:%d", r); |
| return r; |
| } |
| r = mModule->common.methods->open(&mModule->common, VEHICLE_HARDWARE_DEVICE, |
| (hw_device_t**)&mDevice); |
| return r; |
| } |
| |
| void VehicleNetworkService::closeHal() { |
| mDevice->common.close(&mDevice->common); |
| } |
| }; |
