posixFileCommon.cpp

Go to the documentation of this file.

#include "posixFileCommon.h"
#include "genericStat.h"
#include "ewmscp.h"
#include "timer.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <throwcall.h>
#include <errMsgQueue.h>
#ifdef WithXattr
#include <xattr.h>
#endif
#ifdef WithXattrUgly
#include WithXattrUgly
#endif
#ifndef ENOATTR
#define ENOATTR ENODATA
#endif
 
bool posixFileCommon::pathExists(const std::string& path) {
    struct stat statBuf;
    timerInst(stat);
    auto result = stat(path.c_str(), &statBuf);
    if (result && (errno == ENOENT || errno == ENOTDIR)) {
        return false;
    }
    throwcall::good0(result, "can't stat ", path);
    return true;
};
std::unique_ptr<const genericStat> posixFileCommon::getStat(const std::string& path,
        bool followLink) {
    struct stat statBuf;
    for (int retries = 100; retries; --retries) {
        if (followLink) {
            timerInst(stat);
            auto result = stat(path.c_str(), &statBuf);
            if (result && errno == ENOENT) {
                return nullptr;
            } else if (result && errno == ENOTDIR) {
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             path, "stat", "found @#$%@ gpfs err ", errno);
                continue;
            }
            throwcall::good0(result, "can't stat", path);
        } else {
            timerInst(lstat);
            auto result = lstat(path.c_str(), &statBuf);
            if (result && errno == ENOENT) {
                return nullptr;
            } else if (result && errno == ENOTDIR) {
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             path, "lstat", "found @#$%@ gpfs err", errno);
                continue;
            }
            throwcall::good0(result, "can't lstat", path);
        }
        break;
    }
    return std::unique_ptr<const genericStat>(new genericStat(statBuf, std::chrono::nanoseconds(1)));
};
 
 
std::string posixFileCommon::getXattr(const std::string& path,
                                      const std::string& name) {
    #if defined(WithXattr) || defined(WithXattrUgly)
    char buffer[512];
 
    for (int i = 0; i < 100; i++) {
        timerInst(lgetxattr);
        auto retval = lgetxattr(path.c_str(), name.c_str(), buffer, sizeof(buffer));
 
        if (retval == -1) {
            if (errno == ENOENT || errno == ENOATTR) {
                return "";
            } else if (errno == ENOTDIR) { // we ran against a GPFS bug
                errMsg::emit(errMsg::level::info, errMsg::location(),
                             path, "lgetxattr",
                             "got a f*^%$&^%$ GPFS bug", errno);
                continue; // try again
            }
            throwcall::badval(retval, -1, "can't get xattr on ", path);
        }
        buffer[retval] = '\0';
        break;
    }
    return buffer;
    #else
    throw unimplementedActionError("no xattr support");
    #endif
};
 
// while (true) {
 
// auto retval = lstat(source.c_str(), &readInitialStat);
 
// if (retval && errno == ENOENT) {
//  state |= stateBitType::vanished;
//  return;
// } else if (retval && errno == ENOTDIR) {
//  *errStream << statPrefix << __FILE__ << ":" << __LINE__ << ": found @#$%@ gpfs err on " << source << std::endl;
//  continue;
// }
 
// throwcall::good0(retval, "can't stat ", source);
// break;
//}
 
 
 
posixFileIoCommon::posixFileIoCommon(const std::string& aPath):
    path(aPath) {
}
 
 
 
std::unique_ptr<const genericStat> posixFileIoCommon::getStat() {
    struct stat statBuf;
    timerInst(fstat);
    throwcall::good0(fstat(fd, &statBuf), "can't stat", path);
    return std::unique_ptr<const genericStat>(new genericStat(statBuf, std::chrono::nanoseconds(1)));
}
void posixFileIoCommon::setXattr(const std::string& name, const std::string& value) {
    #if defined(WithXattr) || defined(WithXattrUgly)
    timerInst(fsetxattr);
    throwcall::good0(fsetxattr(fd, name.c_str(), value.data(), value.size(), 0),
                     "can't set xattr '", name, "' to '", value, "' on ", path);
    #else
    throw unimplementedActionError("no xattr support");
    #endif
}
 
std::string posixFileIoCommon::getXattr(const std::string& name) {
    #if defined(WithXattr) || defined(WithXattrUgly)
    char buffer[512];
    timerInst(getXattr);
    auto retval = fgetxattr(fd, name.c_str(), buffer, sizeof(buffer));
    if (retval == -1) {
        if (errno != ENOATTR) {
            throwcall::badval(retval, -1, "can't read xattr '", name, "' from ", path);
        }
        return "";
    } else {
        buffer[retval] = '\0';
    }
    return buffer;
    #else
    throw unimplementedActionError("no xattr support");
    return ""; // newver reached
    #endif
 
}
 
void posixFileIoCommon::removeXattr(const std::string& name) {
    #if defined(WithXattr) || defined(WithXattrUgly)
    timerInst(fremovexattr);
    auto result = fremovexattr(fd, name.c_str());
    if (result && errno == ENOATTR) {
        return; // be silent about this
    }
    throwcall::good0(result,
                     "can't remove xattr ", name, " from ", path);
    #else
    throw unimplementedActionError("no xattr support");
    #endif
 
}
 
void posixFileIoCommon::attrDataType::add(const std::string& name, const std::string& value) {
    xattrs.emplace_front(name, value);
}
void posixFileIoCommon::attrDataType::set(ioHandle* handle) {
    for (const auto& item : xattrs) {
        handle->setXattr(item.first, item.second);
    }
}
 
#if defined(WithXattr) || defined(WithXattrUgly)
void posixFileIoCommon::attrDataType::fill(posixFileIoCommon& handler) {
    char buf[0x10000];
    static timer::anchor la("flistxattr");
    timer::instanceUnscoped li(la);
    auto bufSize = throwcall::badval(flistxattr(handler.fd, buf, sizeof(buf)), -1,
                                     "can't get xattrs for ", handler.path);
    li.stop();
    for (auto readPtr = &buf[0]; readPtr < &buf[bufSize];) {
        add(readPtr, handler.getXattr(readPtr));
        while (*readPtr++);
    }
}
std::unique_ptr<ioHandle::attrDataType> posixFileIoCommon::getAttrData(const outputHandler::base* /*aOutputHandler*/) {
    auto attrData = std::unique_ptr<attrDataType>(new attrDataType());
    attrData->fill(*this);
    if (attrData->xattrs.empty()) {
        return nullptr;
    }
    #if __GNUC__ >= 8
    return attrData;
    #else
    return std::move(attrData);
    #endif
}
#else
void posixFileIoCommon::attrDataType::fill(posixFileIoCommon& /*handler*/) {
};
std::unique_ptr<ioHandle::attrDataType> posixFileIoCommon::getAttrData(const outputHandler::base* aOutputHandler) {
    return ioHandle::getAttrData(aOutputHandler);
}
#endif