ACE/ace/Filecache.cpp

   1 #include "ace/Filecache.h"
   2 #include "ace/Object_Manager.h"
   3 #include "ace/Log_Category.h"
   4 #include "ace/ACE.h"
   5 #include "ace/Guard_T.h"
   6 #include "ace/OS_NS_string.h"
   7 #include "ace/OS_NS_time.h"
   8 #include "ace/OS_NS_unistd.h"
   9 #include "ace/OS_NS_fcntl.h"
  10 #include "ace/Truncate.h"
  11
  12 #if defined (ACE_WIN32)
  13 // Specifies no sharing flags.
  14 #define R_MASK ACE_DEFAULT_OPEN_PERMS
  15 #define W_MASK 0
  16 #else
  17 #define R_MASK S_IRUSR|S_IRGRP|S_IROTH
  18 #define W_MASK S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH
  19 #endif /* ACE_WIN32 */
  20
  21 #if defined (ACE_WIN32)
  22 // See if you can get rid of some of these.
  23 #define READ_FLAGS (FILE_FLAG_SEQUENTIAL_SCAN | \
  24                     FILE_FLAG_OVERLAPPED | \
  25                     O_RDONLY)
  26 // static const int RCOPY_FLAGS = (FILE_FLAG_SEQUENTIAL_SCAN |
  27 //                                 O_RDONLY);
  28 #define WRITE_FLAGS (FILE_FLAG_SEQUENTIAL_SCAN | \
  29                      FILE_FLAG_OVERLAPPED | \
  30                      O_RDWR | O_CREAT | O_TRUNC)
  31 // static const int WCOPY_FLAGS = (FILE_FLAG_SEQUENTIAL_SCAN |
  32 //                                 O_RDWR | O_CREAT | O_TRUNC);
  33 #else
  34 #define READ_FLAGS O_RDONLY
  35 // static const int RCOPY_FLAGS = O_RDONLY;
  36 #define WRITE_FLAGS (O_RDWR | O_CREAT | O_TRUNC)
  37 // static const int WCOPY_FLAGS = O_RDWR | O_CREAT | O_TRUNC;
  38 #endif /* ACE_WIN32 */
  39
  40 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  41
  42 // static data members
  43 ACE_Filecache *ACE_Filecache::cvf_ = 0;
  44
  45 void
  46 ACE_Filecache_Handle::init ()
  47 {
  48   this->file_ = 0;
  49   this->handle_ = ACE_INVALID_HANDLE;
  50 }
  51
  52 ACE_Filecache_Handle::ACE_Filecache_Handle ()
  53   : file_ (0), handle_ (0)
  54 {
  55   this->init ();
  56 }
  57
  58 ACE_Filecache_Handle::ACE_Filecache_Handle (const ACE_TCHAR *filename,
  59                                             ACE_Filecache_Flag mapit)
  60   : file_ (0), handle_ (0)
  61 {
  62   this->init ();
  63   // Fetch the file from the Virtual_Filesystem let the
  64   // Virtual_Filesystem do the work of cache coherency.
  65
  66   // Filecache will also do the acquire, since it holds the lock at
  67   // that time.
  68   this->file_ = ACE_Filecache::instance ()->fetch (filename, mapit);
  69 }
  70
  71 ACE_Filecache_Handle::ACE_Filecache_Handle (const ACE_TCHAR *filename,
  72                                             int size,
  73                                             ACE_Filecache_Flag )
  74   : file_ (0), handle_ (0)
  75 {
  76   this->init ();
  77
  78   if (size == 0)
  79     ACE_Filecache::instance ()->remove (filename);
  80   else
  81     {
  82       // Since this is being opened for a write, simply create a new
  83       // ACE_Filecache_Object now, and let the destructor add it into CVF
  84       // later
  85
  86       // Filecache will also do the acquire, since it holds the lock at
  87       // that time.
  88       this->file_ = ACE_Filecache::instance ()->create (filename, size);
  89     }
  90 }
  91
  92 ACE_Filecache_Handle::~ACE_Filecache_Handle ()
  93 {
  94   if (this->handle_ != ACE_INVALID_HANDLE)
  95     // this was dup ()'d
  96     ACE_OS::close (this->handle_);
  97
  98   ACE_Filecache::instance ()->finish (this->file_);
  99 }
 100
 101 void *
 102 ACE_Filecache_Handle::address () const
 103 {
 104   return this->file_ == 0 ? 0 : this->file_->address ();
 105 }
 106
 107 ACE_HANDLE
 108 ACE_Filecache_Handle::handle () const
 109 {
 110   if (this->handle_ == ACE_INVALID_HANDLE && this->file_ != 0)
 111     {
 112       ACE_Filecache_Handle *mutable_this =
 113         const_cast<ACE_Filecache_Handle *> (this);
 114       mutable_this->handle_ = ACE_OS::dup (this->file_->handle ());
 115     }
 116   return this->handle_;
 117 }
 118
 119 int
 120 ACE_Filecache_Handle::error () const
 121 {
 122   if (this->file_ == 0)
 123     return -1;
 124   else
 125     return this->file_->error ();
 126 }
 127
 128 ACE_OFF_T
 129 ACE_Filecache_Handle::size () const
 130 {
 131   if (this->file_ == 0)
 132     return -1;
 133   else
 134     return this->file_->size ();
 135 }
 136
 137 // ------------------
 138 // ACE_Filecache_Hash
 139 // ------------------
 140
 141 #define ACE_Filecache_Hash \
 142         ACE_Hash_Map_Manager_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
 143 #define ACE_Filecache_Hash_Entry \
 144         ACE_Hash_Map_Entry<const ACE_TCHAR *, ACE_Filecache_Object *>
 145
 146 template <>
 147 ACE_Filecache_Hash_Entry::ACE_Hash_Map_Entry (
 148   const ACE_TCHAR *const &ext_id,
 149   ACE_Filecache_Object *const &int_id,
 150   ACE_Filecache_Hash_Entry *next,
 151   ACE_Filecache_Hash_Entry *prev)
 152   : ext_id_ (ext_id
 153              ? ACE_OS::strdup (ext_id)
 154              : ACE_OS::strdup (ACE_TEXT (""))),
 155     int_id_ (int_id),
 156     next_ (next),
 157     prev_ (prev)
 158 {
 159 }
 160
 161 template <>
 162 ACE_Filecache_Hash_Entry::ACE_Hash_Map_Entry (ACE_Filecache_Hash_Entry *next,
 163                                               ACE_Filecache_Hash_Entry *prev)
 164   : ext_id_ (0),
 165     int_id_ (0),
 166     next_ (next),
 167     prev_ (prev)
 168 {
 169 }
 170
 171 template <>
 172 ACE_Filecache_Hash_Entry::~ACE_Hash_Map_Entry ()
 173 {
 174 #if defined (ACE_HAS_ALLOC_HOOKS)
 175   ACE_Allocator::instance()->free ((void *) ext_id_);
 176 #else
 177   ACE_OS::free ((void *) ext_id_);
 178 #endif /* ACE_HAS_ALLOC_HOOKS */
 179 }
 180
 181 // We need these template specializations since KEY is defined as a
 182 // ACE_TCHAR*, which doesn't have a hash() or equal() method defined on it.
 183
 184 template <>
 185 unsigned long
 186 ACE_Filecache_Hash::hash (const ACE_TCHAR *const &ext_id)
 187 {
 188   return ACE::hash_pjw (ext_id);
 189 }
 190
 191 template <>
 192 int
 193 ACE_Filecache_Hash::equal (const ACE_TCHAR *const &id1,
 194                            const ACE_TCHAR *const &id2)
 195 {
 196   return ACE_OS::strcmp (id1, id2) == 0;
 197 }
 198
 199 #undef ACE_Filecache_Hash
 200 #undef ACE_Filecache_Hash_Entry
 201
 202
 203 // -------------
 204 // ACE_Filecache
 205 // -------------
 206
 207 ACE_Filecache *
 208 ACE_Filecache::instance ()
 209 {
 210   // Double check locking pattern.
 211   if (ACE_Filecache::cvf_ == 0)
 212     {
 213       ACE_SYNCH_RW_MUTEX &lock =
 214         *ACE_Managed_Object<ACE_SYNCH_RW_MUTEX>::get_preallocated_object
 215           (ACE_Object_Manager::ACE_FILECACHE_LOCK);
 216       ACE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX, ace_mon, lock, 0);
 217
 218       // @@ James, please check each of the ACE_NEW_RETURN calls to
 219       // make sure that it is safe to return if allocation fails.
 220       if (ACE_Filecache::cvf_ == 0)
 221         ACE_NEW_RETURN (ACE_Filecache::cvf_,
 222                         ACE_Filecache,
 223                         0);
 224     }
 225
 226   return ACE_Filecache::cvf_;
 227 }
 228
 229 ACE_Filecache::ACE_Filecache ()
 230   : size_ (ACE_DEFAULT_VIRTUAL_FILESYSTEM_TABLE_SIZE),
 231     hash_ (size_)
 232 {
 233 }
 234
 235 ACE_Filecache::~ACE_Filecache ()
 236 {
 237 }
 238
 239 ACE_ALLOC_HOOK_DEFINE(ACE_Filecache)
 240
 241 ACE_Filecache_Object *
 242 ACE_Filecache::insert_i (const ACE_TCHAR *filename,
 243                          ACE_SYNCH_RW_MUTEX &filelock,
 244                          int mapit)
 245 {
 246   ACE_Filecache_Object *handle = 0;
 247
 248   if (this->hash_.find (filename, handle) == -1)
 249     {
 250       ACE_NEW_RETURN (handle,
 251                       ACE_Filecache_Object (filename, filelock, 0, mapit),
 252                       0);
 253
 254       //      ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("   (%t) CVF: creating %s\n"), filename));
 255
 256       if (this->hash_.bind (filename, handle) == -1)
 257         {
 258           delete handle;
 259           handle = 0;
 260         }
 261     }
 262   else
 263     handle = 0;
 264
 265   return handle;
 266 }
 267
 268 ACE_Filecache_Object *
 269 ACE_Filecache::remove_i (const ACE_TCHAR *filename)
 270 {
 271   ACE_Filecache_Object *handle = 0;
 272
 273   // Disassociate file from the cache.
 274   if (this->hash_.unbind (filename, handle) == 0)
 275     {
 276       handle->stale_ = 1;
 277
 278       // Try a lock.  If it succeeds, we can delete it now.
 279       // Otherwise, it will clean itself up later.
 280       if (handle->lock_.tryacquire_write () == 0)
 281         {
 282           delete handle;
 283           handle = 0;
 284         }
 285     }
 286   else
 287     handle = 0;
 288
 289   return handle;
 290 }
 291
 292 ACE_Filecache_Object *
 293 ACE_Filecache::update_i (const ACE_TCHAR *filename,
 294                          ACE_SYNCH_RW_MUTEX &filelock,
 295                          int mapit)
 296 {
 297   ACE_Filecache_Object *handle = 0;
 298
 299   handle = this->remove_i (filename);
 300   handle = this->insert_i (filename, filelock, mapit);
 301
 302   return handle;
 303 }
 304
 305 int
 306 ACE_Filecache::find (const ACE_TCHAR *filename)
 307 {
 308   return this->hash_.find (filename);
 309 }
 310
 311
 312 ACE_Filecache_Object *
 313 ACE_Filecache::remove (const ACE_TCHAR *filename)
 314 {
 315   ACE_Filecache_Object *handle = 0;
 316
 317   ACE_OFF_T loc = ACE::hash_pjw (filename) % this->size_;
 318   ACE_SYNCH_RW_MUTEX &hashlock = this->hash_lock_[loc];
 319   // ACE_SYNCH_RW_MUTEX &filelock = this->file_lock_[loc];
 320
 321   if (this->hash_.find (filename, handle) != -1)
 322     {
 323       ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX,
 324                               ace_mon,
 325                               hashlock,
 326                               0);
 327
 328       return this->remove_i (filename);
 329     }
 330
 331   return 0;
 332 }
 333
 334
 335 ACE_Filecache_Object *
 336 ACE_Filecache::fetch (const ACE_TCHAR *filename, int mapit)
 337 {
 338   ACE_Filecache_Object *handle = 0;
 339
 340   ACE_OFF_T loc = ACE::hash_pjw (filename) % this->size_;
 341   ACE_SYNCH_RW_MUTEX &hashlock = this->hash_lock_[loc];
 342   ACE_SYNCH_RW_MUTEX &filelock = this->file_lock_[loc];
 343
 344   filelock.acquire_read ();
 345
 346   if (this->hash_.find (filename, handle) == -1)
 347     {
 348       ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX,
 349                               ace_mon,
 350                               hashlock,
 351                               0);
 352
 353       // Second check in the method call
 354       handle = this->insert_i (filename, filelock, mapit);
 355
 356       if (handle == 0)
 357         filelock.release ();
 358     }
 359   else
 360     {
 361       if (handle->update ())
 362         {
 363           {
 364             // Double check locking pattern
 365             ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX,
 366                                     ace_mon,
 367                                     hashlock,
 368                                     0);
 369
 370             // Second check in the method call
 371             handle = this->update_i (filename, filelock, mapit);
 372
 373             if (handle == 0)
 374               filelock.release ();
 375           }
 376         }
 377       //      ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("   (%t) CVF: found %s\n"), filename));
 378     }
 379
 380   return handle;
 381 }
 382
 383 ACE_Filecache_Object *
 384 ACE_Filecache::create (const ACE_TCHAR *filename, int size)
 385 {
 386   ACE_Filecache_Object *handle = 0;
 387
 388   ACE_OFF_T loc = ACE::hash_pjw (filename) % this->size_;
 389   ACE_SYNCH_RW_MUTEX &filelock = this->file_lock_[loc];
 390
 391   ACE_NEW_RETURN (handle,
 392                   ACE_Filecache_Object (filename, size, filelock),
 393                   0);
 394   handle->acquire ();
 395
 396   return handle;
 397 }
 398
 399 ACE_Filecache_Object *
 400 ACE_Filecache::finish (ACE_Filecache_Object *&file)
 401 {
 402   if (file == 0)
 403     return file;
 404
 405   ACE_OFF_T loc = ACE::hash_pjw (file->filename_) % this->size_;
 406   ACE_SYNCH_RW_MUTEX &hashlock = this->hash_lock_[loc];
 407
 408   if (file != 0)
 409     switch (file->action_)
 410       {
 411       case ACE_Filecache_Object::ACE_WRITING:
 412         {
 413           ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX,
 414                                   ace_mon,
 415                                   hashlock,
 416                                   0);
 417
 418           file->release ();
 419
 420           this->remove_i (file->filename_);
 421 #if 0
 422           int result = this->hash_.bind (file->filename (), file);
 423
 424           if (result == 0)
 425             file->acquire ();
 426 #else
 427         // Last one using a stale file is resposible for deleting it.
 428         if (file->stale_)
 429           {
 430             // Try a lock.  If it succeds, we can delete it now.
 431             // Otherwise, it will clean itself up later.
 432             if (file->lock_.tryacquire_write () == 0)
 433               {
 434                 delete file;
 435                 file = 0;
 436               }
 437           }
 438 #endif
 439         }
 440
 441         break;
 442       default:
 443         file->release ();
 444
 445         // Last one using a stale file is resposible for deleting it.
 446         if (file->stale_)
 447           {
 448             // Try a lock.  If it succeds, we can delete it now.
 449             // Otherwise, it will clean itself up later.
 450             if (file->lock_.tryacquire_write () == 0)
 451               {
 452                 delete file;
 453                 file = 0;
 454               }
 455           }
 456
 457         break;
 458       }
 459
 460   return file;
 461 }
 462
 463 void
 464 ACE_Filecache_Object::init ()
 465 {
 466   this->filename_[0] = '\0';
 467   this->handle_ = ACE_INVALID_HANDLE;
 468   this->error_ = ACE_SUCCESS;
 469   this->tempname_ = 0;
 470   this->size_ = 0;
 471
 472   ACE_OS::memset (&(this->stat_), 0, sizeof (this->stat_));
 473 }
 474
 475 ACE_Filecache_Object::ACE_Filecache_Object ()
 476   : tempname_ (0),
 477     mmap_ (),
 478     handle_ (0),
 479     // stat_ (),
 480     size_ (0),
 481     action_ (0),
 482     error_ (0),
 483     stale_ (0),
 484     // sa_ (),
 485     junklock_ (),
 486     lock_ (junklock_)
 487 {
 488   this->init ();
 489 }
 490
 491 ACE_Filecache_Object::ACE_Filecache_Object (const ACE_TCHAR *filename,
 492                                             ACE_SYNCH_RW_MUTEX &lock,
 493                                             LPSECURITY_ATTRIBUTES sa,
 494                                             int mapit)
 495   : tempname_ (0),
 496     mmap_ (),
 497     handle_ (0),
 498     // stat_ (),
 499     size_ (0),
 500     action_ (0),
 501     error_ (0),
 502     stale_ (0),
 503     sa_ (sa),
 504     junklock_ (),
 505     lock_ (lock)
 506 {
 507   this->init ();
 508
 509   // ASSERT strlen(filename) < sizeof (this->filename_)
 510   ACE_OS::strcpy (this->filename_, filename);
 511   this->action_ = ACE_Filecache_Object::ACE_READING;
 512   // place ourselves into the READING state
 513
 514   // Can we access the file?
 515   if (ACE_OS::access (this->filename_, R_OK) == -1)
 516     {
 517       this->error_i (ACE_Filecache_Object::ACE_ACCESS_FAILED);
 518       return;
 519     }
 520
 521   // Can we stat the file?
 522   if (ACE_OS::stat (this->filename_, &this->stat_) == -1)
 523     {
 524       this->error_i (ACE_Filecache_Object::ACE_STAT_FAILED);
 525       return;
 526     }
 527
 528   this->size_ = ACE_Utils::truncate_cast<ACE_OFF_T> (this->stat_.st_size);
 529   this->tempname_ = this->filename_;
 530
 531   // Can we open the file?
 532   this->handle_ = ACE_OS::open (this->tempname_,
 533                                 READ_FLAGS, R_MASK, this->sa_);
 534   if (this->handle_ == ACE_INVALID_HANDLE)
 535     {
 536       this->error_i (ACE_Filecache_Object::ACE_OPEN_FAILED,
 537                      ACE_TEXT ("ACE_Filecache_Object::ctor: open"));
 538       return;
 539     }
 540
 541   if (mapit)
 542     {
 543       // Can we map the file?
 544       if (this->mmap_.map (this->handle_, static_cast<size_t> (-1),
 545                            PROT_READ, ACE_MAP_PRIVATE, 0, 0, this->sa_) != 0)
 546         {
 547           this->error_i (ACE_Filecache_Object::ACE_MEMMAP_FAILED,
 548                          ACE_TEXT ("ACE_Filecache_Object::ctor: map"));
 549           ACE_OS::close (this->handle_);
 550           this->handle_ = ACE_INVALID_HANDLE;
 551           return;
 552         }
 553     }
 554
 555    // Ok, finished!
 556    this->action_ = ACE_Filecache_Object::ACE_READING;
 557 }
 558
 559 ACE_Filecache_Object::ACE_Filecache_Object (const ACE_TCHAR *filename,
 560                                             ACE_OFF_T size,
 561                                             ACE_SYNCH_RW_MUTEX &lock,
 562                                             LPSECURITY_ATTRIBUTES sa)
 563   : stale_ (0),
 564     sa_ (sa),
 565     lock_ (lock)
 566 {
 567   this->init ();
 568
 569   this->size_ = size;
 570   ACE_OS::strcpy (this->filename_, filename);
 571   this->action_ = ACE_Filecache_Object::ACE_WRITING;
 572
 573   // Can we access the file?
 574   if (ACE_OS::access (this->filename_, R_OK|W_OK) == -1
 575       // Does it exist?
 576       && ACE_OS::access (this->filename_, F_OK) != -1)
 577     {
 578       // File exists, but we cannot access it.
 579       this->error_i (ACE_Filecache_Object::ACE_ACCESS_FAILED);
 580       return;
 581     }
 582
 583   this->tempname_ = this->filename_;
 584
 585   // Can we open the file?
 586   this->handle_ = ACE_OS::open (this->tempname_, WRITE_FLAGS, W_MASK, this->sa_);
 587   if (this->handle_ == ACE_INVALID_HANDLE)
 588     {
 589       this->error_i (ACE_Filecache_Object::ACE_OPEN_FAILED,
 590                      ACE_TEXT ("ACE_Filecache_Object::acquire: open"));
 591       return;
 592     }
 593
 594   // Can we write?
 595   if (ACE_OS::pwrite (this->handle_, "", 1, this->size_ - 1) != 1)
 596     {
 597       this->error_i (ACE_Filecache_Object::ACE_WRITE_FAILED,
 598                      ACE_TEXT ("ACE_Filecache_Object::acquire: write"));
 599       ACE_OS::close (this->handle_);
 600       return;
 601     }
 602
 603   // Can we map?
 604   if (this->mmap_.map (this->handle_, this->size_, PROT_RDWR, MAP_SHARED,
 605                        0, 0, this->sa_) != 0)
 606     {
 607       this->error_i (ACE_Filecache_Object::ACE_MEMMAP_FAILED,
 608                      ACE_TEXT ("ACE_Filecache_Object::acquire: map"));
 609       ACE_OS::close (this->handle_);
 610     }
 611
 612   // Ok, done!
 613 }
 614
 615 ACE_Filecache_Object::~ACE_Filecache_Object ()
 616 {
 617   if (this->error_ == ACE_SUCCESS)
 618     {
 619       this->mmap_.unmap ();
 620       ACE_OS::close (this->handle_);
 621       this->handle_ = ACE_INVALID_HANDLE;
 622     }
 623
 624   this->lock_.release ();
 625 }
 626
 627 ACE_ALLOC_HOOK_DEFINE(ACE_Filecache_Object)
 628
 629 int
 630 ACE_Filecache_Object::acquire ()
 631 {
 632   return this->lock_.tryacquire_read ();
 633 }
 634
 635 int
 636 ACE_Filecache_Object::release ()
 637 {
 638   if (this->action_ == ACE_WRITING)
 639     {
 640       // We are safe since only one thread has a writable Filecache_Object
 641
 642 #if 0
 643       ACE_HANDLE original = ACE_OS::open (this->filename_, WRITE_FLAGS, W_MASK,
 644                                           this->sa_);
 645       if (original == ACE_INVALID_HANDLE)
 646         this->error_ = ACE_Filecache_Object::ACE_OPEN_FAILED;
 647       else if (ACE_OS::write (original, this->mmap_.addr (),
 648                               this->size_) == -1)
 649         {
 650           this->error_ = ACE_Filecache_Object::ACE_WRITE_FAILED;
 651           ACE_OS::close (original);
 652           ACE_OS::unlink (this->filename_);
 653         }
 654       else if (ACE_OS::stat (this->filename_, &this->stat_) == -1)
 655         this->error_ = ACE_Filecache_Object::ACE_STAT_FAILED;
 656 #endif
 657
 658       this->mmap_.unmap ();
 659       ACE_OS::close (this->handle_);
 660       this->handle_ = ACE_INVALID_HANDLE;
 661
 662 #if 0
 663       // Leave the file in an acquirable state.
 664       this->handle_ = ACE_OS::open (this->tempname_, READ_FLAGS, R_MASK);
 665       if (this->handle_ == ACE_INVALID_HANDLE)
 666         {
 667           this->error_i (ACE_Filecache_Object::ACE_OPEN_FAILED,
 668                          "ACE_Filecache_Object::acquire: open");
 669         }
 670       else if (this->mmap_.map (this->handle_, -1,
 671                                 PROT_READ,
 672                                 ACE_MAP_PRIVATE,
 673                                 0,
 674                                 0,
 675                                 this->sa_) != 0)
 676         {
 677           this->error_i (ACE_Filecache_Object::ACE_MEMMAP_FAILED,
 678                          "ACE_Filecache_Object::acquire: map");
 679           ACE_OS::close (this->handle_);
 680           this->handle_ = ACE_INVALID_HANDLE;
 681         }
 682
 683       this->action_ = ACE_Filecache_Object::ACE_READING;
 684 #endif
 685     }
 686
 687   return this->lock_.release ();
 688 }
 689
 690 int
 691 ACE_Filecache_Object::error () const
 692 {
 693   // The existence of the object means a read lock is being held.
 694   return this->error_;
 695 }
 696
 697 int
 698 ACE_Filecache_Object::error_i (int error_value, const ACE_TCHAR *s)
 699 {
 700   ACE_UNUSED_ARG (s);
 701   ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), s));
 702   this->error_ = error_value;
 703   return error_value;
 704 }
 705
 706 const ACE_TCHAR *
 707 ACE_Filecache_Object::filename () const
 708 {
 709   // The existence of the object means a read lock is being held.
 710   return this->filename_;
 711 }
 712
 713 ACE_OFF_T
 714 ACE_Filecache_Object::size () const
 715 {
 716   // The existence of the object means a read lock is being held.
 717   return this->size_;
 718 }
 719
 720 ACE_HANDLE
 721 ACE_Filecache_Object::handle () const
 722 {
 723   // The existence of the object means a read lock is being held.
 724   return this->handle_;
 725 }
 726
 727 void *
 728 ACE_Filecache_Object::address () const
 729 {
 730   // The existence of the object means a read lock is being held.
 731   return this->mmap_.addr ();
 732 }
 733
 734 int
 735 ACE_Filecache_Object::update () const
 736 {
 737   // The existence of the object means a read lock is being held.
 738   int result;
 739   ACE_stat statbuf;
 740
 741   if (ACE_OS::stat (this->filename_, &statbuf) == -1)
 742     result = 1;
 743   else
 744     result = ACE_OS::difftime (this->stat_.st_mtime, statbuf.st_mtime) < 0;
 745
 746   return result;
 747 }
 748
 749 ACE_END_VERSIONED_NAMESPACE_DECL