static fsal_status_t file_close(struct fsal_obj_handle *obj_hdl) { int rc = 0; fsal_status_t status = { ERR_FSAL_NO_ERROR, 0 }; struct glusterfs_handle *objhandle = container_of(obj_hdl, struct glusterfs_handle, handle); #ifdef GLTIMING struct timespec s_time, e_time; now(&s_time); #endif rc = glfs_close(objhandle->glfd); if (rc != 0) { status = gluster2fsal_error(errno); goto out; } objhandle->glfd = NULL; objhandle->openflags = FSAL_O_CLOSED; out: #ifdef GLTIMING now(&e_time); latency_update(&s_time, &e_time, lat_file_close); #endif return status; }
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; }
static void qemu_gluster_close(BlockDriverState *bs) { BDRVGlusterState *s = bs->opaque; if (s->fd) { glfs_close(s->fd); s->fd = NULL; } glfs_fini(s->glfs); }
int main (int argc, char *argv[]) { glfs_t *fs = NULL; glfs_fd_t *fd = NULL; int ret = 1; if (argc != 4) { fprintf (stderr, "Syntax: %s <host> <volname> <file-path> \n", argv[0]); return 1; } fs = glfs_new (argv[2]); if (!fs) { fprintf (stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); if (ret != 0) { fprintf (stderr, "glfs_set_volfile_server: retuned %d\n", ret); goto out; } ret = glfs_set_logging (fs, "/var/log/glusterfs/glfs-dis.log", 7); if (ret != 0) { fprintf (stderr, "glfs_set_logging: returned %d\n", ret); goto out; } ret = glfs_init (fs); if (ret != 0) { fprintf (stderr, "glfs_init: returned %d\n", ret); goto out; } fd = glfs_open (fs, argv[3], O_RDWR); if (fd == NULL) { fprintf (stderr, "glfs_open: returned NULL\n"); goto out; } /* Zero-fill "foo" with 10MB of data */ ret = glfs_zerofill (fd, 0, 10485760); if (ret <= 0) { fprintf (stderr, "glfs_zerofill: returned %d\n", ret); goto out; } glfs_close(fd); ret = 0; out: glfs_fini (fs); return ret; }
static void tcmu_glfs_close(struct tcmu_device *dev) { struct glfs_state *gfsp = tcmu_get_dev_private(dev); glfs_close(gfsp->gfd); glfs_fini(gfsp->fs); free(gfsp->volname); free(gfsp->pathname); free(gfsp->servername); free(gfsp); }
int xglfs_release(const char* _path, struct fuse_file_info* _info) { (void)_path; int ret = 0; ret = glfs_close(FH_TO_FD(_info->fh)); if (unlikely(ret < 0)) ret = -errno; return ret; }
static int qemu_gluster_open(BlockDriverState *bs, const char *filename, QDict *options, int bdrv_flags) { BDRVGlusterState *s = bs->opaque; int open_flags = O_BINARY; int ret = 0; GlusterConf *gconf = g_malloc0(sizeof(GlusterConf)); s->glfs = qemu_gluster_init(gconf, filename); if (!s->glfs) { ret = -errno; goto out; } if (bdrv_flags & BDRV_O_RDWR) { open_flags |= O_RDWR; } else { open_flags |= O_RDONLY; } if ((bdrv_flags & BDRV_O_NOCACHE)) { open_flags |= O_DIRECT; } s->fd = glfs_open(s->glfs, gconf->image, open_flags); if (!s->fd) { ret = -errno; goto out; } ret = qemu_pipe(s->fds); if (ret < 0) { ret = -errno; goto out; } fcntl(s->fds[GLUSTER_FD_READ], F_SETFL, O_NONBLOCK); qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], qemu_gluster_aio_event_reader, NULL, qemu_gluster_aio_flush_cb, s); out: qemu_gluster_gconf_free(gconf); if (!ret) { return ret; } if (s->fd) { glfs_close(s->fd); } if (s->glfs) { glfs_fini(s->glfs); } return ret; }
int gfapi_device::d_close(int fd) { if (m_gfd) { int status; status = glfs_close(m_gfd); m_gfd = NULL; return status; } else { errno = EBADF; return -1; } }
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; }
static void qemu_gluster_close(BlockDriverState *bs) { BDRVGlusterState *s = bs->opaque; close(s->fds[GLUSTER_FD_READ]); close(s->fds[GLUSTER_FD_WRITE]); qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], NULL, NULL, NULL); if (s->fd) { glfs_close(s->fd); s->fd = NULL; } glfs_fini(s->glfs); }
static int qemu_gluster_open(BlockDriverState *bs, QDict *options, int bdrv_flags, Error **errp) { BDRVGlusterState *s = bs->opaque; int open_flags = 0; int ret = 0; GlusterConf *gconf = g_malloc0(sizeof(GlusterConf)); QemuOpts *opts; Error *local_err = NULL; const char *filename; opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); qemu_opts_absorb_qdict(opts, options, &local_err); if (local_err) { error_propagate(errp, local_err); ret = -EINVAL; goto out; } filename = qemu_opt_get(opts, "filename"); s->glfs = qemu_gluster_init(gconf, filename, errp); if (!s->glfs) { ret = -errno; goto out; } qemu_gluster_parse_flags(bdrv_flags, &open_flags); s->fd = glfs_open(s->glfs, gconf->image, open_flags); if (!s->fd) { ret = -errno; } out: qemu_opts_del(opts); qemu_gluster_gconf_free(gconf); if (!ret) { return ret; } if (s->fd) { glfs_close(s->fd); } if (s->glfs) { glfs_fini(s->glfs); } return ret; }
gfapi_device::~gfapi_device() { if (m_gfd) { glfs_close(m_gfd); m_gfd = NULL; } if (!m_glfs) { glfs_fini(m_glfs); m_glfs = NULL; } if (m_gfapi_volume) { free(m_gfapi_volume); m_gfapi_volume = NULL; } }
/** * @brief Commit a byte range to a DS handle. * * NFSv4.1 data server filehandles are disjount from normal * filehandles (in Ganesha, there is a ds_flag in the filehandle_v4_t * structure) and do not get loaded into cache_inode or processed the * normal way. * * @param[in] ds_pub FSAL DS handle * @param[in] req_ctx Credentials * @param[in] offset Start of commit window * @param[in] count Length of commit window * @param[out] writeverf Write verifier * * @return An NFSv4.1 status code. */ static nfsstat4 ds_commit(struct fsal_ds_handle *const ds_pub, struct req_op_context *const req_ctx, const offset4 offset, const count4 count, verifier4 * const writeverf) { memset(writeverf, 0, NFS4_VERIFIER_SIZE); struct glfs_ds_handle *ds = container_of(ds_pub, struct glfs_ds_handle, ds); int rc = 0; fsal_status_t status = { ERR_FSAL_NO_ERROR, 0 }; if (ds->stability_got == FILE_SYNC4) { struct glusterfs_export *glfs_export = container_of(ds_pub->pds->mds_fsal_export, struct glusterfs_export, export); struct glfs_fd *glfd = NULL; SET_GLUSTER_CREDS(glfs_export, &op_ctx->creds->caller_uid, &op_ctx->creds->caller_gid, op_ctx->creds->caller_glen, op_ctx->creds->caller_garray); glfd = glfs_h_open(glfs_export->gl_fs->fs, ds->glhandle, O_RDWR); if (glfd == NULL) { LogDebug(COMPONENT_PNFS, "glfd in ds_handle is NULL"); SET_GLUSTER_CREDS(glfs_export, NULL, NULL, 0, NULL); return NFS4ERR_SERVERFAULT; } rc = glfs_fsync(glfd); if (rc != 0) LogMajor(COMPONENT_PNFS, "ds_commit() failed %d", -rc); rc = glfs_close(glfd); if (rc != 0) LogDebug(COMPONENT_PNFS, "status after close %d", -rc); SET_GLUSTER_CREDS(glfs_export, NULL, NULL, 0, NULL); } if ((rc != 0) || (status.major != ERR_FSAL_NO_ERROR)) return NFS4ERR_INVAL; return NFS4_OK; }
int cli_disconnect (struct cli_context *ctx) { int ret = 0; struct fd_list *cur, *ptr = NULL; free_xlator_options (&ctx->options->xlator_options); /* Traverse fd_list and cleanup each entry.*/ ptr = ctx->flist; while (ptr) { if (ptr->fd) { glfs_close (ptr->fd); ptr->fd = NULL; } if (ptr->path) { free (ptr->path); ptr->path = NULL; } cur = ptr; ptr = ptr->next; free (cur); } if (ctx->fs) { // FIXME: Memory leak occurs here in GFS >= 3.6. Test with 3.7 // and if fixed, remove the entry (xlator_mem_acct_init) from // the valgrind suppression file. ret = glfs_fini (ctx->fs); ctx->fs = NULL; } if (ctx->url) { gluster_url_free (ctx->url); ctx->url = NULL; } free (ctx->conn_str); ctx->conn_str = NULL; return ret; }
static fsal_status_t handle_release(struct fsal_obj_handle *obj_hdl) { int rc = 0; fsal_status_t status = { ERR_FSAL_NO_ERROR, 0 }; struct glusterfs_handle *objhandle = container_of(obj_hdl, struct glusterfs_handle, handle); #ifdef GLTIMING struct timespec s_time, e_time; now(&s_time); #endif rc = fsal_obj_handle_uninit(&objhandle->handle); if (rc != 0) { status = gluster2fsal_error(rc); goto out; } if (objhandle->glfd) { rc = glfs_close(objhandle->glfd); if (rc) { status = gluster2fsal_error(errno); /* cleanup as much as possible */ } } if (objhandle->glhandle) { rc = glfs_h_close(objhandle->glhandle); if (rc) { status = gluster2fsal_error(errno); goto out; } } gsh_free(objhandle); out: #ifdef GLTIMING now(&e_time); latency_update(&s_time, &e_time, lat_handle_release); #endif return status; }
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; }
gfapi_device::~gfapi_device() { if (m_gfd) { glfs_close(m_gfd); m_gfd = NULL; } if (!m_glfs) { glfs_fini(m_glfs); m_glfs = NULL; } if (m_gfapi_volume) { free(m_gfapi_volume); m_gfapi_volume = NULL; } free_pool_memory(m_virtual_filename); }
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; }
static void qemu_gluster_reopen_abort(BDRVReopenState *state) { BDRVGlusterReopenState *reop_s = state->opaque; if (reop_s == NULL) { return; } if (reop_s->fd) { glfs_close(reop_s->fd); } if (reop_s->glfs) { glfs_fini(reop_s->glfs); } g_free(state->opaque); state->opaque = NULL; return; }
static void qemu_gluster_reopen_commit(BDRVReopenState *state) { BDRVGlusterReopenState *reop_s = state->opaque; BDRVGlusterState *s = state->bs->opaque; /* close the old */ if (s->fd) { glfs_close(s->fd); } if (s->glfs) { glfs_fini(s->glfs); } /* use the newly opened image / connection */ s->fd = reop_s->fd; s->glfs = reop_s->glfs; g_free(state->opaque); state->opaque = NULL; return; }
static int gluster_get (glfs_t *fs, const char *filename) { glfs_fd_t *fd = NULL; int ret = -1; fd = glfs_open (fs, filename, O_RDONLY); if (fd == NULL) { error (0, errno, state->url); goto out; } // don't allow concurrent reads and writes. ret = gluster_lock (fd, F_WRLCK); if (ret == -1) { error (0, errno, state->url); goto out; } if ((ret = gluster_read (fd, STDOUT_FILENO)) == -1) { error (0, errno, "write error"); goto out; } ret = 0; out: if (fd) { if (glfs_close (fd) == -1) { ret = -1; error (0, errno, "cannot close file %s", state->gluster_url->path); } } return ret; }
static int uwsgi_glusterfs_request(struct wsgi_request *wsgi_req) { char filename[PATH_MAX+1]; /* Standard GlusterFS request */ if (!wsgi_req->uh->pktsize) { uwsgi_log( "Empty GlusterFS request. skip.\n"); return -1; } if (uwsgi_parse_vars(wsgi_req)) { return -1; } // blocks empty paths if (wsgi_req->path_info_len == 0 || wsgi_req->path_info_len > PATH_MAX) { uwsgi_403(wsgi_req); return UWSGI_OK; } wsgi_req->app_id = uwsgi_get_app_id(wsgi_req, wsgi_req->appid, wsgi_req->appid_len, glusterfs_plugin.modifier1); if (wsgi_req->app_id == -1 && !uwsgi.no_default_app && uwsgi.default_app > -1) { if (uwsgi_apps[uwsgi.default_app].modifier1 == glusterfs_plugin.modifier1) { wsgi_req->app_id = uwsgi.default_app; } } if (wsgi_req->app_id == -1) { uwsgi_404(wsgi_req); return UWSGI_OK; } struct uwsgi_app *ua = &uwsgi_apps[wsgi_req->app_id]; memcpy(filename, wsgi_req->path_info, wsgi_req->path_info_len); filename[wsgi_req->path_info_len] = 0; glfs_fd_t *fd = glfs_open((glfs_t *) ua->interpreter, filename, O_RDONLY); if (!fd) { uwsgi_404(wsgi_req); return UWSGI_OK; } struct stat st; if (glfs_fstat(fd, &st)) { uwsgi_403(wsgi_req); return UWSGI_OK; } if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end; size_t mime_type_len = 0; char *mime_type = uwsgi_get_mime_type(wsgi_req->path_info, wsgi_req->path_info_len, &mime_type_len); if (mime_type) { if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end; } if (uwsgi_response_add_last_modified(wsgi_req, (uint64_t) st.st_mtime)) goto end; if (uwsgi_response_add_content_length(wsgi_req, st.st_size)) goto end; // skip body on HEAD if (uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "HEAD", 4)) { size_t remains = st.st_size; while(remains > 0) { char buf[8192]; ssize_t rlen = glfs_read (fd, buf, UMIN(remains, 8192), 0); if (rlen <= 0) goto end; if (uwsgi_response_write_body_do(wsgi_req, buf, rlen)) goto end; remains -= rlen; } } end: glfs_close(fd); return UWSGI_OK; }
int glfs_java_close (glfs_fd_t *glfd) { return glfs_close (glfd); }
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; }
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); }
static int qemu_gluster_open(BlockDriverState *bs, QDict *options, int bdrv_flags) { BDRVGlusterState *s = bs->opaque; int open_flags = O_BINARY; int ret = 0; GlusterConf *gconf = g_malloc0(sizeof(GlusterConf)); QemuOpts *opts; Error *local_err = NULL; const char *filename; opts = qemu_opts_create_nofail(&runtime_opts); qemu_opts_absorb_qdict(opts, options, &local_err); if (error_is_set(&local_err)) { qerror_report_err(local_err); error_free(local_err); ret = -EINVAL; goto out; } filename = qemu_opt_get(opts, "filename"); s->glfs = qemu_gluster_init(gconf, filename); if (!s->glfs) { ret = -errno; goto out; } if (bdrv_flags & BDRV_O_RDWR) { open_flags |= O_RDWR; } else { open_flags |= O_RDONLY; } if ((bdrv_flags & BDRV_O_NOCACHE)) { open_flags |= O_DIRECT; } s->fd = glfs_open(s->glfs, gconf->image, open_flags); if (!s->fd) { ret = -errno; goto out; } ret = qemu_pipe(s->fds); if (ret < 0) { ret = -errno; goto out; } fcntl(s->fds[GLUSTER_FD_READ], F_SETFL, O_NONBLOCK); qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], qemu_gluster_aio_event_reader, NULL, s); out: qemu_opts_del(opts); qemu_gluster_gconf_free(gconf); if (!ret) { return ret; } if (s->fd) { glfs_close(s->fd); } if (s->glfs) { glfs_fini(s->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[]) { int ret = 1; int opcode = -1; off_t offset = 0; size_t len = 0; glfs_t *fs = NULL; glfs_fd_t *fd = NULL; if (argc != 8) { fprintf(stderr, "Syntax: %s <host> <volname> <opcode> <offset> <len> " "<file-path> <log-file>\n", argv[0]); return 1; } fs = glfs_new(argv[2]); if (!fs) { fprintf(stderr, "glfs_new: returned NULL\n"); return 1; } ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); if (ret != 0) { fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); goto out; } ret = glfs_set_logging(fs, argv[7], 7); if (ret != 0) { fprintf(stderr, "glfs_set_logging: returned %d\n", ret); goto out; } ret = glfs_init(fs); if (ret != 0) { fprintf(stderr, "glfs_init: returned %d\n", ret); goto out; } opcode = atoi(argv[3]); opcode = get_fallocate_flag(opcode); if (opcode < 0) { fprintf(stderr, "get_fallocate_flag: invalid flag \n"); goto out; } offset = atoi(argv[4]); len = atoi(argv[5]); fd = glfs_open(fs, argv[6], O_RDWR); if (fd == NULL) { fprintf(stderr, "glfs_open: returned NULL\n"); goto out; } ret = glfs_fallocate(fd, opcode, offset, len); if (ret <= 0) { fprintf(stderr, "glfs_fallocate: returned %d\n", ret); goto out; } ret = 0; out: if (fd) glfs_close(fd); glfs_fini(fs); 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[]) { 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; }