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
27namespace android {
28namespace hardware {
29namespace details {
30
31// tag for pure interfaces (e.x. IFoo)
32struct i_tag {};
33
34// tag for server interfaces (e.x. BnHwFoo)
35struct bnhw_tag {};
36
37// tag for proxy interfaces (e.x. BpHwFoo)
38struct bphw_tag {};
39
40// tag for passthrough interfaces (e.x. BsFoo)
41struct bs_tag {};
42
43//Templated classes can use the below method
44//to avoid creating dependencies on liblog.
45void 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.
49std::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.
58template<typename T>
59struct hidl_pointer {
60    hidl_pointer()
61        : _pad(0) {
62    }
63    hidl_pointer(T* ptr) : hidl_pointer() { mPointer = ptr; }
64    hidl_pointer(const hidl_pointer<T>& other) : hidl_pointer() { mPointer = other.mPointer; }
65    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
100private:
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.
130struct 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:
162    const std::vector<InstrumentationCallback>& getInstrumentationCallbacks() {
163        return mInstrumentationCallbacks;
164    }
165    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