| #ifndef _ADSP_CURRENT_PROCESS_STUB_H |
| #define _ADSP_CURRENT_PROCESS_STUB_H |
| /* |
| * Copyright (c) 2019, The Linux Foundation. All rights reserved. |
| * |
| * 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * 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. |
| */ |
| #include "adsp_current_process.h" |
| #ifndef _QAIC_ENV_H |
| #define _QAIC_ENV_H |
| |
| #ifdef __GNUC__ |
| #ifdef __clang__ |
| #pragma GCC diagnostic ignored "-Wunknown-pragmas" |
| #else |
| #pragma GCC diagnostic ignored "-Wpragmas" |
| #endif |
| #pragma GCC diagnostic ignored "-Wuninitialized" |
| #pragma GCC diagnostic ignored "-Wunused-parameter" |
| #pragma GCC diagnostic ignored "-Wunused-function" |
| #endif |
| |
| #ifndef _ATTRIBUTE_UNUSED |
| |
| #ifdef _WIN32 |
| #define _ATTRIBUTE_UNUSED |
| #else |
| #define _ATTRIBUTE_UNUSED __attribute__ ((unused)) |
| #endif |
| |
| #endif // _ATTRIBUTE_UNUSED |
| |
| #ifndef __QAIC_REMOTE |
| #define __QAIC_REMOTE(ff) ff |
| #endif //__QAIC_REMOTE |
| |
| #ifndef __QAIC_HEADER |
| #define __QAIC_HEADER(ff) ff |
| #endif //__QAIC_HEADER |
| |
| #ifndef __QAIC_HEADER_EXPORT |
| #define __QAIC_HEADER_EXPORT |
| #endif // __QAIC_HEADER_EXPORT |
| |
| #ifndef __QAIC_HEADER_ATTRIBUTE |
| #define __QAIC_HEADER_ATTRIBUTE |
| #endif // __QAIC_HEADER_ATTRIBUTE |
| |
| #ifndef __QAIC_IMPL |
| #define __QAIC_IMPL(ff) ff |
| #endif //__QAIC_IMPL |
| |
| #ifndef __QAIC_IMPL_EXPORT |
| #define __QAIC_IMPL_EXPORT |
| #endif // __QAIC_IMPL_EXPORT |
| |
| #ifndef __QAIC_IMPL_ATTRIBUTE |
| #define __QAIC_IMPL_ATTRIBUTE |
| #endif // __QAIC_IMPL_ATTRIBUTE |
| |
| #ifndef __QAIC_STUB |
| #define __QAIC_STUB(ff) ff |
| #endif //__QAIC_STUB |
| |
| #ifndef __QAIC_STUB_EXPORT |
| #define __QAIC_STUB_EXPORT |
| #endif // __QAIC_STUB_EXPORT |
| |
| #ifndef __QAIC_STUB_ATTRIBUTE |
| #define __QAIC_STUB_ATTRIBUTE |
| #endif // __QAIC_STUB_ATTRIBUTE |
| |
| #ifndef __QAIC_SKEL |
| #define __QAIC_SKEL(ff) ff |
| #endif //__QAIC_SKEL__ |
| |
| #ifndef __QAIC_SKEL_EXPORT |
| #define __QAIC_SKEL_EXPORT |
| #endif // __QAIC_SKEL_EXPORT |
| |
| #ifndef __QAIC_SKEL_ATTRIBUTE |
| #define __QAIC_SKEL_ATTRIBUTE |
| #endif // __QAIC_SKEL_ATTRIBUTE |
| |
| #ifdef __QAIC_DEBUG__ |
| #ifndef __QAIC_DBG_PRINTF__ |
| #include <stdio.h> |
| #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0) |
| #endif |
| #else |
| #define __QAIC_DBG_PRINTF__( ee ) (void)0 |
| #endif |
| |
| |
| #define _OFFSET(src, sof) ((void*)(((char*)(src)) + (sof))) |
| |
| #define _COPY(dst, dof, src, sof, sz) \ |
| do {\ |
| struct __copy { \ |
| char ar[sz]; \ |
| };\ |
| *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\ |
| } while (0) |
| |
| #define _COPYIF(dst, dof, src, sof, sz) \ |
| do {\ |
| if(_OFFSET(dst, dof) != _OFFSET(src, sof)) {\ |
| _COPY(dst, dof, src, sof, sz); \ |
| } \ |
| } while (0) |
| |
| _ATTRIBUTE_UNUSED |
| static __inline void _qaic_memmove(void* dst, void* src, int size) { |
| int i; |
| for(i = 0; i < size; ++i) { |
| ((char*)dst)[i] = ((char*)src)[i]; |
| } |
| } |
| |
| #define _MEMMOVEIF(dst, src, sz) \ |
| do {\ |
| if(dst != src) {\ |
| _qaic_memmove(dst, src, sz);\ |
| } \ |
| } while (0) |
| |
| |
| #define _ASSIGN(dst, src, sof) \ |
| do {\ |
| dst = OFFSET(src, sof); \ |
| } while (0) |
| |
| #define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str)) |
| |
| #include "AEEStdErr.h" |
| |
| #define _TRY(ee, func) \ |
| do { \ |
| if (AEE_SUCCESS != ((ee) = func)) {\ |
| __QAIC_DBG_PRINTF__((__FILE__ ":%d:error:%d:%s\n", __LINE__, (int)(ee),#func));\ |
| goto ee##bail;\ |
| } \ |
| } while (0) |
| |
| #define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS) |
| |
| #define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS) |
| |
| #ifdef __QAIC_DEBUG__ |
| #define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv)) |
| #else |
| #define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, 0, size, alignment, (void**)&pv)) |
| #endif |
| |
| |
| #endif // _QAIC_ENV_H |
| |
| #include "remote.h" |
| #include <string.h> |
| #ifndef _ALLOCATOR_H |
| #define _ALLOCATOR_H |
| |
| #include <stdlib.h> |
| #include <stdint.h> |
| |
| typedef struct _heap _heap; |
| struct _heap { |
| _heap* pPrev; |
| const char* loc; |
| uint64_t buf; |
| }; |
| |
| typedef struct _allocator { |
| _heap* pheap; |
| uint8_t* stack; |
| uint8_t* stackEnd; |
| int nSize; |
| } _allocator; |
| |
| _ATTRIBUTE_UNUSED |
| static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) { |
| _heap* pn = 0; |
| pn = malloc(size + sizeof(_heap) - sizeof(uint64_t)); |
| if(pn != 0) { |
| pn->pPrev = *ppa; |
| pn->loc = loc; |
| *ppa = pn; |
| *ppbuf = (void*)&(pn->buf); |
| return 0; |
| } else { |
| return -1; |
| } |
| } |
| #define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1)) |
| |
| _ATTRIBUTE_UNUSED |
| static __inline int _allocator_alloc(_allocator* me, |
| const char* loc, |
| int size, |
| unsigned int al, |
| void** ppbuf) { |
| if(size < 0) { |
| return -1; |
| } else if (size == 0) { |
| *ppbuf = 0; |
| return 0; |
| } |
| if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) { |
| *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al); |
| me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size; |
| return 0; |
| } else { |
| return _heap_alloc(&me->pheap, loc, size, ppbuf); |
| } |
| } |
| |
| _ATTRIBUTE_UNUSED |
| static __inline void _allocator_deinit(_allocator* me) { |
| _heap* pa = me->pheap; |
| while(pa != 0) { |
| _heap* pn = pa; |
| const char* loc = pn->loc; |
| (void)loc; |
| pa = pn->pPrev; |
| free(pn); |
| } |
| } |
| |
| _ATTRIBUTE_UNUSED |
| static __inline void _allocator_init(_allocator* me, uint8_t* stack, int stackSize) { |
| me->stack = stack; |
| me->stackEnd = stack + stackSize; |
| me->nSize = stackSize; |
| me->pheap = 0; |
| } |
| |
| |
| #endif // _ALLOCATOR_H |
| |
| #ifndef SLIM_H |
| #define SLIM_H |
| |
| #include <stdint.h> |
| |
| //a C data structure for the idl types that can be used to implement |
| //static and dynamic language bindings fairly efficiently. |
| // |
| //the goal is to have a minimal ROM and RAM footprint and without |
| //doing too many allocations. A good way to package these things seemed |
| //like the module boundary, so all the idls within one module can share |
| //all the type references. |
| |
| |
| #define PARAMETER_IN 0x0 |
| #define PARAMETER_OUT 0x1 |
| #define PARAMETER_INOUT 0x2 |
| #define PARAMETER_ROUT 0x3 |
| #define PARAMETER_INROUT 0x4 |
| |
| //the types that we get from idl |
| #define TYPE_OBJECT 0x0 |
| #define TYPE_INTERFACE 0x1 |
| #define TYPE_PRIMITIVE 0x2 |
| #define TYPE_ENUM 0x3 |
| #define TYPE_STRING 0x4 |
| #define TYPE_WSTRING 0x5 |
| #define TYPE_STRUCTURE 0x6 |
| #define TYPE_UNION 0x7 |
| #define TYPE_ARRAY 0x8 |
| #define TYPE_SEQUENCE 0x9 |
| |
| //these require the pack/unpack to recurse |
| //so it's a hint to those languages that can optimize in cases where |
| //recursion isn't necessary. |
| #define TYPE_COMPLEX_STRUCTURE (0x10 | TYPE_STRUCTURE) |
| #define TYPE_COMPLEX_UNION (0x10 | TYPE_UNION) |
| #define TYPE_COMPLEX_ARRAY (0x10 | TYPE_ARRAY) |
| #define TYPE_COMPLEX_SEQUENCE (0x10 | TYPE_SEQUENCE) |
| |
| |
| typedef struct Type Type; |
| |
| #define INHERIT_TYPE\ |
| int32_t nativeSize; /*in the simple case its the same as wire size and alignment*/\ |
| union {\ |
| struct {\ |
| const uintptr_t p1;\ |
| const uintptr_t p2;\ |
| } _cast;\ |
| struct {\ |
| uint32_t iid;\ |
| uint32_t bNotNil;\ |
| } object;\ |
| struct {\ |
| const Type *arrayType;\ |
| int32_t nItems;\ |
| } array;\ |
| struct {\ |
| const Type *seqType;\ |
| int32_t nMaxLen;\ |
| } seqSimple; \ |
| struct {\ |
| uint32_t bFloating;\ |
| uint32_t bSigned;\ |
| } prim; \ |
| const SequenceType* seqComplex;\ |
| const UnionType *unionType;\ |
| const StructType *structType;\ |
| int32_t stringMaxLen;\ |
| uint8_t bInterfaceNotNil;\ |
| } param;\ |
| uint8_t type;\ |
| uint8_t nativeAlignment\ |
| |
| typedef struct UnionType UnionType; |
| typedef struct StructType StructType; |
| typedef struct SequenceType SequenceType; |
| struct Type { |
| INHERIT_TYPE; |
| }; |
| |
| struct SequenceType { |
| const Type *seqType; |
| uint32_t nMaxLen; |
| uint32_t inSize; |
| uint32_t routSizePrimIn; |
| uint32_t routSizePrimROut; |
| }; |
| |
| //byte offset from the start of the case values for |
| //this unions case value array. it MUST be aligned |
| //at the alignment requrements for the descriptor |
| // |
| //if negative it means that the unions cases are |
| //simple enumerators, so the value read from the descriptor |
| //can be used directly to find the correct case |
| typedef union CaseValuePtr CaseValuePtr; |
| union CaseValuePtr { |
| const uint8_t* value8s; |
| const uint16_t* value16s; |
| const uint32_t* value32s; |
| const uint64_t* value64s; |
| }; |
| |
| //these are only used in complex cases |
| //so I pulled them out of the type definition as references to make |
| //the type smaller |
| struct UnionType { |
| const Type *descriptor; |
| uint32_t nCases; |
| const CaseValuePtr caseValues; |
| const Type * const *cases; |
| int32_t inSize; |
| int32_t routSizePrimIn; |
| int32_t routSizePrimROut; |
| uint8_t inAlignment; |
| uint8_t routAlignmentPrimIn; |
| uint8_t routAlignmentPrimROut; |
| uint8_t inCaseAlignment; |
| uint8_t routCaseAlignmentPrimIn; |
| uint8_t routCaseAlignmentPrimROut; |
| uint8_t nativeCaseAlignment; |
| uint8_t bDefaultCase; |
| }; |
| |
| struct StructType { |
| uint32_t nMembers; |
| const Type * const *members; |
| int32_t inSize; |
| int32_t routSizePrimIn; |
| int32_t routSizePrimROut; |
| uint8_t inAlignment; |
| uint8_t routAlignmentPrimIn; |
| uint8_t routAlignmentPrimROut; |
| }; |
| |
| typedef struct Parameter Parameter; |
| struct Parameter { |
| INHERIT_TYPE; |
| uint8_t mode; |
| uint8_t bNotNil; |
| }; |
| |
| #define SLIM_IFPTR32(is32,is64) (sizeof(uintptr_t) == 4 ? (is32) : (is64)) |
| #define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff) |
| |
| typedef struct Method Method; |
| struct Method { |
| uint32_t uScalars; //no method index |
| int32_t primInSize; |
| int32_t primROutSize; |
| int maxArgs; |
| int numParams; |
| const Parameter * const *params; |
| uint8_t primInAlignment; |
| uint8_t primROutAlignment; |
| }; |
| |
| typedef struct Interface Interface; |
| |
| struct Interface { |
| int nMethods; |
| const Method * const *methodArray; |
| int nIIds; |
| const uint32_t *iids; |
| const uint16_t* methodStringArray; |
| const uint16_t* methodStrings; |
| const char* strings; |
| }; |
| |
| |
| #endif //SLIM_H |
| |
| |
| #ifndef _ADSP_CURRENT_PROCESS_SLIM_H |
| #define _ADSP_CURRENT_PROCESS_SLIM_H |
| #include "remote.h" |
| #include <stdint.h> |
| |
| #ifndef __QAIC_SLIM |
| #define __QAIC_SLIM(ff) ff |
| #endif |
| #ifndef __QAIC_SLIM_EXPORT |
| #define __QAIC_SLIM_EXPORT |
| #endif |
| |
| static const Type types[1]; |
| static const SequenceType sequenceTypes[1] = {{&(types[0]),0x0,0x4,0x4,0x0}}; |
| static const Type types[1] = {{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)0x0,0}}, 4,SLIM_IFPTR32(0x4,0x8)}}; |
| static const Parameter parameters[3] = {{0x2,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x2,0,0},{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(sequenceTypes[0]),0}}, 25,SLIM_IFPTR32(0x4,0x8),0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x4,3,0}}; |
| static const Parameter* const parameterArrays[3] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2]))}; |
| static const Method methods[3] = {{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x0,0x0),0x0,0x0,0,0,0,0x0,0x0},{REMOTE_SCALARS_MAKEX(0,0,255,255,15,15),0x8,0x0,3,2,(&(parameterArrays[0])),0x4,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x0,0x1,0x0,0x0),0x0,0x4,1,1,(&(parameterArrays[2])),0x1,0x4}}; |
| static const Method* const methodArrays[4] = {&(methods[0]),&(methods[0]),&(methods[1]),&(methods[2])}; |
| static const char strings[60] = "set_logging_params\0thread_exit\0filesToLog\0getASID\0asid\0mask\0"; |
| static const uint16_t methodStrings[7] = {0,55,31,42,50,19,26}; |
| static const uint16_t methodStringsArrays[4] = {6,5,0,3}; |
| __QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(adsp_current_process_slim) = {4,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings}; |
| #endif //_ADSP_CURRENT_PROCESS_SLIM_H |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #ifndef _const_adsp_current_process_handle |
| #define _const_adsp_current_process_handle ((remote_handle)-1) |
| #endif //_const_adsp_current_process_handle |
| |
| static void _adsp_current_process_pls_dtor(void* data) { |
| remote_handle* ph = (remote_handle*)data; |
| if(_const_adsp_current_process_handle != *ph) { |
| (void)__QAIC_REMOTE(remote_handle_close)(*ph); |
| *ph = _const_adsp_current_process_handle; |
| } |
| } |
| |
| static int _adsp_current_process_pls_ctor(void* ctx, void* data) { |
| remote_handle* ph = (remote_handle*)data; |
| *ph = _const_adsp_current_process_handle; |
| if(*ph == (remote_handle)-1) { |
| return __QAIC_REMOTE(remote_handle_open)((const char*)ctx, ph); |
| } |
| return 0; |
| } |
| |
| #if (defined __qdsp6__) || (defined __hexagon__) |
| #pragma weak adsp_pls_add_lookup |
| extern int adsp_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo); |
| #pragma weak HAP_pls_add_lookup |
| extern int HAP_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo); |
| |
| __QAIC_STUB_EXPORT remote_handle _adsp_current_process_handle(void) { |
| remote_handle* ph; |
| if(adsp_pls_add_lookup) { |
| if(0 == adsp_pls_add_lookup((uint32_t)_adsp_current_process_handle, 0, sizeof(*ph), _adsp_current_process_pls_ctor, "adsp_current_process", _adsp_current_process_pls_dtor, (void**)&ph)) { |
| return *ph; |
| } |
| return (remote_handle)-1; |
| } else if(HAP_pls_add_lookup) { |
| if(0 == HAP_pls_add_lookup((uint32_t)_adsp_current_process_handle, 0, sizeof(*ph), _adsp_current_process_pls_ctor, "adsp_current_process", _adsp_current_process_pls_dtor, (void**)&ph)) { |
| return *ph; |
| } |
| return (remote_handle)-1; |
| } |
| return(remote_handle)-1; |
| } |
| |
| #else //__qdsp6__ || __hexagon__ |
| |
| uint32_t _adsp_current_process_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare); |
| |
| #ifdef _WIN32 |
| #include "Windows.h" |
| uint32_t _adsp_current_process_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) { |
| return (uint32_t)InterlockedCompareExchange((volatile LONG*)puDest, (LONG)uExchange, (LONG)uCompare); |
| } |
| #elif __GNUC__ |
| uint32_t _adsp_current_process_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) { |
| return __sync_val_compare_and_swap(puDest, uCompare, uExchange); |
| } |
| #endif //_WIN32 |
| |
| |
| __QAIC_STUB_EXPORT remote_handle _adsp_current_process_handle(void) { |
| static remote_handle handle = _const_adsp_current_process_handle; |
| if((remote_handle)-1 != handle) { |
| return handle; |
| } else { |
| remote_handle tmp; |
| int nErr = _adsp_current_process_pls_ctor("adsp_current_process", (void*)&tmp); |
| if(nErr) { |
| return (remote_handle)-1; |
| } |
| if(((remote_handle)-1 != handle) || ((remote_handle)-1 != (remote_handle)_adsp_current_process_atomic_CompareAndExchange((uint32_t*)&handle, (uint32_t)tmp, (uint32_t)-1))) { |
| _adsp_current_process_pls_dtor(&tmp); |
| } |
| return handle; |
| } |
| } |
| |
| #endif //__qdsp6__ |
| |
| __QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE { |
| return __QAIC_REMOTE(remote_handle_invoke)(_adsp_current_process_handle(), _sc, _pra); |
| } |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| static __inline int _stub_method(remote_handle _handle, uint32_t _mid) { |
| remote_arg* _pra = 0; |
| int _nErr = 0; |
| _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 0, 0, 0), _pra)); |
| _CATCH(_nErr) {} |
| return _nErr; |
| } |
| __QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_exit)(void) __QAIC_STUB_ATTRIBUTE { |
| uint32_t _mid = 0; |
| return _stub_method(_adsp_current_process_handle(), _mid); |
| } |
| __QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_thread_exit)(void) __QAIC_STUB_ATTRIBUTE { |
| uint32_t _mid = 1; |
| return _stub_method(_adsp_current_process_handle(), _mid); |
| } |
| static __inline int _stub_unpack(remote_arg* _praROutPost, remote_arg* _ppraROutPost[1], void* _primROut, char* _in0[1], uint32_t _in0Len[1]) { |
| int _nErr = 0; |
| remote_arg* _praROutPostStart = _praROutPost; |
| remote_arg** _ppraROutPostStart = _ppraROutPost; |
| _ppraROutPost = &_praROutPost; |
| _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) +0; |
| return _nErr; |
| } |
| static __inline int _stub_pack(_allocator* _al, remote_arg* _praIn, remote_arg* _ppraIn[1], remote_arg* _praROut, remote_arg* _ppraROut[1], void* _primIn, void* _primROut, char* _in0[1], uint32_t _in0Len[1]) { |
| int _nErr = 0; |
| remote_arg* _praInStart = _praIn; |
| remote_arg** _ppraInStart = _ppraIn; |
| remote_arg* _praROutStart = _praROut; |
| remote_arg** _ppraROutStart = _ppraROut; |
| _ppraIn = &_praIn; |
| _ppraROut = &_praROut; |
| _in0Len[0] = (1 + strlen(_in0[0])); |
| _COPY(_primIn, 0, _in0Len, 0, 4); |
| _praIn[0].buf.pv = _in0[0]; |
| _praIn[0].buf.nLen = (1 * _in0Len[0]); |
| _ppraInStart[0] += (_praIn - _praInStart) + 1; |
| _ppraROutStart[0] += (_praROut - _praROutStart) +0; |
| return _nErr; |
| } |
| static __inline void _count(int _numIn[1], int _numROut[1], char* _in0[1], uint32_t _in0Len[1]) { |
| _numIn[0] += 1; |
| _numROut[0] += 0; |
| } |
| static __inline int _stub_method_1(remote_handle _handle, uint32_t _mid, uint16_t _in0[1], void* _in1[1], uint32_t _in1Len[1]) { |
| remote_arg* _pra; |
| int _numIn[1]; |
| int _numROut[1]; |
| char* _seq_nat1; |
| int _ii; |
| _allocator _al[1] = {{0}}; |
| uint32_t _primIn[2]; |
| remote_arg* _praIn; |
| remote_arg** _ppraIn = &_praIn; |
| remote_arg* _praROut; |
| remote_arg** _ppraROut = &_praROut; |
| char* _seq_primIn1; |
| int _nErr = 0; |
| remote_arg* _praROutPost; |
| remote_arg** _ppraROutPost = &_praROutPost; |
| _numIn[0] = 1; |
| _numROut[0] = 0; |
| for(_ii = 0, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16))) |
| { |
| _count(_numIn, _numROut, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2]))); |
| } |
| _allocator_init(_al, 0, 0); |
| _ALLOCATE(_nErr, _al, ((((_numIn[0] + _numROut[0]) + 1) + 0) * sizeof(_pra[0])), 4, _pra); |
| _pra[0].buf.pv = (void*)_primIn; |
| _pra[0].buf.nLen = sizeof(_primIn); |
| _COPY(_primIn, 0, _in0, 0, 2); |
| _COPY(_primIn, 4, _in1Len, 0, 4); |
| _praIn = (_pra + 1); |
| _praROut = (_praIn + _numIn[0] + 0); |
| _ALLOCATE(_nErr, _al, (_in1Len[0] * 4), 4, _praIn[0].buf.pv); |
| _praIn[0].buf.nLen = (4 * _in1Len[0]); |
| for(_ii = 0, _seq_primIn1 = (char*)_praIn[0].buf.pv, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_primIn1 = (_seq_primIn1 + 4), _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16))) |
| { |
| _TRY(_nErr, _stub_pack(_al, (_praIn + 1), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn1, 0, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2])))); |
| } |
| _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, (_numIn[0] + 1), (_numROut[0] + 0), 0, 0), _pra)); |
| _praROutPost = _praROut; |
| for(_ii = 0, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16))) |
| { |
| _TRY(_nErr, _stub_unpack((_praROutPost + 0), _ppraROutPost, 0, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2])))); |
| } |
| _CATCH(_nErr) {} |
| _allocator_deinit(_al); |
| return _nErr; |
| } |
| __QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_set_logging_params)(unsigned short mask, const _cstring1_t* filesToLog, int filesToLogLen) __QAIC_STUB_ATTRIBUTE { |
| uint32_t _mid = 2; |
| return _stub_method_1(_adsp_current_process_handle(), _mid, (uint16_t*)&mask, (void**)&filesToLog, (uint32_t*)&filesToLogLen); |
| } |
| static __inline int _stub_method_2(remote_handle _handle, uint32_t _mid, uint32_t _rout0[1]) { |
| int _numIn[1]; |
| remote_arg _pra[1]; |
| uint32_t _primROut[1]; |
| int _nErr = 0; |
| _numIn[0] = 0; |
| _pra[(_numIn[0] + 0)].buf.pv = (void*)_primROut; |
| _pra[(_numIn[0] + 0)].buf.nLen = sizeof(_primROut); |
| _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 1, 0, 0), _pra)); |
| _COPY(_rout0, 0, _primROut, 0, 4); |
| _CATCH(_nErr) {} |
| return _nErr; |
| } |
| __QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_getASID)(unsigned int* asid) __QAIC_STUB_ATTRIBUTE { |
| uint32_t _mid = 3; |
| return _stub_method_2(_adsp_current_process_handle(), _mid, (uint32_t*)asid); |
| } |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif //_ADSP_CURRENT_PROCESS_STUB_H |
