4 * Copyright 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
8 * Woojin Jung <woojin2.jung@samsung.com>
9 * Jaewon Lim <jaewon81.lim@samsung.com>
10 * Juyoung Kim <j0.kim@samsung.com>
12 * This library is free software; you can redistribute it and/or modify it under
13 * the terms of the GNU Lesser General Public License as published by the
14 * Free Software Foundation; either version 2.1 of the License, or (at your option)
17 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
18 * WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
20 * License for more details.
22 * You should have received a copy of the GNU Lesser General Public License
23 * along with this library; if not, write to the Free Software Foundation, Inc., 51
24 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include <FBaseResult.h>
32 #include <FBaseString.h>
33 #include <FBaseRtTypes.h>
37 #include "probeinfo.h"
42 static enum DaOptions _sopt = OPT_THREAD;
51 result Create(const Tizen::Base::String& name);
54 result TryToAcquire(void);
57 // virtual ~Mutex(void);
60 // Mutex(const Mutex& value);
61 // Mutex& opereator =(const Mutex& value);
64 // friend class _MutexImpl;
65 // class _MutexImpl * __pMutexImpl;
70 result Create(int count = 1);
71 result Create(const Tizen::Base::String& name, int count = 1);
72 result Acquire(long timeout = INFINITE);
73 result TryToAcquire(void);
77 // virtual ~Semaphore(void);
80 // Semaphore(const Semaphore& rhs);
81 // Semaphore& operator =(const Semaphore& rhs);
84 // friend class _SemaphoreImpl;
85 // class _SemaphoreImpl * __pSemaphoreImpl;
90 result Construct(void);
95 result NotifyAll(void);
98 // virtual ~Monitor(void);
101 // Monitor(const Monitor& rhs);
102 // Monitor& operator =(const Monitor& rhs);
105 // friend class _MonitorImpl;
106 // class _MonitorImpl * __pMonitorImpl;
110 result Mutex::Create(void) {
112 (Mutex::*methodType)(void);
113 static methodType Createp = 0;
115 probeInfo_t probeInfo;
118 bool bfiltering = true;
123 if(lib_handle[LIBOSP_APPFW] == NULL) {
124 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
125 if (lib_handle[LIBOSP_APPFW] == NULL) {
126 perror("dlopen failed : libosp-appfw.so");
130 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex6CreateEv");
132 if (tmpPtr == NULL || dlerror() != NULL) {
133 perror("dlsym failed : Tizen::Base::Runtime::Mutex::Create");
137 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
142 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
143 setProbePoint(&probeInfo);
147 ret = (this->*Createp)();
149 if (postBlockBegin(blockresult)) {
153 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
154 probeInfo.eventIndex, "Mutex::Create",
155 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
157 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
158 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
159 log.length += sprintf(log.data + log.length,
160 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
161 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_NEW);
163 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
164 getBacktraceString(&log, 4096 - log.length - 17);
165 log.length += sprintf(log.data + log.length, "`,callstack_end");
167 printLog(&log, MSG_LOG);
170 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
171 PACK_COMMON_END(ret, ret, blockresult);
172 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_NEW);
180 result Mutex::Create(const Tizen::Base::String& name) {
182 (Mutex::*methodType)(const Tizen::Base::String& name);
183 static methodType Createp = 0;
185 probeInfo_t probeInfo;
188 bool bfiltering = true;
194 if(lib_handle[LIBOSP_APPFW] == NULL) {
195 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
196 if (lib_handle[LIBOSP_APPFW] == NULL) {
197 perror("dlopen failed : libosp-appfw.so");
201 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex6CreateERKNS0_6StringE");
203 if (tmpPtr == NULL || dlerror() != NULL) {
204 perror("dlsym failed : Tizen::Base::Runtime::Mutex::Create");
208 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
213 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
214 setProbePoint(&probeInfo);
218 ret = (this->*Createp)(name);
220 if (postBlockBegin(blockresult)) {
224 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
225 probeInfo.eventIndex, "Mutex::Create",
226 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
228 WcharToChar(temp, name.GetPointer());
229 log.length += sprintf(log.data + log.length, "`,%s`,%ld", temp, ret);
230 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
231 log.length += sprintf(log.data + log.length,
232 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
233 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_NEW);
235 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
236 getBacktraceString(&log, 4096 - log.length - 17);
237 log.length += sprintf(log.data + log.length, "`,callstack_end");
239 printLog(&log, MSG_LOG);
242 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "s", temp);
243 PACK_COMMON_END(ret, ret, blockresult);
244 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_NEW);
252 result Mutex::Release(void) {
254 (Mutex::*methodType)(void);
255 static methodType Releasep = 0;
257 probeInfo_t probeInfo;
260 bool bfiltering = true;
265 if(lib_handle[LIBOSP_APPFW] == NULL) {
266 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
267 if (lib_handle[LIBOSP_APPFW] == NULL) {
268 perror("dlopen failed : libosp-appfw.so");
272 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex7ReleaseEv");
274 if (tmpPtr == NULL || dlerror() != NULL) {
275 perror("dlsym failed : Tizen::Base::Runtime::Mutex::Release");
279 memcpy(&Releasep, &tmpPtr, sizeof(tmpPtr));
284 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
285 setProbePoint(&probeInfo);
289 ret = (this->*Releasep)();
291 if (postBlockBegin(blockresult)) {
295 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
296 probeInfo.eventIndex, "Mutex::Release",
297 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
299 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
300 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
301 log.length += sprintf(log.data + log.length,
302 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
303 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_RELEASE);
305 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
306 getBacktraceString(&log, 4096 - log.length - 17);
307 log.length += sprintf(log.data + log.length, "`,callstack_end");
309 printLog(&log, MSG_LOG);
312 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
313 PACK_COMMON_END(ret, ret, blockresult);
314 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_RELEASE);
322 result Mutex::Acquire(void) {
324 (Mutex::*methodType)(void);
325 static methodType Acquirep = 0;
327 probeInfo_t probeInfo;
330 bool bfiltering = true;
335 if(lib_handle[LIBOSP_APPFW] == NULL) {
336 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
337 if (lib_handle[LIBOSP_APPFW] == NULL) {
338 perror("dlopen failed : libosp-appfw.so");
342 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex7AcquireEv");
344 if (tmpPtr == NULL || dlerror() != NULL) {
345 perror("dlsym failed : Tizen::Base::Runtime::Mutex::Acquire");
349 memcpy(&Acquirep, &tmpPtr, sizeof(tmpPtr));
354 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
355 setProbePoint(&probeInfo);
359 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
360 probeInfo.eventIndex, "Mutex::Acquire",
361 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
363 log.length += sprintf(log.data + log.length, "`,`,");
364 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
365 log.length += sprintf(log.data + log.length,
366 "`,0`,0`,%d`,%u`,0x%x`,%d`,%d",blockresult,
367 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
369 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
370 getBacktraceString(&log, 4096 - log.length - 17);
371 log.length += sprintf(log.data + log.length, "`,callstack_end");
373 printLog(&log, MSG_LOG);
376 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
377 PACK_COMMON_END(0, 0, blockresult);
378 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
384 ret = (this->*Acquirep)();
386 if (postBlockBegin(blockresult)) {
387 setProbePoint(&probeInfo);
391 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
392 probeInfo.eventIndex, "Mutex::Acquire",
393 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
395 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
396 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
397 log.length += sprintf(log.data + log.length,
398 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
399 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
401 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
402 getBacktraceString(&log, 4096 - log.length - 17);
403 log.length += sprintf(log.data + log.length, "`,callstack_end");
405 printLog(&log, MSG_LOG);
408 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
409 PACK_COMMON_END(ret, ret, blockresult);
410 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
418 result Mutex::TryToAcquire(void) {
420 (Mutex::*methodType)(void);
421 static methodType TryToAcquirep = 0;
423 probeInfo_t probeInfo;
426 bool bfiltering = true;
429 if (!TryToAcquirep) {
431 if(lib_handle[LIBOSP_APPFW] == NULL) {
432 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
433 if (lib_handle[LIBOSP_APPFW] == NULL) {
434 perror("dlopen failed : libosp-appfw.so");
438 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex12TryToAcquireEv");
440 if (tmpPtr == NULL || dlerror() != NULL) {
441 perror("dlsym failed : Tizen::Base::Runtime::Mutex::TryToAcquire");
445 memcpy(&TryToAcquirep, &tmpPtr, sizeof(tmpPtr));
450 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
451 setProbePoint(&probeInfo);
455 ret = (this->*TryToAcquirep)();
457 if (postBlockBegin(blockresult)) {
461 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
462 probeInfo.eventIndex, "Mutex::TryToAcquire",
463 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
465 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
466 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
467 log.length += sprintf(log.data + log.length,
468 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
469 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_TRY_ACQUIRE);
471 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
472 getBacktraceString(&log, 4096 - log.length - 17);
473 log.length += sprintf(log.data + log.length, "`,callstack_end");
475 printLog(&log, MSG_LOG);
478 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
479 PACK_COMMON_END(ret, ret, blockresult);
480 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_TRY_ACQUIRE);
489 result Semaphore::Create(int count) {
491 (Semaphore::*methodType)(int count);
492 static methodType Createp = 0;
494 probeInfo_t probeInfo;
497 bool bfiltering = true;
502 if(lib_handle[LIBOSP_APPFW] == NULL) {
503 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
504 if (lib_handle[LIBOSP_APPFW] == NULL) {
505 perror("dlopen failed : libosp-appfw.so");
509 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore6CreateEi");
511 if (tmpPtr == NULL || dlerror() != NULL) {
512 perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Create");
516 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
521 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
522 setProbePoint(&probeInfo);
526 ret = (this->*Createp)(count);
528 if (postBlockBegin(blockresult)) {
532 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
533 probeInfo.eventIndex, "Semaphore::Create",
534 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
536 log.length += sprintf(log.data + log.length, "`,%d`,%ld", count, ret);
537 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
538 log.length += sprintf(log.data + log.length,
539 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
540 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_NEW);
542 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
543 getBacktraceString(&log, 4096 - log.length - 17);
544 log.length += sprintf(log.data + log.length, "`,callstack_end");
546 printLog(&log, MSG_LOG);
549 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "d", count);
550 PACK_COMMON_END(ret, ret, blockresult);
551 PACK_THREAD((unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_NEW);
559 result Semaphore::Create(const Tizen::Base::String& name, int count) {
561 (Semaphore::*methodType)(const Tizen::Base::String& name, int count);
562 static methodType Createp = 0;
564 probeInfo_t probeInfo;
567 bool bfiltering = true;
573 if(lib_handle[LIBOSP_APPFW] == NULL) {
574 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
575 if (lib_handle[LIBOSP_APPFW] == NULL) {
576 perror("dlopen failed : libosp-appfw.so");
580 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore6CreateERKNS0_6StringEi");
582 if (tmpPtr == NULL || dlerror() != NULL) {
583 perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Create");
587 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
592 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
593 setProbePoint(&probeInfo);
597 ret = (this->*Createp)(name, count);
599 if (postBlockBegin(blockresult)) {
603 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
604 probeInfo.eventIndex, "Semaphore::Create",
605 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
607 WcharToChar(temp, name.GetPointer());
608 log.length += sprintf(log.data + log.length, "`,%s,%d`,%ld", temp, count, ret);
609 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
610 log.length += sprintf(log.data + log.length,
611 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
612 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_NEW);
614 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
615 getBacktraceString(&log, 4096 - log.length - 17);
616 log.length += sprintf(log.data + log.length, "`,callstack_end");
618 printLog(&log, MSG_LOG);
621 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "sd", temp, count);
622 PACK_COMMON_END(ret, ret, blockresult);
623 PACK_THREAD((unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_NEW);
632 result Semaphore::Acquire(long timeout) {
634 (Semaphore::*methodType)(long timeout);
635 static methodType Acquirep = 0;
637 probeInfo_t probeInfo;
640 bool bfiltering = true;
645 if(lib_handle[LIBOSP_APPFW] == NULL) {
646 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
647 if (lib_handle[LIBOSP_APPFW] == NULL) {
648 perror("dlopen failed : libosp-appfw.so");
652 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore7AcquireEl");
654 if (tmpPtr == NULL || dlerror() != NULL) {
655 perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Acquire");
659 memcpy(&Acquirep, &tmpPtr, sizeof(tmpPtr));
664 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
665 setProbePoint(&probeInfo);
669 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
670 probeInfo.eventIndex, "Semaphore::Acquire",
671 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
673 log.length += sprintf(log.data + log.length, "`,%ld`,", timeout);
674 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
675 log.length += sprintf(log.data + log.length,
676 "`,0`,0`,%d`,%u`,0x%x`,%d`,%d",blockresult,
677 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_START);
679 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
680 getBacktraceString(&log, 4096 - log.length - 17);
681 log.length += sprintf(log.data + log.length, "`,callstack_end");
683 printLog(&log, MSG_LOG);
686 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "x", timeout);
687 PACK_COMMON_END(0, 0, blockresult);
688 PACK_THREAD((unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_START);
694 ret = (this->*Acquirep)(timeout);
696 if (postBlockBegin(blockresult)) {
697 setProbePoint(&probeInfo);
701 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
702 probeInfo.eventIndex, "Semaphore::Acquire",
703 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
705 log.length += sprintf(log.data + log.length, "`,%ld`,%ld", timeout, ret);
706 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
707 log.length += sprintf(log.data + log.length,
708 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
709 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_END);
711 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
712 getBacktraceString(&log, 4096 - log.length - 17);
713 log.length += sprintf(log.data + log.length, "`,callstack_end");
715 printLog(&log, MSG_LOG);
718 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "x", timeout);
719 PACK_COMMON_END(ret, ret, blockresult);
720 PACK_THREAD((unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_END);
728 result Semaphore::TryToAcquire(void) {
730 (Semaphore::*methodType)(void);
731 static methodType TryToAcquirep = 0;
733 probeInfo_t probeInfo;
736 bool bfiltering = true;
739 if (!TryToAcquirep) {
741 if(lib_handle[LIBOSP_APPFW] == NULL) {
742 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
743 if (lib_handle[LIBOSP_APPFW] == NULL) {
744 perror("dlopen failed : libosp-appfw.so");
748 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore12TryToAcquireEv");
750 if (tmpPtr == NULL || dlerror() != NULL) {
751 perror("dlsym failed : Tizen::Base::Runtime::Semaphore::TryToAcquire");
755 memcpy(&TryToAcquirep, &tmpPtr, sizeof(tmpPtr));
760 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
761 setProbePoint(&probeInfo);
765 ret = (this->*TryToAcquirep)();
767 if (postBlockBegin(blockresult)) {
771 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
772 probeInfo.eventIndex, "Semaphore::TryToAcquire",
773 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
775 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
776 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
777 log.length += sprintf(log.data + log.length,
778 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
779 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_TRY_ACQUIRE);
781 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
782 getBacktraceString(&log, 4096 - log.length - 17);
783 log.length += sprintf(log.data + log.length, "`,callstack_end");
785 printLog(&log, MSG_LOG);
788 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
789 PACK_COMMON_END(ret, ret, blockresult);
790 PACK_THREAD((unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_TRY_ACQUIRE);
798 result Semaphore::Release(void) {
800 (Semaphore::*methodType)(void);
801 static methodType Releasep = 0;
803 probeInfo_t probeInfo;
806 bool bfiltering = true;
811 if(lib_handle[LIBOSP_APPFW] == NULL) {
812 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
813 if (lib_handle[LIBOSP_APPFW] == NULL) {
814 perror("dlopen failed : libosp-appfw.so");
818 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore7ReleaseEv");
820 if (tmpPtr == NULL || dlerror() != NULL) {
821 perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Release");
825 memcpy(&Releasep, &tmpPtr, sizeof(tmpPtr));
830 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
831 setProbePoint(&probeInfo);
835 ret = (this->*Releasep)();
837 if (postBlockBegin(blockresult)) {
841 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
842 probeInfo.eventIndex, "Semaphore::Release",
843 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
845 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
846 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
847 log.length += sprintf(log.data + log.length,
848 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
849 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_RELEASE);
851 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
852 getBacktraceString(&log, 4096 - log.length - 17);
853 log.length += sprintf(log.data + log.length, "`,callstack_end");
855 printLog(&log, MSG_LOG);
858 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
859 PACK_COMMON_END(ret, ret, blockresult);
860 PACK_THREAD((unsigned int) this, SYNC_OSP_SEMAPHORE, SYNC_API_RELEASE);
869 result Monitor::Construct(void) {
871 (Monitor::*methodType)(void);
872 static methodType Constructp = 0;
874 probeInfo_t probeInfo;
877 bool bfiltering = true;
882 if(lib_handle[LIBOSP_APPFW] == NULL) {
883 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
884 if (lib_handle[LIBOSP_APPFW] == NULL) {
885 perror("dlopen failed : libosp-appfw.so");
889 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor9ConstructEv");
891 if (tmpPtr == NULL || dlerror() != NULL) {
892 perror("dlsym failed : Tizen::Base::Runtime::Monitor::Construct");
896 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
900 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
901 setProbePoint(&probeInfo);
905 ret = (this->*Constructp)();
907 if (postBlockBegin(blockresult)) {
911 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
912 probeInfo.eventIndex, "Monitor::Construct",
913 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
915 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
916 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
917 log.length += sprintf(log.data + log.length,
918 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
919 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_NEW);
921 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
922 getBacktraceString(&log, 4096 - log.length - 17);
923 log.length += sprintf(log.data + log.length, "`,callstack_end");
925 printLog(&log, MSG_LOG);
928 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
929 PACK_COMMON_END(ret, ret, blockresult);
930 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_NEW);
938 result Monitor::Enter(void) {
940 (Monitor::*methodType)(void);
941 static methodType Enterp = 0;
943 probeInfo_t probeInfo;
946 bool bfiltering = true;
951 if(lib_handle[LIBOSP_APPFW] == NULL) {
952 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
953 if (lib_handle[LIBOSP_APPFW] == NULL) {
954 perror("dlopen failed : libosp-appfw.so");
958 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor5EnterEv");
960 if (tmpPtr == NULL || dlerror() != NULL) {
961 perror("dlsym failed : Tizen::Base::Runtime::Monitor::Enter");
965 memcpy(&Enterp, &tmpPtr, sizeof(tmpPtr));
970 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
971 setProbePoint(&probeInfo);
975 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
976 probeInfo.eventIndex, "Monitor::Enter",
977 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
979 log.length += sprintf(log.data + log.length, "`,`,");
980 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
981 log.length += sprintf(log.data + log.length,
982 "`,0`,0`,%d`,%u`,0x%x`,%d`,%d",blockresult,
983 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_ACQUIRE_WAIT_START);
985 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
986 getBacktraceString(&log, 4096 - log.length - 17);
987 log.length += sprintf(log.data + log.length, "`,callstack_end");
989 printLog(&log, MSG_LOG);
992 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
993 PACK_COMMON_END(ret, ret, blockresult);
994 PACK_THREAD((unsigned int) this, SYNC_OSP_MUTEX, SYNC_API_NEW);
1000 ret = (this->*Enterp)();
1002 if (postBlockBegin(blockresult)) {
1003 setProbePoint(&probeInfo);
1007 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
1008 probeInfo.eventIndex, "Monitor::Enter",
1009 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1011 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1012 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
1013 log.length += sprintf(log.data + log.length,
1014 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
1015 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_ACQUIRE_WAIT_END);
1017 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1018 getBacktraceString(&log, 4096 - log.length - 17);
1019 log.length += sprintf(log.data + log.length, "`,callstack_end");
1021 printLog(&log, MSG_LOG);
1023 PREPARE_LOCAL_BUF();
1024 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
1025 PACK_COMMON_END(ret, ret, blockresult);
1026 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_ACQUIRE_WAIT_END);
1034 result Monitor::Exit(void) {
1036 (Monitor::*methodType)(void);
1037 static methodType Exitp = 0;
1039 probeInfo_t probeInfo;
1042 bool bfiltering = true;
1047 if(lib_handle[LIBOSP_APPFW] == NULL) {
1048 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1049 if (lib_handle[LIBOSP_APPFW] == NULL) {
1050 perror("dlopen failed : libosp-appfw.so");
1054 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor4ExitEv");
1056 if (tmpPtr == NULL || dlerror() != NULL) {
1057 perror("dlsym failed : Tizen::Base::Runtime::Monitor::Exit");
1061 memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
1066 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1067 setProbePoint(&probeInfo);
1071 ret = (this->*Exitp)();
1073 if (postBlockBegin(blockresult)) {
1077 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
1078 probeInfo.eventIndex, "Monitor::Exit",
1079 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1081 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1082 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
1083 log.length += sprintf(log.data + log.length,
1084 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
1085 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_RELEASE);
1087 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1088 getBacktraceString(&log, 4096 - log.length - 17);
1089 log.length += sprintf(log.data + log.length, "`,callstack_end");
1091 printLog(&log, MSG_LOG);
1093 PREPARE_LOCAL_BUF();
1094 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
1095 PACK_COMMON_END(ret, ret, blockresult);
1096 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_RELEASE);
1104 result Monitor::Wait(void) {
1106 (Monitor::*methodType)(void);
1107 static methodType Waitp = 0;
1109 probeInfo_t probeInfo;
1112 bool bfiltering = true;
1117 if(lib_handle[LIBOSP_APPFW] == NULL) {
1118 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1119 if (lib_handle[LIBOSP_APPFW] == NULL) {
1120 perror("dlopen failed : libosp-appfw.so");
1124 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor4WaitEv");
1126 if (tmpPtr == NULL || dlerror() != NULL) {
1127 perror("dlsym failed : Tizen::Base::Runtime::Monitor::Wait");
1131 memcpy(&Waitp, &tmpPtr, sizeof(tmpPtr));
1136 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1137 setProbePoint(&probeInfo);
1141 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
1142 probeInfo.eventIndex, "Monitor::Wait",
1143 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1145 log.length += sprintf(log.data + log.length, "`,`,");
1146 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
1147 log.length += sprintf(log.data + log.length,
1148 "`,0`,0`,%d`,%u`,0x%x`,%d`,%d",blockresult,
1149 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_COND_WAIT_START);
1151 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1152 getBacktraceString(&log, 4096 - log.length - 17);
1153 log.length += sprintf(log.data + log.length, "`,callstack_end");
1155 printLog(&log, MSG_LOG);
1157 PREPARE_LOCAL_BUF();
1158 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
1159 PACK_COMMON_END(0, 0, blockresult);
1160 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_COND_WAIT_START);
1166 ret = (this->*Waitp)();
1168 if (postBlockBegin(blockresult)) {
1169 setProbePoint(&probeInfo);
1173 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
1174 probeInfo.eventIndex, "Monitor::Wait",
1175 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1177 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1178 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
1179 log.length += sprintf(log.data + log.length,
1180 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
1181 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_COND_WAIT_END);
1183 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1184 getBacktraceString(&log, 4096 - log.length - 17);
1185 log.length += sprintf(log.data + log.length, "`,callstack_end");
1187 printLog(&log, MSG_LOG);
1189 PREPARE_LOCAL_BUF();
1190 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
1191 PACK_COMMON_END(ret, ret, blockresult);
1192 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_COND_WAIT_END);
1200 result Monitor::Notify(void) {
1202 (Monitor::*methodType)(void);
1203 static methodType Notifyp = 0;
1205 probeInfo_t probeInfo;
1208 bool bfiltering = true;
1213 if(lib_handle[LIBOSP_APPFW] == NULL) {
1214 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1215 if (lib_handle[LIBOSP_APPFW] == NULL) {
1216 perror("dlopen failed : libosp-appfw.so");
1220 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor6NotifyEv");
1222 if (tmpPtr == NULL || dlerror() != NULL) {
1223 perror("dlsym failed : Tizen::Base::Runtime::Monitor::Notify");
1227 memcpy(&Notifyp, &tmpPtr, sizeof(tmpPtr));
1232 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1233 setProbePoint(&probeInfo);
1237 ret = (this->*Notifyp)();
1239 if (postBlockBegin(blockresult)) {
1243 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
1244 probeInfo.eventIndex, "Monitor::Notify",
1245 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1247 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1248 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
1249 log.length += sprintf(log.data + log.length,
1250 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
1251 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_NOTIFY);
1253 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1254 getBacktraceString(&log, 4096 - log.length - 17);
1255 log.length += sprintf(log.data + log.length, "`,callstack_end");
1257 printLog(&log, MSG_LOG);
1259 PREPARE_LOCAL_BUF();
1260 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
1261 PACK_COMMON_END(ret, ret, blockresult);
1262 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_NOTIFY);
1270 result Monitor::NotifyAll(void) {
1272 (Monitor::*methodType)(void);
1273 static methodType NotifyAllp = 0;
1275 probeInfo_t probeInfo;
1278 bool bfiltering = true;
1283 if(lib_handle[LIBOSP_APPFW] == NULL) {
1284 lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1285 if (lib_handle[LIBOSP_APPFW] == NULL) {
1286 perror("dlopen failed : libosp-appfw.so");
1290 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor9NotifyAllEv");
1292 if (tmpPtr == NULL || dlerror() != NULL) {
1293 perror("dlsym failed : Tizen::Base::Runtime::Monitor::NotifyAll");
1297 memcpy(&NotifyAllp, &tmpPtr, sizeof(tmpPtr));
1302 if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1303 setProbePoint(&probeInfo);
1307 ret = (this->*NotifyAllp)();
1309 if (postBlockBegin(blockresult)) {
1313 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_SYNC,
1314 probeInfo.eventIndex, "Monitor::NotifyAll",
1315 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1317 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1318 //PCAddr,errno,InternalCall,CallerPCAddr,SyncVal,SyncType,ApiType
1319 log.length += sprintf(log.data + log.length,
1320 "`,0`,%lu`,%d`,%u`,0x%x`,%d`,%d", ret, blockresult,
1321 (unsigned int)CALLER_ADDRESS, (unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_NOTIFY_ALL);
1323 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1324 getBacktraceString(&log, 4096 - log.length - 17);
1325 log.length += sprintf(log.data + log.length, "`,callstack_end");
1327 printLog(&log, MSG_LOG);
1329 PREPARE_LOCAL_BUF();
1330 PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, "", 0);
1331 PACK_COMMON_END(ret, ret, blockresult);
1332 PACK_THREAD((unsigned int) this, SYNC_OSP_MONITOR, SYNC_API_NOTIFY_ALL);