gpfsCommon.cpp

Go to the documentation of this file.

#include "gpfsCommon.h"
#include <gpfs.h>
#include <throwcall.h>
#include "outputHandlerGpfs.h"
#include "errMsgQueue.h"
#include "timer.h"
 
gpfsIoCommon::gpfsIoCommon(const std::string& aPath):
    posixFileIoCommon(aPath),
    leastRecentlyAccessedBlock(0),
    leastRecentlyReleasedBlock(0) {
}
 
void gpfsIoCommon::releaseUsedBlocks(size_t aBlockSize) {
    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;
    }
}
void gpfsIoCommon::handleParallelUsedBlocks(size_t aBlockSize, off_t offset) {
    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");
    }
}
void gpfsIoCommon::attrDataType::set(ioHandle* handle) {
    auto castHandle = dynamic_cast<outputHandler::posixFile::writerPosixFile*>(handle);
    posixFileIoCommon::attrDataType::set(handle);
    if (size != 0) {
        timerInst(gpfs_fputattrs);
        throwcall::good0(gpfs_fputattrs(castHandle->fd, GPFS_ATTRFLAG_NO_PLACEMENT, buffer),
                         "can't set gpfs attributes for", castHandle->path);
    }
}
 
std::unique_ptr<ioHandle::attrDataType> gpfsIoCommon::getAttrData(const outputHandler::base* aOutputHandler) {
    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;
    }
}
 
std::unique_ptr<acl::list> gpfsIoCommon::getAclData() {
    gpfs_acl_handler aclHandler;
    aclHandler.get(fd, path);
    return aclFromGpfs(aclHandler, path);
}
 
std::unique_ptr<acl::list> gpfsIoCommon::aclFromGpfs(const gpfs_acl_handler& gpfsAcl,
        const std::string& aPath) {
    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;
}