probe_badaapi/bada_sync.cpp

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Woojin Jung <woojin2.jung@samsung.com>
   9  * Jaewon Lim <jaewon81.lim@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  *
  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)
  15  * any later version.
  16  *
  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.
  21  *
  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
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  *
  29  */
  30
  31 #include <FBaseResult.h>
  32 #include <FBaseString.h>
  33 #include <FBaseRtTypes.h>
  34
  35 #include <string.h>
  36 #include "daprobe.h"
  37 #include "probeinfo.h"
  38 #include "dahelper.h"
  39
  40 #include "binproto.h"
  41
  42 static enum DaOptions _sopt = OPT_THREAD;
  43
  44 namespace Tizen {
  45 namespace Base {
  46 namespace Runtime {
  47
  48 class Mutex {
  49 public:
  50         result Create(void);
  51         result Create(const Tizen::Base::String& name);
  52         result Release(void);
  53         result Acquire(void);
  54         result TryToAcquire(void);
  55
  56 //      Mutex(void);
  57 //      virtual ~Mutex(void);
  58
  59 //private:
  60 //      Mutex(const Mutex& value);
  61 //      Mutex& opereator =(const Mutex& value);
  62
  63 //private:
  64 //      friend class _MutexImpl;
  65 //      class _MutexImpl * __pMutexImpl;
  66 };
  67
  68 class Semaphore {
  69 public:
  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);
  74         result Release(void);
  75
  76 //      Semaphore(void);
  77 //      virtual ~Semaphore(void);
  78
  79 //private:
  80 //      Semaphore(const Semaphore& rhs);
  81 //      Semaphore& operator =(const Semaphore& rhs);
  82
  83 //private:
  84 //      friend class _SemaphoreImpl;
  85 //      class _SemaphoreImpl * __pSemaphoreImpl;
  86 };
  87
  88 class Monitor {
  89 public:
  90         result Construct(void);
  91         result Enter(void);
  92         result Exit(void);
  93         result Wait(void);
  94         result Notify(void);
  95         result NotifyAll(void);
  96
  97 //      Monitor(void);
  98 //      virtual ~Monitor(void);
  99
 100 //private:
 101 //      Monitor(const Monitor& rhs);
 102 //      Monitor& operator =(const Monitor& rhs);
 103
 104 //private:
 105 //      friend class _MonitorImpl;
 106 //      class _MonitorImpl * __pMonitorImpl;
 107 };
 108
 109
 110 result Mutex::Create(void) {
 111         typedef result
 112                 (Mutex::*methodType)(void);
 113         static methodType Createp = 0;
 114         result ret;
 115         probeInfo_t probeInfo;
 116         log_t log;
 117         int blockresult;
 118         bool bfiltering = true;
 119         void *tmpPtr;
 120
 121         if (!Createp) {
 122                 probeBlockStart();
 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");
 127                                 exit(0);
 128                         }
 129                 }
 130                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex6CreateEv");
 131
 132                 if (tmpPtr == NULL || dlerror() != NULL) {
 133                         perror("dlsym failed : Tizen::Base::Runtime::Mutex::Create");
 134                         exit(0);
 135                 }
 136
 137                 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
 138
 139                 probeBlockEnd();
 140         }
 141
 142         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 143                 setProbePoint(&probeInfo);
 144                 preBlockEnd();
 145         }
 146         //
 147         ret = (this->*Createp)();
 148         //
 149         if (postBlockBegin(blockresult)) {
 150                 log.type = 0;
 151                 log.length = 0;
 152                 log.data[0] = '\0';
 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);
 156                 //Input,ret
 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);
 162                 //callstack
 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");
 166
 167                 printLog(&log, MSG_LOG);
 168
 169                 PREPARE_LOCAL_BUF();
 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);
 173                 FLUSH_LOCAL_BUF();
 174
 175                 postBlockEnd();
 176         }
 177         return ret;
 178 }
 179
 180 result Mutex::Create(const Tizen::Base::String& name) {
 181         typedef result
 182                 (Mutex::*methodType)(const Tizen::Base::String& name);
 183         static methodType Createp = 0;
 184         result ret;
 185         probeInfo_t probeInfo;
 186         log_t log;
 187         int blockresult;
 188         bool bfiltering = true;
 189         void *tmpPtr;
 190         char temp[50];
 191
 192         if (!Createp) {
 193                 probeBlockStart();
 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");
 198                                 exit(0);
 199                         }
 200                 }
 201                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex6CreateERKNS0_6StringE");
 202
 203                 if (tmpPtr == NULL || dlerror() != NULL) {
 204                         perror("dlsym failed : Tizen::Base::Runtime::Mutex::Create");
 205                         exit(0);
 206                 }
 207
 208                 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
 209
 210                 probeBlockEnd();
 211         }
 212
 213         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 214                 setProbePoint(&probeInfo);
 215                 preBlockEnd();
 216         }
 217         //
 218         ret = (this->*Createp)(name);
 219         //
 220         if (postBlockBegin(blockresult)) {
 221                 log.type = 0;
 222                 log.length = 0;
 223                 log.data[0] = '\0';
 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);
 227                 //Input,ret
 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);
 234                 //callstack
 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");
 238
 239                 printLog(&log, MSG_LOG);
 240
 241                 PREPARE_LOCAL_BUF();
 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);
 245                 FLUSH_LOCAL_BUF();
 246
 247                 postBlockEnd();
 248         }
 249         return ret;
 250 }
 251
 252 result Mutex::Release(void) {
 253         typedef result
 254                 (Mutex::*methodType)(void);
 255         static methodType Releasep = 0;
 256         result ret;
 257         probeInfo_t probeInfo;
 258         log_t log;
 259         int blockresult;
 260         bool bfiltering = true;
 261         void *tmpPtr;
 262
 263         if (!Releasep) {
 264                 probeBlockStart();
 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");
 269                                 exit(0);
 270                         }
 271                 }
 272                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex7ReleaseEv");
 273
 274                 if (tmpPtr == NULL || dlerror() != NULL) {
 275                         perror("dlsym failed : Tizen::Base::Runtime::Mutex::Release");
 276                         exit(0);
 277                 }
 278
 279                 memcpy(&Releasep, &tmpPtr, sizeof(tmpPtr));
 280
 281                 probeBlockEnd();
 282         }
 283
 284         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 285                 setProbePoint(&probeInfo);
 286                 preBlockEnd();
 287         }
 288         //
 289         ret = (this->*Releasep)();
 290         //
 291         if (postBlockBegin(blockresult)) {
 292                 log.type = 0;
 293                 log.length = 0;
 294                 log.data[0] = '\0';
 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);
 298                 //Input,ret
 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);
 304                 //callstack
 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");
 308
 309                 printLog(&log, MSG_LOG);
 310
 311                 PREPARE_LOCAL_BUF();
 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);
 315                 FLUSH_LOCAL_BUF();
 316
 317                 postBlockEnd();
 318         }
 319         return ret;
 320 }
 321
 322 result Mutex::Acquire(void) {
 323         typedef result
 324                 (Mutex::*methodType)(void);
 325         static methodType Acquirep = 0;
 326         result ret;
 327         probeInfo_t probeInfo;
 328         log_t log;
 329         int blockresult;
 330         bool bfiltering = true;
 331         void *tmpPtr;
 332
 333         if (!Acquirep) {
 334                 probeBlockStart();
 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");
 339                                 exit(0);
 340                         }
 341                 }
 342                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex7AcquireEv");
 343
 344                 if (tmpPtr == NULL || dlerror() != NULL) {
 345                         perror("dlsym failed : Tizen::Base::Runtime::Mutex::Acquire");
 346                         exit(0);
 347                 }
 348
 349                 memcpy(&Acquirep, &tmpPtr, sizeof(tmpPtr));
 350
 351                 probeBlockEnd();
 352         }
 353
 354         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 355                 setProbePoint(&probeInfo);
 356                 log.type = 0;
 357                 log.length = 0;
 358                 log.data[0] = '\0';
 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);
 362                 //Input,ret
 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);
 368                 //callstack
 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");
 372
 373                 printLog(&log, MSG_LOG);
 374
 375                 PREPARE_LOCAL_BUF();
 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);
 379                 FLUSH_LOCAL_BUF();
 380
 381                 preBlockEnd();
 382         }
 383         //
 384         ret = (this->*Acquirep)();
 385         //
 386         if (postBlockBegin(blockresult)) {
 387                 setProbePoint(&probeInfo);
 388                 log.type = 0;
 389                 log.length = 0;
 390                 log.data[0] = '\0';
 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);
 394                 //Input,ret
 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);
 400                 //callstack
 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");
 404
 405                 printLog(&log, MSG_LOG);
 406
 407                 PREPARE_LOCAL_BUF();
 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);
 411                 FLUSH_LOCAL_BUF();
 412
 413                 postBlockEnd();
 414         }
 415         return ret;
 416 }
 417
 418 result Mutex::TryToAcquire(void) {
 419         typedef result
 420                 (Mutex::*methodType)(void);
 421         static methodType TryToAcquirep = 0;
 422         result ret;
 423         probeInfo_t probeInfo;
 424         log_t log;
 425         int blockresult;
 426         bool bfiltering = true;
 427         void *tmpPtr;
 428
 429         if (!TryToAcquirep) {
 430                 probeBlockStart();
 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");
 435                                 exit(0);
 436                         }
 437                 }
 438                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex12TryToAcquireEv");
 439
 440                 if (tmpPtr == NULL || dlerror() != NULL) {
 441                         perror("dlsym failed : Tizen::Base::Runtime::Mutex::TryToAcquire");
 442                         exit(0);
 443                 }
 444
 445                 memcpy(&TryToAcquirep, &tmpPtr, sizeof(tmpPtr));
 446
 447                 probeBlockEnd();
 448         }
 449
 450         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 451                 setProbePoint(&probeInfo);
 452                 preBlockEnd();
 453         }
 454         //
 455         ret = (this->*TryToAcquirep)();
 456         //
 457         if (postBlockBegin(blockresult)) {
 458                 log.type = 0;
 459                 log.length = 0;
 460                 log.data[0] = '\0';
 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);
 464                 //Input,ret
 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);
 470                 //callstack
 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");
 474
 475                 printLog(&log, MSG_LOG);
 476
 477                 PREPARE_LOCAL_BUF();
 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);
 481                 FLUSH_LOCAL_BUF();
 482
 483                 postBlockEnd();
 484         }
 485         return ret;
 486 }
 487
 488
 489 result Semaphore::Create(int count) {
 490         typedef result
 491                 (Semaphore::*methodType)(int count);
 492         static methodType Createp = 0;
 493         result ret;
 494         probeInfo_t probeInfo;
 495         log_t log;
 496         int blockresult;
 497         bool bfiltering = true;
 498         void *tmpPtr;
 499
 500         if (!Createp) {
 501                 probeBlockStart();
 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");
 506                                 exit(0);
 507                         }
 508                 }
 509                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore6CreateEi");
 510
 511                 if (tmpPtr == NULL || dlerror() != NULL) {
 512                         perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Create");
 513                         exit(0);
 514                 }
 515
 516                 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
 517
 518                 probeBlockEnd();
 519         }
 520
 521         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 522                 setProbePoint(&probeInfo);
 523                 preBlockEnd();
 524         }
 525         //
 526         ret = (this->*Createp)(count);
 527         //
 528         if (postBlockBegin(blockresult)) {
 529                 log.type = 0;
 530                 log.length = 0;
 531                 log.data[0] = '\0';
 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);
 535                 //Input,ret
 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);
 541                 //callstack
 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");
 545
 546                 printLog(&log, MSG_LOG);
 547
 548                 PREPARE_LOCAL_BUF();
 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);
 552                 FLUSH_LOCAL_BUF();
 553
 554                 postBlockEnd();
 555         }
 556         return ret;
 557 }
 558
 559 result Semaphore::Create(const Tizen::Base::String& name, int count) {
 560         typedef result
 561                 (Semaphore::*methodType)(const Tizen::Base::String& name, int count);
 562         static methodType Createp = 0;
 563         result ret;
 564         probeInfo_t probeInfo;
 565         log_t log;
 566         int blockresult;
 567         bool bfiltering = true;
 568         void *tmpPtr;
 569         char temp[50];
 570
 571         if (!Createp) {
 572                 probeBlockStart();
 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");
 577                                 exit(0);
 578                         }
 579                 }
 580                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore6CreateERKNS0_6StringEi");
 581
 582                 if (tmpPtr == NULL || dlerror() != NULL) {
 583                         perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Create");
 584                         exit(0);
 585                 }
 586
 587                 memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
 588
 589                 probeBlockEnd();
 590         }
 591
 592         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 593                 setProbePoint(&probeInfo);
 594                 preBlockEnd();
 595         }
 596         //
 597         ret = (this->*Createp)(name, count);
 598         //
 599         if (postBlockBegin(blockresult)) {
 600                 log.type = 0;
 601                 log.length = 0;
 602                 log.data[0] = '\0';
 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);
 606                 //Input,ret
 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);
 613                 //callstack
 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");
 617
 618                 printLog(&log, MSG_LOG);
 619
 620                 PREPARE_LOCAL_BUF();
 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);
 624                 FLUSH_LOCAL_BUF();
 625
 626                 postBlockEnd();
 627         }
 628         return ret;
 629
 630 }
 631
 632 result Semaphore::Acquire(long timeout) {
 633         typedef result
 634                 (Semaphore::*methodType)(long timeout);
 635         static methodType Acquirep = 0;
 636         result ret;
 637         probeInfo_t probeInfo;
 638         log_t log;
 639         int blockresult;
 640         bool bfiltering = true;
 641         void *tmpPtr;
 642
 643         if (!Acquirep) {
 644                 probeBlockStart();
 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");
 649                                 exit(0);
 650                         }
 651                 }
 652                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore7AcquireEl");
 653
 654                 if (tmpPtr == NULL || dlerror() != NULL) {
 655                         perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Acquire");
 656                         exit(0);
 657                 }
 658
 659                 memcpy(&Acquirep, &tmpPtr, sizeof(tmpPtr));
 660
 661                 probeBlockEnd();
 662         }
 663
 664         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 665                 setProbePoint(&probeInfo);
 666                 log.type = 0;
 667                 log.length = 0;
 668                 log.data[0] = '\0';
 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);
 672                 //Input,ret
 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);
 678                 //callstack
 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");
 682
 683                 printLog(&log, MSG_LOG);
 684
 685                 PREPARE_LOCAL_BUF();
 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);
 689                 FLUSH_LOCAL_BUF();
 690
 691                 preBlockEnd();
 692         }
 693         //
 694         ret = (this->*Acquirep)(timeout);
 695         //
 696         if (postBlockBegin(blockresult)) {
 697                 setProbePoint(&probeInfo);
 698                 log.type = 0;
 699                 log.length = 0;
 700                 log.data[0] = '\0';
 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);
 704                 //Input,ret
 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);
 710                 //callstack
 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");
 714
 715                 printLog(&log, MSG_LOG);
 716
 717                 PREPARE_LOCAL_BUF();
 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);
 721                 FLUSH_LOCAL_BUF();
 722
 723                 postBlockEnd();
 724         }
 725         return ret;
 726 }
 727
 728 result Semaphore::TryToAcquire(void) {
 729         typedef result
 730                 (Semaphore::*methodType)(void);
 731         static methodType TryToAcquirep = 0;
 732         result ret;
 733         probeInfo_t probeInfo;
 734         log_t log;
 735         int blockresult;
 736         bool bfiltering = true;
 737         void *tmpPtr;
 738
 739         if (!TryToAcquirep) {
 740                 probeBlockStart();
 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");
 745                                 exit(0);
 746                         }
 747                 }
 748                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore12TryToAcquireEv");
 749
 750                 if (tmpPtr == NULL || dlerror() != NULL) {
 751                         perror("dlsym failed : Tizen::Base::Runtime::Semaphore::TryToAcquire");
 752                         exit(0);
 753                 }
 754
 755                 memcpy(&TryToAcquirep, &tmpPtr, sizeof(tmpPtr));
 756
 757                 probeBlockEnd();
 758         }
 759
 760         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 761                 setProbePoint(&probeInfo);
 762                 preBlockEnd();
 763         }
 764         //
 765         ret = (this->*TryToAcquirep)();
 766         //
 767         if (postBlockBegin(blockresult)) {
 768                 log.type = 0;
 769                 log.length = 0;
 770                 log.data[0] = '\0';
 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);
 774                 //Input,ret
 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);
 780                 //callstack
 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");
 784
 785                 printLog(&log, MSG_LOG);
 786
 787                 PREPARE_LOCAL_BUF();
 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);
 791                 FLUSH_LOCAL_BUF();
 792
 793                 postBlockEnd();
 794         }
 795         return ret;
 796 }
 797
 798 result Semaphore::Release(void) {
 799         typedef result
 800                 (Semaphore::*methodType)(void);
 801         static methodType Releasep = 0;
 802         result ret;
 803         probeInfo_t probeInfo;
 804         log_t log;
 805         int blockresult;
 806         bool bfiltering = true;
 807         void *tmpPtr;
 808
 809         if (!Releasep) {
 810                 probeBlockStart();
 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");
 815                                 exit(0);
 816                         }
 817                 }
 818                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore7ReleaseEv");
 819
 820                 if (tmpPtr == NULL || dlerror() != NULL) {
 821                         perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Release");
 822                         exit(0);
 823                 }
 824
 825                 memcpy(&Releasep, &tmpPtr, sizeof(tmpPtr));
 826
 827                 probeBlockEnd();
 828         }
 829
 830         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 831                 setProbePoint(&probeInfo);
 832                 preBlockEnd();
 833         }
 834         //
 835         ret = (this->*Releasep)();
 836         //
 837         if (postBlockBegin(blockresult)) {
 838                 log.type = 0;
 839                 log.length = 0;
 840                 log.data[0] = '\0';
 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);
 844                 //Input,ret
 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);
 850                 //callstack
 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");
 854
 855                 printLog(&log, MSG_LOG);
 856
 857                 PREPARE_LOCAL_BUF();
 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);
 861                 FLUSH_LOCAL_BUF();
 862
 863                 postBlockEnd();
 864         }
 865         return ret;
 866 }
 867
 868
 869 result Monitor::Construct(void) {
 870         typedef result
 871                 (Monitor::*methodType)(void);
 872         static methodType Constructp = 0;
 873         result ret;
 874         probeInfo_t probeInfo;
 875         log_t log;
 876         int blockresult;
 877         bool bfiltering = true;
 878         void *tmpPtr;
 879
 880         if (!Constructp) {
 881                 probeBlockStart();
 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");
 886                                 exit(0);
 887                         }
 888                 }
 889                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor9ConstructEv");
 890
 891                 if (tmpPtr == NULL || dlerror() != NULL) {
 892                         perror("dlsym failed : Tizen::Base::Runtime::Monitor::Construct");
 893                         exit(0);
 894                 }
 895
 896                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 897                 probeBlockEnd();
 898         }
 899
 900         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 901                 setProbePoint(&probeInfo);
 902                 preBlockEnd();
 903         }
 904         //
 905         ret = (this->*Constructp)();
 906         //
 907         if (postBlockBegin(blockresult)) {
 908                 log.type = 0;
 909                 log.length = 0;
 910                 log.data[0] = '\0';
 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);
 914                 //Input,ret
 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);
 920                 //callstack
 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");
 924
 925                 printLog(&log, MSG_LOG);
 926
 927                 PREPARE_LOCAL_BUF();
 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);
 931                 FLUSH_LOCAL_BUF();
 932
 933                 postBlockEnd();
 934         }
 935         return ret;
 936 }
 937
 938 result Monitor::Enter(void) {
 939         typedef result
 940                 (Monitor::*methodType)(void);
 941         static methodType Enterp = 0;
 942         result ret;
 943         probeInfo_t probeInfo;
 944         log_t log;
 945         int blockresult;
 946         bool bfiltering = true;
 947         void *tmpPtr;
 948
 949         if (!Enterp) {
 950                 probeBlockStart();
 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");
 955                                 exit(0);
 956                         }
 957                 }
 958                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor5EnterEv");
 959
 960                 if (tmpPtr == NULL || dlerror() != NULL) {
 961                         perror("dlsym failed : Tizen::Base::Runtime::Monitor::Enter");
 962                         exit(0);
 963                 }
 964
 965                 memcpy(&Enterp, &tmpPtr, sizeof(tmpPtr));
 966
 967                 probeBlockEnd();
 968         }
 969
 970         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 971                 setProbePoint(&probeInfo);
 972                 log.type = 0;
 973                 log.length = 0;
 974                 log.data[0] = '\0';
 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);
 978                 //Input,ret
 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);
 984                 //callstack
 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");
 988
 989                 printLog(&log, MSG_LOG);
 990
 991                 PREPARE_LOCAL_BUF();
 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);
 995                 FLUSH_LOCAL_BUF();
 996
 997                 preBlockEnd();
 998         }
 999         //
1000         ret = (this->*Enterp)();
1001         //
1002         if (postBlockBegin(blockresult)) {
1003                 setProbePoint(&probeInfo);
1004                 log.type = 0;
1005                 log.length = 0;
1006                 log.data[0] = '\0';
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);
1010                 //Input,ret
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);
1016                 //callstack
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");
1020
1021                 printLog(&log, MSG_LOG);
1022
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);
1027                 FLUSH_LOCAL_BUF();
1028
1029                 postBlockEnd();
1030         }
1031         return ret;
1032 }
1033
1034 result Monitor::Exit(void) {
1035         typedef result
1036                 (Monitor::*methodType)(void);
1037         static methodType Exitp = 0;
1038         result ret;
1039         probeInfo_t probeInfo;
1040         log_t log;
1041         int blockresult;
1042         bool bfiltering = true;
1043         void *tmpPtr;
1044
1045         if (!Exitp) {
1046                 probeBlockStart();
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");
1051                                 exit(0);
1052                         }
1053                 }
1054                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor4ExitEv");
1055
1056                 if (tmpPtr == NULL || dlerror() != NULL) {
1057                         perror("dlsym failed : Tizen::Base::Runtime::Monitor::Exit");
1058                         exit(0);
1059                 }
1060
1061                 memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
1062
1063                 probeBlockEnd();
1064         }
1065
1066         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1067                 setProbePoint(&probeInfo);
1068                 preBlockEnd();
1069         }
1070         //
1071         ret = (this->*Exitp)();
1072         //
1073         if (postBlockBegin(blockresult)) {
1074                 log.type = 0;
1075                 log.length = 0;
1076                 log.data[0] = '\0';
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);
1080                 //Input,ret
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);
1086                 //callstack
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");
1090
1091                 printLog(&log, MSG_LOG);
1092
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);
1097                 FLUSH_LOCAL_BUF();
1098
1099                 postBlockEnd();
1100         }
1101         return ret;
1102 }
1103
1104 result Monitor::Wait(void) {
1105         typedef result
1106                 (Monitor::*methodType)(void);
1107         static methodType Waitp = 0;
1108         result ret;
1109         probeInfo_t probeInfo;
1110         log_t log;
1111         int blockresult;
1112         bool bfiltering = true;
1113         void *tmpPtr;
1114
1115         if (!Waitp) {
1116                 probeBlockStart();
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");
1121                                 exit(0);
1122                         }
1123                 }
1124                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor4WaitEv");
1125
1126                 if (tmpPtr == NULL || dlerror() != NULL) {
1127                         perror("dlsym failed : Tizen::Base::Runtime::Monitor::Wait");
1128                         exit(0);
1129                 }
1130
1131                 memcpy(&Waitp, &tmpPtr, sizeof(tmpPtr));
1132
1133                 probeBlockEnd();
1134         }
1135
1136         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1137                 setProbePoint(&probeInfo);
1138                 log.type = 0;
1139                 log.length = 0;
1140                 log.data[0] = '\0';
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);
1144                 //Input,ret
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);
1150                 //callstack
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");
1154
1155                 printLog(&log, MSG_LOG);
1156
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);
1161                 FLUSH_LOCAL_BUF();
1162
1163                 preBlockEnd();
1164         }
1165         //
1166         ret = (this->*Waitp)();
1167         //
1168         if (postBlockBegin(blockresult)) {
1169                 setProbePoint(&probeInfo);
1170                 log.type = 0;
1171                 log.length = 0;
1172                 log.data[0] = '\0';
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);
1176                 //Input,ret
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);
1182                 //callstack
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");
1186
1187                 printLog(&log, MSG_LOG);
1188
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);
1193                 FLUSH_LOCAL_BUF();
1194
1195                 postBlockEnd();
1196         }
1197         return ret;
1198 }
1199
1200 result Monitor::Notify(void) {
1201         typedef result
1202                 (Monitor::*methodType)(void);
1203         static methodType Notifyp = 0;
1204         result ret;
1205         probeInfo_t probeInfo;
1206         log_t log;
1207         int blockresult;
1208         bool bfiltering = true;
1209         void *tmpPtr;
1210
1211         if (!Notifyp) {
1212                 probeBlockStart();
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");
1217                                 exit(0);
1218                         }
1219                 }
1220                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor6NotifyEv");
1221
1222                 if (tmpPtr == NULL || dlerror() != NULL) {
1223                         perror("dlsym failed : Tizen::Base::Runtime::Monitor::Notify");
1224                         exit(0);
1225                 }
1226
1227                 memcpy(&Notifyp, &tmpPtr, sizeof(tmpPtr));
1228
1229                 probeBlockEnd();
1230         }
1231
1232         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1233                 setProbePoint(&probeInfo);
1234                 preBlockEnd();
1235         }
1236         //
1237         ret = (this->*Notifyp)();
1238         //
1239         if (postBlockBegin(blockresult)) {
1240                 log.type = 0;
1241                 log.length = 0;
1242                 log.data[0] = '\0';
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);
1246                 //Input,ret
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);
1252                 //callstack
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");
1256
1257                 printLog(&log, MSG_LOG);
1258
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);
1263                 FLUSH_LOCAL_BUF();
1264
1265                 postBlockEnd();
1266         }
1267         return ret;
1268 }
1269
1270 result Monitor::NotifyAll(void) {
1271         typedef result
1272                 (Monitor::*methodType)(void);
1273         static methodType NotifyAllp = 0;
1274         result ret;
1275         probeInfo_t probeInfo;
1276         log_t log;
1277         int blockresult;
1278         bool bfiltering = true;
1279         void *tmpPtr;
1280
1281         if (!NotifyAllp) {
1282                 probeBlockStart();
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");
1287                                 exit(0);
1288                         }
1289                 }
1290                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor9NotifyAllEv");
1291
1292                 if (tmpPtr == NULL || dlerror() != NULL) {
1293                         perror("dlsym failed : Tizen::Base::Runtime::Monitor::NotifyAll");
1294                         exit(0);
1295                 }
1296
1297                 memcpy(&NotifyAllp, &tmpPtr, sizeof(tmpPtr));
1298
1299                 probeBlockEnd();
1300         }
1301
1302         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1303                 setProbePoint(&probeInfo);
1304                 preBlockEnd();
1305         }
1306         //
1307         ret = (this->*NotifyAllp)();
1308         //
1309         if (postBlockBegin(blockresult)) {
1310                 log.type = 0;
1311                 log.length = 0;
1312                 log.data[0] = '\0';
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);
1316                 //Input,ret
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);
1322                 //callstack
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");
1326
1327                 printLog(&log, MSG_LOG);
1328
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);
1333                 FLUSH_LOCAL_BUF();
1334
1335                 postBlockEnd();
1336         }
1337         return ret;
1338 }
1339
1340 }
1341 }
1342 }