1558 lines · cpp
1 2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#include "kmp_config.h" // INTEL_ITTNOTIFY_PREFIX definition11#include "ittnotify_config.h"12 13#if ITT_PLATFORM == ITT_PLATFORM_WIN14#if !defined(PATH_MAX)15#define PATH_MAX 51216#endif17#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */18#include <limits.h>19#include <dlfcn.h>20#include <errno.h>21#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */22#include <stdio.h>23#include <stdlib.h>24#include <stdarg.h>25#include <string.h>26 27#define INTEL_NO_MACRO_BODY28#define INTEL_ITTNOTIFY_API_PRIVATE29#include "ittnotify.h"30#include "legacy/ittnotify.h"31 32#include "disable_warnings.h"33 34static const char api_version[] = API_VERSION "\0\n@(#) $Revision$\n";35 36#define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)37 38#ifndef HAS_CPP_ATTR39#if defined(__cplusplus) && defined(__has_cpp_attribute)40#define HAS_CPP_ATTR(X) __has_cpp_attribute(X)41#else42#define HAS_CPP_ATTR(X) 043#endif44#endif45 46#ifndef HAS_C_ATTR47#if defined(__STDC__) && defined(__has_c_attribute)48#define HAS_C_ATTR(X) __has_c_attribute(X)49#else50#define HAS_C_ATTR(X) 051#endif52#endif53 54#ifndef HAS_GNU_ATTR55#if defined(__has_attribute)56#define HAS_GNU_ATTR(X) __has_attribute(X)57#else58#define HAS_GNU_ATTR(X) 059#endif60#endif61 62#ifndef ITT_ATTRIBUTE_FALLTHROUGH63#if (HAS_CPP_ATTR(fallthrough) || HAS_C_ATTR(fallthrough)) && \64 (__cplusplus >= 201703L || _MSVC_LANG >= 201703L)65#define ITT_ATTRIBUTE_FALLTHROUGH [[fallthrough]]66#elif HAS_CPP_ATTR(gnu::fallthrough)67#define ITT_ATTRIBUTE_FALLTHROUGH [[gnu::fallthrough]]68#elif HAS_CPP_ATTR(clang::fallthrough)69#define ITT_ATTRIBUTE_FALLTHROUGH [[clang::fallthrough]]70#elif HAS_GNU_ATTR(fallthrough) && !__INTEL_COMPILER71#define ITT_ATTRIBUTE_FALLTHROUGH __attribute__((fallthrough))72#else73#define ITT_ATTRIBUTE_FALLTHROUGH74#endif75#endif76 77#if ITT_OS == ITT_OS_WIN78static const char *ittnotify_lib_name = "libittnotify.dll";79#elif ITT_OS == ITT_OS_LINUX || ITT_OS == ITT_OS_FREEBSD80static const char *ittnotify_lib_name = "libittnotify.so";81#elif ITT_OS == ITT_OS_MAC82static const char *ittnotify_lib_name = "libittnotify.dylib";83#else84#error Unsupported or unknown OS.85#endif86 87#ifdef __ANDROID__88#include <android/log.h>89#include <stdio.h>90#include <unistd.h>91#include <sys/types.h>92#include <sys/stat.h>93#include <fcntl.h>94#include <linux/limits.h>95 96#ifdef ITT_ANDROID_LOG97#define ITT_ANDROID_LOG_TAG "INTEL_VTUNE_USERAPI"98#define ITT_ANDROID_LOGI(...) \99 ((void)__android_log_print(ANDROID_LOG_INFO, ITT_ANDROID_LOG_TAG, \100 __VA_ARGS__))101#define ITT_ANDROID_LOGW(...) \102 ((void)__android_log_print(ANDROID_LOG_WARN, ITT_ANDROID_LOG_TAG, \103 __VA_ARGS__))104#define ITT_ANDROID_LOGE(...) \105 ((void)__android_log_print(ANDROID_LOG_ERROR, ITT_ANDROID_LOG_TAG, \106 __VA_ARGS__))107#define ITT_ANDROID_LOGD(...) \108 ((void)__android_log_print(ANDROID_LOG_DEBUG, ITT_ANDROID_LOG_TAG, \109 __VA_ARGS__))110#else111#define ITT_ANDROID_LOGI(...)112#define ITT_ANDROID_LOGW(...)113#define ITT_ANDROID_LOGE(...)114#define ITT_ANDROID_LOGD(...)115#endif116 117/* default location of userapi collector on Android */118#define ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(x) \119 "/data/data/com.intel.vtune/perfrun/lib" #x "/runtime/libittnotify.so"120 121#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM122#define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32)123#else124#define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64)125#endif126 127#endif128 129#ifndef LIB_VAR_NAME130#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM131#define LIB_VAR_NAME INTEL_LIBITTNOTIFY32132#else133#define LIB_VAR_NAME INTEL_LIBITTNOTIFY64134#endif135#endif /* LIB_VAR_NAME */136 137#define ITT_MUTEX_INIT_AND_LOCK(p) \138 { \139 if (PTHREAD_SYMBOLS) { \140 if (!p.mutex_initialized) { \141 if (__itt_interlocked_increment(&p.atomic_counter) == 1) { \142 __itt_mutex_init(&p.mutex); \143 p.mutex_initialized = 1; \144 } else \145 while (!p.mutex_initialized) \146 __itt_thread_yield(); \147 } \148 __itt_mutex_lock(&p.mutex); \149 } \150 }151 152#define ITT_MODULE_OBJECT_VERSION 1153 154typedef int(__itt_init_ittlib_t)(const char *, __itt_group_id);155 156/* this define used to control initialization function name. */157#ifndef __itt_init_ittlib_name158ITT_EXTERN_C int _N_(init_ittlib)(const char *, __itt_group_id);159static __itt_init_ittlib_t *__itt_init_ittlib_ptr = _N_(init_ittlib);160#define __itt_init_ittlib_name __itt_init_ittlib_ptr161#endif /* __itt_init_ittlib_name */162 163typedef void(__itt_fini_ittlib_t)(void);164 165/* this define used to control finalization function name. */166#ifndef __itt_fini_ittlib_name167ITT_EXTERN_C void _N_(fini_ittlib)(void);168static __itt_fini_ittlib_t *__itt_fini_ittlib_ptr = _N_(fini_ittlib);169#define __itt_fini_ittlib_name __itt_fini_ittlib_ptr170#endif /* __itt_fini_ittlib_name */171 172extern __itt_global _N_(_ittapi_global);173 174/* building pointers to imported funcs */175#undef ITT_STUBV176#undef ITT_STUB177#define ITT_STUB(api, type, name, args, params, ptr, group, format) \178 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \179 typedef type api ITT_JOIN(_N_(name), _t) args; \180 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \181 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \182 ITT_EXTERN_C_END \183 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args { \184 if (!_N_(_ittapi_global).api_initialized && \185 _N_(_ittapi_global).thread_list == NULL) \186 __itt_init_ittlib_name(NULL, __itt_group_all); \187 if (ITTNOTIFY_NAME(name) && \188 ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init))) \189 return ITTNOTIFY_NAME(name) params; \190 else \191 return (type)0; \192 }193 194#define ITT_STUBV(api, type, name, args, params, ptr, group, format) \195 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \196 typedef type api ITT_JOIN(_N_(name), _t) args; \197 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \198 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \199 ITT_EXTERN_C_END \200 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args { \201 if (!_N_(_ittapi_global).api_initialized && \202 _N_(_ittapi_global).thread_list == NULL) \203 __itt_init_ittlib_name(NULL, __itt_group_all); \204 if (ITTNOTIFY_NAME(name) && \205 ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init))) \206 ITTNOTIFY_NAME(name) params; \207 else \208 return; \209 }210 211#undef __ITT_INTERNAL_INIT212#include "ittnotify_static.h"213 214#undef ITT_STUB215#undef ITT_STUBV216#define ITT_STUB(api, type, name, args, params, ptr, group, format) \217 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \218 typedef type api ITT_JOIN(_N_(name), _t) args; \219 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \220 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \221 ITT_EXTERN_C_END222 223#define ITT_STUBV(api, type, name, args, params, ptr, group, format) \224 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \225 typedef type api ITT_JOIN(_N_(name), _t) args; \226 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \227 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \228 ITT_EXTERN_C_END229 230#define __ITT_INTERNAL_INIT231#include "ittnotify_static.h"232#undef __ITT_INTERNAL_INIT233 234ITT_GROUP_LIST(group_list);235 236#pragma pack(push, 8)237 238typedef struct ___itt_group_alias {239 const char *env_var;240 __itt_group_id groups;241} __itt_group_alias;242 243static __itt_group_alias group_alias[] = {244 {"KMP_FOR_TPROFILE",245 (__itt_group_id)(__itt_group_control | __itt_group_thread |246 __itt_group_sync | __itt_group_mark)},247 {"KMP_FOR_TCHECK",248 (__itt_group_id)(__itt_group_control | __itt_group_thread |249 __itt_group_sync | __itt_group_fsync | __itt_group_mark |250 __itt_group_suppress)},251 {NULL, (__itt_group_none)},252 {api_version,253 (__itt_group_none)} /* !!! Just to avoid unused code elimination !!! */254};255 256#pragma pack(pop)257 258#if ITT_PLATFORM == ITT_PLATFORM_WIN259#if _MSC_VER260#pragma warning(push)261#pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function \262 pointer 'XXX' to data pointer 'void *' */263#endif264#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */265 266static __itt_api_info api_list[] = {267/* Define functions with static implementation */268#undef ITT_STUB269#undef ITT_STUBV270#define ITT_STUB(api, type, name, args, params, nameindll, group, format) \271 {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)), \272 (void **)(void *)&ITTNOTIFY_NAME(name), \273 (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), \274 (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), \275 (__itt_group_id)(group)},276#define ITT_STUBV ITT_STUB277#define __ITT_INTERNAL_INIT278#include "ittnotify_static.h"279#undef __ITT_INTERNAL_INIT280/* Define functions without static implementation */281#undef ITT_STUB282#undef ITT_STUBV283#define ITT_STUB(api, type, name, args, params, nameindll, group, format) \284 {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)), \285 (void **)(void *)&ITTNOTIFY_NAME(name), \286 (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), NULL, \287 (__itt_group_id)(group)},288#define ITT_STUBV ITT_STUB289#include "ittnotify_static.h"290 {NULL, NULL, NULL, NULL, __itt_group_none}};291 292#if ITT_PLATFORM == ITT_PLATFORM_WIN293#if _MSC_VER294#pragma warning(pop)295#endif296#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */297 298/* static part descriptor which handles. all notification api attributes. */299__itt_global _N_(_ittapi_global) = {300 ITT_MAGIC, /* identification info */301 ITT_MAJOR,302 ITT_MINOR,303 API_VERSION_BUILD, /* version info */304 0, /* api_initialized */305 0, /* mutex_initialized */306 0, /* atomic_counter */307 MUTEX_INITIALIZER, /* mutex */308 NULL, /* dynamic library handle */309 NULL, /* error_handler */310 NULL, /* dll_path_ptr */311 (__itt_api_info *)&api_list, /* api_list_ptr */312 NULL, /* next __itt_global */313 NULL, /* thread_list */314 NULL, /* domain_list */315 NULL, /* string_list */316 __itt_collection_normal, /* collection state */317 NULL, /* counter_list */318 0, /* ipt_collect_events */319 NULL /* histogram_list */320};321 322typedef void(__itt_api_init_t)(__itt_global *, __itt_group_id);323typedef void(__itt_api_fini_t)(__itt_global *);324 325static __itt_domain dummy_domain;326/* ========================================================================= */327 328#ifdef ITT_NOTIFY_EXT_REPORT329ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args);330#endif /* ITT_NOTIFY_EXT_REPORT */331 332#if ITT_PLATFORM == ITT_PLATFORM_WIN333#if _MSC_VER334#pragma warning(push)335#pragma warning( \336 disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \337 to function pointer 'XXX' */338#endif339#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */340 341static void __itt_report_error(int code, ...) {342 va_list args;343 va_start(args, code);344 if (_N_(_ittapi_global).error_handler != NULL) {345 __itt_error_handler_t *handler =346 (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;347 handler((__itt_error_code)code, args);348 }349#ifdef ITT_NOTIFY_EXT_REPORT350 _N_(error_handler)((__itt_error_code)code, args);351#endif /* ITT_NOTIFY_EXT_REPORT */352 va_end(args);353}354 355#if ITT_PLATFORM == ITT_PLATFORM_WIN356#if _MSC_VER357#pragma warning(pop)358#endif359#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */360 361#if ITT_PLATFORM == ITT_PLATFORM_WIN362static __itt_domain *ITTAPI363ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))(const wchar_t *name) {364 __itt_domain *h_tail = NULL, *h = NULL;365 366 if (name == NULL) {367 return NULL;368 }369 370 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));371 if (_N_(_ittapi_global).api_initialized) {372 if (ITTNOTIFY_NAME(domain_createW) &&373 ITTNOTIFY_NAME(domain_createW) !=374 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))) {375 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);376 return ITTNOTIFY_NAME(domain_createW)(name);377 } else {378 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);379 return &dummy_domain;380 }381 }382 for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;383 h_tail = h, h = h->next) {384 if (h->nameW != NULL && !wcscmp(h->nameW, name))385 break;386 }387 if (h == NULL) {388 NEW_DOMAIN_W(&_N_(_ittapi_global), h, h_tail, name);389 }390 if (PTHREAD_SYMBOLS)391 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);392 return h;393}394 395static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),396 _init))(const char *name)397#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */398static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),399 _init))(const char *name)400#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */401{402 __itt_domain *h_tail = NULL, *h = NULL;403 404 if (name == NULL) {405 return NULL;406 }407 408 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));409 if (_N_(_ittapi_global).api_initialized) {410#if ITT_PLATFORM == ITT_PLATFORM_WIN411 if (ITTNOTIFY_NAME(domain_createA) &&412 ITTNOTIFY_NAME(domain_createA) !=413 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA), _init))) {414 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);415 return ITTNOTIFY_NAME(domain_createA)(name);416 }417#else418 if (ITTNOTIFY_NAME(domain_create) &&419 ITTNOTIFY_NAME(domain_create) !=420 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create), _init))) {421 if (PTHREAD_SYMBOLS)422 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);423 return ITTNOTIFY_NAME(domain_create)(name);424 }425#endif426 else {427#if ITT_PLATFORM == ITT_PLATFORM_WIN428 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);429#else430 if (PTHREAD_SYMBOLS)431 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);432#endif433 return &dummy_domain;434 }435 }436 for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;437 h_tail = h, h = h->next) {438 if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name))439 break;440 }441 if (h == NULL) {442 NEW_DOMAIN_A(&_N_(_ittapi_global), h, h_tail, name);443 }444 if (PTHREAD_SYMBOLS)445 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);446 return h;447}448 449static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(450 _N_(module_load_with_sections), _init))(__itt_module_object *module_obj) {451 if (!_N_(_ittapi_global).api_initialized &&452 _N_(_ittapi_global).thread_list == NULL) {453 __itt_init_ittlib_name(NULL, __itt_group_all);454 }455 if (ITTNOTIFY_NAME(module_load_with_sections) &&456 ITTNOTIFY_NAME(module_load_with_sections) !=457 ITT_VERSIONIZE(ITT_JOIN(_N_(module_load_with_sections), _init))) {458 if (module_obj != NULL) {459 module_obj->version = ITT_MODULE_OBJECT_VERSION;460 ITTNOTIFY_NAME(module_load_with_sections)(module_obj);461 }462 }463}464 465static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(466 _N_(module_unload_with_sections), _init))(__itt_module_object *module_obj) {467 if (!_N_(_ittapi_global).api_initialized &&468 _N_(_ittapi_global).thread_list == NULL) {469 __itt_init_ittlib_name(NULL, __itt_group_all);470 }471 if (ITTNOTIFY_NAME(module_unload_with_sections) &&472 ITTNOTIFY_NAME(module_unload_with_sections) !=473 ITT_VERSIONIZE(ITT_JOIN(_N_(module_unload_with_sections), _init))) {474 if (module_obj != NULL) {475 module_obj->version = ITT_MODULE_OBJECT_VERSION;476 ITTNOTIFY_NAME(module_unload_with_sections)(module_obj);477 }478 }479}480 481#if ITT_PLATFORM == ITT_PLATFORM_WIN482static __itt_string_handle *ITTAPI ITT_VERSIONIZE(483 ITT_JOIN(_N_(string_handle_createW), _init))(const wchar_t *name) {484 __itt_string_handle *h_tail = NULL, *h = NULL;485 486 if (name == NULL) {487 return NULL;488 }489 490 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));491 if (_N_(_ittapi_global).api_initialized) {492 if (ITTNOTIFY_NAME(string_handle_createW) &&493 ITTNOTIFY_NAME(string_handle_createW) !=494 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW), _init))) {495 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);496 return ITTNOTIFY_NAME(string_handle_createW)(name);497 } else {498 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);499 return NULL;500 }501 }502 for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;503 h_tail = h, h = h->next) {504 if (h->strW != NULL && !wcscmp(h->strW, name))505 break;506 }507 if (h == NULL) {508 NEW_STRING_HANDLE_W(&_N_(_ittapi_global), h, h_tail, name);509 }510 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);511 return h;512}513 514static __itt_string_handle *ITTAPI515ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))(const char *name)516#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */517static __itt_string_handle *ITTAPI518ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))(const char *name)519#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */520{521 __itt_string_handle *h_tail = NULL, *h = NULL;522 523 if (name == NULL) {524 return NULL;525 }526 527 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));528 if (_N_(_ittapi_global).api_initialized) {529#if ITT_PLATFORM == ITT_PLATFORM_WIN530 if (ITTNOTIFY_NAME(string_handle_createA) &&531 ITTNOTIFY_NAME(string_handle_createA) !=532 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))) {533 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);534 return ITTNOTIFY_NAME(string_handle_createA)(name);535 }536#else537 if (ITTNOTIFY_NAME(string_handle_create) &&538 ITTNOTIFY_NAME(string_handle_create) !=539 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))) {540 if (PTHREAD_SYMBOLS)541 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);542 return ITTNOTIFY_NAME(string_handle_create)(name);543 }544#endif545 else {546#if ITT_PLATFORM == ITT_PLATFORM_WIN547 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);548#else549 if (PTHREAD_SYMBOLS)550 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);551#endif552 return NULL;553 }554 }555 for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;556 h_tail = h, h = h->next) {557 if (h->strA != NULL && !__itt_fstrcmp(h->strA, name))558 break;559 }560 if (h == NULL) {561 NEW_STRING_HANDLE_A(&_N_(_ittapi_global), h, h_tail, name);562 }563 if (PTHREAD_SYMBOLS)564 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);565 return h;566}567 568#if ITT_PLATFORM == ITT_PLATFORM_WIN569static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(570 _N_(counter_createW), _init))(const wchar_t *name, const wchar_t *domain) {571 __itt_counter_info_t *h_tail = NULL, *h = NULL;572 __itt_metadata_type type = __itt_metadata_u64;573 574 if (name == NULL) {575 return NULL;576 }577 578 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));579 if (_N_(_ittapi_global).api_initialized) {580 if (ITTNOTIFY_NAME(counter_createW) &&581 ITTNOTIFY_NAME(counter_createW) !=582 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW), _init))) {583 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);584 return ITTNOTIFY_NAME(counter_createW)(name, domain);585 } else {586 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);587 return NULL;588 }589 }590 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;591 h_tail = h, h = h->next) {592 if (h->nameW != NULL && h->type == (int)type && !wcscmp(h->nameW, name) &&593 ((h->domainW == NULL && domain == NULL) ||594 (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))595 break;596 }597 if (h == NULL) {598 NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);599 }600 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);601 return (__itt_counter)h;602}603 604static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),605 _init))(const char *name,606 const char *domain)607#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */608static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),609 _init))(const char *name,610 const char *domain)611#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */612{613 __itt_counter_info_t *h_tail = NULL, *h = NULL;614 __itt_metadata_type type = __itt_metadata_u64;615 616 if (name == NULL) {617 return NULL;618 }619 620 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));621 if (_N_(_ittapi_global).api_initialized) {622#if ITT_PLATFORM == ITT_PLATFORM_WIN623 if (ITTNOTIFY_NAME(counter_createA) &&624 ITTNOTIFY_NAME(counter_createA) !=625 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA), _init))) {626 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);627 return ITTNOTIFY_NAME(counter_createA)(name, domain);628 }629#else630 if (ITTNOTIFY_NAME(counter_create) &&631 ITTNOTIFY_NAME(counter_create) !=632 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create), _init))) {633 if (PTHREAD_SYMBOLS)634 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);635 return ITTNOTIFY_NAME(counter_create)(name, domain);636 }637#endif638 else {639#if ITT_PLATFORM == ITT_PLATFORM_WIN640 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);641#else642 if (PTHREAD_SYMBOLS)643 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);644#endif645 return NULL;646 }647 }648 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;649 h_tail = h, h = h->next) {650 if (h->nameA != NULL && h->type == (int)type &&651 !__itt_fstrcmp(h->nameA, name) &&652 ((h->domainA == NULL && domain == NULL) ||653 (h->domainA != NULL && domain != NULL &&654 !__itt_fstrcmp(h->domainA, domain))))655 break;656 }657 if (h == NULL) {658 NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);659 }660 if (PTHREAD_SYMBOLS)661 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);662 return (__itt_counter)h;663}664 665#if ITT_PLATFORM == ITT_PLATFORM_WIN666static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),667 _init))(668 const wchar_t *name, const wchar_t *domain, __itt_metadata_type type) {669 __itt_counter_info_t *h_tail = NULL, *h = NULL;670 671 if (name == NULL) {672 return NULL;673 }674 675 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));676 if (_N_(_ittapi_global).api_initialized) {677 if (ITTNOTIFY_NAME(counter_create_typedW) &&678 ITTNOTIFY_NAME(counter_create_typedW) !=679 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW), _init))) {680 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);681 return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type);682 } else {683 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);684 return NULL;685 }686 }687 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;688 h_tail = h, h = h->next) {689 if (h->nameW != NULL && h->type == (int)type && !wcscmp(h->nameW, name) &&690 ((h->domainW == NULL && domain == NULL) ||691 (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))692 break;693 }694 if (h == NULL) {695 NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);696 }697 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);698 return (__itt_counter)h;699}700 701static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(702 _N_(counter_create_typedA), _init))(const char *name, const char *domain,703 __itt_metadata_type type)704#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */705static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(706 _N_(counter_create_typed), _init))(const char *name, const char *domain,707 __itt_metadata_type type)708#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */709{710 __itt_counter_info_t *h_tail = NULL, *h = NULL;711 712 if (name == NULL) {713 return NULL;714 }715 716 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));717 if (_N_(_ittapi_global).api_initialized) {718#if ITT_PLATFORM == ITT_PLATFORM_WIN719 if (ITTNOTIFY_NAME(counter_create_typedA) &&720 ITTNOTIFY_NAME(counter_create_typedA) !=721 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA), _init))) {722 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);723 return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type);724 }725#else726 if (ITTNOTIFY_NAME(counter_create_typed) &&727 ITTNOTIFY_NAME(counter_create_typed) !=728 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed), _init))) {729 if (PTHREAD_SYMBOLS)730 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);731 return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type);732 }733#endif734 else {735#if ITT_PLATFORM == ITT_PLATFORM_WIN736 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);737#else738 if (PTHREAD_SYMBOLS)739 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);740#endif741 return NULL;742 }743 }744 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;745 h_tail = h, h = h->next) {746 if (h->nameA != NULL && h->type == (int)type &&747 !__itt_fstrcmp(h->nameA, name) &&748 ((h->domainA == NULL && domain == NULL) ||749 (h->domainA != NULL && domain != NULL &&750 !__itt_fstrcmp(h->domainA, domain))))751 break;752 }753 if (h == NULL) {754 NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);755 }756 if (PTHREAD_SYMBOLS)757 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);758 return (__itt_counter)h;759}760 761#if ITT_PLATFORM == ITT_PLATFORM_WIN762static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createW),763 _init))(764 const __itt_domain *domain, const wchar_t *name, __itt_metadata_type x_type,765 __itt_metadata_type y_type) {766 __itt_histogram *h_tail = NULL, *h = NULL;767 768 if (domain == NULL || name == NULL) {769 return NULL;770 }771 772 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));773 if (_N_(_ittapi_global).api_initialized) {774 if (ITTNOTIFY_NAME(histogram_createW) &&775 ITTNOTIFY_NAME(histogram_createW) !=776 ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createW), _init))) {777 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);778 return ITTNOTIFY_NAME(histogram_createW)(domain, name, x_type, y_type);779 } else {780 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);781 return NULL;782 }783 }784 for (h_tail = NULL, h = _N_(_ittapi_global).histogram_list; h != NULL;785 h_tail = h, h = h->next) {786 if (h->domain == NULL)787 continue;788 else if (h->domain != domain && h->nameW != NULL && !wcscmp(h->nameW, name))789 break;790 }791 if (h == NULL) {792 NEW_HISTOGRAM_W(&_N_(_ittapi_global), h, h_tail, domain, name, x_type,793 y_type);794 }795 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);796 return (__itt_histogram *)h;797}798 799static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createA),800 _init))(801 const __itt_domain *domain, const char *name, __itt_metadata_type x_type,802 __itt_metadata_type y_type)803#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */804static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(805 _N_(histogram_create), _init))(const __itt_domain *domain, const char *name,806 __itt_metadata_type x_type,807 __itt_metadata_type y_type)808#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */809{810 __itt_histogram *h_tail = NULL, *h = NULL;811 812 if (domain == NULL || name == NULL) {813 return NULL;814 }815 816 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));817 if (_N_(_ittapi_global).api_initialized) {818#if ITT_PLATFORM == ITT_PLATFORM_WIN819 if (ITTNOTIFY_NAME(histogram_createA) &&820 ITTNOTIFY_NAME(histogram_createA) !=821 ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createA), _init))) {822 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);823 return ITTNOTIFY_NAME(histogram_createA)(domain, name, x_type, y_type);824 }825#else826 if (ITTNOTIFY_NAME(histogram_create) &&827 ITTNOTIFY_NAME(histogram_create) !=828 ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_create), _init))) {829 if (PTHREAD_SYMBOLS)830 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);831 return ITTNOTIFY_NAME(histogram_create)(domain, name, x_type, y_type);832 }833#endif834 else {835#if ITT_PLATFORM == ITT_PLATFORM_WIN836 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);837#else838 if (PTHREAD_SYMBOLS)839 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);840#endif841 return NULL;842 }843 }844 for (h_tail = NULL, h = _N_(_ittapi_global).histogram_list; h != NULL;845 h_tail = h, h = h->next) {846 if (h->domain == NULL)847 continue;848 else if (h->domain != domain && h->nameA != NULL &&849 !__itt_fstrcmp(h->nameA, name))850 break;851 }852 if (h == NULL) {853 NEW_HISTOGRAM_A(&_N_(_ittapi_global), h, h_tail, domain, name, x_type,854 y_type);855 }856 if (PTHREAD_SYMBOLS)857 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);858 return (__itt_histogram *)h;859}860 861/* -------------------------------------------------------------------------- */862 863static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))(void) {864 if (!_N_(_ittapi_global).api_initialized &&865 _N_(_ittapi_global).thread_list == NULL) {866 __itt_init_ittlib_name(NULL, __itt_group_all);867 }868 if (ITTNOTIFY_NAME(pause) &&869 ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))) {870 ITTNOTIFY_NAME(pause)();871 } else {872 _N_(_ittapi_global).state = __itt_collection_paused;873 }874}875 876static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))(void) {877 if (!_N_(_ittapi_global).api_initialized &&878 _N_(_ittapi_global).thread_list == NULL) {879 __itt_init_ittlib_name(NULL, __itt_group_all);880 }881 if (ITTNOTIFY_NAME(resume) &&882 ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))) {883 ITTNOTIFY_NAME(resume)();884 } else {885 _N_(_ittapi_global).state = __itt_collection_normal;886 }887}888 889#if ITT_PLATFORM == ITT_PLATFORM_WIN890static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),891 _init))(const wchar_t *name) {892 if (!_N_(_ittapi_global).api_initialized &&893 _N_(_ittapi_global).thread_list == NULL) {894 __itt_init_ittlib_name(NULL, __itt_group_all);895 }896 if (ITTNOTIFY_NAME(thread_set_nameW) &&897 ITTNOTIFY_NAME(thread_set_nameW) !=898 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))) {899 ITTNOTIFY_NAME(thread_set_nameW)(name);900 }901}902 903static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),904 _init))(const wchar_t *name,905 int namelen) {906 (void)namelen;907 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))(name);908 return 0;909}910 911static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),912 _init))(const char *name)913#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */914static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),915 _init))(const char *name)916#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */917{918 if (!_N_(_ittapi_global).api_initialized &&919 _N_(_ittapi_global).thread_list == NULL) {920 __itt_init_ittlib_name(NULL, __itt_group_all);921 }922#if ITT_PLATFORM == ITT_PLATFORM_WIN923 if (ITTNOTIFY_NAME(thread_set_nameA) &&924 ITTNOTIFY_NAME(thread_set_nameA) !=925 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))) {926 ITTNOTIFY_NAME(thread_set_nameA)(name);927 }928#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */929 if (ITTNOTIFY_NAME(thread_set_name) &&930 ITTNOTIFY_NAME(thread_set_name) !=931 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))) {932 ITTNOTIFY_NAME(thread_set_name)(name);933 }934#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */935}936 937#if ITT_PLATFORM == ITT_PLATFORM_WIN938static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),939 _init))(const char *name,940 int namelen) {941 (void)namelen;942 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))(name);943 return 0;944}945#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */946static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),947 _init))(const char *name,948 int namelen) {949 (void)namelen;950 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))(name);951 return 0;952}953#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */954 955static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))(void) {956 if (!_N_(_ittapi_global).api_initialized &&957 _N_(_ittapi_global).thread_list == NULL) {958 __itt_init_ittlib_name(NULL, __itt_group_all);959 }960 if (ITTNOTIFY_NAME(thread_ignore) &&961 ITTNOTIFY_NAME(thread_ignore) !=962 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))) {963 ITTNOTIFY_NAME(thread_ignore)();964 }965}966 967static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_ignore), _init))(void) {968 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))();969}970 971static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(enable_attach), _init))(void) {972#ifdef __ANDROID__973 /*974 * if LIB_VAR_NAME env variable were set before then stay previous value975 * else set default path976 */977 setenv(ITT_TO_STR(LIB_VAR_NAME), ANDROID_ITTNOTIFY_DEFAULT_PATH, 0);978#endif979}980 981/* -------------------------------------------------------------------------- */982 983static const char *__itt_fsplit(const char *s, const char *sep,984 const char **out, int *len) {985 int i;986 int j;987 988 if (!s || !sep || !out || !len)989 return NULL;990 991 for (i = 0; s[i]; i++) {992 int b = 0;993 for (j = 0; sep[j]; j++)994 if (s[i] == sep[j]) {995 b = 1;996 break;997 }998 if (!b)999 break;1000 }1001 1002 if (!s[i])1003 return NULL;1004 1005 *len = 0;1006 *out = &s[i];1007 1008 for (; s[i]; i++, (*len)++) {1009 int b = 0;1010 for (j = 0; sep[j]; j++)1011 if (s[i] == sep[j]) {1012 b = 1;1013 break;1014 }1015 if (b)1016 break;1017 }1018 1019 for (; s[i]; i++) {1020 int b = 0;1021 for (j = 0; sep[j]; j++)1022 if (s[i] == sep[j]) {1023 b = 1;1024 break;1025 }1026 if (!b)1027 break;1028 }1029 1030 return &s[i];1031}1032 1033/* This function return value of env variable that placed into static buffer.1034 * !!! The same static buffer is used for subsequent calls. !!!1035 * This was done to avoid dynamic allocation for few calls.1036 * Actually we need this function only four times.1037 */1038static const char *__itt_get_env_var(const char *name) {1039#define MAX_ENV_VALUE_SIZE 40861040 static char env_buff[MAX_ENV_VALUE_SIZE];1041 static char *env_value = (char *)env_buff;1042 1043 if (name != NULL) {1044#if ITT_PLATFORM == ITT_PLATFORM_WIN1045 size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);1046 DWORD rc = GetEnvironmentVariableA(name, env_value, (DWORD)max_len);1047 if (rc >= max_len)1048 __itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1,1049 (size_t)(max_len - 1));1050 else if (rc > 0) {1051 const char *ret = (const char *)env_value;1052 env_value += rc + 1;1053 return ret;1054 } else {1055 /* If environment variable is empty, GetEnvironmentVariables()1056 * returns zero (number of characters (not including terminating null),1057 * and GetLastError() returns ERROR_SUCCESS. */1058 DWORD err = GetLastError();1059 if (err == ERROR_SUCCESS)1060 return env_value;1061 1062 if (err != ERROR_ENVVAR_NOT_FOUND)1063 __itt_report_error(__itt_error_cant_read_env, name, (int)err);1064 }1065#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */1066 char *env = getenv(name);1067 if (env != NULL) {1068 size_t len = __itt_fstrnlen(env, MAX_ENV_VALUE_SIZE);1069 size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);1070 if (len < max_len) {1071 const char *ret = (const char *)env_value;1072 __itt_fstrcpyn(env_value, max_len, env, len + 1);1073 env_value += len + 1;1074 return ret;1075 } else1076 __itt_report_error(__itt_error_env_too_long, name, (size_t)len,1077 (size_t)(max_len - 1));1078 }1079#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */1080 }1081 return NULL;1082}1083 1084static const char *__itt_get_lib_name(void) {1085 const char *lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));1086 1087#ifdef __ANDROID__1088 if (lib_name == NULL) {1089 1090#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM1091 const char *const marker_filename = "com.intel.itt.collector_lib_32";1092#else1093 const char *const marker_filename = "com.intel.itt.collector_lib_64";1094#endif1095 1096 char system_wide_marker_filename[PATH_MAX] = {0};1097 int itt_marker_file_fd = -1;1098 ssize_t res = 0;1099 1100 res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s",1101 "/data/local/tmp/", marker_filename);1102 if (res < 0) {1103 ITT_ANDROID_LOGE("Unable to concatenate marker file string.");1104 return lib_name;1105 }1106 itt_marker_file_fd = open(system_wide_marker_filename, O_RDONLY);1107 1108 if (itt_marker_file_fd == -1) {1109 const pid_t my_pid = getpid();1110 char cmdline_path[PATH_MAX] = {0};1111 char package_name[PATH_MAX] = {0};1112 char app_sandbox_file[PATH_MAX] = {0};1113 int cmdline_fd = 0;1114 1115 ITT_ANDROID_LOGI("Unable to open system-wide marker file.");1116 res = snprintf(cmdline_path, PATH_MAX - 1, "/proc/%d/cmdline", my_pid);1117 if (res < 0) {1118 ITT_ANDROID_LOGE("Unable to get cmdline path string.");1119 return lib_name;1120 }1121 1122 ITT_ANDROID_LOGI("CMD file: %s\n", cmdline_path);1123 cmdline_fd = open(cmdline_path, O_RDONLY);1124 if (cmdline_fd == -1) {1125 ITT_ANDROID_LOGE("Unable to open %s file!", cmdline_path);1126 return lib_name;1127 }1128 res = read(cmdline_fd, package_name, PATH_MAX - 1);1129 if (res == -1) {1130 ITT_ANDROID_LOGE("Unable to read %s file!", cmdline_path);1131 res = close(cmdline_fd);1132 if (res == -1) {1133 ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);1134 }1135 return lib_name;1136 }1137 res = close(cmdline_fd);1138 if (res == -1) {1139 ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);1140 return lib_name;1141 }1142 ITT_ANDROID_LOGI("Package name: %s\n", package_name);1143 res = snprintf(app_sandbox_file, PATH_MAX - 1, "/data/data/%s/%s",1144 package_name, marker_filename);1145 if (res < 0) {1146 ITT_ANDROID_LOGE("Unable to concatenate marker file string.");1147 return lib_name;1148 }1149 1150 ITT_ANDROID_LOGI("Lib marker file name: %s\n", app_sandbox_file);1151 itt_marker_file_fd = open(app_sandbox_file, O_RDONLY);1152 if (itt_marker_file_fd == -1) {1153 ITT_ANDROID_LOGE("Unable to open app marker file!");1154 return lib_name;1155 }1156 }1157 1158 {1159 char itt_lib_name[PATH_MAX] = {0};1160 1161 res = read(itt_marker_file_fd, itt_lib_name, PATH_MAX - 1);1162 if (res == -1) {1163 ITT_ANDROID_LOGE("Unable to read %s file!", itt_marker_file_fd);1164 res = close(itt_marker_file_fd);1165 if (res == -1) {1166 ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);1167 }1168 return lib_name;1169 }1170 ITT_ANDROID_LOGI("ITT Lib path: %s", itt_lib_name);1171 res = close(itt_marker_file_fd);1172 if (res == -1) {1173 ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);1174 return lib_name;1175 }1176 ITT_ANDROID_LOGI("Set env %s to %s", ITT_TO_STR(LIB_VAR_NAME),1177 itt_lib_name);1178 res = setenv(ITT_TO_STR(LIB_VAR_NAME), itt_lib_name, 0);1179 if (res == -1) {1180 ITT_ANDROID_LOGE("Unable to set env var!");1181 return lib_name;1182 }1183 lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));1184 ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name);1185 }1186 }1187#endif1188 1189 return lib_name;1190}1191 1192/* Avoid clashes with std::min */1193#define __itt_min(a, b) ((a) < (b) ? (a) : (b))1194 1195static __itt_group_id __itt_get_groups(void) {1196 int i;1197 __itt_group_id res = __itt_group_none;1198 const char *var_name = "INTEL_ITTNOTIFY_GROUPS";1199 const char *group_str = __itt_get_env_var(var_name);1200 1201 if (group_str != NULL) {1202 int len;1203 char gr[255];1204 const char *chunk;1205 while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL) {1206 int min_len = __itt_min(len, (int)(sizeof(gr) - 1));1207 __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk, min_len);1208 gr[min_len] = 0;1209 1210 for (i = 0; group_list[i].name != NULL; i++) {1211 if (!__itt_fstrcmp(gr, group_list[i].name)) {1212 res = (__itt_group_id)(res | group_list[i].id);1213 break;1214 }1215 }1216 }1217 /* TODO: !!! Workaround for bug with warning for unknown group !!!1218 * Should be fixed in new initialization scheme.1219 * Now the following groups should be set always. */1220 for (i = 0; group_list[i].id != __itt_group_none; i++)1221 if (group_list[i].id != __itt_group_all &&1222 group_list[i].id > __itt_group_splitter_min &&1223 group_list[i].id < __itt_group_splitter_max)1224 res = (__itt_group_id)(res | group_list[i].id);1225 return res;1226 } else {1227 for (i = 0; group_alias[i].env_var != NULL; i++)1228 if (__itt_get_env_var(group_alias[i].env_var) != NULL)1229 return group_alias[i].groups;1230 }1231 1232 return res;1233}1234 1235#undef __itt_min1236 1237static int __itt_lib_version(lib_t lib) {1238 if (lib == NULL)1239 return 0;1240 if (__itt_get_proc(lib, "__itt_api_init"))1241 return 2;1242 if (__itt_get_proc(lib, "__itt_api_version"))1243 return 1;1244 return 0;1245}1246 1247/* It's not used right now! Comment it out to avoid warnings.1248static void __itt_reinit_all_pointers(void)1249{1250 register int i;1251 // Fill all pointers with initial stubs1252 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)1253 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =1254_N_(_ittapi_global).api_list_ptr[i].init_func;1255}1256*/1257 1258static void __itt_nullify_all_pointers(void) {1259 int i;1260 /* Nulify all pointers except domain_create, string_handle_create and1261 * counter_create */1262 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)1263 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =1264 _N_(_ittapi_global).api_list_ptr[i].null_func;1265}1266 1267#if ITT_PLATFORM == ITT_PLATFORM_WIN1268#if _MSC_VER1269#pragma warning(push)1270#pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function \1271 pointer 'XXX' to data pointer 'void *' */1272#pragma warning( \1273 disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \1274 to function pointer 'XXX' */1275#endif1276#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */1277 1278ITT_EXTERN_C void _N_(fini_ittlib)(void) {1279 __itt_api_fini_t *__itt_api_fini_ptr = NULL;1280 static volatile TIDT current_thread = 0;1281 1282 if (_N_(_ittapi_global).api_initialized) {1283 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));1284 if (_N_(_ittapi_global).api_initialized) {1285 if (current_thread == 0) {1286 if (PTHREAD_SYMBOLS)1287 current_thread = __itt_thread_id();1288 if (_N_(_ittapi_global).lib != NULL) {1289 __itt_api_fini_ptr = (__itt_api_fini_t *)(size_t)__itt_get_proc(1290 _N_(_ittapi_global).lib, "__itt_api_fini");1291 }1292 if (__itt_api_fini_ptr) {1293 __itt_api_fini_ptr(&_N_(_ittapi_global));1294 }1295 1296 __itt_nullify_all_pointers();1297 1298 /* TODO: !!! not safe !!! don't support unload so far.1299 * if (_N_(_ittapi_global).lib != NULL)1300 * __itt_unload_lib(_N_(_ittapi_global).lib);1301 * _N_(_ittapi_global).lib = NULL;1302 */1303 _N_(_ittapi_global).api_initialized = 0;1304 current_thread = 0;1305 }1306 }1307 if (PTHREAD_SYMBOLS)1308 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);1309 }1310}1311 1312/* !!! this function should be called under mutex lock !!! */1313static void __itt_free_allocated_resources(void) {1314 __itt_string_handle *current_string = _N_(_ittapi_global).string_list;1315 while (current_string != NULL) {1316 __itt_string_handle *tmp = current_string->next;1317 free((char *)current_string->strA);1318#if ITT_PLATFORM == ITT_PLATFORM_WIN1319 free((wchar_t *)current_string->strW);1320#endif1321 free(current_string);1322 current_string = tmp;1323 }1324 _N_(_ittapi_global).string_list = NULL;1325 1326 __itt_domain *current_domain = _N_(_ittapi_global).domain_list;1327 while (current_domain != NULL) {1328 __itt_domain *tmp = current_domain->next;1329 free((char *)current_domain->nameA);1330#if ITT_PLATFORM == ITT_PLATFORM_WIN1331 free((wchar_t *)current_domain->nameW);1332#endif1333 free(current_domain);1334 current_domain = tmp;1335 }1336 _N_(_ittapi_global).domain_list = NULL;1337 1338 __itt_counter_info_t *current_couter = _N_(_ittapi_global).counter_list;1339 while (current_couter != NULL) {1340 __itt_counter_info_t *tmp = current_couter->next;1341 free((char *)current_couter->nameA);1342 free((char *)current_couter->domainA);1343#if ITT_PLATFORM == ITT_PLATFORM_WIN1344 free((wchar_t *)current_couter->nameW);1345 free((wchar_t *)current_couter->domainW);1346#endif1347 free(current_couter);1348 current_couter = tmp;1349 }1350 _N_(_ittapi_global).counter_list = NULL;1351 1352 __itt_histogram *current_histogram = _N_(_ittapi_global).histogram_list;1353 while (current_histogram != NULL) {1354 __itt_histogram *tmp = current_histogram->next;1355 free((char *)current_histogram->nameA);1356#if ITT_PLATFORM == ITT_PLATFORM_WIN1357 free((wchar_t *)current_histogram->nameW);1358#endif1359 free(current_histogram);1360 current_histogram = tmp;1361 }1362 _N_(_ittapi_global).histogram_list = NULL;1363}1364 1365ITT_EXTERN_C int _N_(init_ittlib)(const char *lib_name,1366 __itt_group_id init_groups) {1367 int i;1368 __itt_group_id groups;1369#ifdef ITT_COMPLETE_GROUP1370 __itt_group_id zero_group = __itt_group_none;1371#endif /* ITT_COMPLETE_GROUP */1372 static volatile TIDT current_thread = 0;1373 1374 if (!_N_(_ittapi_global).api_initialized) {1375#ifndef ITT_SIMPLE_INIT1376 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));1377#endif /* ITT_SIMPLE_INIT */1378 1379 if (!_N_(_ittapi_global).api_initialized) {1380 if (current_thread == 0) {1381 if (PTHREAD_SYMBOLS)1382 current_thread = __itt_thread_id();1383 if (lib_name == NULL) {1384 lib_name = __itt_get_lib_name();1385 }1386 groups = __itt_get_groups();1387 if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL)) {1388 _N_(_ittapi_global).lib = __itt_load_lib(1389 (lib_name == NULL) ? ittnotify_lib_name : lib_name);1390 1391 if (_N_(_ittapi_global).lib != NULL) {1392 __itt_api_init_t *__itt_api_init_ptr;1393 int lib_version = __itt_lib_version(_N_(_ittapi_global).lib);1394 1395 switch (lib_version) {1396 case 0:1397 groups = __itt_group_legacy;1398 ITT_ATTRIBUTE_FALLTHROUGH;1399 case 1:1400 /* Fill all pointers from dynamic library */1401 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL;1402 i++) {1403 if (_N_(_ittapi_global).api_list_ptr[i].group & groups &1404 init_groups) {1405 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =1406 (void *)__itt_get_proc(1407 _N_(_ittapi_global).lib,1408 _N_(_ittapi_global).api_list_ptr[i].name);1409 if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL) {1410 /* Restore pointers for function with static implementation1411 */1412 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =1413 _N_(_ittapi_global).api_list_ptr[i].null_func;1414 __itt_report_error(1415 __itt_error_no_symbol, lib_name,1416 _N_(_ittapi_global).api_list_ptr[i].name);1417#ifdef ITT_COMPLETE_GROUP1418 zero_group =1419 (__itt_group_id)(zero_group | _N_(_ittapi_global)1420 .api_list_ptr[i]1421 .group);1422#endif /* ITT_COMPLETE_GROUP */1423 }1424 } else1425 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =1426 _N_(_ittapi_global).api_list_ptr[i].null_func;1427 }1428 1429 if (groups == __itt_group_legacy) {1430 /* Compatibility with legacy tools */1431 ITTNOTIFY_NAME(thread_ignore) = ITTNOTIFY_NAME(thr_ignore);1432#if ITT_PLATFORM == ITT_PLATFORM_WIN1433 ITTNOTIFY_NAME(sync_createA) = ITTNOTIFY_NAME(sync_set_nameA);1434 ITTNOTIFY_NAME(sync_createW) = ITTNOTIFY_NAME(sync_set_nameW);1435#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */1436 ITTNOTIFY_NAME(sync_create) = ITTNOTIFY_NAME(sync_set_name);1437#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */1438 ITTNOTIFY_NAME(sync_prepare) =1439 ITTNOTIFY_NAME(notify_sync_prepare);1440 ITTNOTIFY_NAME(sync_cancel) =1441 ITTNOTIFY_NAME(notify_sync_cancel);1442 ITTNOTIFY_NAME(sync_acquired) =1443 ITTNOTIFY_NAME(notify_sync_acquired);1444 ITTNOTIFY_NAME(sync_releasing) =1445 ITTNOTIFY_NAME(notify_sync_releasing);1446 }1447 1448#ifdef ITT_COMPLETE_GROUP1449 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)1450 if (_N_(_ittapi_global).api_list_ptr[i].group & zero_group)1451 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =1452 _N_(_ittapi_global).api_list_ptr[i].null_func;1453#endif /* ITT_COMPLETE_GROUP */1454 break;1455 case 2:1456 __itt_api_init_ptr = (__itt_api_init_t *)(size_t)__itt_get_proc(1457 _N_(_ittapi_global).lib, "__itt_api_init");1458 if (__itt_api_init_ptr)1459 __itt_api_init_ptr(&_N_(_ittapi_global), init_groups);1460 break;1461 }1462 } else {1463 __itt_free_allocated_resources();1464 __itt_nullify_all_pointers();1465 1466 __itt_report_error(__itt_error_no_module, lib_name,1467#if ITT_PLATFORM == ITT_PLATFORM_WIN1468 __itt_system_error()1469#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */1470 dlerror()1471#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */1472 );1473 }1474 } else {1475 __itt_free_allocated_resources();1476 __itt_nullify_all_pointers();1477 }1478 _N_(_ittapi_global).api_initialized = 1;1479 current_thread = 0;1480 /* !!! Just to avoid unused code elimination !!! */1481 if (__itt_fini_ittlib_ptr == _N_(fini_ittlib))1482 current_thread = 0;1483 }1484 }1485 1486#ifndef ITT_SIMPLE_INIT1487 if (PTHREAD_SYMBOLS)1488 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);1489#endif /* ITT_SIMPLE_INIT */1490 }1491 1492 /* Evaluating if any function ptr is non empty and it's in init_groups */1493 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) {1494 if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr !=1495 _N_(_ittapi_global).api_list_ptr[i].null_func &&1496 _N_(_ittapi_global).api_list_ptr[i].group & init_groups) {1497 return 1;1498 }1499 }1500 return 0;1501}1502 1503ITT_EXTERN_C __itt_error_handler_t *1504_N_(set_error_handler)(__itt_error_handler_t *handler) {1505 __itt_error_handler_t *prev =1506 (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;1507 _N_(_ittapi_global).error_handler = (void *)(size_t)handler;1508 return prev;1509}1510 1511#if ITT_PLATFORM == ITT_PLATFORM_WIN1512#if _MSC_VER1513#pragma warning(pop)1514#endif1515#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */1516 1517/** __itt_mark_pt_region functions marks region of interest1518 * region parameter defines different regions.1519 * 0 <= region < 8 */1520 1521#if defined(ITT_API_IPT_SUPPORT) && \1522 (ITT_PLATFORM == ITT_PLATFORM_WIN || \1523 ITT_PLATFORM == ITT_PLATFORM_POSIX) && \1524 !defined(__ANDROID__)1525void __itt_pt_mark(__itt_pt_region region);1526void __itt_pt_mark_event(__itt_pt_region region);1527#endif1528 1529ITT_EXTERN_C void _N_(mark_pt_region_begin)(__itt_pt_region region) {1530#if defined(ITT_API_IPT_SUPPORT) && \1531 (ITT_PLATFORM == ITT_PLATFORM_WIN || \1532 ITT_PLATFORM == ITT_PLATFORM_POSIX) && \1533 !defined(__ANDROID__)1534 if (_N_(_ittapi_global).ipt_collect_events == 1) {1535 __itt_pt_mark_event(2 * region);1536 } else {1537 __itt_pt_mark(2 * region);1538 }1539#else1540 (void)region;1541#endif1542}1543 1544ITT_EXTERN_C void _N_(mark_pt_region_end)(__itt_pt_region region) {1545#if defined(ITT_API_IPT_SUPPORT) && \1546 (ITT_PLATFORM == ITT_PLATFORM_WIN || \1547 ITT_PLATFORM == ITT_PLATFORM_POSIX) && \1548 !defined(__ANDROID__)1549 if (_N_(_ittapi_global).ipt_collect_events == 1) {1550 __itt_pt_mark_event(2 * region + 1);1551 } else {1552 __itt_pt_mark(2 * region + 1);1553 }1554#else1555 (void)region;1556#endif1557}1558