XRootD
XrdPosixXrootd.cc
Go to the documentation of this file.
1 /******************************************************************************/
2 /* */
3 /* X r d P o s i x X r o o t d . c c */
4 /* */
5 /* (c) 2010 by the Board of Trustees of the Leland Stanford, Jr., University */
6 /* All Rights Reserved */
7 /* Produced by Andrew Hanushevsky for Stanford University under contract */
8 /* DE-AC02-76-SFO0515 with the Department of Energy */
9 /* */
10 /* This file is part of the XRootD software suite. */
11 /* */
12 /* XRootD is free software: you can redistribute it and/or modify it under */
13 /* the terms of the GNU Lesser General Public License as published by the */
14 /* Free Software Foundation, either version 3 of the License, or (at your */
15 /* option) any later version. */
16 /* */
17 /* XRootD is distributed in the hope that it will be useful, but WITHOUT */
18 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or */
19 /* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public */
20 /* License for more details. */
21 /* */
22 /* You should have received a copy of the GNU Lesser General Public License */
23 /* along with XRootD in a file called COPYING.LESSER (LGPL license) and file */
24 /* COPYING (GPL license). If not, see <http://www.gnu.org/licenses/>. */
25 /* */
26 /* The copyright holder's institutional names and contributor's names may not */
27 /* be used to endorse or promote products derived from this software without */
28 /* specific prior written permission of the institution or contributor. */
29 /******************************************************************************/
30 
31 #include <cerrno>
32 #include <fcntl.h>
33 #include <iostream>
34 #include <cstdio>
35 #include <sys/time.h>
36 #include <sys/param.h>
37 #include <sys/resource.h>
38 #include <sys/uio.h>
39 
40 #include "XrdVersion.hh"
41 
42 #include "Xrd/XrdScheduler.hh"
43 
44 #include "XrdCl/XrdClDefaultEnv.hh"
45 #include "XrdCl/XrdClFileSystem.hh"
46 #include "XrdCl/XrdClFile.hh"
47 #include "XrdCl/XrdClURL.hh"
49 
50 #include "XrdSys/XrdSysHeaders.hh"
51 #include "XrdSys/XrdSysPlatform.hh"
52 
53 #include "XrdOuc/XrdOucCache.hh"
54 #include "XrdOuc/XrdOucECMsg.hh"
55 #include "XrdOuc/XrdOucEnv.hh"
57 #include "XrdOuc/XrdOucPsx.hh"
58 
62 #include "XrdPosix/XrdPosixDir.hh"
63 #include "XrdPosix/XrdPosixFile.hh"
65 #include "XrdPosix/XrdPosixInfo.hh"
66 #include "XrdPosix/XrdPosixMap.hh"
72 
73 #include "XrdSys/XrdSysTrace.hh"
74 
75 /******************************************************************************/
76 /* S t a t i c M e m b e r s */
77 /******************************************************************************/
78 
79 class XrdSysError;
80 
81 namespace XrdPosixGlobals
82 {
83 thread_local XrdOucECMsg ecMsg("[posix]");
84 
85 XrdScheduler *schedP = 0;
89 XrdSysError *eDest = 0;
91 XrdSysTrace Trace("Posix", 0,
92  (getenv("XRDPOSIX_DEBUG") ? TRACE_Debug : 0));
93 int ddInterval= 30;
94 int ddMaxTries= 180/30;
96 bool oidsOK = false;
97 bool p2lSRC = false;
98 bool p2lSGI = false;
99 bool autoPGRD = false;
100 bool usingEC = false;
101 };
102 
103 int XrdPosixXrootd::baseFD = 0;
104 int XrdPosixXrootd::initDone = 0;
105 
106 XrdVERSIONINFO(XrdPosix,XrdPosix);
107 
108 /******************************************************************************/
109 /* L o c a l C l a s s e s */
110 /******************************************************************************/
111 /******************************************************************************/
112 /* L f n P a t h */
113 /******************************************************************************/
114 
115 namespace
116 {
117 class LfnPath
118 {
119 public:
120 const char *path;
121 
122  LfnPath(const char *who, const char *pURL, bool ponly=true)
123  {path = XrdPosixXrootPath::P2L(who, pURL, relURL, ponly);}
124 
125  ~LfnPath() {if (relURL) free(relURL);}
126 
127 private:
128 char *relURL;
129 };
130 }
131 
132 /******************************************************************************/
133 /* L o c a l F u n c t i o n s */
134 /******************************************************************************/
135 
136 namespace
137 {
138 
139 /******************************************************************************/
140 /* O p e n D e f e r */
141 /******************************************************************************/
142 
143 int OpenDefer(XrdPosixFile *fp,
144  XrdPosixCallBack *cbP,
145  XrdCl::OpenFlags::Flags XOflags,
146  XrdCl::Access::Mode XOmode,
147  bool isStream)
148 {
149 
150 // Assign a file descriptor to this file
151 //
152  if (!(fp->AssignFD(isStream)))
153  {delete fp; return XrdPosixGlobals::ecMsg.SetErrno(EMFILE);}
154 
155 // Allocate a prepare I/O object to defer this open
156 //
157  fp->PrepIO = new XrdPosixPrepIO(fp, XOflags, XOmode);
158 
159 // Finalize this file object. A null argument indicates it is deferred.
160 //
161  fp->Finalize(0);
162 
163 // For sync opens we just need to return the file descriptor
164 //
165  if (!cbP) return fp->FDNum();
166 
167 // For async opens do the callback here and return an inprogress
168 //
169  cbP->Complete(fp->FDNum());
170  errno = EINPROGRESS;
171  return -1;
172 }
173 };
174 
175 /******************************************************************************/
176 /* C o n s t r u c t o r */
177 /******************************************************************************/
178 
179 XrdPosixXrootd::XrdPosixXrootd(int fdnum, int dirnum, int thrnum)
180 {
181  static XrdSysMutex myMutex;
182  char *cfn;
183 
184 // Test if XRDCL_EC is set. That env var. is set at XrdCl::PlugInManager::LoadFactory
185 // in XrdClPlugInManager.cc, which is called (by XrdOssGetSS while loading
186 // libXrdPss.so) before this function.
187 // Note: some standalone programs will call this constructor directly.
188  XrdPosixGlobals::usingEC = getenv("XRDCL_EC")? true : false;
189 
190 // Only static fields are initialized here. We need to do this only once!
191 //
192  myMutex.Lock();
193  if (initDone) {myMutex.UnLock(); return;}
194  initDone = 1;
195  myMutex.UnLock();
196 
197 // Initialize environment as a client or a server (it differs somewhat).
198 // Note that we create a permanent Env since some plugins rely on it. We
199 // leave the logger handling to OucPsx as we do not want to enable messages
200 // because this is likely a client application that doesn't understand noise.
201 //
202  if (!XrdPosixGlobals::theLogger && (cfn=getenv("XRDPOSIX_CONFIG")) && *cfn)
203  {bool hush;
204  if (*cfn == '+') {hush = false; cfn++;}
205  else hush = (getenv("XRDPOSIX_DEBUG") == 0);
206  if (*cfn)
207  {XrdOucEnv *psxEnv = new XrdOucEnv;
208  psxEnv->Put("psx.Client", "1");
209  XrdOucPsx psxConfig(&XrdVERSIONINFOVAR(XrdPosix), cfn, 0, psxEnv);
210  if (!psxConfig.ClientConfig("posix.", hush)
211  || !XrdPosixConfig::SetConfig(psxConfig))
212  {std::cerr <<"Posix: Unable to instantiate specified "
213  "configuration; program exiting!" <<std::endl;
214  exit(16);
215  }
216  }
217  }
218 
219 // Initialize file tracking
220 //
221  baseFD = XrdPosixObject::Init(fdnum);
222 }
223 
224 /******************************************************************************/
225 /* D e s t r u c t o r */
226 /******************************************************************************/
227 
229 {
230 
231 // Shutdown processing
232 //
234  initDone = 0;
235 }
236 
237 /******************************************************************************/
238 /* A c c e s s */
239 /******************************************************************************/
240 
241 int XrdPosixXrootd::Access(const char *path, int amode)
242 {
244  mode_t stMode;
245  bool aOK = true;
246 
247 // Issue the stat and verify that all went well
248 //
249  if (!admin.Stat(&stMode)) return -1;
250 
251 // Translate the mode bits
252 //
253  if (amode & R_OK && !(stMode & S_IRUSR)) aOK = 0;
254  if (amode & W_OK && !(stMode & S_IWUSR)) aOK = 0;
255  if (amode & X_OK && !(stMode & S_IXUSR)) aOK = 0;
256 
257 // All done
258 //
259  if (aOK) return 0;
260  return XrdPosixGlobals::ecMsg.SetErrno(EACCES);
261 }
262 
263 /******************************************************************************/
264 /* C l o s e */
265 /******************************************************************************/
266 
267 int XrdPosixXrootd::Close(int fildes)
268 {
269  EPNAME("Close");
270  XrdCl::XRootDStatus Status;
271  XrdPosixFile *fP;
272  bool ret;
273 
274 // Map the file number to the file object. In the prcess we relese the file
275 // number so no one can reference this file again.
276 //
277  if (!(fP = XrdPosixObject::ReleaseFile(fildes)))
278  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
279 
280 // Detach the file from a possible cache. We need to up the reference count
281 // to synchrnoize with any possible callback as we may need to place this
282 // object in he delayed destroy queue if it is stil being used. Note that
283 // the caller will get a zero return code should we delay the close.
284 //
285  fP->Ref();
286  if (fP->XCio->Detach((XrdOucCacheIOCD&)*fP) && fP->Refs() < 2)
287  {if ((ret = fP->Close(Status))) {delete fP; fP = 0;}
288  else if (DEBUGON)
289  {std::string eTxt = Status.ToString();
290  DEBUG(eTxt <<" closing " <<fP->Origin());
291  }
292  } else {
293  ret = true;
294  }
295 
296 // If we still have a handle then we need to do a delayed delete on this
297 // object because either the close failed or there is still active I/O
298 //
299  if (fP) XrdPosixFile::DelayedDestroy(fP);
300 
301 // Return final result. Note: close errors are recorded in global thread status
302 //
303  return (ret ? 0 : XrdPosixMap::Result(Status,XrdPosixGlobals::ecMsg,true));
304 }
305 
306 /******************************************************************************/
307 /* C l o s e d i r */
308 /******************************************************************************/
309 
311 {
312  XrdPosixDir *dP;
313  int fildes = XrdPosixDir::dirNo(dirp);
314 
315 // Get the directory object
316 //
317  if (!(dP = XrdPosixObject::ReleaseDir(fildes)))
318  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
319 
320 // Deallocate the directory
321 //
322  delete dP;
323  return 0;
324 }
325 
326 /******************************************************************************/
327 /* e n d P o i n t */
328 /******************************************************************************/
329 
330 int XrdPosixXrootd::endPoint(int FD, char *Buff, int Blen)
331 {
332  XrdPosixFile *fp;
333  int uPort;
334 
335 // Find the file object
336 //
337  if (!(fp = XrdPosixObject::File(FD))) return 0;
338 
339 // Make sure url is valid
340 //
341  if (!(fp->clFile.IsOpen()))
342  {fp->UnLock(); return -ENOTCONN;}
343 
344 // Make sure we can fit result in the buffer
345 //
346  std::string dataServer;
347  fp->clFile.GetProperty( "DataServer", dataServer );
348  XrdCl::URL dataServerUrl = dataServer;
349 
350  if (dataServer.size() >= (uint32_t)Blen)
351  {fp->UnLock(); return -ENAMETOOLONG;}
352 
353 // Copy the data server location
354 //
355  strcpy(Buff, dataServer.c_str());
356 
357 // Get the port and return it
358 //
359  uPort = dataServerUrl.GetPort();
360  fp->UnLock();
361  return uPort;
362 }
363 
364 /******************************************************************************/
365 /* F s t a t */
366 /******************************************************************************/
367 
368 int XrdPosixXrootd::Fstat(int fildes, struct stat *buf)
369 {
370  XrdPosixFile *fp;
371  int rc;
372 
373 // Find the file object
374 //
375  if (!(fp = XrdPosixObject::File(fildes))) return -1;
376 
377 // First initialize the stat buffer
378 //
380 
381 // Check if we can get the stat information from the cache.
382 //
383  rc = fp->XCio->Fstat(*buf);
384  if (rc <= 0)
385  {fp->UnLock();
386  if (!rc) return 0;
387  errno = -rc; //???
388  return -1;
389  }
390 
391 // At this point we can call the file's Fstat() and if the file is not open
392 // it will be opened.
393 //
394  rc = fp->Fstat(*buf);
395  fp->UnLock();
396  if (rc < 0) {errno = -rc; rc = -1;}
397  return rc;
398 }
399 
400 /******************************************************************************/
401 /* F s y n c */
402 /******************************************************************************/
403 
404 int XrdPosixXrootd::Fsync(int fildes)
405 {
406  XrdPosixFile *fp;
407  int rc;
408 
409 // Find the file object
410 //
411  if (!(fp = XrdPosixObject::File(fildes))) return -1;
412 
413 // Do the sync
414 //
415  if ((rc = fp->XCio->Sync()) < 0) return Fault(fp, -rc);
416  fp->UnLock();
417  return 0;
418 }
419 
420 /******************************************************************************/
421 
423 {
424  XrdPosixFile *fp;
425 
426 // Find the file object and do the sync
427 //
428  if ((fp = XrdPosixObject::File(fildes)))
429  {cbp->theFile = fp;
430  fp->Ref(); fp->UnLock();
431  fp->XCio->Sync(*cbp);
432  } else cbp->Complete(-1);
433 }
434 
435 /******************************************************************************/
436 /* F t r u n c a t e */
437 /******************************************************************************/
438 
439 int XrdPosixXrootd::Ftruncate(int fildes, off_t offset)
440 {
441  XrdPosixFile *fp;
442  int rc;
443 
444 // Find the file object
445 //
446  if (!(fp = XrdPosixObject::File(fildes))) return -1;
447 
448 // Do the trunc
449 //
450  if ((rc = fp->XCio->Trunc(offset)) < 0) return Fault(fp, -rc);
451  fp->UnLock();
452  return 0;
453 }
454 
455 /******************************************************************************/
456 /* G e t x a t t r */
457 /******************************************************************************/
458 
459 #ifndef ENOATTR
460 #define ENOATTR ENOTSUP
461 #endif
462 
463 long long XrdPosixXrootd::Getxattr (const char *path, const char *name,
464  void *value, unsigned long long size)
465 {
467  XrdCl::QueryCode::Code reqCode;
468  int vsize = static_cast<int>(size);
469 
470 // Check if user just wants the maximum length needed
471 //
472  if (size == 0) return 1024;
473 
474 // Check if we support the query
475 //
476  if (name)
477  { if (!strcmp(name,"xroot.cksum")) reqCode=XrdCl::QueryCode::Checksum;
478  else if (!strcmp(name,"xroot.space")) reqCode=XrdCl::QueryCode::Space;
479  else if (!strcmp(name,"xroot.xattr")) reqCode=XrdCl::QueryCode::XAttr;
480  else {errno = ENOATTR; return -1;} //???
481  }else {errno = EINVAL; return -1;}
482 
483 // Stat the file first to allow vectoring of the request to the right server
484 //
485  if (!admin.Stat()) return -1;
486 
487 // Return the result
488 //
489  return admin.Query(reqCode, value, vsize);
490 }
491 
492 /******************************************************************************/
493 /* L s e e k */
494 /******************************************************************************/
495 
496 off_t XrdPosixXrootd::Lseek(int fildes, off_t offset, int whence)
497 {
498  XrdPosixFile *fp;
499  long long curroffset;
500 
501 // Find the file object
502 //
503  if (!(fp = XrdPosixObject::File(fildes))) return -1;
504 
505 // Set the new offset. Note that SEEK_END requires that the file be opened.
506 // An open may occur by calling the FSize() method via the cache pointer.
507 //
508  if (whence == SEEK_SET) curroffset = fp->setOffset(offset);
509  else if (whence == SEEK_CUR) curroffset = fp->addOffset(offset);
510  else if (whence == SEEK_END)
511  {curroffset = fp->XCio->FSize();
512  if (curroffset < 0) return Fault(fp,static_cast<int>(-curroffset));
513  curroffset = fp->setOffset(curroffset+offset);
514  }
515  else return Fault(fp, EINVAL);
516 
517 // All done
518 //
519  fp->UnLock();
520  return curroffset;
521 }
522 
523 /******************************************************************************/
524 /* M k d i r */
525 /******************************************************************************/
526 
527 int XrdPosixXrootd::Mkdir(const char *path, mode_t mode)
528 {
531 
532 // Preferentially make the whole path unless told otherwise
533 //
534  flags = (mode & S_ISUID ? XrdCl::MkDirFlags::None
536 
537 // Make sure the admin is OK
538 //
539  if (!admin.isOK()) return -1;
540 
541 // Issue the mkdir
542 //
543  return XrdPosixMap::Result(admin.Xrd.MkDir(admin.Url.GetPathWithParams(),
544  flags,
547  );
548 }
549 
550 /******************************************************************************/
551 /* O p e n */
552 /******************************************************************************/
553 
554 int XrdPosixXrootd::Open(const char *path, int oflags, mode_t mode,
555  XrdPosixCallBack *cbP)
556 {
557  return Open(path, oflags, mode, cbP, 0);
558 }
559 
560 int XrdPosixXrootd::Open(const char *path, int oflags, mode_t mode,
561  XrdPosixCallBack *cbP, XrdPosixInfo *infoP)
562 {
563  EPNAME("Open");
564  XrdCl::XRootDStatus Status;
565  XrdPosixFile *fp;
567  XrdCl::OpenFlags::Flags XOflags;
568  int Opts;
569  bool aOK, isRO = false;
570 
571 // Translate R/W and R/O flags
572 //
573  if (oflags & (O_WRONLY | O_RDWR))
575  XOflags = XrdCl::OpenFlags::Update;
576  } else {
577  Opts = 0;
578  XOflags = XrdCl::OpenFlags::Read;
579  isRO = true;
580  }
581 
582 // Pass along the stream flag
583 //
584  if (oflags & isStream)
586  return XrdPosixGlobals::ecMsg.SetErrno(EMFILE);
587  }
588 
589 // Translate create vs simple open. Always make dirpath on create!
590 //
591  if (oflags & O_CREAT)
592  {XOflags |= (oflags & O_EXCL ? XrdCl::OpenFlags::New
594  XOflags |= XrdCl::OpenFlags::MakePath;
595  XOmode = XrdPosixMap::Mode2Access(mode);
596  }
597  else if (oflags & O_TRUNC && Opts & XrdPosixFile::isUpdt)
598  XOflags |= XrdCl::OpenFlags::Delete;
599 
600 // Allocate the new file object
601 //
602  if (!(fp = new XrdPosixFile(aOK, path, cbP, Opts)))
603  return XrdPosixGlobals::ecMsg.SetErrno(EMFILE);
604 
605 // Check if all went well during allocation
606 //
607  if (!aOK) {delete fp; return -1;}
608 
609 // If we have a cache, then issue a prepare as the cache may want to defer the
610 // open request ans we have a lot more work to do.
611 //
613  {int rc;
614  if (infoP && isRO && OpenCache(*fp, *infoP))
615  {delete fp;
616  errno = 0;
617  return -3;
618  }
619  rc = XrdPosixGlobals::theCache->Prepare(fp->Path(), oflags, mode);
620  if (rc > 0) return OpenDefer(fp, cbP, XOflags, XOmode, oflags&isStream);
621  if (rc < 0) {delete fp; return XrdPosixGlobals::ecMsg.SetErrno(-rc);}
622  }
623 
624 // Open the file (sync or async)
625 //
627  if (!cbP) Status = fp->clFile.Open((std::string)path, XOflags, XOmode);
628  else Status = fp->clFile.Open((std::string)path, XOflags, XOmode,
629  (XrdCl::ResponseHandler *)fp);
630 
631 // If we failed, return the reason
632 //
633  if (!Status.IsOK())
635  int rc = XrdPosixMap::Result(Status,XrdPosixGlobals::ecMsg,false);
636  if (DEBUGON && rc != -ENOENT && rc != -ELOOP)
637  {DEBUG(XrdPosixGlobals::ecMsg.Msg() <<" open " <<fp->Origin());}
638  delete fp;
639  errno = -rc; // Saved errno across the delete
640  return -1;
641  }
642 
643 // Assign a file descriptor to this file
644 //
645  if (!(fp->AssignFD(oflags & isStream)))
646  {delete fp;
647  return XrdPosixGlobals::ecMsg.SetErrno(EMFILE);
648  }
649 
650 // Finalize the open (this gets the stat info). For async opens, the
651 // finalization is deferred until the callback happens.
652 //
653  if (cbP) {errno = EINPROGRESS; return -1;}
654  if (fp->Finalize(&Status)) return fp->FDNum();
655  auto rc = XrdPosixMap::Result(Status,XrdPosixGlobals::ecMsg,false);
656  if (!Status.IsOK()) {
657  delete fp;
658  errno = -rc;
659  }
660  return rc;
661 }
662 
663 /******************************************************************************/
664 /* Private: O p e n C a c h e */
665 /******************************************************************************/
666 
667 bool XrdPosixXrootd::OpenCache(XrdPosixFile &file,XrdPosixInfo &Info)
668 {
669  EPNAME("OpenCache");
670  int rc;
671 
672 // Check if the full file is in the cache
673 //
674  rc = XrdPosixGlobals::theCache->LocalFilePath(file.Path(), Info.cachePath,
675  (int)sizeof(Info.cachePath),
677  Info.ffReady);
678  if (rc == 0)
679  {Info.ffReady = true;
680  DEBUG("File in cache url=" <<Info.cacheURL);
681  return true;
682  }
683 
684 // File is not fully in the cache
685 //
686  Info.ffReady = false;
687  return false;
688 }
689 
690 /******************************************************************************/
691 /* O p e n d i r */
692 /******************************************************************************/
693 
694 DIR* XrdPosixXrootd::Opendir(const char *path)
695 {
696  XrdPosixDir *dP;
697  DIR *dirP;
698  int rc;
699 
700 // Get a new directory object
701 //
702  if (!(dP = new XrdPosixDir(path)))
704  return (DIR*)0;
705  }
706 
707 // Assign a file descriptor to this file
708 //
709  if (!(dP->AssignFD()))
710  {delete dP;
712  return (DIR*)0;
713  }
714 
715 // Open the directory
716 //
717  if ((dirP = dP->Open())) return dirP;
718 
719 // We failed
720 //
721  rc = errno;
722  delete dP;
723  errno = rc; // Restore saved errno
724  return (DIR *)0;
725 }
726 
727 /******************************************************************************/
728 /* P r e a d */
729 /******************************************************************************/
730 
731 ssize_t XrdPosixXrootd::Pread(int fildes, void *buf, size_t nbyte, off_t offset)
732 {
733  XrdPosixFile *fp;
734  long long offs, bytes;
735  int iosz;
736 
737 // Find the file object
738 //
739  if (!(fp = XrdPosixObject::File(fildes)))
740  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
741 
742 // Make sure the size is not too large
743 //
744  if (nbyte > (size_t)0x7fffffff)
745  return Fault(fp, EOVERFLOW, "read size too large");
746  else iosz = static_cast<int>(nbyte);
747 
748 // Issue the read
749 //
750  offs = static_cast<long long>(offset);
751  bytes = fp->XCio->Read((char *)buf, offs, (int)iosz);
752  if (bytes < 0) return Fault(fp,-bytes,"*");
753 
754 // All went well
755 //
756  fp->UnLock();
757  return (ssize_t)bytes;
758 }
759 
760 /******************************************************************************/
761 
762 void XrdPosixXrootd::Pread(int fildes, void *buf, size_t nbyte, off_t offset,
763  XrdPosixCallBackIO *cbp)
764 {
765  XrdPosixFile *fp;
766  long long offs;
767  int iosz;
768 
769 // Find the file object
770 //
771  if (!(fp = XrdPosixObject::File(fildes))) {cbp->Complete(-1); return;}
772 
773 // Make sure the size is not too large
774 //
775  if (nbyte > (size_t)0x7fffffff)
776  {fp->UnLock();
777  fp->ecMsg.SetErrno(EOVERFLOW,0,"read size too large");
778  cbp->Complete(-1);
779  return;
780  }
781 
782 // Prepare for the read
783 //
784  cbp->theFile = fp;
785  fp->Ref(); fp->UnLock();
786  iosz = static_cast<int>(nbyte);
787  offs = static_cast<long long>(offset);
788 
789 // Issue the read
790 //
791  fp->XCio->Read(*cbp, (char *)buf, offs, (int)iosz);
792 }
793 
794 /******************************************************************************/
795 /* P w r i t e */
796 /******************************************************************************/
797 
798 ssize_t XrdPosixXrootd::Pwrite(int fildes, const void *buf, size_t nbyte, off_t offset)
799 {
800  XrdPosixFile *fp;
801  long long offs;
802  int iosz, bytes;
803 
804 // Find the file object
805 //
806  if (!(fp = XrdPosixObject::File(fildes))) return -1;
807 
808 // Make sure the size is not too large
809 //
810  if (nbyte > (size_t)0x7fffffff)
811  return Fault(fp,EOVERFLOW,"write size too large");
812  else iosz = static_cast<int>(nbyte);
813 
814 // Issue the write
815 //
816  offs = static_cast<long long>(offset);
817  bytes = fp->XCio->Write((char *)buf, offs, (int)iosz);
818  if (bytes < 0) return Fault(fp,-bytes,"*");
819 
820 // All went well
821 //
822  fp->UpdtSize(offs + iosz);
823  fp->UnLock();
824  return (ssize_t)iosz;
825 }
826 
827 /******************************************************************************/
828 
829 void XrdPosixXrootd::Pwrite(int fildes, const void *buf, size_t nbyte,
830  off_t offset, XrdPosixCallBackIO *cbp)
831 {
832  XrdPosixFile *fp;
833  long long offs;
834  int iosz;
835 
836 // Find the file object
837 //
838  if (!(fp = XrdPosixObject::File(fildes))) {cbp->Complete(-1); return;}
839 
840 // Make sure the size is not too large
841 //
842  if (nbyte > (size_t)0x7fffffff)
843  {fp->UnLock();
844  fp->ecMsg.SetErrno(EOVERFLOW,0,"read size too large");
845  cbp->Complete(-1);
846  return;
847  }
848 
849 // Prepare for the writing
850 //
851  cbp->theFile = fp;
852  fp->Ref(); fp->UnLock();
853  iosz = static_cast<int>(nbyte);
854  offs = static_cast<long long>(offset);
855 
856 // Issue the read
857 //
858  fp->XCio->Write(*cbp, (char *)buf, offs, (int)iosz);
859 }
860 
861 /******************************************************************************/
862 /* R e a d */
863 /******************************************************************************/
864 
865 ssize_t XrdPosixXrootd::Read(int fildes, void *buf, size_t nbyte)
866 {
867  XrdPosixFile *fp;
868  long long bytes;
869  int iosz;
870 
871 // Find the file object
872 //
873  if (!(fp = XrdPosixObject::File(fildes))) return -1;
874 
875 // Make sure the size is not too large
876 //
877  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
878  else iosz = static_cast<int>(nbyte);
879 
880 // Issue the read
881 //
882  bytes = fp->XCio->Read((char *)buf,fp->Offset(),(int)iosz);
883  if (bytes < 0) return Fault(fp,-bytes);
884 
885 // All went well
886 //
887  fp->addOffset(bytes);
888  fp->UnLock();
889  return (ssize_t)bytes;
890 }
891 
892 /******************************************************************************/
893 /* R e a d v */
894 /******************************************************************************/
895 
896 ssize_t XrdPosixXrootd::Readv(int fildes, const struct iovec *iov, int iovcnt)
897 {
898  ssize_t bytes, totbytes = 0;
899  int i;
900 
901 // Return the results of the read for each iov segment
902 //
903  for (i = 0; i < iovcnt; i++)
904  {bytes = Read(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len);
905  if (bytes > 0) totbytes += bytes;
906  else if (bytes < 0) return -1;
907  else break;
908  }
909 
910 // All done
911 //
912  return totbytes;
913 }
914 
915 /******************************************************************************/
916 /* V R e a d */
917 /******************************************************************************/
918 
919 ssize_t XrdPosixXrootd::VRead(int fildes, const XrdOucIOVec *readV, int n)
920 {
921  XrdPosixFile *fp;
922  ssize_t bytes;
923 
924 // Find the file object
925 //
926  if (!(fp = XrdPosixObject::File(fildes))) return -1;
927 
928 // Issue the read
929 //
930  if ((bytes = fp->XCio->ReadV(readV, n)) < 0) return Fault(fp,-bytes);
931 
932 // Return bytes read
933 //
934  fp->UnLock();
935  return bytes;
936 }
937 
938 /******************************************************************************/
939 
940 void XrdPosixXrootd::VRead(int fildes, const XrdOucIOVec *readV, int n,
941  XrdPosixCallBackIO *cbp)
942 {
943  XrdPosixFile *fp;
944 
945 // Find the file object and issue read
946 //
947  if ((fp = XrdPosixObject::File(fildes)))
948  {cbp->theFile = fp;
949  fp->Ref(); fp->UnLock();
950  fp->XCio->ReadV(*cbp, readV, n);
951  } else cbp->Complete(-1);
952 }
953 
954 /******************************************************************************/
955 /* R e a d d i r */
956 /******************************************************************************/
957 
958 struct dirent* XrdPosixXrootd::Readdir(DIR *dirp)
959 {
960  dirent64 *dp64;
961  dirent *dp32; // Could be the same as dp64
962 
963  if (!(dp64 = Readdir64(dirp))) return 0;
964 
965  dp32 = (struct dirent *)dp64;
966  if ((char*)dp32->d_name != (char*)dp64->d_name)
967  {dp32->d_ino = dp64->d_ino;
968 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
969  dp32->d_off = dp64->d_off;
970 #endif
971 #ifndef __solaris__
972  dp32->d_type = dp64->d_type;
973 #endif
974  dp32->d_reclen = dp64->d_reclen;
975  strcpy(dp32->d_name, dp64->d_name);
976  }
977  return dp32;
978 }
979 
980 struct dirent64* XrdPosixXrootd::Readdir64(DIR *dirp)
981 {
982  XrdPosixDir *dP;
983  dirent64 *dentP;
984  int rc, fildes = XrdPosixDir::dirNo(dirp);
985 
986 // Find the object
987 //
988  if (!(dP = XrdPosixObject::Dir(fildes)))
990  return (dirent64*)0;
991  }
992 
993 // Get the next directory entry
994 //
995  if (!(dentP = dP->nextEntry())) rc = dP->Status();
996  else rc = 0;
997 
998 // Return the appropriate result
999 //
1000  dP->UnLock();
1001  if (rc) errno = rc;
1002  return dentP;
1003 }
1004 
1005 /******************************************************************************/
1006 /* R e a d d i r _ r */
1007 /******************************************************************************/
1008 
1009 int XrdPosixXrootd::Readdir_r(DIR *dirp, struct dirent *entry,
1010  struct dirent **result)
1011 {
1012  dirent64 *dp64 = 0, d64ent;
1013  int rc;
1014 
1015  if ((rc = Readdir64_r(dirp, &d64ent, &dp64)) || !dp64)
1016  {*result = 0; return rc;}
1017 
1018  entry->d_ino = dp64->d_ino;
1019 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1020  entry->d_off = dp64->d_off;
1021 #endif
1022 #ifndef __solaris__
1023  entry->d_type = dp64->d_type;
1024 #endif
1025  entry->d_reclen = dp64->d_reclen;
1026  strcpy(entry->d_name, dp64->d_name);
1027  *result = entry;
1028  return rc;
1029 }
1030 
1031 int XrdPosixXrootd::Readdir64_r(DIR *dirp, struct dirent64 *entry,
1032  struct dirent64 **result)
1033 {
1034  XrdPosixDir *dP;
1035  int rc, fildes = XrdPosixDir::dirNo(dirp);
1036 
1037 // Find the object
1038 //
1039  if (!(dP = XrdPosixObject::Dir(fildes))) return EBADF;
1040 
1041 // Get the next entry
1042 //
1043  if (!(*result = dP->nextEntry(entry))) {rc = dP->Status(); *result = 0;}
1044  else {rc = 0; *result = entry;}
1045 
1046 // Return the appropriate result
1047 //
1048  dP->UnLock();
1049  return rc;
1050 }
1051 
1052 /******************************************************************************/
1053 /* R e n a m e */
1054 /******************************************************************************/
1055 
1056 int XrdPosixXrootd::Rename(const char *oldpath, const char *newpath)
1057 {
1058  XrdPosixAdmin admin(oldpath,XrdPosixGlobals::ecMsg);
1059  XrdCl::URL newUrl((std::string)newpath);
1060 
1061 // Make sure the admin is OK and the new url is valid
1062 //
1063  if (!admin.isOK() || !newUrl.IsValid())
1064  return XrdPosixGlobals::ecMsg.SetErrno(EINVAL);
1065 
1066 // Issue rename to he cache (it really should just deep-six both files)
1067 //
1069  {LfnPath oldF("rename", oldpath);
1070  LfnPath newF("rename", newpath);
1071  if (!oldF.path || !newF.path) return -1;
1072  XrdPosixGlobals::theCache->Rename(oldF.path, newF.path);
1073  }
1074 
1075 // Issue the rename
1076 //
1078  return EcRename(oldpath, newpath, admin);
1079 
1080  return XrdPosixMap::Result(admin.Xrd.Mv(admin.Url.GetPathWithParams(),
1081  newUrl.GetPathWithParams()),
1082  XrdPosixGlobals::ecMsg, true);
1083 }
1084 
1085 /******************************************************************************/
1086 /* R e w i n d d i r */
1087 /******************************************************************************/
1088 
1090 {
1091  XrdPosixDir *dP;
1092  int fildes = XrdPosixDir::dirNo(dirp);
1093 
1094 // Find the object and rewind it
1095 //
1096  if ((dP = XrdPosixObject::Dir(fildes)))
1097  {dP->rewind();
1098  dP->UnLock();
1099  }
1100 }
1101 
1102 /******************************************************************************/
1103 /* R m d i r */
1104 /******************************************************************************/
1105 
1106 int XrdPosixXrootd::Rmdir(const char *path)
1107 {
1109 
1110 // Make sure the admin is OK
1111 //
1112  if (!admin.isOK()) return -1;
1113 
1114 // Remove directory from the cache first
1115 //
1117  {LfnPath rmd("rmdir", path);
1118  if (!rmd.path) return -1;
1119  XrdPosixGlobals::theCache->Rmdir(rmd.path);
1120  }
1121 
1122 // Issue the rmdir
1123 //
1124  return XrdPosixMap::Result(admin.Xrd.RmDir(admin.Url.GetPathWithParams()),
1125  XrdPosixGlobals::ecMsg, true);
1126 }
1127 
1128 /******************************************************************************/
1129 /* S e e k d i r */
1130 /******************************************************************************/
1131 
1132 void XrdPosixXrootd::Seekdir(DIR *dirp, long loc)
1133 {
1134  XrdPosixDir *dP;
1135  int fildes = XrdPosixDir::dirNo(dirp);
1136 
1137 // Find the object
1138 //
1139  if (!(dP = XrdPosixObject::Dir(fildes))) return;
1140 
1141 // Sets the current directory position
1142 //
1143  if (dP->Unread() && !(dP->Open()))
1144  {if (loc >= dP->getEntries()) loc = dP->getEntries();
1145  else if (loc < 0) loc = 0;
1146  dP->setOffset(loc);
1147  }
1148  dP->UnLock();
1149 }
1150 
1151 /******************************************************************************/
1152 /* S t a t */
1153 /******************************************************************************/
1154 
1155 int XrdPosixXrootd::Stat(const char *path, struct stat *buf)
1156 {
1158 
1159 // Make sure the admin is OK
1160 //
1161  if (!admin.isOK()) return -1;
1162 
1163 // Initialize the stat buffer
1164 //
1166 
1167 // Check if we can get the stat informatation from the cache
1168 //
1170  {LfnPath statX("stat", path, false);
1171  if (!statX.path) return -1;
1172  int rc = XrdPosixGlobals::theCache->Stat(statX.path, *buf);
1173  if (!rc) return 0;
1174  if (rc < 0) {errno = -rc; return -1;} // does the cache set this???
1175  }
1176 
1177 // Issue the stat and verify that all went well
1178 //
1180  return EcStat(path, buf, admin);
1181 
1182  if (!admin.Stat(*buf)) return -1;
1183  return 0;
1184 }
1185 
1186 /******************************************************************************/
1187 /* S t a t f s */
1188 /******************************************************************************/
1189 
1190 int XrdPosixXrootd::Statfs(const char *path, struct statfs *buf)
1191 {
1192  struct statvfs myVfs;
1193  int rc;
1194 
1195 // Issue a statvfs() call and transcribe the results
1196 //
1197  if ((rc = Statvfs(path, &myVfs))) return rc;
1198 
1199 // The vfs structure and fs structures should be size compatible (not really)
1200 //
1201  memset(buf, 0, sizeof(struct statfs));
1202  buf->f_bsize = myVfs.f_bsize;
1203  buf->f_blocks = myVfs.f_blocks;
1204  buf->f_bfree = myVfs.f_bfree;
1205  buf->f_files = myVfs.f_files;
1206  buf->f_ffree = myVfs.f_ffree;
1207 #if defined(__APPLE__) || defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1208  buf->f_iosize = myVfs.f_frsize;
1209 #else
1210  buf->f_frsize = myVfs.f_frsize;
1211 #endif
1212 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1213  buf->f_bavail = myVfs.f_bavail;
1214 #endif
1215 #if defined(__linux__) || defined(__GNU__)
1216  buf->f_namelen = myVfs.f_namemax;
1217 #elif defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1218  buf->f_namemax = myVfs.f_namemax;
1219 #endif
1220  return 0;
1221 }
1222 
1223 /******************************************************************************/
1224 /* S t a t v f s */
1225 /******************************************************************************/
1226 
1227 int XrdPosixXrootd::Statvfs(const char *path, struct statvfs *buf)
1228 {
1229  static const int szVFS = sizeof(buf->f_bfree);
1230  static const long long max32 = 0x7fffffffLL;
1231 
1233  XrdCl::StatInfoVFS *vfsStat;
1234 
1235  long long rwFree, ssFree, rwBlks;
1236  int rwNum, ssNum, rwUtil, ssUtil;
1237 
1238 // Make sure we connected
1239 //
1240  if (!admin.isOK()) return -1;
1241 
1242 // Issue the statfvs call
1243 //
1245  vfsStat),
1246  XrdPosixGlobals::ecMsg) < 0) return -1;
1247 
1248 // Extract out the information
1249 //
1250  rwNum = static_cast<int>(vfsStat->GetNodesRW());
1251  rwFree = (long long)vfsStat->GetFreeRW();
1252  rwUtil = static_cast<int>(vfsStat->GetUtilizationRW());
1253  ssNum = static_cast<int>(vfsStat->GetNodesStaging());
1254  ssFree = (long long)vfsStat->GetFreeStaging();
1255  ssUtil = static_cast<int>(vfsStat->GetUtilizationStaging());
1256  delete vfsStat;
1257 
1258 // Calculate number of blocks
1259 //
1260  if (rwUtil == 0) rwBlks = rwFree;
1261  else if (rwUtil >= 100) rwBlks = 0;
1262  else rwBlks = rwFree * (100 / (100 - rwUtil));
1263  if (ssUtil == 0) rwBlks += ssFree;
1264  else if (ssUtil < 100) rwBlks += ssFree * (100 / (100 - ssUtil));
1265 
1266 // Scale units to what will fit here (we can have a 32-bit or 64-bit struct)
1267 //
1268  if (szVFS < 8)
1269  {if (rwBlks > max32) rwBlks = max32;
1270  if (rwFree > max32) rwFree = max32;
1271  if (ssFree > max32) ssFree = max32;
1272  }
1273 
1274 // Return what little we can
1275 //
1276  memset(buf, 0, sizeof(struct statvfs));
1277  buf->f_bsize = 1024*1024;
1278  buf->f_frsize = 1024*1024;
1279  buf->f_blocks = static_cast<fsblkcnt_t>(rwBlks);
1280  buf->f_bfree = static_cast<fsblkcnt_t>(rwFree + ssFree);
1281  buf->f_bavail = static_cast<fsblkcnt_t>(rwFree);
1282  buf->f_ffree = rwNum + ssNum;
1283  buf->f_favail = rwNum;
1284  buf->f_namemax = 255; // The best we are going to do here
1285  buf->f_flag = (rwNum == 0 ? ST_RDONLY|ST_NOSUID : ST_NOSUID);
1286  return 0;
1287 }
1288 
1289 /******************************************************************************/
1290 /* T e l l d i r */
1291 /******************************************************************************/
1292 
1294 {
1295  XrdPosixDir *dP;
1296  long pos;
1297  int fildes = XrdPosixDir::dirNo(dirp);
1298 
1299 // Find the object
1300 //
1301  if (!(dP = XrdPosixObject::Dir(fildes)))
1302  return XrdPosixGlobals::ecMsg.SetErrno(EBADF,0);
1303 
1304 // Tell the current directory location
1305 //
1306  pos = dP->getOffset();
1307  dP->UnLock();
1308  return pos;
1309 }
1310 
1311 /******************************************************************************/
1312 /* T r u n c a t e */
1313 /******************************************************************************/
1314 
1315 int XrdPosixXrootd::Truncate(const char *path, off_t Size)
1316 {
1318  uint64_t tSize = static_cast<uint64_t>(Size);
1319 
1320 // Make sure the admin is OK
1321 //
1322  if (!admin.isOK()) return -1;
1323 
1324 // Truncate in the cache first
1325 //
1327  {LfnPath trunc("truncate", path);
1328  if (!trunc.path) return -1;
1329  XrdPosixGlobals::theCache->Truncate(trunc.path, tSize);
1330  }
1331 
1332 // Issue the truncate to the origin
1333 //
1334  std::string urlp = admin.Url.GetPathWithParams();
1335  return XrdPosixMap::Result(admin.Xrd.Truncate(urlp,tSize),
1336  XrdPosixGlobals::ecMsg,true);
1337 }
1338 
1339 /******************************************************************************/
1340 /* U n l i n k */
1341 /******************************************************************************/
1342 
1343 int XrdPosixXrootd::Unlink(const char *path)
1344 {
1346 
1347 // Make sure the admin is OK
1348 //
1349  if (!admin.isOK()) return -1;
1350 
1351 // Unlink the cache first
1352 //
1354  {LfnPath remf("unlink", path);
1355  if (!remf.path) return -1;
1356  XrdPosixGlobals::theCache->Unlink(remf.path);
1357  }
1358 
1359 // Issue the UnLink
1360 //
1362  return EcUnlink(path, admin);
1363 
1364  return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1365  XrdPosixGlobals::ecMsg, true);
1366 }
1367 
1368 /******************************************************************************/
1369 /* W r i t e */
1370 /******************************************************************************/
1371 
1372 ssize_t XrdPosixXrootd::Write(int fildes, const void *buf, size_t nbyte)
1373 {
1374  XrdPosixFile *fp;
1375  int iosz, bytes;
1376 
1377 // Find the file object
1378 //
1379  if (!(fp = XrdPosixObject::File(fildes))) return -1;
1380 
1381 // Make sure the size is not too large
1382 //
1383  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
1384  else iosz = static_cast<int>(nbyte);
1385 
1386 // Issue the write
1387 //
1388  bytes = fp->XCio->Write((char *)buf,fp->Offset(),(int)iosz);
1389  if (bytes < 0) return Fault(fp,-bytes);
1390 
1391 // All went well
1392 //
1393  fp->addOffset(iosz, 1);
1394  fp->UnLock();
1395  return (ssize_t)iosz;
1396 }
1397 
1398 /******************************************************************************/
1399 /* W r i t e v */
1400 /******************************************************************************/
1401 
1402 ssize_t XrdPosixXrootd::Writev(int fildes, const struct iovec *iov, int iovcnt)
1403 {
1404  ssize_t totbytes = 0;
1405  int i;
1406 
1407 // Return the results of the write for each iov segment
1408 //
1409  for (i = 0; i < iovcnt; i++)
1410  {if (!Write(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len))
1411  return -1;
1412  totbytes += iov[i].iov_len;
1413  }
1414 
1415 // All done
1416 //
1417  return totbytes;
1418 }
1419 
1420 /******************************************************************************/
1421 /* i s X r o o t d D i r */
1422 /******************************************************************************/
1423 
1425 {
1426  XrdPosixDir *dP;
1427  int fildes;
1428 
1429  if (!dirp) return false;
1430  fildes = XrdPosixDir::dirNo(dirp);
1431 
1432  if (!myFD(fildes) || !(dP = XrdPosixObject::Dir(fildes))) return false;
1433 
1434  dP->UnLock();
1435  return true;
1436 }
1437 
1438 /******************************************************************************/
1439 /* m y F D */
1440 /******************************************************************************/
1441 
1443 {
1444  return XrdPosixObject::Valid(fd);
1445 }
1446 
1447 /******************************************************************************/
1448 /* Q u e r y C h k s u m */
1449 /******************************************************************************/
1450 
1451 int XrdPosixXrootd::QueryChksum(const char *path, time_t &Mtime,
1452  char *value, int vsize)
1453 {
1455 
1456 // Stat the file first to allow vectoring of the request to the right server
1457 //
1458  if (!admin.Stat(0, &Mtime)) return -1;
1459 
1460 // Now we can get the checksum as we have landed on the right server
1461 //
1462  return admin.Query(XrdCl::QueryCode::Checksum, value, vsize);
1463 }
1464 
1465 /******************************************************************************/
1466 /* Q u e r y E r r o r */
1467 /******************************************************************************/
1468 
1469 int XrdPosixXrootd::QueryError(std::string& emsg, int fd, bool reset)
1470 {
1471  XrdOucECMsg* ecmP;
1472 
1473 // If global wanted then use that one otherwise find the object specific one
1474 //
1475  if (fd < 0) ecmP = &XrdPosixGlobals::ecMsg;
1476  else {XrdPosixFile *fp;
1477  if (!(fp = XrdPosixObject::File(fd))) return -1;
1478  ecmP = fp->getECMsg();
1479  }
1480 
1481 // Return the message information
1482 //
1483  return ecmP->Get(emsg, reset);
1484 }
1485 
1486 /******************************************************************************/
1487 
1488 int XrdPosixXrootd::QueryError(std::string& emsg, DIR* dirP, bool reset)
1489 {
1490  XrdPosixDir *dP;
1491  int fildes = XrdPosixDir::dirNo(dirP);
1492 
1493 // Find the object
1494 //
1495  if (!(dP = XrdPosixObject::Dir(fildes)))
1496  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
1497 
1498 // Return result
1499 //
1500  return dP->getECMsg()->Get(emsg, reset);
1501 }
1502 
1503 /******************************************************************************/
1504 /* Q u e r y O p a q u e */
1505 /******************************************************************************/
1506 
1507 long long XrdPosixXrootd::QueryOpaque(const char *path, char *value, int size)
1508 {
1510 
1511 // Stat the file first to allow vectoring of the request to the right server
1512 //
1513  if (!admin.Stat()) return -1;
1514 
1515 // Now we can get the checksum as we have landed on the right server
1516 //
1517  return admin.Query(XrdCl::QueryCode::OpaqueFile, value, size);
1518 }
1519 
1520 /******************************************************************************/
1521 /* P r i v a t e M e t h o d s */
1522 /******************************************************************************/
1523 /******************************************************************************/
1524 /* F a u l t */
1525 /******************************************************************************/
1526 
1527 int XrdPosixXrootd::Fault(XrdPosixFile *fp, int ecode, const char *msg)
1528 {
1529  fp->UnLock();
1530  return XrdPosixGlobals::ecMsg.SetErrno(ecode, -1, msg);
1531 }
1532 
1533 /******************************************************************************/
1534 /* E c R e n a m e */
1535 /******************************************************************************/
1536 
1537 int XrdPosixXrootd::EcRename(const char *oldpath, const char *newpath,
1538  XrdPosixAdmin &admin)
1539 {
1540  XrdCl::URL url(oldpath);
1541  XrdCl::URL newUrl(newpath);
1542 
1543  std::string file = url.GetPath();
1544  XrdCl::LocationInfo *info = nullptr;
1545  XrdCl::FileSystem fs(oldpath);
1546 
1547  XrdCl::Buffer queryArgs(5), *queryResp = nullptr;
1548  queryArgs.FromString("role");
1549  XrdCl::XRootDStatus st = fs.Query(XrdCl::QueryCode::Config, queryArgs, queryResp);
1550  // xrootdfs call this function with individual servers. but we can only do
1551  // fs.DeepLocate("*"...) agaist a redirector
1552  // xrootdfs already did a stat and know that this is a file, not a dir
1553  if (!st.IsOK() || queryResp->ToString() == "server"
1554  || queryResp->ToString() == "server\n")
1555  {
1556  if (queryResp) delete queryResp;
1557  return XrdPosixMap::Result(admin.Xrd.Mv(admin.Url.GetPathWithParams(),
1558  newUrl.GetPathWithParams()),
1559  XrdPosixGlobals::ecMsg, true);
1560  }
1561  else
1562  if (queryResp) delete queryResp;
1563 
1564  st = fs.DeepLocate("*", XrdCl::OpenFlags::None, info );
1565  std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1566  if( !st.IsOK() )
1567  return XrdPosixMap::Result(st, XrdPosixGlobals::ecMsg, true);
1568 
1569  // check if this is a file or a dir, do not support dir renaming in EC
1570  struct stat buf;
1571  if (XrdPosixXrootd::Stat(oldpath, &buf) != 0)
1572  return XrdPosixGlobals::ecMsg.SetErrno(ENOENT);
1573 
1574  if ( ! S_ISREG(buf.st_mode))
1575  return XrdPosixGlobals::ecMsg.SetErrno(ENOTSUP);
1576 
1577  if (XrdPosixXrootd::Stat(newpath, &buf) == 0)
1578  return XrdPosixGlobals::ecMsg.SetErrno(EEXIST);
1579 
1580  int rc = -ENOENT;
1581  for( size_t i = 0; i < info->GetSize(); ++i )
1582  {
1583  std::string url_i = "root://" + info->At(i).GetAddress() + "/" + file;
1584  XrdPosixAdmin *admin_i = new XrdPosixAdmin(url_i.c_str(),admin.ecMsg);
1585  int x = XrdPosixMap::Result(admin_i->Xrd.Mv(admin_i->Url.GetPathWithParams(),
1586  newUrl.GetPathWithParams()),
1587  admin.ecMsg);
1588  if (x != -ENOENT && rc != 0)
1589  rc = x;
1590  if (admin_i) delete admin_i;
1591  }
1592  return rc;
1593 }
1594 
1595 /******************************************************************************/
1596 /* E c S t a t */
1597 /******************************************************************************/
1598 
1599 int XrdPosixXrootd::EcStat(const char *path, struct stat *buf,
1600  XrdPosixAdmin &admin)
1601 {
1602  XrdCl::URL url(path);
1603  std::string file = url.GetPath();
1604  XrdCl::LocationInfo *info = nullptr;
1605  XrdCl::FileSystem fs(path);
1606 
1607  std::vector<std::string> xattrkeys;
1608  std::vector<XrdCl::XAttr> xattrvals;
1609  xattrkeys.push_back("xrdec.strpver");
1610  xattrkeys.push_back("xrdec.filesize");
1611 
1612  XrdCl::Buffer queryArgs(5), *queryResp = nullptr;
1613  queryArgs.FromString("role");
1614  XrdCl::XRootDStatus st = fs.Query(XrdCl::QueryCode::Config, queryArgs, queryResp);
1615  // xrootdfs call this function with individual servers. but we can only do
1616  // // fs.DeepLocate("*"...) agaist a redirector
1617  if (!st.IsOK() || queryResp->ToString() == "server"
1618  || queryResp->ToString() == "server\n")
1619  {
1620  if (queryResp) delete queryResp;
1621  if (!admin.Stat(*buf))
1622  return -1;
1623  else
1624  {
1625  st = fs.GetXAttr(file, xattrkeys, xattrvals, 0);
1626  if (! xattrvals[0].value.empty())
1627  {
1628  std::stringstream sstream0(xattrvals[0].value);
1629  sstream0 >> buf->st_mtime;
1630  std::stringstream sstream1(xattrvals[1].value);
1631  sstream1 >> buf->st_size;
1632  buf->st_blocks = (buf->st_size + 512)/512;
1633  }
1634  return 0;
1635  }
1636  }
1637  else
1638  if (queryResp) delete queryResp;
1639 
1640  st = fs.DeepLocate("*", XrdCl::OpenFlags::None, info );
1641  std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1642  if( !st.IsOK() )
1643  {
1644  errno = ENOENT;
1645  return -1;
1646  }
1647 
1648  int found = 0;
1649  uint64_t verNumMax = 0;
1650  struct stat buf_i;
1651  XrdPosixConfig::initStat(&buf_i);
1652  for( size_t i = 0; i < info->GetSize(); ++i )
1653  {
1654  std::string url_i = "root://" + info->At(i).GetAddress() + "/" + file;
1655  XrdPosixAdmin *admin_i = new XrdPosixAdmin(url_i.c_str(),admin.ecMsg);
1656 
1657  if (admin_i->Stat(buf_i))
1658  {
1659  if (! S_ISREG(buf_i.st_mode))
1660  {
1661  memcpy(buf, &buf_i, sizeof(struct stat));
1662  if (admin_i) delete admin_i;
1663  return 0;
1664  }
1665  else
1666  {
1667  if (verNumMax == 0) memcpy(buf, &buf_i, sizeof(struct stat));
1668  found = 1;
1669  }
1670  XrdCl::FileSystem *fs_i = new XrdCl::FileSystem(info->At( i ).GetAddress());
1671 
1672  xattrvals.clear();
1673  st = fs_i->GetXAttr(file, xattrkeys, xattrvals, 0);
1674  if (! xattrvals[0].value.empty())
1675  {
1676  std::stringstream sstream(xattrvals[0].value);
1677  uint64_t verNum;
1678  sstream >> verNum;
1679  if ( verNum > verNumMax )
1680  {
1681  verNumMax = verNum;
1682  memcpy(buf, &buf_i, sizeof(struct stat));
1683  buf->st_mtime = verNumMax; // assume verNum is mtime
1684  std::stringstream sstream(xattrvals[1].value);
1685  sstream >> buf->st_size;
1686  buf->st_blocks = (buf->st_size + 512)/512;
1687  }
1688  }
1689  if (fs_i) delete fs_i;
1690  }
1691  if (admin_i) delete admin_i;
1692  }
1693  if (! found)
1694  {
1695  errno = ENOENT;
1696  return -1;
1697  }
1698  return 0;
1699 }
1700 
1701 /******************************************************************************/
1702 /* E c U n l i n k */
1703 /******************************************************************************/
1704 
1705 int XrdPosixXrootd::EcUnlink(const char *path, XrdPosixAdmin &admin)
1706 {
1707  XrdCl::URL url(path);
1708  std::string file = url.GetPath();
1709  XrdCl::LocationInfo *info = nullptr;
1710  XrdCl::FileSystem fs(path);
1711 
1712  XrdCl::Buffer queryArgs(5), *queryResp = nullptr;
1713  queryArgs.FromString("role");
1714  XrdCl::XRootDStatus st = fs.Query(XrdCl::QueryCode::Config, queryArgs, queryResp);
1715  // xrootdfs call this function with individual servers. but we can only do
1716  // fs.DeepLocate("*"...) agaist a redirector
1717  if (!st.IsOK() || queryResp->ToString() == "server"
1718  || queryResp->ToString() == "server\n")
1719  {
1720  if (queryResp) delete queryResp;
1721  return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1722  admin.ecMsg, true);
1723  }
1724  else
1725  if (queryResp) delete queryResp;
1726 
1727  st = fs.DeepLocate("*", XrdCl::OpenFlags::None, info );
1728  std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1729  if( !st.IsOK() )
1730  return XrdPosixMap::Result(st, admin.ecMsg, true);
1731 
1732  int rc = -ENOENT;
1733  for( size_t i = 0; i < info->GetSize(); ++i )
1734  {
1735  std::string url_i = "root://" + info->At(i).GetAddress() + "/" + file;
1736  XrdPosixAdmin *admin_i = new XrdPosixAdmin(url_i.c_str(),admin.ecMsg);
1737  int x = XrdPosixMap::Result(admin_i->
1738  Xrd.Rm(admin_i->Url.GetPathWithParams()),
1739  admin.ecMsg);
1740  if (x != -ENOENT && rc != 0)
1741  rc = x;
1742  if (admin_i) delete admin_i;
1743  }
1744  return rc;
1745 }
#define ENOATTR
Definition: XProtocol.hh:1339
#define DEBUG(x)
Definition: XrdBwmTrace.hh:54
#define EPNAME(x)
Definition: XrdBwmTrace.hh:56
#define TRACE_Debug
Definition: XrdCmsTrace.hh:37
int stat(const char *path, struct stat *buf)
int statvfs(const char *path, struct statvfs *buf)
int statfs(const char *path, struct statfs *buf)
#define DEBUGON
XrdVERSIONINFO(XrdPosix, XrdPosix)
int emsg(int rc, char *msg)
Binary blob representation.
Definition: XrdClBuffer.hh:34
void FromString(const std::string str)
Fill the buffer from a string.
Definition: XrdClBuffer.hh:205
std::string ToString() const
Convert the buffer to a string.
Definition: XrdClBuffer.hh:215
Send file/filesystem queries to an XRootD cluster.
XRootDStatus RmDir(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Mv(const std::string &source, const std::string &dest, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Rm(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus GetXAttr(const std::string &path, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus Truncate(const std::string &path, uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus MkDir(const std::string &path, MkDirFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus StatVFS(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
bool IsOpen() const
Check if the file is open.
Definition: XrdClFile.cc:846
XRootDStatus Open(const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
Definition: XrdClFile.cc:99
bool GetProperty(const std::string &name, std::string &value) const
Definition: XrdClFile.cc:878
const std::string & GetAddress() const
Get address.
Path location info.
uint32_t GetSize() const
Get number of locations.
Location & At(uint32_t index)
Get the location at index.
Handle an async response.
uint64_t GetFreeRW() const
Get size of the largest contiguous area of free r/w space (in MB)
uint64_t GetNodesStaging() const
Get number of nodes that can provide staging space.
uint8_t GetUtilizationStaging() const
Get percentage of the partition utilization represented by FreeStaging.
uint64_t GetFreeStaging() const
Get size of the largest contiguous area of free staging space (in MB)
uint8_t GetUtilizationRW() const
Get percentage of the partition utilization represented by FreeRW.
uint64_t GetNodesRW() const
Get number of nodes that can provide read/write space.
URL representation.
Definition: XrdClURL.hh:31
std::string GetPathWithParams() const
Get the path with params.
Definition: XrdClURL.cc:304
bool IsValid() const
Is the url valid.
Definition: XrdClURL.cc:438
int GetPort() const
Get the target port.
Definition: XrdClURL.hh:183
virtual int Read(char *buff, long long offs, int rlen)=0
virtual int Fstat(struct stat &sbuff)
Definition: XrdOucCache.hh:148
virtual int Write(char *buff, long long offs, int wlen)=0
virtual int Sync()=0
virtual long long FSize()=0
virtual bool Detach(XrdOucCacheIOCD &iocd)=0
virtual int Trunc(long long offs)=0
virtual int ReadV(const XrdOucIOVec *readV, int rnum)
Definition: XrdOucCache.cc:86
virtual int Rename(const char *oldp, const char *newp)
Definition: XrdOucCache.hh:610
virtual int Stat(const char *url, struct stat &sbuff)
Definition: XrdOucCache.hh:638
virtual int Truncate(const char *path, off_t size)
Definition: XrdOucCache.hh:651
virtual int Unlink(const char *path)
Definition: XrdOucCache.hh:663
virtual int LocalFilePath(const char *url, char *buff=0, int blen=0, LFP_Reason why=ForAccess, bool forall=false)
Definition: XrdOucCache.hh:572
virtual int Prepare(const char *url, int oflags, mode_t mode)
Definition: XrdOucCache.hh:597
virtual int Rmdir(const char *dirp)
Definition: XrdOucCache.hh:622
int Get(std::string &ecm, bool rst=true)
Definition: XrdOucECMsg.cc:41
int SetErrno(int ecc, int retval=-1, const char *alt=0)
Definition: XrdOucECMsg.cc:144
void Put(const char *varname, const char *value)
Definition: XrdOucEnv.hh:85
bool ClientConfig(const char *pfx, bool hush=false)
Definition: XrdOucPsx.cc:100
bool Stat(mode_t *flags=0, time_t *mtime=0)
XrdCl::FileSystem Xrd
XrdOucECMsg & ecMsg
int Query(XrdCl::QueryCode::Code reqCode, void *buff, int bsz)
XrdCl::URL Url
virtual void Complete(ssize_t Result)=0
An abstract class to define a callback for Open() call.
virtual void Complete(int Result)=0
static void initStat(struct stat *buf)
static bool SetConfig(XrdOucPsx &parms)
static int dirNo(DIR *dirP)
Definition: XrdPosixDir.hh:60
void rewind()
Definition: XrdPosixDir.hh:72
long getOffset()
Definition: XrdPosixDir.hh:64
DIR * Open()
Definition: XrdPosixDir.cc:94
bool Unread()
Definition: XrdPosixDir.hh:78
dirent64 * nextEntry(dirent64 *dp=0)
Definition: XrdPosixDir.cc:48
void setOffset(long offset)
Definition: XrdPosixDir.hh:66
int Status()
Definition: XrdPosixDir.hh:76
long getEntries()
Definition: XrdPosixDir.hh:62
const char * Path() override
static const int isUpdt
static const int isStrm
XrdPosixPrepIO * PrepIO
Definition: XrdPosixFile.hh:66
void UpdtSize(size_t newsz)
long long addOffset(long long offs, int updtSz=0)
Definition: XrdPosixFile.hh:69
int Fstat(struct stat &buf) override
const char * Origin()
bool Close(XrdCl::XRootDStatus &Status)
XrdCl::File clFile
Definition: XrdPosixFile.hh:67
XrdOucCacheIO * XCio
Definition: XrdPosixFile.hh:65
long long Offset()
bool Finalize(XrdCl::XRootDStatus *Status)
long long setOffset(long long offs)
static void * DelayedDestroy(void *)
static int Result(const XrdCl::XRootDStatus &Status, XrdOucECMsg &ecMsg, bool retneg1=false)
Definition: XrdPosixMap.cc:150
static XrdCl::Access::Mode Mode2Access(mode_t mode)
Definition: XrdPosixMap.cc:130
XrdOucECMsg * getECMsg()
static void Shutdown()
bool AssignFD(bool isStream=false)
static XrdPosixDir * Dir(int fildes, bool glk=false)
static XrdPosixDir * ReleaseDir(int fildes)
static int Init(int numfd)
static XrdPosixFile * ReleaseFile(int fildes)
static bool Valid(int fd)
static bool CanStream()
XrdOucECMsg ecMsg
static XrdPosixFile * File(int fildes, bool glk=false)
void Count(long long &Dest)
static const char * P2L(const char *who, const char *inP, char *&relP, bool ponly=false)
static ssize_t Readv(int fildes, const struct iovec *iov, int iovcnt)
Readv() conforms to POSIX.1-2001 readv()
static ssize_t Pread(int fildes, void *buf, size_t nbyte, off_t offset)
Pread() conforms to POSIX.1-2001 pread()
static int Closedir(DIR *dirp)
Closedir() conforms to POSIX.1-2001 closedir()
static void Seekdir(DIR *dirp, long loc)
Seekdir() conforms to POSIX.1-2001 seekdir()
static const int isStream
static int Stat(const char *path, struct stat *buf)
Stat() conforms to POSIX.1-2001 stat()
static int QueryChksum(const char *path, time_t &mtime, char *buff, int blen)
static int Mkdir(const char *path, mode_t mode)
Mkdir() conforms to POSIX.1-2001 mkdir()
static int Unlink(const char *path)
Unlink() conforms to POSIX.1-2001 unlink()
static int Rmdir(const char *path)
Rmdir() conforms to POSIX.1-2001 rmdir()
static void Rewinddir(DIR *dirp)
Rewinddir() conforms to POSIX.1-2001 rewinddir()
static void VRead(int fildes, const XrdOucIOVec *readV, int n, XrdPosixCallBackIO *cbp)
static int Rename(const char *oldpath, const char *newpath)
Rename() conforms to POSIX.1-2001 rename()
static int Close(int fildes)
Close() conforms to POSIX.1-2001 close()
static int Statvfs(const char *path, struct statvfs *buf)
Statvfs() conforms to POSIX.1-2001 statvfs()
static int endPoint(int FD, char *Buff, int Blen)
static ssize_t Write(int fildes, const void *buf, size_t nbyte)
Write() conforms to POSIX.1-2001 write()
static struct dirent * Readdir(DIR *dirp)
static int Readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
static ssize_t Writev(int fildes, const struct iovec *iov, int iovcnt)
Writev() conforms to POSIX.1-2001 writev()
static int QueryError(std::string &emsg, int fd=-1, bool reset=true)
static struct dirent64 * Readdir64(DIR *dirp)
XrdPosixXrootd(int maxfd=255, int maxdir=0, int maxthr=0)
static bool myFD(int fd)
static int Ftruncate(int fildes, off_t offset)
Ftruncate() conforms to POSIX.1-2001 ftruncate()
static long Telldir(DIR *dirp)
Telldir() conforms to POSIX.1-2001 telldir()
static bool isXrootdDir(DIR *dirp)
static int Access(const char *path, int amode)
Access() conforms to POSIX.1-2001 access()
static DIR * Opendir(const char *path)
Opendir() conforms to POSIX.1-2001 opendir()
static int Fsync(int fildes)
Fsync() conforms to POSIX.1-2001 fsync()
static long long Getxattr(const char *path, const char *name, void *value, unsigned long long size)
static long long QueryOpaque(const char *path, char *buff, int blen)
static int Statfs(const char *path, struct statfs *buf)
static int Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
static ssize_t Read(int fildes, void *buf, size_t nbyte)
Read() conforms to POSIX.1-2001 read()
static int Fstat(int fildes, struct stat *buf)
Fstat() conforms to POSIX.1-2001 fstat()
static off_t Lseek(int fildes, off_t offset, int whence)
Lseek() conforms to POSIX.1-2001 lseek()
static int Open(const char *path, int oflag, mode_t mode=0, XrdPosixCallBack *cbP=0)
static ssize_t Pwrite(int fildes, const void *buf, size_t nbyte, off_t offset)
Pwrite() conforms to POSIX.1-2001 pwrite()
static int Truncate(const char *path, off_t offset)
Telldir() conforms to POSIX.1-2001 telldir()
int Opts
Definition: XrdMpxStats.cc:58
XrdScheduler * schedP
XrdSysLogger * theLogger
XrdPosixStats Stats
Definition: XrdPosixFile.cc:63
thread_local XrdOucECMsg ecMsg
XrdSysError * eDest
Definition: XrdPosixFile.cc:62
XrdOucCache * theCache
XrdOucName2Name * theN2N
Definition: XrdPosixFile.cc:61
XrdSysTrace Trace
XrdCl::DirListFlags::Flags dlFlag
Definition: XrdPosixDir.cc:41
Mode
Access mode.
@ None
Nothing special.
@ None
Nothing special.
@ MakePath
create the entire directory tree if it doesn't exist
Flags
Open flags, may be or'd when appropriate.
@ Read
Open only for reading.
@ Update
Open for reading and writing.
Code
XRootD query request codes.
@ OpaqueFile
Implementation dependent.
@ XAttr
Query file extended attributes.
@ Config
Query server configuration.
@ Checksum
Query file checksum.
@ Space
Query logical space stats.
bool IsOK() const
We're fine.
Definition: XrdClStatus.hh:124
std::string ToString() const
Create a string representation.
Definition: XrdClStatus.cc:97