XrdOss.hh

Go to the documentation of this file.

#ifndef _XRDOSS_H
#define _XRDOSS_H
/******************************************************************************/
/*                                                                            */
/*                             X r d O s s . h h                              */
/*                                                                            */
/* (c) 2003 by the Board of Trustees of the Leland Stanford, Jr., University  */
/*                            All Rights Reserved                             */
/*   Produced by Andrew Hanushevsky for Stanford University under contract    */
/*              DE-AC02-76-SFO0515 with the Department of Energy              */
/*                                                                            */
/* This file is part of the XRootD software suite.                            */
/*                                                                            */
/* XRootD is free software: you can redistribute it and/or modify it under    */
/* the terms of the GNU Lesser General Public License as published by the     */
/* Free Software Foundation, either version 3 of the License, or (at your     */
/* option) any later version.                                                 */
/*                                                                            */
/* XRootD is distributed in the hope that it will be useful, but WITHOUT      */
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      */
/* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public       */
/* License for more details.                                                  */
/*                                                                            */
/* You should have received a copy of the GNU Lesser General Public License   */
/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
/* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
/*                                                                            */
/* The copyright holder's institutional names and contributor's names may not */
/* be used to endorse or promote products derived from this software without  */
/* specific prior written permission of the institution or contributor.       */
/******************************************************************************/
 
#include <dirent.h>
#include <cerrno>
#include <cstdint>
#include <strings.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <cstring>
 
#include "XrdOss/XrdOssVS.hh"
#include "XrdOuc/XrdOucIOVec.hh"
 
class XrdOucEnv;
class XrdSysLogger;
class XrdSfsAio;
 
#ifndef XrdOssOK
#define XrdOssOK 0
#endif
 
/******************************************************************************/
/*                        C l a s s   X r d O s s D F                         */
/******************************************************************************/
 
  
class XrdOssDF
{
public:
 
/******************************************************************************/
/*            D i r e c t o r y   O r i e n t e d   M e t h o d s             */
/******************************************************************************/
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Opendir(const char *path, XrdOucEnv &env) {return -ENOTDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Readdir(char *buff, int blen) {return -ENOTDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     StatRet(struct stat *buff) {return -ENOTSUP;}
 
/******************************************************************************/
/*                 F i l e   O r i e n t e d   M e t h o d s                  */
/******************************************************************************/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fchmod(mode_t mode) {return -EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void    Flush() {}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fstat(struct stat *buf) {return -EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fsync() {return -EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fsync(XrdSfsAio *aiop) {return -EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Ftruncate(unsigned long long flen) {return -EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual off_t   getMmap(void **addr) {*addr = 0; return 0;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     isCompressed(char *cxidp=0) {(void)cxidp; return 0;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Open(const char *path, int Oflag, mode_t Mode, XrdOucEnv &env)
                    {return -EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
// pgRead and pgWrite options as noted.
//
static const uint64_t
Verify       = 0x8000000000000000ULL; 
static const uint64_t
doCalc       = 0x4000000000000000ULL; 
 
virtual ssize_t pgRead (void* buffer, off_t offset, size_t rdlen,
                        uint32_t* csvec, uint64_t opts);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     pgRead (XrdSfsAio* aioparm, uint64_t opts);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t pgWrite(void* buffer, off_t offset, size_t wrlen,
                        uint32_t* csvec, uint64_t opts);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     pgWrite(XrdSfsAio* aioparm, uint64_t opts);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Read(off_t offset, size_t size) {return (ssize_t)-EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Read(void *buffer, off_t offset, size_t size)
                    {return (ssize_t)-EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Read(XrdSfsAio *aiop) {(void)aiop; return (ssize_t)-EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t ReadRaw(void *buffer, off_t offset, size_t size)
                       {return (ssize_t)-EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t ReadV(XrdOucIOVec *readV, int rdvcnt);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Write(const void *buffer, off_t offset, size_t size)
                     {return (ssize_t)-EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Write(XrdSfsAio *aiop) {(void)aiop; return (ssize_t)-EISDIR;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t WriteV(XrdOucIOVec *writeV, int wrvcnt);
 
/******************************************************************************/
/*     C o m m o n   D i r e c t o r y   a n d   F i l e   M e t h o d s      */
/******************************************************************************/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Close(long long *retsz=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
// Returned value will have one or more bits set as below.
//
static const uint16_t DF_isDir   = 0x0001;  
static const uint16_t DF_isFile  = 0x0002;  
static const uint16_t DF_isProxy = 0x0010;  
 
uint16_t        DFType() {return dfType;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
static const int Fctl_ckpObj = 0;
static const int Fctl_utimes = 1;
 
virtual int     Fctl(int cmd, int alen, const char *args, char **resp=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     getFD() {return -1;} // Must override to support sendfile()
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
virtual
const char     *getTID() {return tident;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
                XrdOssDF(const char *tid="", uint16_t dftype=0, int fdnum=-1)
                        : tident(tid), pgwEOF(0), fd(fdnum), dfType(dftype),
                          rsvd(0) {}
 
virtual        ~XrdOssDF() {}
 
 
protected:
 
const char *tident;  // Trace identifier
off_t       pgwEOF;  // Highest short offset on pgWrite (0 means none yet)
int         fd;      // The associated file descriptor.
uint16_t    dfType;  // Type of this object
short       rsvd;    // Reserved
};
 
/******************************************************************************/
/*                        X r d O s s   O p t i o n s                         */
/******************************************************************************/
 
// Options that can be passed to Create()
//
#define XRDOSS_mkpath  0x01
#define XRDOSS_new     0x02
#define XRDOSS_Online  0x04
#define XRDOSS_isPFN   0x10
#define XRDOSS_isMIG   0x20
#define XRDOSS_setnoxa 0x40
 
// Values returned by Features()
//
#define XRDOSS_HASPGRW 0x0000000000000001ULL
#define XRDOSS_HASFSCS 0x0000000000000002ULL
#define XRDOSS_HASPRXY 0x0000000000000004ULL
#define XRDOSS_HASNOSF 0x0000000000000008ULL
#define XRDOSS_HASCACH 0x0000000000000010ULL
#define XRDOSS_HASNAIO 0x0000000000000020ULL
#define XRDOSS_HASRPXY 0x0000000000000040ULL
 
// Options that can be passed to Stat()
//
#define XRDOSS_resonly 0x0001
#define XRDOSS_updtatm 0x0002
#define XRDOSS_preop   0x0004
 
// Commands that can be passed to FSctl
//
#define XRDOSS_FSCTLFA 0x0001
  
/******************************************************************************/
/*                          C l a s s   X r d O s s                           */
/******************************************************************************/
  
class XrdOss
{
public:
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual XrdOssDF *newDir(const char *tident)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual XrdOssDF *newFile(const char *tident)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Chmod(const char * path, mode_t mode, XrdOucEnv *envP=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void      Connect(XrdOucEnv &env);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Create(const char *tid, const char *path,
                         mode_t mode, XrdOucEnv &env,
                         int opts=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void      Disc(XrdOucEnv &env);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void      EnvInfo(XrdOucEnv *envP);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual uint64_t  Features();
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       FSctl(int cmd, int alen, const char *args, char **resp=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Init(XrdSysLogger *lp, const char *cfn)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Init(XrdSysLogger *lp, const char *cfn, XrdOucEnv *envP)
                      {return Init(lp, cfn);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Mkdir(const char *path, mode_t mode, int mkpath=0,
                        XrdOucEnv  *envP=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Reloc(const char *tident, const char *path,
                        const char *cgName, const char *anchor=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Remdir(const char *path, int Opts=0, XrdOucEnv *envP=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Rename(const char *oPath, const char *nPath,
                         XrdOucEnv  *oEnvP=0, XrdOucEnv *nEnvP=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Stat(const char *path, struct stat *buff,
                       int opts=0, XrdOucEnv *envP=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Stats(char *buff, int blen) {(void)buff; (void)blen; return 0;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatFS(const char *path, char *buff, int &blen,
                         XrdOucEnv  *envP=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatLS(XrdOucEnv &env, const char *path,
                         char *buff, int &blen);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
static const int  PF_dInfo = 0x00000001;
static const int  PF_dNums = 0x00000002;
static const int  PF_isLFN = 0x00000004;
static const int  PF_dStat = 0x00000008;
 
// Bits returned in st_rdev when PF_dStat specified in opts. Absence of either
// PF_csVer and PF_csVun flags means that the file has no checksums present.
//
static const int  PF_csVer = 0x00000001; 
static const int  PF_csVun = 0x00000002; 
 
virtual int       StatPF(const char *path, struct stat *buff, int opts);
 
virtual int       StatPF(const char *path, struct stat *buff)
                        {return StatPF(path, buff, 0);} // Backward compat
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatVS(XrdOssVSInfo *vsP, const char *sname=0, int updt=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatXA(const char *path, char *buff, int &blen,
                         XrdOucEnv *envP=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatXP(const char *path, unsigned long long &attr,
                         XrdOucEnv  *envP=0);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Truncate(const char *path, unsigned long long fsize,
                           XrdOucEnv *envP=0)=0;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Unlink(const char *path, int Opts=0, XrdOucEnv *envP=0)=0;
 
                  // Default Name-to-Name Methods
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Lfn2Pfn(const char *Path, char *buff, int blen)
                         {if ((int)strlen(Path) >= blen) return -ENAMETOOLONG;
                          strcpy(buff, Path); return 0;
                         }
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
virtual
const char       *Lfn2Pfn(const char *Path, char *buff, int blen, int &rc)
                         { (void)buff; (void)blen; rc = 0; return Path;}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
                XrdOss() {}
virtual        ~XrdOss() {}
};
 
/******************************************************************************/
/*           S t o r a g e   S y s t e m   I n s t a n t i a t o r            */
/******************************************************************************/
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
typedef XrdOss *(*XrdOssGetStorageSystem_t) (XrdOss        *native_oss,
                                             XrdSysLogger  *Logger,
                                             const char    *config_fn,
                                             const char    *parms);
 
typedef XrdOss *(*XrdOssGetStorageSystem2_t)(XrdOss       *native_oss,
                                             XrdSysLogger *Logger,
                                             const char   *config_fn,
                                             const char   *parms,
                                             XrdOucEnv    *envP);
 
typedef XrdOssGetStorageSystem2_t XrdOssAddStorageSystem2_t;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#endif