int
write_something (glfs_t *fs)
{
glfs_fd_t *fd = NULL;
char *buf = NULL;
int ret = 0;
int j = 0;
fd = glfs_creat (fs, "filename", O_RDWR, 0644);
if (!fd) {
fprintf (stderr, "%s: (%p) %s\n", "filename", fd,
strerror (errno));
return -1;
}
buf = (char *) malloc (WRITE_SIZE);
memset (buf, '-', WRITE_SIZE);
for (j = 0; j < 4; j++) {
ret = glfs_write (fd, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Write(%s): %d (%s)\n", "filename", ret,
strerror (errno));
return ret;
}
glfs_lseek (fd, 0, SEEK_SET);
}
return 0;
}
bool gfapi_device::d_truncate(DCR *dcr)
{
struct stat st;
if (m_gfd) {
if (glfs_ftruncate(m_gfd, 0) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
print_name(), be.bstrerror());
Emsg0(M_FATAL, 0, errmsg);
return false;
}
/*
* Check for a successful glfs_truncate() and issue work-around when truncation doesn't work.
*
* 1. close file
* 2. delete file
* 3. open new file with same mode
* 4. change ownership to original
*/
if (glfs_fstat(m_gfd, &st) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"), print_name(), be.bstrerror());
return false;
}
if (st.st_size != 0) { /* glfs_truncate() didn't work */
glfs_close(m_gfd);
glfs_unlink(m_glfs, getVolCatName());
set_mode(CREATE_READ_WRITE);
/*
* Recreate the file -- of course, empty
*/
m_gfd = glfs_creat(m_glfs, getVolCatName(), oflags, st.st_mode);
if (!m_gfd) {
berrno be;
dev_errno = errno;
Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), getVolCatName(), be.bstrerror());
Emsg0(M_FATAL, 0, errmsg);
return false;
}
/*
* Reset proper owner
*/
glfs_chown(m_glfs, getVolCatName(), st.st_uid, st.st_gid);
}
}
return true;
}
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;
}
int
glfs_test_function (const char *hostname, const char *volname,
const char *logfile)
{
int ret = -1;
int flags = O_CREAT | O_RDWR;
glfs_t *fs = NULL;
glfs_fd_t *glfd = NULL;
const char *buff = "This is from my prog\n";
const char *filename = "glfs_test.txt";
fs = init_glfs (hostname, volname, logfile);
if (fs == NULL) {
LOG_ERR ("init_glfs failed");
return -1;
}
glfd = glfs_creat (fs, filename, flags, 0644);
if (glfd == NULL) {
LOG_ERR ("glfs_creat failed");
goto out;
}
ret = glfs_write (glfd, buff, strlen (buff), flags);
if (ret < 0) {
LOG_ERR ("glfs_write failed");
goto out;
}
ret = glfs_close (glfd);
if (ret < 0) {
LOG_ERR ("glfs_write failed");
goto out;
}
out:
ret = glfs_fini (fs);
if (ret) {
LOG_ERR ("glfs_fini failed");
}
return ret;
}
static int qemu_gluster_create(const char *filename,
QEMUOptionParameter *options)
{
struct glfs *glfs;
struct glfs_fd *fd;
int ret = 0;
int64_t total_size = 0;
GlusterConf *gconf = g_malloc0(sizeof(GlusterConf));
glfs = qemu_gluster_init(gconf, filename);
if (!glfs) {
ret = -errno;
goto out;
}
while (options && options->name) {
if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
total_size = options->value.n / BDRV_SECTOR_SIZE;
}
options++;
}
fd = glfs_creat(glfs, gconf->image,
O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR);
if (!fd) {
ret = -errno;
} else {
if (glfs_ftruncate(fd, total_size * BDRV_SECTOR_SIZE) != 0) {
ret = -errno;
}
if (glfs_close(fd) != 0) {
ret = -errno;
}
}
out:
qemu_gluster_gconf_free(gconf);
if (glfs) {
glfs_fini(glfs);
}
return ret;
}
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 qemu_gluster_create(const char *filename,
QEMUOptionParameter *options, Error **errp)
{
struct glfs *glfs;
struct glfs_fd *fd;
int ret = 0;
int prealloc = 0;
int64_t total_size = 0;
GlusterConf *gconf = g_malloc0(sizeof(GlusterConf));
glfs = qemu_gluster_init(gconf, filename, errp);
if (!glfs) {
ret = -EINVAL;
goto out;
}
while (options && options->name) {
if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
total_size = options->value.n / BDRV_SECTOR_SIZE;
} else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
if (!options->value.s || !strcmp(options->value.s, "off")) {
prealloc = 0;
} else if (!strcmp(options->value.s, "full") &&
gluster_supports_zerofill()) {
prealloc = 1;
} else {
error_setg(errp, "Invalid preallocation mode: '%s'"
" or GlusterFS doesn't support zerofill API",
options->value.s);
ret = -EINVAL;
goto out;
}
}
options++;
}
fd = glfs_creat(glfs, gconf->image,
O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR);
if (!fd) {
ret = -errno;
} else {
if (!glfs_ftruncate(fd, total_size * BDRV_SECTOR_SIZE)) {
if (prealloc && qemu_gluster_zerofill(fd, 0,
total_size * BDRV_SECTOR_SIZE)) {
ret = -errno;
}
} else {
ret = -errno;
}
if (glfs_close(fd) != 0) {
ret = -errno;
}
}
out:
qemu_gluster_gconf_free(gconf);
if (glfs) {
glfs_fini(glfs);
}
return ret;
}
int
main (int argc, char *argv[])
{
glfs_t *fs = NULL;
glfs_t *fs2 = NULL;
glfs_t *fs_tmp = NULL;
glfs_t *fs_tmp2 = NULL;
int ret = 0, i;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd2 = NULL;
glfs_fd_t *fd_tmp = NULL;
glfs_fd_t *fd_tmp2 = NULL;
char readbuf[32];
char *filename = "file_tmp";
char *writebuf = NULL;
char *vol_id = NULL;
unsigned int cnt = 1;
struct glfs_upcall *cbk = NULL;
char *logfile = NULL;
char *volname = NULL;
char *hostname = NULL;
if (argc != 4) {
fprintf (stderr, "Invalid argument\n");
exit(1);
}
hostname = argv[1];
volname = argv[2];
logfile = argv[3];
fs = glfs_new (volname);
if (!fs) {
fprintf (stderr, "glfs_new: returned NULL\n");
return -1;
}
ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
LOG_ERR("glfs_set_volfile_server", ret);
ret = glfs_set_logging (fs, logfile, 7);
LOG_ERR("glfs_set_logging", ret);
ret = glfs_init (fs);
LOG_ERR("glfs_init", ret);
/* This does not block, but enables caching of events. Real
* applications like NFS-Ganesha run this in a thread before activity
* on the fs (through this instance) happens. */
ret = glfs_h_poll_upcall(fs_tmp, &cbk);
LOG_ERR ("glfs_h_poll_upcall", ret);
fs2 = glfs_new (volname);
if (!fs2) {
fprintf (stderr, "glfs_new fs2: returned NULL\n");
return 1;
}
ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
LOG_ERR("glfs_set_volfile_server-fs2", ret);
ret = glfs_set_logging (fs2, logfile, 7);
LOG_ERR("glfs_set_logging-fs2", ret);
ret = glfs_init (fs2);
LOG_ERR("glfs_init-fs2", ret);
fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
if (fd <= 0) {
ret = -1;
LOG_ERR ("glfs_creat", ret);
}
fprintf (stderr, "glfs-create fd - %d\n", fd);
fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
if (fd2 <= 0) {
ret = -1;
LOG_ERR ("glfs_open-fs2", ret);
}
fprintf (stderr, "glfs-open fd2 - %d\n", fd2);
do {
if (cnt%2) {
fd_tmp = fd;
fs_tmp = fs;
fd_tmp2 = fd2;
fs_tmp2 = fs2;
} else {
fd_tmp = fd2;
fs_tmp = fs2;
fd_tmp2 = fd;
fs_tmp2 = fs;
}
/* WRITE on fd_tmp */
writebuf = malloc(10);
if (writebuf) {
memcpy (writebuf, "abcd", 4);
ret = glfs_write (fd_tmp, writebuf, 4, 0);
if (ret <= 0) {
ret = -1;
LOG_ERR ("glfs_write", ret);
} else {
fprintf (stderr,
"glfs_write suceeded\n");
}
free(writebuf);
} else {
fprintf (stderr,
"Could not allocate writebuf\n");
return -1;
}
/* READ on fd_tmp2 */
ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
LOG_ERR ("glfs_lseek", ret);
memset (readbuf, 0, sizeof(readbuf));
ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL);
if (ret <= 0) {
ret = -1;
LOG_ERR ("glfs_pread", ret);
} else {
fprintf (stderr, "glfs_read: %s\n", readbuf);
}
/* Open() fops seem to be not performed on server side until
* there are I/Os on that fd
*/
if (cnt > 2) {
struct glfs_upcall_inode *in_arg = NULL;
enum glfs_upcall_reason reason = 0;
struct glfs_object *object = NULL;
uint64_t flags = 0;
uint64_t expire = 0;
ret = glfs_h_poll_upcall(fs_tmp, &cbk);
LOG_ERR ("glfs_h_poll_upcall", ret);
reason = glfs_upcall_get_reason (cbk);
/* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
in_arg = glfs_upcall_get_event (cbk);
object = glfs_upcall_inode_get_object (in_arg);
flags = glfs_upcall_inode_get_flags (in_arg);
expire = glfs_upcall_inode_get_expire (in_arg);
fprintf (stderr, " upcall event type - %d,"
" object(%p), flags(%d), "
" expire_time_attr(%d)\n" ,
reason, object, flags, expire);
} else {
fprintf (stderr,
"Didnt receive upcall notify event");
ret = -1;
goto err;
}
glfs_free (cbk);
}
sleep(5);
} while (++cnt < 5);
err:
glfs_close(fd);
LOG_ERR ("glfs_close", ret);
glfs_close(fd2);
LOG_ERR ("glfs_close-fd2", ret);
out:
if (fs) {
ret = glfs_fini(fs);
fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
}
if (fs2) {
ret = glfs_fini(fs2);
fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret);
}
if (ret)
exit(1);
exit(0);
}
int
main(int argc, char *argv[])
{
glfs_t *fs = NULL;
int ret = 0, i, status = 0;
glfs_fd_t *fd1 = NULL;
glfs_fd_t *fd2 = NULL;
glfs_fd_t *fd3 = NULL;
char *filename = "file_tmp";
char *volname = NULL;
char *logfile = NULL;
char *hostname = NULL;
if (argc != 4) {
fprintf(stderr, "Invalid argument\n");
exit(1);
}
hostname = argv[1];
volname = argv[2];
logfile = argv[3];
fs = glfs_new(volname);
if (!fs) {
fprintf(stderr, "glfs_new: returned NULL\n");
return -1;
}
ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
LOG_ERR("glfs_set_volfile_server", ret);
ret = glfs_set_logging(fs, logfile, 7);
LOG_ERR("glfs_set_logging", ret);
ret = glfs_init(fs);
LOG_ERR("glfs_init", ret);
fd1 = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
if (fd1 <= 0) {
ret = -1;
LOG_ERR("glfs_creat", ret);
}
fprintf(stderr, "glfs-create fd1 - %d\n", fd1);
fd2 = glfs_dup(fd1);
fprintf(stderr, "glfs-dup fd2 - %d\n", fd2);
fd3 = glfs_open(fs, filename, O_RDWR | O_SYNC);
if (fd2 <= 0) {
ret = -1;
LOG_ERR("glfs_open", ret);
}
fprintf(stderr, "glfs-open fd3 - %d\n", fd3);
/* TEST 1: Conflicting ranges, same lk_owner
* lock1 (0, 10, lownera)
* lock2 (5, 10, lownera)
* Expected: should not fail but get merged
*/
ret = lock_test(fd1, fd2, false, 0, 10, lownera, 8, 5, 10, lownera, 8);
LOG_ERR("==== glfs_lock_test_1", ret);
/* TEST 2: Conflicting ranges, different lk_owner
* lock1 (0, 10, lownera) - already taken
* lock2 (5, 10, lownerb)
* Expected: should fail and not get merged
*/
ret = lock_test(NULL, fd2, true, 0, 10, lownera, 8, 5, 10, lownerb, 8);
LOG_ERR("==== glfs_lock_test_2", ret);
/* TEST 3: Different ranges, same lk_owner
* lock1 (0, 10, lownera) - already taken
* lock2 (30, 10, lownera)
* Expected: should not fail
*/
ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 30, 10, lownera, 8);
LOG_ERR("==== glfs_lock_test_3", ret);
/* TEST 4: Conflicting ranges, different lk_owner
* lock1 (0, 10, lownera) - already taken
* lock2 (50, 10, lownerb)
* Expected: should not fail
*/
ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 50, 10, lownerb, 8);
LOG_ERR("==== glfs_lock_test_4", ret);
/* TEST 5: Close fd1 & retry TEST2
* lock1 (not applicable)
* lock2 (5, 10, lownerb)
* Expected: should succeed now
*/
ret = glfs_close(fd1);
LOG_ERR("glfs_close", ret);
ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 5, 10, lownerb, 8);
LOG_ERR("==== glfs_lock_test_5", ret);
/* TEST 6: Check closing fd1 doesn't flush fd2 locks
* retry TEST 4 but with fd2 and fd3.
* lock1 (50, 10, lownerb) - already taken
* lock2 (55, 10, lownerc)
* Expected: should fail
*/
ret = lock_test(NULL, fd3, true, 50, 10, lownerb, 8, 55, 10, lownerc, 8);
LOG_ERR("==== glfs_lock_test_6", ret);
err:
ret = glfs_close(fd2);
LOG_ERR("glfs_close", ret);
ret = glfs_close(fd3);
LOG_ERR("glfs_close", ret);
out:
if (fs) {
ret = glfs_fini(fs);
fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
}
if (ret)
exit(1);
exit(0);
}
int
main(int argc, char *argv[])
{
int ret = -1;
int flags = O_RDWR | O_SYNC;
glfs_t *fs = NULL;
glfs_fd_t *fd = NULL;
char *volname = NULL;
char *logfile = NULL;
const char *filename = "file_tmp";
struct glfs_object *object = NULL;
acl_t acl = NULL;
struct stat sb;
if (argc != 3) {
fprintf(stderr, "Invalid argument\n");
return 1;
}
volname = argv[1];
logfile = argv[2];
fs = glfs_new(volname);
if (!fs)
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
ret = glfs_set_logging(fs, logfile, 7);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
ret = glfs_init(fs);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
fd = glfs_creat(fs, filename, flags, 0044);
if (fd == NULL) {
ret = -1;
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
}
glfs_close(fd);
object = glfs_h_lookupat(fs, NULL, filename, NULL, 0);
if (object == NULL) {
ret = -1;
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out);
}
ret = glfs_chown(fs, filename, 99, 99);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out);
ret = glfs_setfsuid(99);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out);
ret = glfs_setfsgid(99);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out);
acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS);
if (acl == NULL) {
ret = -1;
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
}
ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
out:
glfs_setfsuid(0);
glfs_setfsgid(0);
if (object)
glfs_h_close(object);
if (fs)
glfs_fini(fs);
return ret;
}
int
main (int argc, char *argv[])
{
glfs_t *fs = NULL;
glfs_t *fs2 = NULL;
glfs_t *fs_tmp = NULL;
glfs_t *fs_tmp2 = NULL;
int ret = 0, i;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd2 = NULL;
glfs_fd_t *fd_tmp = NULL;
glfs_fd_t *fd_tmp2 = NULL;
char readbuf[32];
char *filename = "file_tmp";
char *writebuf = NULL;
char *vol_id = NULL;
unsigned int cnt = 1;
struct callback_arg cbk;
char *logfile = NULL;
char *volname = NULL;
cbk.object = NULL;
if (argc != 3) {
fprintf (stderr, "Invalid argument\n");
exit(1);
}
volname = argv[1];
logfile = argv[2];
fs = glfs_new (volname);
if (!fs) {
fprintf (stderr, "glfs_new: returned NULL\n");
return -1;
}
ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
LOG_ERR("glfs_set_volfile_server", ret);
ret = glfs_set_logging (fs, logfile, 7);
LOG_ERR("glfs_set_logging", ret);
ret = glfs_init (fs);
LOG_ERR("glfs_init", ret);
fs2 = glfs_new (volname);
if (!fs2) {
fprintf (stderr, "glfs_new fs2: returned NULL\n");
return 1;
}
ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007);
LOG_ERR("glfs_set_volfile_server-fs2", ret);
ret = glfs_set_logging (fs2, logfile, 7);
LOG_ERR("glfs_set_logging-fs2", ret);
ret = glfs_init (fs2);
LOG_ERR("glfs_init-fs2", ret);
fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
if (fd <= 0) {
ret = -1;
LOG_ERR ("glfs_creat", ret);
}
fprintf (stderr, "glfs-create fd - %d\n", fd);
fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
if (fd2 <= 0) {
ret = -1;
LOG_ERR ("glfs_open-fs2", ret);
}
fprintf (stderr, "glfs-open fd2 - %d\n", fd2);
do {
if (cnt%2) {
fd_tmp = fd;
fs_tmp = fs;
fd_tmp2 = fd2;
fs_tmp2 = fs2;
} else {
fd_tmp = fd2;
fs_tmp = fs2;
fd_tmp2 = fd;
fs_tmp2 = fs;
}
/* WRITE on fd_tmp */
writebuf = malloc(10);
if (writebuf) {
memcpy (writebuf, "abcd", 4);
ret = glfs_write (fd_tmp, writebuf, 4, 0);
if (ret <= 0) {
ret = -1;
LOG_ERR ("glfs_write", ret);
} else {
fprintf (stderr,
"glfs_write suceeded\n");
}
free(writebuf);
} else {
fprintf (stderr,
"Could not allocate writebuf\n");
return -1;
}
/* READ on fd_tmp2 */
ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
LOG_ERR ("glfs_lseek", ret);
ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0);
if (ret <= 0) {
ret = -1;
LOG_ERR ("glfs_pread", ret);
} else {
fprintf (stderr, "glfs_read: %s\n", readbuf);
}
/* Open() fops seem to be not performed on server side until
* there are I/Os on that fd
*/
if (cnt > 2) {
ret = glfs_h_poll_upcall(fs_tmp, &cbk);
LOG_ERR ("glfs_h_poll_upcall", ret);
if (cbk.object) {
fprintf (stderr, " upcall event type - %d,"
" flags - %d, expire_time_attr - %d\n" ,
cbk.reason, cbk.flags, cbk.expire_time_attr);
} else {
fprintf (stderr,
"Dint receive upcall notify event");
ret = -1;
goto err;
}
}
sleep(5);
} while (++cnt < 5);
err:
glfs_close(fd);
LOG_ERR ("glfs_close", ret);
glfs_close(fd2);
LOG_ERR ("glfs_close-fd2", ret);
out:
if (fs) {
ret = glfs_fini(fs);
fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
}
if (fs2) {
ret = glfs_fini(fs2);
fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret);
}
if (ret)
exit(1);
exit(0);
}
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;
}
}
}
/*
* Open a volume using gfapi.
*/
int gfapi_device::d_open(const char *pathname, int flags, int mode)
{
int status;
POOL_MEM virtual_filename(PM_FNAME);
/*
* Parse the gluster URI.
*/
if (!m_gfapi_volume) {
m_gfapi_volume = bstrdup(dev_name);
if (!parse_gfapi_devicename(m_gfapi_volume,
&m_transport,
&m_servername,
&m_volumename,
&m_basedir,
&m_serverport)) {
Mmsg1(errmsg, _("Unable to parse device URI %s.\n"), dev_name);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
}
/*
* See if we need to setup a Gluster context.
*/
if (!m_glfs) {
m_glfs = glfs_new(m_volumename);
if (!m_glfs) {
Mmsg1(errmsg, _("Unable to create new Gluster context for volumename %s.\n"), m_volumename);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
status = glfs_set_volfile_server(m_glfs, (m_transport) ? m_transport : "tcp", m_servername, m_serverport);
if (status < 0) {
Mmsg3(errmsg, _("Unable to initialize Gluster management server for transport %s, servername %s, serverport %d\n"),
(m_transport) ? m_transport : "tcp", m_servername, m_serverport);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
status = glfs_init(m_glfs);
if (status < 0) {
Mmsg1(errmsg, _("Unable to initialize Gluster for volumename %s.\n"), m_volumename);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
}
/*
* See if we don't have a file open already.
*/
if (m_gfd) {
glfs_close(m_gfd);
m_gfd = NULL;
}
/*
* See if we store in an explicit directory.
*/
if (m_basedir) {
struct stat st;
/*
* Make sure the dir exists if one is defined.
*/
Mmsg(virtual_filename, "/%s", m_basedir);
if (glfs_stat(m_glfs, virtual_filename.c_str(), &st) != 0) {
switch (errno) {
case ENOENT:
if (!gfapi_makedir(m_glfs, virtual_filename.c_str())) {
Mmsg1(errmsg, _("Specified glusterfs direcory %s cannot be created.\n"), virtual_filename.c_str());
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
break;
default:
goto bail_out;
}
} else {
if (!S_ISDIR(st.st_mode)) {
Mmsg1(errmsg, _("Specified glusterfs direcory %s is not a directory.\n"), virtual_filename.c_str());
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
}
Mmsg(virtual_filename, "/%s/%s", m_basedir, getVolCatName());
} else {
Mmsg(virtual_filename, "%s", getVolCatName());
}
/*
* See if the O_CREAT flag is set as glfs_open doesn't support that flag and you have to call glfs_creat then.
*/
if (flags & O_CREAT) {
m_gfd = glfs_creat(m_glfs, virtual_filename.c_str(), flags, mode);
} else {
m_gfd = glfs_open(m_glfs, virtual_filename.c_str(), flags);
}
if (!m_gfd) {
goto bail_out;
}
return 0;
bail_out:
/*
* Cleanup the Gluster context.
*/
if (m_glfs) {
glfs_fini(m_glfs);
m_glfs = NULL;
}
return -1;
}
int
main (int argc, char *argv[])
{
int ret = -1;
int flags = O_RDWR|O_SYNC;
glfs_t *fs = NULL;
glfs_fd_t *fd1 = NULL;
char *volname = NULL;
char *logfile = NULL;
const char *filename = "file_tmp";
const char buff[WRITE_SIZE];
struct stat sb;
if (argc != 3) {
fprintf (stderr, "Invalid argument\n");
return 1;
}
volname = argv[1];
logfile = argv[2];
fs = glfs_new (volname);
if (!fs)
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
ret = glfs_set_logging (fs, logfile, 7);
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
ret = glfs_init (fs);
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
fd1 = glfs_creat(fs, filename, flags, 0644);
if (fd1 == NULL) {
ret = -1;
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
}
ret = glfs_write (fd1, buff, WRITE_SIZE, flags);
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
ret = glfs_truncate (fs, filename, TRUNC_SIZE);
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_truncate", ret, out);
ret = glfs_fstat (fd1, &sb);
VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_fstat", ret, out);
if (sb.st_size != TRUNC_SIZE) {
fprintf (stderr, "wrong size %jd should be %jd\n",
(intmax_t)sb.st_size, (intmax_t)2048);
ret = -1;
}
out:
if (fd1 != NULL)
glfs_close(fd1);
if (fs) {
/*
* If this fails (as it does on Special Snowflake NetBSD for no
* good reason), it shouldn't affect the result of the test.
*/
(void) glfs_fini(fs);
}
return ret;
}
int
main(int argc, char *argv[])
{
glfs_t *fs = NULL;
int ret = 0;
glfs_fd_t *fd = NULL;
char *filename = NULL;
char *logfile = NULL;
char *host = NULL;
if (argc != 5) {
return -1;
}
host = argv[2];
logfile = argv[3];
filename = argv[4];
/* setup signal handler for exiting */
signal(SIGTERM, stop_running);
fs = glfs_new(argv[1]);
if (!fs) {
return -1;
}
ret = glfs_set_volfile_server(fs, "tcp", host, 24007);
if (ret < 0) {
return -1;
}
ret = glfs_set_logging(fs, logfile, 7);
if (ret < 0) {
return -1;
}
ret = glfs_init(fs);
if (ret < 0) {
return -1;
}
fd = glfs_creat(fs, filename, O_RDWR, 0644);
if (!fd) {
return -1;
}
/* sleep until SIGTERM has been received */
while (keep_running) {
sleep(1);
}
ret = glfs_close(fd);
if (ret < 0) {
return -1;
}
ret = glfs_fini(fs);
if (ret < 0) {
return -1;
}
return 0;
}
bool GlusterBackend::put(const SyncEvent* _putEvent) {
if(_putEvent == nullptr || _putEvent->fullPathBuffer.empty())
return false;
FileNode* node = FileSystem::getInstance().findAndOpenNode(_putEvent->fullPathBuffer);
if(node == nullptr){
LOG(ERROR)<<_putEvent->fullPathBuffer<<" Does not exist! So can't upload it.";
return false;
}
uint64_t inodeNum = FileSystem::getInstance().assignINodeNum((intptr_t)node);
//Double check if not already uploaded
if(node->flushed()){
node->close(inodeNum);
return true;
}
//CheckEvent validity
if(!UploadQueue::getInstance().checkEventValidity(*_putEvent)) {
//release file delete lock, so they can delete it
node->close(inodeNum);
return true;//going to be deletes so anyway say it's synced!
}
if(node->mustBeDeleted()){
node->close(inodeNum);
return true;
}
//Create necessary directories
//Traverse FileSystem Hierarchies
Poco::StringTokenizer tokenizer(_putEvent->fullPathBuffer,
FileSystem::delimiter,Poco::StringTokenizer::TOK_TRIM |
Poco::StringTokenizer::TOK_IGNORE_EMPTY);
//Nested directories
if(tokenizer.count()>=2){
for(unsigned int i=0;i<tokenizer.count()-1;i++){
string path = FileSystem::delimiter;
for(unsigned int j=0;j<=i;j++){
path += tokenizer[j];
path += FileSystem::delimiter;
}
if(!createDirectory(path.c_str())){
LOG(ERROR)<<"Failed to create parent directory("<<tokenizer[i]<<") for:"<<_putEvent->fullPathBuffer;
node->close(inodeNum);
return false;
}
}
}
//Create the file! (overwrite or create)
glfs_fd_t *fd = glfs_creat((glfs_t*)fs, _putEvent->fullPathBuffer.c_str(), O_RDWR, 0644);
//glfs_fd_t *fd = glfs_open(,O_RDWR| O_CREAT | O_TRUNC);
if(!fd){
LOG(ERROR)<<"Error in creating file:"<<_putEvent->fullPathBuffer<<" in GlusterFS. errno:"<<errno;
return false;
}
//Ready to write (write each time a blocksize)
uint64_t buffSize = 1024ll*1024ll*10ll;
char *buff = new char[buffSize];//10MB buffer
size_t offset = 0;
long read = 0;
//FileNode *node = _putEvent->node;
do {
//CheckEvent validity
if(!UploadQueue::getInstance().checkEventValidity(*_putEvent)){
glfs_close(fd);
delete []buff;
buff = nullptr;
node->close(inodeNum);
return true;
}
if(node->mustBeDeleted()){//Check Delete
glfs_close(fd);
delete []buff;
buff = nullptr;
node->close(inodeNum);
return true;
}
//get lock delete so file won't be deleted
read = node->read(buff,offset,buffSize);
offset += read;
int64_t written = glfs_write(fd,buff,read,0);
if(written!=read){
LOG(ERROR)<<"Error while writing to:"<<_putEvent->fullPathBuffer<<
". Asked to write:"<<read<<" but wrote:"<<written;
glfs_close(fd);
return false;
}
}
while(read > 0);
delete []buff;
buff = nullptr;
if(node->mustBeDeleted()){//Check Delete
glfs_close(fd);
node->close(inodeNum);
return true;
}
//Now sync
if(glfs_close(fd)!=0){
LOG(ERROR)<<"Error in closing:"<<_putEvent->fullPathBuffer<<" errorNo:"<<errno;
node->close(inodeNum);
return false;
}
node->close(inodeNum);
return true;
}
int
main(int argc, char *argv[])
{
int ret = -1;
glfs_t *fs = NULL;
char *volname = NULL;
char *logfile = NULL;
char *hostname = NULL;
char *my_file = "file_";
char my_file_name[MAXPATHNAME];
uint32_t flags = O_RDWR | O_SYNC;
struct glfs_fd *fd = NULL;
int i = 0;
int pct = 0;
struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp;
struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
if (argc != 4) {
fprintf(stderr, "Invalid argument\n");
return 1;
}
hostname = argv[1];
volname = argv[2];
logfile = argv[3];
fs = glfs_new(volname);
VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_new", !!fs, ret, out);
ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
ret = glfs_set_logging(fs, logfile, 7);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
ret = glfs_init(fs);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
for (i = 0; i < MAX_FILES_CREATE; i++) {
sprintf(my_file_name, "%s%d", my_file, i);
fd = glfs_creat(fs, my_file_name, flags, 0644);
VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_creat", !!fd, ret, out);
glfs_close(fd);
}
/* measure performance using old readdir call and new xreaddirplus call and
* compare */
ret = clock_gettime(CLOCK_REALTIME, &ost_timestamp);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
ret = old_readdir(fs);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("old_readdir", ret, out);
ret = clock_gettime(CLOCK_REALTIME, &oed_timestamp);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
assimilatetime(&otimestamp, ost_timestamp, oed_timestamp);
printf("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
otimestamp.tv_sec, otimestamp.tv_nsec);
ret = clock_gettime(CLOCK_REALTIME, &st_timestamp);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
ret = new_xreaddirplus(fs);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("new_xreaddirplus", ret, out);
ret = clock_gettime(CLOCK_REALTIME, &ed_timestamp);
VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
assimilatetime(×tamp, st_timestamp, ed_timestamp);
printf("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
timestamp.tv_sec, timestamp.tv_nsec);
pct = comparetime(otimestamp, timestamp);
printf("There is improvement by %d%%\n", pct);
ret = 0;
out:
if (fs) {
ret = glfs_fini(fs);
if (ret)
fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
}
return ret;
}
static int
large_read_write (glfs_t *fs) {
int ret = 0;
int j = 0;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd1 = NULL;
char *filename = NULL;
char *buf = NULL;
ret = asprintf (&filename, "filerw%d", extension);
if (ret < 0) {
fprintf (stderr, "cannot construct filename (%s)",
strerror (errno));
return ret;
}
extension++;
fd = glfs_creat (fs, filename, O_RDWR, 0644);
if (!fd) {
fprintf (stderr, "%s: (%p) %s\n", filename, fd,
strerror (errno));
return -1;
}
buf = (char *) malloc (WRITE_SIZE);
memset (buf, '-', WRITE_SIZE);
for (j = 0; j < READ_WRITE_LOOP; j++) {
ret = glfs_write (fd, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
strerror (errno));
return ret;
}
}
fd1 = glfs_open (fs, filename, O_RDWR);
if (fd1 < 0) {
fprintf (stderr, "Open(%s): %d (%s)\n", filename, ret,
strerror (errno));
return -1;
}
glfs_lseek (fd1, 0, SEEK_SET);
for (j = 0; j < READ_WRITE_LOOP; j++) {
ret = glfs_read (fd1, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Read(%s): %d (%s)\n", filename, ret,
strerror (errno));
return ret;
}
}
for (j = 0; j < READ_WRITE_LOOP; j++) {
ret = glfs_write (fd1, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
strerror (errno));
return ret;
}
}
glfs_close (fd);
glfs_close (fd1);
ret = glfs_unlink (fs, filename);
if (ret < 0) {
fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
free (buf);
free (filename);
}
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;
}
