probe_badaapi/bada_thread.cpp

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (Thread::*c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Woojin Jung <woojin2.jung@samsung.com>
   9  * Yeongtaik Byeon <yeongtaik.byeon@samsung.com>
  10  * Jaewon Lim <jaewon81.lim@samsung.com>
  11  * Juyoung Kim <j0.kim@samsung.com>
  12  *
  13  * This library is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the
  15  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  21  * License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  25  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  *
  30  */
  31
  32 //#include <FBase.h>
  33 #include <FBaseDataType.h>
  34 #include <FBaseRtIRunnable.h>
  35 #include <FBaseCol.h>
  36 //#include <FIo.h>
  37 #include "daprobe.h"
  38 #include "probeinfo.h"
  39 #include "dahelper.h"
  40
  41 static enum DaOptions _sopt = OPT_THREAD;
  42
  43 extern  __thread unsigned int gProbeDepth;
  44
  45 namespace Tizen {
  46 namespace Base {
  47 namespace Runtime {
  48 enum ThreadType {
  49         THREAD_TYPE_WORKER = 0, /**< The worker thread mode */
  50         THREAD_TYPE_EVENT_DRIVEN, /**< The event-driven thread mode */
  51         THREAD_TYPE_MAIN
  52 // This enum value is for internal use only. Using this enum value can cause behavioral,
  53 // security-related, and consistency-related issues in the application.
  54 // The main thread mode
  55 };
  56
  57 enum ThreadPriority {
  58         THREAD_PRIORITY_HIGH, /**< The high priority*/
  59         THREAD_PRIORITY_MID, /**< The mid priority*/
  60         THREAD_PRIORITY_LOW,
  61 /**< The low priority*/
  62 };
  63
  64 class Thread {
  65 public:
  66         const static unsigned long DEFAULT_STACK_SIZE = 64 * 1024;
  67
  68         static result Sleep(long milliSeconds);
  69         static Thread* GetCurrentThread(void);
  70         static result Yield(void);
  71         static result Exit(int exitCode=0x00);
  72
  73         result Construct(ThreadType threadType, long stackSize, // deprecated
  74                         ThreadPriority priority = THREAD_PRIORITY_MID);
  75         result Construct(long stackSize = DEFAULT_STACK_SIZE,
  76                         ThreadPriority priority = THREAD_PRIORITY_MID);
  77         result Construct(const Tizen::Base::String &name, long stackSize =
  78                         DEFAULT_STACK_SIZE, ThreadPriority priority = THREAD_PRIORITY_MID);
  79         result Construct(const Tizen::Base::String &name, ThreadType threadType, // deprecated
  80                         long stackSize = DEFAULT_STACK_SIZE, ThreadPriority priority =
  81                                         THREAD_PRIORITY_MID);
  82         result Construct(IRunnable &target, long stackSize = DEFAULT_STACK_SIZE,
  83                         ThreadPriority priority = THREAD_PRIORITY_MID);
  84         result Construct(const Tizen::Base::String &name, IRunnable &target,
  85                         long stackSize = DEFAULT_STACK_SIZE, ThreadPriority priority =
  86                                         THREAD_PRIORITY_MID);
  87         result GetExitCode(int &exitCode) const;
  88         const Tizen::Base::String & GetName(void) const;
  89         result Join(void);
  90 //      virtual bool OnStart(void); // deprecated
  91 //      virtual void OnStop(void); // deprecated
  92 //      virtual void OnUserEventReceivedN(RequestId requestId, // deprecated
  93 //                      Tizen::Base::Collection::IList *pArgs);
  94 //      virtual Tizen::Base::Object * Run(void);
  95 //      virtual result SendUserEvent(RequestId requestId, // deprecated
  96 //                      const Tizen::Base::Collection::IList *pArgs);
  97         result Start(void);
  98         result Stop(void); // deprecated
  99
 100 //      Thread(void);
 101 //      virtual ~Thread(void);
 102
 103 //private:
 104 //      Thread(const Thread& rhs);
 105 //      Thread& operator =(const Thread& rhs);
 106 //private:
 107 //      friend class _ThreadImpl;
 108 //      class _ThreadImpl* __pThreadImpl;
 109 };
 110
 111 class _ThreadImpl {
 112 //public:
 113 //      virtual result Stop(void);
 114 protected:
 115 //      virtual result Finalize(void);
 116         const Thread* GetThread(void) const;
 117 private:
 118         static void* ThreadProc(void* pParam);
 119 //protected:
 120 //      Thread* _pThread;
 121 };
 122 //const Thread*
 123 //_ThreadImpl::GetThread(void) const
 124 //{
 125 //      typedef const Thread*
 126 //      (_ThreadImpl::*methodType)(void) const;
 127 //      static methodType GetThreadp = 0;
 128 //      probeInfo_t probeInfo;
 129 //      log_t log;
 130 //      int blockresult;
 131 //      bool bfiltering = false;
 132 //      void *tmpPtr;
 133 //
 134 //      if (!GetThreadp) {
 135 //              probeBlockStart();
 136 //              void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
 137 //              if (lib_handle == NULL) {
 138 //                      perror("dlopen failed : libosp-appfw.so");
 139 //                      exit(0);
 140 //              }
 141 //              tmpPtr = dlsym(lib_handle, "_ZNK5Tizen4Base7Runtime11_ThreadImpl9GetThreadEv");
 142 //
 143 //              if (tmpPtr == NULL || dlerror() != NULL) {
 144 //                      perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::GetThreadp");
 145 //                      exit(0);
 146 //              }
 147 //
 148 //              memcpy(&GetThreadp, &tmpPtr, sizeof(tmpPtr));
 149 //
 150 //              probeBlockEnd();
 151 //      }
 152 //
 153 //      if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 154 //              setProbePoint(&probeInfo);
 155 //              preBlockEnd();
 156 //      }
 157 //      //
 158 //      const Thread* ret = (this->*GetThreadp)();
 159 //      result res = GetLastResult();
 160 //      //
 161 //      if (postBlockBegin(blockresult)) {
 162 //              log.type = 0;
 163 //              log.length = 0;
 164 //              log.data[0] = '\0';
 165 //              log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 166 //                              probeInfo.eventIndex, "_ThreadImpl::GetThread", probeInfo.currentTime,
 167 //                              probeInfo.pID, probeInfo.tID);
 168 //
 169 //              //Input,ret
 170 //              log.length += sprintf(log.data + log.length, "`,`,0x%x",ret);
 171 //              //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 172 //              log.length += sprintf(log.data + log.length,
 173 //                              "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", res,blockresult,
 174 //                              (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_OTHER);
 175 //              //callstack
 176 //              log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 177 //              getBacktraceString(&log, 4096 - log.length - 17);
 178 //              log.length += sprintf(log.data + log.length, "`,callstack_end");
 179 //
 180 //              printLog(&log, MSG_LOG);
 181 //              postBlockEnd();
 182 //      }
 183 //      return ret;
 184 //}
 185
 186 class EventDrivenThread : public Thread {
 187 public:
 188         result Construct(long stackSize = DEFAULT_STACK_SIZE,
 189                         ThreadPriority priority = THREAD_PRIORITY_MID);
 190         result Construct(const Tizen::Base::String &name, long stackSize =
 191                         DEFAULT_STACK_SIZE, ThreadPriority priority = THREAD_PRIORITY_MID);
 192
 193         virtual result Quit();
 194 //      virtual bool OnStart(void);
 195 //      virtual void OnStop(void);
 196 //      virtual void OnUserEventReceivedN(RequestId requestId,
 197 //                      Tizen::Base::Collection::IList *pArgs);
 198 //      virtual Tizen::Base::Object * Run(void);
 199 //      virtual result SendUserEvent(RequestId requestId,
 200 //                      const Tizen::Base::Collection::IList *pArgs);
 201
 202 //      EventDrivenThread(void);
 203 //      virtual ~EventDrivenThread(void);
 204
 205 //private:
 206 //      EventDrivenThread(const EventDrivenThread& rhs);
 207 //      EventDrivenThread& operator = (const EventDrivenThread& rhs);
 208 //private:
 209 //      class _EventDrivenThreadImpl* __pEventDrivenThreadImpl;
 210 //      friend class _EventDrivenThreadImpl;
 211 };
 212
 213
 214 void*
 215 _ThreadImpl::ThreadProc(void* params) {
 216         typedef void*
 217         (*methodType)(void*);
 218         static methodType ThreadProcp = 0;
 219         probeInfo_t probeInfo;
 220         log_t log;
 221         int blockresult;
 222         bool bfiltering = false;
 223         void *tmpPtr;
 224
 225         if (!ThreadProcp) {
 226                 probeBlockStart();
 227                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 228                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 229                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 230                                 perror("dlopen failed : libosp-appfw.so");
 231                                 exit(0);
 232                         }
 233                 }
 234                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime11_ThreadImpl10ThreadProcEPv");
 235
 236                 if (tmpPtr == NULL || dlerror() != NULL) {
 237                         perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::ThreadProc");
 238                         exit(0);
 239                 }
 240
 241                 memcpy(&ThreadProcp, &tmpPtr, sizeof(tmpPtr));
 242
 243                 probeBlockEnd();
 244         }
 245
 246         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 247                 setProbePoint(&probeInfo);
 248                 log.type = 0;
 249                 log.length = 0;
 250                 log.data[0] = '\0';
 251                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 252                                 probeInfo.eventIndex, "_ThreadImpl::ThreadProc", probeInfo.currentTime,
 253                                 probeInfo.pID, probeInfo.tID);
 254
 255                 _ThreadImpl* pSelf =(_ThreadImpl*)params;
 256                 const Thread* pThread;
 257                 if(pSelf != null){
 258                         pThread = pSelf->GetThread();
 259                 }
 260                 //Input,ret
 261                 log.length += sprintf(log.data + log.length, "`,0x%x`,",(unsigned int)pSelf);
 262                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 263                 log.length += sprintf(log.data + log.length,
 264                                 "`,0`,0`,%d`,%u`,`,0x%x`,%d`,%d", blockresult,
 265                                 (unsigned int)CALLER_ADDRESS, (unsigned int)pThread, THREAD_OSPTHREAD_WORKER, THREAD_API_INTERNAL_START);
 266                 //callstack
 267                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 268                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 269
 270                 printLog(&log, MSG_LOG);
 271                 preBlockEnd();
 272         }
 273         // all probe should be reachable inside thread start_routine (user implemented Thread::Run)
 274         gProbeDepth--;
 275         TRACE_STATE_UNSET(TS_ENTER_PROBE_BLOCK);
 276         (ThreadProcp)(params);
 277         TRACE_STATE_SET(TS_ENTER_PROBE_BLOCK);
 278         gProbeDepth++;
 279         //
 280         if (postBlockBegin(blockresult)) {
 281                 setProbePoint(&probeInfo);
 282                 log.type = 0;
 283                 log.length = 0;
 284                 log.data[0] = '\0';
 285                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 286                                 probeInfo.eventIndex, "_ThreadImpl::ThreadProc", probeInfo.currentTime,
 287                                 probeInfo.pID, probeInfo.tID);
 288
 289                 _ThreadImpl* pSelf =(_ThreadImpl*)params;
 290                 const Thread* pThread;
 291                 if(pSelf != null){
 292                         pThread = pSelf->GetThread();
 293                 }
 294                 //Input,ret
 295                 log.length += sprintf(log.data + log.length, "`,0x%x`,",(unsigned int)pSelf);
 296                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 297                 log.length += sprintf(log.data + log.length,
 298                                 "`,0`,0`,%d`,%u`,`,0x%x`,%d`,%d", blockresult,
 299                                 (unsigned int)CALLER_ADDRESS, (unsigned int)pThread, THREAD_OSPTHREAD_WORKER, THREAD_API_INTERNAL_STOP);
 300                 //callstack
 301                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 302                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 303
 304                 printLog(&log, MSG_LOG);
 305                 postBlockEnd();
 306         }
 307         return null;
 308 }
 309 //result _ThreadImpl::Stop(void) {
 310 //      typedef result
 311 //      (_ThreadImpl::*methodType)(void);
 312 //      static methodType Stopp = 0;
 313 //      probeInfo_t probeInfo;
 314 //      log_t log;
 315 //      int blockresult;
 316 //      bool bfiltering = true;
 317 //      void *tmpPtr;
 318 //
 319 //      if (!Stopp) {
 320 //              probeBlockStart();
 321 //              void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
 322 //              if (lib_handle == NULL) {
 323 //                      perror("dlopen failed : libosp-appfw.so");
 324 //                      exit(0);
 325 //              }
 326 //              tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl4StopEv");
 327 //
 328 //              if (tmpPtr == NULL || dlerror() != NULL) {
 329 //                      perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::Stopp");
 330 //                      exit(0);
 331 //              }
 332 //
 333 //              memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
 334 //
 335 //              probeBlockEnd();
 336 //      }
 337 //
 338 //      if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 339 //              setProbePoint(&probeInfo);
 340 //              preBlockEnd();
 341 //      }
 342 //      //
 343 //      result ret= (this->*Stopp)();
 344 //      //
 345 //      if (postBlockBegin(blockresult)) {
 346 //              log.type = 0;
 347 //              log.length = 0;
 348 //              log.data[0] = '\0';
 349 //              log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 350 //                              probeInfo.eventIndex, "_ThreadImpl::Stop", probeInfo.currentTime,
 351 //                              probeInfo.pID, probeInfo.tID);
 352 //              //Input,ret
 353 //              log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
 354 //              //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 355 //              log.length += sprintf(log.data + log.length,
 356 //                              "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", ret, blockresult,
 357 //                              (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_CLOSE);
 358 //              //callstack
 359 //              log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 360 //              getBacktraceString(&log, 4096 - log.length - 17);
 361 //              log.length += sprintf(log.data + log.length, "`,callstack_end");
 362 //
 363 //              printLog(&log, MSG_LOG);
 364 //              postBlockEnd();
 365 //      }
 366 //      return ret;
 367 //}
 368 //
 369 //result _ThreadImpl::Finalize(void) {
 370 //      typedef result
 371 //      (_ThreadImpl::*methodType)(void);
 372 //      static methodType Finalizep = 0;
 373 //      probeInfo_t probeInfo;
 374 //      log_t log;
 375 //      int blockresult;
 376 //      bool bfiltering = false;
 377 //      void *tmpPtr;
 378 //
 379 //      if (!Finalizep) {
 380 //              probeBlockStart();
 381 //              void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
 382 //              if (lib_handle == NULL) {
 383 //                      perror("dlopen failed : libosp-appfw.so");
 384 //                      exit(0);
 385 //              }
 386 //              tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl8FinalizeEv");
 387 //
 388 //              if (tmpPtr == NULL || dlerror() != NULL) {
 389 //                      perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::Finalizep");
 390 //                      exit(0);
 391 //              }
 392 //
 393 //              memcpy(&Finalizep, &tmpPtr, sizeof(tmpPtr));
 394 //              probeBlockEnd();
 395 //      }
 396 //
 397 //      if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 398 //              setProbePoint(&probeInfo);
 399 //              preBlockEnd();
 400 //      }
 401 //      //
 402 //      result ret= (this->*Finalizep)();
 403 //      //
 404 //      if (postBlockBegin(blockresult)) {
 405 //              log.type = 0;
 406 //              log.length = 0;
 407 //              log.data[0] = '\0';
 408 //              log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 409 //                              probeInfo.eventIndex, "_ThreadImpl::Finalize", probeInfo.currentTime,
 410 //                              probeInfo.pID, probeInfo.tID);
 411 //              //Input,ret
 412 //              log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
 413 //              //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 414 //              log.length += sprintf(log.data + log.length,
 415 //                              "`,0`,%ld`,%d`,0`,%u`,0x%x`,%d`,%d`,`,", ret, blockresult,
 416 //                              (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_CLOSE);
 417 //              //callstack
 418 //              log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 419 //              getBacktraceString(&log, 4096 - log.length - 17);
 420 //              log.length += sprintf(log.data + log.length, "`,callstack_end");
 421 //
 422 //              printLog(&log, MSG_LOG);
 423 //              postBlockEnd();
 424 //      }
 425 //      return ret;
 426 //}
 427 //Thread::Thread(void) {
 428 //      typedef void (Thread::*methodType)();
 429 //      static methodType Threadp = 0;
 430 //      probeInfo_t probeInfo;
 431 //      log_t log;
 432 //      int blockresult;
 433 //      bool bfiltering = true;
 434 //      void *tmpPtr;
 435 //
 436 //      if (!Threadp) {
 437 //              probeBlockStart();
 438 //
 439 //              tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen4Base7Runtime6ThreadC1Ev");
 440 //
 441 //              if (tmpPtr == NULL || dlerror() != NULL) {
 442 //                      log.type = 0;
 443 //                                                                                      log.length = 0;
 444 //                                                                                      log.data[0] = '\0';
 445 //                                                                                      log.length = sprintf(log.data,"dlsym failed : Tizen::Base::Runtime::Thread::Thread");
 446 //                      perror("dlsym failed : Tizen::Base::Runtime::Thread::Thread");
 447 //                      printLog(&log, MSG_MSG);
 448 //                      return;
 449 //              }
 450 //
 451 //              memcpy(&Threadp, &tmpPtr, sizeof(tmpPtr));
 452 //              probeBlockEnd();
 453 //      }
 454 //
 455 //      if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 456 //              setProbePoint(&probeInfo);
 457 //              preBlockEnd();
 458 //      }
 459 ////
 460 //      (this->*Threadp)();
 461 ////
 462 //      if (postBlockBegin(blockresult)) {
 463 //              log.type = 0;
 464 //              log.length = 0;
 465 //              log.data[0] = '\0';
 466 //              log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 467 //                              probeInfo.eventIndex, "Thread::Thread", probeInfo.currentTime,
 468 //                              probeInfo.pID, probeInfo.tID);
 469 //              //Input,ret
 470 //              log.length += sprintf(log.data + log.length, "`,`,");
 471 //              //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 472 //
 473 //              log.length += sprintf(log.data + log.length,
 474 //                              "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
 475 //                              (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_OPEN);
 476 //              //callstack
 477 //              log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 478 //              getBacktraceString(&log, 4096 - log.length - 17);
 479 //              log.length += sprintf(log.data + log.length, "`,callstack_end");
 480 //
 481 //              printLog(&log, MSG_LOG);
 482 //              postBlockEnd();
 483 //      }
 484 //}
 485 //
 486 //Thread::~Thread(void) {
 487 //      typedef void (Thread::*methodType)();
 488 //      static methodType ThreadDp = 0;
 489 //      probeInfo_t probeInfo;
 490 //      log_t log;
 491 //      int blockresult;
 492 //      bool bfiltering = true;
 493 //      void *tmpPtr;
 494 //
 495 //      if (!ThreadDp) {
 496 //              probeBlockStart();
 497 //
 498 //              void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
 499 //              if (lib_handle == NULL) {
 500 //                      perror("dlopen failed : libosp-appfw.so");
 501 //                      exit(0);
 502 //              }
 503 //              tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6ThreadD0Ev");
 504 //
 505 //              if (tmpPtr == NULL || dlerror() != NULL) {
 506 //                      perror("dlsym failed : Tizen::Base::Runtime::Thread::~Thread");
 507 //                      exit(0);
 508 //              }
 509 //
 510 //              memcpy(&ThreadDp, &tmpPtr, sizeof(tmpPtr));
 511 //              probeBlockEnd();
 512 //      }
 513 //
 514 //      if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 515 //              setProbePoint(&probeInfo);
 516 //              preBlockEnd();
 517 //      }
 518 ////
 519 //      (this->*ThreadDp)();
 520 ////
 521 //      if (postBlockBegin(blockresult)) {
 522 //              log.type = 0;
 523 //              log.length = 0;
 524 //              log.data[0] = '\0';
 525 //              log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 526 //                              probeInfo.eventIndex, "Thread::~Thread", probeInfo.currentTime,
 527 //                              probeInfo.pID, probeInfo.tID);
 528 //              //Input,ret
 529 //              log.length += sprintf(log.data + log.length, "`,`,");
 530 //              //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 531 //
 532 //              log.length += sprintf(log.data + log.length,
 533 //                              "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
 534 //                              (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_CLOSE);
 535 //              //callstack
 536 //              log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 537 //              getBacktraceString(&log, 4096 - log.length - 17);
 538 //              log.length += sprintf(log.data + log.length, "`,callstack_end");
 539 //
 540 //              printLog(&log, MSG_LOG);
 541 //              postBlockEnd();
 542 //      }
 543 //}
 544 result Thread::Sleep(long milliSeconds) {
 545         typedef result
 546         (*methodType)(long);
 547         static methodType Sleepp = 0;
 548         probeInfo_t probeInfo;
 549         log_t log;
 550         int blockresult;
 551         bool bfiltering = true;
 552         void *tmpPtr;
 553
 554         if (!Sleepp) {
 555                 probeBlockStart();
 556                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 557                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 558                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 559                                 perror("dlopen failed : libosp-appfw.so");
 560                                 exit(0);
 561                         }
 562                 }
 563                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5SleepEl");
 564
 565                 if (tmpPtr == NULL || dlerror() != NULL) {
 566                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Sleep");
 567                         exit(0);
 568                 }
 569
 570                 memcpy(&Sleepp, &tmpPtr, sizeof(tmpPtr));
 571
 572                 probeBlockEnd();
 573         }
 574
 575         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 576                 setProbePoint(&probeInfo);
 577                 log.type = 0;
 578                 log.length = 0;
 579                 log.data[0] = '\0';
 580                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 581                                 probeInfo.eventIndex, "Thread::Sleep", probeInfo.currentTime,
 582                                 probeInfo.pID, probeInfo.tID);
 583
 584                 Thread *currentThread;
 585                 currentThread = GetCurrentThread();
 586
 587                 //Input,ret
 588                 log.length += sprintf(log.data + log.length, "`,%ld`,",milliSeconds);
 589                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 590                 log.length += sprintf(log.data + log.length,
 591                                                 "`,0`,0`,%d`,%u`,`,0x%x`,%d`,%d",blockresult,
 592                                                 (unsigned int)CALLER_ADDRESS, (unsigned int)currentThread, THREAD_OSPTHREAD_WORKER, THREAD_API_WAIT_START);
 593                 //callstack
 594                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 595                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 596
 597                 printLog(&log, MSG_LOG);
 598                 preBlockEnd();
 599         }
 600         //
 601         result ret = (Sleepp)(milliSeconds);
 602         //
 603         if (postBlockBegin(blockresult)) {
 604                 setProbePoint(&probeInfo);
 605                 log.type = 0;
 606                 log.length = 0;
 607                 log.data[0] = '\0';
 608                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 609                                 probeInfo.eventIndex, "Thread::Sleep", probeInfo.currentTime,
 610                                 probeInfo.pID, probeInfo.tID);
 611
 612                 Thread *currentThread;
 613                 currentThread = GetCurrentThread();
 614
 615                 //Input,ret
 616                 log.length += sprintf(log.data + log.length, "`,%ld`,%ld",milliSeconds,ret);
 617                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 618                 log.length += sprintf(log.data + log.length,
 619                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret,blockresult,
 620                                 (unsigned int)CALLER_ADDRESS, (unsigned int)currentThread, THREAD_OSPTHREAD_WORKER, THREAD_API_WAIT_END);
 621                 //callstack
 622                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 623                 getBacktraceString(&log, 4096 - log.length - 17);
 624                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 625
 626                 printLog(&log, MSG_LOG);
 627                 postBlockEnd();
 628         }
 629         return ret;
 630 }
 631
 632 Thread* Thread::GetCurrentThread(void) {
 633         typedef Thread*
 634                 (*methodType)(void);
 635         static methodType GetCurrentThreadp = 0;
 636         probeInfo_t probeInfo;
 637         log_t log;
 638         int blockresult;
 639         bool bfiltering = true;
 640         void *tmpPtr;
 641
 642         if (!GetCurrentThreadp) {
 643                 probeBlockStart();
 644                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 645                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 646                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 647                                 perror("dlopen failed : libosp-appfw.so");
 648                                 exit(0);
 649                         }
 650                 }
 651                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread16GetCurrentThreadEv");
 652
 653                 if (tmpPtr == NULL || dlerror() != NULL) {
 654                         perror("dlsym failed : Tizen::Base::Runtime::Thread::GetCurrentThread");
 655                         exit(0);
 656                 }
 657
 658                 memcpy(&GetCurrentThreadp, &tmpPtr, sizeof(tmpPtr));
 659
 660                 probeBlockEnd();
 661         }
 662
 663         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 664                 setProbePoint(&probeInfo);
 665                 preBlockEnd();
 666         }
 667         //
 668         Thread *currentThread = (GetCurrentThreadp)();
 669         result res = GetLastResult();
 670         //
 671         if (postBlockBegin(blockresult)) {
 672                 log.type = 0;
 673                 log.length = 0;
 674                 log.data[0] = '\0';
 675                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 676                                 probeInfo.eventIndex, "Thread::GetCurrentThread", probeInfo.currentTime,
 677                                 probeInfo.pID, probeInfo.tID);
 678
 679                 //Input,ret
 680                 log.length += sprintf(log.data + log.length, "`,`,0x%x",(unsigned int)currentThread);
 681                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 682                 log.length += sprintf(log.data + log.length,
 683                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", res,blockresult,
 684                                 (unsigned int)CALLER_ADDRESS, (unsigned int)currentThread, THREAD_OSPTHREAD_WORKER, THREAD_API_OTHER);
 685                 //callstack
 686                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 687                 getBacktraceString(&log, 4096 - log.length - 17);
 688                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 689
 690                 printLog(&log, MSG_LOG);
 691                 postBlockEnd();
 692         }
 693         return currentThread;
 694 }
 695
 696 result Thread::Yield(void) {
 697         typedef result
 698                 (*methodType)(void);
 699         static methodType Yieldp = 0;
 700         probeInfo_t probeInfo;
 701         log_t log;
 702         int blockresult;
 703         bool bfiltering = true;
 704         void *tmpPtr;
 705
 706         if (!Yieldp) {
 707                 probeBlockStart();
 708                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 709                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 710                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 711                                 perror("dlopen failed : libosp-appfw.so");
 712                                 exit(0);
 713                         }
 714                 }
 715                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5YieldEv");
 716
 717                 if (tmpPtr == NULL || dlerror() != NULL) {
 718                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Yield");
 719                         exit(0);
 720                 }
 721
 722                 memcpy(&Yieldp, &tmpPtr, sizeof(tmpPtr));
 723
 724                 probeBlockEnd();
 725         }
 726
 727         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 728                 setProbePoint(&probeInfo);
 729                 preBlockEnd();
 730         }
 731         //
 732         result ret = (Yieldp)();
 733         //
 734         if (postBlockBegin(blockresult)) {
 735                 log.type = 0;
 736                 log.length = 0;
 737                 log.data[0] = '\0';
 738                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 739                                 probeInfo.eventIndex, "Thread::Yield", probeInfo.currentTime,
 740                                 probeInfo.pID, probeInfo.tID);
 741
 742                 Thread *currentThread;
 743                 currentThread = GetCurrentThread();
 744
 745                 //Input,ret
 746                 log.length += sprintf(log.data + log.length, "`,`,%ld",ret);
 747                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 748                 log.length += sprintf(log.data + log.length,
 749                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret,blockresult,
 750                                 (unsigned int)CALLER_ADDRESS, (unsigned int)currentThread, THREAD_OSPTHREAD_WORKER, THREAD_API_OTHER);
 751                 //callstack
 752                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 753                 getBacktraceString(&log, 4096 - log.length - 17);
 754                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 755
 756                 printLog(&log, MSG_LOG);
 757                 postBlockEnd();
 758         }
 759         return ret;
 760 }
 761
 762 result Thread::Exit(int exitCode) {
 763         typedef result
 764                 (*methodType)(int exitCode);
 765         static methodType Exitp = 0;
 766         probeInfo_t probeInfo;
 767         log_t log;
 768         int blockresult;
 769         bool bfiltering = true;
 770         void *tmpPtr;
 771
 772         if (!Exitp) {
 773                 probeBlockStart();
 774                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 775                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 776                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 777                                 perror("dlopen failed : libosp-appfw.so");
 778                                 exit(0);
 779                         }
 780                 }
 781                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4ExitEi");
 782
 783                 if (tmpPtr == NULL || dlerror() != NULL) {
 784                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Exit");
 785                         exit(0);
 786                 }
 787
 788                 memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
 789
 790                 probeBlockEnd();
 791         }
 792
 793         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 794                 setProbePoint(&probeInfo);
 795                 log.type = 0;
 796                 log.length = 0;
 797                 log.data[0] = '\0';
 798                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 799                                 probeInfo.eventIndex, "Thread::Exit", probeInfo.currentTime,
 800                                 probeInfo.pID, probeInfo.tID);
 801
 802                 Thread *currentThread;
 803                 currentThread = GetCurrentThread();
 804
 805                 //Input,ret
 806                 log.length += sprintf(log.data + log.length, "`,%d`,",exitCode);
 807                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 808                 log.length += sprintf(log.data + log.length,
 809                                 "`,0`,0`,%d`,%u`,`,0x%x`,%d`,%d",blockresult,
 810                                 (unsigned int)CALLER_ADDRESS, (unsigned int)currentThread, THREAD_OSPTHREAD_WORKER, THREAD_API_EXIT);
 811                 //callstack
 812                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 813                 getBacktraceString(&log, 4096 - log.length - 17);
 814                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 815
 816                 printLog(&log, MSG_LOG);
 817                 preBlockEnd();
 818         }
 819         //
 820         result ret = (Exitp)(exitCode);
 821         //
 822         return ret;
 823 }
 824
 825 result Thread::Construct(ThreadType threadType, long stackSize,
 826                 ThreadPriority priority) {
 827         typedef result
 828         (Thread::*methodType)(ThreadType threadType, long stackSize,
 829                         ThreadPriority priority);
 830         static methodType Constructp = 0;
 831         result ret;
 832         probeInfo_t probeInfo;
 833         log_t log;
 834         int blockresult;
 835         bool bfiltering = true;
 836         void *tmpPtr;
 837
 838         if (!Constructp) {
 839                 probeBlockStart();
 840                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 841                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 842                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 843                                 perror("dlopen failed : libosp-appfw.so");
 844                                 exit(0);
 845                         }
 846                 }
 847                 tmpPtr =
 848                                 dlsym(
 849                                                 lib_handle[LIBOSP_APPFW],
 850                                                 "_ZN5Tizen4Base7Runtime6Thread9ConstructENS1_10ThreadTypeElNS1_14ThreadPriorityE");
 851
 852                 if (tmpPtr == NULL || dlerror() != NULL) {
 853                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
 854                         exit(0);
 855                 }
 856
 857                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 858                 probeBlockEnd();
 859         }
 860
 861         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 862                 setProbePoint(&probeInfo);
 863                 preBlockEnd();
 864         }
 865         //
 866         ret = (this->*Constructp)(threadType, stackSize, priority);
 867         //
 868         if (postBlockBegin(blockresult)) {
 869                 log.type = 0;
 870                 log.length = 0;
 871                 log.data[0] = '\0';
 872                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 873                                 probeInfo.eventIndex, "Thread::Construct",
 874                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 875                 //Input,ret
 876                 log.length += sprintf(log.data + log.length, "`,%d, %ld, %d`,%ld",
 877                                 threadType, stackSize, priority, ret);
 878                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 879                 log.length += sprintf(log.data + log.length,
 880                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
 881                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_NEW);
 882                 //callstack
 883                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 884                 getBacktraceString(&log, 4096 - log.length - 17);
 885                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 886
 887                 printLog(&log, MSG_LOG);
 888                 postBlockEnd();
 889         }
 890         return ret;
 891 }
 892 result Thread::Construct(long stackSize, ThreadPriority priority) {
 893         typedef result
 894         (Thread::*methodType)(long stackSize, ThreadPriority priority);
 895         static methodType Constructp = 0;
 896         result ret;
 897         probeInfo_t probeInfo;
 898         log_t log;
 899         int blockresult;
 900         bool bfiltering = true;
 901         void *tmpPtr;
 902
 903         if (!Constructp) {
 904                 probeBlockStart();
 905                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 906                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 907                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 908                                 perror("dlopen failed : libosp-appfw.so");
 909                                 exit(0);
 910                         }
 911                 }
 912                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
 913                                 "_ZN5Tizen4Base7Runtime6Thread9ConstructElNS1_14ThreadPriorityE");
 914                 if (tmpPtr == NULL || dlerror() != NULL) {
 915                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
 916                         exit(0);
 917                 }
 918
 919                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 920                 probeBlockEnd();
 921         }
 922
 923         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 924                 setProbePoint(&probeInfo);
 925                 preBlockEnd();
 926         }
 927         //
 928         ret = (this->*Constructp)(stackSize, priority);
 929         //
 930         if (postBlockBegin(blockresult)) {
 931                 log.type = 0;
 932                 log.length = 0;
 933                 log.data[0] = '\0';
 934                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
 935                                 probeInfo.eventIndex, "Thread::Construct",
 936                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 937                 //Input,ret
 938                 log.length += sprintf(log.data + log.length, "`,%ld, %d`,%ld",
 939                                 stackSize, priority, ret);
 940                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
 941                 log.length += sprintf(log.data + log.length,
 942                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
 943                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_NEW);
 944                 //callstack
 945                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
 946                 getBacktraceString(&log, 4096 - log.length - 17);
 947                 log.length += sprintf(log.data + log.length, "`,callstack_end");
 948
 949                 printLog(&log, MSG_LOG);
 950                 postBlockEnd();
 951         }
 952         return ret;
 953 }
 954 result Thread::Construct(const Tizen::Base::String &name, long stackSize,
 955                 ThreadPriority priority) {
 956         typedef result
 957         (Thread::*methodType)(const Tizen::Base::String &name, long stackSize,
 958                         ThreadPriority priority);
 959         static methodType Constructp = 0;
 960         result ret;
 961         probeInfo_t probeInfo;
 962         log_t log;
 963         int blockresult;
 964         bool bfiltering = true;
 965         void *tmpPtr;
 966         char temp[50];
 967
 968         if (!Constructp) {
 969                 probeBlockStart();
 970                 if(lib_handle[LIBOSP_APPFW] == NULL) {
 971                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
 972                         if (lib_handle[LIBOSP_APPFW] == NULL) {
 973                                 perror("dlopen failed : libosp-appfw.so");
 974                                 exit(0);
 975                         }
 976                 }
 977                 tmpPtr =
 978                                 dlsym(
 979                                                 lib_handle[LIBOSP_APPFW],
 980                                                 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
 981
 982                 if (tmpPtr == NULL || dlerror() != NULL) {
 983                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
 984                         exit(0);
 985                 }
 986
 987                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 988                 probeBlockEnd();
 989         }
 990
 991         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 992                 setProbePoint(&probeInfo);
 993                 preBlockEnd();
 994         }
 995         //
 996         ret = (this->*Constructp)(name, stackSize, priority);
 997         //
 998         if (postBlockBegin(blockresult)) {
 999                 log.type = 0;
1000                 log.length = 0;
1001                 log.data[0] = '\0';
1002                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1003                                 probeInfo.eventIndex, "Thread::Construct",
1004                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1005                 //Input,ret
1006                 WcharToChar(temp, name.GetPointer());
1007                 log.length += sprintf(log.data + log.length, "`,%s, %ld, %d`,%ld", temp,
1008                                 stackSize, priority, ret);
1009                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1010                 log.length += sprintf(log.data + log.length,
1011                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1012                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_NEW);
1013                 //callstack
1014                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1015                 getBacktraceString(&log, 4096 - log.length - 17);
1016                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1017
1018                 printLog(&log, MSG_LOG);
1019                 postBlockEnd();
1020         }
1021         return ret;
1022 }
1023 result Thread::Construct(const Tizen::Base::String &name, ThreadType threadType,
1024                 long stackSize, ThreadPriority priority) {
1025         typedef result
1026         (Thread::*methodType)(const Tizen::Base::String &name, ThreadType threadType,
1027                         long stackSize, ThreadPriority priority);
1028         static methodType Constructp = 0;
1029         result ret;
1030         probeInfo_t probeInfo;
1031         log_t log;
1032         int blockresult;
1033         bool bfiltering = true;
1034         void *tmpPtr;
1035         char temp[50];
1036
1037         if (!Constructp) {
1038                 probeBlockStart();
1039                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1040                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1041                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1042                                 perror("dlopen failed : libosp-appfw.so");
1043                                 exit(0);
1044                         }
1045                 }
1046
1047                 tmpPtr =
1048                                 dlsym(
1049                                                 lib_handle[LIBOSP_APPFW],
1050                                                 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringENS1_10ThreadTypeElNS1_14ThreadPriorityE");
1051                 if (tmpPtr == NULL || dlerror() != NULL) {
1052                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
1053                         exit(0);
1054                 }
1055
1056                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1057                 probeBlockEnd();
1058         }
1059
1060         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1061                 setProbePoint(&probeInfo);
1062                 preBlockEnd();
1063         }
1064         //
1065         ret = (this->*Constructp)(name, threadType, stackSize, priority);
1066         //
1067         if (postBlockBegin(blockresult)) {
1068                 log.type = 0;
1069                 log.length = 0;
1070                 log.data[0] = '\0';
1071                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1072                                 probeInfo.eventIndex, "Thread::Construct",
1073                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1074                 //Input,ret
1075                 WcharToChar(temp, name.GetPointer());
1076                 log.length += sprintf(log.data + log.length, "`,%s, %d, %ld, %d`,%ld",
1077                                 temp, threadType, stackSize, priority, ret);
1078                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1079                 log.length += sprintf(log.data + log.length,
1080                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1081                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_NEW);
1082                 //callstack
1083                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1084                 getBacktraceString(&log, 4096 - log.length - 17);
1085                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1086
1087                 printLog(&log, MSG_LOG);
1088                 postBlockEnd();
1089         }
1090         return ret;
1091 }
1092 result Thread::Construct(IRunnable &target, long stackSize,
1093                 ThreadPriority priority) {
1094         typedef result
1095         (Thread::*methodType)(IRunnable &target, long stackSize,
1096                         ThreadPriority priority);
1097         static methodType Constructp = 0;
1098         result ret;
1099         probeInfo_t probeInfo;
1100         log_t log;
1101         int blockresult;
1102         bool bfiltering = true;
1103         void *tmpPtr;
1104
1105         if (!Constructp) {
1106                 probeBlockStart();
1107                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1108                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1109                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1110                                 perror("dlopen failed : libosp-appfw.so");
1111                                 exit(0);
1112                         }
1113                 }
1114                 tmpPtr =
1115                                 dlsym(
1116                                                 lib_handle[LIBOSP_APPFW],
1117                                                 "_ZN5Tizen4Base7Runtime6Thread9ConstructERNS1_9IRunnableElNS1_14ThreadPriorityE");
1118
1119                 if (tmpPtr == NULL || dlerror() != NULL) {
1120                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
1121                         exit(0);
1122                 }
1123
1124                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1125                 probeBlockEnd();
1126         }
1127
1128         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1129                 setProbePoint(&probeInfo);
1130                 preBlockEnd();
1131         }
1132         //
1133         ret = (this->*Constructp)(target, stackSize, priority);
1134         //
1135         if (postBlockBegin(blockresult)) {
1136                 log.type = 0;
1137                 log.length = 0;
1138                 log.data[0] = '\0';
1139                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1140                                 probeInfo.eventIndex, "Thread::Construct",
1141                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1142                 //Input,ret
1143                 log.length += sprintf(log.data + log.length, "`,0x%x, %ld, %d`,%ld",
1144                                 (unsigned int) &target, stackSize, priority, ret);
1145                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1146                 log.length += sprintf(log.data + log.length,
1147                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1148                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_NEW);
1149                 //callstack
1150                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1151                 getBacktraceString(&log, 4096 - log.length - 17);
1152                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1153
1154                 printLog(&log, MSG_LOG);
1155                 postBlockEnd();
1156         }
1157         return ret;
1158 }
1159 result Thread::Construct(const Tizen::Base::String &name, IRunnable &target,
1160                 long stackSize, ThreadPriority priority) {
1161         typedef result
1162         (Thread::*methodType)(const Tizen::Base::String &name, IRunnable &target,
1163                         long stackSize, ThreadPriority priority);
1164         static methodType Constructp = 0;
1165         result ret;
1166         probeInfo_t probeInfo;
1167         log_t log;
1168         int blockresult;
1169         bool bfiltering = true;
1170         void *tmpPtr;
1171         char temp[50];
1172
1173         if (!Constructp) {
1174                 probeBlockStart();
1175                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1176                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1177                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1178                                 perror("dlopen failed : libosp-appfw.so");
1179                                 exit(0);
1180                         }
1181                 }
1182                 tmpPtr =
1183                                 dlsym(
1184                                                 lib_handle[LIBOSP_APPFW],
1185                                                 "_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringERNS1_9IRunnableElNS1_14ThreadPriorityE");
1186
1187                 if (tmpPtr == NULL || dlerror() != NULL) {
1188                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
1189                         exit(0);
1190                 }
1191
1192                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1193                 probeBlockEnd();
1194         }
1195
1196         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1197                 setProbePoint(&probeInfo);
1198                 preBlockEnd();
1199         }
1200         //
1201         ret = (this->*Constructp)(name, target, stackSize, priority);
1202         //
1203         if (postBlockBegin(blockresult)) {
1204                 log.type = 0;
1205                 log.length = 0;
1206                 log.data[0] = '\0';
1207                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1208                                 probeInfo.eventIndex, "Thread::Construct",
1209                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1210                 //Input,ret
1211                 WcharToChar(temp, name.GetPointer());
1212                 log.length += sprintf(log.data + log.length, "`,%s, 0x%x, %ld, %d`,%ld",
1213                                 temp, (unsigned int) &target, stackSize, priority, ret);
1214                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1215                 log.length += sprintf(log.data + log.length,
1216                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1217                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_NEW);
1218                 //callstack
1219                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1220                 getBacktraceString(&log, 4096 - log.length - 17);
1221                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1222
1223                 printLog(&log, MSG_LOG);
1224                 postBlockEnd();
1225         }
1226         return ret;
1227 }
1228
1229 result Thread::GetExitCode(int &exitCode) const {
1230         typedef result
1231         (Thread::*methodType)(int &exitCode) const;
1232         static methodType GetExitCodep = 0;
1233         result ret;
1234         probeInfo_t probeInfo;
1235         log_t log;
1236         int blockresult;
1237         bool bfiltering = true;
1238         void *tmpPtr;
1239 //      int exitOld = exitCode;
1240
1241         if (!GetExitCodep) {
1242                 probeBlockStart();
1243                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1244                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1245                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1246                                 perror("dlopen failed : libosp-appfw.so");
1247                                 exit(0);
1248                         }
1249                 }
1250                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
1251                                 "_ZNK5Tizen4Base7Runtime6Thread11GetExitCodeERi");
1252
1253                 if (tmpPtr == NULL || dlerror() != NULL) {
1254                         perror("dlsym failed : Tizen::Base::Runtime::Thread::GetExitCode");
1255                         exit(0);
1256                 }
1257
1258                 memcpy(&GetExitCodep, &tmpPtr, sizeof(tmpPtr));
1259                 probeBlockEnd();
1260         }
1261
1262         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1263                 setProbePoint(&probeInfo);
1264                 preBlockEnd();
1265         }
1266         //
1267         ret = (this->*GetExitCodep)(exitCode);
1268         //
1269         if (postBlockBegin(blockresult)) {
1270                 log.type = 0;
1271                 log.length = 0;
1272                 log.data[0] = '\0';
1273                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1274                                 probeInfo.eventIndex, "Thread::GetExitCode",
1275                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1276                 //Input,ret
1277 //              log.length += sprintf(log.data + log.length, "`,(%d->%d)`,%ld", exitOld,
1278 //                              exitCode, ret);
1279                 log.length += sprintf(log.data + log.length, "`,%d`,%ld", exitCode, ret);
1280                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1281                 log.length += sprintf(log.data + log.length,
1282                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1283                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_OTHER);
1284                 //callstack
1285                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1286                 getBacktraceString(&log, 4096 - log.length - 17);
1287                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1288
1289                 printLog(&log, MSG_LOG);
1290                 postBlockEnd();
1291         }
1292         return ret;
1293 }
1294
1295 const Tizen::Base::String & Thread::GetName(void) const {
1296         typedef const Tizen::Base::String &
1297         (Thread::*methodType)(void) const;
1298         static methodType GetNamep = 0;
1299         probeInfo_t probeInfo;
1300         log_t log;
1301         int blockresult;
1302         bool bfiltering = true;
1303         void *tmpPtr;
1304         char temp[50];
1305
1306         if (!GetNamep) {
1307                 probeBlockStart();
1308                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1309                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1310                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1311                                 perror("dlopen failed : libosp-appfw.so");
1312                                 exit(0);
1313                         }
1314                 }
1315                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZNK5Tizen4Base7Runtime6Thread7GetNameEv");
1316
1317                 if (tmpPtr == NULL || dlerror() != NULL) {
1318                         perror("dlsym failed : Tizen::Base::Runtime::Thread::GetName");
1319                         exit(0);
1320                 }
1321
1322                 memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
1323                 probeBlockEnd();
1324         }
1325
1326         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1327                 setProbePoint(&probeInfo);
1328                 preBlockEnd();
1329         }
1330         //
1331         const Tizen::Base::String& ret = (this->*GetNamep)();
1332         result res = GetLastResult();
1333         //
1334         if (postBlockBegin(blockresult)) {
1335                 log.type = 0;
1336                 log.length = 0;
1337                 log.data[0] = '\0';
1338                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1339                                 probeInfo.eventIndex, "Thread::GetName", probeInfo.currentTime,
1340                                 probeInfo.pID, probeInfo.tID);
1341                 //Input,ret
1342                 WcharToChar(temp, ret.GetPointer());
1343                 log.length += sprintf(log.data + log.length, "`,`,%s", temp);
1344                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1345                 log.length += sprintf(log.data + log.length,
1346                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", res, blockresult,
1347                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_OTHER);
1348                 //callstack
1349                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1350                 getBacktraceString(&log, 4096 - log.length - 17);
1351                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1352
1353                 printLog(&log, MSG_LOG);
1354                 postBlockEnd();
1355         }
1356         return ret;
1357 }
1358
1359 result Thread::Join(void) {
1360         typedef result
1361         (Thread::*methodType)(void);
1362         static methodType Joinp = 0;
1363         result ret;
1364         probeInfo_t probeInfo;
1365         log_t log;
1366         int blockresult;
1367         bool bfiltering = true;
1368         void *tmpPtr;
1369
1370         if (!Joinp) {
1371                 probeBlockStart();
1372                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1373                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1374                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1375                                 perror("dlopen failed : libosp-appfw.so");
1376                                 exit(0);
1377                         }
1378                 }
1379                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4JoinEv");
1380
1381                 if (tmpPtr == NULL || dlerror() != NULL) {
1382                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Join");
1383                         exit(0);
1384                 }
1385
1386                 memcpy(&Joinp, &tmpPtr, sizeof(tmpPtr));
1387                 probeBlockEnd();
1388         }
1389
1390         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1391                 setProbePoint(&probeInfo);
1392                 log.type = 0;
1393                 log.length = 0;
1394                 log.data[0] = '\0';
1395                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1396                                 probeInfo.eventIndex, "Thread::Join", probeInfo.currentTime,
1397                                 probeInfo.pID, probeInfo.tID);
1398                 //Input,ret
1399                 log.length += sprintf(log.data + log.length, "`,`,");
1400                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1401                 log.length += sprintf(log.data + log.length,
1402                                 "`,0`,0`,%d`,%u`,`,0x%x`,%d`,%d",blockresult,
1403                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_WAIT_START);
1404                 //callstack
1405                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1406                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1407
1408                 printLog(&log, MSG_LOG);
1409                 preBlockEnd();
1410         }
1411         //
1412         ret = (this->*Joinp)();
1413         //
1414         if (postBlockBegin(blockresult)) {
1415                 setProbePoint(&probeInfo);
1416                 log.type = 0;
1417                 log.length = 0;
1418                 log.data[0] = '\0';
1419                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1420                                 probeInfo.eventIndex, "Thread::Join", probeInfo.currentTime,
1421                                 probeInfo.pID, probeInfo.tID);
1422                 //Input,ret
1423                 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1424                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1425                 log.length += sprintf(log.data + log.length,
1426                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret,blockresult,
1427                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_WAIT_END);
1428                 //callstack
1429                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1430                 getBacktraceString(&log, 4096 - log.length - 17);
1431                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1432
1433                 printLog(&log, MSG_LOG);
1434                 postBlockEnd();
1435         }
1436         return ret;
1437 }
1438 //Tizen::Base::Object * Thread::Run(void) {
1439 //      typedef Tizen::Base::Object * (Thread::*methodType)(void);
1440 //      static methodType Runp = 0;
1441 //      Tizen::Base::Object * ret;
1442 //      probeInfo_t probeInfo;
1443 //      log_t log;
1444 //      int blockresult;
1445 //      bool bfiltering = true;
1446 //      void *tmpPtr;
1447 //      log.type = 0;
1448 //                              log.length = 0;
1449 //                              log.data[0] = '\0';
1450 //                              log.length = sprintf(log.data, "call Thread::Run");
1451 //                              printLog(&log, MSG_MSG);
1452 //                              return null;
1453 //      if (!Runp) {
1454 //              probeBlockStart();
1455 //              void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
1456 //              if (lib_handle == NULL) {
1457 //                      perror("dlopen failed : libosp-appfw.so");
1458 //                      log.type = 0;
1459 //                      log.length = 0;
1460 //                      log.data[0] = '\0';
1461 //                      log.length = sprintf(log.data, "dlopen failed :libosp-appfw.so");
1462 //                      printLog(&log, MSG_MSG);
1463 //                      return null;
1464 //              }
1465 //              tmpPtr =
1466 //                              dlsym(
1467 //                                              RTLD_NEXT,
1468 //                                              "_ZN5Tizen4Base7Runtime6Thread3RunEv");
1469 //
1470 //              if (tmpPtr == NULL || dlerror() != NULL) {
1471 //                      perror("dlsym failed : Thread::Run");
1472 //                      log.type = 0;
1473 //                      log.length = 0;
1474 //                      log.data[0] = '\0';
1475 //                      log.length = sprintf(log.data, "dlsym failed : Thread::Run");
1476 //                      printLog(&log, MSG_MSG);
1477 //                      return null;
1478 //              }
1479 //
1480 //              memcpy(&Runp, &tmpPtr, sizeof(tmpPtr));
1481 //              probeBlockEnd();
1482 //      }
1483 //
1484 //      if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1485 //              setProbePoint(&probeInfo);
1486 //              preBlockEnd();
1487 //      }
1488 //      //
1489 //      ret = (this->*Runp)();
1490 //      //
1491 //      if (postBlockBegin(blockresult)) {
1492 //              log.type = 0;
1493 //              log.length = 0;
1494 //              log.data[0] = '\0';
1495 //              log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1496 //                              probeInfo.eventIndex, "Thread::Run",
1497 //                              probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1498 //              //Input,ret
1499 //              log.length += sprintf(log.data + log.length, "`,`,0x%x",(unsigned int)ret;
1500 //              //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1501 //
1502 //
1503 //              log.length += sprintf(log.data + log.length,
1504 //                              "`,0`,0`,%d`,0`,0x%x`,%d`,%d`,`,", blockresult,
1505 //                              (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_OTHER);
1506 //              //callstack
1507 //              log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1508 //              getBacktraceString(&log, 4096 - log.length - 17);
1509 //              log.length += sprintf(log.data + log.length, "`,callstack_end");
1510 //
1511 //              printLog(&log, MSG_LOG);
1512 //              postBlockEnd();
1513 //      }
1514 //      return ret;
1515 //}
1516
1517 result Thread::Start(void) {
1518         typedef result (Thread::*methodType)(void);
1519         static methodType Startp = 0;
1520         result ret;
1521         probeInfo_t probeInfo;
1522         log_t log;
1523         int blockresult;
1524         bool bfiltering = true;
1525         void *tmpPtr;
1526
1527         if (!Startp) {
1528                 probeBlockStart();
1529                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1530                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1531                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1532                                 perror("dlopen failed : libosp-appfw.so");
1533                                 exit(0);
1534                         }
1535                 }
1536                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5StartEv");
1537
1538                 if (tmpPtr == NULL || dlerror() != NULL) {
1539                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Start");
1540                         exit(0);
1541                 }
1542
1543                 memcpy(&Startp, &tmpPtr, sizeof(tmpPtr));
1544                 probeBlockEnd();
1545         }
1546
1547         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1548                 setProbePoint(&probeInfo);
1549                 preBlockEnd();
1550         }
1551         //
1552         ret = (this->*Startp)();
1553         //
1554         if (postBlockBegin(blockresult)) {
1555                 log.type = 0;
1556                 log.length = 0;
1557                 log.data[0] = '\0';
1558                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1559                                 probeInfo.eventIndex, "Thread::Start", probeInfo.currentTime,
1560                                 probeInfo.pID, probeInfo.tID);
1561                 //Input,ret
1562                 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1563                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1564                 log.length += sprintf(log.data + log.length,
1565                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1566                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_START);
1567                 //callstack
1568                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1569                 getBacktraceString(&log, 4096 - log.length - 17);
1570                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1571
1572                 printLog(&log, MSG_LOG);
1573                 postBlockEnd();
1574         }
1575         return ret;
1576 }
1577 result Thread::Stop(void) {
1578         typedef result (Thread::*methodType)(void);
1579         static methodType Stopp = 0;
1580         result ret;
1581         probeInfo_t probeInfo;
1582         log_t log;
1583         int blockresult;
1584         bool bfiltering = true;
1585         void *tmpPtr;
1586
1587         if (!Stopp) {
1588                 probeBlockStart();
1589                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1590                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1591                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1592                                 perror("dlopen failed : libosp-appfw.so");
1593                                 exit(0);
1594                         }
1595                 }
1596                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4StopEv");
1597
1598                 if (tmpPtr == NULL || dlerror() != NULL) {
1599                         perror("dlsym failed : Tizen::Base::Runtime::Thread::Stop");
1600                         exit(0);
1601                 }
1602
1603                 memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
1604                 probeBlockEnd();
1605         }
1606
1607         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1608                 setProbePoint(&probeInfo);
1609                 preBlockEnd();
1610         }
1611         //
1612         ret = (this->*Stopp)();
1613         //
1614         if (postBlockBegin(blockresult)) {
1615                 log.type = 0;
1616                 log.length = 0;
1617                 log.data[0] = '\0';
1618                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1619                                 probeInfo.eventIndex, "Thread::Stop", probeInfo.currentTime,
1620                                 probeInfo.pID, probeInfo.tID);
1621                 //Input,ret
1622                 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1623                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1624                 log.length += sprintf(log.data + log.length,
1625                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1626                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_WORKER, THREAD_API_STOP);
1627                 //callstack
1628                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1629                 getBacktraceString(&log, 4096 - log.length - 17);
1630                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1631
1632                 printLog(&log, MSG_LOG);
1633                 postBlockEnd();
1634         }
1635         return ret;
1636 }
1637
1638 result EventDrivenThread::Construct(long stackSize, ThreadPriority priority) {
1639         typedef result
1640         (Thread::*methodType)(long stackSize, ThreadPriority priority);
1641         static methodType Constructp = 0;
1642         result ret;
1643         probeInfo_t probeInfo;
1644         log_t log;
1645         int blockresult;
1646         bool bfiltering = true;
1647         void *tmpPtr;
1648
1649         if (!Constructp) {
1650                 probeBlockStart();
1651                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1652                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1653                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1654                                 perror("dlopen failed : libosp-appfw.so");
1655                                 exit(0);
1656                         }
1657                 }
1658                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
1659                                 "_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructElNS1_14ThreadPriorityE");
1660                 if (tmpPtr == NULL || dlerror() != NULL) {
1661                         perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
1662                         exit(0);
1663                 }
1664
1665                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1666                 probeBlockEnd();
1667         }
1668
1669         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1670                 setProbePoint(&probeInfo);
1671                 preBlockEnd();
1672         }
1673         //
1674         ret = (this->*Constructp)(stackSize, priority);
1675         //
1676         if (postBlockBegin(blockresult)) {
1677                 log.type = 0;
1678                 log.length = 0;
1679                 log.data[0] = '\0';
1680                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1681                                 probeInfo.eventIndex, "EventDrivenThread::Construct",
1682                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1683                 //Input,ret
1684                 log.length += sprintf(log.data + log.length, "`,%ld, %d`,%ld",
1685                                 stackSize, priority, ret);
1686                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1687                 log.length += sprintf(log.data + log.length,
1688                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1689                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_EVENTDRIVEN, THREAD_API_NEW);
1690                 //callstack
1691                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1692                 getBacktraceString(&log, 4096 - log.length - 17);
1693                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1694
1695                 printLog(&log, MSG_LOG);
1696                 postBlockEnd();
1697         }
1698         return ret;
1699 }
1700
1701 result EventDrivenThread::Construct(const Tizen::Base::String &name, long stackSize,
1702                 ThreadPriority priority) {
1703         typedef result
1704         (Thread::*methodType)(const Tizen::Base::String &name, long stackSize,
1705                         ThreadPriority priority);
1706         static methodType Constructp = 0;
1707         result ret;
1708         probeInfo_t probeInfo;
1709         log_t log;
1710         int blockresult;
1711         bool bfiltering = true;
1712         void *tmpPtr;
1713         char temp[50];
1714
1715         if (!Constructp) {
1716                 probeBlockStart();
1717                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1718                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1719                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1720                                 perror("dlopen failed : libosp-appfw.so");
1721                                 exit(0);
1722                         }
1723                 }
1724                 tmpPtr =
1725                                 dlsym(
1726                                                 lib_handle[LIBOSP_APPFW],
1727                                                 "_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
1728
1729                 if (tmpPtr == NULL || dlerror() != NULL) {
1730                         perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
1731                         exit(0);
1732                 }
1733
1734                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
1735                 probeBlockEnd();
1736         }
1737
1738         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1739                 setProbePoint(&probeInfo);
1740                 preBlockEnd();
1741         }
1742         //
1743         ret = (this->*Constructp)(name, stackSize, priority);
1744         //
1745         if (postBlockBegin(blockresult)) {
1746                 log.type = 0;
1747                 log.length = 0;
1748                 log.data[0] = '\0';
1749                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1750                                 probeInfo.eventIndex, "EventDrivenThread::Construct",
1751                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1752                 //Input,ret
1753                 WcharToChar(temp, name.GetPointer());
1754                 log.length += sprintf(log.data + log.length, "`,%s, %ld, %d`,%ld", temp,
1755                                 stackSize, priority, ret);
1756                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1757                 log.length += sprintf(log.data + log.length,
1758                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1759                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_EVENTDRIVEN, THREAD_API_NEW);
1760                 //callstack
1761                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1762                 getBacktraceString(&log, 4096 - log.length - 17);
1763                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1764
1765                 printLog(&log, MSG_LOG);
1766                 postBlockEnd();
1767         }
1768         return ret;
1769
1770 }
1771
1772 result EventDrivenThread::Quit() {
1773         typedef result (Thread::*methodType)(void);
1774         static methodType Quitp = 0;
1775         result ret;
1776         probeInfo_t probeInfo;
1777         log_t log;
1778         int blockresult;
1779         bool bfiltering = true;
1780         void *tmpPtr;
1781
1782         if (!Quitp) {
1783                 probeBlockStart();
1784                 if(lib_handle[LIBOSP_APPFW] == NULL) {
1785                         lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
1786                         if (lib_handle[LIBOSP_APPFW] == NULL) {
1787                                 perror("dlopen failed : libosp-appfw.so");
1788                                 exit(0);
1789                         }
1790                 }
1791                 tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime17EventDrivenThread4QuitEv");
1792
1793                 if (tmpPtr == NULL || dlerror() != NULL) {
1794                         perror("dlsym failed : Tizen::Base::Runtime::EventThread::Quit");
1795                         exit(0);
1796                 }
1797
1798                 memcpy(&Quitp, &tmpPtr, sizeof(tmpPtr));
1799                 probeBlockEnd();
1800         }
1801
1802         if ((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1803                 setProbePoint(&probeInfo);
1804                 preBlockEnd();
1805         }
1806         //
1807         ret = (this->*Quitp)();
1808         //
1809         if (postBlockBegin(blockresult)) {
1810                 log.type = 0;
1811                 log.length = 0;
1812                 log.data[0] = '\0';
1813                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", LC_THREAD,
1814                                 probeInfo.eventIndex, "EventThread::Quit", probeInfo.currentTime,
1815                                 probeInfo.pID, probeInfo.tID);
1816                 //Input,ret
1817                 log.length += sprintf(log.data + log.length, "`,`,%ld", ret);
1818                 //PCAddr,errno,InternalCall,CallerPCAddr,PThreadID,OspThreadID,ThreadType,ApiType
1819                 log.length += sprintf(log.data + log.length,
1820                                 "`,0`,%lu`,%d`,%u`,`,0x%x`,%d`,%d", ret, blockresult,
1821                                 (unsigned int)CALLER_ADDRESS, (unsigned int) this, THREAD_OSPTHREAD_EVENTDRIVEN, THREAD_API_STOP);
1822                 //callstack
1823                 log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
1824                 getBacktraceString(&log, 4096 - log.length - 17);
1825                 log.length += sprintf(log.data + log.length, "`,callstack_end");
1826
1827                 printLog(&log, MSG_LOG);
1828                 postBlockEnd();
1829         }
1830         return ret;
1831 }
1832
1833 }
1834 }
1835 }