XRootD
Loading...
Searching...
No Matches
XrdCephOss.cc
Go to the documentation of this file.
1//------------------------------------------------------------------------------
2// Copyright (c) 2014-2015 by European Organization for Nuclear Research (CERN)
3// Author: Sebastien Ponce <sebastien.ponce@cern.ch>
4//------------------------------------------------------------------------------
5// This file is part of the XRootD software suite.
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 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// In applying this licence, CERN does not waive the privileges and immunities
21// granted to it by virtue of its status as an Intergovernmental Organization
22// or submit itself to any jurisdiction.
23//------------------------------------------------------------------------------
24
25#include <chrono>
26#include <stdio.h>
27#include <string>
28#include <fcntl.h>
29#include <limits.h>
30
31#include "XrdVersion.hh"
32#include "XrdCeph/XrdCephOss.hh"
38
39#include "XrdOuc/XrdOucEnv.hh"
40#include "XrdSys/XrdSysError.hh"
42#include "XrdOuc/XrdOucTrace.hh"
46
48
51
53static std::string ts() {
54 std::time_t t = std::time(nullptr);
55 char mbstr[50];
56 std::strftime(mbstr, sizeof(mbstr), "%y%m%d %H:%M:%S ", std::localtime(&t));
57 return std::string(mbstr);
58}
59
60// log wrapping function to be used by ceph_posix interface
61char g_logstring[1024];
62static void logwrapper(char *format, va_list argp) {
63 vsnprintf(g_logstring, 1024, format, argp);
64 XrdCephEroute.Say(ts().c_str(), g_logstring);
65}
66
71
72
74void m_translateFileName(std::string &physName, std::string logName){
75 if (0 != g_namelib) {
76 char physCName[MAXPATHLEN+1];
77 int retc = g_namelib->lfn2pfn(logName.c_str(), physCName, sizeof(physCName));
78 if (retc) {
79 XrdCephEroute.Say(__FUNCTION__, " - failed to translate '", logName.c_str(), "' using namelib plugin, using it as is");
80 physName = logName;
81 } else {
82 XrdCephEroute.Say(__FUNCTION__, " - translated '", logName.c_str(), "' to '", physCName, "'");
83 physName = physCName;
84 }
85 } else {
86 physName = logName;
87 }
88}
89
104ssize_t getNumericAttr(const char* const path, const char* attrName, const int maxAttrLen)
105{
106
107 ssize_t retval;
108 char *attrValue = (char*)malloc(maxAttrLen+1);
109 if (NULL == attrValue) {
110 return -ENOMEM;
111 }
112
113 ssize_t attrLen = ceph_posix_getxattr((XrdOucEnv*)NULL, path, attrName, attrValue, maxAttrLen);
114
115 if (attrLen <= 0) {
116 retval = -EINVAL;
117 } else {
118 attrValue[attrLen] = '\0';
119 char *endPointer = (char *)NULL;
120 retval = strtoll(attrValue, &endPointer, 10);
121 }
122
123 if (NULL != attrValue) {
124 free(attrValue);
125 }
126
127 return retval;
128
129}
130
131extern "C"
132{
133 XrdOss*
135 XrdSysLogger* lp,
136 const char* config_fn,
137 const char* parms)
138 {
139 // Do the herald thing
140 XrdCephEroute.SetPrefix("ceph_");
142 XrdCephEroute.Say("++++++ CERN/IT-DSS XrdCeph");
143 // set parameters
144 try {
146 } catch (std::exception &e) {
147 XrdCephEroute.Say("CephOss loading failed with exception. Check the syntax of parameters : ", parms);
148 return 0;
149 }
150 // deal with logging
152 return new XrdCephOss(config_fn, XrdCephEroute);
153 }
154}
155
156XrdCephOss::XrdCephOss(const char *configfn, XrdSysError &Eroute) {
157 Configure(configfn, Eroute);
158}
159
163
164// declared and used in XrdCephPosix.cc
165extern unsigned int g_maxCephPoolIdx;
166extern unsigned int g_cephAioWaitThresh;
167
168int XrdCephOss::Configure(const char *configfn, XrdSysError &Eroute) {
169 int NoGo = 0;
170 XrdOucEnv myEnv;
171 XrdOucStream Config(&Eroute, getenv("XRDINSTANCE"), &myEnv, "=====> ");
172 //disable posc
173 XrdOucEnv::Export("XRDXROOTD_NOPOSC", "1");
174 // If there is no config file, nothing to be done
175 if (configfn && *configfn) {
176 // Try to open the configuration file.
177 int cfgFD;
178 if ((cfgFD = open(configfn, O_RDONLY, 0)) < 0) {
179 Eroute.Emsg("Config", errno, "open config file", configfn);
180 return 1;
181 }
182 Config.Attach(cfgFD);
183 // Now start reading records until eof.
184 char *var;
185 while((var = Config.GetMyFirstWord())) {
186 if (!strncmp(var, "ceph.nbconnections", 18)) {
187 var = Config.GetWord();
188 if (var) {
189 unsigned long value = strtoul(var, 0, 10);
190 if (value > 0 and value <= 100) {
191 g_maxCephPoolIdx = value;
192 } else {
193 Eroute.Emsg("Config", "Invalid value for ceph.nbconnections in config file (must be between 1 and 100)", configfn, var);
194 return 1;
195 }
196 } else {
197 Eroute.Emsg("Config", "Missing value for ceph.nbconnections in config file", configfn);
198 return 1;
199 }
200 }
201 if (!strncmp(var, "ceph.namelib", 12)) {
202 var = Config.GetWord();
203 if (var) {
204 std::string libname = var;
205 // Warn in case parameters were givne
206 char parms[1040];
207 bool hasParms{false};
208 if (!Config.GetRest(parms, sizeof(parms)) || parms[0]) {
209 hasParms = true;
210 }
211 // Load name lib
212 XrdOucN2NLoader n2nLoader(&Eroute,configfn,(hasParms?parms:""),NULL,NULL);
213 g_namelib = n2nLoader.Load(libname.c_str(), XrdVERSIONINFOVAR(XrdOssGetStorageSystem), NULL);
214 if (!g_namelib) {
215 Eroute.Emsg("Config", "Unable to load library given in ceph.namelib : %s", var);
216 }
217 } else {
218 Eroute.Emsg("Config", "Missing value for ceph.namelib in config file ", configfn);
219 return 1;
220 }
221 }
222
223 int pread_flag_set = !strncmp(var, "ceph.usedefaultpreadalg", 24);
224 int readv_flag_set = !strncmp(var, "ceph.usedefaultreadvalg", 24);
225 if (pread_flag_set or readv_flag_set) {
226 var = Config.GetWord();
227 if (var) {
228 char* endptr;
229 long value = strtol(var, &endptr, 10);
230 if ((value == 0 || value == 1) && (var != endptr)) {
231 if (pread_flag_set) {
232 m_useDefaultPreadAlg = value;
233 } else if(readv_flag_set) {
234 m_useDefaultReadvAlg = value;
235 } else {
236 Eroute.Emsg("Config", "Bug encountered during parsing", var);
237 }
238 } else {
239 Eroute.Emsg("Config", "Invalid value for ceph.usedefault* in config file -- must be 0 or 1, got", var);
240 return 1;
241 }
242 } else {
243 Eroute.Emsg("Config", "Missing value for ceph.usedefault* in config file");
244 return 1;
245 }
246 }
247
248 if (!strncmp(var, "ceph.aiowaitthresh", 19)) {
249 var = Config.GetWord();
250 if (var) {
251 unsigned long value = strtoul(var, 0, 10);
252 if ((value > 0) && (value < INT_MAX)){
253 g_cephAioWaitThresh = value;
254 } else {
255 Eroute.Emsg("Config", "Invalid value for ceph.aiowaitthresh:", var);
256 }
257 } else {
258 Eroute.Emsg("Config", "Missing value for ceph.aiowaitthresh in config file");
259 return 1;
260 }
261 }
262
263 if (!strncmp(var, "ceph.usebuffer", 14)) { // allowable values: 0, 1
264 var = Config.GetWord();
265 if (var) {
266 unsigned long value = strtoul(var, 0, 10);
267 if (value <= 1) {
268 m_configBufferEnable = value;
269 Eroute.Emsg("Config", "ceph.usebuffer",std::to_string(m_configBufferEnable).c_str());
270 } else {
271 Eroute.Emsg("Config", "Invalid value for ceph.usebuffer in config file (must be 0 or 1)", configfn, var);
272 return 1;
273 }
274 } else {
275 Eroute.Emsg("Config", "Missing value for ceph.usebuffer in config file", configfn);
276 return 1;
277 }
278 } // usebuffer
279 if (!strncmp(var, "ceph.buffersize", 15)) { // size in bytes
280 var = Config.GetWord();
281 if (var) {
282 unsigned long value = strtoul(var, 0, 10);
283 if (value > 0 and value <= 1000000000L) {
284 m_configBufferSize = value;
285 Eroute.Emsg("Config", "ceph.buffersize", std::to_string(m_configBufferSize).c_str() );
286 } else {
287 Eroute.Emsg("Config", "Invalid value for ceph.buffersize in config file; enter in bytes (no units)", configfn, var);
288 return 1;
289 }
290 } else {
291 Eroute.Emsg("Config", "Missing value for ceph.buffersize in config file", configfn);
292 return 1;
293 }
294 } // buffersize
295 if (!strncmp(var, "ceph.buffermaxpersimul", 22)) { // size in bytes
296 var = Config.GetWord();
297 if (var) {
298 unsigned long value = strtoul(var, 0, 10);
299 if (value > 0 and value <= 1000000000L) {
300 m_configMaxSimulBufferCount = value;
301 Eroute.Emsg("Config", "ceph.buffermaxpersimul", std::to_string(m_configMaxSimulBufferCount).c_str() );
302 } else {
303 Eroute.Emsg("Config", "Invalid value for ceph.buffermaxpersimul in config file; enter in bytes (no units)", configfn, var);
304 return 1;
305 }
306 } else {
307 Eroute.Emsg("Config", "Missing value for ceph.buffermaxpersimul in config file", configfn);
308 return 1;
309 }
310 } // buffersize
311
312 if (!strncmp(var, "ceph.usereadv", 13)) { // allowable values: 0, 1
313 var = Config.GetWord();
314 if (var) {
315 unsigned long value = strtoul(var, 0, 10);
316 if (value <= 1) {
317 m_configReadVEnable = value;
318 Eroute.Emsg("Config", "ceph.usereadvalg",std::to_string(m_configBufferEnable).c_str());
319 } else {
320 Eroute.Emsg("Config", "Invalid value for ceph.usereadv in config file (must be 0 or 1)", configfn, var);
321 return 1;
322 }
323 } else {
324 Eroute.Emsg("Config", "Missing value for ceph.usereadv in config file", configfn);
325 return 1;
326 }
327 } // usereadv
328 if (!strncmp(var, "ceph.readvalgname", 17)) {
329 var = Config.GetWord();
330 // Eroute.Emsg("Config", "readvalgname readvalgname readvalgname readvalgname", var);
331 if (var) {
332 // Warn in case parameters were givne
333 char parms[1040];
334 if (!Config.GetRest(parms, sizeof(parms)) || parms[0]) {
335 Eroute.Emsg("Config", "readvalgname parameters will be ignored");
336 }
337 m_configReadVAlgName = var;
338 } else {
339 Eroute.Emsg("Config", "Missing value for ceph.readvalgname in config file", configfn);
340 return 1;
341 }
342 }
343 if (!strncmp(var, "ceph.bufferiomode", 17)) {
344 var = Config.GetWord();
345 if (var) {
346 // Warn in case parameters were givne
347 char parms[1040];
348 if (!Config.GetRest(parms, sizeof(parms)) || parms[0]) {
349 Eroute.Emsg("Config", "readvalgname parameters will be ignored");
350 }
351 m_configBufferIOmode = var; // allowed values would be aio, io
352 } else {
353 Eroute.Emsg("Config", "Missing value for ceph.bufferiomode in config file", configfn);
354 return 1;
355 }
356 }
357
358 if (!strcmp(var, "ceph.reportingpools")) {
359 var = Config.GetWord();
360 if (var) {
361 m_configPoolnames = var;
362 } else {
363 Eroute.Emsg("Config", "Missing value for ceph.reportingpools in config file", configfn);
364 return 1;
365 }
366 }
367 } // while
368
369 // Now check if any errors occurred during file i/o
370
371 int retc = Config.LastError();
372 if (retc) {
373 NoGo = Eroute.Emsg("Config", -retc, "read config file",
374 configfn);
375 }
376 Config.Close();
377 }
378 return NoGo;
379}
380
381int XrdCephOss::Chmod(const char *path, mode_t mode, XrdOucEnv *envP) {
382 return -ENOTSUP;
383}
384
385int XrdCephOss::Create(const char *tident, const char *path, mode_t access_mode,
386 XrdOucEnv &env, int Opts) {
387 return -ENOTSUP;
388}
389
390int XrdCephOss::Init(XrdSysLogger *logger, const char* configFn) { return 0; }
391
392//SCS - lie to posix-assuming clients about directories [fixes brittleness in GFAL2]
393int XrdCephOss::Mkdir(const char *path, mode_t mode, int mkpath, XrdOucEnv *envP) {
394 return 0;
395}
396
397//SCS - lie to posix-assuming clients about directories [fixes brittleness in GFAL2]
398int XrdCephOss::Remdir(const char *path, int Opts, XrdOucEnv *eP) {
399 return 0;
400}
401
402int XrdCephOss::Rename(const char *from,
403 const char *to,
404 XrdOucEnv *eP1,
405 XrdOucEnv *eP2) {
406 return -ENOTSUP;
407}
408
421std::string extractPool(std::string possPool) {
422
423 std::string pool;
424 auto colonPos = possPool.find_first_of(':');
425
426 if (colonPos > 0) {
427 pool = possPool.substr(0, colonPos);
428 } else {
429 pool = possPool;
430 }
431 return pool;
432}
433
434
454int XrdCephOss::Stat(const char* path,
455 struct stat* buff,
456 int opts,
457 XrdOucEnv* env) {
458
459 XrdCephEroute.Say(__FUNCTION__, " path = ", path);
460
461 std::string spath {path};
462 m_translateFileName(spath,path);
463
464 if (spath.back() == '/') { // Request to stat the root
465
466
467#ifdef STAT_TRACE
468 XrdCephEroute.Say(__FUNCTION__, " - fake a return for stat'ing root element '/'");
469#endif
470
471
472 // special case of a stat made by the locate interface
473 // we intend to then list all files
474
475 memset(buff, 0, sizeof(*buff));
476
477 buff->st_mode = S_IFDIR|S_IRWXU;
478 buff->st_dev = 1;
479 buff->st_ino = 1;
480
481 return XrdOssOK;
482
483 }
484
485 if (spath.find_first_of(":") == spath.length()-1) { // Request to stat just the pool name
486
487#ifdef STAT_TRACE
488 XrdCephEroute.Say(__FUNCTION__, "Found request to stat pool name");
489#endif
490
491 spath.pop_back(); // remove colon from pool name
492 if (m_configPoolnames.find(spath) != std::string::npos) { // Support 'locate' for spaceinfo
493#ifdef STAT_TRACE
494 XrdCephEroute.Say(__FUNCTION__, " - preparing spaceinfo report for '", path, "'");
495#endif
496 return XrdOssOK; // Only requires a status code, do not need to fill contents in struct stat
497 } else {
498 XrdCephEroute.Say(__FUNCTION__, " - cannot find pool '", path, "' in ceph.reportingpools");
499 return -EINVAL;
500 }
501
502
503 } else if (ceph_posix_stat(env, path, buff) == 0) { // Found object ID
504
505#ifdef STAT_TRACE
506 XrdCephEroute.Say(__FUNCTION__, " - found object ", spath.c_str(), " via ceph_posix_stat");
507#endif
508 return XrdOssOK;
509
510 } else {
511
512#ifdef STAT_TRACE
513 XrdCephEroute.Say(__FUNCTION__, " - cannot find object '", spath.c_str(), "'");
514#endif
515 return -ENOENT;
516
517 }
518
519
520}
521
522
523
524int XrdCephOss::StatFS(const char *path, char *buff, int &blen, XrdOucEnv *eP) {
525
526#ifdef STAT_TRACE
527 XrdCephEroute.Say(__FUNCTION__, " path = ", path);
528#endif
529 XrdOssVSInfo sP;
530 int rc = StatVS(&sP, 0, 0);
531 if (rc) {
532 return rc;
533 }
534 int percentUsedSpace = (sP.Usage*100)/sP.Total;
535 blen = snprintf(buff, blen, "%d %lld %d %d %lld %d",
536 1, sP.Free, percentUsedSpace, 0, 0LL, 0);
537 return XrdOssOK;
538}
539
540int XrdCephOss::StatVS(XrdOssVSInfo *sP, const char *sname, int updt) {
541
542#ifdef STAT_TRACE
543 XrdCephEroute.Say(__FUNCTION__, " path = ", sname);
544#endif
545 int rc = ceph_posix_statfs(&(sP->Total), &(sP->Free));
546 if (rc) {
547 return rc;
548 }
549 sP->Large = sP->Total;
550 sP->LFree = sP->Free;
551 sP->Usage = sP->Total-sP->Free;
552 sP->Extents = 1;
553 return XrdOssOK;
554}
555
556int formatStatLSResponse(char *buff, int &blen, const char* cgroup, long long totalSpace,
557 long long usedSpace, long long freeSpace, long long quota, long long maxFreeChunk)
558{
559 return snprintf(buff, blen, "oss.cgroup=%s&oss.space=%lld&oss.free=%lld&oss.maxf=%lld&oss.used=%lld&oss.quota=%lld",
560 cgroup, totalSpace, freeSpace, maxFreeChunk, usedSpace, quota);
561}
562
581int XrdCephOss::StatLS(XrdOucEnv &env, const char *charPath, char *buff, int &blen)
582{
583 XrdCephEroute.Say(__FUNCTION__, " incoming path = ", charPath);
584
585 std::string path(charPath);
586 path = extractPool(path);
587 std::string spath {path};
588
589 m_translateFileName(spath,path);
590
591//
592// Following test is now redundant as we take the substring up to colonPos
593//
594
595 if (spath.back() == ':') {
596 spath.pop_back();
597 }
598 if (m_configPoolnames.find(spath) == std::string::npos) {
599 XrdCephEroute.Say("Can't report on ", spath.c_str());
600 return -EINVAL;
601 }
602
603 long long usedSpace, totalSpace, freeSpace;
604
605 if (ceph_posix_stat_pool(spath.c_str(), &usedSpace) != 0) {
606 XrdCephEroute.Say("Failed to get used space in pool ", spath.c_str());
607 return -EINVAL;
608 }
609
610 // Construct the object path
611 std::string spaceInfoPath = spath + ":" + (const char *)"__spaceinfo__";
612 totalSpace = getNumericAttr(spaceInfoPath.c_str(), "total_space", 24);
613 if (totalSpace < 0) {
614 XrdCephEroute.Say("Could not get 'total_space' attribute from ", spaceInfoPath.c_str());
615 return -EINVAL;
616 }
617
618//
619// Figure for 'usedSpace' already accounts for Erasure Coding overhead
620//
621
622
623 freeSpace = totalSpace - usedSpace;
624 blen = formatStatLSResponse(buff, blen,
625 spath.c_str(), /* "oss.cgroup" */
626 totalSpace, /* "oss.space" */
627 usedSpace, /* "oss.used" */
628 freeSpace, /* "oss.free" */
629 totalSpace, /* "oss.quota" */
630 freeSpace /* "oss.maxf" */);
631#ifdef STAT_TRACE
632 XrdCephEroute.Say(__FUNCTION__, "space info = \n", buff);
633#endif
634 return XrdOssOK;
635
636}
637
638int XrdCephOss::Truncate (const char* path,
639 unsigned long long size,
640 XrdOucEnv* env) {
641 try {
642 return ceph_posix_truncate(env, path, size);
643 } catch (std::exception &e) {
644 XrdCephEroute.Say("truncate : invalid syntax in file parameters");
645 return -EINVAL;
646 }
647}
648
649int XrdCephOss::Unlink(const char *path, int Opts, XrdOucEnv *env) {
650 try {
651 return ceph_posix_unlink(env, path);
652 } catch (std::exception &e) {
653 XrdCephEroute.Say("unlink : invalid syntax in file parameters");
654 return -EINVAL;
655 }
656}
657
659 return new XrdCephOssDir(this);
660}
661
663
664 // Depending on the configuration settings stack up the underlying
665 // XrdCephOssFile instance with decorator objects for readV and Buffering requests
666
667 XrdCephOssFile* xrdCephOssDF = new XrdCephOssFile(this);
668
669 if (m_configReadVEnable) {
670 xrdCephOssDF = new XrdCephOssReadVFile(this,xrdCephOssDF,m_configReadVAlgName);
671 }
672
673 if (m_configBufferEnable) {
674 xrdCephOssDF = new XrdCephOssBufferedFile(this,xrdCephOssDF, m_configBufferSize,
675 m_configBufferIOmode, m_configMaxSimulBufferCount);
676 }
677
678
679 return xrdCephOssDF;
680}
681
#define tident
XrdOucTrace XrdCephTrace
XrdOucName2Name * g_namelib
XrdOss * XrdOssGetStorageSystem(XrdOss *native_oss, XrdSysLogger *lp, const char *config_fn, const char *parms)
static std::string ts()
timestamp output for logging messages
Definition XrdCephOss.cc:53
int formatStatLSResponse(char *buff, int &blen, const char *cgroup, long long totalSpace, long long usedSpace, long long freeSpace, long long quota, long long maxFreeChunk)
unsigned int g_maxCephPoolIdx
static void logwrapper(char *format, va_list argp)
Definition XrdCephOss.cc:62
void m_translateFileName(std::string &physName, std::string logName)
converts a logical filename to physical one if needed
Definition XrdCephOss.cc:74
char g_logstring[1024]
Definition XrdCephOss.cc:61
ssize_t getNumericAttr(const char *const path, const char *attrName, const int maxAttrLen)
Retrieve an integer-value extended attribute.
std::string extractPool(std::string possPool)
Extract a pool name (string before the first colon ':') from an object ID.
XrdVERSIONINFO(XrdOssGetStorageSystem, XrdCephOss)
unsigned int g_cephAioWaitThresh
XrdSysError XrdCephEroute(0)
Definition XrdCephOss.cc:50
void ceph_posix_set_logfunc(void(*logfunc)(char *, va_list argp))
int ceph_posix_truncate(XrdOucEnv *env, const char *pathname, unsigned long long size)
int ceph_posix_unlink(XrdOucEnv *env, const char *pathname)
ssize_t ceph_posix_getxattr(XrdOucEnv *env, const char *path, const char *name, void *value, size_t size)
void ceph_posix_disconnect_all()
int ceph_posix_statfs(long long *totalSpace, long long *freeSpace)
int ceph_posix_stat_pool(char const *poolName, long long *usedSpace)
Return the amount of space used in a pool.
void ceph_posix_set_defaults(const char *value)
int ceph_posix_stat(XrdOucEnv *env, const char *pathname, struct stat *buf)
#define XrdOssOK
Definition XrdOss.hh:50
#define open
Definition XrdPosix.hh:76
#define stat(a, b)
Definition XrdPosix.hh:101
struct myOpts opts
virtual int Truncate(const char *, unsigned long long, XrdOucEnv *eP=0)
virtual int StatLS(XrdOucEnv &env, const char *path, char *buff, int &blen)
Report on disk space use in this pool.
virtual int Rename(const char *, const char *, XrdOucEnv *eP1=0, XrdOucEnv *eP2=0)
int m_useDefaultPreadAlg
Definition XrdCephOss.hh:78
virtual int StatVS(XrdOssVSInfo *sP, const char *sname=0, int updt=0)
virtual int Remdir(const char *, int Opts=0, XrdOucEnv *eP=0)
virtual int Create(const char *, const char *, mode_t, XrdOucEnv &, int opts=0)
XrdCephOss(const char *, XrdSysError &)
virtual int Mkdir(const char *, mode_t mode, int mkpath=0, XrdOucEnv *eP=0)
virtual int Stat(const char *, struct stat *, int opts=0, XrdOucEnv *eP=0)
Return status information for an object ID.
virtual XrdOssDF * newDir(const char *tident)
virtual int Chmod(const char *, mode_t mode, XrdOucEnv *eP=0)
virtual int Unlink(const char *path, int Opts=0, XrdOucEnv *eP=0)
virtual ~XrdCephOss()
virtual int StatFS(const char *path, char *buff, int &blen, XrdOucEnv *eP=0)
virtual int Init(XrdSysLogger *, const char *)
virtual XrdOssDF * newFile(const char *tident)
int m_useDefaultReadvAlg
Definition XrdCephOss.hh:80
int Configure(const char *, XrdSysError &)
long long LFree
Definition XrdOssVS.hh:93
long long Usage
Definition XrdOssVS.hh:94
long long Large
Definition XrdOssVS.hh:92
long long Total
Definition XrdOssVS.hh:90
long long Free
Definition XrdOssVS.hh:91
static int Export(const char *Var, const char *Val)
Definition XrdOucEnv.cc:170
XrdOucName2Name * Load(const char *libName, XrdVersionInfo &urVer, XrdOucEnv *envP=0)
virtual int lfn2pfn(const char *lfn, char *buff, int blen)=0
int Emsg(const char *esfx, int ecode, const char *text1, const char *text2=0)
void Say(const char *text1, const char *text2=0, const char *txt3=0, const char *text4=0, const char *text5=0, const char *txt6=0)
const char * SetPrefix(const char *prefix)
XrdSysLogger * logger(XrdSysLogger *lp=0)