2019-06-21 15:05:41 +03:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <gfarm/gfarm.h>
|
|
|
|
#undef PACKAGE_NAME
|
|
|
|
#undef PACKAGE_STRING
|
|
|
|
#undef PACKAGE_TARNAME
|
|
|
|
#undef PACKAGE_VERSION
|
|
|
|
#include "ior.h"
|
|
|
|
#include "aiori.h"
|
|
|
|
|
|
|
|
struct gfarm_file {
|
|
|
|
GFS_File gf;
|
|
|
|
};
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
static aiori_xfer_hint_t *hints = NULL;
|
|
|
|
|
|
|
|
void
|
|
|
|
Gfarm_xfer_hints(aiori_xfer_hint_t *params)
|
|
|
|
{
|
|
|
|
hints = params;
|
|
|
|
}
|
|
|
|
|
2019-06-21 15:05:41 +03:00
|
|
|
void
|
|
|
|
Gfarm_initialize()
|
|
|
|
{
|
|
|
|
gfarm_initialize(NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Gfarm_finalize()
|
|
|
|
{
|
|
|
|
gfarm_terminate();
|
|
|
|
}
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
aiori_fd_t *
|
|
|
|
Gfarm_create(char *fn, int flag, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
GFS_File gf;
|
|
|
|
struct gfarm_file *fp;
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
e = gfs_pio_create(fn, GFARM_FILE_RDWR, 0664, &gf);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("gfs_pio_create failed");
|
|
|
|
GFARM_MALLOC(fp);
|
|
|
|
if (fp == NULL)
|
|
|
|
ERR("no memory");
|
|
|
|
fp->gf = gf;
|
2020-10-26 14:26:10 +03:00
|
|
|
return ((aiori_fd_t *)fp);
|
2019-06-21 15:05:41 +03:00
|
|
|
}
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
aiori_fd_t *
|
|
|
|
Gfarm_open(char *fn, int flag, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
GFS_File gf;
|
|
|
|
struct gfarm_file *fp;
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
e = gfs_pio_open(fn, GFARM_FILE_RDWR, &gf);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("gfs_pio_open failed");
|
|
|
|
GFARM_MALLOC(fp);
|
|
|
|
if (fp == NULL)
|
|
|
|
ERR("no memory");
|
|
|
|
fp->gf = gf;
|
2020-10-26 14:26:10 +03:00
|
|
|
return ((aiori_fd_t *)fp);
|
2019-06-21 15:05:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
IOR_offset_t
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_xfer(int access, aiori_fd_t *fd, IOR_size_t *buffer,
|
|
|
|
IOR_offset_t len, IOR_offset_t offset, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
2020-10-26 14:26:10 +03:00
|
|
|
struct gfarm_file *fp = (struct gfarm_file *)fd;
|
2019-06-21 15:05:41 +03:00
|
|
|
IOR_offset_t rem = len;
|
|
|
|
gfarm_off_t off;
|
|
|
|
gfarm_error_t e;
|
|
|
|
#define MAX_SZ (1024 * 1024 * 1024)
|
|
|
|
int sz, n;
|
|
|
|
char *buf = (char *)buffer;
|
2019-06-22 04:48:41 +03:00
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (len);
|
|
|
|
|
|
|
|
if (len > MAX_SZ)
|
|
|
|
sz = MAX_SZ;
|
|
|
|
else
|
|
|
|
sz = len;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
e = gfs_pio_seek(fp->gf, offset, GFARM_SEEK_SET, &off);
|
2019-06-21 15:05:41 +03:00
|
|
|
if (e != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("gfs_pio_seek failed");
|
|
|
|
while (rem > 0) {
|
|
|
|
if (access == WRITE)
|
|
|
|
e = gfs_pio_write(fp->gf, buf, sz, &n);
|
|
|
|
else
|
|
|
|
e = gfs_pio_read(fp->gf, buf, sz, &n);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("xfer failed");
|
|
|
|
if (n == 0)
|
|
|
|
ERR("EOF encountered");
|
|
|
|
rem -= n;
|
|
|
|
buf += n;
|
|
|
|
}
|
|
|
|
return (len);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_close(aiori_fd_t *fd, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
2020-10-26 14:26:10 +03:00
|
|
|
struct gfarm_file *fp = (struct gfarm_file *)fd;
|
2019-06-21 15:05:41 +03:00
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (gfs_pio_close(fp->gf) != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("gfs_pio_close failed");
|
|
|
|
free(fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_delete(char *fn, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return;
|
|
|
|
|
|
|
|
e = gfs_unlink(fn);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR)
|
|
|
|
errno = gfarm_error_to_errno(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *
|
|
|
|
Gfarm_version()
|
|
|
|
{
|
|
|
|
return ((char *)gfarm_version());
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_fsync(aiori_fd_t *fd, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
2020-10-26 14:26:10 +03:00
|
|
|
struct gfarm_file *fp = (struct gfarm_file *)fd;
|
2019-06-21 15:05:41 +03:00
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (gfs_pio_sync(fp->gf) != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("gfs_pio_sync failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
IOR_offset_t
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_get_file_size(aiori_mod_opt_t *param, char *fn)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
struct gfs_stat st;
|
|
|
|
IOR_offset_t size, sum, min, max;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
if (gfs_stat(fn, &st) != GFARM_ERR_NO_ERROR)
|
|
|
|
ERR("gfs_stat failed");
|
|
|
|
size = st.st_size;
|
|
|
|
gfs_stat_free(&st);
|
|
|
|
|
|
|
|
return (size);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_statfs(const char *fn, ior_aiori_statfs_t *st, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
gfarm_off_t used, avail, files;
|
|
|
|
gfarm_error_t e;
|
|
|
|
int bsize = 4096;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
e = gfs_statfs_by_path(fn, &used, &avail, &files);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR) {
|
|
|
|
errno = gfarm_error_to_errno(e);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
st->f_bsize = bsize;
|
|
|
|
st->f_blocks = (used + avail) / bsize;
|
|
|
|
st->f_bfree = avail / bsize;
|
|
|
|
st->f_files = 2 * files; /* XXX */
|
|
|
|
st->f_ffree = files; /* XXX */
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_mkdir(const char *fn, mode_t mode, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (0);
|
|
|
|
|
2019-06-22 04:48:41 +03:00
|
|
|
e = gfs_mkdir(fn, mode);
|
2019-06-21 15:05:41 +03:00
|
|
|
if (e == GFARM_ERR_NO_ERROR)
|
|
|
|
return (0);
|
|
|
|
errno = gfarm_error_to_errno(e);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_rmdir(const char *fn, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (0);
|
|
|
|
|
2019-06-22 04:48:41 +03:00
|
|
|
e = gfs_rmdir(fn);
|
2019-06-21 15:05:41 +03:00
|
|
|
if (e == GFARM_ERR_NO_ERROR)
|
|
|
|
return (0);
|
|
|
|
errno = gfarm_error_to_errno(e);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_access(const char *fn, int mode, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
struct gfs_stat st;
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
e = gfs_stat(fn, &st);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR) {
|
|
|
|
errno = gfarm_error_to_errno(e);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
gfs_stat_free(&st);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX FIXME */
|
|
|
|
#define GFS_DEV ((dev_t)-1)
|
|
|
|
#define GFS_BLKSIZE 8192
|
|
|
|
#define STAT_BLKSIZ 512 /* for st_blocks */
|
|
|
|
|
|
|
|
int
|
2020-10-26 14:26:10 +03:00
|
|
|
Gfarm_stat(const char *fn, struct stat *buf, aiori_mod_opt_t *param)
|
2019-06-21 15:05:41 +03:00
|
|
|
{
|
|
|
|
struct gfs_stat st;
|
|
|
|
gfarm_error_t e;
|
|
|
|
|
2020-10-26 14:26:10 +03:00
|
|
|
if (hints->dryRun)
|
2019-06-21 15:05:41 +03:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
e = gfs_stat(fn, &st);
|
|
|
|
if (e != GFARM_ERR_NO_ERROR) {
|
|
|
|
errno = gfarm_error_to_errno(e);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
buf->st_dev = GFS_DEV;
|
|
|
|
buf->st_ino = st.st_ino;
|
|
|
|
buf->st_mode = st.st_mode;
|
|
|
|
buf->st_nlink = st.st_nlink;
|
|
|
|
buf->st_uid = getuid(); /* XXX */
|
|
|
|
buf->st_gid = getgid(); /* XXX */
|
|
|
|
buf->st_size = st.st_size;
|
|
|
|
buf->st_blksize = GFS_BLKSIZE;
|
|
|
|
buf->st_blocks = (st.st_size + STAT_BLKSIZ - 1) / STAT_BLKSIZ;
|
|
|
|
buf->st_atime = st.st_atimespec.tv_sec;
|
|
|
|
buf->st_mtime = st.st_mtimespec.tv_sec;
|
|
|
|
buf->st_ctime = st.st_ctimespec.tv_sec;
|
|
|
|
#if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
|
|
|
|
buf->st_atim.tv_nsec = st.st_atimespec.tv_nsec;
|
|
|
|
buf->st_mtim.tv_nsec = st.st_mtimespec.tv_nsec;
|
|
|
|
buf->st_ctim.tv_nsec = st.st_ctimespec.tv_nsec;
|
|
|
|
#endif
|
|
|
|
gfs_stat_free(&st);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2020-11-06 12:15:39 +03:00
|
|
|
void
|
|
|
|
Gfarm_sync(aiori_mod_opt_t *param)
|
|
|
|
{
|
|
|
|
if (hints->dryRun)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* no cache in libgfarm */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-06-21 15:05:41 +03:00
|
|
|
ior_aiori_t gfarm_aiori = {
|
|
|
|
.name = "Gfarm",
|
|
|
|
.name_legacy = NULL,
|
|
|
|
.create = Gfarm_create,
|
|
|
|
.open = Gfarm_open,
|
2020-10-26 14:26:10 +03:00
|
|
|
.xfer_hints = Gfarm_xfer_hints,
|
2019-06-21 15:05:41 +03:00
|
|
|
.xfer = Gfarm_xfer,
|
|
|
|
.close = Gfarm_close,
|
|
|
|
.delete = Gfarm_delete,
|
|
|
|
.get_version = Gfarm_version,
|
|
|
|
.fsync = Gfarm_fsync,
|
|
|
|
.get_file_size = Gfarm_get_file_size,
|
|
|
|
.statfs = Gfarm_statfs,
|
|
|
|
.mkdir = Gfarm_mkdir,
|
|
|
|
.rmdir = Gfarm_rmdir,
|
|
|
|
.access = Gfarm_access,
|
|
|
|
.stat = Gfarm_stat,
|
|
|
|
.initialize = Gfarm_initialize,
|
|
|
|
.finalize = Gfarm_finalize,
|
|
|
|
.get_options = NULL,
|
2020-11-06 12:15:39 +03:00
|
|
|
.sync = Gfarm_sync,
|
2019-06-21 15:05:41 +03:00
|
|
|
.enable_mdtest = true,
|
|
|
|
};
|