inputHandler::posixFile::readerPosixFile Class Reference

#include <inputHandlerPosixFile.h>

Inheritance diagram for inputHandler::posixFile::readerPosixFile:

Collaboration diagram for inputHandler::posixFile::readerPosixFile:

Public Member Functions
	readerPosixFile (const std::string &aPath, copyRequest::stateType &state, const genericStat &inititalStat)
	~readerPosixFile () override
bool	parallelizable () const override
	tell if this handler is capable of parallel IO. Unsually not the case More...
bool	setupSparseRegions (const std::string &sparseHandling) override
	create a region list which maps the holes in the source file More...
void	seek (size_t pos) override
	like the standard seek, to be used only when appending new data to a file More...
bool	readBlock (block &b) override
	read one block from the file More...
void	readBlockP (block &b, size_t bytesToRead, off_t offset) override
	read one block from the file, starting at offset. More...
void	checkUnchangedness () override
	check if the file is unchanged by comparing cuttent stat to initial stat More...
Public Member Functions inherited from inputHandler::base::reader
virtual	~reader () noexcept(false)=default
Public Member Functions inherited from ioHandle
	ioHandle ()
virtual	~ioHandle () noexcept(false)
virtual size_t	getBlockSize () const
virtual void	setBlockSize (size_t newSize)
virtual std::unique_ptr< acl::list >	getAclData ()
	get acls More...
Public Member Functions inherited from posixFileIoCommon
	posixFileIoCommon (const std::string &aPath)
void	setXattr (const std::string &name, const std::string &value) override
std::string	getXattr (const std::string &name) override
	get one extended attribute value More...
void	removeXattr (const std::string &name) override
std::unique_ptr< const genericStat >	getStat () override
std::unique_ptr< ioHandle::attrDataType >	getAttrData (const outputHandler::base *aOutputHandler) override
	get attributes in the optimal way for setting with aOutputHandler More...

Protected Attributes
std::deque< regionType >	regions
Protected Attributes inherited from inputHandler::base::reader
const genericStat &	readInitialStat
	stat at beginning, needed for unchngedness check More...
std::remove_const< decltype(readInitialStat.size)>::type	totalBytesRead = 0
	number of bytes read so far, needed for check on growing files More...
Protected Attributes inherited from ioHandle
size_t	blockSize
	in bytes, block size to be used when reading or writing More...
Protected Attributes inherited from posixFileIoCommon
const std::string &	path
int	fd = -1

Additional Inherited Members
Protected Member Functions inherited from inputHandler::base::reader
	reader (const genericStat &inititalStat)
Protected Member Functions inherited from unwindCheck
	unwindCheck ()=default
	~unwindCheck ()=default
bool	isUnwinding () const
Protected Member Functions inherited from ioHandle
	ioHandle ()
virtual	~ioHandle () noexcept(false)
virtual size_t	getBlockSize () const
virtual void	setBlockSize (size_t newSize)
virtual std::unique_ptr< acl::list >	getAclData ()
	get acls More...

Detailed Description

Definition at line 44 of file inputHandlerPosixFile.h.

Constructor & Destructor Documentation

readerPosixFile()

inputHandler::posixFile::readerPosixFile::readerPosixFile	(	const std::string &	aPath,
		copyRequest::stateType &	state,
		const genericStat &	inititalStat
	)

Definition at line 44 of file inputHandlerPosixFile.cpp.

                                           :
        posixFileIoCommon(aPath),
        reader(inititalStat) {
        {
            timerInst(open);
            fd = open(path.c_str(), O_RDONLY);
        }
        if (fd == -1) {
            if (errno == ENOENT
                    || (errno == ENOTDIR && !S_ISDIR(readInitialStat.mode))) {
                state |= copyRequest::stateBitType::vanished;
            }
        }
        throwcall::badval(fd, -1, "can't open ", path, " for reading");
        blockSize = readInitialStat.blksize;
        {
            timerInst(posix_fadvise);
            throwcall::good0(posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL),
                             "can't advise ", path, " as sequential");
        }
        {
            timerInst(posix_fadvise);
            throwcall::good0(posix_fadvise(fd, 0, 0, POSIX_FADV_NOREUSE),
                             "can't advise ", path, " as use only once");
        }
    }

References throwcall::badval(), genericStat::blksize, ioHandle::blockSize, posixFileIoCommon::fd, throwcall::good0(), genericStat::mode, posixFileIoCommon::path, inputHandler::base::reader::readInitialStat, timerInst, and copyRequest::vanished.

Here is the call graph for this function:

~readerPosixFile()

inputHandler::posixFile::readerPosixFile::~readerPosixFile ( )

override

Definition at line 73 of file inputHandlerPosixFile.cpp.

                                               {
        if (fd != -1) {
            if (isUnwinding()) {
                timerInst(close);
                if (close(fd) != 0) {
                    errMsg::emit(errMsg::level::debug, errMsg::location(),
                                 path, "close during unwind ",
                                 std::system_category().default_error_condition(errno).message());
                }
                return;
            }
            if (preserveAtime) {
                struct timespec times[2];
                readInitialStat.getAtime(times[0]);
                times[1].tv_nsec = UTIME_OMIT; // leave mtime unchanged
                timerInst(futimens);
                throwcall::good0(futimens(fd, times), "can't set time stamps on ", path, " to old values");
            }
            {
                timerInst(close);
                throwcall::good0(close(fd), "can't close ", path, " after reading");
            }
        }
    }

References errMsg::debug, errMsg::emit(), throwcall::good0(), inputHandler::posixFile::preserveAtime, and timerInst.

Here is the call graph for this function:

Member Function Documentation

checkUnchangedness()

void inputHandler::posixFile::readerPosixFile::checkUnchangedness ( )

overridevirtual

check if the file is unchanged by comparing cuttent stat to initial stat

Exceptions

delayAdvisingError	if file has changed according to size of mtime
std::system_error	if stat fails

Implements inputHandler::base::reader.

Definition at line 252 of file inputHandlerPosixFile.cpp.

                                                      {
        struct stat readFinalStatBuf;
        {
            timerInst(fstat);
            throwcall::good0(fstat(fd, &readFinalStatBuf), "can't stat path file ", path);
        }
        genericStat readFinalStat(readFinalStatBuf, std::chrono::nanoseconds(1));
        if (readFinalStat.size != readInitialStat.size) {
            throw delayAdvisingError("file size has changed (" +
                                     std::to_string(readInitialStat.size) +
                                     " -> " +
                                     std::to_string(readFinalStat.size) +
                                     ") during reading on " + path);
        }
 
        if (!readFinalStat.isSameMtimeAs(readInitialStat)) {
            throw delayAdvisingError("file " + path + " was modified (" +
                                     std::to_string(std::chrono::duration_cast<std::chrono::duration<double>>(readFinalStat.getMtime() - readInitialStat.getMtime()).count()) +
                                     "s different mtime) during reading");
        }
    }

References genericStat::getMtime(), throwcall::good0(), genericStat::isSameMtimeAs(), genericStat::size, and timerInst.

Here is the call graph for this function:

parallelizable()

bool inputHandler::posixFile::readerPosixFile::parallelizable ( ) const

overridevirtual

tell if this handler is capable of parallel IO. Unsually not the case

Reimplemented from ioHandle.

Definition at line 151 of file inputHandlerPosixFile.cpp.

                                                        {
        return regions.empty();
    }

readBlock()

bool inputHandler::posixFile::readerPosixFile::readBlock ( block &  b )

overridevirtual

read one block from the file

Returns

true if the last block was read, false if more to follow

Exceptions

std::system_error	if read fails
delayAdvisingError	if file changes during reading

Implements inputHandler::base::reader.

Definition at line 154 of file inputHandlerPosixFile.cpp.

                                                     {
        b.clear(totalBytesRead);
        bool lastblock = false;
 
        auto bytesToRead = b.max_size();
        if (!regions.empty()) {
            auto region = regions.front();
            if (region.isHole()) {
                b.setHoleState(true);
                b.bump_size(region.size());
                timerInst(lseek);
                size_t nextData;
                auto result = lseek(fd, totalBytesRead, SEEK_DATA);
                if (result == -1 && errno == ENXIO) { // this is the final hole
                    nextData = region.getEnd();
                } else {
                    throwcall::badval(result, -1, "seek in ", path, " to data after ", totalBytesRead);
                    nextData = result;
                }
                totalBytesRead += region.size(); // hole counts as total size...
                if (nextData != totalBytesRead) {
                    throw delayAdvisingError(path + " hole moved druring reading, (" +
                                             std::to_string(totalBytesRead) +
                                             " -> " +
                                             std::to_string(nextData) +
                                             ")");
                }
                regions.pop_front();
                return regions.empty();
            } else { // we are somewhere in a data region...
                if (region.getEnd() < totalBytesRead + bytesToRead) {
                    bytesToRead = region.getEnd() - totalBytesRead; // read only up to end of region
                }
                if (region.getEnd() == totalBytesRead + bytesToRead) { // we finish the region in this block
                    regions.pop_front();
                }
            }
        }
 
        while (b.size() + blockSize <= bytesToRead) {
            readRateLimit.wait();
            timerInst(read);
            auto bytes_read = throwcall::badval(read(fd, b.bufferAt(b.size()), blockSize),
                                                -1, "read failed on ", path);
            readRateLimit.update(bytes_read);
            if (bytes_read == 0) {
                lastblock = true;
                if (totalBytesRead < readInitialStat.size) {
                    throw delayAdvisingError(path + " has shrunk while reading, (" +
                                             std::to_string(readInitialStat.size) +
                                             " -> " +
                                             std::to_string(totalBytesRead) +
                                             ")");
                }
                break;
            }
            totalBytesRead += bytes_read;
            if (totalBytesRead > readInitialStat.size) {
                throw delayAdvisingError(path + " has grown while reading, (" +
                                         std::to_string(readInitialStat.size) +
                                         " -> " +
                                         std::to_string(totalBytesRead) +
                                         ")");
            }
 
            b.bump_size(bytes_read);
        }
 
        return lastblock;
    }

References throwcall::badval(), block::bufferAt(), block::bump_size(), block::clear(), block::max_size(), readRateLimit, block::setHoleState(), block::size(), timerInst, throttle::watch::update(), and throttle::watch::wait().

Referenced by inputHandler::Gpfs::readerGpfs::readBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

readBlockP()

void inputHandler::posixFile::readerPosixFile::readBlockP ( block &  , size_t  , off_t    )

overridevirtual

read one block from the file, starting at offset.

meant for pparallel reading, often not implemented only for non-sparse files

Exceptions

std::system_error	if read fails
delayAdvisingError	if file changes during reading
std::logic_error	if attempted on sparse file

Reimplemented from inputHandler::base::reader.

Definition at line 226 of file inputHandlerPosixFile.cpp.

                                                                                        {
        if (!regions.empty()) {
            throw std::logic_error("parallel read attempted on sparse file");
        }
        b.clear(offset);
        while (b.size() + blockSize <= b.max_size()) {
            timerInst(pread);
            auto bytes_read = throwcall::badval(pread(fd, b.bufferAt(b.size()), blockSize, offset + b.size()),
                                                -1, "read failed on ", path);
            if (bytes_read == 0) {
                break;
            }
            b.bump_size(bytes_read);
            if (b.size() > bytesToRead) {
                throw delayAdvisingError(path + " has grown while reading");
            }
        }
        if (b.size() < bytesToRead) {
            throw delayAdvisingError(path + " has shrunk while reading "
                                     + std::to_string(bytesToRead)
                                     + " "
                                     + std::to_string(b.size()));
        }
    }

References throwcall::badval(), block::bufferAt(), block::bump_size(), block::clear(), block::max_size(), block::size(), and timerInst.

Referenced by inputHandler::Gpfs::readerGpfs::readBlockP().

Here is the call graph for this function:

Here is the caller graph for this function:

seek()

void inputHandler::posixFile::readerPosixFile::seek ( size_t  )

overridevirtual

like the standard seek, to be used only when appending new data to a file

Exceptions

std::system_error	if seek fails
unimplementedActionError	if seek is not implemented (most input handlers)

Reimplemented from inputHandler::base::reader.

Definition at line 139 of file inputHandlerPosixFile.cpp.

                                                  {
        throwcall::badval(lseek(fd, pos, SEEK_SET),
                          -1, "can't seek ", path, " to ", pos);
        if (! regions.empty()) {
            while (regions.front().getEnd() < pos) {
                regions.pop_front();
                if (regions.empty()) {
                    break;
                }
            }
        }
    }

References throwcall::badval().

Here is the call graph for this function:

setupSparseRegions()

bool inputHandler::posixFile::readerPosixFile::setupSparseRegions ( const std::string &  sparseHandling )

overridevirtual

create a region list which maps the holes in the source file

Reimplemented from inputHandler::base::reader.

Definition at line 103 of file inputHandlerPosixFile.cpp.

                                                                                     {
        if (readInitialStat.size < readInitialStat.blksize) { // cannot be sparse
            return false;
        }
        if (sparseHandling == "auto" &&
            readInitialStat.size <= readInitialStat.sizeOnDisk) {
            return false;
        } else if (sparseHandling == "never") {
            return false;
        }
        auto what = SEEK_HOLE;
        for (std::remove_const<decltype(readInitialStat.size)>::type pos = 0;
                pos < readInitialStat.size;
                what = what == SEEK_HOLE ? SEEK_DATA : SEEK_HOLE) {
            timerInst(lseek);
            size_t next;
            auto result = lseek(fd, pos, what);
            if (result == -1 && errno == ENXIO) { // we found a hole at the end of the file
                next = readInitialStat.size;
            } else {
                throwcall::badval(result, -1,
                                  "seek ", path, " for ", what == SEEK_HOLE ? "hole" : "data",
                                  ", from offset ", pos);
                next = result;
            }
            if (next != pos) {
                regions.emplace_back(pos, next, what == SEEK_DATA);
                pos = next;
            }
        }
        timerInst(lseek);
        throwcall::good0(lseek(fd, 0, SEEK_SET), "re-seek to start of ", path);
        return !regions.empty();
    }

References throwcall::badval(), throwcall::good0(), and timerInst.

Here is the call graph for this function:

Member Data Documentation

regions

std::deque<regionType> inputHandler::posixFile::readerPosixFile::regions

protected

Definition at line 46 of file inputHandlerPosixFile.h.

---

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

• src/inputHandlerPosixFile.h (v0.19-24-g0617ca1 with changes)
• src/inputHandlerPosixFile.cpp (v0.19-24-g0617ca1 with changes)