1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 /*! \file oscl_file_io.cpp 19 \brief This file contains file io APIs 20 */ 21 22 #include "oscl_file_io.h" 23 #include "oscl_dll.h" 24 #include "oscl_mem.h" 25 #include "oscl_file_native.h" 26 #include "oscl_file_handle.h" 27 #include "oscl_file_cache.h" 28 #include "pvlogger.h" 29 #include "oscl_string_containers.h" 30 #include "oscl_file_stats.h" 31 #include "oscl_file_async_read.h" 32 33 #ifndef OSCL_COMBINED_DLL 34 OSCL_DLL_ENTRY_POINT_DEFAULT() 35 #endif 36 37 38 OSCL_EXPORT_REF Oscl_File::Oscl_File() 39 { 40 Construct(); 41 42 //for back-compatibility, set the old compile-time defaults. 43 OldCacheDefaults(); 44 } 45 46 void Oscl_File::Construct() 47 { 48 iOpenFileHandle = NULL; 49 iLogger = NULL; 50 iStatsLogger = NULL; 51 iNativeLogger = NULL; 52 iAsyncLogger = NULL; 53 iFileStats = NULL; 54 iNativeFile = NULL; 55 iFileCache = NULL; 56 iIsOpen = false; 57 iNativeBufferSize = 0; 58 iNativeAccessMode = 0; 59 iPVCacheSize = 0; 60 iAsyncReadBufferSize = 0; 61 iAsyncFile = NULL; 62 63 //Create the native file I/O implementation 64 int32 err; 65 OSCL_TRY(err, iNativeFile = OSCL_NEW(OsclNativeFile, ());); 66 } 67 68 //For back-compatibility, this sets cache defaults using the 69 //compile-switches (if defined). 70 void Oscl_File::OldCacheDefaults() 71 { 72 73 //native file cache enable chooses RFileBuf mode over RFile mode 74 //for symbian. 75 76 SetNativeAccessMode(ESymbianAccessMode_RfileBuf); 77 78 #if defined(OSCL_FILE_BUFFER_MAX_SIZE) 79 //native buffer size defaults to max buffer size 80 81 SetNativeBufferSize(OSCL_FILE_BUFFER_MAX_SIZE); 82 #endif 83 84 #if defined(OSCL_ASYNC_READ_BUFFER_SIZE) 85 // enable async file read operation 86 87 SetAsyncReadBufferSize(OSCL_ASYNC_READ_BUFFER_SIZE); 88 #endif 89 90 91 } 92 93 //For back-compatibility constructors. 94 //This sets the cache settings using a combination of the input value 95 //and the compile-time settings (if defined). 96 void Oscl_File::OldCacheSelect(uint32 aCacheSize) 97 { 98 uint32 cacheSize = aCacheSize; 99 100 //file buffer max limits the actual cache size when defined. 101 #if defined(OSCL_FILE_BUFFER_MAX_SIZE) 102 if (cacheSize > OSCL_FILE_BUFFER_MAX_SIZE) 103 cacheSize = OSCL_FILE_BUFFER_MAX_SIZE; 104 #endif 105 106 107 //cache option is "off" (or not defined) 108 109 //cache option is "on" 110 SetNativeBufferSize(cacheSize); 111 112 } 113 114 //This constructor is deprecated, but present for back-compatibility. 115 OSCL_EXPORT_REF Oscl_File::Oscl_File(uint32 cacheSize) 116 { 117 Construct(); 118 OldCacheDefaults(); 119 OldCacheSelect(cacheSize); 120 } 121 122 //This constructor is deprecated, but present for back-compatibility. 123 OSCL_EXPORT_REF Oscl_File::Oscl_File(uint32 cacheSize, OsclFileHandle* aHandle) 124 { 125 Construct(); 126 OldCacheDefaults(); 127 OldCacheSelect(cacheSize); 128 SetFileHandle(aHandle); 129 } 130 131 OSCL_EXPORT_REF Oscl_File::~Oscl_File() 132 { 133 if (iIsOpen) 134 Close(); 135 136 if (iOpenFileHandle) 137 OSCL_DELETE(iOpenFileHandle); 138 iOpenFileHandle = NULL; 139 140 if (iFileCache) 141 OSCL_DELETE(iFileCache); 142 iFileCache = NULL; 143 144 if (iAsyncFile) 145 OsclAsyncFile::Delete(iAsyncFile); 146 iAsyncFile = NULL; 147 148 if (iNativeFile) 149 OSCL_DELETE(iNativeFile); 150 iNativeFile = NULL; 151 152 if (iFileStats) 153 OSCL_DELETE(iFileStats); 154 iFileStats = NULL; 155 } 156 157 OSCL_EXPORT_REF void Oscl_File::SetPVCacheSize(uint32 aSize) 158 { 159 //just save the value now-- it will take effect on the next open. 160 iPVCacheSize = aSize; 161 } 162 163 OSCL_EXPORT_REF void Oscl_File::SetAsyncReadBufferSize(uint32 aSize) 164 { 165 //just save the value now-- it will take effect on the next open. 166 iAsyncReadBufferSize = aSize; 167 168 } 169 170 OSCL_EXPORT_REF void Oscl_File::SetLoggingEnable(bool aEnable) 171 { 172 if (aEnable) 173 { 174 iLogger = PVLogger::GetLoggerObject("Oscl_File"); 175 iNativeLogger = PVLogger::GetLoggerObject("OsclNativeFile"); 176 iAsyncLogger = PVLogger::GetLoggerObject("OsclAsyncFile"); 177 } 178 else 179 { 180 iLogger = NULL; 181 iNativeLogger = NULL; 182 iAsyncLogger = NULL; 183 } 184 } 185 186 OSCL_EXPORT_REF void Oscl_File::SetSummaryStatsLoggingEnable(bool aEnable) 187 { 188 if (aEnable) 189 { 190 iStatsLogger = PVLogger::GetLoggerObject("OsclFileStats"); 191 } 192 else 193 { 194 iStatsLogger = NULL; 195 } 196 CreateFileStats(); 197 } 198 199 void Oscl_File::CreateFileStats() 200 { 201 if (iFileStats) 202 OSCL_DELETE(iFileStats); 203 iFileStats = NULL; 204 if (iStatsLogger) 205 { 206 int32 err; 207 OSCL_TRY(err, iFileStats = OSCL_NEW(OsclFileStats, (this));); 208 } 209 } 210 211 212 OSCL_EXPORT_REF void Oscl_File::SetNativeAccessMode(uint32 aMode) 213 { 214 //just save the value now-- it will take effect on the next open. 215 iNativeAccessMode = aMode; 216 } 217 218 OSCL_EXPORT_REF void Oscl_File::SetNativeBufferSize(int32 aSize) 219 { 220 //just save the value now-- it will take effect on the next open. 221 iNativeBufferSize = aSize; 222 } 223 224 OSCL_EXPORT_REF int32 Oscl_File::SetFileHandle(OsclFileHandle* aHandle) 225 { 226 if (iIsOpen) 227 return -1;//can't reset file handle when file is open. 228 229 if (iOpenFileHandle) 230 OSCL_DELETE(iOpenFileHandle); 231 iOpenFileHandle = NULL; 232 233 //make a copy to avoid memory persistence issues 234 if (aHandle) 235 { 236 int32 err; 237 OSCL_TRY(err, iOpenFileHandle = OSCL_NEW(OsclFileHandle, (*aHandle));); 238 if (!iOpenFileHandle) 239 return (-1);//allocation failed. 240 } 241 242 return 0; 243 } 244 245 246 #include "pvlogger.h" 247 248 int32 Oscl_File::OpenFileCacheOrAsyncBuffer(const char *filename 249 , const oscl_wchar* wfilename 250 , uint32 mode 251 , const OsclNativeFileParams& params 252 , Oscl_FileServer& fileserv) 253 //open pv cache or async file implementation for the given open mode. 254 //if cache is not enabled, then cleanup any old implementation. 255 { 256 //use async buffer when read-only mode and iAsyncReadBufferSize is > 0 257 bool asyncEnable = ((mode == MODE_READ || mode == MODE_READ + MODE_BINARY) && iAsyncReadBufferSize > 0); 258 259 //use cache when *not* using async file and iPVCacheSize is > 0 260 bool cacheEnable = !asyncEnable && (iPVCacheSize > 0); 261 262 if (cacheEnable) 263 { 264 //create file cache implementation if needed. 265 if (!iFileCache) 266 { 267 int32 err; 268 OSCL_TRY(err, iFileCache = OSCL_NEW(OsclFileCache, (*this));); 269 if (!iFileCache) 270 return -1;//allocation failed 271 } 272 } 273 else 274 { 275 //cleanup any old implementation of file cache 276 if (iFileCache) 277 OSCL_DELETE(iFileCache); 278 iFileCache = NULL; 279 } 280 281 if (asyncEnable) 282 { 283 //async file implementation isn't reusable so destroy 284 //& re-create it 285 if (iAsyncFile) 286 OsclAsyncFile::Delete(iAsyncFile); 287 iAsyncFile = NULL; 288 int32 err; 289 OSCL_TRY(err, iAsyncFile = OsclAsyncFile::NewL(*iNativeFile, iAsyncReadBufferSize, iAsyncLogger);); 290 if (!iAsyncFile) 291 return -1;//allocation failed 292 } 293 else 294 { 295 //cleanup any old implementation of async file. 296 if (iAsyncFile) 297 OsclAsyncFile::Delete(iAsyncFile); 298 iAsyncFile = NULL; 299 } 300 301 //at this point we have either iFileCache, iAsyncFile, or neither. 302 303 if (iFileCache) 304 { 305 return iFileCache->Open(mode, iPVCacheSize); 306 } 307 else if (iAsyncFile) 308 { 309 if (filename) 310 return iAsyncFile->Open(filename, mode, params, fileserv); 311 else if (wfilename) 312 return iAsyncFile->Open(wfilename, mode, params, fileserv); 313 else 314 return -1; 315 } 316 else 317 { 318 return 0; 319 } 320 } 321 322 OSCL_EXPORT_REF int32 Oscl_File::Open(const oscl_wchar *filename, uint32 mode, Oscl_FileServer& fileserv) 323 { 324 if (iLogger) 325 { 326 OSCL_wHeapString<OsclMemAllocator> wstr(filename); 327 OSCL_HeapString<OsclMemAllocator> str; 328 char buf[2]; 329 buf[1] = '\0'; 330 for (uint32 i = 0; i < wstr.get_size(); i++) 331 { 332 buf[0] = (char)wstr[i]; 333 str += buf; 334 } 335 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 336 (0, "Oscl_File(0x%x)::Open IN name '%s' mode %d serv 0x%x", this, str.get_cstr(), mode, &fileserv)); 337 } 338 339 int32 result = (-1); 340 341 uint32 ticks = 0; 342 if (iFileStats) 343 iFileStats->Start(ticks); 344 345 //protect against duplicate open calls 346 if (iIsOpen) 347 goto ErrorExit; 348 349 //do native open or attach 350 { 351 OsclNativeFileParams params(iNativeAccessMode, iNativeBufferSize, iAsyncReadBufferSize); 352 if (iOpenFileHandle) 353 result = CallNativeOpen(*iOpenFileHandle, mode, params, fileserv); 354 else 355 result = CallNativeOpen(filename, mode , params, fileserv); 356 357 if (result != 0) 358 goto ErrorExit; 359 360 //create cache implementation if needed. 361 result = OpenFileCacheOrAsyncBuffer(NULL, filename, mode, params, fileserv); 362 } 363 if (result != 0) 364 goto ErrorExit; 365 366 ErrorExit: 367 368 if (result == 0) 369 iIsOpen = true; 370 371 if (iFileStats 372 && result == 0) 373 iFileStats->End(EOsclFileOp_Open, ticks); 374 375 if (iLogger) 376 { 377 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 378 (0, "Oscl_File(0x%x)::Open OUT result %d", this, result)); 379 } 380 381 return result; 382 } 383 384 385 OSCL_EXPORT_REF int32 Oscl_File::Open(const char *filename, uint32 mode, Oscl_FileServer& fileserv) 386 { 387 if (iLogger) 388 { 389 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 390 (0, "Oscl_File(0x%x)::Open IN name '%s' mode %d serv 0x%x", this, filename, mode, &fileserv)); 391 } 392 393 int32 result = (-1); 394 395 uint32 ticks = 0; 396 if (iFileStats) 397 iFileStats->Start(ticks); 398 399 //protect against duplicate open calls 400 if (iIsOpen) 401 goto ErrorExit; 402 403 //do native open or attach 404 { 405 OsclNativeFileParams params(iNativeAccessMode, iNativeBufferSize, iAsyncReadBufferSize); 406 if (iOpenFileHandle) 407 result = CallNativeOpen(*iOpenFileHandle, mode, params, fileserv); 408 else 409 result = CallNativeOpen(filename, mode , params, fileserv); 410 411 if (result != 0) 412 goto ErrorExit; 413 414 //create file cache implementation if needed 415 result = OpenFileCacheOrAsyncBuffer(filename, NULL, mode, params, fileserv); 416 } 417 if (result != 0) 418 goto ErrorExit; 419 420 ErrorExit: 421 422 if (result == 0) 423 iIsOpen = true; 424 425 if (iFileStats 426 && result == 0) 427 iFileStats->End(EOsclFileOp_Open, ticks); 428 429 if (iLogger) 430 { 431 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 432 (0, "Oscl_File(0x%x)::Open OUT result %d", this, result)); 433 } 434 435 return result; 436 } 437 438 OSCL_EXPORT_REF int32 Oscl_File::Close() 439 { 440 if (iLogger) 441 { 442 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 443 (0, "Oscl_File(0x%x)::Close IN", this)); 444 } 445 446 uint32 ticks = 0; 447 if (iFileStats) 448 iFileStats->Start(ticks); 449 450 int32 result = (-1); 451 452 if (iIsOpen) 453 { 454 if (iFileCache) 455 iFileCache->Close(); 456 else if (iAsyncFile) 457 iAsyncFile->Close(); 458 459 result = CallNativeClose(); 460 } 461 462 iIsOpen = false; 463 464 if (iFileStats 465 && result == 0) 466 { 467 iFileStats->End(EOsclFileOp_Close, ticks); 468 iFileStats->LogAll(iStatsLogger, PVLOGMSG_DEBUG); 469 } 470 471 if (iLogger) 472 { 473 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 474 (0, "Oscl_File(0x%x)::Close OUT result %d", this, result)); 475 } 476 477 return result; 478 } 479 480 481 OSCL_EXPORT_REF uint32 Oscl_File::Read(OsclAny *buffer, uint32 size, uint32 numelements) 482 { 483 if (iLogger) 484 { 485 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 486 (0, "Oscl_File(0x%x)::Read IN size %d num %d", this, size, numelements)); 487 } 488 489 if (!size || !numelements || !buffer) 490 { 491 OSCL_LEAVE(OsclErrArgument); 492 } 493 494 uint32 ticks = 0; 495 if (iFileStats) 496 iFileStats->Start(ticks); 497 498 uint32 result = 0; 499 500 if (iIsOpen) 501 { 502 if (iFileCache) 503 result = iFileCache->Read(buffer, size, numelements); 504 else if (iAsyncFile) 505 result = iAsyncFile->Read(buffer, size, numelements); 506 else 507 result = CallNativeRead(buffer, size, numelements); 508 } 509 510 if (iFileStats 511 && result > 0) 512 iFileStats->End(EOsclFileOp_Read, ticks, result*size); 513 514 if (iLogger) 515 { 516 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 517 (0, "Oscl_File(0x%x)::Read OUT result %d", this, result)); 518 } 519 return result; 520 } 521 522 523 OSCL_EXPORT_REF uint32 Oscl_File::Write(const OsclAny *buffer, uint32 size, uint32 numelements) 524 { 525 if (iLogger) 526 { 527 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 528 (0, "Oscl_File(0x%x)::Write IN size %d num %d", this, size, numelements)); 529 } 530 531 uint32 ticks = 0; 532 if (iFileStats) 533 iFileStats->Start(ticks); 534 535 uint32 result = 0; 536 537 if (iIsOpen) 538 { 539 if (iFileCache) 540 result = iFileCache->Write(buffer, size, numelements); 541 else if (iAsyncFile) 542 return iAsyncFile->Write(buffer, size, numelements); 543 else 544 result = CallNativeWrite(buffer, size, numelements); 545 } 546 547 if (iFileStats 548 && result > 0) 549 iFileStats->End(EOsclFileOp_Write, ticks, result*size); 550 551 if (iLogger) 552 { 553 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 554 (0, "Oscl_File(0x%x)::Write OUT result %d", this, result)); 555 } 556 return result; 557 } 558 559 OSCL_EXPORT_REF int32 Oscl_File::Seek(TOsclFileOffset offset, seek_type origin) 560 { 561 if (iLogger) 562 { 563 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 564 (0, "Oscl_File(0x%x)::Seek IN offset %d origin %d", this, offset, origin)); 565 } 566 567 uint32 ticks = 0; 568 if (iFileStats) 569 iFileStats->Start(ticks); 570 571 int32 result = (-1); 572 573 if (iIsOpen) 574 { 575 if (iFileCache) 576 result = iFileCache->Seek(offset, origin); 577 else if (iAsyncFile) 578 result = iAsyncFile->Seek(offset, origin); 579 else 580 result = CallNativeSeek(offset, origin); 581 } 582 583 if (iFileStats 584 && result == 0) 585 iFileStats->End(EOsclFileOp_Seek, ticks, origin, offset); 586 587 if (iLogger) 588 { 589 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 590 (0, "Oscl_File(0x%x)::Seek OUT result %d", this, result)); 591 } 592 return result; 593 } 594 595 596 OSCL_EXPORT_REF TOsclFileOffset Oscl_File::Tell() 597 { 598 if (iLogger) 599 { 600 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 601 (0, "Oscl_File(0x%x)::Tell IN", this)); 602 } 603 604 uint32 ticks = 0; 605 if (iFileStats) 606 iFileStats->Start(ticks); 607 608 TOsclFileOffset result = (-1); 609 610 if (iIsOpen) 611 { 612 if (iFileCache) 613 result = iFileCache->Tell(); 614 else if (iAsyncFile) 615 result = iAsyncFile->Tell(); 616 else 617 result = CallNativeTell(); 618 } 619 620 if (iFileStats 621 && result == 0) 622 iFileStats->End(EOsclFileOp_Tell, ticks); 623 624 if (iLogger) 625 { 626 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 627 (0, "Oscl_File(0x%x)::Tell OUT result %d", this, result)); 628 } 629 return result; 630 } 631 632 OSCL_EXPORT_REF int32 Oscl_File::Flush() 633 { 634 if (iLogger) 635 { 636 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 637 (0, "Oscl_File(0x%x)::Flush IN", this)); 638 } 639 640 uint32 ticks = 0; 641 if (iFileStats) 642 iFileStats->Start(ticks); 643 644 int32 result = (-1); 645 646 if (iIsOpen) 647 { 648 if (iFileCache) 649 result = iFileCache->Flush(); 650 else if (iAsyncFile) 651 return iAsyncFile->Flush(); 652 else 653 result = CallNativeFlush(); 654 } 655 656 if (iFileStats 657 && result == 0) 658 iFileStats->End(EOsclFileOp_Flush, ticks); 659 660 if (iLogger) 661 { 662 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 663 (0, "Oscl_File(0x%x)::Flush OUT result %d", this, result)); 664 } 665 return result; 666 } 667 668 669 OSCL_EXPORT_REF int32 Oscl_File::EndOfFile() 670 { 671 if (iLogger) 672 { 673 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 674 (0, "Oscl_File(0x%x)::EndOfFile IN", this)); 675 } 676 677 uint32 ticks = 0; 678 if (iFileStats) 679 iFileStats->Start(ticks); 680 681 int32 result = (-1); 682 if (iIsOpen) 683 { 684 if (iFileCache) 685 result = iFileCache->EndOfFile(); 686 else if (iAsyncFile) 687 result = iAsyncFile->EndOfFile(); 688 else 689 result = CallNativeEndOfFile(); 690 } 691 692 if (iFileStats 693 && result != (-1)) 694 iFileStats->End(EOsclFileOp_EndOfFile, ticks); 695 696 if (iLogger) 697 { 698 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 699 (0, "Oscl_File(0x%x)::EndOfFile OUT result %d", this, result)); 700 } 701 return result; 702 } 703 704 OSCL_EXPORT_REF TOsclFileOffset Oscl_File::Size() 705 { 706 if (iLogger) 707 { 708 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 709 (0, "Oscl_File(0x%x)::Size IN")); 710 } 711 712 uint32 ticks = 0; 713 if (iFileStats) 714 iFileStats->Start(ticks); 715 716 TOsclFileOffset result = (-1); 717 718 if (iIsOpen) 719 { 720 if (iFileCache) 721 result = iFileCache->FileSize(); 722 else if (iAsyncFile) 723 result = iAsyncFile->Size(); 724 else 725 result = CallNativeSize(); 726 } 727 728 if (iFileStats 729 && result != (-1)) 730 iFileStats->End(EOsclFileOp_Size, ticks); 731 732 if (iLogger) 733 { 734 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, 735 (0, "Oscl_File(0x%x)::Size OUT result %d", this, result)); 736 } 737 return result; 738 } 739 740 OSCL_EXPORT_REF int32 Oscl_File::GetError() 741 { 742 return CallNativeGetError(); 743 } 744 745 int32 Oscl_File::CallNativeOpen(const OsclFileHandle& handle, uint32 mode 746 , const OsclNativeFileParams& params 747 , Oscl_FileServer& fileserv) 748 { 749 if (iNativeLogger) 750 { 751 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 752 (0, "OsclNativeFile(0x%x)::Open IN handle 0x%x mode %d serv 0x%x", this, &handle, mode, &fileserv)); 753 } 754 755 uint32 ticks = 0; 756 if (iFileStats) 757 iFileStats->Start(ticks); 758 759 int32 result = (-1); 760 761 if (iNativeFile) 762 result = iNativeFile->Open(handle, mode, params, fileserv); 763 764 if (iFileStats 765 && result == 0) 766 iFileStats->End(EOsclFileOp_NativeOpen, ticks); 767 768 if (iNativeLogger) 769 { 770 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 771 (0, "OsclNativeFile(0x%x)::Open OUT result %d", this, result)); 772 } 773 774 return result; 775 } 776 777 int32 Oscl_File::CallNativeOpen(const oscl_wchar *filename, uint32 mode 778 , const OsclNativeFileParams& params 779 , Oscl_FileServer& fileserv) 780 { 781 OSCL_UNUSED_ARG(params); 782 783 if (iNativeLogger) 784 { 785 OSCL_wHeapString<OsclMemAllocator> wstr(filename); 786 OSCL_HeapString<OsclMemAllocator> str; 787 char buf[2]; 788 buf[1] = '\0'; 789 for (uint32 i = 0; i < wstr.get_size(); i++) 790 { 791 buf[0] = (char)wstr[i]; 792 str += buf; 793 } 794 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 795 (0, "OsclNativeFile(0x%x)::Open IN name '%s' mode %d serv 0x%x", this, str.get_cstr(), mode, &fileserv)); 796 } 797 798 uint32 ticks = 0; 799 if (iFileStats) 800 iFileStats->Start(ticks); 801 802 int32 result = (-1); 803 804 { 805 OsclNativeFileParams params(iNativeAccessMode, iNativeBufferSize, iAsyncReadBufferSize); 806 if (iNativeFile) 807 result = iNativeFile->Open(filename, mode, params, fileserv); 808 } 809 810 if (iFileStats 811 && result == 0) 812 iFileStats->End(EOsclFileOp_NativeOpen, ticks); 813 814 if (iNativeLogger) 815 { 816 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 817 (0, "OsclNativeFile(0x%x)::Open OUT result %d", this, result)); 818 } 819 820 return result; 821 } 822 823 int32 Oscl_File::CallNativeOpen(const char *filename, uint32 mode 824 , const OsclNativeFileParams& params 825 , Oscl_FileServer& fileserv) 826 { 827 OSCL_UNUSED_ARG(params); 828 829 if (iNativeLogger) 830 { 831 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 832 (0, "OsclNativeFile(0x%x)::Open IN name '%s' mode %d serv 0x%x", this, filename, mode, &fileserv)); 833 } 834 835 uint32 ticks = 0; 836 if (iFileStats) 837 iFileStats->Start(ticks); 838 839 int32 result = (-1); 840 841 { 842 OsclNativeFileParams params(iNativeAccessMode, iNativeBufferSize, iAsyncReadBufferSize); 843 if (iNativeFile) 844 result = iNativeFile->Open(filename, mode, params, fileserv); 845 } 846 847 if (iFileStats 848 && result == 0) 849 iFileStats->End(EOsclFileOp_NativeOpen, ticks); 850 851 if (iNativeLogger) 852 { 853 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 854 (0, "OsclNativeFile(0x%x)::Open OUT result %d", this, result)); 855 } 856 857 return result; 858 } 859 860 uint32 Oscl_File::CallNativeRead(OsclAny *buffer, uint32 size, uint32 numelements) 861 { 862 if (iNativeLogger) 863 { 864 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 865 (0, "OsclNativeFile(0x%x)::Read IN size %d numelements %d", this, size, numelements)); 866 } 867 868 uint32 ticks = 0; 869 if (iFileStats) 870 iFileStats->Start(ticks); 871 872 int32 result = 0; 873 874 if (iNativeFile) 875 result = iNativeFile->Read(buffer, size, numelements); 876 877 if (iFileStats 878 && result > 0) 879 iFileStats->End(EOsclFileOp_NativeRead, ticks, result*size); 880 881 if (iNativeLogger) 882 { 883 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 884 (0, "OsclNativeFile(0x%x)::Read OUT result %d", this, result)); 885 } 886 887 return result; 888 } 889 890 uint32 Oscl_File::CallNativeWrite(const OsclAny *buffer, uint32 size, uint32 numelements) 891 { 892 if (iNativeLogger) 893 { 894 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 895 (0, "OsclNativeFile(0x%x)::Write IN size %d numelements %d", this, size, numelements)); 896 } 897 898 uint32 ticks = 0; 899 if (iFileStats) 900 iFileStats->Start(ticks); 901 902 int32 result = 0; 903 904 if (iNativeFile) 905 result = iNativeFile->Write(buffer, size, numelements); 906 907 if (iFileStats 908 && result > 0) 909 iFileStats->End(EOsclFileOp_NativeWrite, ticks, result*size); 910 911 if (iNativeLogger) 912 { 913 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 914 (0, "OsclNativeFile(0x%x)::Write OUT result %d", this, result)); 915 } 916 917 return result; 918 } 919 920 int32 Oscl_File::CallNativeSeek(TOsclFileOffset offset, Oscl_File::seek_type origin) 921 { 922 if (iNativeLogger) 923 { 924 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 925 (0, "OsclNativeFile(0x%x)::Seek IN offset %d origin %d", this, offset, origin)); 926 } 927 928 uint32 ticks = 0; 929 if (iFileStats) 930 iFileStats->Start(ticks); 931 932 int32 result = (-1); 933 934 if (iNativeFile) 935 result = iNativeFile->Seek(offset, origin); 936 937 if (iFileStats 938 && result == 0) 939 iFileStats->End(EOsclFileOp_NativeSeek, ticks, origin, offset); 940 941 if (iNativeLogger) 942 { 943 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 944 (0, "OsclNativeFile(0x%x)::Seek OUT result %d", this, result)); 945 } 946 947 return result; 948 } 949 950 TOsclFileOffset Oscl_File::CallNativeTell() 951 { 952 if (iNativeLogger) 953 { 954 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 955 (0, "OsclNativeFile(0x%x)::Tell IN", this)); 956 } 957 958 uint32 ticks = 0; 959 if (iFileStats) 960 iFileStats->Start(ticks); 961 962 TOsclFileOffset result = (-1); 963 964 if (iNativeFile) 965 result = iNativeFile->Tell(); 966 967 if (iFileStats 968 && result == 0) 969 iFileStats->End(EOsclFileOp_NativeTell, ticks); 970 971 if (iNativeLogger) 972 { 973 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 974 (0, "OsclNativeFile(0x%x)::Tell OUT result %d", this, result)); 975 } 976 977 return result; 978 } 979 980 981 int32 Oscl_File::CallNativeFlush() 982 { 983 if (iNativeLogger) 984 { 985 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 986 (0, "OsclNativeFile(0x%x)::Flush IN", this)); 987 } 988 989 uint32 ticks = 0; 990 if (iFileStats) 991 iFileStats->Start(ticks); 992 993 int32 result = (-1); 994 995 if (iNativeFile) 996 result = iNativeFile->Flush(); 997 998 if (iFileStats 999 && result == 0) 1000 iFileStats->End(EOsclFileOp_NativeFlush, ticks); 1001 1002 if (iNativeLogger) 1003 { 1004 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1005 (0, "OsclNativeFile(0x%x)::Flush OUT result", this, result)); 1006 } 1007 1008 return result; 1009 } 1010 1011 int32 Oscl_File::CallNativeEndOfFile() 1012 { 1013 if (iNativeLogger) 1014 { 1015 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1016 (0, "OsclNativeFile(0x%x)::EndOfFile IN", this)); 1017 } 1018 1019 uint32 ticks = 0; 1020 if (iFileStats) 1021 iFileStats->Start(ticks); 1022 1023 int32 result = (-1); 1024 1025 if (iNativeFile) 1026 result = iNativeFile->EndOfFile(); 1027 1028 if (iFileStats 1029 && result == 0) 1030 iFileStats->End(EOsclFileOp_NativeEndOfFile, ticks); 1031 1032 if (iNativeLogger) 1033 { 1034 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1035 (0, "OsclNativeFile(0x%x)::EndOfFile OUT result", this, result)); 1036 } 1037 1038 return result; 1039 } 1040 1041 TOsclFileOffset Oscl_File::CallNativeSize() 1042 { 1043 if (iNativeLogger) 1044 { 1045 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1046 (0, "OsclNativeFile(0x%x)::Size IN", this)); 1047 } 1048 1049 uint32 ticks = 0; 1050 if (iFileStats) 1051 iFileStats->Start(ticks); 1052 1053 TOsclFileOffset result = (-1); 1054 1055 if (iNativeFile) 1056 result = iNativeFile->Size(); 1057 1058 if (iFileStats 1059 && result >= 0) 1060 iFileStats->End(EOsclFileOp_NativeSize, ticks); 1061 1062 if (iNativeLogger) 1063 { 1064 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1065 (0, "OsclNativeFile(0x%x)::Size OUT result", this, result)); 1066 } 1067 1068 return result; 1069 } 1070 1071 int32 Oscl_File::CallNativeClose() 1072 { 1073 if (iNativeLogger) 1074 { 1075 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1076 (0, "OsclNativeFile(0x%x)::Close IN", this)); 1077 } 1078 1079 uint32 ticks = 0; 1080 if (iFileStats) 1081 iFileStats->Start(ticks); 1082 1083 int32 result = (-1); 1084 1085 if (iNativeFile) 1086 result = iNativeFile->Close(); 1087 1088 if (iFileStats 1089 && result >= 0) 1090 iFileStats->End(EOsclFileOp_NativeClose, ticks); 1091 1092 if (iNativeLogger) 1093 { 1094 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iNativeLogger, PVLOGMSG_DEBUG, 1095 (0, "OsclNativeFile(0x%x)::Close OUT result", this, result)); 1096 } 1097 1098 return result; 1099 } 1100 1101 uint32 Oscl_File::CallNativeMode() 1102 { 1103 int32 result = (-1); 1104 1105 if (iNativeFile) 1106 result = iNativeFile->Mode(); 1107 1108 return result; 1109 } 1110 1111 int32 Oscl_File::CallNativeGetError() 1112 { 1113 int32 result = (-1); 1114 1115 if (iNativeFile) 1116 result = iNativeFile->GetError(); 1117 1118 return result; 1119 } 1120 1121 OSCL_EXPORT_REF uint32 Oscl_File::GetAsyncFileNumOfRun() 1122 { 1123 if (iAsyncFile) 1124 return iAsyncFile->iNumOfRun; 1125 else 1126 return 0; 1127 } 1128 1129 OSCL_EXPORT_REF uint32 Oscl_File::GetAsyncFileNumOfRunError() 1130 { 1131 if (iAsyncFile) 1132 return iAsyncFile->iNumOfRunErr; 1133 else 1134 return 0; 1135 } 1136 1137