XrdPfc.hh

Go to the documentation of this file.

#ifndef __XRDPFC_CACHE_HH__
#define __XRDPFC_CACHE_HH__
//----------------------------------------------------------------------------------
// Copyright (c) 2014 by Board of Trustees of the Leland Stanford, Jr., University
// Author: Alja Mrak-Tadel, Matevz Tadel, Brian Bockelman
//----------------------------------------------------------------------------------
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY emacs WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------------
#include <string>
#include <list>
#include <map>
#include <set>
 
#include "Xrd/XrdScheduler.hh"
#include "XrdVersion.hh"
#include "XrdSys/XrdSysPthread.hh"
#include "XrdOuc/XrdOucCache.hh"
#include "XrdOuc/XrdOucCallBack.hh"
 
#include "XrdCl/XrdClURL.hh"
 
#include "XrdPfcFile.hh"
#include "XrdPfcDecision.hh"
 
class XrdOss;
class XrdOucStream;
class XrdSysError;
class XrdSysTrace;
class XrdXrootdGStream;
 
namespace XrdPfc
{
class File;
class IO;
class PurgePin;
class ResourceMonitor;
 
 
template<class MOO>
struct MutexHolder {
   MOO &mutex;
   MutexHolder(MOO &m) : mutex(m) { mutex.Lock(); }
   ~MutexHolder() { mutex.UnLock(); }
};
}
 
 
namespace XrdPfc
{
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
struct Configuration
{
   Configuration();
 
   bool are_file_usage_limits_set()    const { return m_fileUsageMax > 0; }
   bool is_age_based_purge_in_effect() const { return m_purgeColdFilesAge > 0 ; }
   bool is_uvkeep_purge_in_effect()    const { return m_cs_UVKeep >= 0; }
   bool is_dir_stat_reporting_on()     const { return m_dirStatsStoreDepth >= 0 || ! m_dirStatsDirs.empty() || ! m_dirStatsDirGlobs.empty(); }
   bool is_purge_plugin_set_up()       const { return false; }
 
   CkSumCheck_e get_cs_Chk() const { return (CkSumCheck_e) m_cs_Chk; }
 
   bool is_cschk_cache() const { return m_cs_Chk & CSChk_Cache; }
   bool is_cschk_net()   const { return m_cs_Chk & CSChk_Net;   }
   bool is_cschk_any()   const { return m_cs_Chk & CSChk_Both;  }
   bool is_cschk_both()  const { return (m_cs_Chk & CSChk_Both) == CSChk_Both; }
 
   bool does_cschk_have_missing_bits(CkSumCheck_e cks_on_file) const { return m_cs_Chk & ~cks_on_file; }
 
   bool should_uvkeep_purge(time_t delta) const { return m_cs_UVKeep >= 0 && delta > m_cs_UVKeep; }
 
   bool m_write_through;                
   bool m_hdfsmode;                     
   bool m_allow_xrdpfc_command;         
 
   std::string m_username;              
   std::string m_data_space;            
   std::string m_meta_space;            
 
   long long m_diskTotalSpace;          
   long long m_diskUsageLWM;            
   long long m_diskUsageHWM;            
   long long m_fileUsageBaseline;       
   long long m_fileUsageNominal;        
   long long m_fileUsageMax;            
   int       m_purgeInterval;           
   int       m_purgeColdFilesAge;       
   int       m_purgeAgeBasedPeriod;     
   int       m_accHistorySize;          
 
   std::set<std::string> m_dirStatsDirs;     
   std::set<std::string> m_dirStatsDirGlobs; 
   int       m_dirStatsInterval;        
   int       m_dirStatsStoreDepth;      
 
   long long m_bufferSize;              
   long long m_RamAbsAvailable;         
   int       m_RamKeepStdBlocks;        
   int       m_wqueue_blocks;           
   int       m_wqueue_threads;          
   int       m_prefetch_max_blocks;     
 
   long long m_cgi_min_bufferSize = 0;          
   long long m_cgi_max_bufferSize = 0;          
   int       m_cgi_min_prefetch_max_blocks = 0; 
   int       m_cgi_max_prefetch_max_blocks = 0; 
   bool      m_cgi_blocksize_allowed = false;   
   bool      m_cgi_prefetch_allowed  = false;   
 
   long long m_hdfsbsize;               
   long long m_flushCnt;                
 
   time_t    m_cs_UVKeep;               
   int       m_cs_Chk;                  
   bool      m_cs_ChkTLS;               
 
   long long m_onlyIfCachedMinSize;     
   double    m_onlyIfCachedMinFrac;     
 
   static constexpr long long s_min_bufferSize = 4 * 1024;
   static constexpr long long s_max_bufferSize = 512 * 1024 * 1024;
 
   static constexpr int s_max_prefetch_max_blocks = 4096;
 
   bool      m_httpcc;                  
   bool      m_qfsredir;                
};
 
//------------------------------------------------------------------------------
 
struct TmpConfiguration
{
   std::string m_diskUsageLWM;
   std::string m_diskUsageHWM;
   std::string m_fileUsageBaseline;
   std::string m_fileUsageNominal;
   std::string m_fileUsageMax;
   std::string m_flushRaw;
 
   TmpConfiguration() :
      m_diskUsageLWM("0.90"), m_diskUsageHWM("0.95"),
      m_flushRaw("")
   {}
};
 
//------------------------------------------------------------------------------
 
struct snprintf_wrapper {
   std::vector<char> f_string;
   size_t            f_pos;
   std::string       f_exc_prefix;
 
   static const size_t s_MAX_SIZE;
 
   snprintf_wrapper(const std::string& exc_prefix, int size = 1024);
 
   void operator()(const char *fmt, ...);
 
   const char* c_str() const { return f_string.data(); }
};
 
//==============================================================================
// Cache
//==============================================================================
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
class Cache : public XrdOucCache
{
public:
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   Cache(XrdSysLogger *logger, XrdOucEnv *env);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   using XrdOucCache::Attach;
 
   virtual XrdOucCacheIO *Attach(XrdOucCacheIO *, int Options = 0);
 
   //---------------------------------------------------------------------
   // Virtual function of XrdOucCache. Used for redirection to a local
   // file on a distributed FS.
   virtual int LocalFilePath(const char *url, char *buff=0, int blen=0,
                             LFP_Reason why=ForAccess, bool forall=false);
 
   //---------------------------------------------------------------------
   // Virtual function of XrdOucCache. Used for deferred open.
   virtual int  Prepare(const char *url, int oflags, mode_t mode);
 
   // virtual function of XrdOucCache.
   virtual int  Stat(const char *url, struct stat &sbuff);
 
   // virtual function of XrdOucCache.
   virtual int  Unlink(const char *url);
 
   //---------------------------------------------------------------------
   //  Used by PfcFstcl::Fsctl function.
   //  Test if file is cached taking in onlyifcached configuration parameters.
   //---------------------------------------------------------------------
   virtual int ConsiderCached(const char *url);
 
   bool DecideIfConsideredCached(long long file_size, long long bytes_on_disk);
   void WriteCacheControlXAttr(int cinfo_fd, const char* path, const std::string& cc);
   void WriteFileSizeXAttr(int cinfo_fd, long long file_size);
   long long DetermineFullFileSize(const std::string &cinfo_fname);
   int GetCacheControlXAttr(const std::string &cinfo_fname, std::string& res) const;
   int GetCacheControlXAttr(int fd, std::string& res) const;
 
 
   //--------------------------------------------------------------------
   //--------------------------------------------------------------------
   bool Decide(XrdOucCacheIO*);
 
   //------------------------------------------------------------------------
   //------------------------------------------------------------------------
   const Configuration& RefConfiguration() const { return m_configuration; }
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool Config(const char *config_filename, const char *parameters, XrdOucEnv *env);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   static Cache &CreateInstance(XrdSysLogger *logger, XrdOucEnv *env);
 
  //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   static       Cache         &GetInstance();
   static const Cache         &TheOne();
   static const Configuration &Conf();
 
   static ResourceMonitor     &ResMon();
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   static bool VCheck(XrdVersionInfo &urVersion) { return true; }
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   int  UnlinkFile(const std::string& f_name, bool fail_if_open);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void AddWriteTask(Block* b, bool from_read);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void RemoveWriteQEntriesFor(File *f);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void ProcessWriteTasks();
 
   long long WritesSinceLastCall();
 
   char* RequestRAM(long long size);
   void  ReleaseRAM(char* buf, long long size);
 
   void RegisterPrefetchFile(File*);
   void DeRegisterPrefetchFile(File*);
 
   File* GetNextFileToPrefetch();
 
   void Prefetch();
 
   XrdOss* GetOss() const { return m_oss; }
 
   bool IsFileActiveOrPurgeProtected(const std::string&) const;
   void ClearPurgeProtectedSet();
   PurgePin* GetPurgePin() const { return m_purge_pin; }
 
   File* GetFile(const std::string&, IO*, long long off = 0, long long filesize = 0);
 
   void  ReleaseFile(File*, IO*);
 
   void ScheduleFileSync(File* f) { schedule_file_sync(f, false, false); }
 
   void FileSyncDone(File*, bool high_debug);
 
   XrdSysError* GetLog()   const { return &m_log;  }
   XrdSysTrace* GetTrace() const { return m_trace; }
 
   ResourceMonitor& RefResMon() { return *m_res_mon; }
   XrdXrootdGStream* GetGStream() { return m_gstream; }
 
   void ExecuteCommandUrl(const std::string& command_url);
 
   static XrdScheduler *schedP;
 
   bool blocksize_str2value(const char *from, const char *str, long long &val, long long min, long long max) const;
   bool prefetch_str2value(const char *from, const char *str, int &val, int min, int max) const;
 
   bool is_prefetch_enabled() const { return m_prefetch_enabled; }
 
private:
   bool ConfigParameters(std::string, XrdOucStream&, TmpConfiguration &tmpc);
   bool ConfigXeq(char *, XrdOucStream &);
   bool xcschk(XrdOucStream &);
   bool xdlib(XrdOucStream &);
   bool xplib(XrdOucStream &);
   bool xtrace(XrdOucStream &);
   bool test_oss_basics_and_features();
 
   bool cfg2bytes(const std::string &str, long long &store, long long totalSpace, const char *name) const;
 
   static Cache     *m_instance;        
 
   XrdOucEnv        *m_env;             
   mutable XrdSysError m_log;           
   XrdSysTrace      *m_trace;
   const char       *m_traceID;
 
   XrdOss           *m_oss;             
 
   XrdXrootdGStream *m_gstream;
 
   ResourceMonitor  *m_res_mon;
 
   std::vector<Decision*> m_decisionpoints; 
   PurgePin*              m_purge_pin;      
 
   Configuration m_configuration;           
 
   XrdSysCondVar m_prefetch_condVar;        
   bool          m_prefetch_enabled;        
 
   XrdSysMutex m_RAM_mutex;                 
   long long   m_RAM_used;
   long long   m_RAM_write_queue;
   std::list<char*> m_RAM_std_blocks;       
   int              m_RAM_std_size;
 
   bool        m_isClient;                  
   bool        m_dataXattr = false;         
   bool        m_metaXattr = false;         
 
   struct WriteQ
   {
      WriteQ() : condVar(0), writes_between_purges(0), size(0) {}
 
      XrdSysCondVar     condVar;      
      std::list<Block*> queue;        
      long long         writes_between_purges; 
      int               size;         
   };
 
   WriteQ m_writeQ;
 
   // active map, purge delay set
   typedef std::map<std::string, File*>               ActiveMap_t;
   typedef ActiveMap_t::iterator                      ActiveMap_i;
   typedef std::set<std::string>                      FNameSet_t;
 
   ActiveMap_t            m_active;          
   FNameSet_t             m_purge_delay_set; 
   mutable XrdSysCondVar  m_active_cond;     
 
   void inc_ref_cnt(File*, bool lock, bool high_debug);
   void dec_ref_cnt(File*, bool high_debug);
 
   void schedule_file_sync(File*, bool ref_cnt_already_set, bool high_debug);
 
   bool is_http_cache_valid(const std::string& fname, const std::string& iname, XrdCl::URL& url);
 
   // prefetching
   typedef std::vector<File*>  PrefetchList;
   PrefetchList m_prefetchList;
};
 
}
 
#endif