bool
glfs_java_file_isFile (glfs_t *glfs, const char *path)
{
struct stat buf;
int ret;
ret = glfs_lstat (glfs, path, &buf);
return (ret == 0 && !S_ISDIR (buf.st_mode));
}
bool
glfs_java_file_exists (glfs_t *glfs, const char *path)
{
struct stat buf;
int ret;
ret = glfs_lstat (glfs, path, &buf);
return (ret == 0);
}
unsigned long glfs_java_getmod(glfs_t *glfs, const char *path){
struct stat buf;
long ret;
ret = glfs_lstat (glfs, path, &buf);
if (ret < 0)
return -1;
return buf.st_mode;
}
long glfs_java_getctime(glfs_t *glfs, const char *path){
struct stat buf;
long ret;
ret = glfs_lstat (glfs, path, &buf);
if (ret < 0)
return -1;
return buf.st_ctime;
}
int glfs_java_getblocksize(glfs_t *glfs, const char *path){
struct stat buf;
long ret;
ret = glfs_lstat (glfs, path, &buf);
if (ret < 0)
return -1;
return buf.st_blksize;
}
unsigned int glfs_java_getgid(glfs_t *glfs, const char *path){
struct stat buf;
long ret;
ret = glfs_lstat (glfs, path, &buf);
if (ret < 0)
return -1;
return buf.st_gid;
}
long
glfs_java_file_length (glfs_t *glfs, const char *path)
{
struct stat buf;
long ret;
ret = glfs_lstat (glfs, path, &buf);
if (ret < 0)
return -1;
return buf.st_size;
}
int
main (int argc, char *argv[])
{
glfs_t *fs = NULL;
int ret = 0;
glfs_fd_t *fd = NULL;
struct stat sb = {0, };
char readbuf[32];
char writebuf[32];
char *volname = "iops";
char *filename = "/filename2";
fs = glfs_new (volname);
if (!fs) {
fprintf (stderr, "glfs_new: returned NULL\n");
return 1;
}
// ret = glfs_set_volfile (fs, "/tmp/filename.vol");
ret = glfs_set_volfile_server (fs, "socket", "localhost", 24007);
// ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
ret = glfs_set_logging (fs, "/dev/stderr", 7);
ret = glfs_init (fs);
fprintf (stderr, "glfs_init: returned %d\n", ret);
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
fd = glfs_creat (fs, filename, O_RDWR, 0644);
fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
sprintf (writebuf, "hi there\n");
ret = glfs_write (fd, writebuf, 32, 0);
glfs_lseek (fd, 0, SEEK_SET);
ret = glfs_read (fd, readbuf, 32, 0);
printf ("read %d, %s", ret, readbuf);
glfs_close (fd);
return ret;
}
bool
glfs_java_file_delete (glfs_t *glfs, const char *path)
{
int ret;
struct stat buf;
ret = glfs_lstat (glfs, path, &buf);
if (ret != 0)
return false;
if (S_ISDIR (buf.st_mode))
ret = glfs_rmdir (glfs, path);
else
ret = glfs_unlink (glfs, path);
return (ret == 0);
}
int
main (int argc, char *argv[])
{
glfs_t *fs = NULL;
glfs_t *fs2 = NULL;
int ret = 0;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd2 = NULL;
struct stat sb = {0, };
char readbuf[32];
char writebuf[32];
char *filename = "/filename2";
fs = glfs_new ("fsync");
if (!fs) {
fprintf (stderr, "glfs_new: returned NULL\n");
return 1;
}
// ret = glfs_set_volfile (fs, "/tmp/posix.vol");
ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
// ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
ret = glfs_set_logging (fs, "/dev/stderr", 7);
ret = glfs_init (fs);
fprintf (stderr, "glfs_init: returned %d\n", ret);
sleep (2);
fs2 = glfs_new ("fsync");
if (!fs2) {
fprintf (stderr, "glfs_new: returned NULL\n");
return 1;
}
// ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007);
ret = glfs_set_logging (fs2, "/dev/stderr", 7);
ret = glfs_init (fs2);
fprintf (stderr, "glfs_init: returned %d\n", ret);
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
fd = glfs_creat (fs, filename, O_RDWR, 0644);
fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
fd2 = glfs_open (fs2, filename, O_RDWR);
fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
sprintf (writebuf, "hi there\n");
ret = glfs_write (fd, writebuf, 32, 0);
glfs_lseek (fd2, 0, SEEK_SET);
ret = glfs_read (fd2, readbuf, 32, 0);
printf ("read %d, %s", ret, readbuf);
glfs_close (fd);
glfs_close (fd2);
filename = "/filename3";
ret = glfs_mknod (fs, filename, S_IFIFO, 0);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_rename (fs, filename, "/filename4");
fprintf (stderr, "rename(%s): (%d) %s\n", filename, ret,
strerror (errno));
ret = glfs_unlink (fs, "/filename4");
fprintf (stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
strerror (errno));
filename = "/dirname2";
ret = glfs_mkdir (fs, filename, 0);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_rmdir (fs, filename);
fprintf (stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror (errno));
test_dirops (fs);
test_xattr (fs);
test_chdir (fs);
// done
glfs_fini (fs);
glfs_fini (fs2);
return ret;
}
static int tcmu_glfs_open(struct tcmu_device *dev)
{
struct glfs_state *gfsp;
int ret = 0;
char *config;
struct stat st;
int attribute;
gfsp = calloc(1, sizeof(*gfsp));
if (!gfsp)
return -ENOMEM;
tcmu_set_dev_private(dev, gfsp);
attribute = tcmu_get_attribute(dev, "hw_block_size");
if (attribute == -1) {
errp("Could not get hw_block_size setting\n");
goto fail;
}
gfsp->block_size = attribute;
config = strchr(tcmu_get_dev_cfgstring(dev), '/');
if (!config) {
errp("no configuration found in cfgstring\n");
goto fail;
}
config += 1; /* get past '/' */
if (parse_imagepath(config, &gfsp->servername, &gfsp->volname, &gfsp->pathname) == -1) {
errp("servername, volname, or pathname not set\n");
goto fail;
}
gfsp->fs = glfs_new(gfsp->volname);
if (!gfsp->fs) {
errp("glfs_new failed\n");
goto fail;
}
ret = glfs_set_volfile_server(gfsp->fs, "tcp", gfsp->servername,
GLUSTER_PORT);
if (ret) {
errp("glfs_set_volfile_server failed: %m\n");
goto fail;
}
ret = glfs_init(gfsp->fs);
if (ret) {
errp("glfs_init failed: %m\n");
goto fail;
}
gfsp->gfd = glfs_open(gfsp->fs, gfsp->pathname, ALLOWED_BSOFLAGS);
if (!gfsp->gfd) {
errp("glfs_open failed: %m\n");
goto fail;
}
ret = glfs_lstat(gfsp->fs, gfsp->pathname, &st);
if (ret) {
errp("glfs_lstat failed: %m\n");
goto fail;
}
if (st.st_size != tcmu_get_device_size(dev)) {
errp("device size and backing size disagree: "
"device %lld backing %lld\n",
tcmu_get_device_size(dev),
(long long) st.st_size);
goto fail;
}
return 0;
fail:
if (gfsp->gfd)
glfs_close(gfsp->gfd);
if (gfsp->fs)
glfs_fini(gfsp->fs);
free(gfsp->volname);
free(gfsp->pathname);
free(gfsp->servername);
free(gfsp);
return -EIO;
}
static bool glfs_check_config(const char *cfgstring, char **reason)
{
char *path;
char *servername = NULL;
char *volname = NULL;
char *pathname = NULL;
glfs_t *fs = NULL;
glfs_fd_t *gfd = NULL;
struct stat st;
int ret;
bool result = true;
path = strchr(cfgstring, '/');
if (!path) {
if (asprintf(reason, "No path found") == -1)
*reason = NULL;
result = false;
goto done;
}
path += 1; /* get past '/' */
if (parse_imagepath(path, &servername, &volname, &pathname) == -1) {
if (asprintf(reason, "Invalid imagepath") == -1)
*reason = NULL;
result = false;
goto done;
}
/* Actually attempt to open the volume to verify things are working */
/* TODO: consolidate this with v. similar tcmu_glfs_open code? */
fs = glfs_new(volname);
if (!fs) {
if (asprintf(reason, "glfs_new failed") == -1)
*reason = NULL;
result = false;
goto done;
}
ret = glfs_set_volfile_server(fs, "tcp", servername,
GLUSTER_PORT);
if (ret) {
if (asprintf(reason, "glfs_set_volfile_server failed: %m") == -1)
*reason = NULL;
result = false;
goto done;
}
ret = glfs_init(fs);
if (ret) {
if (asprintf(reason, "glfs_init failed: %m") == -1)
*reason = NULL;
result = false;
goto done;
}
gfd = glfs_open(fs, pathname, ALLOWED_BSOFLAGS);
if (!gfd) {
if (asprintf(reason, "glfs_open failed: %m") == -1)
*reason = NULL;
result = false;
goto done;
}
ret = glfs_lstat(fs, pathname, &st);
if (ret) {
if (asprintf(reason, "glfs_lstat failed: %m") == -1)
*reason = NULL;
result = false;
goto done;
}
done:
if (gfd)
glfs_close(gfd);
if (fs)
glfs_fini(fs);
free(servername);
free(volname);
free(pathname);
return result;
}
static int
large_number_of_fops (glfs_t *fs) {
int ret = 0;
int i = 0;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd1 = NULL;
char *dir1 = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL;
char *buf = NULL;
struct stat sb = {0, };
for (i = 0 ; i < FOP_LOOP_COUNT ; i++) {
ret = asprintf (&dir1, "dir%d", extension);
if (ret < 0) {
fprintf (stderr, "cannot construct filename (%s)",
strerror (errno));
return ret;
}
extension++;
ret = glfs_mkdir (fs, dir1, 0755);
if (ret < 0) {
fprintf (stderr, "mkdir(%s): %s\n", dir1, strerror (errno));
return -1;
}
fd = glfs_opendir (fs, dir1);
if (!fd) {
fprintf (stderr, "/: %s\n", strerror (errno));
return -1;
}
ret = glfs_fsetxattr (fd, "user.dirfattr", "fsetxattr", 8, 0);
if (ret < 0) {
fprintf (stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret,
strerror (errno));
return -1;
}
ret = glfs_closedir (fd);
if (ret < 0) {
fprintf (stderr, "glfs_closedir failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
ret = glfs_rmdir (fs, dir1);
if (ret < 0) {
fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
ret = asprintf (&filename1, "file%d", extension);
if (ret < 0) {
fprintf (stderr, "cannot construct filename (%s)",
strerror (errno));
return ret;
}
ret = asprintf (&filename2, "file-%d", extension);
if (ret < 0) {
fprintf (stderr, "cannot construct filename (%s)",
strerror (errno));
return ret;
}
extension++;
fd = glfs_creat (fs, filename1, O_RDWR, 0644);
if (!fd) {
fprintf (stderr, "%s: (%p) %s\n", filename1, fd,
strerror (errno));
return -1;
}
ret = glfs_rename (fs, filename1, filename2);
if (ret < 0) {
fprintf (stderr, "glfs_rename failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
ret = glfs_lstat (fs, filename2, &sb);
if (ret < 0) {
fprintf (stderr, "glfs_lstat failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
ret = glfs_close (fd);
if (ret < 0) {
fprintf (stderr, "glfs_close failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
ret = glfs_unlink (fs, filename2);
if (ret < 0) {
fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
}
}
int
gluster_put (glfs_t *fs, struct state *state)
{
int ret = -1;
glfs_fd_t *fd = NULL;
char *filename = state->gluster_url->path;
char *dir_path = strdup (state->gluster_url->path);
struct stat statbuf;
if (dir_path == NULL) {
error (EXIT_FAILURE, errno, "strdup");
goto out;
}
ret = glfs_lstat (fs, filename, &statbuf);
if (ret != -1 && !state->append && !state->overwrite) {
errno = EEXIST;
ret = -1;
goto out;
}
if (state->parents) {
ret = gluster_create_path (fs, dir_path,
get_default_dir_mode_perm ());
if (ret == -1) {
goto out;
}
}
fd = glfs_creat (fs, filename, O_RDWR, get_default_file_mode_perm ());
if (fd == NULL) {
ret = -1;
goto out;
}
ret = gluster_lock (fd, F_WRLCK);
if (ret == -1) {
goto out;
}
if (state->append) {
ret = glfs_lseek (fd, 0, SEEK_END);
if (ret == -1) {
error (0, errno, "seek error: %s", filename);
goto out;
}
} else {
ret = glfs_ftruncate (fd, 0);
if (ret == -1) {
error (0, errno, "truncate error: %s", filename);
goto out;
}
}
if (gluster_write (STDIN_FILENO, fd) == 0) {
ret = -1;
}
out:
free (dir_path);
if (fd) {
glfs_close (fd);
}
return ret;
}
