gpfsIoCommon Class Reference

#include <gpfsCommon.h>

Inheritance diagram for gpfsIoCommon:

Collaboration diagram for gpfsIoCommon:

Classes
class	attrDataType

Public Member Functions
	gpfsIoCommon (const std::string &aPath)
	~gpfsIoCommon () override=default
std::unique_ptr< ioHandle::attrDataType >	getAttrData (const outputHandler::base *aOutputHandler) override
	get attributes in the optimal way for setting with aOutputHandler More...
std::unique_ptr< acl::list >	getAclData () override
	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...
Public Member Functions inherited from ioHandle
	ioHandle ()
virtual	~ioHandle () noexcept(false)
virtual bool	parallelizable () const
	tell if this handler is capable of parallel IO. Unsually not the case More...
virtual size_t	getBlockSize () const
virtual void	setBlockSize (size_t newSize)

Static Public Member Functions
static std::unique_ptr< acl::list >	aclFromGpfs (const gpfs_acl_handler &acl, const std::string &aPath)

Protected Member Functions
void	releaseUsedBlocks (size_t aBlockSize)
void	handleParallelUsedBlocks (size_t aBlockSize, off_t offset)

Protected Attributes
off_t	leastRecentlyAccessedBlock
off_t	leastRecentlyReleasedBlock
std::bitset< 64 >	usedBlockMap
std::bitset< 64 >	nextUsedBlockMap
std::mutex	blockBookkeepingMutex
Protected Attributes inherited from posixFileIoCommon
const std::string &	path
int	fd = -1
Protected Attributes inherited from ioHandle
size_t	blockSize
	in bytes, block size to be used when reading or writing More...

Detailed Description

Definition at line 8 of file gpfsCommon.h.

Constructor & Destructor Documentation

gpfsIoCommon()

gpfsIoCommon::gpfsIoCommon

(

const std::string &

aPath

)

Definition at line 8 of file gpfsCommon.cpp.

                                                :
    posixFileIoCommon(aPath),
    leastRecentlyAccessedBlock(0),
    leastRecentlyReleasedBlock(0) {
}

~gpfsIoCommon()

gpfsIoCommon::~gpfsIoCommon ( )

overridedefault

Member Function Documentation

aclFromGpfs()

std::unique_ptr< acl::list > gpfsIoCommon::aclFromGpfs ( const gpfs_acl_handler &  acl, const std::string &  aPath  )

static

Definition at line 83 of file gpfsCommon.cpp.

                                {
    auto acl = std::unique_ptr<acl::list>(new acl::list());
    acl->entries.reserve(gpfsAcl.size()); // we will have this many aces
    static_assert(static_cast<unsigned short>(acl::list::entryType::flagsType::file_inherit_ace) == ACE4_FLAG_FILE_INHERIT &&
                  static_cast<unsigned short>(acl::list::entryType::flagsType::directory_inherit_ace) == ACE4_FLAG_DIR_INHERIT &&
                  static_cast<unsigned short>(acl::list::entryType::flagsType::no_propagate_inherit_ace) == ACE4_FLAG_NO_PROPAGATE &&
                  static_cast<unsigned short>(acl::list::entryType::flagsType::inherit_only_ace) == ACE4_FLAG_INHERIT_ONLY &&
                  static_cast<unsigned short>(acl::list::entryType::flagsType::identifier_group) == ACE4_FLAG_GROUP_ID &&
                  static_cast<unsigned short>(acl::list::entryType::flagsType::inherited_ace) == ACE4_FLAG_INHERITED,
                  "incompatible flag bit maps between gpfs and rich acl");
    static_assert(static_cast<unsigned int>(acl::list::entryType::maskType::read_data) == ACE4_MASK_READ &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::list_directory) == ACE4_MASK_LIST_DIR &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::write_data) == ACE4_MASK_WRITE &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::add_file) == ACE4_MASK_ADD_FILE &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::append_data) == ACE4_MASK_APPEND &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::add_subdirectory) == ACE4_MASK_ADD_SUBDIR &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::read_named_attrs) == ACE4_MASK_READ_NAMED &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::write_named_attrs) == ACE4_MASK_WRITE_NAMED &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::execute) == ACE4_MASK_EXECUTE &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::execute) == ACE4_MASK_SEARCH &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::delete_child) == ACE4_MASK_DELETE_CHILD &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::read_attributes) == ACE4_MASK_READ_ATTR &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::write_attributes) == ACE4_MASK_WRITE_ATTR &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::delete_) == ACE4_MASK_DELETE &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::read_acl) == ACE4_MASK_READ_ACL &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::write_acl) == ACE4_MASK_WRITE_ACL &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::write_owner) == ACE4_MASK_WRITE_OWNER &&
                  static_cast<unsigned int>(acl::list::entryType::maskType::synchronize) == ACE4_MASK_SYNCHRONIZE,
                  "incompatible mask bit maps between gpfs and rich acl");
    static_assert(static_cast<unsigned char>(acl::list::entryType::typeValue::access_allowed_ace_type) == ACE4_TYPE_ALLOW &&
                  static_cast<unsigned char>(acl::list::entryType::typeValue::access_denied_ace_type) == ACE4_TYPE_DENY,
                  "incompatible ace type bit  maps between gpfs and rich acl");
 
    // std::cerr << "n:" << acl.acl_nace << "\n";
    // std::cerr << "len: " << acl.acl_len << "\n";
    // std::cerr << "level: " << acl.acl_level << "\n";
    // std::cerr << "version: " << acl.acl_version << "\n";
    // std::cerr << "type: " << acl.acl_type << "\n";
    for (const auto gpfs_ace : gpfsAcl) {
        acl->entries.emplace_back();
        auto& rich_ace = acl->entries.back();
 
        // std::cerr<<i<<": type:"<<gpfs_ace->aceType << "\n";
        // std::cerr<<i<<": flag:"<<gpfs_ace->aceFlags << "\n";
        // std::cerr<<i<<": iflag:"<<gpfs_ace->aceIFlags << "\n";
        // std::cerr<<i<<": mask:"<<gpfs_ace->aceMask << "\n";
        // std::cerr<<i<<": who:"<<gpfs_ace->aceWho << "\n";
        // transfer only flags valid in both repesentations
        rich_ace.setType(gpfs_ace.aceType & (ACE4_TYPE_ALLOW |
                                             ACE4_TYPE_DENY));
        rich_ace.setFlags(gpfs_ace.aceFlags & (ACE4_FLAG_FILE_INHERIT |
                                               ACE4_FLAG_DIR_INHERIT |
                                               ACE4_FLAG_NO_PROPAGATE |
                                               ACE4_FLAG_INHERIT_ONLY |
                                               ACE4_FLAG_GROUP_ID |
                                               ACE4_FLAG_INHERITED));
        rich_ace.setMask(gpfs_ace.aceMask);
        if (gpfs_ace.aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
            switch (gpfs_ace.aceWho) {
                case ACE4_SPECIAL_OWNER:
                    rich_ace.e_id = acl::list::entryType::specialIdType::owner_special_id;
                    break;
                case ACE4_SPECIAL_GROUP:
                    rich_ace.e_id = acl::list::entryType::specialIdType::group_special_id;
                    break;
                case ACE4_SPECIAL_EVERYONE:
                    rich_ace.e_id = acl::list::entryType::specialIdType::everyone_special_id;
                    break;
                default:
                    throw std::runtime_error("unknon special acl id on " + aPath);
            }
            rich_ace.addFlags(acl::list::entryType::flagsType::special_who);
        } else {
            rich_ace.e_id = gpfs_ace.aceWho;
        }
    }
    return acl;
}

References acl::list::entryType::access_allowed_ace_type, acl::list::entryType::access_denied_ace_type, acl::list::entryType::add_file, acl::list::entryType::add_subdirectory, acl::list::entryType::append_data, acl::list::entryType::delete_, acl::list::entryType::delete_child, acl::list::entryType::directory_inherit_ace, acl::list::entryType::execute, acl::list::entryType::file_inherit_ace, acl::list::entryType::identifier_group, acl::list::entryType::inherit_only_ace, acl::list::entryType::inherited_ace, acl::list::entryType::list_directory, acl::list::entryType::no_propagate_inherit_ace, acl::list::entryType::read_acl, acl::list::entryType::read_attributes, acl::list::entryType::read_data, acl::list::entryType::read_named_attrs, gpfs_acl_handler::size(), acl::list::entryType::special_who, acl::list::entryType::synchronize, acl::list::entryType::write_acl, acl::list::entryType::write_attributes, acl::list::entryType::write_data, acl::list::entryType::write_named_attrs, and acl::list::entryType::write_owner.

Referenced by getAclData(), and inputHandler::Gpfs::getAclData().

Here is the call graph for this function:

Here is the caller graph for this function:

getAclData()

std::unique_ptr< acl::list > gpfsIoCommon::getAclData ( )

overridevirtual

get acls

Returns

std::unique_ptr to the acl data or nullptr if none available

Exceptions

std::system_error

when reading of acls fails

Reimplemented from ioHandle.

Definition at line 77 of file gpfsCommon.cpp.

                                                {
    gpfs_acl_handler aclHandler;
    aclHandler.get(fd, path);
    return aclFromGpfs(aclHandler, path);
}

References aclFromGpfs(), posixFileIoCommon::fd, gpfs_acl_handler::get(), and posixFileIoCommon::path.

Here is the call graph for this function:

getAttrData()

std::unique_ptr< ioHandle::attrDataType > gpfsIoCommon::getAttrData ( const outputHandler::base *  )

overridevirtual

get attributes in the optimal way for setting with aOutputHandler

Returns

std::unique_ptr to the attribute data or nullptr if none available

Exceptions

std::system_error

when reading of attributes fails

Reimplemented from ioHandle.

Definition at line 55 of file gpfsCommon.cpp.

                                                                                                     {
    auto attrData = std::unique_ptr<gpfsIoCommon::attrDataType>(new gpfsIoCommon::attrDataType());
    attrData->fill(*this); // get the posix part: the xattrs
    if (dynamic_cast<const outputHandler::Gpfs*>(aOutputHandler)) { // we work all in gpfs
        // remove system attrs
        attrData->xattrs.remove_if([](const decltype(attrData->xattrs)::value_type & item) {
            return item.first.find("system.") == 0;
        });
        timerInst(gpfs_fgetattrs);
        throwcall::good0(gpfs_fgetattrs(fd, GPFS_ATTRFLAG_NO_PLACEMENT,
                                        attrData->buffer,
                                        sizeof(attrData->buffer),
                                        &(attrData->size)),
                         "can't get gpfs attributes for ", path);
    }
    if (attrData->size > 0 && !attrData->xattrs.empty()) {
        return std::unique_ptr<ioHandle::attrDataType>(attrData.release());
    } else { // no xattr data found
        return nullptr;
    }
}

References posixFileIoCommon::fd, throwcall::good0(), posixFileIoCommon::path, and timerInst.

Here is the call graph for this function:

handleParallelUsedBlocks()

void gpfsIoCommon::handleParallelUsedBlocks ( size_t  aBlockSize, off_t  offset  )

protected

Definition at line 26 of file gpfsCommon.cpp.

                                                                           {
    std::lock_guard<decltype(blockBookkeepingMutex)> lock(blockBookkeepingMutex);
    auto index = (offset - leastRecentlyAccessedBlock) / aBlockSize;
    if (index < usedBlockMap.size()) {
        usedBlockMap.set(index);
        if (usedBlockMap.all()) {
            leastRecentlyAccessedBlock = offset;
            usedBlockMap = nextUsedBlockMap;
            nextUsedBlockMap.reset();
            releaseUsedBlocks(aBlockSize);
        }
    } else if (index - usedBlockMap.size() < nextUsedBlockMap.size()) {
        nextUsedBlockMap.set(index - usedBlockMap.size());
    } else {
        errMsg::emit(errMsg::level::debug, errMsg::location(),
                     path, "parallel read",
                     "blocks scattered to far, ", index, " blocks difference");
    }
}

References blockBookkeepingMutex, errMsg::debug, errMsg::emit(), leastRecentlyAccessedBlock, nextUsedBlockMap, posixFileIoCommon::path, releaseUsedBlocks(), and usedBlockMap.

Here is the call graph for this function:

releaseUsedBlocks()

void gpfsIoCommon::releaseUsedBlocks ( size_t  aBlockSize )

protected

Definition at line 14 of file gpfsCommon.cpp.

                                                      {
    if (leastRecentlyAccessedBlock - leastRecentlyReleasedBlock >
            static_cast<off_t>(aBlockSize * usedBlockMap.size())) {
        gpfs_fcntl_handler fcntl;
        auto& hint = fcntl.buffer.add<gpfsFreeRange_t>(GPFS_FREE_RANGE);
        hint.start = leastRecentlyReleasedBlock;
        hint.length = leastRecentlyAccessedBlock - leastRecentlyReleasedBlock;
        timerInst(gpfsFreeRange);
        fcntl.call(fd, path);
        leastRecentlyReleasedBlock = leastRecentlyAccessedBlock;
    }
}

References gpfs_fcntl_handler::buffer, gpfs_fcntl_handler::call(), posixFileIoCommon::fd, leastRecentlyAccessedBlock, leastRecentlyReleasedBlock, posixFileIoCommon::path, timerInst, and usedBlockMap.

Referenced by handleParallelUsedBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

blockBookkeepingMutex

std::mutex gpfsIoCommon::blockBookkeepingMutex

protected

Definition at line 14 of file gpfsCommon.h.

Referenced by handleParallelUsedBlocks().

leastRecentlyAccessedBlock

off_t gpfsIoCommon::leastRecentlyAccessedBlock

protected

Definition at line 10 of file gpfsCommon.h.

Referenced by handleParallelUsedBlocks(), and releaseUsedBlocks().

leastRecentlyReleasedBlock

off_t gpfsIoCommon::leastRecentlyReleasedBlock

protected

Definition at line 11 of file gpfsCommon.h.

Referenced by releaseUsedBlocks().

nextUsedBlockMap

std::bitset<64> gpfsIoCommon::nextUsedBlockMap

protected

Definition at line 13 of file gpfsCommon.h.

Referenced by handleParallelUsedBlocks().

usedBlockMap

std::bitset<64> gpfsIoCommon::usedBlockMap

protected

Definition at line 12 of file gpfsCommon.h.

Referenced by handleParallelUsedBlocks(), and releaseUsedBlocks().

---

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

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