xbmc/filesystem/CacheStrategy.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "threads/SystemClock.h"
  10 #include "CacheStrategy.h"
  11 #include "IFile.h"
  12 #ifdef TARGET_POSIX
  13 #include "PlatformDefs.h"
  14 #include "platform/posix/ConvUtils.h"
  15 #endif
  16 #include "Util.h"
  17 #include "utils/log.h"
  18 #include "SpecialProtocol.h"
  19 #include "URL.h"
  20 #if defined(TARGET_POSIX)
  21 #include "platform/posix/filesystem/PosixFile.h"
  22 #define CacheLocalFile CPosixFile
  23 #elif defined(TARGET_WINDOWS)
  24 #include "platform/win32/filesystem/Win32File.h"
  25 #define CacheLocalFile CWin32File
  26 #endif // TARGET_WINDOWS
  27
  28 #include <cassert>
  29 #include <algorithm>
  30
  31 using namespace XFILE;
  32
  33 using namespace std::chrono_literals;
  34
  35 CCacheStrategy::~CCacheStrategy() = default;
  36
  37 void CCacheStrategy::EndOfInput() {
  38   m_bEndOfInput = true;
  39 }
  40
  41 bool CCacheStrategy::IsEndOfInput()
  42 {
  43   return m_bEndOfInput;
  44 }
  45
  46 void CCacheStrategy::ClearEndOfInput()
  47 {
  48   m_bEndOfInput = false;
  49 }
  50
  51 CSimpleFileCache::CSimpleFileCache()
  52   : m_cacheFileRead(new CacheLocalFile())
  53   , m_cacheFileWrite(new CacheLocalFile())
  54   , m_hDataAvailEvent(NULL)
  55 {
  56 }
  57
  58 CSimpleFileCache::~CSimpleFileCache()
  59 {
  60   Close();
  61   delete m_cacheFileRead;
  62   delete m_cacheFileWrite;
  63 }
  64
  65 int CSimpleFileCache::Open()
  66 {
  67   Close();
  68
  69   m_hDataAvailEvent = new CEvent;
  70
  71   m_filename = CSpecialProtocol::TranslatePath(
  72       CUtil::GetNextFilename("special://temp/filecache{:03}.cache", 999));
  73   if (m_filename.empty())
  74   {
  75     CLog::Log(LOGERROR, "CSimpleFileCache::{} - Unable to generate a new filename", __FUNCTION__);
  76     Close();
  77     return CACHE_RC_ERROR;
  78   }
  79
  80   CURL fileURL(m_filename);
  81
  82   if (!m_cacheFileWrite->OpenForWrite(fileURL, false))
  83   {
  84     CLog::Log(LOGERROR, "CSimpleFileCache::{} - Failed to create file \"{}\" for writing",
  85               __FUNCTION__, m_filename);
  86     Close();
  87     return CACHE_RC_ERROR;
  88   }
  89
  90   if (!m_cacheFileRead->Open(fileURL))
  91   {
  92     CLog::Log(LOGERROR, "CSimpleFileCache::{} - Failed to open file \"{}\" for reading",
  93               __FUNCTION__, m_filename);
  94     Close();
  95     return CACHE_RC_ERROR;
  96   }
  97
  98   return CACHE_RC_OK;
  99 }
 100
 101 void CSimpleFileCache::Close()
 102 {
 103   if (m_hDataAvailEvent)
 104     delete m_hDataAvailEvent;
 105
 106   m_hDataAvailEvent = NULL;
 107
 108   m_cacheFileWrite->Close();
 109   m_cacheFileRead->Close();
 110
 111   if (!m_filename.empty() && !m_cacheFileRead->Delete(CURL(m_filename)))
 112     CLog::Log(LOGWARNING, "SimpleFileCache::{} - Failed to delete cache file \"{}\"", __FUNCTION__,
 113               m_filename);
 114
 115   m_filename.clear();
 116 }
 117
 118 size_t CSimpleFileCache::GetMaxWriteSize(const size_t& iRequestSize)
 119 {
 120   return iRequestSize; // Can always write since it's on disk
 121 }
 122
 123 int CSimpleFileCache::WriteToCache(const char *pBuffer, size_t iSize)
 124 {
 125   size_t written = 0;
 126   while (iSize > 0)
 127   {
 128     const ssize_t lastWritten =
 129         m_cacheFileWrite->Write(pBuffer, std::min(iSize, static_cast<size_t>(SSIZE_MAX)));
 130     if (lastWritten <= 0)
 131     {
 132       CLog::Log(LOGERROR, "SimpleFileCache::{} - <{}> Failed to write to cache", __FUNCTION__,
 133                 m_filename);
 134       return CACHE_RC_ERROR;
 135     }
 136     m_nWritePosition += lastWritten;
 137     iSize -= lastWritten;
 138     written += lastWritten;
 139   }
 140
 141   // when reader waits for data it will wait on the event.
 142   m_hDataAvailEvent->Set();
 143
 144   return written;
 145 }
 146
 147 int64_t CSimpleFileCache::GetAvailableRead()
 148 {
 149   return m_nWritePosition - m_nReadPosition;
 150 }
 151
 152 int CSimpleFileCache::ReadFromCache(char *pBuffer, size_t iMaxSize)
 153 {
 154   int64_t iAvailable = GetAvailableRead();
 155   if ( iAvailable <= 0 )
 156     return m_bEndOfInput ? 0 : CACHE_RC_WOULD_BLOCK;
 157
 158   size_t toRead = std::min(iMaxSize, static_cast<size_t>(iAvailable));
 159
 160   size_t readBytes = 0;
 161   while (toRead > 0)
 162   {
 163     const ssize_t lastRead =
 164       m_cacheFileRead->Read(pBuffer, std::min(toRead, static_cast<size_t>(SSIZE_MAX)));
 165
 166     if (lastRead == 0)
 167       break;
 168     if (lastRead < 0)
 169     {
 170       CLog::Log(LOGERROR, "CSimpleFileCache::{} - <{}> Failed to read from cache", __FUNCTION__,
 171                 m_filename);
 172       return CACHE_RC_ERROR;
 173     }
 174     m_nReadPosition += lastRead;
 175     toRead -= lastRead;
 176     readBytes += lastRead;
 177   }
 178
 179   if (readBytes > 0)
 180     m_space.Set();
 181
 182   return readBytes;
 183 }
 184
 185 int64_t CSimpleFileCache::WaitForData(uint32_t iMinAvail, std::chrono::milliseconds timeout)
 186 {
 187   if (timeout == 0ms || IsEndOfInput())
 188     return GetAvailableRead();
 189
 190   XbmcThreads::EndTime<> endTime{timeout};
 191   while (!IsEndOfInput())
 192   {
 193     int64_t iAvail = GetAvailableRead();
 194     if (iAvail >= iMinAvail)
 195       return iAvail;
 196
 197     if (!m_hDataAvailEvent->Wait(endTime.GetTimeLeft()))
 198       return CACHE_RC_TIMEOUT;
 199   }
 200   return GetAvailableRead();
 201 }
 202
 203 int64_t CSimpleFileCache::Seek(int64_t iFilePosition)
 204 {
 205   int64_t iTarget = iFilePosition - m_nStartPosition;
 206
 207   if (iTarget < 0)
 208   {
 209     CLog::Log(LOGDEBUG, "CSimpleFileCache::{} - <{}> Request seek to {} before start of cache",
 210               __FUNCTION__, iFilePosition, m_filename);
 211     return CACHE_RC_ERROR;
 212   }
 213
 214   int64_t nDiff = iTarget - m_nWritePosition;
 215   if (nDiff > 500000)
 216   {
 217     CLog::Log(LOGDEBUG,
 218               "CSimpleFileCache::{} - <{}> Requested position {} is beyond cached data ({})",
 219               __FUNCTION__, m_filename, iFilePosition, m_nWritePosition);
 220     return CACHE_RC_ERROR;
 221   }
 222
 223   if (nDiff > 0 &&
 224       WaitForData(static_cast<uint32_t>(iTarget - m_nReadPosition), 5s) == CACHE_RC_TIMEOUT)
 225   {
 226     CLog::Log(LOGDEBUG, "CSimpleFileCache::{} - <{}> Wait for position {} failed. Ended up at {}",
 227               __FUNCTION__, m_filename, iFilePosition, m_nWritePosition);
 228     return CACHE_RC_ERROR;
 229   }
 230
 231   m_nReadPosition = m_cacheFileRead->Seek(iTarget, SEEK_SET);
 232   if (m_nReadPosition != iTarget)
 233   {
 234     CLog::Log(LOGERROR, "CSimpleFileCache::{} - <{}> Can't seek cache file for position {}",
 235               __FUNCTION__, iFilePosition, m_filename);
 236     return CACHE_RC_ERROR;
 237   }
 238
 239   m_space.Set();
 240
 241   return iFilePosition;
 242 }
 243
 244 bool CSimpleFileCache::Reset(int64_t iSourcePosition)
 245 {
 246   if (IsCachedPosition(iSourcePosition))
 247   {
 248     m_nReadPosition = m_cacheFileRead->Seek(iSourcePosition - m_nStartPosition, SEEK_SET);
 249     return false;
 250   }
 251
 252   m_nStartPosition = iSourcePosition;
 253   m_nWritePosition = m_cacheFileWrite->Seek(0, SEEK_SET);
 254   m_nReadPosition = m_cacheFileRead->Seek(0, SEEK_SET);
 255   return true;
 256 }
 257
 258 void CSimpleFileCache::EndOfInput()
 259 {
 260   CCacheStrategy::EndOfInput();
 261   m_hDataAvailEvent->Set();
 262 }
 263
 264 int64_t CSimpleFileCache::CachedDataEndPosIfSeekTo(int64_t iFilePosition)
 265 {
 266   if (iFilePosition >= m_nStartPosition && iFilePosition <= m_nStartPosition + m_nWritePosition)
 267     return m_nStartPosition + m_nWritePosition;
 268   return iFilePosition;
 269 }
 270
 271 int64_t CSimpleFileCache::CachedDataStartPos()
 272 {
 273   return m_nStartPosition;
 274 }
 275
 276 int64_t CSimpleFileCache::CachedDataEndPos()
 277 {
 278   return m_nStartPosition + m_nWritePosition;
 279 }
 280
 281 bool CSimpleFileCache::IsCachedPosition(int64_t iFilePosition)
 282 {
 283   return iFilePosition >= m_nStartPosition && iFilePosition <= m_nStartPosition + m_nWritePosition;
 284 }
 285
 286 CCacheStrategy *CSimpleFileCache::CreateNew()
 287 {
 288   return new CSimpleFileCache();
 289 }
 290
 291
 292 CDoubleCache::CDoubleCache(CCacheStrategy *impl)
 293 {
 294   assert(NULL != impl);
 295   m_pCache = impl;
 296   m_pCacheOld = NULL;
 297 }
 298
 299 CDoubleCache::~CDoubleCache()
 300 {
 301   delete m_pCache;
 302   delete m_pCacheOld;
 303 }
 304
 305 int CDoubleCache::Open()
 306 {
 307   return m_pCache->Open();
 308 }
 309
 310 void CDoubleCache::Close()
 311 {
 312   m_pCache->Close();
 313   if (m_pCacheOld)
 314   {
 315     delete m_pCacheOld;
 316     m_pCacheOld = NULL;
 317   }
 318 }
 319
 320 size_t CDoubleCache::GetMaxWriteSize(const size_t& iRequestSize)
 321 {
 322   return m_pCache->GetMaxWriteSize(iRequestSize); // NOTE: Check the active cache only
 323 }
 324
 325 int CDoubleCache::WriteToCache(const char *pBuffer, size_t iSize)
 326 {
 327   return m_pCache->WriteToCache(pBuffer, iSize);
 328 }
 329
 330 int CDoubleCache::ReadFromCache(char *pBuffer, size_t iMaxSize)
 331 {
 332   return m_pCache->ReadFromCache(pBuffer, iMaxSize);
 333 }
 334
 335 int64_t CDoubleCache::WaitForData(uint32_t iMinAvail, std::chrono::milliseconds timeout)
 336 {
 337   return m_pCache->WaitForData(iMinAvail, timeout);
 338 }
 339
 340 int64_t CDoubleCache::Seek(int64_t iFilePosition)
 341 {
 342   /* Check whether position is NOT in our current cache but IS in our old cache.
 343    * This is faster/more efficient than having to possibly wait for data in the
 344    * Seek() call below
 345    */
 346   if (!m_pCache->IsCachedPosition(iFilePosition) &&
 347        m_pCacheOld && m_pCacheOld->IsCachedPosition(iFilePosition))
 348   {
 349     // Return error to trigger a seek event which will swap the caches:
 350     return CACHE_RC_ERROR;
 351   }
 352
 353   return m_pCache->Seek(iFilePosition); // Normal seek
 354 }
 355
 356 bool CDoubleCache::Reset(int64_t iSourcePosition)
 357 {
 358   /* Check if we should (not) swap the caches. Note that when both caches have the
 359    * requested position, we prefer the cache that has the most forward data
 360    */
 361   if (m_pCache->IsCachedPosition(iSourcePosition) &&
 362       (!m_pCacheOld || !m_pCacheOld->IsCachedPosition(iSourcePosition) ||
 363        m_pCache->CachedDataEndPos() >= m_pCacheOld->CachedDataEndPos()))
 364   {
 365     // No swap: Just use current cache
 366     return m_pCache->Reset(iSourcePosition);
 367   }
 368
 369   // Need to swap caches
 370   CCacheStrategy* pCacheTmp;
 371   if (!m_pCacheOld)
 372   {
 373     pCacheTmp = m_pCache->CreateNew();
 374     if (pCacheTmp->Open() != CACHE_RC_OK)
 375     {
 376       delete pCacheTmp;
 377       return m_pCache->Reset(iSourcePosition);
 378     }
 379   }
 380   else
 381   {
 382     pCacheTmp = m_pCacheOld;
 383   }
 384
 385   // Perform actual swap:
 386   m_pCacheOld = m_pCache;
 387   m_pCache = pCacheTmp;
 388
 389   // If new active cache still doesn't have this position, log it
 390   if (!m_pCache->IsCachedPosition(iSourcePosition))
 391   {
 392     CLog::Log(LOGDEBUG, "CDoubleCache::{} - ({}) Cache miss for {} with new={}-{} and old={}-{}",
 393               __FUNCTION__, fmt::ptr(this), iSourcePosition, m_pCache->CachedDataStartPos(),
 394               m_pCache->CachedDataEndPos(), m_pCacheOld->CachedDataStartPos(),
 395               m_pCacheOld->CachedDataEndPos());
 396   }
 397
 398   return m_pCache->Reset(iSourcePosition);
 399 }
 400
 401 void CDoubleCache::EndOfInput()
 402 {
 403   m_pCache->EndOfInput();
 404 }
 405
 406 bool CDoubleCache::IsEndOfInput()
 407 {
 408   return m_pCache->IsEndOfInput();
 409 }
 410
 411 void CDoubleCache::ClearEndOfInput()
 412 {
 413   m_pCache->ClearEndOfInput();
 414 }
 415
 416 int64_t CDoubleCache::CachedDataStartPos()
 417 {
 418   return m_pCache->CachedDataStartPos();
 419 }
 420
 421 int64_t CDoubleCache::CachedDataEndPos()
 422 {
 423   return m_pCache->CachedDataEndPos();
 424 }
 425
 426 int64_t CDoubleCache::CachedDataEndPosIfSeekTo(int64_t iFilePosition)
 427 {
 428   /* Return the position on source we would end up after a cache-seek(/reset)
 429    * Note that we select the cache that has the most forward data already cached
 430    * for this position
 431    */
 432   int64_t ret = m_pCache->CachedDataEndPosIfSeekTo(iFilePosition);
 433   if (m_pCacheOld)
 434     return std::max(ret, m_pCacheOld->CachedDataEndPosIfSeekTo(iFilePosition));
 435   return ret;
 436 }
 437
 438 bool CDoubleCache::IsCachedPosition(int64_t iFilePosition)
 439 {
 440   return m_pCache->IsCachedPosition(iFilePosition) || (m_pCacheOld && m_pCacheOld->IsCachedPosition(iFilePosition));
 441 }
 442
 443 CCacheStrategy *CDoubleCache::CreateNew()
 444 {
 445   return new CDoubleCache(m_pCache->CreateNew());
 446 }
 447