Newer
Older
#include <global/configure.hpp>
#include <global/path_util.hpp>
#include <client/preload.hpp>
#include "client/preload_util.hpp"
#include <client/adafs_functions.hpp>
#include <client/rpc/ld_rpc_metadentry.hpp>
#include <client/rpc/ld_rpc_data_ws.hpp>
#include <client/open_dir.hpp>
using namespace std;
int adafs_open(const std::string& path, mode_t mode, int flags) {
init_ld_env_if_needed();
if(flags & O_PATH){
CTX->log()->error("{}() `O_PATH` flag is not supported", __func__);
errno = ENOTSUP;
return -1;
}
if(flags & O_APPEND){
CTX->log()->error("{}() `O_APPEND` flag is not supported", __func__);
errno = ENOTSUP;
return -1;
}
auto md = adafs_metadata(path);
if (!md) {
if(errno == ENOENT) {
exists = false;
} else {
CTX->log()->error("{}() error while retriving stat to file", __func__);
return -1;
}
}
if (!exists) {
if (! (flags & O_CREAT)) {
// file doesn't exists and O_CREAT was not set
errno = ENOENT;
return -1;
}
/*** CREATION ***/
assert(flags & O_CREAT);
CTX->log()->error("{}() O_DIRECTORY use with O_CREAT. NOT SUPPORTED", __func__);
// no access check required here. If one is using our FS they have the permissions.
if(adafs_mk_node(path, mode | S_IFREG)) {
CTX->log()->error("{}() error creating non-existent file", __func__);
/* File already exists */
if(flags & O_EXCL) {
// File exists and O_EXCL was set
errno = EEXIST;
return -1;
#if defined(CHECK_ACCESS_DURING_OPEN)
if ((mode & S_IRUSR) || (mode & S_IRGRP) || (mode & S_IROTH))
mask = mask & R_OK;
if ((mode & S_IWUSR) || (mode & S_IWGRP) || (mode & S_IWOTH))
mask = mask & W_OK;
if ((mode & S_IXUSR) || (mode & S_IXGRP) || (mode & S_IXOTH))
mask = mask & X_OK;
return adafs_opendir(path);
}
if( (flags & O_TRUNC) && ((flags & O_RDWR) || (flags & O_WRONLY)) ) {
if(adafs_truncate(path, md->size(), 0)) {
CTX->log()->error("{}() error truncating file", __func__);
return -1;
return CTX->file_map()->add(std::make_shared<OpenFile>(path, flags));
int adafs_mk_node(const std::string& path, const mode_t mode) {
init_ld_env_if_needed();
//file type must be set
assert((mode & S_IFMT) != 0);
//file type must be either regular file or directory
assert(S_ISREG(mode) || S_ISDIR(mode));
auto p_comp = dirname(path);
auto md = adafs_metadata(p_comp);
if (!md) {
CTX->log()->debug("{}() parent component does not exists: '{}'", __func__, p_comp);
errno = ENOENT;
return -1;
}
CTX->log()->debug("{}() parent component is not a direcotory: '{}'", __func__, p_comp);
errno = ENOTDIR;
return -1;
}
return rpc_send::mk_node(path, mode);
/**
* This sends internally a broadcast (i.e. n RPCs) to clean their chunk folders for that path
* @param path
* @return
*/
init_ld_env_if_needed();
auto md = adafs_metadata(path);
if (!md) {
return -1;
bool has_data = S_ISREG(md->mode()) && (md->size() != 0);
return rpc_send::rm_node(path, !has_data);
}
int adafs_access(const std::string& path, const int mask) {
init_ld_env_if_needed();
#if !defined(DO_LOOKUP)
// object is assumed to be existing, even though it might not
return 0;
#endif
return rpc_send::access(path, mask);
return rpc_send::access(path, F_OK); // Only check for file exists
int adafs_stat(const string& path, struct stat* buf) {
init_ld_env_if_needed();
auto md = adafs_metadata(path);
if (!md) {
return -1;
}
metadata_to_stat(path, *md, *buf);
return 0;
}
std::shared_ptr<Metadata> adafs_metadata(const string& path) {
auto err = rpc_send::stat(path, attr);
CTX->log()->trace("{}() called", __func__);
auto blk_stat = rpc_send::chunk_stat();
buf->f_type = 0;
buf->f_bsize = blk_stat.chunk_size;
buf->f_blocks = blk_stat.chunk_total;
buf->f_bfree = blk_stat.chunk_free;
buf->f_bavail = blk_stat.chunk_free;
buf->f_files = 0;
buf->f_ffree = 0;
buf->f_fsid = {0, 0};
buf->f_namelen = PATH_MAX_LEN;
buf->f_frsize = 0;
buf->f_flags =
ST_NOATIME | ST_NODIRATIME | ST_NOSUID | ST_NODEV | ST_SYNCHRONOUS;
return 0;
}
int adafs_statvfs(struct statvfs* buf) {
init_ld_env_if_needed();
auto blk_stat = rpc_send::chunk_stat();
buf->f_bsize = blk_stat.chunk_size;
buf->f_blocks = blk_stat.chunk_total;
buf->f_bfree = blk_stat.chunk_free;
buf->f_bavail = blk_stat.chunk_free;
buf->f_files = 0;
buf->f_ffree = 0;
buf->f_favail = 0;
buf->f_fsid = 0;
buf->f_namemax = PATH_MAX_LEN;
buf->f_frsize = 0;
buf->f_flag =
ST_NOATIME | ST_NODIRATIME | ST_NOSUID | ST_NODEV | ST_SYNCHRONOUS;
off64_t adafs_lseek(int fd, off64_t offset, int whence) {
init_ld_env_if_needed();
return adafs_lseek(CTX->file_map()->get(fd), offset, whence);
off64_t adafs_lseek(shared_ptr<OpenFile> adafs_fd, off64_t offset, int whence) {
init_ld_env_if_needed();
switch (whence) {
case SEEK_SET:
adafs_fd->pos(offset);
break;
case SEEK_CUR:
adafs_fd->pos(adafs_fd->pos() + offset);
break;
case SEEK_END: {
auto err = rpc_send::get_metadentry_size(adafs_fd->path(), file_size);
if (err < 0) {
errno = err; // Negative numbers are explicitly for error codes
return -1;
}
adafs_fd->pos(file_size + offset);
break;
}
case SEEK_DATA:
// We do not support this whence yet
errno = EINVAL;
return -1;
case SEEK_HOLE:
// We do not support this whence yet
errno = EINVAL;
return -1;
default:
errno = EINVAL;
return -1;
}
return adafs_fd->pos();
}
int adafs_truncate(const std::string& path, off_t old_size, off_t new_size) {
assert(new_size >= 0);
assert(new_size <= old_size);
if(new_size == old_size) {
return 0;
}
if (rpc_send::decr_size(path, new_size)) {
CTX->log()->debug("{}() failed to decrease size", __func__);
return -1;
}
if(rpc_send::trunc_data(path, old_size, new_size)){
CTX->log()->debug("{}() failed to truncate data", __func__);
return -1;
}
return 0;
}
int adafs_truncate(const std::string& path, off_t length) {
/* TODO CONCURRENCY:
* At the moment we first ask the length to the metadata-server in order to
* know which data-server have data to be deleted.
*
* From the moment we issue the adafs_stat and the moment we issue the
* adafs_trunc_data, some more data could have been added to the file and the
* length increased.
*/
init_ld_env_if_needed();
if(length < 0) {
CTX->log()->debug("{}() length is negative: {}", __func__, length);
errno = EINVAL;
return -1;
}
auto md = adafs_metadata(path);
if (!md) {
auto size = md->size();
if(static_cast<unsigned long>(length) > size) {
CTX->log()->debug("{}() length is greater then file size: {} > {}",
return adafs_truncate(path, size, length);
int adafs_dup(const int oldfd) {
return CTX->file_map()->dup(oldfd);
}
int adafs_dup2(const int oldfd, const int newfd) {
return CTX->file_map()->dup2(oldfd, newfd);
ssize_t adafs_pwrite(std::shared_ptr<OpenFile> file, const char * buf, size_t count, off64_t offset) {
init_ld_env_if_needed();
if (file->type() != FileType::regular) {
assert(file->type() == FileType::directory);
CTX->log()->warn("{}() cannot read from directory", __func__);
errno = EISDIR;
return -1;
}
auto path = make_shared<string>(file->path());
CTX->log()->trace("{}() count: {}, offset: {}", __func__, count, offset);
auto append_flag = file->get_flag(OpenFile_flags::append);
ret = rpc_send::update_metadentry_size(*path, count, offset, append_flag, updated_size);
CTX->log()->error("{}() update_metadentry_size failed with ret {}", __func__, ret);
ret = rpc_send::write(*path, buf, append_flag, offset, count, updated_size);
CTX->log()->warn("{}() rpc_send::write failed with ret {}", __func__, ret);
return ret; // return written size or -1 as error
ssize_t adafs_pwrite_ws(int fd, const void* buf, size_t count, off64_t offset) {
init_ld_env_if_needed();
auto file = CTX->file_map()->get(fd);
return adafs_pwrite(file, reinterpret_cast<const char*>(buf), count, offset);
/* Write counts bytes starting from current file position
* It also update the file position accordingly
*
* Same as write syscall.
*/
ssize_t adafs_write(int fd, const void * buf, size_t count) {
auto adafs_fd = CTX->file_map()->get(fd);
auto pos = adafs_fd->pos(); //retrieve the current offset
if (adafs_fd->get_flag(OpenFile_flags::append))
adafs_lseek(adafs_fd, 0, SEEK_END);
auto ret = adafs_pwrite(adafs_fd, reinterpret_cast<const char*>(buf), count, pos);
// Update offset in file descriptor in the file map
if (ret > 0) {
adafs_fd->pos(pos + count);
}
return ret;
}
ssize_t adafs_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset) {
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
CTX->log()->trace("{}() called with fd {}, op num {}, offset {}",
__func__, fd, iovcnt, offset);
auto file = CTX->file_map()->get(fd);
auto pos = offset; // keep truck of current position
ssize_t written = 0;
ssize_t ret;
for (int i = 0; i < iovcnt; ++i) {
auto count = (iov+i)->iov_len;
if (count == 0) {
continue;
}
auto buf = (iov+i)->iov_base;
ret = adafs_pwrite(file, reinterpret_cast<char *>(buf), count, pos);
if (ret == -1) {
break;
}
written += ret;
pos += ret;
if (static_cast<size_t>(ret) < count) {
break;
}
}
if (written == 0) {
return -1;
}
return written;
}
ssize_t adafs_writev(int fd, const struct iovec * iov, int iovcnt) {
CTX->log()->trace("{}() called with fd {}, ops num {}",
__func__, fd, iovcnt);
auto adafs_fd = CTX->file_map()->get(fd);
auto pos = adafs_fd->pos(); // retrieve the current offset
auto ret = adafs_pwritev(fd, iov, iovcnt, pos);
assert(ret != 0);
if (ret < 0) {
return -1;
}
adafs_fd->pos(pos + ret);
return ret;
}
ssize_t adafs_pread(std::shared_ptr<OpenFile> file, char * buf, size_t count, off64_t offset) {
init_ld_env_if_needed();
if (file->type() != FileType::regular) {
assert(file->type() == FileType::directory);
CTX->log()->warn("{}() cannot read from directory", __func__);
errno = EISDIR;
return -1;
}
CTX->log()->trace("{}() count: {}, offset: {}", __func__, count, offset);
// Zeroing buffer before read is only relevant for sparse files. Otherwise sparse regions contain invalid data.
#if defined(ZERO_BUFFER_BEFORE_READ)
auto ret = rpc_send::read(file->path(), buf, offset, count);
CTX->log()->warn("{}() rpc_send::read failed with ret {}", __func__, ret);
}
// XXX check that we don't try to read past end of the file
return ret; // return read size or -1 as error
ssize_t adafs_read(int fd, void* buf, size_t count) {
init_ld_env_if_needed();
auto adafs_fd = CTX->file_map()->get(fd);
auto pos = adafs_fd->pos(); //retrieve the current offset
auto ret = adafs_pread(adafs_fd, reinterpret_cast<char*>(buf), count, pos);
// Update offset in file descriptor in the file map
if (ret > 0) {
adafs_fd->pos(pos + ret);
}
return ret;
}
ssize_t adafs_pread_ws(int fd, void* buf, size_t count, off64_t offset) {
init_ld_env_if_needed();
auto adafs_fd = CTX->file_map()->get(fd);
return adafs_pread(adafs_fd, reinterpret_cast<char*>(buf), count, offset);
}
int adafs_opendir(const std::string& path) {
init_ld_env_if_needed();
auto md = adafs_metadata(path);
if (!md) {
CTX->log()->debug("{}() path is not a directory", __func__);
errno = ENOTDIR;
return -1;
}
auto open_dir = std::make_shared<OpenDir>(path);
rpc_send::get_dirents(*open_dir);
return CTX->file_map()->add(open_dir);
}
int adafs_rmdir(const std::string& path) {
init_ld_env_if_needed();
auto md = adafs_metadata(path);
if (!md) {
CTX->log()->debug("{}() path does not exists: '{}'", __func__, path);
errno = ENOENT;
return -1;
if (!S_ISDIR(md->mode())) {
CTX->log()->debug("{}() path is not a directory", __func__);
errno = ENOTDIR;
return -1;
}
rpc_send::get_dirents(*open_dir);
if(open_dir->size() != 0){
errno = ENOTEMPTY;
return -1;
}
return rpc_send::rm_node(path, true);
struct dirent * adafs_readdir(int fd){
init_ld_env_if_needed();
CTX->log()->trace("{}() called on fd: {}", __func__, fd);
auto open_file = CTX->file_map()->get(fd);
assert(open_file != nullptr);
auto open_dir = static_pointer_cast<OpenDir>(open_file);
if(!open_dir){
//Cast did not succeeded: open_file is a regular file
errno = EBADF;
}
return open_dir->readdir();