gpfsFcntlHandler.cpp

Go to the documentation of this file.

#include <string>
#include "gpfsFcntlHandler.h"
#include "copyRequestTypes.h"
#include "timer.h"
#include <throwcall.h>
#include <iostream>
 
gpfs_fcntl_handler::gpfs_fcntl_handler() {
    buffer.header.totalLength = sizeof(buffer.header);
    buffer.header.fcntlVersion = GPFS_FCNTL_CURRENT_VERSION;
    buffer.header.errorOffset = -1;
    buffer.header.fcntlReserved = 0;
}
 
void gpfs_fcntl_handler::call(int fd, const std::string& path) {
    auto result = gpfs_fcntl(fd, &buffer);
    if (result) {
        if (errno == ENOSYS) {
            throw unimplementedActionError("gpfs_fcntl not implemented here");
        }
        switch (buffer.header.errorOffset) {
            case -1: // unchanged, happens if fd does not point to a file on gpfs
                throwcall::good0(result, "can't fcntl ", path, ", is not on a gpfs file system");
                break;
            case 0:
 
                throwcall::good0(result, "can't fcntl ", path,
                                 ", wrong version number ", buffer.header.fcntlVersion);
                break;
            default:
                int i = 0;
                int o = 0;
                while (o < buffer.header.errorOffset) {
                    std::cerr << o << "\n";
                    o += *reinterpret_cast<const int*>(&buffer.justCharsProvidingSpace[o]);
                    i++;
                }
                throwcall::good0(result, "can't fcntl ", path,
                                 ", wrong parameter in hint ", i,
                                 " at offset ", buffer.header.errorOffset);
        }
    }
};
 
void gpfs_fcntl_handler::dump() const {
    std::cerr << "dump of fcntl struct at " << (void*)this << "\n";
    for (int i = 0; i < buffer.header.totalLength; i += sizeof(int)) {
        std::cerr << *reinterpret_cast<const int*>(&buffer.justCharsProvidingSpace[i]) << "\n";
    }
}
 
gpfs_acl_handler::gpfs_acl_handler() {
    buffer.acl.acl_len = sizeof(buffer);
    buffer.acl.acl_level = GPFS_ACL_LEVEL_BASE;
    buffer.acl.acl_version = 0;
    buffer.acl.acl_type = GPFS_ACL_TYPE_NFS4;
}
gpfs_acl_handler::gpfs_acl_handler(gpfs_aclCount_t nEntries) {
    buffer.acl.acl_len = reinterpret_cast<char*>(&buffer.acl.ace_v4[nEntries])
                         - reinterpret_cast<char*>(&buffer.acl.acl_len);
    if (buffer.acl.acl_len > sizeof(buffer)) {
        throw std::runtime_error("to many entries for gpfs acl");
    }
    buffer.acl.acl_level = GPFS_ACL_LEVEL_BASE;
    buffer.acl.acl_version = GPFS_ACL_VERSION_NFS4;
    buffer.acl.acl_type = GPFS_ACL_TYPE_NFS4;
    buffer.acl.acl_nace = nEntries;
}
 
const gpfs_ace_v4_t* gpfs_acl_handler::begin() const {
    if (buffer.acl.acl_version == GPFS_ACL_VERSION_NFS4) {
        return &buffer.acl.ace_v4[0];
    } else {
        return &buffer.acl.v4Level1.ace_v4[0];
    }
}
const gpfs_ace_v4_t* gpfs_acl_handler::end() const {
    if (buffer.acl.acl_version == GPFS_ACL_VERSION_NFS4) {
        return &buffer.acl.ace_v4[buffer.acl.acl_nace];
    } else {
        return &buffer.acl.v4Level1.ace_v4[buffer.acl.acl_nace];
    }
}
gpfs_ace_v4_t* gpfs_acl_handler::begin() {
    if (buffer.acl.acl_version == GPFS_ACL_VERSION_NFS4) {
        return &buffer.acl.ace_v4[0];
    } else {
        return &buffer.acl.v4Level1.ace_v4[0];
    }
}
gpfs_ace_v4_t* gpfs_acl_handler::end() {
    if (buffer.acl.acl_version == GPFS_ACL_VERSION_NFS4) {
        return &buffer.acl.ace_v4[buffer.acl.acl_nace];
    } else {
        return &buffer.acl.v4Level1.ace_v4[buffer.acl.acl_nace];
    }
}
 
void gpfs_acl_handler::get(int fd, const std::string& path) {
    // use LWE_DATA_LWESEND as test for the existence of gpfs_getacl_fd
#ifdef LWE_DATA_LWESEND
    if (fd != -1) {
        timerInst(gpfs_getacl_fd);
        throwcall::good0(gpfs_getacl_fd(fd,
                                        GPFS_GETACL_STRUCT,
                                        buffer.justTheSpace),
                         "can't get acl for ", path);
    } else
#endif
        {
        timerInst(gpfs_getacl);
        throwcall::good0(gpfs_getacl(path.c_str(),
                                     GPFS_GETACL_STRUCT,
                                     buffer.justTheSpace),
                         "can't get acl for ", path);
    }
    if (buffer.acl.acl_version != GPFS_ACL_VERSION_NFS4 &&
            buffer.acl.acl_version != GPFS_ACL_VERSION_NFS4F) {
        throw std::runtime_error("wrong acl version on " + path);
    }
}
 
void gpfs_acl_handler::set(int fd, const std::string& path) {
#ifdef LWE_DATA_LWESEND
    if (fd != -1) {
        timerInst(gpfs_putacl_fd);
        throwcall::good0(gpfs_putacl_fd(fd,
                                        GPFS_PUTACL_STRUCT,
                                        buffer.justTheSpace),
                         "can't set acl for ", path);
    }   else
#endif
        {
        timerInst(gpfs_putacl);
        throwcall::good0(gpfs_putacl(path.c_str(),
                                     GPFS_PUTACL_STRUCT,
                                     buffer.justTheSpace),
                         "can't set acl for ", path);
    }
}