1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HIDL_INTERNAL_H 18 #define ANDROID_HIDL_INTERNAL_H 19 20 #include <cstdint> 21 #include <dirent.h> 22 #include <functional> 23 #include <string> 24 #include <vector> 25 #include <utility> 26 27 namespace android { 28 namespace hardware { 29 namespace details { 30 31 // tag for pure interfaces (e.x. IFoo) 32 struct i_tag {}; 33 34 // tag for server interfaces (e.x. BnHwFoo) 35 struct bnhw_tag {}; 36 37 // tag for proxy interfaces (e.x. BpHwFoo) 38 struct bphw_tag {}; 39 40 // tag for passthrough interfaces (e.x. BsFoo) 41 struct bs_tag {}; 42 43 //Templated classes can use the below method 44 //to avoid creating dependencies on liblog. 45 void logAlwaysFatal(const char *message); 46 47 // Returns vndk version from "ro.vndk.version" with '-' as a prefix. 48 // If "ro.vndk.version" is not set or set to "current", it returns empty string. 49 std::string getVndkVersionStr(); 50 51 // HIDL client/server code should *NOT* use this class. 52 // 53 // hidl_pointer wraps a pointer without taking ownership, 54 // and stores it in a union with a uint64_t. This ensures 55 // that we always have enough space to store a pointer, 56 // regardless of whether we're running in a 32-bit or 64-bit 57 // process. 58 template<typename T> 59 struct hidl_pointer { hidl_pointerhidl_pointer60 hidl_pointer() 61 : _pad(0) { 62 } hidl_pointerhidl_pointer63 hidl_pointer(T* ptr) : hidl_pointer() { mPointer = ptr; } hidl_pointerhidl_pointer64 hidl_pointer(const hidl_pointer<T>& other) : hidl_pointer() { mPointer = other.mPointer; } hidl_pointerhidl_pointer65 hidl_pointer(hidl_pointer<T>&& other) : hidl_pointer() { *this = std::move(other); } 66 67 hidl_pointer &operator=(const hidl_pointer<T>& other) { 68 mPointer = other.mPointer; 69 return *this; 70 } 71 hidl_pointer &operator=(hidl_pointer<T>&& other) { 72 mPointer = other.mPointer; 73 other.mPointer = nullptr; 74 return *this; 75 } 76 hidl_pointer &operator=(T* ptr) { 77 mPointer = ptr; 78 return *this; 79 } 80 81 operator T*() const { 82 return mPointer; 83 } 84 explicit operator void*() const { // requires explicit cast to avoid ambiguity 85 return mPointer; 86 } 87 T& operator*() const { 88 return *mPointer; 89 } 90 T* operator->() const { 91 return mPointer; 92 } 93 T &operator[](size_t index) { 94 return mPointer[index]; 95 } 96 const T &operator[](size_t index) const { 97 return mPointer[index]; 98 } 99 100 private: 101 union { 102 T* mPointer; 103 uint64_t _pad; 104 }; 105 }; 106 107 #define HAL_LIBRARY_PATH_SYSTEM_64BIT "/system/lib64/hw/" 108 #define HAL_LIBRARY_PATH_VNDK_SP_64BIT_FOR_VERSION "/system/lib64/vndk-sp%s/hw/" 109 #define HAL_LIBRARY_PATH_VENDOR_64BIT "/vendor/lib64/hw/" 110 #define HAL_LIBRARY_PATH_ODM_64BIT "/odm/lib64/hw/" 111 #define HAL_LIBRARY_PATH_SYSTEM_32BIT "/system/lib/hw/" 112 #define HAL_LIBRARY_PATH_VNDK_SP_32BIT_FOR_VERSION "/system/lib/vndk-sp%s/hw/" 113 #define HAL_LIBRARY_PATH_VENDOR_32BIT "/vendor/lib/hw/" 114 #define HAL_LIBRARY_PATH_ODM_32BIT "/odm/lib/hw/" 115 116 #if defined(__LP64__) 117 #define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_64BIT 118 #define HAL_LIBRARY_PATH_VNDK_SP_FOR_VERSION HAL_LIBRARY_PATH_VNDK_SP_64BIT_FOR_VERSION 119 #define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_64BIT 120 #define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_64BIT 121 #else 122 #define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_32BIT 123 #define HAL_LIBRARY_PATH_VNDK_SP_FOR_VERSION HAL_LIBRARY_PATH_VNDK_SP_32BIT_FOR_VERSION 124 #define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_32BIT 125 #define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_32BIT 126 #endif 127 128 // ---------------------------------------------------------------------- 129 // Class that provides Hidl instrumentation utilities. 130 struct HidlInstrumentor { 131 // Event that triggers the instrumentation. e.g. enter of an API call on 132 // the server/client side, exit of an API call on the server/client side 133 // etc. 134 enum InstrumentationEvent { 135 SERVER_API_ENTRY = 0, 136 SERVER_API_EXIT, 137 CLIENT_API_ENTRY, 138 CLIENT_API_EXIT, 139 SYNC_CALLBACK_ENTRY, 140 SYNC_CALLBACK_EXIT, 141 ASYNC_CALLBACK_ENTRY, 142 ASYNC_CALLBACK_EXIT, 143 PASSTHROUGH_ENTRY, 144 PASSTHROUGH_EXIT, 145 }; 146 147 // Signature of the instrumentation callback function. 148 using InstrumentationCallback = std::function<void( 149 const InstrumentationEvent event, 150 const char *package, 151 const char *version, 152 const char *interface, 153 const char *method, 154 std::vector<void *> *args)>; 155 156 explicit HidlInstrumentor( 157 const std::string &package, 158 const std::string &insterface); 159 virtual ~HidlInstrumentor(); 160 161 public: getInstrumentationCallbacksHidlInstrumentor162 const std::vector<InstrumentationCallback>& getInstrumentationCallbacks() { 163 return mInstrumentationCallbacks; 164 } isInstrumentationEnabledHidlInstrumentor165 bool isInstrumentationEnabled() { return mEnableInstrumentation; } 166 167 protected: 168 // Set mEnableInstrumentation based on system property 169 // hal.instrumentation.enable, register/de-register instrumentation 170 // callbacks if mEnableInstrumentation is true/false. 171 void configureInstrumentation(bool log=true); 172 // Function that lookup and dynamically loads the hidl instrumentation 173 // libraries and registers the instrumentation callback functions. 174 // 175 // The instrumentation libraries should be stored under any of the following 176 // directories: HAL_LIBRARY_PATH_SYSTEM, HAL_LIBRARY_PATH_VNDK_SP, 177 // HAL_LIBRARY_PATH_VENDOR and HAL_LIBRARY_PATH_ODM. 178 // The name of instrumentation libraries should follow pattern: 179 // ^profilerPrefix(.*).profiler.so$ 180 // 181 // Each instrumentation library is expected to implement the instrumentation 182 // function called HIDL_INSTRUMENTATION_FUNCTION. 183 // 184 // A no-op for user build. 185 void registerInstrumentationCallbacks( 186 std::vector<InstrumentationCallback> *instrumentationCallbacks); 187 188 // Utility function to determine whether a give file is a instrumentation 189 // library (i.e. the file name follow the expected pattern). 190 bool isInstrumentationLib(const dirent *file); 191 192 // A list of registered instrumentation callbacks. 193 std::vector<InstrumentationCallback> mInstrumentationCallbacks; 194 // Flag whether to enable instrumentation. 195 bool mEnableInstrumentation; 196 // Prefix to lookup the instrumentation libraries. 197 std::string mInstrumentationLibPackage; 198 // Used for dlsym to load the profiling method for given interface. 199 std::string mInterfaceName; 200 201 }; 202 203 } // namespace details 204 } // namespace hardware 205 } // namespace android 206 207 #endif // ANDROID_HIDL_INTERNAL_H 208