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 //Templated classes can use the below method 32 //to avoid creating dependencies on liblog. 33 void logAlwaysFatal(const char *message); 34 35 // HIDL client/server code should *NOT* use this class. 36 // 37 // hidl_pointer wraps a pointer without taking ownership, 38 // and stores it in a union with a uint64_t. This ensures 39 // that we always have enough space to store a pointer, 40 // regardless of whether we're running in a 32-bit or 64-bit 41 // process. 42 template<typename T> 43 struct hidl_pointer { 44 hidl_pointer() 45 : _pad(0) { 46 } 47 hidl_pointer(T* ptr) : hidl_pointer() { mPointer = ptr; } 48 hidl_pointer(const hidl_pointer<T>& other) : hidl_pointer() { mPointer = other.mPointer; } 49 hidl_pointer(hidl_pointer<T>&& other) : hidl_pointer() { *this = std::move(other); } 50 51 hidl_pointer &operator=(const hidl_pointer<T>& other) { 52 mPointer = other.mPointer; 53 return *this; 54 } 55 hidl_pointer &operator=(hidl_pointer<T>&& other) { 56 mPointer = other.mPointer; 57 other.mPointer = nullptr; 58 return *this; 59 } 60 hidl_pointer &operator=(T* ptr) { 61 mPointer = ptr; 62 return *this; 63 } 64 65 operator T*() const { 66 return mPointer; 67 } 68 explicit operator void*() const { // requires explicit cast to avoid ambiguity 69 return mPointer; 70 } 71 T& operator*() const { 72 return *mPointer; 73 } 74 T* operator->() const { 75 return mPointer; 76 } 77 T &operator[](size_t index) { 78 return mPointer[index]; 79 } 80 const T &operator[](size_t index) const { 81 return mPointer[index]; 82 } 83 84 private: 85 union { 86 T* mPointer; 87 uint64_t _pad; 88 }; 89 }; 90 91 #define HAL_LIBRARY_PATH_SYSTEM_64BIT "/system/lib64/hw/" 92 #define HAL_LIBRARY_PATH_VNDK_SP_64BIT "/system/lib64/vndk-sp/hw/" 93 #define HAL_LIBRARY_PATH_VENDOR_64BIT "/vendor/lib64/hw/" 94 #define HAL_LIBRARY_PATH_ODM_64BIT "/odm/lib64/hw/" 95 #define HAL_LIBRARY_PATH_SYSTEM_32BIT "/system/lib/hw/" 96 #define HAL_LIBRARY_PATH_VNDK_SP_32BIT "/system/lib/vndk-sp/hw/" 97 #define HAL_LIBRARY_PATH_VENDOR_32BIT "/vendor/lib/hw/" 98 #define HAL_LIBRARY_PATH_ODM_32BIT "/odm/lib/hw/" 99 100 #if defined(__LP64__) 101 #define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_64BIT 102 #define HAL_LIBRARY_PATH_VNDK_SP HAL_LIBRARY_PATH_VNDK_SP_64BIT 103 #define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_64BIT 104 #define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_64BIT 105 #else 106 #define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_32BIT 107 #define HAL_LIBRARY_PATH_VNDK_SP HAL_LIBRARY_PATH_VNDK_SP_32BIT 108 #define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_32BIT 109 #define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_32BIT 110 #endif 111 112 // ---------------------------------------------------------------------- 113 // Class that provides Hidl instrumentation utilities. 114 struct HidlInstrumentor { 115 // Event that triggers the instrumentation. e.g. enter of an API call on 116 // the server/client side, exit of an API call on the server/client side 117 // etc. 118 enum InstrumentationEvent { 119 SERVER_API_ENTRY = 0, 120 SERVER_API_EXIT, 121 CLIENT_API_ENTRY, 122 CLIENT_API_EXIT, 123 SYNC_CALLBACK_ENTRY, 124 SYNC_CALLBACK_EXIT, 125 ASYNC_CALLBACK_ENTRY, 126 ASYNC_CALLBACK_EXIT, 127 PASSTHROUGH_ENTRY, 128 PASSTHROUGH_EXIT, 129 }; 130 131 // Signature of the instrumentation callback function. 132 using InstrumentationCallback = std::function<void( 133 const InstrumentationEvent event, 134 const char *package, 135 const char *version, 136 const char *interface, 137 const char *method, 138 std::vector<void *> *args)>; 139 140 explicit HidlInstrumentor( 141 const std::string &package, 142 const std::string &insterface); 143 virtual ~HidlInstrumentor(); 144 145 public: 146 const std::vector<InstrumentationCallback>& getInstrumentationCallbacks() { 147 return mInstrumentationCallbacks; 148 } 149 bool isInstrumentationEnabled() { return mEnableInstrumentation; } 150 151 protected: 152 // Set mEnableInstrumentation based on system property 153 // hal.instrumentation.enable, register/de-register instrumentation 154 // callbacks if mEnableInstrumentation is true/false. 155 void configureInstrumentation(bool log=true); 156 // Function that lookup and dynamically loads the hidl instrumentation 157 // libraries and registers the instrumentation callback functions. 158 // 159 // The instrumentation libraries should be stored under any of the following 160 // directories: HAL_LIBRARY_PATH_SYSTEM, HAL_LIBRARY_PATH_VNDK_SP, 161 // HAL_LIBRARY_PATH_VENDOR and HAL_LIBRARY_PATH_ODM. 162 // The name of instrumentation libraries should follow pattern: 163 // ^profilerPrefix(.*).profiler.so$ 164 // 165 // Each instrumentation library is expected to implement the instrumentation 166 // function called HIDL_INSTRUMENTATION_FUNCTION. 167 // 168 // A no-op for user build. 169 void registerInstrumentationCallbacks( 170 std::vector<InstrumentationCallback> *instrumentationCallbacks); 171 172 // Utility function to determine whether a give file is a instrumentation 173 // library (i.e. the file name follow the expected pattern). 174 bool isInstrumentationLib(const dirent *file); 175 176 // A list of registered instrumentation callbacks. 177 std::vector<InstrumentationCallback> mInstrumentationCallbacks; 178 // Flag whether to enable instrumentation. 179 bool mEnableInstrumentation; 180 // Prefix to lookup the instrumentation libraries. 181 std::string mInstrumentationLibPackage; 182 // Used for dlsym to load the profiling method for given interface. 183 std::string mInterfaceName; 184 185 }; 186 187 } // namespace details 188 } // namespace hardware 189 } // namespace android 190 191 #endif // ANDROID_HIDL_INTERNAL_H 192