// Copyright(c) 2018-2020, Intel Corporation // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // * Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // * Neither the name of Intel Corporation nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE. #ifndef __OPAE_OPAE_INT_H__ #define __OPAE_OPAE_INT_H__ #include #include #include #include #include #include #ifndef __USE_GNU #define __USE_GNU #endif // __USE_GNU #include #define ASSERT_NOT_NULL_MSG_RESULT(__arg, __msg, __result) \ do { \ if (!__arg) { \ OPAE_ERR(__msg); \ return __result; \ } \ } while (0) /* * Check if argument is NULL and return FPGA_INVALID_PARAM and a message */ #define ASSERT_NOT_NULL_MSG(__arg, __msg) \ ASSERT_NOT_NULL_MSG_RESULT(__arg, __msg, FPGA_INVALID_PARAM) #define ASSERT_NOT_NULL(__arg) ASSERT_NOT_NULL_MSG(__arg, #__arg " is NULL") #define ASSERT_NOT_NULL_RESULT(__arg, __result) \ ASSERT_NOT_NULL_MSG_RESULT(__arg, #__arg " is NULL", __result) #define ASSERT_RESULT(__result) \ do { \ if ((__result) != FPGA_OK) \ return __result; \ } while (0) #define UNUSED_PARAM(x) ((void)x) #define opae_mutex_lock(__res, __mtx_ptr) \ ({ \ (__res) = pthread_mutex_lock(__mtx_ptr); \ if (__res) \ OPAE_ERR("pthread_mutex_lock failed: %s", \ strerror(errno)); \ __res; \ }) #define opae_mutex_unlock(__res, __mtx_ptr) \ ({ \ (__res) = pthread_mutex_unlock(__mtx_ptr); \ if (__res) \ OPAE_ERR("pthread_mutex_unlock failed: %s", \ strerror(errno)); \ __res; \ }) #ifndef __OPAE_ADAPTER_H__ typedef struct _opae_api_adapter_table opae_api_adapter_table; #endif // __OPAE_ADAPTER_H__ // k o t w #define OPAE_WRAPPED_TOKEN_MAGIC 0x6b6f7477 typedef struct _opae_wrapped_token { uint32_t magic; fpga_token opae_token; opae_api_adapter_table *adapter_table; } opae_wrapped_token; opae_wrapped_token * opae_allocate_wrapped_token(fpga_token token, const opae_api_adapter_table *adapter); static inline opae_wrapped_token *opae_validate_wrapped_token(fpga_token t) { opae_wrapped_token *wt; if (!t) return NULL; wt = (opae_wrapped_token *)t; return (wt->magic == OPAE_WRAPPED_TOKEN_MAGIC) ? wt : NULL; } static inline void opae_destroy_wrapped_token(opae_wrapped_token *wt) { wt->magic = 0; free(wt); } // n a h w #define OPAE_WRAPPED_HANDLE_MAGIC 0x6e616877 typedef struct _opae_wrapped_handle { uint32_t magic; opae_wrapped_token *wrapped_token; fpga_handle opae_handle; opae_api_adapter_table *adapter_table; } opae_wrapped_handle; opae_wrapped_handle * opae_allocate_wrapped_handle(opae_wrapped_token *wt, fpga_handle opae_handle, opae_api_adapter_table *adapter); static inline opae_wrapped_handle *opae_validate_wrapped_handle(fpga_handle h) { opae_wrapped_handle *wh; if (!h) return NULL; wh = (opae_wrapped_handle *)h; return (wh->magic == OPAE_WRAPPED_HANDLE_MAGIC) ? wh : NULL; } static inline void opae_destroy_wrapped_handle(opae_wrapped_handle *wh) { wh->magic = 0; free(wh); } // e v e w #define OPAE_WRAPPED_EVENT_HANDLE_MAGIC 0x65766577 #define OPAE_WRAPPED_EVENT_HANDLE_CREATED 0x00000001 typedef struct _opae_wrapped_event_handle { uint32_t magic; pthread_mutex_t lock; uint32_t flags; fpga_event_handle opae_event_handle; opae_api_adapter_table *adapter_table; } opae_wrapped_event_handle; opae_wrapped_event_handle * opae_allocate_wrapped_event_handle(fpga_event_handle opae_event_handle, opae_api_adapter_table *adapter); static inline opae_wrapped_event_handle * opae_validate_wrapped_event_handle(fpga_event_handle h) { opae_wrapped_event_handle *we; if (!h) return NULL; we = (opae_wrapped_event_handle *)h; return (we->magic == OPAE_WRAPPED_EVENT_HANDLE_MAGIC) ? we : NULL; } static inline void opae_destroy_wrapped_event_handle(opae_wrapped_event_handle *we) { int err; opae_mutex_lock(err, &we->lock); we->magic = 0; opae_mutex_unlock(err, &we->lock); if (pthread_mutex_destroy(&we->lock)) OPAE_ERR("pthread_mutex_destroy() failed"); free(we); } // j b o w #define OPAE_WRAPPED_OBJECT_MAGIC 0x6a626f77 typedef struct _opae_wrapped_object { uint32_t magic; fpga_object opae_object; opae_api_adapter_table *adapter_table; } opae_wrapped_object; opae_wrapped_object * opae_allocate_wrapped_object(fpga_object opae_object, opae_api_adapter_table *adapter); static inline opae_wrapped_object *opae_validate_wrapped_object(fpga_object o) { opae_wrapped_object *wo; if (!o) return NULL; wo = (opae_wrapped_object *)o; return (wo->magic == OPAE_WRAPPED_OBJECT_MAGIC) ? wo : NULL; } static inline void opae_destroy_wrapped_object(opae_wrapped_object *wo) { wo->magic = 0; free(wo); } #endif // ___OPAE_OPAE_INT_H__