probe_badaapi/bada_file.cpp

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (File::*c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Jaewon Lim <jaewon81.lim@samsung.com>
   9  * Woojin Jung <woojin2.jung@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  *
  12  * This library is free software; you can redistribute it and/or modify it under
  13  * the terms of the GNU Lesser General Public License as published by the
  14  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  20  * License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  24  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  *
  29  */
  30
  31 #include <FIo.h>
  32 #include "daprobe.h"
  33 #include "probeinfo.h"
  34 #include "dahelper.h"
  35
  36 static enum DaOptions _sopt = OPT_FILE;
  37
  38 namespace Tizen {
  39 namespace Io {
  40
  41 result File::Construct(const Tizen::Base::String& filePath,
  42                 const Tizen::Base::String& openMode, bool createParentDirectories) {
  43         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
  44                         const Tizen::Base::String& openMode, bool createParentDirectories);
  45         static methodType Constructp = 0;
  46         result ret;
  47         probeInfo_t     probeInfo;
  48         log_t   log;
  49         int blockresult;
  50         bool bfiltering = true;
  51         char temp[50];
  52         FileAttributes attr;
  53         long long size = 0L;
  54
  55         if (!Constructp) {
  56                 probeBlockStart();
  57                 void *tmpPtr = dlsym(RTLD_NEXT,
  58                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringES5_b");
  59
  60                 if (tmpPtr == NULL || dlerror() != NULL) {
  61                         perror("dlsym failed : Tizen::Io::File::Construct");
  62                         exit(0);
  63                 }
  64
  65                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
  66                 probeBlockEnd();
  67         }
  68
  69         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
  70                 setProbePoint(&probeInfo);
  71                 preBlockEnd();
  72         }
  73
  74         ret = (this->*Constructp)(filePath, openMode, createParentDirectories);
  75
  76         if(postBlockBegin(blockresult)) {
  77                  log.type = 0;
  78                  log.length = 0;
  79                  log.data[0] = '\0';
  80                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
  81                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
  82                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
  83                  //Input,ret
  84                  WcharToChar(temp,filePath.GetPointer());
  85                  log.length += sprintf(log.data + log.length,"`,%s",temp);
  86                  WcharToChar(temp,openMode.GetPointer());
  87                  log.length += sprintf(log.data + log.length,", %s",temp);
  88                  log.length += sprintf(log.data + log.length,", %s`,%ld",(createParentDirectories == 0 ? "false" : "true"),ret);
  89                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
  90                  if(ret == E_SUCCESS && E_SUCCESS == File::GetAttributes(this->GetName(),attr))
  91                         size = attr.GetFileSize();
  92                  WcharToChar(temp,filePath.GetPointer());
  93 //               WcharToChar(temp,this->GetName().GetPointer());
  94                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,size,temp);
  95                  //callstack
  96
  97 //               if(E_SUCCESS != ret || blockresult == 2) {
  98 //                       log.length += sprintf(log.data + log.length,
  99 //                                       "`,\ncallstack_start`,`,callstack_end");
 100 //               } else{
 101                          log.length += sprintf(log.data + log.length,
 102                                          "`,\ncallstack_start`,");
 103                          getBacktraceString(&log, 4096 - log.length - 17);
 104                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 105 //               }
 106
 107                  printLog(&log, MSG_LOG);
 108                  postBlockEnd();
 109         }
 110
 111         return ret;
 112 }
 113
 114 result File::Construct(const Tizen::Base::String& filePath,
 115                 const Tizen::Base::String& openMode) {
 116         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 117                         const Tizen::Base::String& openMode);
 118         static methodType Constructp = 0;
 119         result ret;
 120         probeInfo_t     probeInfo;
 121         log_t   log;
 122         int blockresult;
 123         bool bfiltering = true;
 124         char temp[50];
 125         FileAttributes attr;
 126         long long size = 0L;
 127
 128         if(!Constructp) {
 129                 probeBlockStart();
 130                 void *tmpPtr = dlsym(RTLD_NEXT,
 131                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringES5_");
 132
 133                 if(tmpPtr == NULL || dlerror() != NULL) {
 134                         perror("dlsym failed : Tizen::Io::File::Construct");
 135                         exit(0);
 136                 }
 137
 138                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 139                 probeBlockEnd();
 140         }
 141
 142         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 143                 setProbePoint(&probeInfo);
 144                 preBlockEnd();
 145         }
 146
 147         ret = (this->*Constructp)(filePath, openMode);
 148
 149         if(postBlockBegin(blockresult)) {
 150                  log.type = 0;
 151                  log.length = 0;
 152                  log.data[0] = '\0';
 153                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 154                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 155                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 156                  //Input,ret
 157                  WcharToChar(temp,filePath.GetPointer());
 158                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 159                  WcharToChar(temp,openMode.GetPointer());
 160                  log.length += sprintf(log.data + log.length,", %s`,%ld",temp,ret);
 161                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 162                  if(ret == E_SUCCESS && E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 163                         size = attr.GetFileSize();
 164                  WcharToChar(temp,filePath.GetPointer());
 165 //               WcharToChar(temp,this->GetName().GetPointer());
 166                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,size,temp);
 167                  //callstack
 168
 169 //               if(E_SUCCESS != ret || blockresult == 2) {
 170 //                       log.length += sprintf(log.data + log.length,
 171 //                                       "`,\ncallstack_start`,`,callstack_end");
 172 //               } else{
 173                          log.length += sprintf(log.data + log.length,
 174                                          "`,\ncallstack_start`,");
 175                          getBacktraceString(&log, 4096 - log.length - 17);
 176                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 177 //               }
 178
 179                  printLog(&log, MSG_LOG);
 180                  postBlockEnd();
 181         }
 182
 183         return ret;
 184 }
 185
 186 result File::Construct(const Tizen::Base::String& filePath,
 187                 const char *pOpenMode) {
 188         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 189                         const char *pOpenMode);
 190         static methodType Constructp = 0;
 191         result ret;
 192         probeInfo_t     probeInfo;
 193         log_t   log;
 194         int blockresult;
 195         bool bfiltering = true;
 196         char temp[50];
 197         FileAttributes attr;
 198         long long size = 0L;
 199
 200         if(!Constructp) {
 201                 probeBlockStart();
 202                 void *tmpPtr = dlsym(RTLD_NEXT,
 203                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringEPKc");
 204
 205                 if(tmpPtr == NULL || dlerror() != NULL) {
 206                         perror("dlsym failed : Tizen::Io::File::Construct");
 207                         exit(0);
 208                 }
 209
 210                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 211                 probeBlockEnd();
 212         }
 213
 214         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 215                 setProbePoint(&probeInfo);
 216                 preBlockEnd();
 217         }
 218
 219         ret = (this->*Constructp)(filePath, pOpenMode);
 220
 221         if(postBlockBegin(blockresult)) {
 222                  log.type = 0;
 223                  log.length = 0;
 224                  log.data[0] = '\0';
 225                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 226                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 227                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 228                  //Input,ret
 229                  WcharToChar(temp,filePath.GetPointer());
 230                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 231                  log.length += sprintf(log.data + log.length,", %s`,%ld",pOpenMode,ret);
 232                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 233                  if(ret == E_SUCCESS && E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 234                         size = attr.GetFileSize();
 235                  WcharToChar(temp,filePath.GetPointer());
 236 //               WcharToChar(temp,this->GetName().GetPointer());
 237                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,size,temp);
 238                  //callstack
 239
 240 //               if(E_SUCCESS != ret || blockresult == 2) {
 241 //                       log.length += sprintf(log.data + log.length,
 242 //                                       "`,\ncallstack_start`,`,callstack_end");
 243 //               } else{
 244                          log.length += sprintf(log.data + log.length,
 245                                          "`,\ncallstack_start`,");
 246                          getBacktraceString(&log, 4096 - log.length - 17);
 247                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 248 //               }
 249
 250                  printLog(&log, MSG_LOG);
 251                  postBlockEnd();
 252         }
 253
 254         return ret;
 255 }
 256
 257 result File::Construct(const Tizen::Base::String& filePath,
 258                 const char *pOpenMode,
 259                 const Tizen::Base::ByteBuffer& secretKey) {
 260         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 261                         const char *pOpenMode,
 262                         const Tizen::Base::ByteBuffer& secretKey);
 263         static methodType Constructp = 0;
 264         result ret;
 265         probeInfo_t probeInfo;
 266         log_t   log;
 267         int blockresult;
 268         bool bfiltering = true;
 269         char temp[50];
 270         FileAttributes attr;
 271         long long size = 0L;
 272
 273         if(!Constructp) {
 274                 probeBlockStart();
 275
 276                 void *tmpPtr = dlsym(RTLD_NEXT,
 277                                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringEPKcRKNS2_10ByteBufferE");
 278
 279                 if(tmpPtr == NULL || dlerror() != NULL) {
 280                         perror("dlsym failed : Tizen::Io::File::Construct");
 281                         exit(0);
 282                 }
 283
 284                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 285                 probeBlockEnd();
 286         }
 287
 288         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 289                 setProbePoint(&probeInfo);
 290                 preBlockEnd();
 291         }
 292
 293         ret = (this->*Constructp)(filePath, pOpenMode, secretKey);
 294
 295         if(postBlockBegin(blockresult)) {
 296                  log.type = 0;
 297                  log.length = 0;
 298                  log.data[0] = '\0';
 299                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 300                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 301                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 302                  //Input,ret
 303                  WcharToChar(temp,filePath.GetPointer());
 304                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 305                  log.length += sprintf(log.data + log.length,", %s",pOpenMode);
 306                  log.length += sprintf(log.data + log.length,", 0x%x`,%ld",(unsigned int)&secretKey,ret);
 307                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 308                  if(ret == E_SUCCESS && E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 309                         size = attr.GetFileSize();
 310                  WcharToChar(temp,filePath.GetPointer());
 311                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,size,temp);
 312                  //callstack
 313
 314 //               if(E_SUCCESS != ret || blockresult == 2) {
 315 //                       log.length += sprintf(log.data + log.length,
 316 //                                       "`,\ncallstack_start`,`,callstack_end");
 317 //               } else{
 318                          log.length += sprintf(log.data + log.length,
 319                                          "`,\ncallstack_start`,");
 320                          getBacktraceString(&log, 4096 - log.length - 17);
 321                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 322 //               }
 323
 324                  printLog(&log, MSG_LOG);
 325                  postBlockEnd();
 326         }
 327
 328         return ret;
 329 }
 330
 331 result File::Flush(void) {
 332         typedef result (File::*methodType)(void);
 333         static methodType Flushp = 0;
 334         result ret;
 335         probeInfo_t     probeInfo;
 336         log_t   log;
 337         int blockresult;
 338         bool bfiltering = true;
 339         char temp[50];
 340         FileAttributes attr;
 341         long long size = 0L;
 342
 343         if (!Flushp) {
 344                 probeBlockStart();
 345
 346                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5FlushEv");
 347
 348                 if (tmpPtr == NULL || dlerror() != NULL) {
 349                         perror("dlsym failed : Tizen::Io::File::Flush");
 350                         exit(0);
 351                 }
 352
 353                 memcpy(&Flushp, &tmpPtr, sizeof(tmpPtr));
 354                 probeBlockEnd();
 355         }
 356
 357         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 358                 setProbePoint(&probeInfo);
 359                 preBlockEnd();
 360         }
 361
 362         ret = (this->*Flushp)();
 363
 364         if(postBlockBegin(blockresult)) {
 365                  log.type = 0;
 366                  log.length = 0;
 367                  log.data[0] = '\0';
 368                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 369                  LC_RESOURCE, probeInfo.eventIndex, "File::Flush",
 370                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 371                  //Input,ret
 372                  log.length += sprintf(log.data + log.length,"`,`,%ld",ret);
 373                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 374                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 375                         size = attr.GetFileSize();
 376                  WcharToChar(temp,this->GetName().GetPointer());
 377                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OTHER,size,temp);
 378                  //callstack
 379
 380                  //              if(E_SUCCESS != ret || blockresult == 2) {
 381 //                       log.length += sprintf(log.data + log.length,
 382 //                                       "`,\ncallstack_start`,`,callstack_end");
 383 //               } else{
 384                          log.length += sprintf(log.data + log.length,
 385                                          "`,\ncallstack_start`,");
 386                          getBacktraceString(&log, 4096 - log.length - 17);
 387                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 388 //               }
 389
 390                  printLog(&log, MSG_LOG);
 391                  postBlockEnd();
 392         }
 393
 394         return ret;
 395 }
 396
 397 Tizen::Base::String File::GetName(void) const{
 398         typedef Tizen::Base::String (File::*methodType)(void) const;
 399         static methodType GetNamep = 0;
 400         Tizen::Base::String ret;
 401         probeInfo_t     probeInfo;
 402         log_t   log;
 403         int blockresult;
 404         bool bfiltering = true;
 405         char temp[50];
 406         FileAttributes attr;
 407         long long size = 0L;
 408
 409         if (!GetNamep) {
 410                 probeBlockStart();
 411
 412                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZNK5Tizen2Io4File7GetNameEv");
 413
 414                 if (tmpPtr == NULL || dlerror() != NULL) {
 415                         perror("dlsym failed : Tizen::Io::File::GetName");
 416                         exit(0);
 417                 }
 418
 419                 memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
 420                 probeBlockEnd();
 421         }
 422
 423         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 424                 setProbePoint(&probeInfo);
 425                 preBlockEnd();
 426         }
 427
 428         ret = (this->*GetNamep)();
 429         result res = GetLastResult();
 430
 431         if(postBlockBegin(blockresult)) {
 432                  log.type = 0;
 433                  log.length = 0;
 434                  log.data[0] = '\0';
 435                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 436                  LC_RESOURCE, probeInfo.eventIndex, "File::GetName",
 437                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 438                  //Input,ret
 439                  WcharToChar(temp,ret.GetPointer());
 440                  log.length += sprintf(log.data + log.length,"`,`,%s",temp);
 441                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 442                  if(E_SUCCESS == File::GetAttributes(ret,attr))
 443                          size = attr.GetFileSize();
 444                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",res,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OTHER,size,temp);
 445                  //callstack
 446
 447 //               if(E_SUCCESS != res || blockresult == 2) {
 448 //                       log.length += sprintf(log.data + log.length,
 449 //                                       "`,\ncallstack_start`,`,callstack_end");
 450 //               } else{
 451                          log.length += sprintf(log.data + log.length,
 452                                          "`,\ncallstack_start`,");
 453                          getBacktraceString(&log, 4096 - log.length - 17);
 454                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 455 //               }
 456
 457                  printLog(&log, MSG_LOG);
 458                  postBlockEnd();
 459         }
 460
 461         return ret;
 462 }
 463
 464 result File::Read(Tizen::Base::String& buffer) {
 465         typedef result (File::*methodType)(Tizen::Base::String & buffer);
 466         static methodType Readp = 0;
 467         result ret;
 468         probeInfo_t     probeInfo;
 469         log_t   log;
 470         int blockresult;
 471         bool bfiltering = true;
 472         char temp[50];
 473         int nRead = 0;
 474         FileAttributes attr;
 475         long long size = 0L;
 476
 477         if (!Readp) {
 478                 probeBlockStart();
 479
 480                 void *tmpPtr = dlsym(RTLD_NEXT,
 481                                 "_ZN5Tizen2Io4File4ReadERNS_4Base6StringE");
 482
 483                 if (tmpPtr == NULL || dlerror() != NULL) {
 484                         perror("dlsym failed : Tizen::Io::File::Read");
 485                         exit(0);
 486                 }
 487
 488                 memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
 489                 probeBlockEnd();
 490         }
 491
 492         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 493                 setProbePoint(&probeInfo);
 494                 preBlockEnd();
 495         }
 496
 497         ret = (this->*Readp)(buffer);
 498
 499         if(postBlockBegin(blockresult)) {
 500                  log.type = 0;
 501                  log.length = 0;
 502                  log.data[0] = '\0';
 503                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 504                  LC_RESOURCE, probeInfo.eventIndex, "File::Read",
 505                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 506                  //Input,ret
 507                  log.length += sprintf(log.data + log.length,"`,0x%x`,%ld",(unsigned int)&buffer,ret);
 508                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 509                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 510                         size = attr.GetFileSize();
 511                  WcharToChar(temp,this->GetName().GetPointer());
 512                  nRead = buffer.GetLength();
 513                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,%d`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,nRead,(unsigned int)this,FD_FILE,FD_API_READ,size,temp);
 514                  //callstack
 515
 516                  //              if(E_SUCCESS != ret || blockresult == 2) {
 517 //                       log.length += sprintf(log.data + log.length,
 518 //                                       "`,\ncallstack_start`,`,callstack_end");
 519 //               } else{
 520                          log.length += sprintf(log.data + log.length,
 521                                          "`,\ncallstack_start`,");
 522                          getBacktraceString(&log, 4096 - log.length - 17);
 523                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 524 //               }
 525
 526                  printLog(&log, MSG_LOG);
 527                  postBlockEnd();
 528         }
 529
 530         return ret;
 531 }
 532
 533 result File::Read(Tizen::Base::ByteBuffer& buffer) {
 534         typedef result (File::*methodType)(Tizen::Base::ByteBuffer & buffer);
 535         static methodType Readp = 0;
 536         result ret;
 537         probeInfo_t     probeInfo;
 538         log_t   log;
 539         int blockresult;
 540         bool bfiltering = true;
 541         char temp[50];
 542         int nRead = 0;
 543         FileAttributes attr;
 544         long long size = 0L;
 545
 546         if (!Readp) {
 547                 probeBlockStart();
 548
 549                 void *tmpPtr = dlsym(RTLD_NEXT,
 550                                 "_ZN5Tizen2Io4File4ReadERNS_4Base10ByteBufferE");
 551
 552                 if (tmpPtr == NULL || dlerror() != NULL) {
 553                         perror("dlsym failed : Tizen::Io::File::Read");
 554                         exit(0);
 555                 }
 556
 557                 memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
 558                 probeBlockEnd();
 559         }
 560
 561         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 562                 setProbePoint(&probeInfo);
 563                 preBlockEnd();
 564         }
 565
 566         ret = (this->*Readp)(buffer);
 567
 568         if(postBlockBegin(blockresult)) {
 569                  log.type = 0;
 570                  log.length = 0;
 571                  log.data[0] = '\0';
 572                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 573                  LC_RESOURCE, probeInfo.eventIndex, "File::Read",
 574                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 575                  //Input,ret
 576                  log.length += sprintf(log.data + log.length,"`,0x%x`,%ld",(unsigned int)&buffer,ret);
 577                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 578                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 579                         size = attr.GetFileSize();
 580                  WcharToChar(temp,this->GetName().GetPointer());
 581                  buffer.GetInt(nRead);
 582                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,%d`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,nRead,(unsigned int)this,FD_FILE,FD_API_READ,size,temp);
 583                  //callstack
 584
 585                  //              if(E_SUCCESS != ret || blockresult == 2) {
 586 //                       log.length += sprintf(log.data + log.length,
 587 //                                       "`,\ncallstack_start`,`,callstack_end");
 588 //               } else{
 589                          log.length += sprintf(log.data + log.length,
 590                                          "`,\ncallstack_start`,");
 591                          getBacktraceString(&log, 4096 - log.length - 17);
 592                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 593 //               }
 594
 595                  printLog(&log, MSG_LOG);
 596                  postBlockEnd();
 597         }
 598
 599         return ret;
 600 }
 601
 602 int File::Read(void *buffer, int length) {
 603         typedef int (File::*methodType)(void *buffer, int length);
 604         static methodType Readp = 0;
 605         int ret;
 606         probeInfo_t     probeInfo;
 607         log_t   log;
 608         int blockresult;
 609         bool bfiltering = true;
 610         char temp[50];
 611         int nRead = 0;
 612         FileAttributes attr;
 613         long long size = 0L;
 614
 615         if (!Readp) {
 616                 probeBlockStart();
 617
 618                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File4ReadEPvi");
 619
 620                 if (tmpPtr == NULL || dlerror() != NULL) {
 621                         perror("dlsym failed : Tizen::Io::File::Read");
 622                         exit(0);
 623                 }
 624
 625                 memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
 626                 probeBlockEnd();
 627         }
 628
 629         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 630                 setProbePoint(&probeInfo);
 631                 nRead = Tell();
 632                 preBlockEnd();
 633         }
 634
 635         ret = (this->*Readp)(buffer, length);
 636         result res = GetLastResult();
 637
 638         if(postBlockBegin(blockresult)) {
 639                  log.type = 0;
 640                  log.length = 0;
 641                  log.data[0] = '\0';
 642                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 643                  LC_RESOURCE, probeInfo.eventIndex, "File::Read",
 644                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 645                  //Input,ret
 646                  log.length += sprintf(log.data + log.length,"`,0x%x, %d`,%d",(unsigned int)buffer,length,ret);
 647                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 648                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 649                         size = attr.GetFileSize();
 650                  WcharToChar(temp,this->GetName().GetPointer());
 651                  nRead = Tell() - nRead;
 652                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,%d`,0x%x`,%d`,%d`,%lld`,%s",res,blockresult,(unsigned int)CALLER_ADDRESS,nRead,(unsigned int)this,FD_FILE,FD_API_READ,size,temp);
 653                  //callstack
 654
 655                  //              if(E_SUCCESS != ret || blockresult == 2) {
 656 //                       log.length += sprintf(log.data + log.length,
 657 //                                       "`,\ncallstack_start`,`,callstack_end");
 658 //               } else{
 659                          log.length += sprintf(log.data + log.length,
 660                                          "`,\ncallstack_start`,");
 661                          getBacktraceString(&log, 4096 - log.length - 17);
 662                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 663 //               }
 664
 665                  printLog(&log, MSG_LOG);
 666                  postBlockEnd();
 667         }
 668
 669         return ret;
 670 }
 671
 672 result File::Seek(FileSeekPosition position, long offset) {
 673         typedef result (File::*methodType)(FileSeekPosition position, long offset);
 674         static methodType Seekp = 0;
 675         result ret;
 676         probeInfo_t     probeInfo;
 677         log_t   log;
 678         int blockresult;
 679         bool bfiltering = true;
 680         char temp[50];
 681         FileAttributes attr;
 682         long long size = 0L;
 683
 684         if (!Seekp) {
 685                 probeBlockStart();
 686
 687                 void *tmpPtr = dlsym(RTLD_NEXT,
 688                                 "_ZN5Tizen2Io4File4SeekENS0_16FileSeekPositionEl");
 689
 690                 if (tmpPtr == NULL || dlerror() != NULL) {
 691                         perror("dlsym failed : Tizen::Io::File::Seek");
 692                         exit(0);
 693                 }
 694
 695                 memcpy(&Seekp, &tmpPtr, sizeof(tmpPtr));
 696
 697                 probeBlockEnd();
 698         }
 699
 700         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 701                 setProbePoint(&probeInfo);
 702                 preBlockEnd();
 703         }
 704
 705         ret = (this->*Seekp)(position, offset);
 706
 707         if(postBlockBegin(blockresult)) {
 708                  log.type = 0;
 709                  log.length = 0;
 710                  log.data[0] = '\0';
 711                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 712                  LC_RESOURCE, probeInfo.eventIndex, "File::Seek",
 713                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 714                  //Input,ret
 715                  if(FILESEEKPOSITION_BEGIN == position)
 716                          log.length += sprintf(log.data + log.length,"`,FILESEEKPOSITION_BEGIN");
 717                  else if(FILESEEKPOSITION_CURRENT == position)
 718                          log.length += sprintf(log.data + log.length,"`,FILESEEKPOSITION_CURRENT");
 719                  else if(FILESEEKPOSITION_END == position)
 720                          log.length += sprintf(log.data + log.length,"`,FILESEEKPOSITION_END");
 721                  else
 722                          log.length += sprintf(log.data + log.length,"`,%d",position);
 723                  log.length += sprintf(log.data + log.length,", %ld`,%ld",offset,ret);
 724                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 725                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 726                         size = attr.GetFileSize();
 727                  WcharToChar(temp,this->GetName().GetPointer());
 728                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OTHER,size,temp);
 729                  //callstack
 730
 731                  //              if(E_SUCCESS != ret || blockresult == 2) {
 732 //                       log.length += sprintf(log.data + log.length,
 733 //                                       "`,\ncallstack_start`,`,callstack_end");
 734 //               } else{
 735                          log.length += sprintf(log.data + log.length,
 736                                          "`,\ncallstack_start`,");
 737                          getBacktraceString(&log, 4096 - log.length - 17);
 738                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 739 //               }
 740
 741                  printLog(&log, MSG_LOG);
 742                  postBlockEnd();
 743         }
 744
 745         return ret;
 746 }
 747
 748 int File::Tell(void) const {
 749         typedef int (File::*methodType)(void) const;
 750         static methodType Tellp = 0;
 751         int ret;
 752         probeInfo_t     probeInfo;
 753         log_t   log;
 754         int blockresult;
 755         bool bfiltering = true;
 756         char temp[50];
 757         FileAttributes attr;
 758         long long size = 0L;
 759
 760         if (!Tellp) {
 761                 probeBlockStart();
 762
 763                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZNK5Tizen2Io4File4TellEv");
 764
 765                 if (tmpPtr == NULL || dlerror() != NULL) {
 766                         perror("dlsym failed : Tizen::Io::File::Tell");
 767                         exit(0);
 768                 }
 769
 770                 memcpy(&Tellp, &tmpPtr, sizeof(tmpPtr));
 771
 772                 probeBlockEnd();
 773         }
 774
 775         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 776                 setProbePoint(&probeInfo);
 777                 preBlockEnd();
 778         }
 779
 780         ret = (this->*Tellp)();
 781         result res = GetLastResult();
 782
 783         if(postBlockBegin(blockresult)) {
 784                  log.type = 0;
 785                  log.length = 0;
 786                  log.data[0] = '\0';
 787                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 788                  LC_RESOURCE, probeInfo.eventIndex, "File::Tell",
 789                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 790                  //Input,ret
 791                  log.length += sprintf(log.data + log.length,"`,`,%d",ret);
 792                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 793                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 794                         size = attr.GetFileSize();
 795                  WcharToChar(temp,this->GetName().GetPointer());
 796                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",res,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OTHER,size,temp);
 797                  //callstack
 798
 799                  //              if(E_SUCCESS != ret || blockresult == 2) {
 800 //                       log.length += sprintf(log.data + log.length,
 801 //                                       "`,\ncallstack_start`,`,callstack_end");
 802 //               } else{
 803                          log.length += sprintf(log.data + log.length,
 804                                          "`,\ncallstack_start`,");
 805                          getBacktraceString(&log, 4096 - log.length - 17);
 806                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 807 //               }
 808
 809                  printLog(&log, MSG_LOG);
 810                  postBlockEnd();
 811         }
 812
 813         return ret;
 814 }
 815
 816 result File::Truncate(int length) {
 817         typedef result (File::*methodType)(int length);
 818         static methodType Truncatep = 0;
 819         result ret;
 820         probeInfo_t     probeInfo;
 821         log_t   log;
 822         int blockresult;
 823         bool bfiltering = true;
 824         char temp[50];
 825         FileAttributes attr;
 826         long long size = 0L;
 827
 828         if (!Truncatep) {
 829                 probeBlockStart();
 830
 831                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File8TruncateEi");
 832
 833                 if (tmpPtr == NULL || dlerror() != NULL) {
 834                         perror("dlsym failed : Tizen::Io::File::Truncate");
 835                         exit(0);
 836                 }
 837
 838                 memcpy(&Truncatep, &tmpPtr, sizeof(tmpPtr));
 839                 probeBlockEnd();
 840         }
 841
 842         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 843                 setProbePoint(&probeInfo);
 844                 preBlockEnd();
 845         }
 846
 847         ret = (this->*Truncatep)(length);
 848
 849         if(postBlockBegin(blockresult)) {
 850                  log.type = 0;
 851                  log.length = 0;
 852                  log.data[0] = '\0';
 853                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 854                  LC_RESOURCE, probeInfo.eventIndex, "File::Truncate",
 855                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 856                  //Input,ret
 857                  log.length += sprintf(log.data + log.length,"`,%d`,%ld",length,ret);
 858                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 859                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 860                         size = attr.GetFileSize();
 861                  WcharToChar(temp,this->GetName().GetPointer());
 862                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OTHER,size,temp);
 863                  //callstack
 864
 865                  //              if(E_SUCCESS != ret || blockresult == 2) {
 866 //                       log.length += sprintf(log.data + log.length,
 867 //                                       "`,\ncallstack_start`,`,callstack_end");
 868 //               } else{
 869                          log.length += sprintf(log.data + log.length,
 870                                          "`,\ncallstack_start`,");
 871                          getBacktraceString(&log, 4096 - log.length - 17);
 872                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 873 //               }
 874
 875                  printLog(&log, MSG_LOG);
 876                  postBlockEnd();
 877         }
 878
 879         return ret;
 880 }
 881
 882 result File::Write(const void *buffer, int length) {
 883         typedef result (File::*methodType)(const void *buffer, int length);
 884         static methodType Writep = 0;
 885         result ret;
 886         probeInfo_t     probeInfo;
 887         log_t   log;
 888         int blockresult;
 889         bool bfiltering = true;
 890         char temp[50];
 891         int nWritten = 0;
 892         FileAttributes attr;
 893         long long size = 0L;
 894
 895         if (!Writep) {
 896                 probeBlockStart();
 897
 898                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5WriteEPKvi");
 899
 900                 if (tmpPtr == NULL || dlerror() != NULL) {
 901                         perror("dlsym failed : Tizen::Io::File::Write");
 902                         exit(0);
 903                 }
 904
 905                 memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
 906                 probeBlockEnd();
 907         }
 908
 909         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 910                 setProbePoint(&probeInfo);
 911                 nWritten = Tell();
 912                 preBlockEnd();
 913         }
 914
 915         ret = (this->*Writep)(buffer, length);
 916
 917         if(postBlockBegin(blockresult)) {
 918                  log.type = 0;
 919                  log.length = 0;
 920                  log.data[0] = '\0';
 921                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 922                  LC_RESOURCE, probeInfo.eventIndex, "File::Write",
 923                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 924                  //Input,ret
 925                  log.length += sprintf(log.data + log.length,"`,0x%x, %d`,%ld",(unsigned int)buffer,length,ret);
 926                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 927                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 928                          size = attr.GetFileSize();
 929                  WcharToChar(temp,this->GetName().GetPointer());
 930                  nWritten = Tell() - nWritten;
 931                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,%d`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,nWritten,(unsigned int)this,FD_FILE,FD_API_WRITE,size,temp);
 932                  //callstack
 933
 934                  //              if(E_SUCCESS != ret || blockresult == 2) {
 935 //                       log.length += sprintf(log.data + log.length,
 936 //                                       "`,\ncallstack_start`,`,callstack_end");
 937 //               } else{
 938                          log.length += sprintf(log.data + log.length,
 939                                          "`,\ncallstack_start`,");
 940                          getBacktraceString(&log, 4096 - log.length - 17);
 941                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 942 //               }
 943
 944                  printLog(&log, MSG_LOG);
 945                  postBlockEnd();
 946         }
 947
 948         return ret;
 949 }
 950
 951 result File::Write(const Tizen::Base::ByteBuffer& buffer) {
 952         typedef result (File::*methodType)(const Tizen::Base::ByteBuffer& buffer);
 953         static methodType Writep = 0;
 954         result ret;
 955         probeInfo_t     probeInfo;
 956         log_t   log;
 957         int blockresult;
 958         bool bfiltering = true;
 959         char temp[50];
 960         int nWritten = 0;
 961         FileAttributes attr;
 962         long long size = 0L;
 963
 964         if (!Writep) {
 965                 probeBlockStart();
 966
 967                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5WriteERKNS_4Base10ByteBufferE");
 968
 969                 if (tmpPtr == NULL || dlerror() != NULL) {
 970                         perror("dlsym failed : Tizen::Io::File::Write");
 971                         exit(0);
 972                 }
 973
 974                 memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
 975                 probeBlockEnd();
 976         }
 977
 978         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 979                 setProbePoint(&probeInfo);
 980                 nWritten = Tell();
 981                 preBlockEnd();
 982         }
 983
 984         ret = (this->*Writep)(buffer);
 985
 986         if(postBlockBegin(blockresult)) {
 987                  log.type = 0;
 988                  log.length = 0;
 989                  log.data[0] = '\0';
 990                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 991                  LC_RESOURCE, probeInfo.eventIndex, "File::Write",
 992                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 993                  //Input,ret
 994                  log.length += sprintf(log.data + log.length,"`,0x%x`,%ld",(unsigned int)&buffer,ret);
 995                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 996                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
 997                         size = attr.GetFileSize();
 998                  WcharToChar(temp,this->GetName().GetPointer());
 999                  nWritten = Tell() - nWritten;
1000                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,%d`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,nWritten,(unsigned int)this,FD_FILE,FD_API_WRITE,size,temp);
1001                  //callstack
1002
1003                  //              if(E_SUCCESS != ret || blockresult == 2) {
1004 //                       log.length += sprintf(log.data + log.length,
1005 //                                       "`,\ncallstack_start`,`,callstack_end");
1006 //               } else{
1007                          log.length += sprintf(log.data + log.length,
1008                                          "`,\ncallstack_start`,");
1009                          getBacktraceString(&log, 4096 - log.length - 17);
1010                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1011 //               }
1012
1013                  printLog(&log, MSG_LOG);
1014                  postBlockEnd();
1015         }
1016
1017         return ret;
1018 }
1019
1020 result File::Write(const Tizen::Base::String& buffer) {
1021         typedef result (File::*methodType)(const Tizen::Base::String& buffer);
1022         static methodType Writep = 0;
1023         result ret;
1024         probeInfo_t     probeInfo;
1025         log_t   log;
1026         int blockresult;
1027         bool bfiltering = true;
1028         char temp[50];
1029         int nWritten = 0;
1030         FileAttributes attr;
1031         long long size = 0L;
1032
1033         if (!Writep) {
1034                 probeBlockStart();
1035
1036                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5WriteERKNS_4Base6StringE");
1037
1038                 if (tmpPtr == NULL || dlerror() != NULL) {
1039                         perror("dlsym failed : Tizen::Io::File::Write");
1040                         exit(0);
1041                 }
1042
1043                 memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
1044                 probeBlockEnd();
1045         }
1046
1047         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1048                 setProbePoint(&probeInfo);
1049                 nWritten = Tell();
1050                 preBlockEnd();
1051         }
1052
1053         ret = (this->*Writep)(buffer);
1054
1055         if(postBlockBegin(blockresult)) {
1056                  log.type = 0;
1057                  log.length = 0;
1058                  log.data[0] = '\0';
1059                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1060                  LC_RESOURCE, probeInfo.eventIndex, "File::Write",
1061                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1062                  //Input,ret
1063                  WcharToChar(temp,buffer.GetPointer());
1064                  log.length += sprintf(log.data + log.length,"`,%s`,%ld",temp,ret);
1065                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1066                  if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
1067                         size = attr.GetFileSize();
1068                  WcharToChar(temp,this->GetName().GetPointer());
1069                  nWritten = Tell() - nWritten;
1070                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,%d`,0x%x`,%d`,%d`,%lld`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,nWritten,(unsigned int)this,FD_FILE,FD_API_WRITE,size,temp);
1071                  //callstack
1072
1073                  //              if(E_SUCCESS != ret || blockresult == 2) {
1074 //                       log.length += sprintf(log.data + log.length,
1075 //                                       "`,\ncallstack_start`,`,callstack_end");
1076 //               } else{
1077                          log.length += sprintf(log.data + log.length,
1078                                          "`,\ncallstack_start`,");
1079                          getBacktraceString(&log, 4096 - log.length - 17);
1080                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1081 //               }
1082
1083                  printLog(&log, MSG_LOG);
1084                  postBlockEnd();
1085         }
1086         return ret;
1087 }
1088
1089 File::~File(void) {
1090         typedef void (File::*methodType)();
1091         static methodType FileDp = 0;
1092         probeInfo_t     probeInfo;
1093         log_t   log;
1094         int blockresult;
1095         bool bfiltering = true;
1096         void *tmpPtr;
1097 //      FileAttributes attr;
1098         long long size = 0L;
1099
1100         if (!FileDp) {
1101                 probeBlockStart();
1102
1103                 tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4FileD1Ev");
1104
1105                 if (tmpPtr == NULL || dlerror() != NULL) {
1106                         perror("dlsym failed : Tizen::Io::File::~File");
1107                         exit(0);
1108                 }
1109
1110                 memcpy(&FileDp, &tmpPtr, sizeof(tmpPtr));
1111                 probeBlockEnd();
1112         }
1113
1114         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1115                 setProbePoint(&probeInfo);
1116                 // error occur if File class was failed to contruct
1117 //              if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
1118 //                      size = attr.GetFileSize();
1119                 preBlockEnd();
1120         }
1121
1122         (this->*FileDp)();
1123
1124         if(postBlockBegin(blockresult)) {
1125                 log.type = 0;
1126                 log.length = 0;
1127                 log.data[0] = '\0';
1128                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1129                                 LC_RESOURCE, probeInfo.eventIndex, "File::~File",
1130                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1131                 //Input,ret
1132                 log.length += sprintf(log.data + log.length,"`,`,");
1133                 //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1134                 log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_CLOSE,size);
1135                 //callstack
1136
1137 //              if(E_SUCCESS != ret || blockresult == 2) {
1138 //                      log.length += sprintf(log.data + log.length,
1139 //                                      "`,\ncallstack_start`,`,callstack_end");
1140 //              } else{
1141                         log.length += sprintf(log.data + log.length,
1142                                         "`,\ncallstack_start`,");
1143                         getBacktraceString(&log, 4096 - log.length - 17);
1144                         log.length += sprintf(log.data + log.length, "`,callstack_end");
1145 //              }
1146
1147                 printLog(&log, MSG_LOG);
1148                 postBlockEnd();
1149         }
1150 }
1151
1152
1153 // static methods
1154 //static result File::ConvertToSecureFile(const Tizen::Base::String &plainFilePath,
1155 //              const Tizen::Base::String &secureFilePath) {
1156 //      typedef result (File::*methodType)(
1157 //                      const Tizen::Base::String &plainFilePath,
1158 //                      const Tizen::Base::String &secureFilePath);
1159 //      static methodType ConvertToSecureFilep = 0;
1160 //
1161 //}
1162 //static result File::ConvertToSecureFile(const Tizen::Base::String &plainFilePath,
1163 //              const Tizen::Base::String &secureFilePath,
1164 //              const Tizen::Base::ByteBuffer& key) {
1165 //      typedef result (File::*methodType)(
1166 //                      const Tizen::Base::String &plainFilePath,
1167 //                      const Tizen::Base::String &secureFilePath,
1168 //                      const Tizen::Base::ByteBuffer& key);
1169 //      static methodType ConvertToSecureFilep = 0;
1170 //
1171 //}
1172 //static result File::Copy(const Tizen::Base::String& srcFilePath,
1173 //              const Tizen::Base::String& destFilePath, bool failIfExist) {
1174 //      typedef result (File::*methodType)(const Tizen::Base::String& srcFilePath,
1175 //                      const Tizen::Base::String& destFilePath, bool failIfExist);
1176 //      static methodType Copyp = 0;
1177 //
1178 //}
1179 //static result File::GetAttributes(const Tizen::Base::String& filePath,
1180 //              FileAttributes& attribute) {
1181 //      typedef result (File::*methodType)(const Tizen::Base::String& filePath,
1182 //                      FileAttributes& attribute);
1183 //      static methodType GetAttributesp = 0;
1184 //
1185 //}
1186 //static const Tizen::Base::String File::GetFileExtension(
1187 //              const Tizen::Base::String& filePath) {
1188 //      typedef const Tizen::Base::String (File::*methodType)(
1189 //                      const Tizen::Base::String& filePath);
1190 //      static methodType GetFileExtensionp = 0;
1191 //
1192 //}
1193 //const Tizen::Base::String File::GetFileName(
1194 //              const Tizen::Base::String& filePath) {
1195 //      typedef const Tizen::Base::String (File::*methodType)(
1196 //                      const Tizen::Base::String& filePath);
1197 //      static methodType GetFileNamep = 0;
1198 //      Tizen::Base::String ret;
1199 //
1200 //      if (!GetFileNamep) {
1201 //                      probeBlockStart();
1202 //                      void *tmpPtr = dlsym(RTLD_NEXT,
1203 //                                      "_ZN5Tizen2Io4File11GetFileNameERKNS_4Base6StringE");
1204 //
1205 //                      if (tmpPtr == NULL || dlerror() != NULL) {
1206 //                              perror("dlsym failed : Tizen::Io::File::GetFileName");
1207 //                              exit(0);
1208 //                      }
1209 //
1210 //                      memcpy(&GetFileNamep, &tmpPtr, sizeof(tmpPtr));
1211 //                      probeBlockEnd();
1212 //              }
1213 //      ret = (File::(*GetFileNamep))(filePath);
1214 //
1215 //return ret;
1216 //}
1217 //static bool File::IsEncrypted(const Tizen::Base::String &filePath) {
1218 //      typedef bool (File::*methodType)(const Tizen::Base::String &filePath);
1219 //      static methodType IsEncryptedp = 0;
1220 //
1221 //}
1222 //static bool File::IsFileExist(const Tizen::Base::String& filePath) {
1223 //      typedef bool (File::*methodType)(const Tizen::Base::String& filePath);
1224 //      static methodType IsFileExistp = 0;
1225 //
1226 //}
1227 //static result File::Move(const Tizen::Base::String& oldFilePath,
1228 //              const Tizen::Base::String& newFilePath) {
1229 //      typedef result (File::*methodType)(const Tizen::Base::String& oldFilePath,
1230 //                      const Tizen::Base::String& newFilePath);
1231 //      static methodType Movep = 0;
1232 //
1233 //}
1234 //static result File::Remove(const Tizen::Base::String& filePath) {
1235 //      typedef result (File::*methodType)(const Tizen::Base::String& filePath);
1236 //      static methodType Removep = 0;
1237 //
1238 //}
1239
1240 }
1241 }