XRootD
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"
33 #include "XrdCeph/XrdCephOssDir.hh"
35 #include "XrdCeph/XrdCephPosix.hh"
38 
39 #include "XrdOuc/XrdOucEnv.hh"
40 #include "XrdSys/XrdSysError.hh"
41 #include "XrdSys/XrdSysPlatform.hh"
42 #include "XrdOuc/XrdOucTrace.hh"
43 #include "XrdOuc/XrdOucStream.hh"
46 
48 
51 
53 static 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
61 char g_logstring[1024];
62 static 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 
74 void 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 
104 ssize_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 
131 extern "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_");
141  XrdCephEroute.logger(lp);
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 
156 XrdCephOss::XrdCephOss(const char *configfn, XrdSysError &Eroute) {
157  Configure(configfn, Eroute);
158 }
159 
162 }
163 
164 // declared and used in XrdCephPosix.cc
165 extern unsigned int g_maxCephPoolIdx;
166 extern unsigned int g_cephAioWaitThresh;
167 
168 int 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 
381 int XrdCephOss::Chmod(const char *path, mode_t mode, XrdOucEnv *envP) {
382  return -ENOTSUP;
383 }
384 
385 int XrdCephOss::Create(const char *tident, const char *path, mode_t access_mode,
386  XrdOucEnv &env, int Opts) {
387  return -ENOTSUP;
388 }
389 
390 int XrdCephOss::Init(XrdSysLogger *logger, const char* configFn) { return 0; }
391 
392 //SCS - lie to posix-assuming clients about directories [fixes brittleness in GFAL2]
393 int 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]
398 int XrdCephOss::Remdir(const char *path, int Opts, XrdOucEnv *eP) {
399  return 0;
400 }
401 
402 int XrdCephOss::Rename(const char *from,
403  const char *to,
404  XrdOucEnv *eP1,
405  XrdOucEnv *eP2) {
406  return -ENOTSUP;
407 }
408 
421 std::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 
454 int 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 
524 int 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 
540 int 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 
556 int 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 
581 int 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 
638 int 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 
649 int 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
Definition: XrdCephPosix.cc:98
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)
Definition: XrdCephOss.cc:556
unsigned int g_maxCephPoolIdx
Definition: XrdCephPosix.cc:95
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
XrdOss * XrdOssGetStorageSystem(XrdOss *native_oss, XrdSysLogger *lp, const char *config_fn, const char *parms)
Definition: XrdCephOss.cc:134
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.
Definition: XrdCephOss.cc:104
std::string extractPool(std::string possPool)
Extract a pool name (string before the first colon ':') from an object ID.
Definition: XrdCephOss.cc:421
XrdVERSIONINFO(XrdOssGetStorageSystem, XrdCephOss)
unsigned int g_cephAioWaitThresh
Definition: XrdCephPosix.cc:91
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
int stat(const char *path, struct stat *buf)
int open(const char *path, int oflag,...)
struct myOpts opts
virtual int Truncate(const char *, unsigned long long, XrdOucEnv *eP=0)
Definition: XrdCephOss.cc:638
virtual int StatLS(XrdOucEnv &env, const char *path, char *buff, int &blen)
Report on disk space use in this pool.
Definition: XrdCephOss.cc:581
virtual int Rename(const char *, const char *, XrdOucEnv *eP1=0, XrdOucEnv *eP2=0)
Definition: XrdCephOss.cc:402
int m_useDefaultPreadAlg
Definition: XrdCephOss.hh:78
virtual int StatVS(XrdOssVSInfo *sP, const char *sname=0, int updt=0)
Definition: XrdCephOss.cc:540
virtual int Remdir(const char *, int Opts=0, XrdOucEnv *eP=0)
Definition: XrdCephOss.cc:398
virtual int Create(const char *, const char *, mode_t, XrdOucEnv &, int opts=0)
Definition: XrdCephOss.cc:385
XrdCephOss(const char *, XrdSysError &)
Definition: XrdCephOss.cc:156
virtual int Mkdir(const char *, mode_t mode, int mkpath=0, XrdOucEnv *eP=0)
Definition: XrdCephOss.cc:393
virtual int Stat(const char *, struct stat *, int opts=0, XrdOucEnv *eP=0)
Return status information for an object ID.
Definition: XrdCephOss.cc:454
virtual XrdOssDF * newDir(const char *tident)
Definition: XrdCephOss.cc:658
virtual int Chmod(const char *, mode_t mode, XrdOucEnv *eP=0)
Definition: XrdCephOss.cc:381
virtual int Unlink(const char *path, int Opts=0, XrdOucEnv *eP=0)
Definition: XrdCephOss.cc:649
virtual ~XrdCephOss()
Definition: XrdCephOss.cc:160
virtual int StatFS(const char *path, char *buff, int &blen, XrdOucEnv *eP=0)
Definition: XrdCephOss.cc:524
virtual int Init(XrdSysLogger *, const char *)
Definition: XrdCephOss.cc:390
virtual XrdOssDF * newFile(const char *tident)
Definition: XrdCephOss.cc:662
int m_useDefaultReadvAlg
Definition: XrdCephOss.hh:80
int Configure(const char *, XrdSysError &)
Definition: XrdCephOss.cc:168
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:188
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)
Definition: XrdSysError.cc:95
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)
Definition: XrdSysError.cc:141
XrdSysLogger * logger(XrdSysLogger *lp=0)
Definition: XrdSysError.hh:141
const char * SetPrefix(const char *prefix)
Definition: XrdSysError.hh:160
XrdCmsConfig Config
int Opts
Definition: XrdMpxStats.cc:58
XrdOucEnv * envP
Definition: XrdPss.cc:109
static INT to(const char *buffer)
Definition: XrdZipUtils.hh:91