XrdBwmFile Class Reference

#include <XrdBwm.hh>

Inheritance diagram for XrdBwmFile:

Collaboration diagram for XrdBwmFile:

Public Member Functions
	XrdBwmFile (const char *user, int monid)
virtual	~XrdBwmFile ()
int	close ()
int	fctl (const int cmd, const char *args, XrdOucErrInfo &out_error)
virtual int	fctl (const int cmd, int alen, const char *args, const XrdSecEntity *client=0)
const char *	FName ()
int	getCXinfo (char cxtype[4], int &cxrsz)
int	getMmap (void **Addr, off_t &Size)
int	open (const char *fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity *client, const char *opaque=0)
int	read (XrdSfsAio *aioparm)
XrdSfsXferSize	read (XrdSfsFileOffset fileOffset, char *buffer, XrdSfsXferSize buffer_size)
int	read (XrdSfsFileOffset fileOffset, XrdSfsXferSize amount)
int	stat (struct stat *buf)
int	sync ()
int	sync (XrdSfsAio *aiop)
int	truncate (XrdSfsFileOffset fileOffset)
int	write (XrdSfsAio *aioparm)
XrdSfsXferSize	write (XrdSfsFileOffset fileOffset, const char *buffer, XrdSfsXferSize buffer_size)
Public Member Functions inherited from XrdSfsFile
	XrdSfsFile (const char *user=0, int MonID=0)
	XrdSfsFile (XrdOucErrInfo &eInfo)
	XrdSfsFile (XrdSfsFile &wrapF)
virtual	~XrdSfsFile ()
	Destructor.
virtual int	checkpoint (cpAct act, struct iov *range=0, int n=0)
virtual int	Clone (const std::vector< XrdOucCloneSeg > &cVec)
virtual int	Clone (XrdSfsFile &srcFile)
virtual int	pgRead (XrdSfsAio *aioparm, uint64_t opts=0)
virtual XrdSfsXferSize	pgRead (XrdSfsFileOffset offset, char *buffer, XrdSfsXferSize rdlen, uint32_t *csvec, uint64_t opts=0)
virtual int	pgWrite (XrdSfsAio *aioparm, uint64_t opts=0)
virtual XrdSfsXferSize	pgWrite (XrdSfsFileOffset offset, char *buffer, XrdSfsXferSize wrlen, uint32_t *csvec, uint64_t opts=0)
virtual XrdSfsXferSize	read (XrdOucRangeList &rlist)
virtual XrdSfsXferSize	readv (XrdOucIOVec *readV, int rdvCnt)
virtual int	SendData (XrdSfsDio *sfDio, XrdSfsFileOffset offset, XrdSfsXferSize size)
virtual void	setXio (XrdSfsXio *xioP)
virtual XrdSfsXferSize	writev (XrdOucIOVec *writeV, int wdvCnt)

Protected Attributes
const char *	tident

Additional Inherited Members
Public Types inherited from XrdSfsFile
enum	cpAct {   cpCreate =0 ,   cpDelete ,   cpRestore ,   cpQuery ,   cpTrunc ,   cpWrite }
Public Attributes inherited from XrdSfsFile
XrdOucErrInfo &	error
Static Public Attributes inherited from XrdSfsFile
static const uint64_t	Verify = 0x8000000000000000ULL
	Options for pgRead() and pgWrite() as noted below.

Detailed Description

Definition at line 82 of file XrdBwm.hh.

Constructor & Destructor Documentation

XrdBwmFile()

XrdBwmFile::XrdBwmFile	(	const char *	user,
		int	monid )

Definition at line 135 of file XrdBwm.cc.

                                                  : XrdSfsFile(user, monid)
{
   oh = XrdBwm::dummyHandle;
   tident = (user ? user : "");
}

References XrdSfsFile::XrdSfsFile(), and tident.

Referenced by stat().

Here is the call graph for this function:

Here is the caller graph for this function:

~XrdBwmFile()

virtual XrdBwmFile::~XrdBwmFile ( )

inlinevirtual

Definition at line 131 of file XrdBwm.hh.

{if (oh) close();}

References close().

Here is the call graph for this function:

Member Function Documentation

close()

int XrdBwmFile::close ( )

virtual

Close the file.

Returns

One of SFS_OK or SFS_ERROR.

Implements XrdSfsFile.

Definition at line 336 of file XrdBwm.cc.

{
   EPNAME("close");
   XrdBwmHandle *hP;
 
// Trace the call
//
   FTRACE(calls, "close" <<oh->Name());
 
// Verify the handle (we briefly maintain a global lock)
//
   XrdBwmFS.ocMutex.Lock();
   if (oh == XrdBwm::dummyHandle)
      {XrdBwmFS.ocMutex.UnLock(); return SFS_OK;}
   hP = oh; oh = XrdBwm::dummyHandle;
   XrdBwmFS.ocMutex.UnLock();
 
// Now retire it and possibly return the token
//
   hP->Retire();
 
// All done
//
   return SFS_OK;
}

References EPNAME, FTRACE, XrdBwmHandle::Retire(), SFS_OK, and XrdBwmFS.

Referenced by ~XrdBwmFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fctl() [1/2]

int XrdBwmFile::fctl ( const int cmd, const char * args, XrdOucErrInfo & eInfo )

virtual

Execute a special operation on the file (version 1)

Parameters

cmd	- The operation to be performed (see below). SFS_FCTL_GETFD Return file descriptor if possible SFS_FCTL_STATV Reserved for future use.
args	- specific arguments to cmd SFS_FCTL_GETFD Set to zero.
eInfo	- The object where error info or results are to be returned. This is legacy and the error onject may be used as well.

Returns

If an error occurs or the operation is not support, SFS_ERROR should be returned with error.code set to errno. Otherwise, SFS_FCTL_GETFD error.code holds the real file descriptor number If the value is negative, sendfile() is not used. If the value is SFS_SFIO_FDVAL then the SendData() method is used for future read requests.

Implements XrdSfsFile.

Definition at line 373 of file XrdBwm.cc.

{
 
// Make sure the file is open
//
   if (oh == XrdBwm::dummyHandle)
      return XrdBwmFS.Emsg("fctl", out_error, EBADF, "fctl file");
 
// Scan through the fctl operations
//
   switch(cmd)
         {case SFS_FCTL_GETFD:  out_error.setErrInfo(-1,"");
                                return SFS_OK;
          case SFS_FCTL_STATV:  return oh->Activate(out_error);
          default:              break;
         }
 
// Invalid fctl
//
   out_error.setErrInfo(EINVAL, "invalid fctl command");
   return SFS_ERROR;
}

References XrdOucErrInfo::setErrInfo(), SFS_ERROR, SFS_FCTL_GETFD, SFS_FCTL_STATV, SFS_OK, and XrdBwmFS.

Here is the call graph for this function:

fctl() [2/2]

int XrdSfsFile::fctl ( const int cmd, int alen, const char * args, const XrdSecEntity * client = 0 )

virtual

Execute a special operation on the file (version 2)

Parameters

cmd	- The operation to be performed: SFS_FCTL_SPEC1 Perform implementation defined action V1 SFS_FCTL_SPEC2 Perform implementation defined action V2
alen	- Length of data pointed to by args.
args	- Data sent with request, zero if alen is zero.
client	- Client's identify (see common description).

Returns

SFS_OK a null response is sent.

SFS_DATA error.code length of the data to be sent. error.message contains the data to be sent. o/w one of SFS_ERROR, SFS_REDIRECT, or SFS_STALL.

Reimplemented from XrdSfsFile.

Definition at line 521 of file XrdSfsInterface.cc.

{
  (void)cmd; (void)alen; (void)args; (void)client;
  return SFS_OK;
}

FName()

const char * XrdBwmFile::FName ( )

inlinevirtual

Get the file path.

Returns

Null terminated string of the path used in open().

Implements XrdSfsFile.

Definition at line 100 of file XrdBwm.hh.

{return (oh ? oh->Name() : "?");}

Referenced by stat().

Here is the caller graph for this function:

getCXinfo()

int XrdBwmFile::getCXinfo ( char cxtype[4], int & cxrsz )

virtual

Get compression information for the file.

Parameters

cxtype	- Place where the compression algorithm name is to be placed
cxrsz	- Place where the compression page size is to be returned

Returns

One of the valid SFS return codes described above. If the file is not compressed or an error is returned, cxrsz must be set to 0.

Implements XrdSfsFile.

Definition at line 672 of file XrdBwm.cc.

{
 
// Indicate not compressed
//
   cxrsz = 0;
   cxtype[0] = cxtype[1] = cxtype[2] = cxtype[3] = 0;
   return SFS_OK;
}

References SFS_OK.

getMmap()

int XrdBwmFile::getMmap ( void ** Addr, off_t & Size )

virtual

Get file's memory mapping if one exists (memory mapped files only).

Parameters

Addr	- Place where the starting memory address is returned.
Size	- Place where the file's size is returned.

Returns

SFS_OK when the file is memory mapped or any other code otherwise.

Implements XrdSfsFile.

Definition at line 548 of file XrdBwm.cc.

{
 
// Mapping is not supported
//
   *Addr= 0;
   Size = 0;
 
   return SFS_OK;
}

References SFS_OK.

open()

int XrdBwmFile::open ( const char * fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity * client, const char * opaque = 0 )

virtual

Open a file.

Parameters

fileName	- Pointer to the path of the file to be opened.
openMode	- Flags indicating how the open is to be handled. SFS_O_CREAT create the file SFS_O_CREATAT create the file in a perticular FS SFS_O_MKPTH Make directory path if missing SFS_O_NOWAIT do not impose operational delays SFS_O_NOTPC do not allow TPC operation SFS_O_POSC persist only on successful close SFS_O_RAWIO allow client-side decompression SFS_O_RDONLY open read/only SFS_O_RDWR open read/write SFS_O_REPLICA Open for replication SFS_O_RESET Reset any cached information SFS_O_TRUNC truncate existing file to zero length SFS_O_WRONLY open write/only
createMode	- The file's mode if it will be created.
client	- Client's identify (see common description).
opaque	- path's CGI information (see common description).

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED

Note

When SFS_O_CREATAT is specified, the CGI should contain an element oss.coloc=<path> where <path> is URL encoded and determines the filesystem in which the new file should be created.

Implements XrdSfsFile.

Definition at line 244 of file XrdBwm.cc.

{
   EPNAME("open");
   XrdBwmHandle *hP;
   int incoming;
   const char *miss, *theUsr, *theSrc, *theDst=0, *theLfn=0, *lclNode, *rmtNode;
   XrdOucEnv Open_Env(info);
 
// Trace entry
//
   ZTRACE(calls,std::hex <<open_mode <<std::dec <<" fn=" <<path);
 
// Verify that this object is not already associated with an open file
//
   XrdBwmFS.ocMutex.Lock();
   if (oh != XrdBwm::dummyHandle)
      {XrdBwmFS.ocMutex.UnLock();
       return XrdBwmFS.Emsg("open",error,EADDRINUSE,"open file",path);
      }
   XrdBwmFS.ocMutex.UnLock();
 
// Verify that the file is being opened in r/w mode only!
//
   if (!(open_mode & SFS_O_RDWR))
      return XrdBwmFS.Emsg("open", error, EINVAL, "open", path);
 
// Apply security. Note that we reject r/w access but apply r/o access
// restrictions if so wanted.
//
   if (client && XrdBwmFS.Authorization
   &&  !XrdBwmFS.Authorization->Access(client, path, AOP_Update, &Open_Env))
      return XrdBwmFS.Emsg("open", error, EACCES, "open", path);
 
// Make sure that all of the relevant information is present
//
        if (!(theSrc = Open_Env.Get("bwm.src"))) miss = "bwm.src";
   else if (!(theDst = Open_Env.Get("bwm.dst"))) miss = "bwm.dst";
   else if (!(theLfn = index(path+1,'/'))
        ||  !(*(theLfn+1)))                     miss = "lfn";
   else                                         miss = 0;
 
   if (miss) return XrdBwmFS.Emsg("open", error, miss, "open", path);
   theUsr = error.getErrUser();
 
// Determine the direction of flow
//
        if (XrdOucUtils::endsWith(theSrc,XrdBwmFS.myDomain,XrdBwmFS.myDomLen))
           {incoming = 0; lclNode = theSrc; rmtNode = theDst;}
   else if (XrdOucUtils::endsWith(theDst,XrdBwmFS.myDomain,XrdBwmFS.myDomLen))
           {incoming = 1; lclNode = theDst; rmtNode = theSrc;}
   else return XrdBwmFS.Emsg("open", error, EREMOTE, "open", path);
 
// Get a handle for this file.
//
   if (!(hP = XrdBwmHandle::Alloc(theUsr,theLfn,lclNode,rmtNode,incoming)))
      return XrdBwmFS.Stall(error, 13, path);
 
// All done
//
   XrdBwmFS.ocMutex.Lock(); oh = hP; XrdBwmFS.ocMutex.UnLock();
   return SFS_OK;
}

References XrdBwmHandle::Alloc(), AOP_Update, XrdOucUtils::endsWith(), EPNAME, XrdSfsFile::error, XrdOucEnv::Get(), Mode, SFS_O_RDWR, SFS_OK, XrdBwmFS, and ZTRACE.

Here is the call graph for this function:

read() [1/3]

int XrdBwmFile::read ( XrdSfsAio * aioparm )

virtual

Read file bytes using asynchronous I/O.

Parameters

aioparm

- Pointer to async I/O object controlling the I/O.

Returns

SFS_OK Request accepted and will be scheduled.

SFS_ERROR File could not be read, error holds the reason.

Implements XrdSfsFile.

Definition at line 480 of file XrdBwm.cc.

{
 
// Async mode not supported.
//
   aiop->Result = this->read((XrdSfsFileOffset)aiop->sfsAio.aio_offset,
                                       (char *)aiop->sfsAio.aio_buf,
                               (XrdSfsXferSize)aiop->sfsAio.aio_nbytes);
   aiop->doneRead();
   return 0;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdSfsAio::doneRead(), read, XrdSfsAio::Result, and XrdSfsAio::sfsAio.

Here is the call graph for this function:

read() [2/3]

XrdSfsXferSize XrdBwmFile::read ( XrdSfsFileOffset offset, char * buffer, XrdSfsXferSize size )

virtual

Read file bytes into a buffer.

Parameters

offset	- The offset where the read is to start.
buffer	- pointer to buffer where the bytes are to be placed.
size	- The number of bytes to read.

Returns

>= 0 The number of bytes that placed in buffer.

SFS_ERROR File could not be read, error holds the reason.

Implements XrdSfsFile.

Definition at line 439 of file XrdBwm.cc.

{
   EPNAME("read");
 
// Perform required tracing
//
   FTRACE(calls,blen <<"@" <<offset);
 
// Return number of bytes read
//
   return 0;
}

References EPNAME, and FTRACE.

read() [3/3]

int XrdBwmFile::read ( XrdSfsFileOffset offset, XrdSfsXferSize size )

virtual

Preread a file block into the file system cache.

Parameters

offset	- The offset where the read is to start.
size	- The number of bytes to pre-read.

Returns

>= 0 When 0, the request was ignored; otherwise, it has been accepted.

SFS_ERROR File could not be preread, error holds the reason.

Implements XrdSfsFile.

Definition at line 413 of file XrdBwm.cc.

{
   EPNAME("read");
 
// Perform required tracing
//
   FTRACE(calls,"preread " <<blen <<"@" <<offset);
 
// Return number of bytes read
//
   return 0;
}

References EPNAME, and FTRACE.

stat()

int XrdBwmFile::stat ( struct stat * buf )

virtual

Return state information on the file.

Parameters

buf	- Pointer to the structure where info it to be returned.

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL. When SFS_OK is returned, buf must hold stat information.

Implements XrdSfsFile.

Definition at line 570 of file XrdBwm.cc.

{
   EPNAME("fstat");
   static unsigned int myInode = 0;
   union {long long   Fill;
          int         Xor[2];
          XrdBwmFile *fP;
          dev_t       Num;
         } theDev;
 
// Perform any required tracing
//
   FTRACE(calls, FName());
 
// Develop the device number
//
   theDev.Fill = 0; theDev.fP = this; theDev.Xor[0] ^= theDev.Xor[1];
 
// Fill out the stat structure for this pseudo file
//
   memset(buf, 0, sizeof(struct stat));
   buf->st_ino = myInode++;
   buf->st_dev = theDev.Num;
   buf->st_blksize = 4096;
   buf->st_mode = S_IFBLK;
   return SFS_OK;
}

References XrdBwmFile(), EPNAME, FName(), FTRACE, SFS_OK, and stat().

Referenced by stat().

Here is the call graph for this function:

Here is the caller graph for this function:

sync() [1/2]

int XrdBwmFile::sync ( )

virtual

Make sure all outstanding data is actually written to the file (sync).

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED

Implements XrdSfsFile.

Definition at line 609 of file XrdBwm.cc.

{
   EPNAME("sync");
 
// Perform any required tracing
//
   FTRACE(calls,"");
 
// We always succeed
//
   return SFS_OK;
}

References EPNAME, FTRACE, and SFS_OK.

Referenced by sync().

Here is the caller graph for this function:

sync() [2/2]

int XrdBwmFile::sync ( XrdSfsAio * aiop )

virtual

Make sure all outstanding data is actually written to the file (async).

Returns

SFS_OK Request accepted and will be scheduled.

SFS_ERROR Request could not be accepted, return error has reason.

Implements XrdSfsFile.

Definition at line 635 of file XrdBwm.cc.

{
   aiop->Result = this->sync();
   aiop->doneWrite();
   return 0;
}

References XrdSfsAio::doneWrite(), XrdSfsAio::Result, and sync().

Here is the call graph for this function:

truncate()

int XrdBwmFile::truncate ( XrdSfsFileOffset fsize )

virtual

Truncate the file.

Parameters

fsize

- The size that the file is to have.

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFile.

Definition at line 646 of file XrdBwm.cc.

{
   EPNAME("trunc");
 
// Lock the file handle and perform any tracing
//
   FTRACE(calls, "len=" <<flen);
 
// Return an error
//
   return  XrdBwmFS.Emsg("trunc", error, ENOTSUP, "truncate", oh->Name());
}

References EPNAME, XrdSfsFile::error, FTRACE, and XrdBwmFS.

write() [1/2]

int XrdBwmFile::write ( XrdSfsAio * aioparm )

virtual

Write file bytes using asynchronous I/O.

Parameters

aioparm

- Pointer to async I/O object controlling the I/O.

Returns

0 Request accepted and will be scheduled.

!0 Request not accepted, returned value is errno.

Implements XrdSfsFile.

Definition at line 532 of file XrdBwm.cc.

{
 
// Async mode not supported.
//
   aiop->Result = this->write((XrdSfsFileOffset)aiop->sfsAio.aio_offset,
                                        (char *)aiop->sfsAio.aio_buf,
                                (XrdSfsXferSize)aiop->sfsAio.aio_nbytes);
   aiop->doneWrite();
   return 0;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdSfsAio::doneWrite(), XrdSfsAio::Result, XrdSfsAio::sfsAio, and write.

Here is the call graph for this function:

write() [2/2]

XrdSfsXferSize XrdBwmFile::write ( XrdSfsFileOffset offset, const char * buffer, XrdSfsXferSize size )

virtual

Write file bytes from a buffer.

Parameters

offset	- The offset where the write is to start.
buffer	- pointer to buffer where the bytes reside.
size	- The number of bytes to write.

Returns

>= 0 The number of bytes that were written.

SFS_ERROR File could not be written, error holds the reason.

Implements XrdSfsFile.

Definition at line 496 of file XrdBwm.cc.

{
   EPNAME("write");
 
// Perform any required tracing
//
   FTRACE(calls, blen <<"@" <<offset);
 
// Return number of bytes written
//
   return 0;
}

References EPNAME, and FTRACE.

Member Data Documentation

tident

const char* XrdBwmFile::tident

protected

Definition at line 134 of file XrdBwm.hh.

Referenced by XrdBwmFile().

---

The documentation for this class was generated from the following files:

• XrdBwm.hh
• XrdBwm.cc