xrootd
XrdFileCache.hh
Go to the documentation of this file.
1 #ifndef __XRDFILECACHE_CACHE_HH__
2 #define __XRDFILECACHE_CACHE_HH__
3 //----------------------------------------------------------------------------------
4 // Copyright (c) 2014 by Board of Trustees of the Leland Stanford, Jr., University
5 // Author: Alja Mrak-Tadel, Matevz Tadel, Brian Bockelman
6 //----------------------------------------------------------------------------------
7 // XRootD is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU Lesser General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11 //
12 // XRootD is distributed in the hope that it will be useful,
13 // but WITHOUT ANY emacs WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU Lesser General Public License
18 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
19 //----------------------------------------------------------------------------------
20 #include <string>
21 #include <list>
22 #include <set>
23 
24 #include "Xrd/XrdScheduler.hh"
25 #include "XrdVersion.hh"
26 #include "XrdSys/XrdSysPthread.hh"
27 #include "XrdOuc/XrdOucCache2.hh"
28 #include "XrdOuc/XrdOucCallBack.hh"
29 #include "XrdCl/XrdClDefaultEnv.hh"
30 #include "XrdFileCacheFile.hh"
31 #include "XrdFileCacheDecision.hh"
32 
33 class XrdOucStream;
34 class XrdSysError;
35 class XrdSysTrace;
36 
37 namespace XrdCl {
38 class Log;
39 }
40 namespace XrdFileCache {
41 class File;
42 class IO;
43 }
44 
45 
46 namespace XrdFileCache
47 {
48 //----------------------------------------------------------------------------
50 //----------------------------------------------------------------------------
52 {
54  m_hdfsmode(false),
56  m_data_space("public"),
57  m_meta_space("public"),
58  m_diskTotalSpace(-1),
59  m_diskUsageLWM(-1),
60  m_diskUsageHWM(-1),
63  m_fileUsageMax(-1),
64  m_purgeInterval(300),
67  m_bufferSize(1024*1024),
69  m_NRamBuffers(-1),
70  m_wqueue_blocks(16),
73  m_hdfsbsize(128*1024*1024),
74  m_flushCnt(2000)
75  {}
76 
77  bool are_file_usage_limits_set() const { return m_fileUsageMax > 0; }
79  bool is_purge_plugin_set_up() const { return false; }
80 
81  void calculate_fractional_usages(long long du, long long fu, double &frac_du, double &frac_fu);
82 
83  bool m_hdfsmode;
85 
86  std::string m_username;
87  std::string m_data_space;
88  std::string m_meta_space;
89 
90  long long m_diskTotalSpace;
91  long long m_diskUsageLWM;
92  long long m_diskUsageHWM;
93  long long m_fileUsageBaseline;
94  long long m_fileUsageNominal;
95  long long m_fileUsageMax;
99 
100  long long m_bufferSize;
101  long long m_RamAbsAvailable;
106 
107  long long m_hdfsbsize;
108  long long m_flushCnt;
109 };
110 
112 {
113  std::string m_diskUsageLWM;
114  std::string m_diskUsageHWM;
115  std::string m_fileUsageBaseline;
116  std::string m_fileUsageNominal;
117  std::string m_fileUsageMax;
118  std::string m_flushRaw;
119 
121  m_diskUsageLWM("0.90"), m_diskUsageHWM("0.95"),
122  m_flushRaw("")
123  {}
124 };
125 
126 //----------------------------------------------------------------------------
128 //----------------------------------------------------------------------------
129 class Cache : public XrdOucCache2
130 {
131 public:
132  //---------------------------------------------------------------------
134  //---------------------------------------------------------------------
135  Cache(XrdSysLogger *logger);
136 
137  //---------------------------------------------------------------------
139  //---------------------------------------------------------------------
140  using XrdOucCache2::Attach;
141 
142  virtual XrdOucCacheIO2 *Attach(XrdOucCacheIO2 *, int Options = 0);
143 
144  //---------------------------------------------------------------------
146  //---------------------------------------------------------------------
147  virtual int isAttached();
148 
149  //---------------------------------------------------------------------
150  // Virtual function of XrdOucCache2. Used to pass environmental info.
151  virtual void EnvInfo(XrdOucEnv &theEnv);
152 
153  //---------------------------------------------------------------------
154  // Virtual function of XrdOucCache2. Used for redirection to a local
155  // file on a distributed FS.
156  virtual int LocalFilePath(const char *url, char *buff=0, int blen=0,
157  LFP_Reason why=ForAccess, bool forall=false);
158 
159  //---------------------------------------------------------------------
160  // Virtual function of XrdOucCache2. Used for deferred open.
161  virtual int Prepare(const char *url, int oflags, mode_t mode);
162 
163  // virtual function of XrdOucCache2.
164  virtual int Stat(const char *url, struct stat &sbuff);
165 
166  // virtual function of XrdOucCache.
167  virtual int Unlink(const char *url);
168 
169  //--------------------------------------------------------------------
175  //--------------------------------------------------------------------
177 
178  //------------------------------------------------------------------------
180  //------------------------------------------------------------------------
181  const Configuration& RefConfiguration() const { return m_configuration; }
182 
183  //---------------------------------------------------------------------
190  //---------------------------------------------------------------------
191  bool Config(const char *config_filename, const char *parameters);
192 
193  //---------------------------------------------------------------------
195  //---------------------------------------------------------------------
197 
198  //---------------------------------------------------------------------
200  //---------------------------------------------------------------------
201  static Cache &GetInstance();
202 
203  //---------------------------------------------------------------------
205  //---------------------------------------------------------------------
206  static bool VCheck(XrdVersionInfo &urVersion) { return true; }
207 
208  //---------------------------------------------------------------------
210  //---------------------------------------------------------------------
211  void Purge();
212 
213  //---------------------------------------------------------------------
215  //---------------------------------------------------------------------
216  int UnlinkUnlessOpen(const std::string& f_name);
217 
218  //---------------------------------------------------------------------
220  //---------------------------------------------------------------------
221  void AddWriteTask(Block* b, bool from_read);
222 
223  //---------------------------------------------------------------------
226  //---------------------------------------------------------------------
228 
229  //---------------------------------------------------------------------
231  //---------------------------------------------------------------------
233 
235 
237 
240 
242 
243  void Prefetch();
244 
245  XrdOss* GetOss() const { return m_output_fs; }
246 
247  bool IsFileActiveOrPurgeProtected(const std::string&);
248 
249  File* GetFile(const std::string&, IO*, long long off = 0, long long filesize = 0);
250 
251  void ReleaseFile(File*, IO*);
252 
253  void ScheduleFileSync(File* f) { schedule_file_sync(f, false, false); }
254 
255  void FileSyncDone(File*, bool high_debug);
256 
257  XrdSysError* GetLog() { return &m_log; }
258  XrdSysTrace* GetTrace() { return m_trace; }
259 
260  void ExecuteCommandUrl(const std::string& command_url);
261 
262 private:
263  bool ConfigParameters(std::string, XrdOucStream&, TmpConfiguration &tmpc);
264  bool ConfigXeq(char *, XrdOucStream &);
267 
268  bool cfg2bytes(const std::string &str, long long &store, long long totalSpace, const char *name);
269 
270  int UnlinkCommon(const std::string& f_name, bool fail_if_open);
271 
272  static Cache *m_factory;
274 
277  const char *m_traceID;
278 
281 
282  std::vector<XrdFileCache::Decision*> m_decisionpoints;
283 
284  std::map<std::string, long long> m_filesInQueue;
285 
287 
290 
293  bool m_isClient;
294 
295  struct WriteQ
296  {
298 
300  std::list<Block*> queue;
302  int size;
303  };
304 
306 
307  // active map, purge delay set
308  typedef std::map<std::string, File*> ActiveMap_t;
309  typedef ActiveMap_t::iterator ActiveMap_i;
310  typedef std::set<std::string> FNameSet_t;
311 
316 
317  void inc_ref_cnt(File*, bool lock, bool high_debug);
318  void dec_ref_cnt(File*, bool high_debug);
319 
320  void schedule_file_sync(File*, bool ref_cnt_already_set, bool high_debug);
321 
322  // prefetching
323  typedef std::vector<File*> PrefetchList;
325 };
326 
327 }
328 
329 #endif
XrdFileCache::Cache::GetFile
File * GetFile(const std::string &, IO *, long long off=0, long long filesize=0)
XrdOss
Definition: XrdOss.hh:174
XrdFileCache::Cache::m_log
XrdSysError m_log
XrdFileCache namespace logger.
Definition: XrdFileCache.hh:275
XrdFileCache::Cache::m_active
ActiveMap_t m_active
Definition: XrdFileCache.hh:312
XrdOucCache2.hh
XrdFileCache::Cache::Stat
virtual int Stat(const char *url, struct stat &sbuff)
XrdFileCache::Cache::Cache
Cache(XrdSysLogger *logger)
Constructor.
XrdFileCacheFile.hh
XrdFileCache::Cache::m_traceID
const char * m_traceID
Definition: XrdFileCache.hh:277
XrdOucCacheIO
Definition: XrdOucCache.hh:128
XrdOucCacheIO2
Definition: XrdOucCache2.hh:63
XrdFileCache::Configuration::calculate_fractional_usages
void calculate_fractional_usages(long long du, long long fu, double &frac_du, double &frac_fu)
XrdFileCache::Configuration::m_purgeInterval
int m_purgeInterval
sleep interval between cache purges
Definition: XrdFileCache.hh:96
XrdSysMutex
Definition: XrdSysPthread.hh:166
XrdFileCache::Cache::RemoveWriteQEntriesFor
void RemoveWriteQEntriesFor(File *f)
Remove blocks from write queue which belong to given prefetch. This method is used at the time of Fil...
XrdFileCache::Cache::m_output_fs
XrdOss * m_output_fs
disk cache file system
Definition: XrdFileCache.hh:280
XrdFileCache::Cache::Attach
virtual XrdOucCacheIO2 * Attach(XrdOucCacheIO2 *, int Options=0)
XrdFileCache::Cache::LocalFilePath
virtual int LocalFilePath(const char *url, char *buff=0, int blen=0, LFP_Reason why=ForAccess, bool forall=false)
XrdFileCache::Cache::RegisterPrefetchFile
void RegisterPrefetchFile(File *)
XrdFileCacheDecision.hh
XrdFileCache::Cache::RAMBlockReleased
void RAMBlockReleased()
XrdSysPthread.hh
XrdFileCache::Cache::CreateInstance
static Cache & CreateInstance(XrdSysLogger *logger)
Singleton creation.
XrdFileCache::Cache::m_RAMblocks_used
int m_RAMblocks_used
Definition: XrdFileCache.hh:292
XrdFileCache::Block
Definition: XrdFileCacheFile.hh:60
XrdFileCache::Cache::VCheck
static bool VCheck(XrdVersionInfo &urVersion)
Version check.
Definition: XrdFileCache.hh:206
XrdFileCache::Cache::m_active_cond
XrdSysCondVar m_active_cond
Definition: XrdFileCache.hh:315
XrdFileCache::TmpConfiguration::m_fileUsageMax
std::string m_fileUsageMax
Definition: XrdFileCache.hh:117
XrdFileCache::Cache::m_trace
XrdSysTrace * m_trace
Definition: XrdFileCache.hh:276
XrdFileCache::Configuration::m_fileUsageMax
long long m_fileUsageMax
cache purge - files usage maximum
Definition: XrdFileCache.hh:95
XrdFileCache::Cache::ActiveMap_i
ActiveMap_t::iterator ActiveMap_i
Definition: XrdFileCache.hh:309
XrdFileCache::Configuration::m_diskUsageHWM
long long m_diskUsageHWM
cache purge - disk usage high water mark
Definition: XrdFileCache.hh:92
XrdOucCache2
Definition: XrdOucCache2.hh:197
XrdFileCache::File
Definition: XrdFileCacheFile.hh:134
XrdFileCache::Cache::m_RAMblock_mutex
XrdSysMutex m_RAMblock_mutex
lock for allcoation of RAM blocks
Definition: XrdFileCache.hh:291
XrdFileCache::Cache::GetInstance
static Cache & GetInstance()
Singleton access.
XrdOucCache2::ForAccess
@ ForAccess
Definition: XrdOucCache2.hh:297
XrdFileCache::TmpConfiguration::m_diskUsageHWM
std::string m_diskUsageHWM
Definition: XrdFileCache.hh:114
XrdOucCache2::LFP_Reason
LFP_Reason
Definition: XrdOucCache2.hh:297
XrdFileCache::Configuration::m_wqueue_threads
int m_wqueue_threads
number of threads writing blocks to disk
Definition: XrdFileCache.hh:104
XrdFileCache::Configuration::m_hdfsmode
bool m_hdfsmode
flag for enabling block-level operation
Definition: XrdFileCache.hh:83
XrdFileCache::Cache::WriteQ::WriteQ
WriteQ()
Definition: XrdFileCache.hh:297
XrdFileCache::IO
Base cache-io class that implements XrdOucCacheIO abstract methods.
Definition: XrdFileCacheIO.hh:17
XrdFileCache::TmpConfiguration::m_fileUsageBaseline
std::string m_fileUsageBaseline
Definition: XrdFileCache.hh:115
XrdFileCache::Cache::m_prefetch_enabled
bool m_prefetch_enabled
set to true when prefetching is enabled
Definition: XrdFileCache.hh:289
XrdOucStream
Definition: XrdOucStream.hh:46
XrdFileCache::Configuration::m_prefetch_max_blocks
int m_prefetch_max_blocks
maximum number of blocks to prefetch per file
Definition: XrdFileCache.hh:105
XrdFileCache::Cache::xtrace
bool xtrace(XrdOucStream &)
XrdFileCache::Configuration::m_purgeColdFilesAge
int m_purgeColdFilesAge
purge files older than this age
Definition: XrdFileCache.hh:97
XrdFileCache::Cache::dec_ref_cnt
void dec_ref_cnt(File *, bool high_debug)
XrdFileCache::Cache::cfg2bytes
bool cfg2bytes(const std::string &str, long long &store, long long totalSpace, const char *name)
XrdFileCache::Cache::FNameSet_t
std::set< std::string > FNameSet_t
Definition: XrdFileCache.hh:310
XrdFileCache::Cache::m_factory
static Cache * m_factory
this object
Definition: XrdFileCache.hh:272
XrdFileCache::Configuration::m_flushCnt
long long m_flushCnt
nuber of unsynced blcoks on disk before flush is called
Definition: XrdFileCache.hh:108
XrdFileCache::Cache::ConfigParameters
bool ConfigParameters(std::string, XrdOucStream &, TmpConfiguration &tmpc)
XrdFileCache::Cache::m_configuration
Configuration m_configuration
configurable parameters
Definition: XrdFileCache.hh:286
XrdFileCache::Cache::inc_ref_cnt
void inc_ref_cnt(File *, bool lock, bool high_debug)
XrdFileCache::Cache::WriteQ::condVar
XrdSysCondVar condVar
write list condVar
Definition: XrdFileCache.hh:299
XrdFileCache::Cache::WriteQ
Definition: XrdFileCache.hh:296
XrdFileCache::Configuration::m_meta_space
std::string m_meta_space
oss space for metadata files (cinfo)
Definition: XrdFileCache.hh:88
XrdFileCache::Cache::GetOss
XrdOss * GetOss() const
Definition: XrdFileCache.hh:245
XrdFileCache::Cache::UnlinkUnlessOpen
int UnlinkUnlessOpen(const std::string &f_name)
Remove file from cache unless it is currently open.
XrdSysCondVar
Definition: XrdSysPthread.hh:79
XrdFileCache::Cache::ActiveMap_t
std::map< std::string, File * > ActiveMap_t
Definition: XrdFileCache.hh:308
XrdFileCache::TmpConfiguration::m_fileUsageNominal
std::string m_fileUsageNominal
Definition: XrdFileCache.hh:116
XrdFileCache::Cache::Decide
bool Decide(XrdOucCacheIO *)
Makes decision if the original XrdOucCacheIO should be cached.
XrdFileCache::Configuration::are_file_usage_limits_set
bool are_file_usage_limits_set() const
Definition: XrdFileCache.hh:77
XrdFileCache::Cache::ProcessWriteTasks
void ProcessWriteTasks()
Separate task which writes blocks from ram to disk.
XrdFileCache
Definition: XrdFileCache.hh:40
XrdFileCache::Configuration::m_RamAbsAvailable
long long m_RamAbsAvailable
available from configuration
Definition: XrdFileCache.hh:101
XrdOucEnv
Definition: XrdOucEnv.hh:42
XrdFileCache::Cache::IsFileActiveOrPurgeProtected
bool IsFileActiveOrPurgeProtected(const std::string &)
XrdFileCache::Cache::FileSyncDone
void FileSyncDone(File *, bool high_debug)
XrdFileCache::Cache::GetTrace
XrdSysTrace * GetTrace()
Definition: XrdFileCache.hh:258
XrdFileCache::Cache::RefConfiguration
const Configuration & RefConfiguration() const
Reference XrdFileCache configuration.
Definition: XrdFileCache.hh:181
XrdFileCache::Cache::m_purge_delay_set
FNameSet_t m_purge_delay_set
Definition: XrdFileCache.hh:313
XrdScheduler
Definition: XrdScheduler.hh:45
XrdFileCache::Configuration::m_username
std::string m_username
username passed to oss plugin
Definition: XrdFileCache.hh:86
XrdSysLogger
Definition: XrdSysLogger.hh:53
XrdFileCache::Cache::m_stats
XrdOucCacheStats m_stats
Definition: XrdFileCache.hh:279
XrdFileCache::Cache::ScheduleFileSync
void ScheduleFileSync(File *f)
Definition: XrdFileCache.hh:253
XrdFileCache::Cache::Unlink
virtual int Unlink(const char *url)
XrdFileCache::Cache::xdlib
bool xdlib(XrdOucStream &)
XrdFileCache::Configuration::Configuration
Configuration()
Definition: XrdFileCache.hh:53
XrdFileCache::Cache::m_writeQ
WriteQ m_writeQ
Definition: XrdFileCache.hh:305
XrdScheduler.hh
XrdFileCache::Cache::schedule_file_sync
void schedule_file_sync(File *, bool ref_cnt_already_set, bool high_debug)
XrdOucCacheStats
Definition: XrdOucCacheStats.hh:41
XrdFileCache::Cache::Prefetch
void Prefetch()
XrdFileCache::Configuration::m_allow_xrdpfc_command
bool m_allow_xrdpfc_command
flag for enabling access to /xrdpfc-command/ functionality.
Definition: XrdFileCache.hh:84
XrdFileCache::Configuration
Contains parameters configurable from the xrootd config file.
Definition: XrdFileCache.hh:52
XrdFileCache::Cache::AddWriteTask
void AddWriteTask(Block *b, bool from_read)
Add downloaded block in write queue.
XrdCl
Definition: XrdClAnyObject.hh:26
XrdFileCache::Cache::WriteQ::queue
std::list< Block * > queue
container
Definition: XrdFileCache.hh:300
XrdFileCache::Configuration::m_data_space
std::string m_data_space
oss space for data files
Definition: XrdFileCache.hh:87
XrdFileCache::Cache::WriteQ::writes_between_purges
long long writes_between_purges
upper bound on amount of bytes written between two purge passes
Definition: XrdFileCache.hh:301
XrdFileCache::Configuration::m_purgeColdFilesPeriod
int m_purgeColdFilesPeriod
peform cold file purge every this many purge cycles
Definition: XrdFileCache.hh:98
XrdFileCache::Configuration::is_purge_plugin_set_up
bool is_purge_plugin_set_up() const
Definition: XrdFileCache.hh:79
XrdFileCache::Configuration::is_age_based_purge_in_effect
bool is_age_based_purge_in_effect() const
Definition: XrdFileCache.hh:78
XrdClDefaultEnv.hh
XrdFileCache::Cache::WriteQ::size
int size
current size of write queue
Definition: XrdFileCache.hh:302
XrdFileCache::Cache::m_filesInQueue
std::map< std::string, long long > m_filesInQueue
Definition: XrdFileCache.hh:284
XrdFileCache::Cache::isAttached
virtual int isAttached()
Number of cache-io objects atteched through this cache.
XrdFileCache::Cache::Purge
void Purge()
Thread function running disk cache purge periodically.
XrdFileCache::Cache::m_isClient
bool m_isClient
True if running as client.
Definition: XrdFileCache.hh:293
XrdFileCache::Cache::m_prefetch_condVar
XrdSysCondVar m_prefetch_condVar
lock for vector of prefetching files
Definition: XrdFileCache.hh:288
XrdFileCache::Cache::Prepare
virtual int Prepare(const char *url, int oflags, mode_t mode)
XrdOucCache2::Attach
virtual XrdOucCacheIO * Attach(XrdOucCacheIO *ioP, int Options=0)=0
XrdFileCache::Cache::EnvInfo
virtual void EnvInfo(XrdOucEnv &theEnv)
XrdFileCache::Cache::GetLog
XrdSysError * GetLog()
Definition: XrdFileCache.hh:257
XrdOucCallBack.hh
XrdFileCache::Cache::schedP
static XrdScheduler * schedP
Definition: XrdFileCache.hh:273
XrdFileCache::Cache::PrefetchList
std::vector< File * > PrefetchList
Definition: XrdFileCache.hh:323
XrdFileCache::Configuration::m_fileUsageBaseline
long long m_fileUsageBaseline
cache purge - files usage baseline
Definition: XrdFileCache.hh:93
XrdFileCache::Cache::m_prefetchList
PrefetchList m_prefetchList
Definition: XrdFileCache.hh:324
XrdFileCache::Cache::ReleaseFile
void ReleaseFile(File *, IO *)
XrdFileCache::Configuration::m_bufferSize
long long m_bufferSize
prefetch buffer size, default 1MB
Definition: XrdFileCache.hh:100
XrdFileCache::Configuration::m_diskTotalSpace
long long m_diskTotalSpace
total disk space on configured partition or oss space
Definition: XrdFileCache.hh:90
stat
#define stat(a, b)
Definition: XrdPosix.hh:96
XrdFileCache::TmpConfiguration
Definition: XrdFileCache.hh:112
XrdFileCache::Cache
Attaches/creates and detaches/deletes cache-io objects for disk based cache.
Definition: XrdFileCache.hh:130
XrdSysError
Definition: XrdSysError.hh:90
XrdSysTrace
Definition: XrdSysTrace.hh:49
XrdFileCache::Cache::ConfigXeq
bool ConfigXeq(char *, XrdOucStream &)
XrdFileCache::Configuration::m_NRamBuffers
int m_NRamBuffers
number of total in-memory cache blocks, cached
Definition: XrdFileCache.hh:102
XrdFileCache::Cache::m_in_purge
bool m_in_purge
Definition: XrdFileCache.hh:314
XrdFileCache::Configuration::m_wqueue_blocks
int m_wqueue_blocks
maximum number of blocks written per write-queue loop
Definition: XrdFileCache.hh:103
XrdFileCache::TmpConfiguration::m_diskUsageLWM
std::string m_diskUsageLWM
Definition: XrdFileCache.hh:113
XrdFileCache::Cache::RequestRAMBlock
bool RequestRAMBlock()
XrdFileCache::Configuration::m_diskUsageLWM
long long m_diskUsageLWM
cache purge - disk usage low water mark
Definition: XrdFileCache.hh:91
XrdFileCache::TmpConfiguration::m_flushRaw
std::string m_flushRaw
Definition: XrdFileCache.hh:118
XrdFileCache::Cache::DeRegisterPrefetchFile
void DeRegisterPrefetchFile(File *)
XrdFileCache::TmpConfiguration::TmpConfiguration
TmpConfiguration()
Definition: XrdFileCache.hh:120
XrdFileCache::Cache::Config
bool Config(const char *config_filename, const char *parameters)
Parse configuration file.
XrdFileCache::Configuration::m_hdfsbsize
long long m_hdfsbsize
used with m_hdfsmode, default 128MB
Definition: XrdFileCache.hh:107
XrdFileCache::Cache::ExecuteCommandUrl
void ExecuteCommandUrl(const std::string &command_url)
XrdFileCache::Cache::GetNextFileToPrefetch
File * GetNextFileToPrefetch()
XrdFileCache::Configuration::m_fileUsageNominal
long long m_fileUsageNominal
cache purge - files usage nominal
Definition: XrdFileCache.hh:94
XrdFileCache::Cache::m_decisionpoints
std::vector< XrdFileCache::Decision * > m_decisionpoints
decision plugins
Definition: XrdFileCache.hh:282
XrdFileCache::Cache::UnlinkCommon
int UnlinkCommon(const std::string &f_name, bool fail_if_open)