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;
  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                  File::GetAttributes(this->GetName(),attr);
  91                  WcharToChar(temp,filePath.GetPointer());
  92                  size = attr.GetFileSize();
  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 /* deprecated apis
 115 result File::Construct(const Tizen::Base::String& filePath,
 116                 const Tizen::Base::String& openMode, bool secureMode,
 117                 bool createParentDirectories) {
 118         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 119                         const Tizen::Base::String& openMode, bool secureMode,
 120                         bool createParentDirectories);
 121         static methodType Constructp = 0;
 122         result ret;
 123         probeInfo_t     probeInfo;
 124         log_t   log;
 125         int blockresult;
 126         bool bfiltering = true;
 127         char temp[50];
 128         //FileAttributes attr;
 129
 130         if (!Constructp) {
 131                 probeBlockStart();
 132
 133                 void *tmpPtr = dlsym(RTLD_NEXT,
 134                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringES5_bb");
 135
 136                 if (tmpPtr == NULL || dlerror() != NULL) {
 137                         perror("dlsym failed : Tizen::Io::File::Construct");
 138                         exit(0);
 139                 }
 140
 141                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 142                 probeBlockEnd();
 143         }
 144
 145         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 146                 setProbePoint(&probeInfo);
 147                 preBlockEnd();
 148         }
 149
 150         ret = (this->*Constructp)(filePath, openMode, secureMode,
 151                         createParentDirectories);
 152
 153         if(postBlockBegin(blockresult)) {
 154                  log.type = 0;
 155                  log.length = 0;
 156                  log.data[0] = '\0';
 157                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 158                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 159                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 160                  //Input,ret
 161                  WcharToChar(temp,filePath.GetPointer());
 162                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 163                  WcharToChar(temp,openMode.GetPointer());
 164                  log.length += sprintf(log.data + log.length,", %s",temp);
 165                  log.length += sprintf(log.data + log.length,", %s,%s`,%ld",(secureMode == 0 ? "false" : "true"),(createParentDirectories == 0 ? "false" : "true"),ret);
 166                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 167                  //File::GetAttributes(this->GetName(),attr);
 168                  WcharToChar(temp,filePath.GetPointer());
 169                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,?`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,temp);
 170                  //callstack
 171
 172                  //              if(E_SUCCESS != ret || blockresult == 2) {
 173 //                       log.length += sprintf(log.data + log.length,
 174 //                                       "`,\ncallstack_start`,`,callstack_end");
 175 //               } else{
 176                          log.length += sprintf(log.data + log.length,
 177                                          "`,\ncallstack_start`,");
 178                          getBacktraceString(&log, 4096 - log.length - 17);
 179                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 180 //               }
 181
 182                  printLog(&log, MSG_LOG);
 183                  postBlockEnd();
 184         }
 185
 186         return ret;
 187 }
 188
 189 result File::Construct(const Tizen::Base::String& filePath,
 190                 const Tizen::Base::String& openMode, bool secureMode,
 191                 const Tizen::Base::ByteBuffer& key, bool createParentDirectories) {
 192         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 193                         const Tizen::Base::String& openMode, bool secureMode,
 194                         const Tizen::Base::ByteBuffer& key, bool createParentDirectories);
 195         static methodType Constructp = 0;
 196         result ret;
 197         probeInfo_t     probeInfo;
 198         log_t   log;
 199         int blockresult;
 200         bool bfiltering = true;
 201         char temp[50];
 202         //FileAttributes attr;
 203
 204         if (!Constructp) {
 205                 probeBlockStart();
 206
 207                 void *tmpPtr = dlsym(RTLD_NEXT,
 208                                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringES5_bRKNS2_10ByteBufferEb");
 209
 210                 if (tmpPtr == NULL || dlerror() != NULL) {
 211                         perror("dlsym failed : Tizen::Io::File::Construct");
 212                         exit(0);
 213                 }
 214
 215                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 216                 probeBlockEnd();
 217         }
 218
 219         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 220                 setProbePoint(&probeInfo);
 221                 preBlockEnd();
 222         }
 223
 224         ret = (this->*Constructp)(filePath, openMode, secureMode, key,
 225                         createParentDirectories);
 226
 227         if(postBlockBegin(blockresult)) {
 228                  log.type = 0;
 229                  log.length = 0;
 230                  log.data[0] = '\0';
 231                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 232                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 233                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 234                  //Input,ret
 235                  WcharToChar(temp,filePath.GetPointer());
 236                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 237                  WcharToChar(temp,openMode.GetPointer());
 238                  log.length += sprintf(log.data + log.length,", %s",temp);
 239                  log.length += sprintf(log.data + log.length,", %s,0x%x,%s`,%ld",(secureMode == 0 ? "false" : "true"),(unsigned int)&key,(createParentDirectories == 0 ? "false" : "true"),ret);
 240                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 241                  //File::GetAttributes(this->GetName(),attr);
 242                  WcharToChar(temp,filePath.GetPointer());
 243                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,?`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,temp);
 244                  //callstack
 245
 246                  //              if(E_SUCCESS != ret || blockresult == 2) {
 247 //                       log.length += sprintf(log.data + log.length,
 248 //                                       "`,\ncallstack_start`,`,callstack_end");
 249 //               } else{
 250                          log.length += sprintf(log.data + log.length,
 251                                          "`,\ncallstack_start`,");
 252                          getBacktraceString(&log, 4096 - log.length - 17);
 253                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 254 //               }
 255
 256                  printLog(&log, MSG_LOG);
 257                  postBlockEnd();
 258         }
 259
 260         return ret;
 261 }
 262 */
 263 result File::Construct(const Tizen::Base::String& filePath,
 264                 const Tizen::Base::String& openMode) {
 265         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 266                         const Tizen::Base::String& openMode);
 267         static methodType Constructp = 0;
 268         result ret;
 269         probeInfo_t     probeInfo;
 270         log_t   log;
 271         int blockresult;
 272         bool bfiltering = true;
 273         char temp[50];
 274         FileAttributes attr;
 275         long long size;
 276
 277         if(!Constructp) {
 278                 probeBlockStart();
 279                 void *tmpPtr = dlsym(RTLD_NEXT,
 280                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringES5_");
 281
 282                 if(tmpPtr == NULL || dlerror() != NULL) {
 283                         perror("dlsym failed : Tizen::Io::File::Construct");
 284                         exit(0);
 285                 }
 286
 287                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 288                 probeBlockEnd();
 289         }
 290
 291         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 292                 setProbePoint(&probeInfo);
 293                 preBlockEnd();
 294         }
 295
 296         ret = (this->*Constructp)(filePath, openMode);
 297
 298         if(postBlockBegin(blockresult)) {
 299                  log.type = 0;
 300                  log.length = 0;
 301                  log.data[0] = '\0';
 302                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 303                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 304                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 305                  //Input,ret
 306                  WcharToChar(temp,filePath.GetPointer());
 307                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 308                  WcharToChar(temp,openMode.GetPointer());
 309                  log.length += sprintf(log.data + log.length,", %s`,%ld",temp,ret);
 310                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 311                  File::GetAttributes(this->GetName(),attr);
 312                  WcharToChar(temp,filePath.GetPointer());
 313                  size = attr.GetFileSize();
 314 //               WcharToChar(temp,this->GetName().GetPointer());
 315                  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);
 316                  //callstack
 317
 318 //               if(E_SUCCESS != ret || blockresult == 2) {
 319 //                       log.length += sprintf(log.data + log.length,
 320 //                                       "`,\ncallstack_start`,`,callstack_end");
 321 //               } else{
 322                          log.length += sprintf(log.data + log.length,
 323                                          "`,\ncallstack_start`,");
 324                          getBacktraceString(&log, 4096 - log.length - 17);
 325                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 326 //               }
 327
 328                  printLog(&log, MSG_LOG);
 329                  postBlockEnd();
 330         }
 331
 332         return ret;
 333 }
 334
 335 /* deprecated apis
 336 result File::Construct(const Tizen::Base::String& filePath,
 337                 const Tizen::Base::String& openMode,
 338                 const Tizen::Base::ByteBuffer& secretKey) {
 339         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 340                         const Tizen::Base::String &openMode,
 341                         const Tizen::Base::ByteBuffer& secretKey);
 342         static methodType Constructp = 0;
 343         result ret;
 344         probeInfo_t probeInfo;
 345         log_t   log;
 346         int blockresult;
 347         bool bfiltering = true;
 348         char temp[50];
 349         //FileAttributes attr;
 350
 351         if(!Constructp) {
 352                 probeBlockStart();
 353
 354                 void *tmpPtr = dlsym(RTLD_NEXT,
 355                                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringES5_RKNS2_10ByteBufferE");
 356
 357                 if(tmpPtr == NULL || dlerror() != NULL) {
 358                         perror("dlsym failed : Tizen::Io::File::Construct");
 359                         exit(0);
 360                 }
 361
 362                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 363                 probeBlockEnd();
 364         }
 365
 366         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 367                 setProbePoint(&probeInfo);
 368                 preBlockEnd();
 369         }
 370
 371         ret = (this->*Constructp)(filePath, openMode, secretKey);
 372
 373         if(postBlockBegin(blockresult)) {
 374                  log.type = 0;
 375                  log.length = 0;
 376                  log.data[0] = '\0';
 377                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 378                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 379                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 380                  //Input,ret
 381                  WcharToChar(temp,filePath.GetPointer());
 382                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 383                  WcharToChar(temp,openMode.GetPointer());
 384                  log.length += sprintf(log.data + log.length,", %s",temp);
 385                  log.length += sprintf(log.data + log.length,", 0x%x`,%ld",(unsigned int)&secretKey,ret);
 386                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 387                  //File::GetAttributes(this->GetName(),attr);
 388                  WcharToChar(temp,filePath.GetPointer());
 389                  log.length += sprintf(log.data + log.length,"`,0`,%lu`,%d`,%u`,0`,0x%x`,%d`,%d`,?`,%s",ret,blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_OPEN,temp);
 390                  //callstack
 391
 392 //               if(E_SUCCESS != ret || blockresult == 2) {
 393 //                       log.length += sprintf(log.data + log.length,
 394 //                                       "`,\ncallstack_start`,`,callstack_end");
 395 //               } else{
 396                          log.length += sprintf(log.data + log.length,
 397                                          "`,\ncallstack_start`,");
 398                          getBacktraceString(&log, 4096 - log.length - 17);
 399                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 400 //               }
 401
 402                  printLog(&log, MSG_LOG);
 403                  postBlockEnd();
 404         }
 405
 406         return ret;
 407 }
 408 */
 409 result File::Construct(const Tizen::Base::String& filePath,
 410                 const char *pOpenMode) {
 411         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 412                         const char *pOpenMode);
 413         static methodType Constructp = 0;
 414         result ret;
 415         probeInfo_t     probeInfo;
 416         log_t   log;
 417         int blockresult;
 418         bool bfiltering = true;
 419         char temp[50];
 420         FileAttributes attr;
 421         long long size;
 422
 423         if(!Constructp) {
 424                 probeBlockStart();
 425                 void *tmpPtr = dlsym(RTLD_NEXT,
 426                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringEPKc");
 427
 428                 if(tmpPtr == NULL || dlerror() != NULL) {
 429                         perror("dlsym failed : Tizen::Io::File::Construct");
 430                         exit(0);
 431                 }
 432
 433                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 434                 probeBlockEnd();
 435         }
 436
 437         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 438                 setProbePoint(&probeInfo);
 439                 preBlockEnd();
 440         }
 441
 442         ret = (this->*Constructp)(filePath, pOpenMode);
 443
 444         if(postBlockBegin(blockresult)) {
 445                  log.type = 0;
 446                  log.length = 0;
 447                  log.data[0] = '\0';
 448                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 449                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 450                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 451                  //Input,ret
 452                  WcharToChar(temp,filePath.GetPointer());
 453                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 454                  log.length += sprintf(log.data + log.length,", %s`,%ld",pOpenMode,ret);
 455                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 456                  File::GetAttributes(this->GetName(),attr);
 457                  WcharToChar(temp,filePath.GetPointer());
 458                  size = attr.GetFileSize();
 459 //               WcharToChar(temp,this->GetName().GetPointer());
 460                  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);
 461                  //callstack
 462
 463 //               if(E_SUCCESS != ret || blockresult == 2) {
 464 //                       log.length += sprintf(log.data + log.length,
 465 //                                       "`,\ncallstack_start`,`,callstack_end");
 466 //               } else{
 467                          log.length += sprintf(log.data + log.length,
 468                                          "`,\ncallstack_start`,");
 469                          getBacktraceString(&log, 4096 - log.length - 17);
 470                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 471 //               }
 472
 473                  printLog(&log, MSG_LOG);
 474                  postBlockEnd();
 475         }
 476
 477         return ret;
 478 }
 479
 480 result File::Construct(const Tizen::Base::String& filePath,
 481                 const char *pOpenMode,
 482                 const Tizen::Base::ByteBuffer& secretKey) {
 483         typedef result (File::*methodType)(const Tizen::Base::String& filePath,
 484                         const char *pOpenMode,
 485                         const Tizen::Base::ByteBuffer& secretKey);
 486         static methodType Constructp = 0;
 487         result ret;
 488         probeInfo_t probeInfo;
 489         log_t   log;
 490         int blockresult;
 491         bool bfiltering = true;
 492         char temp[50];
 493         FileAttributes attr;
 494         long long size;
 495
 496         if(!Constructp) {
 497                 probeBlockStart();
 498
 499                 void *tmpPtr = dlsym(RTLD_NEXT,
 500                                                 "_ZN5Tizen2Io4File9ConstructERKNS_4Base6StringEPKcRKNS2_10ByteBufferE");
 501
 502                 if(tmpPtr == NULL || dlerror() != NULL) {
 503                         perror("dlsym failed : Tizen::Io::File::Construct");
 504                         exit(0);
 505                 }
 506
 507                 memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
 508                 probeBlockEnd();
 509         }
 510
 511         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 512                 setProbePoint(&probeInfo);
 513                 preBlockEnd();
 514         }
 515
 516         ret = (this->*Constructp)(filePath, pOpenMode, secretKey);
 517
 518         if(postBlockBegin(blockresult)) {
 519                  log.type = 0;
 520                  log.length = 0;
 521                  log.data[0] = '\0';
 522                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 523                  LC_RESOURCE, probeInfo.eventIndex, "File::Construct",
 524                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 525                  //Input,ret
 526                  WcharToChar(temp,filePath.GetPointer());
 527                  log.length += sprintf(log.data + log.length,"`,%s",temp);
 528                  log.length += sprintf(log.data + log.length,", %s",pOpenMode);
 529                  log.length += sprintf(log.data + log.length,", 0x%x`,%ld",(unsigned int)&secretKey,ret);
 530                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 531                  File::GetAttributes(this->GetName(),attr);
 532                  WcharToChar(temp,filePath.GetPointer());
 533                  size = attr.GetFileSize();
 534                  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);
 535                  //callstack
 536
 537 //               if(E_SUCCESS != ret || blockresult == 2) {
 538 //                       log.length += sprintf(log.data + log.length,
 539 //                                       "`,\ncallstack_start`,`,callstack_end");
 540 //               } else{
 541                          log.length += sprintf(log.data + log.length,
 542                                          "`,\ncallstack_start`,");
 543                          getBacktraceString(&log, 4096 - log.length - 17);
 544                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 545 //               }
 546
 547                  printLog(&log, MSG_LOG);
 548                  postBlockEnd();
 549         }
 550
 551         return ret;
 552 }
 553
 554 result File::Flush(void) {
 555         typedef result (File::*methodType)(void);
 556         static methodType Flushp = 0;
 557         result ret;
 558         probeInfo_t     probeInfo;
 559         log_t   log;
 560         int blockresult;
 561         bool bfiltering = true;
 562         char temp[50];
 563         FileAttributes attr;
 564         long long size;
 565
 566         if (!Flushp) {
 567                 probeBlockStart();
 568
 569                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5FlushEv");
 570
 571                 if (tmpPtr == NULL || dlerror() != NULL) {
 572                         perror("dlsym failed : Tizen::Io::File::Flush");
 573                         exit(0);
 574                 }
 575
 576                 memcpy(&Flushp, &tmpPtr, sizeof(tmpPtr));
 577                 probeBlockEnd();
 578         }
 579
 580         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 581                 setProbePoint(&probeInfo);
 582                 preBlockEnd();
 583         }
 584
 585         ret = (this->*Flushp)();
 586
 587         if(postBlockBegin(blockresult)) {
 588                  log.type = 0;
 589                  log.length = 0;
 590                  log.data[0] = '\0';
 591                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 592                  LC_RESOURCE, probeInfo.eventIndex, "File::Flush",
 593                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 594                  //Input,ret
 595                  log.length += sprintf(log.data + log.length,"`,`,%ld",ret);
 596                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 597                  File::GetAttributes(this->GetName(),attr);
 598                  WcharToChar(temp,this->GetName().GetPointer());
 599                  size = attr.GetFileSize();
 600                  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);
 601                  //callstack
 602
 603                  //              if(E_SUCCESS != ret || blockresult == 2) {
 604 //                       log.length += sprintf(log.data + log.length,
 605 //                                       "`,\ncallstack_start`,`,callstack_end");
 606 //               } else{
 607                          log.length += sprintf(log.data + log.length,
 608                                          "`,\ncallstack_start`,");
 609                          getBacktraceString(&log, 4096 - log.length - 17);
 610                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 611 //               }
 612
 613                  printLog(&log, MSG_LOG);
 614                  postBlockEnd();
 615         }
 616
 617         return ret;
 618 }
 619
 620 Tizen::Base::String File::GetName(void) const{
 621         typedef Tizen::Base::String (File::*methodType)(void) const;
 622         static methodType GetNamep = 0;
 623         Tizen::Base::String ret;
 624         probeInfo_t     probeInfo;
 625         log_t   log;
 626         int blockresult;
 627         bool bfiltering = true;
 628         char temp[50];
 629         FileAttributes attr;
 630         long long size;
 631
 632         if (!GetNamep) {
 633                 probeBlockStart();
 634
 635                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZNK5Tizen2Io4File7GetNameEv");
 636
 637                 if (tmpPtr == NULL || dlerror() != NULL) {
 638                         perror("dlsym failed : Tizen::Io::File::GetName");
 639                         exit(0);
 640                 }
 641
 642                 memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
 643                 probeBlockEnd();
 644         }
 645
 646         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 647                 setProbePoint(&probeInfo);
 648                 preBlockEnd();
 649         }
 650
 651         ret = (this->*GetNamep)();
 652         result res = GetLastResult();
 653
 654         if(postBlockBegin(blockresult)) {
 655                  log.type = 0;
 656                  log.length = 0;
 657                  log.data[0] = '\0';
 658                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 659                  LC_RESOURCE, probeInfo.eventIndex, "File::GetName",
 660                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 661                  //Input,ret
 662                  WcharToChar(temp,ret.GetPointer());
 663                  log.length += sprintf(log.data + log.length,"`,`,%s",temp);
 664                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 665                  File::GetAttributes(this->GetName(),attr);
 666                  size = attr.GetFileSize();
 667                  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);
 668                  //callstack
 669
 670 //               if(E_SUCCESS != res || blockresult == 2) {
 671 //                       log.length += sprintf(log.data + log.length,
 672 //                                       "`,\ncallstack_start`,`,callstack_end");
 673 //               } else{
 674                          log.length += sprintf(log.data + log.length,
 675                                          "`,\ncallstack_start`,");
 676                          getBacktraceString(&log, 4096 - log.length - 17);
 677                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 678 //               }
 679
 680                  printLog(&log, MSG_LOG);
 681                  postBlockEnd();
 682         }
 683
 684         return ret;
 685 }
 686
 687 result File::Read(Tizen::Base::String& buffer) {
 688         typedef result (File::*methodType)(Tizen::Base::String & buffer);
 689         static methodType Readp = 0;
 690         result ret;
 691         probeInfo_t     probeInfo;
 692         log_t   log;
 693         int blockresult;
 694         bool bfiltering = true;
 695         char temp[50];
 696         int nRead = 0;
 697         FileAttributes attr;
 698         long long size;
 699
 700         if (!Readp) {
 701                 probeBlockStart();
 702
 703                 void *tmpPtr = dlsym(RTLD_NEXT,
 704                                 "_ZN5Tizen2Io4File4ReadERNS_4Base6StringE");
 705
 706                 if (tmpPtr == NULL || dlerror() != NULL) {
 707                         perror("dlsym failed : Tizen::Io::File::Read");
 708                         exit(0);
 709                 }
 710
 711                 memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
 712                 probeBlockEnd();
 713         }
 714
 715         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 716                 setProbePoint(&probeInfo);
 717                 preBlockEnd();
 718         }
 719
 720         ret = (this->*Readp)(buffer);
 721
 722         if(postBlockBegin(blockresult)) {
 723                  log.type = 0;
 724                  log.length = 0;
 725                  log.data[0] = '\0';
 726                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 727                  LC_RESOURCE, probeInfo.eventIndex, "File::Read",
 728                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 729                  //Input,ret
 730                  log.length += sprintf(log.data + log.length,"`,0x%x`,%ld",(unsigned int)&buffer,ret);
 731                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 732                  File::GetAttributes(this->GetName(),attr);
 733                  WcharToChar(temp,this->GetName().GetPointer());
 734                  size = attr.GetFileSize();
 735                  nRead = buffer.GetLength();
 736                  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);
 737                  //callstack
 738
 739                  //              if(E_SUCCESS != ret || blockresult == 2) {
 740 //                       log.length += sprintf(log.data + log.length,
 741 //                                       "`,\ncallstack_start`,`,callstack_end");
 742 //               } else{
 743                          log.length += sprintf(log.data + log.length,
 744                                          "`,\ncallstack_start`,");
 745                          getBacktraceString(&log, 4096 - log.length - 17);
 746                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 747 //               }
 748
 749                  printLog(&log, MSG_LOG);
 750                  postBlockEnd();
 751         }
 752
 753         return ret;
 754 }
 755
 756 result File::Read(Tizen::Base::ByteBuffer& buffer) {
 757         typedef result (File::*methodType)(Tizen::Base::ByteBuffer & buffer);
 758         static methodType Readp = 0;
 759         result ret;
 760         probeInfo_t     probeInfo;
 761         log_t   log;
 762         int blockresult;
 763         bool bfiltering = true;
 764         char temp[50];
 765         int nRead = 0;
 766         FileAttributes attr;
 767         long long size;
 768
 769         if (!Readp) {
 770                 probeBlockStart();
 771
 772                 void *tmpPtr = dlsym(RTLD_NEXT,
 773                                 "_ZN5Tizen2Io4File4ReadERNS_4Base10ByteBufferE");
 774
 775                 if (tmpPtr == NULL || dlerror() != NULL) {
 776                         perror("dlsym failed : Tizen::Io::File::Read");
 777                         exit(0);
 778                 }
 779
 780                 memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
 781                 probeBlockEnd();
 782         }
 783
 784         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 785                 setProbePoint(&probeInfo);
 786                 preBlockEnd();
 787         }
 788
 789         ret = (this->*Readp)(buffer);
 790
 791         if(postBlockBegin(blockresult)) {
 792                  log.type = 0;
 793                  log.length = 0;
 794                  log.data[0] = '\0';
 795                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 796                  LC_RESOURCE, probeInfo.eventIndex, "File::Read",
 797                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 798                  //Input,ret
 799                  log.length += sprintf(log.data + log.length,"`,0x%x`,%ld",(unsigned int)&buffer,ret);
 800                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 801                  File::GetAttributes(this->GetName(),attr);
 802                  WcharToChar(temp,this->GetName().GetPointer());
 803                  size = attr.GetFileSize();
 804                  buffer.GetInt(nRead);
 805                  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);
 806                  //callstack
 807
 808                  //              if(E_SUCCESS != ret || blockresult == 2) {
 809 //                       log.length += sprintf(log.data + log.length,
 810 //                                       "`,\ncallstack_start`,`,callstack_end");
 811 //               } else{
 812                          log.length += sprintf(log.data + log.length,
 813                                          "`,\ncallstack_start`,");
 814                          getBacktraceString(&log, 4096 - log.length - 17);
 815                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 816 //               }
 817
 818                  printLog(&log, MSG_LOG);
 819                  postBlockEnd();
 820         }
 821
 822         return ret;
 823 }
 824
 825 int File::Read(void *buffer, int length) {
 826         typedef int (File::*methodType)(void *buffer, int length);
 827         static methodType Readp = 0;
 828         int ret;
 829         probeInfo_t     probeInfo;
 830         log_t   log;
 831         int blockresult;
 832         bool bfiltering = true;
 833         char temp[50];
 834         int nRead = 0;
 835         FileAttributes attr;
 836         long long size;
 837
 838         if (!Readp) {
 839                 probeBlockStart();
 840
 841                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File4ReadEPvi");
 842
 843                 if (tmpPtr == NULL || dlerror() != NULL) {
 844                         perror("dlsym failed : Tizen::Io::File::Read");
 845                         exit(0);
 846                 }
 847
 848                 memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
 849                 probeBlockEnd();
 850         }
 851
 852         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 853                 setProbePoint(&probeInfo);
 854                 nRead = Tell();
 855                 preBlockEnd();
 856         }
 857
 858         ret = (this->*Readp)(buffer, length);
 859         result res = GetLastResult();
 860
 861         if(postBlockBegin(blockresult)) {
 862                  log.type = 0;
 863                  log.length = 0;
 864                  log.data[0] = '\0';
 865                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 866                  LC_RESOURCE, probeInfo.eventIndex, "File::Read",
 867                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 868                  //Input,ret
 869                  log.length += sprintf(log.data + log.length,"`,0x%x, %d`,%d",(unsigned int)buffer,length,ret);
 870                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 871                  File::GetAttributes(this->GetName(),attr);
 872                  WcharToChar(temp,this->GetName().GetPointer());
 873                  size = attr.GetFileSize();
 874                  nRead = Tell() - nRead;
 875                  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);
 876                  //callstack
 877
 878                  //              if(E_SUCCESS != ret || blockresult == 2) {
 879 //                       log.length += sprintf(log.data + log.length,
 880 //                                       "`,\ncallstack_start`,`,callstack_end");
 881 //               } else{
 882                          log.length += sprintf(log.data + log.length,
 883                                          "`,\ncallstack_start`,");
 884                          getBacktraceString(&log, 4096 - log.length - 17);
 885                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 886 //               }
 887
 888                  printLog(&log, MSG_LOG);
 889                  postBlockEnd();
 890         }
 891
 892         return ret;
 893 }
 894
 895 result File::Seek(FileSeekPosition position, long offset) {
 896         typedef result (File::*methodType)(FileSeekPosition position, long offset);
 897         static methodType Seekp = 0;
 898         result ret;
 899         probeInfo_t     probeInfo;
 900         log_t   log;
 901         int blockresult;
 902         bool bfiltering = true;
 903         char temp[50];
 904         FileAttributes attr;
 905         long long size;
 906
 907         if (!Seekp) {
 908                 probeBlockStart();
 909
 910                 void *tmpPtr = dlsym(RTLD_NEXT,
 911                                 "_ZN5Tizen2Io4File4SeekENS0_16FileSeekPositionEl");
 912
 913                 if (tmpPtr == NULL || dlerror() != NULL) {
 914                         perror("dlsym failed : Tizen::Io::File::Seek");
 915                         exit(0);
 916                 }
 917
 918                 memcpy(&Seekp, &tmpPtr, sizeof(tmpPtr));
 919
 920                 probeBlockEnd();
 921         }
 922
 923         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 924                 setProbePoint(&probeInfo);
 925                 preBlockEnd();
 926         }
 927
 928         ret = (this->*Seekp)(position, offset);
 929
 930         if(postBlockBegin(blockresult)) {
 931                  log.type = 0;
 932                  log.length = 0;
 933                  log.data[0] = '\0';
 934                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
 935                  LC_RESOURCE, probeInfo.eventIndex, "File::Seek",
 936                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
 937                  //Input,ret
 938                  if(FILESEEKPOSITION_BEGIN == position)
 939                          log.length += sprintf(log.data + log.length,"`,FILESEEKPOSITION_BEGIN");
 940                  else if(FILESEEKPOSITION_CURRENT == position)
 941                          log.length += sprintf(log.data + log.length,"`,FILESEEKPOSITION_CURRENT");
 942                  else if(FILESEEKPOSITION_END == position)
 943                          log.length += sprintf(log.data + log.length,"`,FILESEEKPOSITION_END");
 944                  else
 945                          log.length += sprintf(log.data + log.length,"`,%d",position);
 946                  log.length += sprintf(log.data + log.length,", %ld`,%ld",offset,ret);
 947                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
 948                  File::GetAttributes(this->GetName(),attr);
 949                  WcharToChar(temp,this->GetName().GetPointer());
 950                  size = attr.GetFileSize();
 951                  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);
 952                  //callstack
 953
 954                  //              if(E_SUCCESS != ret || blockresult == 2) {
 955 //                       log.length += sprintf(log.data + log.length,
 956 //                                       "`,\ncallstack_start`,`,callstack_end");
 957 //               } else{
 958                          log.length += sprintf(log.data + log.length,
 959                                          "`,\ncallstack_start`,");
 960                          getBacktraceString(&log, 4096 - log.length - 17);
 961                          log.length += sprintf(log.data + log.length, "`,callstack_end");
 962 //               }
 963
 964                  printLog(&log, MSG_LOG);
 965                  postBlockEnd();
 966         }
 967
 968         return ret;
 969 }
 970
 971 int File::Tell(void) const {
 972         typedef int (File::*methodType)(void) const;
 973         static methodType Tellp = 0;
 974         int ret;
 975         probeInfo_t     probeInfo;
 976         log_t   log;
 977         int blockresult;
 978         bool bfiltering = true;
 979         char temp[50];
 980         FileAttributes attr;
 981         long long size;
 982
 983         if (!Tellp) {
 984                 probeBlockStart();
 985
 986                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZNK5Tizen2Io4File4TellEv");
 987
 988                 if (tmpPtr == NULL || dlerror() != NULL) {
 989                         perror("dlsym failed : Tizen::Io::File::Tell");
 990                         exit(0);
 991                 }
 992
 993                 memcpy(&Tellp, &tmpPtr, sizeof(tmpPtr));
 994
 995                 probeBlockEnd();
 996         }
 997
 998         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
 999                 setProbePoint(&probeInfo);
1000                 preBlockEnd();
1001         }
1002
1003         ret = (this->*Tellp)();
1004         result res = GetLastResult();
1005
1006         if(postBlockBegin(blockresult)) {
1007                  log.type = 0;
1008                  log.length = 0;
1009                  log.data[0] = '\0';
1010                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1011                  LC_RESOURCE, probeInfo.eventIndex, "File::Tell",
1012                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1013                  //Input,ret
1014                  log.length += sprintf(log.data + log.length,"`,`,%d",ret);
1015                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1016                  File::GetAttributes(this->GetName(),attr);
1017                  WcharToChar(temp,this->GetName().GetPointer());
1018                  size = attr.GetFileSize();
1019                  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);
1020                  //callstack
1021
1022                  //              if(E_SUCCESS != ret || blockresult == 2) {
1023 //                       log.length += sprintf(log.data + log.length,
1024 //                                       "`,\ncallstack_start`,`,callstack_end");
1025 //               } else{
1026                          log.length += sprintf(log.data + log.length,
1027                                          "`,\ncallstack_start`,");
1028                          getBacktraceString(&log, 4096 - log.length - 17);
1029                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1030 //               }
1031
1032                  printLog(&log, MSG_LOG);
1033                  postBlockEnd();
1034         }
1035
1036         return ret;
1037 }
1038
1039 result File::Truncate(int length) {
1040         typedef result (File::*methodType)(int length);
1041         static methodType Truncatep = 0;
1042         result ret;
1043         probeInfo_t     probeInfo;
1044         log_t   log;
1045         int blockresult;
1046         bool bfiltering = true;
1047         char temp[50];
1048         FileAttributes attr;
1049         long long size;
1050
1051         if (!Truncatep) {
1052                 probeBlockStart();
1053
1054                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File8TruncateEi");
1055
1056                 if (tmpPtr == NULL || dlerror() != NULL) {
1057                         perror("dlsym failed : Tizen::Io::File::Truncate");
1058                         exit(0);
1059                 }
1060
1061                 memcpy(&Truncatep, &tmpPtr, sizeof(tmpPtr));
1062                 probeBlockEnd();
1063         }
1064
1065         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1066                 setProbePoint(&probeInfo);
1067                 preBlockEnd();
1068         }
1069
1070         ret = (this->*Truncatep)(length);
1071
1072         if(postBlockBegin(blockresult)) {
1073                  log.type = 0;
1074                  log.length = 0;
1075                  log.data[0] = '\0';
1076                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1077                  LC_RESOURCE, probeInfo.eventIndex, "File::Truncate",
1078                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1079                  //Input,ret
1080                  log.length += sprintf(log.data + log.length,"`,%d`,%ld",length,ret);
1081                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1082                  File::GetAttributes(this->GetName(),attr);
1083                  WcharToChar(temp,this->GetName().GetPointer());
1084                  size = attr.GetFileSize();
1085                  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);
1086                  //callstack
1087
1088                  //              if(E_SUCCESS != ret || blockresult == 2) {
1089 //                       log.length += sprintf(log.data + log.length,
1090 //                                       "`,\ncallstack_start`,`,callstack_end");
1091 //               } else{
1092                          log.length += sprintf(log.data + log.length,
1093                                          "`,\ncallstack_start`,");
1094                          getBacktraceString(&log, 4096 - log.length - 17);
1095                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1096 //               }
1097
1098                  printLog(&log, MSG_LOG);
1099                  postBlockEnd();
1100         }
1101
1102         return ret;
1103 }
1104
1105 result File::Write(const void *buffer, int length) {
1106         typedef result (File::*methodType)(const void *buffer, int length);
1107         static methodType Writep = 0;
1108         result ret;
1109         probeInfo_t     probeInfo;
1110         log_t   log;
1111         int blockresult;
1112         bool bfiltering = true;
1113         char temp[50];
1114         int nWritten = 0;
1115         FileAttributes attr;
1116         long long size;
1117
1118         if (!Writep) {
1119                 probeBlockStart();
1120
1121                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5WriteEPKvi");
1122
1123                 if (tmpPtr == NULL || dlerror() != NULL) {
1124                         perror("dlsym failed : Tizen::Io::File::Write");
1125                         exit(0);
1126                 }
1127
1128                 memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
1129                 probeBlockEnd();
1130         }
1131
1132         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1133                 setProbePoint(&probeInfo);
1134                 nWritten = Tell();
1135                 preBlockEnd();
1136         }
1137
1138         ret = (this->*Writep)(buffer, length);
1139
1140         if(postBlockBegin(blockresult)) {
1141                  log.type = 0;
1142                  log.length = 0;
1143                  log.data[0] = '\0';
1144                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1145                  LC_RESOURCE, probeInfo.eventIndex, "File::Write",
1146                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1147                  //Input,ret
1148                  log.length += sprintf(log.data + log.length,"`,0x%x, %d`,%ld",(unsigned int)buffer,length,ret);
1149                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1150                  File::GetAttributes(this->GetName(),attr);
1151                  WcharToChar(temp,this->GetName().GetPointer());
1152                  size = attr.GetFileSize();
1153                  nWritten = Tell() - nWritten;
1154                  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);
1155                  //callstack
1156
1157                  //              if(E_SUCCESS != ret || blockresult == 2) {
1158 //                       log.length += sprintf(log.data + log.length,
1159 //                                       "`,\ncallstack_start`,`,callstack_end");
1160 //               } else{
1161                          log.length += sprintf(log.data + log.length,
1162                                          "`,\ncallstack_start`,");
1163                          getBacktraceString(&log, 4096 - log.length - 17);
1164                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1165 //               }
1166
1167                  printLog(&log, MSG_LOG);
1168                  postBlockEnd();
1169         }
1170
1171         return ret;
1172 }
1173
1174 result File::Write(const Tizen::Base::ByteBuffer& buffer) {
1175         typedef result (File::*methodType)(const Tizen::Base::ByteBuffer& buffer);
1176         static methodType Writep = 0;
1177         result ret;
1178         probeInfo_t     probeInfo;
1179         log_t   log;
1180         int blockresult;
1181         bool bfiltering = true;
1182         char temp[50];
1183         int nWritten = 0;
1184         FileAttributes attr;
1185         long long size;
1186
1187         if (!Writep) {
1188                 probeBlockStart();
1189
1190                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5WriteERKNS_4Base10ByteBufferE");
1191
1192                 if (tmpPtr == NULL || dlerror() != NULL) {
1193                         perror("dlsym failed : Tizen::Io::File::Write");
1194                         exit(0);
1195                 }
1196
1197                 memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
1198                 probeBlockEnd();
1199         }
1200
1201         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1202                 setProbePoint(&probeInfo);
1203                 nWritten = Tell();
1204                 preBlockEnd();
1205         }
1206
1207         ret = (this->*Writep)(buffer);
1208
1209         if(postBlockBegin(blockresult)) {
1210                  log.type = 0;
1211                  log.length = 0;
1212                  log.data[0] = '\0';
1213                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1214                  LC_RESOURCE, probeInfo.eventIndex, "File::Write",
1215                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1216                  //Input,ret
1217                  log.length += sprintf(log.data + log.length,"`,0x%x`,%ld",(unsigned int)&buffer,ret);
1218                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1219                  File::GetAttributes(this->GetName(),attr);
1220                  WcharToChar(temp,this->GetName().GetPointer());
1221                  size = attr.GetFileSize();
1222                  nWritten = Tell() - nWritten;
1223                  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);
1224                  //callstack
1225
1226                  //              if(E_SUCCESS != ret || blockresult == 2) {
1227 //                       log.length += sprintf(log.data + log.length,
1228 //                                       "`,\ncallstack_start`,`,callstack_end");
1229 //               } else{
1230                          log.length += sprintf(log.data + log.length,
1231                                          "`,\ncallstack_start`,");
1232                          getBacktraceString(&log, 4096 - log.length - 17);
1233                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1234 //               }
1235
1236                  printLog(&log, MSG_LOG);
1237                  postBlockEnd();
1238         }
1239
1240         return ret;
1241 }
1242
1243 result File::Write(const Tizen::Base::String& buffer) {
1244         typedef result (File::*methodType)(const Tizen::Base::String& buffer);
1245         static methodType Writep = 0;
1246         result ret;
1247         probeInfo_t     probeInfo;
1248         log_t   log;
1249         int blockresult;
1250         bool bfiltering = true;
1251         char temp[50];
1252         int nWritten = 0;
1253         FileAttributes attr;
1254         long long size;
1255
1256         if (!Writep) {
1257                 probeBlockStart();
1258
1259                 void *tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4File5WriteERKNS_4Base6StringE");
1260
1261                 if (tmpPtr == NULL || dlerror() != NULL) {
1262                         perror("dlsym failed : Tizen::Io::File::Write");
1263                         exit(0);
1264                 }
1265
1266                 memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
1267                 probeBlockEnd();
1268         }
1269
1270         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1271                 setProbePoint(&probeInfo);
1272                 nWritten = Tell();
1273                 preBlockEnd();
1274         }
1275
1276         ret = (this->*Writep)(buffer);
1277
1278         if(postBlockBegin(blockresult)) {
1279                  log.type = 0;
1280                  log.length = 0;
1281                  log.data[0] = '\0';
1282                  log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1283                  LC_RESOURCE, probeInfo.eventIndex, "File::Write",
1284                  probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1285                  //Input,ret
1286                  WcharToChar(temp,buffer.GetPointer());
1287                  log.length += sprintf(log.data + log.length,"`,%s`,%ld",temp,ret);
1288                  //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1289                  File::GetAttributes(this->GetName(),attr);
1290                  WcharToChar(temp,this->GetName().GetPointer());
1291                  size = attr.GetFileSize();
1292                  nWritten = Tell() - nWritten;
1293                  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);
1294                  //callstack
1295
1296                  //              if(E_SUCCESS != ret || blockresult == 2) {
1297 //                       log.length += sprintf(log.data + log.length,
1298 //                                       "`,\ncallstack_start`,`,callstack_end");
1299 //               } else{
1300                          log.length += sprintf(log.data + log.length,
1301                                          "`,\ncallstack_start`,");
1302                          getBacktraceString(&log, 4096 - log.length - 17);
1303                          log.length += sprintf(log.data + log.length, "`,callstack_end");
1304 //               }
1305
1306                  printLog(&log, MSG_LOG);
1307                  postBlockEnd();
1308         }
1309         return ret;
1310 }
1311
1312 File::~File(void) {
1313         typedef void (File::*methodType)();
1314         static methodType FileDp = 0;
1315         probeInfo_t     probeInfo;
1316         log_t   log;
1317         int blockresult;
1318         bool bfiltering = true;
1319         void *tmpPtr;
1320         FileAttributes attr;
1321         long long size;
1322
1323         if (!FileDp) {
1324                 probeBlockStart();
1325
1326                 tmpPtr = dlsym(RTLD_NEXT, "_ZN5Tizen2Io4FileD1Ev");
1327
1328                 if (tmpPtr == NULL || dlerror() != NULL) {
1329                         perror("dlsym failed : Tizen::Io::File::~File");
1330                         exit(0);
1331                 }
1332
1333                 memcpy(&FileDp, &tmpPtr, sizeof(tmpPtr));
1334                 probeBlockEnd();
1335         }
1336
1337         if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
1338                 setProbePoint(&probeInfo);
1339                 File::GetAttributes(this->GetName(),attr);
1340                 size = attr.GetFileSize();
1341                 preBlockEnd();
1342         }
1343 //
1344         (this->*FileDp)();
1345 //
1346         if(postBlockBegin(blockresult)) {
1347                 log.type = 0;
1348                 log.length = 0;
1349                 log.data[0] = '\0';
1350                 log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
1351                                 LC_RESOURCE, probeInfo.eventIndex, "File::~File",
1352                                 probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
1353                 //Input,ret
1354                 log.length += sprintf(log.data + log.length,"`,`,");
1355                 //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
1356                 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);
1357                 //callstack
1358
1359 //              if(E_SUCCESS != ret || blockresult == 2) {
1360 //                      log.length += sprintf(log.data + log.length,
1361 //                                      "`,\ncallstack_start`,`,callstack_end");
1362 //              } else{
1363                         log.length += sprintf(log.data + log.length,
1364                                         "`,\ncallstack_start`,");
1365                         getBacktraceString(&log, 4096 - log.length - 17);
1366                         log.length += sprintf(log.data + log.length, "`,callstack_end");
1367 //              }
1368
1369                 printLog(&log, MSG_LOG);
1370                 postBlockEnd();
1371         }
1372 }
1373
1374
1375 // static methods
1376 //static result File::ConvertToSecureFile(const Tizen::Base::String &plainFilePath,
1377 //              const Tizen::Base::String &secureFilePath) {
1378 //      typedef result (File::*methodType)(
1379 //                      const Tizen::Base::String &plainFilePath,
1380 //                      const Tizen::Base::String &secureFilePath);
1381 //      static methodType ConvertToSecureFilep = 0;
1382 //
1383 //}
1384 //static result File::ConvertToSecureFile(const Tizen::Base::String &plainFilePath,
1385 //              const Tizen::Base::String &secureFilePath,
1386 //              const Tizen::Base::ByteBuffer& key) {
1387 //      typedef result (File::*methodType)(
1388 //                      const Tizen::Base::String &plainFilePath,
1389 //                      const Tizen::Base::String &secureFilePath,
1390 //                      const Tizen::Base::ByteBuffer& key);
1391 //      static methodType ConvertToSecureFilep = 0;
1392 //
1393 //}
1394 //static result File::Copy(const Tizen::Base::String& srcFilePath,
1395 //              const Tizen::Base::String& destFilePath, bool failIfExist) {
1396 //      typedef result (File::*methodType)(const Tizen::Base::String& srcFilePath,
1397 //                      const Tizen::Base::String& destFilePath, bool failIfExist);
1398 //      static methodType Copyp = 0;
1399 //
1400 //}
1401 //static result File::GetAttributes(const Tizen::Base::String& filePath,
1402 //              FileAttributes& attribute) {
1403 //      typedef result (File::*methodType)(const Tizen::Base::String& filePath,
1404 //                      FileAttributes& attribute);
1405 //      static methodType GetAttributesp = 0;
1406 //
1407 //}
1408 //static const Tizen::Base::String File::GetFileExtension(
1409 //              const Tizen::Base::String& filePath) {
1410 //      typedef const Tizen::Base::String (File::*methodType)(
1411 //                      const Tizen::Base::String& filePath);
1412 //      static methodType GetFileExtensionp = 0;
1413 //
1414 //}
1415 //const Tizen::Base::String File::GetFileName(
1416 //              const Tizen::Base::String& filePath) {
1417 //      typedef const Tizen::Base::String (File::*methodType)(
1418 //                      const Tizen::Base::String& filePath);
1419 //      static methodType GetFileNamep = 0;
1420 //      Tizen::Base::String ret;
1421 //
1422 //      if (!GetFileNamep) {
1423 //                      probeBlockStart();
1424 //                      void *tmpPtr = dlsym(RTLD_NEXT,
1425 //                                      "_ZN5Tizen2Io4File11GetFileNameERKNS_4Base6StringE");
1426 //
1427 //                      if (tmpPtr == NULL || dlerror() != NULL) {
1428 //                              perror("dlsym failed : Tizen::Io::File::GetFileName");
1429 //                              exit(0);
1430 //                      }
1431 //
1432 //                      memcpy(&GetFileNamep, &tmpPtr, sizeof(tmpPtr));
1433 //                      probeBlockEnd();
1434 //              }
1435 //      ret = (File::(*GetFileNamep))(filePath);
1436 //
1437 //return ret;
1438 //}
1439 //static bool File::IsEncrypted(const Tizen::Base::String &filePath) {
1440 //      typedef bool (File::*methodType)(const Tizen::Base::String &filePath);
1441 //      static methodType IsEncryptedp = 0;
1442 //
1443 //}
1444 //static bool File::IsFileExist(const Tizen::Base::String& filePath) {
1445 //      typedef bool (File::*methodType)(const Tizen::Base::String& filePath);
1446 //      static methodType IsFileExistp = 0;
1447 //
1448 //}
1449 //static result File::Move(const Tizen::Base::String& oldFilePath,
1450 //              const Tizen::Base::String& newFilePath) {
1451 //      typedef result (File::*methodType)(const Tizen::Base::String& oldFilePath,
1452 //                      const Tizen::Base::String& newFilePath);
1453 //      static methodType Movep = 0;
1454 //
1455 //}
1456 //static result File::Remove(const Tizen::Base::String& filePath) {
1457 //      typedef result (File::*methodType)(const Tizen::Base::String& filePath);
1458 //      static methodType Removep = 0;
1459 //
1460 //}
1461
1462 }
1463 }