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